Change SkImageDecoders to take an SkStreamRewindable.

src/ports/SkImageDecoder_WIC.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #define WIN32_LEAN_AND_MEAN
@@ skipping 21 matching lines @@
 public:
     // Decoding modes corresponding to SkImageDecoder::Mode, plus an extra mode for decoding
     // only the format.
     enum WICModes {
         kDecodeFormat_WICMode,
         kDecodeBounds_WICMode,
         kDecodePixels_WICMode,
     };
 
     /**
-     *  Helper function to decode an SkStream.
-     *  @param stream SkStream to decode. Must be at the beginning.
+     *  Helper function to decode an SkStreamRewindable.
+     *  @param stream SkStreamRewindable to decode. Must be at the beginning.
      *  @param bm   SkBitmap to decode into. Only used if wicMode is kDecodeBounds_WICMode or
      *      kDecodePixels_WICMode, in which case it must not be NULL.
-     *  @param format Out parameter for the SkImageDecoder::Format of the SkStream. Only used if
-     *      wicMode is kDecodeFormat_WICMode.
+     *  @param format Out parameter for the SkImageDecoder::Format of the SkStreamRewindable.
+     *      Only used if wicMode is kDecodeFormat_WICMode.
      */
-    bool decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode, Format* format) const;
+    bool decodeStream(SkStreamRewindable* stream, SkBitmap* bm, WICModes wicMode,
+                      Format* format) const;
 
 protected:
-    virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
+    virtual bool onDecode(SkStreamRewindable* stream, SkBitmap* bm, Mode mode) SK_OVERRIDE;
 };
 
 struct FormatConversion {
     GUID                    fGuidFormat;
     SkImageDecoder::Format  fFormat;
 };
 
 static const FormatConversion gFormatConversions[] = {
     { GUID_ContainerFormatBmp, SkImageDecoder::kBMP_Format },
     { GUID_ContainerFormatGif, SkImageDecoder::kGIF_Format },
     { GUID_ContainerFormatIco, SkImageDecoder::kICO_Format },
     { GUID_ContainerFormatJpeg, SkImageDecoder::kJPEG_Format },
     { GUID_ContainerFormatPng, SkImageDecoder::kPNG_Format },
 };
 
 static SkImageDecoder::Format GuidContainerFormat_to_Format(REFGUID guid) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gFormatConversions); i++) {
         if (IsEqualGUID(guid, gFormatConversions[i].fGuidFormat)) {
             return gFormatConversions[i].fFormat;
         }
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
-bool SkImageDecoder_WIC::onDecode(SkStream* stream, SkBitmap* bm, Mode mode) {
+bool SkImageDecoder_WIC::onDecode(SkStreamRewindable* stream, SkBitmap* bm, Mode mode) {
     WICModes wicMode;
     switch (mode) {
         case SkImageDecoder::kDecodeBounds_Mode:
             wicMode = kDecodeBounds_WICMode;
             break;
         case SkImageDecoder::kDecodePixels_Mode:
             wicMode = kDecodePixels_WICMode;
             break;
     }
     return this->decodeStream(stream, bm, wicMode, NULL);
 }
 
-bool SkImageDecoder_WIC::decodeStream(SkStream* stream, SkBitmap* bm, WICModes wicMode,
+bool SkImageDecoder_WIC::decodeStream(SkStreamRewindable* stream, SkBitmap* bm, WICModes wicMode,
                                       Format* format) const {
     //Initialize COM.
     SkAutoCoInitialize scopedCo;
     if (!scopedCo.succeeded()) {
         return false;
     }
 
     HRESULT hr = S_OK;
 
     //Create Windows Imaging Component ImagingFactory.
     SkTScopedComPtr<IWICImagingFactory> piImagingFactory;
     if (SUCCEEDED(hr)) {
         hr = CoCreateInstance(
             CLSID_WICImagingFactory
             , NULL
             , CLSCTX_INPROC_SERVER
             , IID_PPV_ARGS(&piImagingFactory)
         );
     }
 
-    //Convert SkStream to IStream.
+    //Convert SkStreamRewindable to IStream.
     SkTScopedComPtr<IStream> piStream;
     if (SUCCEEDED(hr)) {
         hr = SkIStream::CreateFromSkStream(stream, false, &piStream);
     }
 
     //Make sure we're at the beginning of the stream.
     if (SUCCEEDED(hr)) {
         LARGE_INTEGER liBeginning = { 0 };
         hr = piStream->Seek(liBeginning, STREAM_SEEK_SET, NULL);
     }
@@ skipping 101 matching lines @@
 
         // Note: we don't need to premultiply here since we specified PBGRA
         bm->computeAndSetOpaquePredicate();
     }
 
     return SUCCEEDED(hr);
 }
 
 /////////////////////////////////////////////////////////////////////////
 
-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_WIC.
         return SkNEW(SkImageDecoder_WIC);
     } else {
         return decoder;
     }
 }
 
 /////////////////////////////////////////////////////////////////////////
 
-SkMovie* SkMovie::DecodeStream(SkStream* stream) {
+SkMovie* SkMovie::DecodeStream(SkStreamRewindable* stream) {
     return NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////
 
 class SkImageEncoder_WIC : public SkImageEncoder {
 public:
     SkImageEncoder_WIC(Type t) : fType(t) {}
 
 protected:
@@ skipping 169 matching lines @@
         case SkImageEncoder::kPNG_Type:
             break;
         default:
             return NULL;
     }
     return SkNEW_ARGS(SkImageEncoder_WIC, (t));
 }
 
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_imageencoder_wic_factory);
 
-static SkImageDecoder::Format get_format_wic(SkStream* stream) {
+static SkImageDecoder::Format get_format_wic(SkStreamRewindable* stream) {
     SkImageDecoder::Format format;
     SkImageDecoder_WIC codec;
     if (!codec.decodeStream(stream, NULL, SkImageDecoder_WIC::kDecodeFormat_WICMode, &format)) {
         format = SkImageDecoder::kUnknown_Format;
     }
     return format;
 }
 
-static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_wic);
+static SkTRegistry<SkImageDecoder::Format, SkStreamRewindable*> gFormatReg(get_format_wic);