Revert of De-proc Color32

src/core/SkBlitter_ARGB32.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCoreBlitters.h"
 #include "SkColorPriv.h"
 #include "SkShader.h"
@@ skipping 34 matching lines @@
     SkColor color = paint.getColor();
     fColor = color;
 
     fSrcA = SkColorGetA(color);
     unsigned scale = SkAlpha255To256(fSrcA);
     fSrcR = SkAlphaMul(SkColorGetR(color), scale);
     fSrcG = SkAlphaMul(SkColorGetG(color), scale);
     fSrcB = SkAlphaMul(SkColorGetB(color), scale);
 
     fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
+    fColor32Proc = SkBlitRow::ColorProcFactory();
 }
 
 const SkBitmap* SkARGB32_Blitter::justAnOpaqueColor(uint32_t* value) {
     if (255 == fSrcA) {
         *value = fPMColor;
         return &fDevice;
     }
     return NULL;
 }
 
 #if defined _WIN32 && _MSC_VER >= 1300  // disable warning : local variable used without having been initialized
 #pragma warning ( push )
 #pragma warning ( disable : 4701 )
 #endif
 
 void SkARGB32_Blitter::blitH(int x, int y, int width) {
     SkASSERT(x >= 0 && y >= 0 && x + width <= fDevice.width());
 
     uint32_t*   device = fDevice.getAddr32(x, y);
-    SkBlitRow::Color32(device, device, width, fPMColor);
+    fColor32Proc(device, device, width, fPMColor);
 }
 
 void SkARGB32_Blitter::blitAntiH(int x, int y, const SkAlpha antialias[],
                                  const int16_t runs[]) {
     if (fSrcA == 0) {
         return;
     }
 
     uint32_t    color = fPMColor;
     uint32_t*   device = fDevice.getAddr32(x, y);
     unsigned    opaqueMask = fSrcA; // if fSrcA is 0xFF, then we will catch the fast opaque case
 
     for (;;) {
         int count = runs[0];
         SkASSERT(count >= 0);
         if (count <= 0) {
             return;
         }
         unsigned aa = antialias[0];
         if (aa) {
             if ((opaqueMask & aa) == 255) {
                 sk_memset32(device, color, count);
             } else {
                 uint32_t sc = SkAlphaMulQ(color, SkAlpha255To256(aa));
-                SkBlitRow::Color32(device, device, count, sc);
+                fColor32Proc(device, device, count, sc);
             }
         }
         runs += count;
         antialias += count;
         device += count;
     }
 }
 
 void SkARGB32_Blitter::blitAntiH2(int x, int y, U8CPU a0, U8CPU a1) {
     uint32_t* device = fDevice.getAddr32(x, y);
     SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
-
+    
     device[0] = SkBlendARGB32(fPMColor, device[0], a0);
     device[1] = SkBlendARGB32(fPMColor, device[1], a1);
 }
 
 void SkARGB32_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
     uint32_t* device = fDevice.getAddr32(x, y);
     SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
-
+    
     device[0] = SkBlendARGB32(fPMColor, device[0], a0);
     device = (uint32_t*)((char*)device + fDevice.rowBytes());
     device[0] = SkBlendARGB32(fPMColor, device[0], a1);
 }
 
 //////////////////////////////////////////////////////////////////////////////////////
 
 #define solid_8_pixels(mask, dst, color)    \
     do {                                    \
         if (mask & 0x80) dst[0] = color;    \
@@ skipping 110 matching lines @@
 
     if (fSrcA == 0) {
         return;
     }
 
     uint32_t*   device = fDevice.getAddr32(x, y);
     uint32_t    color = fPMColor;
     size_t      rowBytes = fDevice.rowBytes();
 
     while (--height >= 0) {
-        SkBlitRow::Color32(device, device, width, color);
+        fColor32Proc(device, device, width, color);
         device = (uint32_t*)((char*)device + rowBytes);
     }
 }
 
 #if defined _WIN32 && _MSC_VER >= 1300
 #pragma warning ( pop )
 #endif
 
 ///////////////////////////////////////////////////////////////////////
 
@@ skipping 32 matching lines @@
     uint32_t* device = fDevice.getAddr32(x, y);
     SkDEBUGCODE((void)fDevice.getAddr32(x + 1, y);)
 
     device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
     device[1] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[1], 256 - a1);
 }
 
 void SkARGB32_Black_Blitter::blitAntiV2(int x, int y, U8CPU a0, U8CPU a1) {
     uint32_t* device = fDevice.getAddr32(x, y);
     SkDEBUGCODE((void)fDevice.getAddr32(x, y + 1);)
-
+    
     device[0] = (a0 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a0);
     device = (uint32_t*)((char*)device + fDevice.rowBytes());
     device[0] = (a1 << SK_A32_SHIFT) + SkAlphaMulQ(device[0], 256 - a1);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Special version of SkBlitRow::Factory32 that knows we're in kSrc_Mode,
 // instead of kSrcOver_Mode
 static void blend_srcmode(SkPMColor* SK_RESTRICT device,
@@ skipping 362 matching lines @@
             SkBlitRow::Proc32 proc = (255 == alpha) ? fProc32 : fProc32Blend;
             do {
                 shaderContext->shadeSpan(x, y, span, 1);
                 proc(device, span, 1, alpha);
                 y += 1;
                 device = (uint32_t*)((char*)device + deviceRB);
             } while (--height > 0);
         }
     }
 }