Updates to skimage tool to use it for testing.

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 "SkErrorInternals.h"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkCanvas.h"
 
 SK_DEFINE_INST_COUNT(SkImageDecoder::Peeker)
 SK_DEFINE_INST_COUNT(SkImageDecoder::Chooser)
 SK_DEFINE_INST_COUNT(SkImageDecoderFactory)
 
-const char *SkImageDecoder::sFormatName[] = {
-    "Unknown Format",
-    "BMP",
-    "GIF",
-    "ICO",
-    "JPEG",
-    "PNG",
-    "WBMP",
-    "WEBP",
-};
-
 static SkBitmap::Config gDeviceConfig = SkBitmap::kNo_Config;
 
 SkBitmap::Config SkImageDecoder::GetDeviceConfig()
 {
     return gDeviceConfig;
 }
 
 void SkImageDecoder::SetDeviceConfig(SkBitmap::Config config)
 {
     gDeviceConfig = config;
@@ skipping 10 matching lines @@
 SkImageDecoder::~SkImageDecoder() {
     SkSafeUnref(fPeeker);
     SkSafeUnref(fChooser);
     SkSafeUnref(fAllocator);
 }
 
 SkImageDecoder::Format SkImageDecoder::getFormat() const {
     return kUnknown_Format;
 }
 
+SkImageDecoder::Format SkImageDecoder::onGetFormat(SkStream*) const {
+    return kUnknown_Format;
+}
+
+SkImageDecoder::Format SkImageDecoder::getFormat(SkStream* stream) const {
+    Format format = this->onGetFormat(stream);

[epoger, 2013/04/23 16:03:41]

It bugs me that SkImageDecoder::getFormat(SkStream* stream) purports to tell me
which format a stream is, but really all it does is tell me whether the stream
matches the SkImageDecoder subclass I instantiated.

e.g., if I call jpegImageDecoder.getFormat(gifStream), it will return
kUnknown_Format, NOT kGIF_Format .

So, I think it would be more honest to call this method something like
bool isSupportedFormat(SkStream* stream) ,
and if we want to find out which format a stream is encoded in, we could create
a factory class that loops over the various implementations and, depending on
which one returns true for isSupportedFormat(), returns the appropriate Format
enum value.

[scroggo, 2013/04/24 18:00:05]

I've replaced this function with a static function. Each decoder now registers a
function to check to see if it knows the Format. They will be called
consecutively, similar to how Factory works.

+    if (!stream->rewind()) {
+        SkErrorInternals::SetError(kInvalidOperation_SkError,
+                                   "Unable to rewind the image stream\n");
+    }
+    return format;
+}
+
 const char* SkImageDecoder::getFormatName() const {
-    SkASSERT(SK_ARRAY_COUNT(sFormatName) == kLastKnownFormat);
-    return sFormatName[this->getFormat()];
+    switch (this->getFormat()) {
+        case kUnknown_Format:
+            return "Unknown Format";
+        case kBMP_Format:
+            return "BMP";
+        case kGIF_Format:
+            return "GIF";
+        case kICO_Format:
+            return "ICO";
+        case kJPEG_Format:
+            return "JPEG";
+        case kPNG_Format:
+            return "PNG";
+        case kWBMP_Format:
+            return "WBMP";
+        case kWEBP_Format:
+            return "WEBP";
+        case kMultiple_Formats:
+            return "Multiple formats";
+        default:
+            SkASSERT(!"Invalid format type!");
+    }
+    return "Unknown Format";
 }
 
 SkImageDecoder::Peeker* SkImageDecoder::setPeeker(Peeker* peeker) {
     SkRefCnt_SafeAssign(fPeeker, peeker);
     return peeker;
 }
 
 SkImageDecoder::Chooser* SkImageDecoder::setChooser(Chooser* chooser) {
     SkRefCnt_SafeAssign(fChooser, chooser);
     return chooser;
@@ skipping 244 matching lines @@
 
     if (NULL != codec) {
         success = codec->decode(stream, bm, pref, mode);
         if (success && format) {
             *format = codec->getFormat();
         }
         delete codec;
     }
     return success;
 }