Updates to skimage tool to use it for testing.

src/images/SkImageDecoder.cpp

Index: src/images/SkImageDecoder.cpp
diff --git a/src/images/SkImageDecoder.cpp b/src/images/SkImageDecoder.cpp
index c16efcf1f32797330cf39d29d10ed2da2f5ee951..c3d0f126e1d4d8de2c9db7d342fc0a5be919638b 100644
--- a/src/images/SkImageDecoder.cpp
+++ b/src/images/SkImageDecoder.cpp
@@ -8,6 +8,7 @@
 
 #include "SkImageDecoder.h"
 #include "SkBitmap.h"
+#include "SkErrorInternals.h"
 #include "SkImagePriv.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
@@ -18,17 +19,6 @@ 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()
@@ -59,9 +49,43 @@ 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) {