Whitespace fix: remove whitespace from the end of lines.

src/core/SkBitmapProcState.cpp

 #include "SkBitmapProcState.h"
 #include "SkColorPriv.h"
 #include "SkFilterProc.h"
 #include "SkPaint.h"
 #include "SkShader.h"   // for tilemodes
 
 #ifdef SK_CPU_BENDIAN
     #define UNPACK_PRIMARY_SHORT(packed)    ((uint32_t)(packed) >> 16)
     #define UNPACK_SECONDARY_SHORT(packed)  ((packed) & 0xFFFF)
 #else
     #define UNPACK_PRIMARY_SHORT(packed)    ((packed) & 0xFFFF)
     #define UNPACK_SECONDARY_SHORT(packed)  ((uint32_t)(packed) >> 16)
 #endif
 
 static inline SkPMColor Filter_32(unsigned x, unsigned y,
                                   SkPMColor a00, SkPMColor a01,
                                   SkPMColor a10, SkPMColor a11) {
     SkASSERT((unsigned)x <= 0xF);
     SkASSERT((unsigned)y <= 0xF);
-    
+
     int xy = x * y;
     uint32_t mask = gMask_00FF00FF; //0xFF00FF;
-    
+
     int scale = 256 - 16*y - 16*x + xy;
     uint32_t lo = (a00 & mask) * scale;
     uint32_t hi = ((a00 >> 8) & mask) * scale;
-    
+
     scale = 16*x - xy;
     lo += (a01 & mask) * scale;
     hi += ((a01 >> 8) & mask) * scale;
-    
+
     scale = 16*y - xy;
     lo += (a10 & mask) * scale;
     hi += ((a10 >> 8) & mask) * scale;
-    
+
     lo += (a11 & mask) * xy;
     hi += ((a11 >> 8) & mask) * xy;
-    
+
     return ((lo >> 8) & mask) | (hi & ~mask);
 }
 
 // returns expanded * 5bits
 static inline uint32_t Filter_565_Expanded(unsigned x, unsigned y,
                                            uint32_t a00, uint32_t a01,
                                            uint32_t a10, uint32_t a11) {
     SkASSERT((unsigned)x <= 0xF);
     SkASSERT((unsigned)y <= 0xF);
-    
+
     a00 = SkExpand_rgb_16(a00);
     a01 = SkExpand_rgb_16(a01);
     a10 = SkExpand_rgb_16(a10);
     a11 = SkExpand_rgb_16(a11);
-    
+
     int xy = x * y >> 3;
     return  a00 * (32 - 2*y - 2*x + xy) +
             a01 * (2*x - xy) +
             a10 * (2*y - xy) +
             a11 * xy;
 }
 
 // turn an expanded 565 * 5bits into SkPMColor
 // g:11 | r:10 | x:1 | b:10
 static inline SkPMColor SkExpanded_565_To_PMColor(uint32_t c) {
     unsigned r = (c >> 13) & 0xFF;
     unsigned g = (c >> 24);
     unsigned b = (c >> 2) & 0xFF;
     return SkPackARGB32(0xFF, r, g, b);
 }
 
 // returns answer in SkPMColor format
 static inline SkPMColor Filter_4444_D32(unsigned x, unsigned y,
                                         uint32_t a00, uint32_t a01,
                                         uint32_t a10, uint32_t a11) {
     SkASSERT((unsigned)x <= 0xF);
     SkASSERT((unsigned)y <= 0xF);
-    
+
     a00 = SkExpand_4444(a00);
     a01 = SkExpand_4444(a01);
     a10 = SkExpand_4444(a10);
     a11 = SkExpand_4444(a11);
 
     int xy = x * y >> 4;
     uint32_t result =   a00 * (16 - y - x + xy) +
                         a01 * (x - xy) +
                         a10 * (y - xy) +
                         a11 * xy;
 
     return SkCompact_8888(result);
 }
 
 static inline U8CPU Filter_8(unsigned x, unsigned y,
                              U8CPU a00, U8CPU a01,
                              U8CPU a10, U8CPU a11) {
     SkASSERT((unsigned)x <= 0xF);
     SkASSERT((unsigned)y <= 0xF);
-    
+
     int xy = x * y;
     unsigned result =   a00 * (256 - 16*y - 16*x + xy) +
                         a01 * (16*x - xy) +
                         a10 * (16*y - xy) +
                         a11 * xy;
-    
+
     return result >> 8;
 }
 
 /*****************************************************************************
  *
  *  D32 functions
  *
  */
 
 // SRC == 8888
@@ skipping 221 matching lines @@
     if (SkShader::kClamp_TileMode == fTileModeX &&
             SkShader::kClamp_TileMode == fTileModeY) {
         m = &inv;
         clamp_clamp = true;
     } else {
         fUnitInvMatrix = inv;
         fUnitInvMatrix.postIDiv(fOrigBitmap.width(), fOrigBitmap.height());
         m = &fUnitInvMatrix;
         clamp_clamp = false;
     }
