Change SkImageDecoders to take an SkStreamRewindable.

src/images/SkImageDecoder_libwebp.cpp

 /*
  * Copyright 2010, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
@@ skipping 40 matching lines @@
 
 // Define VP8 I/O on top of Skia stream
 
 //////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////
 
 static const size_t WEBP_VP8_HEADER_SIZE = 64;
 static const size_t WEBP_IDECODE_BUFFER_SZ = (1 << 16);
 
 // Parse headers of RIFF container, and check for valid Webp (VP8) content.
-static bool webp_parse_header(SkStream* stream, int* width, int* height, int* alpha) {
+static bool webp_parse_header(SkStreamRewindable* stream, int* width, int* height, int* alpha) {
     unsigned char buffer[WEBP_VP8_HEADER_SIZE];
     size_t bytesToRead = WEBP_VP8_HEADER_SIZE;
     size_t totalBytesRead = 0;
     do {
         unsigned char* dst = buffer + totalBytesRead;
         const size_t bytesRead = stream->read(dst, bytesToRead);
         if (0 == bytesRead) {
             // Could not read any bytes. Check to see if we are at the end (exit
             // condition), and continue reading if not. Important for streams
             // that do not have all the data ready.
@@ skipping 38 matching lines @@
     }
     virtual ~SkWEBPImageDecoder() {
         SkSafeUnref(fInputStream);
     }
 
     virtual Format getFormat() const SK_OVERRIDE {
         return kWEBP_Format;
     }
 
 protected:
-    virtual bool onBuildTileIndex(SkStream *stream, int *width, int *height) SK_OVERRIDE;
+    virtual bool onBuildTileIndex(SkStreamRewindable *stream, int *width, int *height) SK_OVERRIDE;
     virtual bool onDecodeSubset(SkBitmap* bitmap, const SkIRect& rect) SK_OVERRIDE;
-    virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
+    virtual bool onDecode(SkStreamRewindable* stream, SkBitmap* bm, Mode) SK_OVERRIDE;
 
 private:
     /**
      *  Called when determining the output config to request to webp.
      *  If the image does not have alpha, there is no need to premultiply.
      *  If the caller wants unpremultiplied colors, that is respected.
      */
     bool shouldPremultiply() const {
         return SkToBool(fHasAlpha) && !this->getRequireUnpremultipliedColors();
     }
 
     bool setDecodeConfig(SkBitmap* decodedBitmap, int width, int height);
 
-    SkStream* fInputStream;
-    int fOrigWidth;
-    int fOrigHeight;
-    int fHasAlpha;
+    SkStreamRewindable* fInputStream;
+    int                 fOrigWidth;
+    int                 fOrigHeight;
+    int                 fHasAlpha;

[bungeman-skia, 2013/09/19 16:15:49]

Vertical aligning declarations (aka table style declarations) are an eyesore.
There, I said it. This drives me crazy. What possible reason does it have? Sure,
I can read off all of the names a bit easier, but why would I care about that?
What I really want to know when looking at a name is what type it is, the name
can be anything (and often is) but the type should mean something.

I also firmly believe that no one should ever use the right binding form of
'const' in a declaration, and that * and & should always be closer to the name
than the type (since that's the actual syntactic binding; Google Style Guide
allows placing next to type or name). So maybe I'm just crazy.

Since I'm looking for justification, the Google Style Guide doen't directly back
me up on this, but the example at
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Variab...
implies that one should not use table style for declarations. The Skia style
guide shows some table style assignments, but no table style declarations. I'm
sometimes ok with the table style assignments.

[scroggo, 2013/09/25 20:25:09]

I could have sworn this was in our style guide. It's certainly something we do a
lot in the Skia code base. I thought reed@ liked it. Mike?
Personally I like the * next to the type, since an SkStreamRewindable* is
different from an SkStreamRewindable. 

 
     typedef SkImageDecoder INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////
 
 #ifdef TIME_DECODE
 
 #include "SkTime.h"
 
