Change SkImageDecoders to take an SkStreamRewindable.

src/images/SkImageDecoder.cpp

 /*
  * Copyright 2006 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 "SkImageDecoder.h"
 #include "SkBitmap.h"
@@ skipping 168 matching lines @@
     } else {
         config = fDefaultPref;
     }
 
     if (SkBitmap::kNo_Config == config) {
         config = SkImageDecoder::GetDeviceConfig();
     }
     return config;
 }
 
-bool SkImageDecoder::decode(SkStream* stream, SkBitmap* bm,
+bool SkImageDecoder::decode(SkStreamRewindable* stream, SkBitmap* bm,
                             SkBitmap::Config pref, Mode mode) {
     // we reset this to false before calling onDecode
     fShouldCancelDecode = false;
     // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
     // pass a temporary bitmap, so that if we return false, we are assured of
     // leaving the caller's bitmap untouched.
     SkBitmap    tmp;
     if (!this->onDecode(stream, &tmp, mode)) {
         return false;
     }
     bm->swap(tmp);
     return true;
 }
 
 bool SkImageDecoder::decodeSubset(SkBitmap* bm, const SkIRect& rect,
                                   SkBitmap::Config pref) {
     // we reset this to false before calling onDecodeSubset
     fShouldCancelDecode = false;
     // assign this, for use by getPrefConfig(), in case fUsePrefTable is false
     fDefaultPref = pref;
 
     return this->onDecodeSubset(bm, rect);
 }
 
-bool SkImageDecoder::buildTileIndex(SkStream* stream,
-                                int *width, int *height) {
+bool SkImageDecoder::buildTileIndex(SkStreamRewindable* stream,
+                                    int *width, int *height) {
     // we reset this to false before calling onBuildTileIndex
     fShouldCancelDecode = false;
 
     return this->onBuildTileIndex(stream, width, height);
 }
 
 bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
                                 int dstX, int dstY, int width, int height,
                                 int srcX, int srcY) {
     int w = width / sampleSize;
@@ skipping 41 matching lines @@
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkImageDecoder::DecodeFile(const char file[], SkBitmap* bm,
                             SkBitmap::Config pref,  Mode mode, Format* format) {
     SkASSERT(file);
     SkASSERT(bm);
 
-    SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(file));
+    SkAutoTUnref<SkStreamRewindable> stream(SkStream::NewFromFile(file));
     if (stream.get()) {
         if (SkImageDecoder::DecodeStream(stream, bm, pref, mode, format)) {
             bm->pixelRef()->setURI(file);
             return true;
         }
     }
     return false;
 }
 
 bool SkImageDecoder::DecodeMemory(const void* buffer, size_t size, SkBitmap* bm,
@@ skipping 40 matching lines @@
 /**
  *  Helper function for DecodeMemoryToTarget. DecodeMemoryToTarget wants
  *  8888, so set the config to it. All parameters must not be null.
  *  @param decoder Decoder appropriate for this stream.
  *  @param stream Rewound stream to the encoded data.
  *  @param bitmap On success, will have its bounds set to the bounds of the
  *      encoded data, and its config set to 8888.
  *  @return True if the bounds were decoded and the bitmap is 8888 or can be
  *      copied to 8888.
  */
-static bool decode_bounds_to_8888(SkImageDecoder* decoder, SkStream* stream,
+static bool decode_bounds_to_8888(SkImageDecoder* decoder, SkStreamRewindable* stream,
                                   SkBitmap* bitmap) {
     SkASSERT(decoder != NULL);
     SkASSERT(stream != NULL);
     SkASSERT(bitmap != NULL);
 
     if (!decoder->decode(stream, bitmap, SkImageDecoder::kDecodeBounds_Mode)) {
         return false;
     }
 
     if (bitmap->config() == SkBitmap::kARGB_8888_Config) {
@@ skipping 12 matching lines @@
  *  Helper function for DecodeMemoryToTarget. Decodes the stream into bitmap, and if
  *  the bitmap is not 8888, then it is copied to 8888. Either way, the end result has
  *  its pixels stored in target. All parameters must not be null.
  *  @param decoder Decoder appropriate for this stream.
  *  @param stream Rewound stream to the encoded data.
  *  @param bitmap On success, will contain the decoded image, with its pixels stored
  *      at target.
  *  @param target Preallocated memory for storing pixels.
  *  @return bool Whether the decode (and copy, if necessary) succeeded.
  */
-static bool decode_pixels_to_8888(SkImageDecoder* decoder, SkStream* stream,
+static bool decode_pixels_to_8888(SkImageDecoder* decoder, SkStreamRewindable* stream,
                                   SkBitmap* bitmap, void* target) {
     SkASSERT(decoder != NULL);
     SkASSERT(stream != NULL);
     SkASSERT(bitmap != NULL);
     SkASSERT(target != NULL);
 
     TargetAllocator allocator(target);
     decoder->setAllocator(&allocator);
 
     bool success = decoder->decode(stream, bitmap, SkImageDecoder::kDecodePixels_Mode);
@@ skipping 54 matching lines @@
         }
         bm.setConfig(bm.config(), bm.width(), bm.height(), target->fRowBytes);
     }
 
     // SkMemoryStream.rewind() will always return true.
     SkAssertResult(stream.rewind());
     return decode_pixels_to_8888(decoder.get(), &stream, &bm, target->fAddr);
 }
 
 
-bool SkImageDecoder::DecodeStream(SkStream* stream, SkBitmap* bm,
-                          SkBitmap::Config pref, Mode mode, Format* format) {
+bool SkImageDecoder::DecodeStream(SkStreamRewindable* stream, SkBitmap* bm,
+                                  SkBitmap::Config pref, Mode mode,
+                                  Format* format) {
     SkASSERT(stream);
     SkASSERT(bm);
 
     bool success = false;
     SkImageDecoder* codec = SkImageDecoder::Factory(stream);
 
     if (NULL != codec) {
         success = codec->decode(stream, bm, pref, mode);
         if (success && format) {
             *format = codec->getFormat();
             if (kUnknown_Format == *format) {
                 if (stream->rewind()) {
                     *format = GetStreamFormat(stream);
                 }
             }
         }
         delete codec;
     }
     return success;
 }