replace config() with colorType()

src/core/SkBlitMask_D32.cpp

 #include "SkBlitMask.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 
 static void D32_A8_Color(void* SK_RESTRICT dst, size_t dstRB,
                          const void* SK_RESTRICT maskPtr, size_t maskRB,
                          SkColor color, int width, int height) {
     SkPMColor pmc = SkPreMultiplyColor(color);
     size_t dstOffset = dstRB - (width << 2);
     size_t maskOffset = maskRB - width;
@@ skipping 212 matching lines @@
         return D32_A8_Opaque;
     } else {
         return D32_A8_Color;
     }
 }
 
 static SkBlitMask::ColorProc D32_LCD32_Factory(SkColor color) {
     return (0xFF == SkColorGetA(color)) ? D32_LCD32_Opaque : D32_LCD32_Blend;
 }
 
-SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkBitmap::Config config,
+SkBlitMask::ColorProc SkBlitMask::ColorFactory(SkColorType ct,
                                                SkMask::Format format,
                                                SkColor color) {
-    ColorProc proc = PlatformColorProcs(config, format, color);
+    ColorProc proc = PlatformColorProcs(ct, format, color);
     if (proc) {
         return proc;
     }
 
-    switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (ct) {
+        case kN32_SkColorType:
             switch (format) {
                 case SkMask::kA8_Format:
                     return D32_A8_Factory(color);
                 case SkMask::kLCD16_Format:
                     return D32_LCD16_Proc;
                 case SkMask::kLCD32_Format:
                     return D32_LCD32_Factory(color);
                 default:
                     break;
             }
             break;
         default:
             break;
     }
     return NULL;
 }
 
 bool SkBlitMask::BlitColor(const SkBitmap& device, const SkMask& mask,
                            const SkIRect& clip, SkColor color) {
-    ColorProc proc = ColorFactory(device.config(), mask.fFormat, color);
+    ColorProc proc = ColorFactory(device.colorType(), mask.fFormat, color);
     if (proc) {
         int x = clip.fLeft;
         int y = clip.fTop;
         proc(device.getAddr32(x, y), device.rowBytes(), mask.getAddr(x, y),
              mask.fRowBytes, color, clip.width(), clip.height());
         return true;
     }
     return false;
 }
 
@@ skipping 268 matching lines @@
 
         // LCD blitting is only supported if the dst is known/required
         // to be opaque
         dst[i] = SkPackARGB32(0xFF,
                               SkAlphaBlend(srcR, dstR, maskR),
                               SkAlphaBlend(srcG, dstG, maskG),
                               SkAlphaBlend(srcB, dstB, maskB));
     }
 }
 
-SkBlitMask::RowProc SkBlitMask::RowFactory(SkBitmap::Config config,
+SkBlitMask::RowProc SkBlitMask::RowFactory(SkColorType ct,
                                            SkMask::Format format,
                                            RowFlags flags) {
 // make this opt-in until chrome can rebaseline
-    RowProc proc = PlatformRowProcs(config, format, flags);
+    RowProc proc = PlatformRowProcs(ct, format, flags);
     if (proc) {
         return proc;
     }
 
     static const RowProc gProcs[] = {
         // need X coordinate to handle BW
         false ? (RowProc)BW_RowProc_Blend : NULL, // suppress unused warning
         false ? (RowProc)BW_RowProc_Opaque : NULL, // suppress unused warning
         (RowProc)A8_RowProc_Blend,      (RowProc)A8_RowProc_Opaque,
         (RowProc)LCD16_RowProc_Blend,   (RowProc)LCD16_RowProc_Opaque,
         (RowProc)LCD32_RowProc_Blend,   (RowProc)LCD32_RowProc_Opaque,
     };
 
     int index;
-    switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (ct) {
+        case kN32_SkColorType:
             switch (format) {
                 case SkMask::kBW_Format:    index = 0; break;
                 case SkMask::kA8_Format:    index = 2; break;
                 case SkMask::kLCD16_Format: index = 4; break;
                 case SkMask::kLCD32_Format: index = 6; break;
                 default:
                     return NULL;
             }
             if (flags & kSrcIsOpaque_RowFlag) {
                 index |= 1;
             }
             SkASSERT((size_t)index < SK_ARRAY_COUNT(gProcs));
             return gProcs[index];
         default:
             break;
     }
     return NULL;
 }