Change SkImageDecoders to take an SkStreamRewindable.

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 10 matching lines @@
 #ifdef SK_BUILD_FOR_IOS
 #include <CoreGraphics/CoreGraphics.h>
 #include <ImageIO/ImageIO.h>
 #include <MobileCoreServices/MobileCoreServices.h>
 #endif
 
 static void malloc_release_proc(void* info, const void* data, size_t size) {
     sk_free(info);
 }
 
-static CGDataProviderRef SkStreamToDataProvider(SkStream* stream) {
+static CGDataProviderRef SkStreamToDataProvider(SkStreamRewindable* stream) {
     // TODO: use callbacks, so we don't have to load all the data into RAM
     size_t len = stream->getLength();
     void* data = sk_malloc_throw(len);
     stream->read(data, len);
 
     return CGDataProviderCreateWithData(data, data, len, malloc_release_proc);
 }
 
-static CGImageSourceRef SkStreamToCGImageSource(SkStream* stream) {
+static CGImageSourceRef SkStreamToCGImageSource(SkStreamRewindable* stream) {
     CGDataProviderRef data = SkStreamToDataProvider(stream);
     CGImageSourceRef imageSrc = CGImageSourceCreateWithDataProvider(data, 0);
     CGDataProviderRelease(data);
     return imageSrc;
 }
 
 class SkImageDecoder_CG : public SkImageDecoder {
 protected:
-    virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
+    virtual bool onDecode(SkStreamRewindable* stream, SkBitmap* bm, Mode);
 };
 
 // Returns an unpremultiplied version of color. It will have the same ordering and size as an
 // SkPMColor, but the alpha will not be premultiplied.
 static SkPMColor unpremultiply_pmcolor(SkPMColor color) {
     U8CPU a = SkGetPackedA32(color);
     const SkUnPreMultiply::Scale scale = SkUnPreMultiply::GetScale(a);
     return SkPackARGB32NoCheck(a,
                                SkUnPreMultiply::ApplyScale(scale, SkGetPackedR32(color)),
                                SkUnPreMultiply::ApplyScale(scale, SkGetPackedG32(color)),
                                SkUnPreMultiply::ApplyScale(scale, SkGetPackedB32(color)));
 }
 
 #define BITMAP_INFO (kCGBitmapByteOrder32Big | kCGImageAlphaPremultipliedLast)
 
-bool SkImageDecoder_CG::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
+bool SkImageDecoder_CG::onDecode(SkStreamRewindable* stream, SkBitmap* bm, Mode mode) {
     CGImageSourceRef imageSrc = SkStreamToCGImageSource(stream);
 
     if (NULL == imageSrc) {
         return false;
     }
     SkAutoTCallVProc<const void, CFRelease> arsrc(imageSrc);
 
     CGImageRef image = CGImageSourceCreateImageAtIndex(imageSrc, 0, NULL);
     if (NULL == image) {
         return false;
@@ skipping 42 matching lines @@
                 *addr = unpremultiply_pmcolor(*addr);
             }
         }
     }
     bm->unlockPixels();
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-extern SkImageDecoder* image_decoder_from_stream(SkStream*);
+extern SkImageDecoder* image_decoder_from_stream(SkStreamRewindable*);
 
-SkImageDecoder* SkImageDecoder::Factory(SkStream* stream) {
+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(SkStream* stream) {
+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;
 }
 
@@ skipping 126 matching lines @@
 
 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(SkStream *stream) {
+static SkImageDecoder::Format get_format_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 SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_cg);
+static SkTRegistry<SkImageDecoder::Format, SkStreamRewindable*> gFormatReg(get_format_cg);