hide Config in SkImageDecoder -- use SkColorType instead

src/images/SkImageDecoder.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 "SkImageDecoder.h"
 #include "SkBitmap.h"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkCanvas.h"
 
 SkImageDecoder::SkImageDecoder()
     : fPeeker(NULL)
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
     , fChooser(NULL)
 #endif
     , fAllocator(NULL)
     , fSampleSize(1)
-    , fDefaultPref(SkBitmap::kNo_Config)
+    , fDefaultPref(kUnknown_SkColorType)
     , fDitherImage(true)
     , fUsePrefTable(false)
     , fSkipWritingZeroes(false)
     , fPreferQualityOverSpeed(false)
     , fRequireUnpremultipliedColors(false) {
 }
 
 SkImageDecoder::~SkImageDecoder() {
     SkSafeUnref(fPeeker);
 #ifdef SK_SUPPORT_LEGACY_IMAGEDECODER_CHOOSER
@@ skipping 106 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkImageDecoder::setPrefConfigTable(const PrefConfigTable& prefTable) {
     fUsePrefTable = true;
     fPrefTable = prefTable;
 }
 
 // TODO: use colortype in fPrefTable, fDefaultPref so we can stop using SkBitmapConfigToColorType()
 //
 SkColorType SkImageDecoder::getPrefColorType(SrcDepth srcDepth, bool srcHasAlpha) const {
-    SkBitmap::Config config = SkBitmap::kNo_Config;
+    SkColorType ct = fDefaultPref;
 
     if (fUsePrefTable) {
+        // Until we kill or change the PrefTable, we have to go into Config land for a moment.
+        SkBitmap::Config config = SkBitmap::kNo_Config;
         switch (srcDepth) {
             case kIndex_SrcDepth:
                 config = srcHasAlpha ? fPrefTable.fPrefFor_8Index_YesAlpha_src
                                      : fPrefTable.fPrefFor_8Index_NoAlpha_src;
                 break;
             case k8BitGray_SrcDepth:
                 config = fPrefTable.fPrefFor_8Gray_src;
                 break;
             case k32Bit_SrcDepth:
                 config = srcHasAlpha ? fPrefTable.fPrefFor_8bpc_YesAlpha_src
                                      : fPrefTable.fPrefFor_8bpc_NoAlpha_src;
                 break;
         }
-    } else {
-        config = fDefaultPref;
+        // now return to SkColorType land
+        ct = SkBitmapConfigToColorType(config);
     }
-
-    return SkBitmapConfigToColorType(config);
+    return ct;
 }
 
-bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm,
-                            SkBitmap::Config pref, Mode mode) {
+bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm, SkColorType pref, Mode mode) {
     // we reset this to false before calling onDecode
     fShouldCancelDecode = false;
-    // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
+    // assign this, for use by getPrefColorType(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
     // pass a temporary bitmap, so that if we return false, we are assured of
     // leaving the caller's bitmap untouched.
     SkBitmap    tmp;
     if (!this->onDecode(stream, &tmp, mode)) {
         return false;
     }
     bm->swap(tmp);
     return true;
 }
 
-bool SkImageDecoder::decodeSubset(SkBitmap* bm, const SkIRect& rect,
-                                  SkBitmap::Config pref) {
+bool SkImageDecoder::decodeSubset(SkBitmap* bm, const SkIRect& rect, SkColorType pref) {
     // we reset this to false before calling onDecodeSubset
     fShouldCancelDecode = false;
-    // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
+    // assign this, for use by getPrefColorType(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
     return this->onDecodeSubset(bm, rect);
 }
 
-bool SkImageDecoder::buildTileIndex(SkStreamRewindable* stream,
-                                    int *width, int *height) {
+bool SkImageDecoder::buildTileIndex(SkStreamRewindable* stream, int *width, int *height) {
     // we reset this to false before calling onBuildTileIndex
     fShouldCancelDecode = false;
 
     return this->onBuildTileIndex(stream, width, height);
 }
 
 bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
                                 int dstX, int dstY, int width, int height,
                                 int srcX, int srcY) {
     int w = width / sampleSize;
@@ skipping 35 matching lines @@
 
     SkCanvas canvas(*dst);
     canvas.drawSprite(*src, (srcX - dstX) / sampleSize,
                             (srcY - dstY) / sampleSize,
                             &paint);
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm,
-                            SkBitmap::Config pref,  Mode mode, Format* format) {
+bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm, SkColorType pref,  Mode mode,
+                                Format* format) {
     SkASSERT(file);
     SkASSERT(bm);
 
     SkAutoTUnref<SkStreamRewindable> stream(SkStream::NewFromFile(file));
     if (stream.get()) {
         if (SkImageDecoder::DecodeStream(stream, bm, pref, mode, format)) {
             bm->pixelRef()->setURI(file);
             return true;
         }
     }
     return false;
 }
 
-bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm,
-                          SkBitmap::Config pref, Mode mode, Format* format) {
+bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm, SkColorType pref,
+                                  Mode mode, Format* format) {
     if (0 == size) {
         return false;
     }
     SkASSERT(buffer);
 
     SkMemoryStream  stream(buffer, size);
     return SkImageDecoder::DecodeStream(&stream, bm, pref, mode, format);
 }
 
-bool SkImageDecoder::DecodeStream(SkStreamRewindable* stream, SkBitmap* bm,
-                                  SkBitmap::Config pref, Mode mode,
-                                  Format* format) {
+bool SkImageDecoder::DecodeStream(SkStreamRewindable* stream, SkBitmap* bm, SkColorType pref,
+                                  Mode mode, Format* format) {
     SkASSERT(stream);
     SkASSERT(bm);
 
     bool success = false;
     SkImageDecoder* codec = SkImageDecoder::Factory(stream);
 
     if (NULL != codec) {
         success = codec->decode(stream, bm, pref, mode);
         if (success && format) {
             *format = codec->getFormat();
             if (kUnknown_Format == *format) {
                 if (stream->rewind()) {
                     *format = GetStreamFormat(stream);
                 }
             }
         }
         delete codec;
     }
     return success;
 }