Style bikeshed - remove extraneous whitespace

src/utils/SkTextureCompressor_Blitter.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTextureCompressor_Blitter_DEFINED
 #define SkTextureCompressor_Blitter_DEFINED
 
@@ skipping 37 matching lines @@
 //
 //     // The function used to compress an A8 block. The layout of the
 //     // block is also expected to be in row-major order.
 //     static void CompressA8Horizontal(uint8_t* dst, const uint8_t* src, int srcRowBytes);
 //
 #if PEDANTIC_BLIT_RECT
 //     // The function used to update an already compressed block. This will
 //     // most likely be implementation dependent. The mask variable will have
 //     // 0xFF in positions where the block should be updated and 0 in positions
 //     // where it shouldn't. src contains an uncompressed buffer of pixels.
-//     static void UpdateBlock(uint8_t* dst, const uint8_t* src, int srcRowBytes, 
+//     static void UpdateBlock(uint8_t* dst, const uint8_t* src, int srcRowBytes,
 //                             const uint8_t* mask);
 #endif
 // };
 template<int BlockDim, int EncodedBlockSize, typename CompressorType>
 class SkTCompressedAlphaBlitter : public SkBlitter {
 public:
     SkTCompressedAlphaBlitter(int width, int height, void *compressedBuffer)
         // 0x7FFE is one minus the largest positive 16-bit int. We use it for
         // debugging to make sure that we're properly setting the nextX distance
-        // in flushRuns(). 
+        // in flushRuns().
 #ifdef SK_DEBUG
         : fCalledOnceWithNonzeroY(false)
         , fBlitMaskCalled(false),
 #else
         :
 #endif
         kLongestRun(0x7FFE), kZeroAlpha(0)
         , fNextRun(0)
         , fWidth(width)
         , fHeight(height)
@@ skipping 53 matching lines @@
         fBufferedRuns[fNextRun].fRuns = runs;
         fBufferedRuns[fNextRun].fX = x;
         fBufferedRuns[fNextRun].fY = y;
 
         // If we've output a block of scanlines in a row that don't violate our
         // assumptions, then it's time to flush them...
         if (BlockDim == ++fNextRun) {
             this->flushRuns();
         }
     }
-    
+
     // Blit a vertical run of pixels with a constant alpha value.
     void blitV(int x, int y, int height, SkAlpha alpha) override {
         // This function is currently not implemented. It is not explicitly
         // required by the contract, but if at some time a code path runs into
         // this function (which is entirely possible), it needs to be implemented.
         //
         // TODO (krajcevski):
         // This function will be most easily implemented in one of two ways:
         // 1. Buffer each vertical column value and then construct a list
         //    of alpha values and output all of the blocks at once. This only
@@ skipping 11 matching lines @@
     bool fCalledOnceWithNonzeroY;
 #endif
     void blitRect(int x, int y, int width, int height) override {
 
         // Assumptions:
         SkASSERT(0 == x);
         SkASSERT(width <= fWidth);
 
         // Make sure that we're only ever bracketing calls to blitAntiH.
         SkASSERT((0 == y) || (!fCalledOnceWithNonzeroY && (fCalledOnceWithNonzeroY = true)));
-        
+
 #if !(PEDANTIC_BLIT_RECT)
         for (int i = 0; i < height; ++i) {
             const SkAlpha kFullAlpha = 0xFF;
             this->blitAntiH(x, y+i, &kFullAlpha, &kLongestRun);
         }
 #else
         const int startBlockX = (x / BlockDim) * BlockDim;
         const int startBlockY = (y / BlockDim) * BlockDim;
 
         const int endBlockX = ((x + width) / BlockDim) * BlockDim;
         const int endBlockY = ((y + height) / BlockDim) * BlockDim;
 
         // If start and end are the same, then we only need to update a single block...
         if (startBlockY == endBlockY && startBlockX == endBlockX) {
             uint8_t mask[BlockDim*BlockDim];
             memset(mask, 0, sizeof(mask));
 
             const int xoff = x - startBlockX;
             SkASSERT((xoff + width) <= BlockDim);
 
             const int yoff = y - startBlockY;
             SkASSERT((yoff + height) <= BlockDim);
-            
+
             for (int j = 0; j < height; ++j) {
                 memset(mask + (j + yoff)*BlockDim + xoff, 0xFF, width);
             }
 
             uint8_t* dst = this->getBlock(startBlockX, startBlockY);
             CompressorType::UpdateBlock(dst, mask, BlockDim, mask);
 
         // If start and end are the same in the y dimension, then we can freely update an
         // entire row of blocks...
         } else if (startBlockY == endBlockY) {
@@ skipping 278 matching lines @@
         //      c1 c2 c3 c4
         // -----------------------------------------------------------------------
         // ... |  |  |  |  |  ----> fBufferedRuns[0]
         // -----------------------------------------------------------------------
         // ... |  |  |  |  |  ----> fBufferedRuns[1]
         // -----------------------------------------------------------------------
         // ... |  |  |  |  |  ----> fBufferedRuns[2]
         // -----------------------------------------------------------------------
         // ... |  |  |  |  |  ----> fBufferedRuns[3]
         // -----------------------------------------------------------------------
-        // 
+        //
         // curX -- the macro X value that we've gotten to.
         // c[BlockDim] -- the buffers that represent the columns of the current block
         //                  that we're operating on
         // curAlphaColumn -- buffer containing the column of alpha values from fBufferedRuns.
         // nextX -- for each run, the next point at which we need to update curAlphaColumn
         //          after the value of curX.
         // finalX -- the minimum of all the nextX values.
         //
         // curX advances to finalX outputting any blocks that it passes along
         // the way. Since finalX will not change when we reach the end of a
@@ skipping 217 matching lines @@
                                         mask, BlockDim, mask);
         }
     }
 #endif  // PEDANTIC_BLIT_RECT
 
 };
 
 }  // namespace SkTextureCompressor
 
 #endif  // SkTextureCompressor_Blitter_DEFINED