@@ skipping 35 matching lines @@
         mode = premultiply ? MODE_rgbA_4444 : MODE_RGBA_4444;
     } else if (config == SkBitmap::kRGB_565_Config) {
         mode = MODE_RGB_565;
     }
     SkASSERT(MODE_LAST != mode);
     return mode;
 }
 
 // Incremental WebP image decoding. Reads input buffer of 64K size iteratively
 // and decodes this block to appropriate color-space as per config object.
-static bool webp_idecode(SkStream* stream, WebPDecoderConfig* config) {
+static bool webp_idecode(SkStreamRewindable* stream, WebPDecoderConfig* config) {
     WebPIDecoder* idec = WebPIDecode(NULL, 0, config);
     if (NULL == idec) {
         WebPFreeDecBuffer(&config->output);
         return false;
     }
 
     if (!stream->rewind()) {
         SkDebugf("Failed to rewind webp stream!");
         return false;
     }
@@ skipping 94 matching lines @@
         return false;
     }
 
     decodedBitmap->setConfig(config, width, height, 0);
 
     decodedBitmap->setIsOpaque(!fHasAlpha);
 
     return true;
 }
 
-bool SkWEBPImageDecoder::onBuildTileIndex(SkStream* stream,
+bool SkWEBPImageDecoder::onBuildTileIndex(SkStreamRewindable* stream,
                                           int *width, int *height) {
     int origWidth, origHeight, hasAlpha;
     if (!webp_parse_header(stream, &origWidth, &origHeight, &hasAlpha)) {
         return false;
     }
 
     if (!stream->rewind()) {
         SkDebugf("Failed to rewind webp stream!");
         return false;
     }
@@ skipping 79 matching lines @@
         return false;
     }
 
     if (!directDecode) {
         cropBitmap(decodedBitmap, bitmap, sampleSize, region.x(), region.y(),
                    region.width(), region.height(), rect.x(), rect.y());
     }
     return true;
 }
 
-bool SkWEBPImageDecoder::onDecode(SkStream* stream, SkBitmap* decodedBitmap,
+bool SkWEBPImageDecoder::onDecode(SkStreamRewindable* stream, SkBitmap* decodedBitmap,
                                   Mode mode) {
 #ifdef TIME_DECODE
     AutoTimeMillis atm("WEBP Decode");
 #endif
 
     int origWidth, origHeight, hasAlpha;
     if (!webp_parse_header(stream, &origWidth, &origHeight, &hasAlpha)) {
         return false;
     }
     this->fHasAlpha = hasAlpha;
@@ skipping 156 matching lines @@
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 DEFINE_DECODER_CREATOR(WEBPImageDecoder);
 DEFINE_ENCODER_CREATOR(WEBPImageEncoder);
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkTRegistry.h"
 
-static SkImageDecoder* sk_libwebp_dfactory(SkStream* stream) {
+static SkImageDecoder* sk_libwebp_dfactory(SkStreamRewindable* stream) {
     int width, height, hasAlpha;
     if (!webp_parse_header(stream, &width, &height, &hasAlpha)) {
         return NULL;
     }
 
     // Magic matches, call decoder
     return SkNEW(SkWEBPImageDecoder);
 }
 
-static SkImageDecoder::Format get_format_webp(SkStream* stream) {
+static SkImageDecoder::Format get_format_webp(SkStreamRewindable* stream) {
     int width, height, hasAlpha;
     if (webp_parse_header(stream, &width, &height, &hasAlpha)) {
         return SkImageDecoder::kWEBP_Format;
     }
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libwebp_efactory(SkImageEncoder::Type t) {
       return (SkImageEncoder::kWEBP_Type == t) ? SkNEW(SkWEBPImageEncoder) : NULL;
 }
 
-static SkTRegistry<SkImageDecoder*, SkStream*> gDReg(sk_libwebp_dfactory);
-static SkTRegistry<SkImageDecoder::Format, SkStream*> gFormatReg(get_format_webp);
+static SkTRegistry<SkImageDecoder*, SkStreamRewindable*> gDReg(sk_libwebp_dfactory);
+static SkTRegistry<SkImageDecoder::Format, SkStreamRewindable*> gFormatReg(get_format_webp);
 static SkTRegistry<SkImageEncoder*, SkImageEncoder::Type> gEReg(sk_libwebp_efactory);