Pass a struct of functions instead of a function to the compressed blitter

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
 
 #include "SkTypes.h"
 #include "SkBlitter.h"
 
 namespace SkTextureCompressor {
 
-// The function used to compress an A8 block. This function is expected to be
-// used as a template argument to SkCompressedAlphaBlitter. The layout of the
-// block is also expected to be in column-major order.
-typedef void (*CompressA8Proc)(uint8_t* dst, const uint8_t block[]);
-
 // This class implements a blitter that blits directly into a buffer that will
 // be used as an compressed alpha texture. We compute this buffer by
 // buffering scan lines and then outputting them all at once. The number of
 // scan lines buffered is controlled by kBlockSize
-template<int BlockDim, int EncodedBlockSize, CompressA8Proc CompressionProc>
+//
+// The CompressorType is a struct with a bunch of static methods that provides
+// the specialized compression functionality of the blitter. A complete CompressorType
+// will implement the following static functions;
+//
+// struct CompressorType {
+//     // The function used to compress an A8 block. The layout of the
+//     // block is also expected to be in column-major order.
+//     static void CompressA8Vertical(uint8_t* dst, const uint8_t block[]);
+//
+//     // 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 block[]);
+//
+//     // The function used to update an already compressed block. This will
+//     // most likely be implementation dependent.
+//     static void UpdateBlock(uint8_t* dst, const uint8_t* src);
+// };
+//
+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(). 
         : kLongestRun(0x7FFE), kZeroAlpha(0)
         , fNextRun(0)
         , fWidth(width)
         , fHeight(height)
@@ skipping 296 matching lines @@
 
             // Do we need to populate the rest of the block?
             if ((finalX - (BlockDim*(curX / BlockDim))) >= BlockDim) {
                 const int col = curX % BlockDim;
                 const int colsLeft = BlockDim - col;
                 SkASSERT(curX + colsLeft <= finalX);
 
                 this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
 
                 // Write this block
-                CompressionProc(outPtr, reinterpret_cast<uint8_t*>(block));
+                CompressorType::CompressA8Vertical(outPtr, reinterpret_cast<uint8_t*>(block));
                 outPtr += EncodedBlockSize;
                 curX += colsLeft;
             }
 
             // If we can advance even further, then just keep memsetting the block
             if ((finalX - curX) >= BlockDim) {
                 SkASSERT((curX % BlockDim) == 0);
 
                 const int col = 0;
                 const int colsLeft = BlockDim;
 
                 this->updateBlockColumns(block, col, colsLeft, curAlphaColumn);
 
                 // While we can keep advancing, just keep writing the block.
                 uint8_t lastBlock[EncodedBlockSize];
-                CompressionProc(lastBlock, reinterpret_cast<uint8_t*>(block));
+                CompressorType::CompressA8Vertical(lastBlock, reinterpret_cast<uint8_t*>(block));
                 while((finalX - curX) >= BlockDim) {
                     memcpy(outPtr, lastBlock, EncodedBlockSize);
                     outPtr += EncodedBlockSize;
                     curX += BlockDim;
                 }
             }
 
             // If we haven't advanced within the block then do so.
             if (curX < finalX) {
                 const int col = curX % BlockDim;
@@ skipping 17 matching lines @@
             }
 
             finalX = 0xFFFFF;
             for (int i = 0; i < BlockDim; ++i) {
                 finalX = SkMin32(nextX[i], finalX);
             }
         }
 
         // If we didn't land on a block boundary, output the block...
         if ((curX % BlockDim) > 1) {
-            CompressionProc(outPtr, reinterpret_cast<uint8_t*>(block));
+            CompressorType::CompressA8Vertical(outPtr, reinterpret_cast<uint8_t*>(block));
         }
 
         fNextRun = 0;
     }
 };
 
 }  // namespace SkTextureCompressor
 
 #endif  // SkTextureCompressor_Blitter_DEFINED