Make SkPngCodec decode progressively.

src/codec/SkIcoCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBmpCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 168 matching lines @@
 
 /*
  * Creates an instance of the decoder
  * Called only by NewFromStream
  */
 SkIcoCodec::SkIcoCodec(int width, int height, const SkEncodedInfo& info,
                        SkTArray<SkAutoTDelete<SkCodec>, true>* codecs)
     : INHERITED(width, height, info, nullptr)
     , fEmbeddedCodecs(codecs)
     , fCurrScanlineCodec(nullptr)
+    , fCurrIncrementalCodec(nullptr)
 {}
 
 /*
  * Chooses the best dimensions given the desired scale
  */
 SkISize SkIcoCodec::onGetScaledDimensions(float desiredScale) const { 
     // We set the dimensions to the largest candidate image by default.
     // Regardless of the scale request, this is the largest image that we
     // will decode.
     int origWidth = this->getInfo().width();
@@ skipping 83 matching lines @@
     while (true) {
         index = this->chooseCodec(dstInfo.dimensions(), index);
         if (index < 0) {
             break;
         }
 
         SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](index);
         result = embeddedCodec->startScanlineDecode(dstInfo, &options, colorTable, colorCount);
         if (kSuccess == result) {
             fCurrScanlineCodec = embeddedCodec;
+            fCurrIncrementalCodec = nullptr;
             return result;
         }
 
         index++;
     }
 
     SkCodecPrintf("Error: No matching candidate image in ico.\n");
     return result;
 }
 
 int SkIcoCodec::onGetScanlines(void* dst, int count, size_t rowBytes) {
     SkASSERT(fCurrScanlineCodec);
     return fCurrScanlineCodec->getScanlines(dst, count, rowBytes);
 }
 
 bool SkIcoCodec::onSkipScanlines(int count) {
     SkASSERT(fCurrScanlineCodec);
     return fCurrScanlineCodec->skipScanlines(count);
 }
 
+SkCodec::Result SkIcoCodec::onStartIncrementalDecode(const SkImageInfo& dstInfo,
+        const SkCodec::Options& options, SkPMColor* colorTable, int* colorCount) {
+    int index = 0;
+    while (true) {
+        index = this->chooseCodec(dstInfo.dimensions(), index);
+        if (index < 0) {
+            break;
+        }
+
+        SkCodec* embeddedCodec = fEmbeddedCodecs->operator[](index);
+        if (SkCodec::kSuccess == embeddedCodec->startIncrementalDecode(dstInfo,
+                &options, colorTable, colorCount)) {
+            fCurrIncrementalCodec = embeddedCodec;
+            fCurrScanlineCodec = nullptr;
+            return SkCodec::kSuccess;
+        }
+
+        index++;
+    }
+
+    // FIXME: As long as PNG only supports incremental decode and BMP only
+    // supports scanline decoding, which image the client gets depends on
+    // which entry point they use, meaning getScaledDimensions could return
+    // a set of dimensions that is only supported by one or the other.
+    SkCodecPrintf("Error: No matching candidate image in ico.\n");
+    return kInvalidScale;
+}
+
+SkCodec::Result SkIcoCodec::onIncrementalDecode(std::function<void*(int)> callback,
+                                                int* rowsDecoded) {
+    SkASSERT(fCurrIncrementalCodec);
+    return fCurrIncrementalCodec->incrementalDecode(callback, rowsDecoded);
+}
+
 SkCodec::SkScanlineOrder SkIcoCodec::onGetScanlineOrder() const {
     // FIXME: This function will possibly return the wrong value if it is called
-    //        before startScanlineDecode().
-    return fCurrScanlineCodec ? fCurrScanlineCodec->getScanlineOrder() :
-            INHERITED::onGetScanlineOrder();
+    //        before startScanlineDecode()/startIncrementalDecode().
+    if (fCurrScanlineCodec) {
+        SkASSERT(!fCurrIncrementalCodec);
+        return fCurrScanlineCodec->getScanlineOrder();
+    }
+
+    if (fCurrIncrementalCodec) {
+        return fCurrIncrementalCodec->getScanlineOrder();
+    }
+
+    return INHERITED::onGetScanlineOrder();
 }
 
 SkSampler* SkIcoCodec::getSampler(bool createIfNecessary) {
-    return fCurrScanlineCodec ? fCurrScanlineCodec->getSampler(createIfNecessary) : nullptr;
+    if (fCurrScanlineCodec) {
+        SkASSERT(!fCurrIncrementalCodec);
+        return fCurrScanlineCodec->getSampler(createIfNecessary);
+    }
+
+    if (fCurrIncrementalCodec) {
+        return fCurrIncrementalCodec->getSampler(createIfNecessary);
+    }
+
+    return nullptr;
 }