Style bikeshed - remove extraneous whitespace

src/core/SkPixmap.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 #include "SkConfig8888.h"
 #include "SkData.h"
@@ skipping 40 matching lines @@
     this->reset();
     return false;
 }
 
 bool SkPixmap::extractSubset(SkPixmap* result, const SkIRect& subset) const {
     SkIRect srcRect, r;
     srcRect.set(0, 0, this->width(), this->height());
     if (!r.intersect(srcRect, subset)) {
         return false;   // r is empty (i.e. no intersection)
     }
-    
+
     // If the upper left of the rectangle was outside the bounds of this SkBitmap, we should have
     // exited above.
     SkASSERT(static_cast<unsigned>(r.fLeft) < static_cast<unsigned>(this->width()));
     SkASSERT(static_cast<unsigned>(r.fTop) < static_cast<unsigned>(this->height()));
 
     const void* pixels = nullptr;
     if (fPixels) {
         const size_t bpp = fInfo.bytesPerPixel();
         pixels = (const uint8_t*)fPixels + r.fTop * fRowBytes + r.fLeft * bpp;
     }
     result->reset(fInfo.makeWH(r.width(), r.height()), pixels, fRowBytes, fCTable);
     return true;
 }
 
 bool SkPixmap::readPixels(const SkImageInfo& requestedDstInfo, void* dstPixels, size_t dstRB,
                           int x, int y) const {
     if (kUnknown_SkColorType == requestedDstInfo.colorType()) {
         return false;
     }
     if (nullptr == dstPixels || dstRB < requestedDstInfo.minRowBytes()) {
         return false;
     }
     if (0 == requestedDstInfo.width() || 0 == requestedDstInfo.height()) {
         return false;
     }
-    
+
     SkIRect srcR = SkIRect::MakeXYWH(x, y, requestedDstInfo.width(), requestedDstInfo.height());
     if (!srcR.intersect(0, 0, this->width(), this->height())) {
         return false;
     }
-    
+
     // the intersect may have shrunk info's logical size
     const SkImageInfo dstInfo = requestedDstInfo.makeWH(srcR.width(), srcR.height());
-    
+
     // if x or y are negative, then we have to adjust pixels
     if (x > 0) {
         x = 0;
     }
     if (y > 0) {
         y = 0;
     }
     // here x,y are either 0 or negative
     dstPixels = ((char*)dstPixels - y * dstRB - x * dstInfo.bytesPerPixel());
 
@@ skipping 21 matching lines @@
     }
 
     U8CPU a = SkColorGetA(color);
     U8CPU r = SkColorGetR(color);
     U8CPU g = SkColorGetG(color);
     U8CPU b = SkColorGetB(color);
 
     int height = area.height();
     const int width = area.width();
     const int rowBytes = this->rowBytes();
-    
+
     switch (this->colorType()) {
         case kGray_8_SkColorType: {
             if (255 != a) {
                 r = SkMulDiv255Round(r, a);
                 g = SkMulDiv255Round(g, a);
                 b = SkMulDiv255Round(b, a);
             }
             int gray = SkComputeLuminance(r, g, b);
             uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
             while (--height >= 0) {
                 memset(p, gray, width);
                 p += rowBytes;
             }
             break;
         }
         case kAlpha_8_SkColorType: {
             uint8_t* p = this->writable_addr8(area.fLeft, area.fTop);
             while (--height >= 0) {
                 memset(p, a, width);
                 p += rowBytes;
             }
             break;
         }
         case kARGB_4444_SkColorType:
         case kRGB_565_SkColorType: {
             uint16_t* p = this->writable_addr16(area.fLeft, area.fTop);
             uint16_t v;
-            
+
             // make rgb premultiplied
             if (255 != a) {
                 r = SkMulDiv255Round(r, a);
                 g = SkMulDiv255Round(g, a);
                 b = SkMulDiv255Round(b, a);
             }
-            
+
             if (kARGB_4444_SkColorType == this->colorType()) {
                 v = pack_8888_to_4444(a, r, g, b);
             } else {
                 v = SkPackRGB16(r >> (8 - SK_R16_BITS),
                                 g >> (8 - SK_G16_BITS),
                                 b >> (8 - SK_B16_BITS));
             }
             while (--height >= 0) {
                 sk_memset16(p, v, width);
                 p = (uint16_t*)((char*)p + rowBytes);
             }
             break;
         }
         case kBGRA_8888_SkColorType:
         case kRGBA_8888_SkColorType: {
             uint32_t* p = this->writable_addr32(area.fLeft, area.fTop);
-            
+
             if (255 != a && kPremul_SkAlphaType == this->alphaType()) {
                 r = SkMulDiv255Round(r, a);
                 g = SkMulDiv255Round(g, a);
                 b = SkMulDiv255Round(b, a);
             }
             uint32_t v = kRGBA_8888_SkColorType == this->colorType()
                              ? SkPackARGB_as_RGBA(a, r, g, b)
                              : SkPackARGB_as_BGRA(a, r, g, b);
 
             while (--height >= 0) {
@@ skipping 66 matching lines @@
 
     SkPaint paint;
     paint.setFilterQuality(quality);
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     surface->getCanvas()->drawBitmapRect(bitmap, SkRect::MakeIWH(dst.width(), dst.height()),
                                          &paint);
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////////////
-