use colortype instead of config

src/core/SkBlitter.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 "SkBlitter.h"
@@ skipping 794 matching lines @@
 /** By analyzing the paint (with an xfermode), we may decide we can take
     special action. This enum lists our possible actions
  */
 enum XferInterp {
     kNormal_XferInterp,         // no special interpretation, draw normally
     kSrcOver_XferInterp,        // draw as if in srcover mode
     kSkipDrawing_XferInterp     // draw nothing
 };
 
 static XferInterp interpret_xfermode(const SkPaint& paint, SkXfermode* xfer,
-                                     SkBitmap::Config deviceConfig) {
+                                     SkColorType deviceCT) {
     SkXfermode::Mode  mode;
 
     if (SkXfermode::AsMode(xfer, &mode)) {
         switch (mode) {
             case SkXfermode::kSrc_Mode:
                 if (just_solid_color(paint)) {
                     return kSrcOver_XferInterp;
                 }
                 break;
             case SkXfermode::kDst_Mode:
                 return kSkipDrawing_XferInterp;
             case SkXfermode::kSrcOver_Mode:
                 return kSrcOver_XferInterp;
             case SkXfermode::kDstOver_Mode:
-                if (SkBitmap::kRGB_565_Config == deviceConfig) {
+                if (kRGB_565_SkColorType == deviceCT) {
                     return kSkipDrawing_XferInterp;
                 }
                 break;
             case SkXfermode::kSrcIn_Mode:
-                if (SkBitmap::kRGB_565_Config == deviceConfig &&
+                if (kRGB_565_SkColorType == deviceCT &&
                     just_solid_color(paint)) {
                     return kSrcOver_XferInterp;
                 }
                 break;
             case SkXfermode::kDstIn_Mode:
                 if (just_solid_color(paint)) {
                     return kSkipDrawing_XferInterp;
                 }
                 break;
             default:
                 break;
         }
     }
     return kNormal_XferInterp;
 }
 
 SkBlitter* SkBlitter::Choose(const SkBitmap& device,
                              const SkMatrix& matrix,
                              const SkPaint& origPaint,
                              void* storage, size_t storageSize,
                              bool drawCoverage) {
     SkASSERT(storageSize == 0 || storage != NULL);
 
     SkBlitter*  blitter = NULL;
 
     // which check, in case we're being called by a client with a dummy device
     // (e.g. they have a bounder that always aborts the draw)
-    if (SkBitmap::kNo_Config == device.config() ||
-            (drawCoverage && (SkBitmap::kA8_Config != device.config()))) {
+    if (kUnknown_SkColorType == device.colorType() ||
+            (drawCoverage && (kAlpha_8_SkColorType != device.colorType()))) {
         SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
         return blitter;
     }
 
     SkShader* shader = origPaint.getShader();
     SkColorFilter* cf = origPaint.getColorFilter();
     SkXfermode* mode = origPaint.getXfermode();
     Sk3DShader* shader3D = NULL;
 
     SkTCopyOnFirstWrite<SkPaint> paint(origPaint);
 
     if (origPaint.getMaskFilter() != NULL &&
             origPaint.getMaskFilter()->getFormat() == SkMask::k3D_Format) {
         shader3D = SkNEW_ARGS(Sk3DShader, (shader));
         // we know we haven't initialized lazyPaint yet, so just do it
         paint.writable()->setShader(shader3D)->unref();
         shader = shader3D;
     }
 
     if (NULL != mode) {
-        switch (interpret_xfermode(*paint, mode, device.config())) {
+        switch (interpret_xfermode(*paint, mode, device.colorType())) {
             case kSrcOver_XferInterp:
                 mode = NULL;
                 paint.writable()->setXfermode(NULL);
                 break;
             case kSkipDrawing_XferInterp:
                 SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
                 return blitter;
             default:
                 break;
         }
@@ skipping 42 matching lines @@
      *  We make the first call here, in case it fails we can abort the draw.
      *  The endContext() call is made by the blitter (assuming setContext did
      *  not fail) in its destructor.
      */
     if (shader && !shader->setContext(device, *paint, matrix)) {
         SK_PLACEMENT_NEW(blitter, SkNullBlitter, storage, storageSize);
         return blitter;
     }
 
 
-    switch (device.config()) {
-        case SkBitmap::kA8_Config:
+    switch (device.colorType()) {
+        case kAlpha_8_SkColorType:
             if (drawCoverage) {
                 SkASSERT(NULL == shader);
                 SkASSERT(NULL == paint->getXfermode());
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Coverage_Blitter,
                                       storage, storageSize, (device, *paint));
             } else if (shader) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Shader_Blitter,
                                       storage, storageSize, (device, *paint));
             } else {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkA8_Blitter,
                                       storage, storageSize, (device, *paint));
             }
             break;
 
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             blitter = SkBlitter_ChooseD565(device, *paint, storage, storageSize);
             break;
 
-        case SkBitmap::kARGB_8888_Config:
+        case kPMColor_SkColorType:
             if (shader) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Shader_Blitter,
                                       storage, storageSize, (device, *paint));
             } else if (paint->getColor() == SK_ColorBLACK) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Black_Blitter,
                                       storage, storageSize, (device, *paint));
             } else if (paint->getAlpha() == 0xFF) {
                 SK_PLACEMENT_NEW_ARGS(blitter, SkARGB32_Opaque_Blitter,
                                       storage, storageSize, (device, *paint));
             } else {
@@ skipping 33 matching lines @@
 
     fShader->ref();
     fShaderFlags = fShader->getFlags();
 }
 
 SkShaderBlitter::~SkShaderBlitter() {
     SkASSERT(fShader->setContextHasBeenCalled());
     fShader->endContext();
     fShader->unref();
 }