Remove image decoder and encoder autoregistration

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 149 matching lines @@
                 *addr = SkUnPreMultiply::UnPreMultiplyPreservingByteOrder(*addr);
             }
         }
         bm->setAlphaType(kUnpremul_SkAlphaType);
     }
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-extern SkImageDecoder* image_decoder_from_stream(SkStreamRewindable*);
-
-SkImageDecoder* SkImageDecoder::Factory(SkStreamRewindable* stream) {
-    SkImageDecoder* decoder = image_decoder_from_stream(stream);
-    if (NULL == decoder) {
-        // If no image decoder specific to the stream exists, use SkImageDecoder_CG.
-        return SkNEW(SkImageDecoder_CG);
-    } else {
-        return decoder;
-    }
-}
-
-/////////////////////////////////////////////////////////////////////////
-
-SkMovie* SkMovie::DecodeStream(SkStreamRewindable* stream) {
-    return NULL;
-}
-
-/////////////////////////////////////////////////////////////////////////
 
 static size_t consumer_put(void* info, const void* buffer, size_t count) {
     SkWStream* stream = reinterpret_cast<SkWStream*>(info);
     return stream->write(buffer, count) ? count : 0;
 }
 
 static void consumer_release(void* info) {
     // we do nothing, since by design we don't "own" the stream (i.e. info)
 }
 
@@ skipping 77 matching lines @@
     CGImageRef image = SkCreateCGImageRef(*bmPtr);
     if (NULL == image) {
         return false;
     }
     SkAutoTCallVProc<CGImage, CGImageRelease> agimage(image);
 
     CGImageDestinationAddImage(dst, image, NULL);
     return CGImageDestinationFinalize(dst);
 }
 
-///////////////////////////////////////////////////////////////////////////////
-
-static SkImageEncoder* sk_imageencoder_cg_factory(SkImageEncoder::Type t) {
+SkImageEncoder* SkCreateImageEncoder_CG(Type t) {
+    SkImageEncoder* codec = NULL;
+    if ((codec = CreateUserEncoder(t))) {
+        return codec;
+    }
     switch (t) {
+#ifndef SK_BUILD_FOR_IOS        
         case SkImageEncoder::kICO_Type:
         case SkImageEncoder::kBMP_Type:
         case SkImageEncoder::kGIF_Type:
         case SkImageEncoder::kJPEG_Type:
+#endif
         case SkImageEncoder::kPNG_Type:
             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;
 };
 
 // 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 },
     // Also include JPEG2000
     { kUTTypeJPEG2000, SkImageDecoder::kJPEG_Format },
     { kUTTypePNG, SkImageDecoder::kPNG_Format },
 };
 
 static SkImageDecoder::Format 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;
 }
 
-static SkImageDecoder::Format get_format_cg(SkStreamRewindable* stream) {
+SkImageDecoder::Format SkDetectFormatImageDecoder_CG(SkStreamRewindable* stream) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
     if (NULL == imageSrc) {
         return SkImageDecoder::kUnknown_Format;
     }
 
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
     const CFStringRef name = CGImageSourceGetType(imageSrc);
     if (NULL == name) {
         return SkImageDecoder::kUnknown_Format;
     }
     return UTType_to_Format(name);
 }
 
-static SkImageDecoder_FormatReg gFormatReg(get_format_cg);
+SkImageDecoder* SkCreateImageDecoder_CG(SkStreamRewindable* stream) {
+    if (SkDetectFormatImageDecoder_CG(stream) != SkImageDecoder::kUnknown_Format) {
+        return SkNEW(SkImageDecoder_CG);
+    }
+    return NULL;
+}