hide Config in SkImageDecoder -- use SkColorType instead

tests/ImageDecodingTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColor.h"
@@ skipping 72 matching lines @@
     if (skip_image_format(format)) {
         return;
     }
 
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
     if (NULL == decoder.get()) {
         SkDebugf("couldn't decode %s\n", filename.c_str());
         return;
     }
 
-    bool success = decoder->decode(&stream, &bm8888, SkBitmap::kARGB_8888_Config,
+    bool success = decoder->decode(&stream, &bm8888, kN32_SkColorType,
                                    SkImageDecoder::kDecodePixels_Mode);
     if (!success) {
         return;
     }
 
     success = stream.rewind();
     REPORTER_ASSERT(reporter, success);
     if (!success) {
         return;
     }
 
     decoder->setRequireUnpremultipliedColors(true);
-    success = decoder->decode(&stream, &bm8888Unpremul, SkBitmap::kARGB_8888_Config,
+    success = decoder->decode(&stream, &bm8888Unpremul, kN32_SkColorType,
                               SkImageDecoder::kDecodePixels_Mode);
     if (!success) {
         return;
     }
 
     bool dimensionsMatch = bm8888.width() == bm8888Unpremul.width()
                            && bm8888.height() == bm8888Unpremul.height();
     REPORTER_ASSERT(reporter, dimensionsMatch);
     if (!dimensionsMatch) {
         return;
     }
 
     // Only do the comparison if the two bitmaps are both 8888.
-    if (bm8888.config() != SkBitmap::kARGB_8888_Config
-        || bm8888Unpremul.config() != SkBitmap::kARGB_8888_Config) {
+    if (bm8888.colorType() != kN32_SkColorType || bm8888Unpremul.colorType() != kN32_SkColorType) {
         return;
     }
 
     // Now compare the two bitmaps.
     for (int i = 0; i < bm8888.width(); ++i) {
         for (int j = 0; j < bm8888.height(); ++j) {
             // "c0" is the color of the premultiplied bitmap at (i, j).
             const SkPMColor c0 = *bm8888.getAddr32(i, j);
             // "c1" is the result of premultiplying the color of the unpremultiplied
             // bitmap at (i, j).
@@ skipping 43 matching lines @@
     SkFILEStream stream(filename.c_str());
 
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
     if (NULL == decoder.get()) {
         return;
     }
 
     decoder->setRequireUnpremultipliedColors(requireUnpremul);
 
     // Decode just the bounds. This should always succeed.
-    bool success = decoder->decode(&stream, &bm, SkBitmap::kARGB_8888_Config,
+    bool success = decoder->decode(&stream, &bm, kN32_SkColorType,
                                    SkImageDecoder::kDecodeBounds_Mode);
     REPORTER_ASSERT(reporter, success);
     if (!success) {
         return;
     }
 
     // Keep track of the alpha type for testing later. If the full decode
     // succeeds, the alpha type should be the same, unless the full decode
     // determined that the alpha type should actually be opaque, which may
     // not be known when only decoding the bounds.
     const SkAlphaType boundsAlphaType = bm.alphaType();
 
     // rewind should always succeed on SkFILEStream.
     success = stream.rewind();
     REPORTER_ASSERT(reporter, success);
     if (!success) {
         return;
     }
 
-    success = decoder->decode(&stream, &bm, SkBitmap::kARGB_8888_Config,
-                              SkImageDecoder::kDecodePixels_Mode);
+    success = decoder->decode(&stream, &bm, kN32_SkColorType, SkImageDecoder::kDecodePixels_Mode);
 
     if (!success) {
         // When the decoder is set to require unpremul, if it does not support
         // unpremul it will fail. This is the only reason the decode should
         // fail (since we know the files we are using to test can be decoded).
         REPORTER_ASSERT(reporter, requireUnpremul);
         return;
     }
 
     // The bounds decode should return with either the requested
@@ skipping 61 matching lines @@
 
         // This should never fail since we know the images we're decoding.
         SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(&stream));
         REPORTER_ASSERT(reporter, NULL != decoder.get());
         if (NULL == decoder.get()) {
             continue;
         }
 
         // Test unpremultiplied. We know what color this should result in.
         decoder->setRequireUnpremultipliedColors(true);
-        bool success = decoder->decode(&stream, &bm, SkBitmap::kARGB_8888_Config,
+        bool success = decoder->decode(&stream, &bm, kN32_SkColorType,
                                        SkImageDecoder::kDecodePixels_Mode);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             continue;
         }
 
         REPORTER_ASSERT(reporter, bm.width() == 1 && bm.height() == 1);
         {
             SkAutoLockPixels alp(bm);
             REPORTER_ASSERT(reporter, bm.getAddr32(0, 0)[0] == 0x7fffffff);
         }
 
         success = stream.rewind();
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             continue;
         }
 
         // Test premultiplied. Once again, we know which color this should
         // result in.
         decoder->setRequireUnpremultipliedColors(false);
-        success = decoder->decode(&stream, &bm, SkBitmap::kARGB_8888_Config,
+        success = decoder->decode(&stream, &bm, kN32_SkColorType,
                                   SkImageDecoder::kDecodePixels_Mode);
         REPORTER_ASSERT(reporter, success);
         if (!success) {
             continue;
         }
 
         REPORTER_ASSERT(reporter, bm.width() == 1 && bm.height() == 1);
         {
             SkAutoLockPixels alp(bm);
             REPORTER_ASSERT(reporter, bm.getAddr32(0, 0)[0] == 0x7f7f7f7f);
@@ skipping 53 matching lines @@
             continue;
         }
         int width, height;
         if (!decoder->buildTileIndex(stream.get(), &width, &height)) {
             SkDebugf("could not build a tile index\n");
             continue;
         }
         // Now unref the stream to make sure it survives
         stream.reset(NULL);
         SkBitmap bm;
-        decoder->decodeSubset(&bm, SkIRect::MakeWH(width, height),
-                              SkBitmap::kARGB_8888_Config);
+        decoder->decodeSubset(&bm, SkIRect::MakeWH(width, height), kN32_SkColorType);
     }
 }
 
 // Test inside SkScaledBitmapSampler.cpp
 extern void test_row_proc_choice();
 
 #endif  // SK_DEBUG
 
 DEF_TEST(ImageDecoding, reporter) {
     test_unpremul(reporter);
@@ skipping 226 matching lines @@
     //     && out_size <= SkNextPow2(((in_size - 1) / sample_size) + 1));
     #endif  // SK_BUILD_FOR_ANDROID || SK_BUILD_FOR_UNIX
     SkAutoLockPixels alp(bm);
     if (bm.getPixels() == NULL) {
         ERRORF(reporter, "Pixel decode failed [sampleSize=%d dither=%s "
                "colorType=%s %s]", opts.fSampleSize, yn(opts.fDitherImage),
                options_colorType(opts), path.c_str());
         return;
     }
 
-    SkBitmap::Config requestedConfig
-        = SkColorTypeToBitmapConfig(opts.fRequestedColorType);
+    SkColorType requestedColorType = opts.fRequestedColorType;
     REPORTER_ASSERT(reporter,
                     (!opts.fUseRequestedColorType)
-                    || (bm.config() == requestedConfig));
+                    || (bm.colorType() == requestedColorType));
 
     // Condition under which we should check the decoding results:
-    if ((SkBitmap::kARGB_8888_Config == bm.config())
+    if ((kN32_SkColorType == bm.colorType())
         && (!path.endsWith(".jpg"))  // lossy
         && (opts.fSampleSize == 1)) {  // scaled
         const SkColor* correctPixels = kExpectedPixels;
         SkASSERT(bm.height() == kExpectedHeight);
         SkASSERT(bm.width() == kExpectedWidth);
         int pixelErrors = 0;
         for (int y = 0; y < bm.height(); ++y) {
             for (int x = 0; x < bm.width(); ++x) {
                 if (*correctPixels != bm.getColor(x, y)) {
                     ++pixelErrors;
@@ skipping 72 matching lines @@
                     }
                     SkDecodingImageGenerator::Options options(scaleList[i],
                                                               ditherList[j]);
                     test_options(reporter, options, encodedStream, encodedData,
                                  useDataList[m], path);
                 }
             }
         }
     }
 }