Add SkEncodedFormat, used by SkCodec.

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 "Resources.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
@@ skipping 26 matching lines @@
     U8CPU r = SkGetPackedR32(c);
     U8CPU g = SkGetPackedG32(c);
     U8CPU b = SkGetPackedB32(c);
     return SkPreMultiplyARGB(a, r, g, b);
 }
 
 /**
  *  Return true if this stream format should be skipped, due
  *  to do being an opaque format or not a valid format.
  */
-static bool skip_image_format(SkImageDecoder::Format format) {
+static bool skip_image_format(SkEncodedFormat format) {
     switch (format) {
-        case SkImageDecoder::kPNG_Format:
-        case SkImageDecoder::kWEBP_Format:
+        case kPNG_SkEncodedFormat:
+        case kWEBP_SkEncodedFormat:
             return false;
         // Skip unknown since it will not be decoded anyway.
-        case SkImageDecoder::kUnknown_Format:
+        case kUnknown_SkEncodedFormat:
         // Technically ICO and BMP supports alpha channels, but our image
         // decoders do not, so skip them as well.
-        case SkImageDecoder::kICO_Format:
-        case SkImageDecoder::kBMP_Format:
+        case kICO_SkEncodedFormat:
+        case kBMP_SkEncodedFormat:
         // KTX and ASTC are texture formats so it's not particularly clear how to 
         // decode the alpha from them.
-        case SkImageDecoder::kKTX_Format:
-        case SkImageDecoder::kASTC_Format:
+        case kKTX_SkEncodedFormat:
+        case kASTC_SkEncodedFormat:
         // The rest of these are opaque.
-        case SkImageDecoder::kPKM_Format:
-        case SkImageDecoder::kWBMP_Format:
-        case SkImageDecoder::kGIF_Format:
-        case SkImageDecoder::kJPEG_Format:
+        case kPKM_SkEncodedFormat:
+        case kWBMP_SkEncodedFormat:
+        case kGIF_SkEncodedFormat:
+        case kJPEG_SkEncodedFormat:
             return true;
     }
     SkASSERT(false);
     return true;
 }
 
 /**
  *  Test decoding an image in premultiplied mode and unpremultiplied mode and compare
  *  them.
  */
 static void compare_unpremul(skiatest::Reporter* reporter, const SkString& filename) {
     // Decode a resource:
     SkBitmap bm8888;
     SkBitmap bm8888Unpremul;
 
     SkFILEStream stream(filename.c_str());
 
-    SkImageDecoder::Format format = SkImageDecoder::GetStreamFormat(&stream);
+    SkEncodedFormat format = SkImageDecoder::GetStreamFormat(&stream);
     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;
     }
 
@@ skipping 649 matching lines @@
                        ((void*)pixels.get(), sizeof(uint16_t) * pixelCount)));
     decoder->setAllocator(allocator);
     decoder->setSampleSize(2);
     SkBitmap bitmap;
     bool success = decoder->decode(stream, &bitmap, kRGB_565_SkColorType,
                                    SkImageDecoder::kDecodePixels_Mode) != SkImageDecoder::kFailure;
     REPORTER_ASSERT(r, success);
     REPORTER_ASSERT(r, !allocator->ready());  // Decoder used correct memory
     REPORTER_ASSERT(r, sentinal == pixels[pixelCount]);
 }