stop using SkBitmap::Config

R=scroggo@google.com

Author: reed@chromium.org

Review URL: https://codereview.chromium.org/338493005

diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 11a79dbe7dc3f6ef23015a921d80ea39ae65b8de..72b07379f259b8727bebb8487ac39ef06850aba1 100644 (file)
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -1376,7 +1376,7 @@ void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
     // the rest from the SkPaint.
     GrPaint grPaint;
     grPaint.addColorEffect(effect);
-    bool alphaOnly = !(SkBitmap::kA8_Config == bitmap.config());
+    bool alphaOnly = !(kAlpha_8_SkColorType == bitmap.colorType());
     GrColor grColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
                                     SkColor2GrColor(paint.getColor());
     SkPaint2GrPaintNoShader(this->context(), paint, grColor, false, &grPaint);

diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index c4720b58c85ade590aa0ad252e8b0f1da999cba2..34e5d0fde37a6533277afe2630426a25c74c6ffc 100644 (file)
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -32,7 +32,7 @@
  as the colortable.count says it is.
  */
 static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
-    SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
+    SkASSERT(kIndex_8_SkColorType == bitmap.colorType());
 
     SkAutoLockPixels alp(bitmap);
     if (!bitmap.readyToDraw()) {
@@ -203,7 +203,7 @@ static GrTexture* sk_gr_create_bitmap_texture(GrContext* ctx,
     GrTextureDesc desc;
     generate_bitmap_texture_desc(*bitmap, &desc);
 
-    if (SkBitmap::kIndex8_Config == bitmap->config()) {
+    if (kIndex_8_SkColorType == bitmap->colorType()) {
         // build_compressed_data doesn't do npot->pot expansion
         // and paletted textures can't be sub-updated
         if (ctx->supportsIndex8PixelConfig(params, bitmap->width(), bitmap->height())) {

diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp
index 3c6ff69982bf903f470079240c567b91a464e340..b12418750525f6d6dd9704752fd90873899c3247 100644 (file)
--- a/src/images/SkImageDecoder.cpp
+++ b/src/images/SkImageDecoder.cpp
@@ -209,7 +209,7 @@ bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
                                 int srcX, int srcY) {
     int w = width / sampleSize;
     int h = height / sampleSize;
-    if (src->config() == SkBitmap::kIndex8_Config) {
+    if (src->colorType() == kIndex_8_SkColorType) {
         // kIndex8 does not allow drawing via an SkCanvas, as is done below.
         // Instead, use extractSubset. Note that this shares the SkPixelRef and
         // SkColorTable.

diff --git a/src/images/SkImageDecoder_libgif.cpp b/src/images/SkImageDecoder_libgif.cpp
index 7b6a4741df8756ca68b7b9061d59aa8f1cc941b3..0c8461f893e5f3e938ac3e1c1fb371ae6bf000d9 100644 (file)
--- a/src/images/SkImageDecoder_libgif.cpp
+++ b/src/images/SkImageDecoder_libgif.cpp
@@ -192,7 +192,7 @@ static bool skip_src_rows(GifFileType* gif, uint8_t* dst, int width, int rowsToS
  *  fixes it.  This makes the output image consistantly deterministic.
  */
 static void sanitize_indexed_bitmap(SkBitmap* bm) {
-    if ((SkBitmap::kIndex8_Config == bm->config()) && !(bm->empty())) {
+    if ((kIndex_8_SkColorType == bm->colorType()) && !(bm->empty())) {
         SkAutoLockPixels alp(*bm);
         if (NULL != bm->getPixels()) {
             SkColorTable* ct = bm->getColorTable();  // Index8 must have it.

diff --git a/src/images/SkImageDecoder_libpng.cpp b/src/images/SkImageDecoder_libpng.cpp
index 9c911e29fcf2fc0692586006063c8828f05813c7..7ff15584c4fb3f592eb36077a8726047cf4404af 100644 (file)
--- a/src/images/SkImageDecoder_libpng.cpp
+++ b/src/images/SkImageDecoder_libpng.cpp
@@ -100,8 +100,8 @@ private:
     bool decodePalette(png_structp png_ptr, png_infop info_ptr,
                        bool * SK_RESTRICT hasAlphap, bool *reallyHasAlphap,
                        SkColorTable **colorTablep);
-    bool getBitmapConfig(png_structp, png_infop, SkColorType*, bool* hasAlpha,
-                         SkPMColor* theTranspColor);
+    bool getBitmapColorType(png_structp, png_infop, SkColorType*, bool* hasAlpha,
+                            SkPMColor* theTranspColor);
 
     typedef SkImageDecoder INHERITED;
 };
@@ -166,7 +166,7 @@ static bool pos_le(int value, int max) {
 }
 
 static bool substituteTranspColor(SkBitmap* bm, SkPMColor match) {
-    SkASSERT(bm->config() == SkBitmap::kARGB_8888_Config);
+    SkASSERT(bm->colorType() == kN32_SkColorType);
 
     bool reallyHasAlpha = false;
 
@@ -321,7 +321,7 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap,
     bool                hasAlpha = false;
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
 
-    if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
+    if (!this->getBitmapColorType(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
         return false;
     }
 
@@ -462,14 +462,14 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap,
         reallyHasAlpha |= substituteTranspColor(decodedBitmap, theTranspColor);
     }
     if (reallyHasAlpha && this->getRequireUnpremultipliedColors()) {
-        switch (decodedBitmap->config()) {
-            case SkBitmap::kIndex8_Config:
+        switch (decodedBitmap->colorType()) {
+            case kIndex_8_SkColorType:
                 // Fall through.
-            case SkBitmap::kARGB_4444_Config:
-                // We have chosen not to support unpremul for these configs.
+            case kARGB_4444_SkColorType:
+                // We have chosen not to support unpremul for these colortypes.
                 return false;
             default: {
-                // Fall through to finish the decode. This config either
+                // Fall through to finish the decode. This colortype either
                 // supports unpremul or it is irrelevant because it has no
                 // alpha (or only alpha).
                 // These brackets prevent a warning.
@@ -485,10 +485,10 @@ bool SkPNGImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* decodedBitmap,
 
 
 
-bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
-                                        SkColorType* colorTypep,
-                                        bool* hasAlphap,
-                                        SkPMColor* SK_RESTRICT theTranspColorp) {
+bool SkPNGImageDecoder::getBitmapColorType(png_structp png_ptr, png_infop info_ptr,
+                                           SkColorType* colorTypep,
+                                           bool* hasAlphap,
+                                           SkPMColor* SK_RESTRICT theTranspColorp) {
     png_uint_32 origWidth, origHeight;
     int bitDepth, colorType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
@@ -513,7 +513,7 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
     if (colorType == PNG_COLOR_TYPE_PALETTE) {
         bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
         *colorTypep = this->getPrefColorType(kIndex_SrcDepth, paletteHasAlpha);
-        // now see if we can upscale to their requested config
+        // now see if we can upscale to their requested colortype
         if (!canUpscalePaletteToConfig(*colorTypep, paletteHasAlpha)) {
             *colorTypep = kIndex_8_SkColorType;
         }
@@ -614,7 +614,7 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
 #endif
 
     // If the image has alpha and the decoder wants unpremultiplied
-    // colors, the only supported config is 8888.
+    // colors, the only supported colortype is 8888.
     if (this->getRequireUnpremultipliedColors() && *hasAlphap) {
         *colorTypep = kN32_SkColorType;
     }
@@ -622,7 +622,7 @@ bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
     if (fImageIndex != NULL) {
         if (kUnknown_SkColorType == fImageIndex->fColorType) {
             // This is the first time for this subset decode. From now on,
-            // all decodes must be in the same config.
+            // all decodes must be in the same colortype.
             fImageIndex->fColorType = *colorTypep;
         } else if (fImageIndex->fColorType != *colorTypep) {
             // Requesting a different colortype for a subsequent decode is not
@@ -685,7 +685,7 @@ bool SkPNGImageDecoder::decodePalette(png_structp png_ptr, png_infop info_ptr,
     int transLessThanFF = 0;
 
     // Choose which function to use to create the color table. If the final destination's
-    // config is unpremultiplied, the color table will store unpremultiplied colors.
+    // colortype is unpremultiplied, the color table will store unpremultiplied colors.
     PackColorProc proc;
     if (this->getRequireUnpremultipliedColors()) {
         proc = &SkPackARGB32NoCheck;
@@ -785,7 +785,7 @@ bool SkPNGImageDecoder::onDecodeSubset(SkBitmap* bm, const SkIRect& region) {
     bool                hasAlpha = false;
     SkPMColor           theTranspColor = 0; // 0 tells us not to try to match
 
-    if (!this->getBitmapConfig(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
+    if (!this->getBitmapColorType(png_ptr, info_ptr, &colorType, &hasAlpha, &theTranspColor)) {
         return false;
     }
 
@@ -998,29 +998,28 @@ static void sk_write_fn(png_structp png_ptr, png_bytep data, png_size_t len) {
     }
 }
 
-static transform_scanline_proc choose_proc(SkBitmap::Config config,
-                                           bool hasAlpha) {
+static transform_scanline_proc choose_proc(SkColorType ct, bool hasAlpha) {
     // we don't care about search on alpha if we're kIndex8, since only the
     // colortable packing cares about that distinction, not the pixels
-    if (SkBitmap::kIndex8_Config == config) {
+    if (kIndex_8_SkColorType == ct) {
         hasAlpha = false;   // we store false in the table entries for kIndex8
     }
 
     static const struct {
-        SkBitmap::Config        fConfig;
+        SkColorType             fColorType;
         bool                    fHasAlpha;
         transform_scanline_proc fProc;
     } gMap[] = {
-        { SkBitmap::kRGB_565_Config,    false,  transform_scanline_565 },
-        { SkBitmap::kARGB_8888_Config,  false,  transform_scanline_888 },
-        { SkBitmap::kARGB_8888_Config,  true,   transform_scanline_8888 },
-        { SkBitmap::kARGB_4444_Config,  false,  transform_scanline_444 },
-        { SkBitmap::kARGB_4444_Config,  true,   transform_scanline_4444 },
-        { SkBitmap::kIndex8_Config,     false,  transform_scanline_memcpy },
+        { kRGB_565_SkColorType,     false,  transform_scanline_565 },
+        { kN32_SkColorType,         false,  transform_scanline_888 },
+        { kN32_SkColorType,         true,   transform_scanline_8888 },
+        { kARGB_4444_SkColorType,   false,  transform_scanline_444 },
+        { kARGB_4444_SkColorType,   true,   transform_scanline_4444 },
+        { kIndex_8_SkColorType,     false,  transform_scanline_memcpy },
     };
 
     for (int i = SK_ARRAY_COUNT(gMap) - 1; i >= 0; --i) {
-        if (gMap[i].fConfig == config && gMap[i].fHasAlpha == hasAlpha) {
+        if (gMap[i].fColorType == ct && gMap[i].fHasAlpha == hasAlpha) {
             return gMap[i].fProc;
         }
     }
@@ -1107,38 +1106,37 @@ protected:
 private:
     bool doEncode(SkWStream* stream, const SkBitmap& bm,
                   const bool& hasAlpha, int colorType,
-                  int bitDepth, SkBitmap::Config config,
+                  int bitDepth, SkColorType ct,
                   png_color_8& sig_bit);
 
     typedef SkImageEncoder INHERITED;
 };
 
-bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap,
-                                 int /*quality*/) {
-    SkBitmap::Config config = bitmap.config();
+bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, int /*quality*/) {
+    SkColorType ct = bitmap.colorType();
 
     const bool hasAlpha = !bitmap.isOpaque();
     int colorType = PNG_COLOR_MASK_COLOR;
     int bitDepth = 8;   // default for color
     png_color_8 sig_bit;
 
-    switch (config) {
-        case SkBitmap::kIndex8_Config:
+    switch (ct) {
+        case kIndex_8_SkColorType:
             colorType |= PNG_COLOR_MASK_PALETTE;
             // fall through to the ARGB_8888 case
-        case SkBitmap::kARGB_8888_Config:
+        case kN32_SkColorType:
             sig_bit.red = 8;
             sig_bit.green = 8;
             sig_bit.blue = 8;
             sig_bit.alpha = 8;
             break;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             sig_bit.red = 4;
             sig_bit.green = 4;
             sig_bit.blue = 4;
             sig_bit.alpha = 4;
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             sig_bit.red = 5;
             sig_bit.green = 6;
             sig_bit.blue = 5;
@@ -1173,13 +1171,12 @@ bool SkPNGImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap,
         bitDepth = computeBitDepth(ctable->count());
     }
 
-    return doEncode(stream, bitmap, hasAlpha, colorType,
-                    bitDepth, config, sig_bit);
+    return doEncode(stream, bitmap, hasAlpha, colorType, bitDepth, ct, sig_bit);
 }
 
 bool SkPNGImageEncoder::doEncode(SkWStream* stream, const SkBitmap& bitmap,
                   const bool& hasAlpha, int colorType,
-                  int bitDepth, SkBitmap::Config config,
+                  int bitDepth, SkColorType ct,
                   png_color_8& sig_bit) {
 
     png_structp png_ptr;
@@ -1224,7 +1221,7 @@ bool SkPNGImageEncoder::doEncode(SkWStream* stream, const SkBitmap& bitmap,
     // set our colortable/trans arrays if needed
     png_color paletteColors[256];
     png_byte trans[256];
-    if (SkBitmap::kIndex8_Config == config) {
+    if (kIndex_8_SkColorType == ct) {
         SkColorTable* ct = bitmap.getColorTable();
         int numTrans = pack_palette(ct, paletteColors, trans, hasAlpha);
         png_set_PLTE(png_ptr, info_ptr, paletteColors, ct->count());
@@ -1239,7 +1236,7 @@ bool SkPNGImageEncoder::doEncode(SkWStream* stream, const SkBitmap& bitmap,
     const char* srcImage = (const char*)bitmap.getPixels();
     SkAutoSMalloc<1024> rowStorage(bitmap.width() << 2);
     char* storage = (char*)rowStorage.get();
-    transform_scanline_proc proc = choose_proc(config, hasAlpha);
+    transform_scanline_proc proc = choose_proc(ct, hasAlpha);
 
     for (int y = 0; y < bitmap.height(); y++) {
         png_bytep row_ptr = (png_bytep)storage;

diff --git a/src/images/SkImageDecoder_libwebp.cpp b/src/images/SkImageDecoder_libwebp.cpp
index 7a3c65875c18191730838bba29d5e576d67eb90a..f7cfa8b4cca4937f15a549cdd27ea4040f07e8dd 100644 (file)
--- a/src/images/SkImageDecoder_libwebp.cpp
+++ b/src/images/SkImageDecoder_libwebp.cpp
@@ -169,9 +169,9 @@ static bool return_false(const SkBitmap& bm, const char msg[]) {
 
 static WEBP_CSP_MODE webp_decode_mode(const SkBitmap* decodedBitmap, bool premultiply) {
     WEBP_CSP_MODE mode = MODE_LAST;
-    SkBitmap::Config config = decodedBitmap->config();
+    const SkColorType ct = decodedBitmap->colorType();
 
-    if (config == SkBitmap::kARGB_8888_Config) {
+    if (ct == kN32_SkColorType) {
         #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
             mode = premultiply ? MODE_bgrA : MODE_BGRA;
         #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
@@ -179,9 +179,9 @@ static WEBP_CSP_MODE webp_decode_mode(const SkBitmap* decodedBitmap, bool premul
         #else
             #error "Skia uses BGRA or RGBA byte order"
         #endif
-    } else if (config == SkBitmap::kARGB_4444_Config) {
+    } else if (ct == kARGB_4444_SkColorType) {
         mode = premultiply ? MODE_rgbA_4444 : MODE_RGBA_4444;
-    } else if (config == SkBitmap::kRGB_565_Config) {
+    } else if (ct == kRGB_565_SkColorType) {
         mode = MODE_RGB_565;
     }
     SkASSERT(MODE_LAST != mode);
@@ -333,10 +333,8 @@ bool SkWEBPImageDecoder::onBuildTileIndex(SkStreamRewindable* stream,
 }
 
 static bool is_config_compatible(const SkBitmap& bitmap) {
-    SkBitmap::Config config = bitmap.config();
-    return config == SkBitmap::kARGB_4444_Config ||
-           config == SkBitmap::kRGB_565_Config ||
-           config == SkBitmap::kARGB_8888_Config;
+    const SkColorType ct = bitmap.colorType();
+    return ct == kARGB_4444_SkColorType || ct == kRGB_565_SkColorType || ct == kN32_SkColorType;
 }
 
 bool SkWEBPImageDecoder::onDecodeSubset(SkBitmap* decodedBitmap,
@@ -556,11 +554,9 @@ static void Index8_To_RGB(const uint8_t* in, uint8_t* rgb, int width,
   }
 }
 
-static ScanlineImporter ChooseImporter(const SkBitmap::Config& config,
-                                       bool  hasAlpha,
-                                       int*  bpp) {
-    switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+static ScanlineImporter ChooseImporter(SkColorType ct, bool  hasAlpha, int*  bpp) {
+    switch (ct) {
+        case kN32_SkColorType:
             if (hasAlpha) {
                 *bpp = 4;
                 return ARGB_8888_To_RGBA;
@@ -568,7 +564,7 @@ static ScanlineImporter ChooseImporter(const SkBitmap::Config& config,
                 *bpp = 3;
                 return ARGB_8888_To_RGB;
             }
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             if (hasAlpha) {
                 *bpp = 4;
                 return ARGB_4444_To_RGBA;
@@ -576,10 +572,10 @@ static ScanlineImporter ChooseImporter(const SkBitmap::Config& config,
                 *bpp = 3;
                 return ARGB_4444_To_RGB;
             }
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             *bpp = 3;
             return RGB_565_To_RGB;
-        case SkBitmap::kIndex8_Config:
+        case kIndex_8_SkColorType:
             *bpp = 3;
             return Index8_To_RGB;
         default:
@@ -603,11 +599,9 @@ private:
 
 bool SkWEBPImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bm,
                                   int quality) {
-    const SkBitmap::Config config = bm.config();
     const bool hasAlpha = !bm.isOpaque();
     int bpp = -1;
-    const ScanlineImporter scanline_import = ChooseImporter(config, hasAlpha,
-                                                            &bpp);
+    const ScanlineImporter scanline_import = ChooseImporter(bm.colorType(), hasAlpha, &bpp);
     if (NULL == scanline_import) {
         return false;
     }

diff --git a/src/images/SkImageEncoder_argb.cpp b/src/images/SkImageEncoder_argb.cpp
index 97b741b8bf1d1717c31397f25e58ce6482a6ac59..296491eef81864ce0c7f48ec0af7b99c1f25f7be 100644 (file)
--- a/src/images/SkImageEncoder_argb.cpp
+++ b/src/images/SkImageEncoder_argb.cpp
@@ -71,15 +71,15 @@ static void Index8_To_ARGB(const uint8_t* in, uint8_t* argb, int width,
   }
 }
 
-static ScanlineImporter ChooseImporter(const SkBitmap::Config& config) {
-    switch (config) {
-        case SkBitmap::kARGB_8888_Config:
+static ScanlineImporter ChooseImporter(SkColorType ct) {
+    switch (ct) {
+        case kN32_SkColorType:
             return ARGB_8888_To_ARGB;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             return RGB_565_To_ARGB;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             return ARGB_4444_To_ARGB;
-        case SkBitmap::kIndex8_Config:
+        case kIndex_8_SkColorType:
             return Index8_To_ARGB;
         default:
             return NULL;
@@ -87,8 +87,7 @@ static ScanlineImporter ChooseImporter(const SkBitmap::Config& config) {
 }
 
 bool SkARGBImageEncoder::onEncode(SkWStream* stream, const SkBitmap& bitmap, int) {
-    const SkBitmap::Config config = bitmap.config();
-    const ScanlineImporter scanline_import = ChooseImporter(config);
+    const ScanlineImporter scanline_import = ChooseImporter(bitmap.colorType());
     if (NULL == scanline_import) {
         return false;
     }

diff --git a/src/images/SkScaledBitmapSampler.cpp b/src/images/SkScaledBitmapSampler.cpp
index 7fd8718bebbc01705cbc800c938c4f16cfb68b38..d78502d2bbd6a3727de5081fcdf3652cfcd6ba45 100644 (file)
--- a/src/images/SkScaledBitmapSampler.cpp
+++ b/src/images/SkScaledBitmapSampler.cpp
@@ -696,20 +696,20 @@ bool SkScaledBitmapSampler::begin(SkBitmap* dst, SrcConfig sc,
             return false;
     }
 
-    switch (dst->config()) {
-        case SkBitmap::kARGB_8888_Config:
+    switch (dst->colorType()) {
+        case kN32_SkColorType:
             index += 0 * gProcDstConfigSpan;
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             index += 1 * gProcDstConfigSpan;
             break;
-        case SkBitmap::kARGB_4444_Config:
+        case kARGB_4444_SkColorType:
             index += 2 * gProcDstConfigSpan;
             break;
-        case SkBitmap::kIndex8_Config:
+        case kIndex_8_SkColorType:
             index += 3 * gProcDstConfigSpan;
             break;
-        case SkBitmap::kA8_Config:
+        case kAlpha_8_SkColorType:
             index += 4 * gProcDstConfigSpan;
             break;
         default:

diff --git a/src/utils/SkTextureCompressor.cpp b/src/utils/SkTextureCompressor.cpp
index 5ef1ae39fcebe31f8c4b96f98c15e019b4e1fb4d..fb41928269be4b98e006c83d702d25d6cd291849 100644 (file)
--- a/src/utils/SkTextureCompressor.cpp
+++ b/src/utils/SkTextureCompressor.cpp
@@ -197,7 +197,7 @@ SkData *CompressBitmapToFormat(const SkBitmap &bitmap, Format format) {
     memset(kProcMap, 0, sizeof(kProcMap));
 
     // Map available bitmap configs to compression functions
-    kProcMap[SkBitmap::kA8_Config][kLATC_Format] = compress_a8_to_latc;
+    kProcMap[kAlpha_8_SkColorType][kLATC_Format] = compress_a8_to_latc;
 
     CompressBitmapProc proc = kProcMap[bitmap.colorType()][format];
     if (NULL != proc) {

diff --git a/tests/KtxTest.cpp b/tests/KtxTest.cpp
index 94a4c22e033cffa7f767de5e10343be26b3b7438..93edaf41f1b50af8fed9e4c444f7d56021c0b2be 100644 (file)
--- a/tests/KtxTest.cpp
+++ b/tests/KtxTest.cpp
@@ -115,7 +115,7 @@ DEF_TEST(KtxReadUnpremul, reporter) {
     bool imageDecodeSuccess = SkImageDecoder::DecodeStream(stream, &decodedBitmap);
     REPORTER_ASSERT(reporter, imageDecodeSuccess);
 
-    REPORTER_ASSERT(reporter, decodedBitmap.config() == SkBitmap::kARGB_8888_Config);
+    REPORTER_ASSERT(reporter, decodedBitmap.colorType() == kN32_SkColorType);
     REPORTER_ASSERT(reporter, decodedBitmap.alphaType() == kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, decodedBitmap.width() == 2);
     REPORTER_ASSERT(reporter, decodedBitmap.height() == 2);

diff --git a/tools/picture_utils.cpp b/tools/picture_utils.cpp
index d88d922af966b7348c169cb567912e0039da8543..597fd4878f338c75aa2e594141768b4e621fa017 100644 (file)
--- a/tools/picture_utils.cpp
+++ b/tools/picture_utils.cpp
@@ -17,8 +17,8 @@
 namespace sk_tools {
     void force_all_opaque(const SkBitmap& bitmap) {
         SkASSERT(NULL == bitmap.getTexture());
-        SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config());
-        if (NULL != bitmap.getTexture() || SkBitmap::kARGB_8888_Config == bitmap.config()) {
+        SkASSERT(kN32_SkColorType == bitmap.colorType());
+        if (NULL != bitmap.getTexture() || kN32_SkColorType == bitmap.colorType()) {
             return;
         }
 

diff --git a/tools/skpdiff/SkCLImageDiffer.cpp b/tools/skpdiff/SkCLImageDiffer.cpp
index b99ef40d700f9b361462460613f883a3ee47d301..1c5d5c56ea3993c65047d657ad56e45995f85f71 100644 (file)
--- a/tools/skpdiff/SkCLImageDiffer.cpp
+++ b/tools/skpdiff/SkCLImageDiffer.cpp
@@ -87,16 +87,16 @@ bool SkCLImageDiffer::loadKernelSource(const char source[], const char name[], c
 bool SkCLImageDiffer::makeImage2D(SkBitmap* bitmap, cl_mem* image) const {
     cl_int imageErr;
     cl_image_format bitmapFormat;
-    switch (bitmap->config()) {
-        case SkBitmap::kA8_Config:
+    switch (bitmap->colorType()) {
+        case kAlpha_8_SkColorType:
             bitmapFormat.image_channel_order = CL_A;
             bitmapFormat.image_channel_data_type = CL_UNSIGNED_INT8;
             break;
-        case SkBitmap::kRGB_565_Config:
+        case kRGB_565_SkColorType:
             bitmapFormat.image_channel_order = CL_RGB;
             bitmapFormat.image_channel_data_type = CL_UNORM_SHORT_565;
             break;
-        case SkBitmap::kARGB_8888_Config:
+        case kN32_SkColorType:
             bitmapFormat.image_channel_order = CL_RGBA;
             bitmapFormat.image_channel_data_type = CL_UNSIGNED_INT8;
             break;