-    
+
     fBitmap = &fOrigBitmap;
     if (fOrigBitmap.hasMipMap()) {
         int shift = fOrigBitmap.extractMipLevel(&fMipBitmap,
                                                 SkScalarToFixed(m->getScaleX()),
                                                 SkScalarToFixed(m->getSkewY()));
-        
+
         if (shift > 0) {
             if (m != &fUnitInvMatrix) {
                 fUnitInvMatrix = *m;
                 m = &fUnitInvMatrix;
             }
 
             SkScalar scale = SkFixedToScalar(SK_Fixed1 >> shift);
             fUnitInvMatrix.postScale(scale, scale);
-            
+
             // now point here instead of fOrigBitmap
             fBitmap = &fMipBitmap;
         }
     }
 
     fInvMatrix      = m;
     fInvProc        = m->getMapXYProc();
     fInvType        = m->getType();
     fInvSx          = SkScalarToFixed(m->getScaleX());
     fInvSy          = SkScalarToFixed(m->getScaleY());
@@ skipping 14 matching lines @@
     fShaderProc16 = NULL;
     fSampleProc32 = NULL;
     fSampleProc16 = NULL;
 
     fMatrixProc = this->chooseMatrixProc();
     if (NULL == fMatrixProc) {
         return false;
     }
 
     ///////////////////////////////////////////////////////////////////////
-    
+
     int index = 0;
     if (fAlphaScale < 256) {  // note: this distinction is not used for D16
         index |= 1;
     }
     if (fInvType <= (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask)) {
         index |= 2;
     }
     if (fDoFilter) {
         index |= 4;
     }
@@ skipping 21 matching lines @@
 
     static const SampleProc32 gSample32[] = {
         S32_opaque_D32_nofilter_DXDY,
         S32_alpha_D32_nofilter_DXDY,
         S32_opaque_D32_nofilter_DX,
         S32_alpha_D32_nofilter_DX,
         S32_opaque_D32_filter_DXDY,
         S32_alpha_D32_filter_DXDY,
         S32_opaque_D32_filter_DX,
         S32_alpha_D32_filter_DX,
-        
+
         S16_opaque_D32_nofilter_DXDY,
         S16_alpha_D32_nofilter_DXDY,
         S16_opaque_D32_nofilter_DX,
         S16_alpha_D32_nofilter_DX,
         S16_opaque_D32_filter_DXDY,
         S16_alpha_D32_filter_DXDY,
         S16_opaque_D32_filter_DX,
         S16_alpha_D32_filter_DX,
-        
+
         SI8_opaque_D32_nofilter_DXDY,
         SI8_alpha_D32_nofilter_DXDY,
         SI8_opaque_D32_nofilter_DX,
         SI8_alpha_D32_nofilter_DX,
         SI8_opaque_D32_filter_DXDY,
         SI8_alpha_D32_filter_DXDY,
         SI8_opaque_D32_filter_DX,
         SI8_alpha_D32_filter_DX,
-        
+
         S4444_opaque_D32_nofilter_DXDY,
         S4444_alpha_D32_nofilter_DXDY,
         S4444_opaque_D32_nofilter_DX,
         S4444_alpha_D32_nofilter_DX,
         S4444_opaque_D32_filter_DXDY,
         S4444_alpha_D32_filter_DXDY,
         S4444_opaque_D32_filter_DX,
         S4444_alpha_D32_filter_DX,
-        
+
         // A8 treats alpha/opauqe the same (equally efficient)
         SA8_alpha_D32_nofilter_DXDY,
         SA8_alpha_D32_nofilter_DXDY,
         SA8_alpha_D32_nofilter_DX,
         SA8_alpha_D32_nofilter_DX,
         SA8_alpha_D32_filter_DXDY,
         SA8_alpha_D32_filter_DXDY,
         SA8_alpha_D32_filter_DX,
         SA8_alpha_D32_filter_DX
     };
-    
+
     static const SampleProc16 gSample16[] = {
         S32_D16_nofilter_DXDY,
         S32_D16_nofilter_DX,
         S32_D16_filter_DXDY,
         S32_D16_filter_DX,
-        
+
         S16_D16_nofilter_DXDY,
         S16_D16_nofilter_DX,
         S16_D16_filter_DXDY,
         S16_D16_filter_DX,
-        
+
         SI8_D16_nofilter_DXDY,
         SI8_D16_nofilter_DX,
         SI8_D16_filter_DXDY,
         SI8_D16_filter_DX,
-        
+
         // Don't support 4444 -> 565
         NULL, NULL, NULL, NULL,
         // Don't support A8 -> 565
         NULL, NULL, NULL, NULL
     };
 
     fSampleProc32 = gSample32[index];
     index >>= 1;    // shift away any opaque/alpha distinction
     fSampleProc16 = gSample16[index];
 
     // our special-case shaderprocs
     if (S16_D16_filter_DX == fSampleProc16) {
         if (clamp_clamp) {
             fShaderProc16 = Clamp_S16_D16_filter_DX_shaderproc;
         } else if (SkShader::kRepeat_TileMode == fTileModeX &&
                    SkShader::kRepeat_TileMode == fTileModeY) {
             fShaderProc16 = Repeat_S16_D16_filter_DX_shaderproc;
         }
     }
     return true;
 }