Change SkImageDecoders to take an SkStreamRewindable.

include/core/SkImageDecoder.h

 
 /*
  * 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.
  */
 
 
 #ifndef SkImageDecoder_DEFINED
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
 #include "SkBitmapFactory.h"
 #include "SkImage.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 #include "SkTypes.h"
 
-class SkStream;
+class SkStreamRewindable;
 
 /** \class SkImageDecoder
 
     Base class for decoding compressed images into a SkBitmap
 */
 class SkImageDecoder : public SkNoncopyable {
 public:
     virtual ~SkImageDecoder();
 
     enum Format {
         kUnknown_Format,
         kBMP_Format,
         kGIF_Format,
         kICO_Format,
         kJPEG_Format,
         kPNG_Format,
         kWBMP_Format,
         kWEBP_Format,
 
         kLastKnownFormat = kWEBP_Format,
     };
 
     /** Return the format of image this decoder can decode. If this decoder can decode multiple
         formats, kUnknown_Format will be returned.
     */
     virtual Format getFormat() const;
 
-    /** Return the format of the SkStream or kUnknown_Format if it cannot be determined. Rewinds the
-        stream before returning.
+    /** Return the format of the SkStreamRewindable or kUnknown_Format if it cannot be determined.
+        Rewinds the stream before returning.
     */
-    static Format GetStreamFormat(SkStream*);
+    static Format GetStreamFormat(SkStreamRewindable*);
 
     /** Return a readable string of the Format provided.
     */
     static const char* GetFormatName(Format);
 
     /** Return a readable string of the value returned by getFormat().
     */
     const char* getFormatName() const;
 
     /** Returns true if the decoder should try to dither the resulting image.
@@ skipping 208 matching lines @@
         used to allocate the pixel memory. A clever allocator can be used
         to allocate the memory from a cache, volatile memory, or even from
         an existing bitmap's memory.
 
         If a Peeker is installed via setPeeker, it may be used to peek into
         meta data during the decode.
 
         If a Chooser is installed via setChooser, it may be used to select
         which image to return from a format that contains multiple images.
     */
-    bool decode(SkStream*, SkBitmap* bitmap, SkBitmap::Config pref, Mode);
-    bool decode(SkStream* stream, SkBitmap* bitmap, Mode mode) {
+    bool decode(SkStreamRewindable*, SkBitmap* bitmap, SkBitmap::Config pref, Mode);
+    bool decode(SkStreamRewindable* stream, SkBitmap* bitmap, Mode mode) {
         return this->decode(stream, bitmap, SkBitmap::kNo_Config, mode);
     }
 
     /**
      * Given a stream, build an index for doing tile-based decode.
      * The built index will be saved in the decoder, and the image size will
      * be returned in width and height.
      *
      * Return true for success or false on failure.
      */
-    bool buildTileIndex(SkStream*, int *width, int *height);
+    bool buildTileIndex(SkStreamRewindable*, int *width, int *height);
 
     /**
      * Decode a rectangle subset in the image.
      * The method can only be called after buildTileIndex().
      *
      * Return true for success.
      * Return false if the index is never built or failing in decoding.
      */
     bool decodeSubset(SkBitmap* bm, const SkIRect& subset, SkBitmap::Config pref);
 
     /**
      *  @Deprecated
      *  Use decodeSubset instead.
      */
     bool decodeRegion(SkBitmap* bitmap, const SkIRect& rect, SkBitmap::Config pref) {
         return this->decodeSubset(bitmap, rect, pref);
     }
 
     /** Given a stream, this will try to find an appropriate decoder object.
         If none is found, the method returns NULL.
     */
-    static SkImageDecoder* Factory(SkStream*);
+    static SkImageDecoder* Factory(SkStreamRewindable*);
 
     /** Decode the image stored in the specified file, and store the result
         in bitmap. Return true for success or false on failure.
 
         @param prefConfig If the PrefConfigTable is not set, prefer this config.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                       of the decoded file. On failure it is ignored.
     */
@@ skipping 41 matching lines @@
      *      target.fAddr = malloc/other allocation
      *      target.fRowBytes = ...
      *      // Now decode the actual pixels into target. &info is optional,
      *      // and could be NULL
      *      success = DecodeMemoryToTarget(src, size, &info, &target);
      *  </code>
      */
     static bool DecodeMemoryToTarget(const void* buffer, size_t size, SkImage::Info* info,
                                      const SkBitmapFactory::Target* target);
 
-    /** Decode the image stored in the specified SkStream, and store the result
+    /** Decode the image stored in the specified SkStreamRewindable, and store the result
         in bitmap. Return true for success or false on failure.
 
         @param prefConfig If the PrefConfigTable is not set, prefer this config.
                           See NOTE ABOUT PREFERRED CONFIGS.
 
         @param format On success, if format is non-null, it is set to the format
                       of the decoded stream. On failure it is ignored.
      */
-    static bool DecodeStream(SkStream* stream, SkBitmap* bitmap,
+    static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap,
                              SkBitmap::Config prefConfig, Mode,
                              Format* format = NULL);
-    static bool DecodeStream(SkStream* stream, SkBitmap* bitmap) {
+    static bool DecodeStream(SkStreamRewindable* stream, SkBitmap* bitmap) {
         return DecodeStream(stream, bitmap, SkBitmap::kNo_Config,
                             kDecodePixels_Mode, NULL);
     }
 
     /** Return the default config for the running device.
         Currently this used as a suggestion to image decoders that need to guess
         what config they should decode into.
         Default is kNo_Config, but this can be changed with SetDeviceConfig()
     */
     static SkBitmap::Config GetDeviceConfig();
     /** Set the default config for the running device.
         Currently this used as a suggestion to image decoders that need to guess
         what config they should decode into.
         Default is kNo_Config.
         This can be queried with GetDeviceConfig()
     */
     static void SetDeviceConfig(SkBitmap::Config);
 
 protected:
     // must be overridden in subclasses. This guy is called by decode(...)
-    virtual bool onDecode(SkStream*, SkBitmap* bitmap, Mode) = 0;
+    virtual bool onDecode(SkStreamRewindable*, SkBitmap* bitmap, Mode) = 0;
 
     // If the decoder wants to support tiled based decoding,
     // this method must be overridden. This guy is called by buildTileIndex(...)
-    virtual bool onBuildTileIndex(SkStream*, int *width, int *height) {
+    virtual bool onBuildTileIndex(SkStreamRewindable*, int *width, int *height) {
         return false;
     }
 
     // If the decoder wants to support tiled based decoding,
     // this method must be overridden. This guy is called by decodeRegion(...)
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) {
         return false;
     }
 
     /*
@@ skipping 90 matching lines @@
 /** Calling newDecoder with a stream returns a new matching imagedecoder
     instance, or NULL if none can be found. The caller must manage its ownership
     of the stream as usual, calling unref() when it is done, as the returned
     decoder may have called ref() (and if so, the decoder is responsible for
     balancing its ownership when it is destroyed).
  */
 class SkImageDecoderFactory : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkImageDecoderFactory)
 
-    virtual SkImageDecoder* newDecoder(SkStream*) = 0;
+    virtual SkImageDecoder* newDecoder(SkStreamRewindable*) = 0;
 
 private:
     typedef SkRefCnt INHERITED;
 };
 
 class SkDefaultImageDecoderFactory : SkImageDecoderFactory {
 public:
     // calls SkImageDecoder::Factory(stream)
-    virtual SkImageDecoder* newDecoder(SkStream* stream) {
+    virtual SkImageDecoder* newDecoder(SkStreamRewindable* stream) {
         return SkImageDecoder::Factory(stream);
     }
 };
 
 // This macro declares a global (i.e., non-class owned) creation entry point
 // for each decoder (e.g., CreateJPEGImageDecoder)
 #define DECLARE_DECODER_CREATOR(codec)          \
     SkImageDecoder *Create ## codec ();
 
 // This macro defines the global creation entry point for each decoder. Each
 // decoder implementation that registers with the decoder factory must call it.
 #define DEFINE_DECODER_CREATOR(codec)           \
     SkImageDecoder *Create ## codec () {        \
         return SkNEW( Sk ## codec );            \
     }
 
 // All the decoders known by Skia. Note that, depending on the compiler settings,
 // not all of these will be available
 DECLARE_DECODER_CREATOR(BMPImageDecoder);
 DECLARE_DECODER_CREATOR(GIFImageDecoder);
 DECLARE_DECODER_CREATOR(ICOImageDecoder);
 DECLARE_DECODER_CREATOR(JPEGImageDecoder);
 DECLARE_DECODER_CREATOR(PNGImageDecoder);
 DECLARE_DECODER_CREATOR(WBMPImageDecoder);
 DECLARE_DECODER_CREATOR(WEBPImageDecoder);
 
 #endif