Add SkEncodedFormat, used by SkCodec.

src/ports/SkImageDecoder_CG.cpp

 /*
  * Copyright 2008 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 "SkCGUtils.h"
 #include "SkColorPriv.h"
 #include "SkImageDecoder.h"
@@ skipping 304 matching lines @@
         return false;
     }
     SkAutoTCallVProc<CGImage, CGImageRelease> agimage(image);
 
     CGImageDestinationAddImage(dst, image, NULL);
     return CGImageDestinationFinalize(dst);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static SkImageEncoder* sk_imageencoder_cg_factory(SkImageEncoder::Type t) {
+static SkImageEncoder* sk_imageencoder_cg_factory(SkEncodedFormat t) {
     switch (t) {
-        case SkImageEncoder::kICO_Type:
-        case SkImageEncoder::kBMP_Type:
-        case SkImageEncoder::kGIF_Type:
-        case SkImageEncoder::kJPEG_Type:
-        case SkImageEncoder::kPNG_Type:
+        case kBMP_SkEncodedFormat:
+        case kGIF_SkEncodedFormat:
+        case kICO_SkEncodedFormat:
+        case kJPEG_SkEncodedFormat:
+        case kPNG_SkEncodedFormat:
             break;
         default:
             return NULL;
     }
     return SkNEW_ARGS(SkImageEncoder_CG, (t));
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_imageencoder_cg_factory);
 
 #ifdef SK_BUILD_FOR_IOS
 class SkPNGImageEncoder_IOS : public SkImageEncoder_CG {
 public:
     SkPNGImageEncoder_IOS()
         : SkImageEncoder_CG(kPNG_Type) {
     }
 };
 
 DEFINE_ENCODER_CREATOR(PNGImageEncoder_IOS);
 #endif
 
 struct FormatConversion {
-    CFStringRef             fUTType;
-    SkImageDecoder::Format  fFormat;
+    CFStringRef     fUTType;
+    SkEncodedFormat fFormat;
 };
 
 // Array of the types supported by the decoder.
 static const FormatConversion gFormatConversions[] = {
-    { kUTTypeBMP, SkImageDecoder::kBMP_Format },
-    { kUTTypeGIF, SkImageDecoder::kGIF_Format },
-    { kUTTypeICO, SkImageDecoder::kICO_Format },
-    { kUTTypeJPEG, SkImageDecoder::kJPEG_Format },
+    { kUTTypeBMP, kBMP_SkEncodedFormat },
+    { kUTTypeGIF, kGIF_SkEncodedFormat },
+    { kUTTypeICO, kICO_SkEncodedFormat },
+    { kUTTypeJPEG, kJPEG_SkEncodedFormat },
     // Also include JPEG2000
-    { kUTTypeJPEG2000, SkImageDecoder::kJPEG_Format },
-    { kUTTypePNG, SkImageDecoder::kPNG_Format },
+    { kUTTypeJPEG2000, kJPEG_SkEncodedFormat },
+    { kUTTypePNG, kPNG_SkEncodedFormat },
 };
 
-static SkImageDecoder::Format UTType_to_Format(const CFStringRef uttype) {
+static SkEncodedFormat UTType_to_Format(const CFStringRef uttype) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) {
         if (CFStringCompare(uttype, gFormatConversions[i].fUTType, 0) == kCFCompareEqualTo) {
             return gFormatConversions[i].fFormat;
         }
     }
-    return SkImageDecoder::kUnknown_Format;
+    return kUnknown_SkEncodedFormat;
 }
 
-static SkImageDecoder::Format get_format_cg(SkStreamRewindable* stream) {
+static SkEncodedFormat get_format_cg(SkStreamRewindable* stream) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
     if (NULL == imageSrc) {
-        return SkImageDecoder::kUnknown_Format;
+        return kUnknown_SkEncodedFormat;
     }
 
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
     const CFStringRef name = CGImageSourceGetType(imageSrc);
     if (NULL == name) {
-        return SkImageDecoder::kUnknown_Format;
+        return kUnknown_SkEncodedFormat;
     }
     return UTType_to_Format(name);
 }
 
 static SkImageDecoder_FormatReg gFormatReg(get_format_cg);