Revert of 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"
 #include "SkData.h"
 #include "SkIcoCodec.h"
 #include "SkPngCodec.h"
 #include "SkStream.h"
 #include "SkTDArray.h"
 #include "SkTSort.h"
 
-#ifdef SK_HAS_PNG_LIBRARY
 /*
  * Checks the start of the stream to see if the image is an Ico or Cur
  */
 bool SkIcoCodec::IsIco(const void* buffer, size_t bytesRead) {
     const char icoSig[] = { '\x00', '\x00', '\x01', '\x00' };
     const char curSig[] = { '\x00', '\x00', '\x02', '\x00' };
     return bytesRead >= sizeof(icoSig) &&
             (!memcmp(buffer, icoSig, sizeof(icoSig)) ||
             !memcmp(buffer, curSig, sizeof(curSig)));
 }
@@ skipping 151 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,
-        void* pixels, size_t rowBytes, 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);
-        switch (embeddedCodec->startIncrementalDecode(dstInfo,
-                pixels, rowBytes, &options, colorTable, colorCount)) {
-            case kSuccess:
-                fCurrIncrementalCodec = embeddedCodec;
-                fCurrScanlineCodec = nullptr;
-                return kSuccess;
-            case kUnimplemented:
-                // FIXME: embeddedCodec is a BMP. If scanline decoding would work,
-                // return kUnimplemented so that SkSampledCodec will fall through
-                // to use the scanline decoder.
-                // Note that calling startScanlineDecode will require an extra
-                // rewind. The embedded codec has an SkMemoryStream, which is
-                // cheap to rewind, though it will do extra work re-reading the
-                // header.
-                // Also note that we pass nullptr for Options. This is because
-                // Options that are valid for incremental decoding may not be
-                // valid for scanline decoding.
-                // Once BMP supports incremental decoding this workaround can go
-                // away.
-                if (embeddedCodec->startScanlineDecode(dstInfo, nullptr,
-                        colorTable, colorCount) == kSuccess) {
-                    return kUnimplemented;
-                }
-                // Move on to the next embedded codec.
-                break;
-            default:
-                break;
-        }
-
-        index++;
-    }
-
-    SkCodecPrintf("Error: No matching candidate image in ico.\n");
-    return kInvalidScale;
-}
-
-SkCodec::Result SkIcoCodec::onIncrementalDecode(int* rowsDecoded) {
-    SkASSERT(fCurrIncrementalCodec);
-    return fCurrIncrementalCodec->incrementalDecode(rowsDecoded);
-}
-
 SkCodec::SkScanlineOrder SkIcoCodec::onGetScanlineOrder() const {
     // FIXME: This function will possibly return the wrong value if it is called
-    //        before startScanlineDecode()/startIncrementalDecode().
-    if (fCurrScanlineCodec) {
-        SkASSERT(!fCurrIncrementalCodec);
-        return fCurrScanlineCodec->getScanlineOrder();
-    }
-
-    if (fCurrIncrementalCodec) {
-        return fCurrIncrementalCodec->getScanlineOrder();
-    }
-
-    return INHERITED::onGetScanlineOrder();
+    //        before startScanlineDecode().
+    return fCurrScanlineCodec ? fCurrScanlineCodec->getScanlineOrder() :
+            INHERITED::onGetScanlineOrder();
 }
 
 SkSampler* SkIcoCodec::getSampler(bool createIfNecessary) {
-    if (fCurrScanlineCodec) {
-        SkASSERT(!fCurrIncrementalCodec);
-        return fCurrScanlineCodec->getSampler(createIfNecessary);
-    }
-
-    if (fCurrIncrementalCodec) {
-        return fCurrIncrementalCodec->getSampler(createIfNecessary);
-    }
-
-    return nullptr;
+    return fCurrScanlineCodec ? fCurrScanlineCodec->getSampler(createIfNecessary) : nullptr;
 }
-#endif // SK_HAS_PNG_LIBRARY