Merge SkCodec with SkScanlineDecoder

src/codec/SkCodec_wbmp.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 "SkCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 78 matching lines @@
 SkCodec::Result SkWbmpCodec::readRow(uint8_t* row) {
     if (this->stream()->read(row, fSrcRowBytes) != fSrcRowBytes) {
         return kIncompleteInput;
     }
     return kSuccess;
 }
 
 SkWbmpCodec::SkWbmpCodec(const SkImageInfo& info, SkStream* stream)
     : INHERITED(info, stream)
     , fSrcRowBytes(get_src_row_bytes(this->getInfo().width()))
+    , fColorTable(nullptr)
+    , fSwizzler(nullptr)
 {}
 
 SkEncodedFormat SkWbmpCodec::onGetEncodedFormat() const {
     return kWBMP_SkEncodedFormat;
 }
 
 SkCodec::Result SkWbmpCodec::onGetPixels(const SkImageInfo& info,
                                          void* dst,
                                          size_t rowBytes,
                                          const Options& options,
                                          SkPMColor ctable[],
                                          int* ctableCount) {
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (info.dimensions() != this->getInfo().dimensions()) {
         return kInvalidScale;
     }
 
     if (!valid_alpha(info.alphaType(), this->getInfo().alphaType())) {
-        return SkCodec::kInvalidConversion;
+        return kInvalidConversion;
     }
 
     // Prepare a color table if necessary
     setup_color_table(info.colorType(), ctable, ctableCount);
 
 
     // Initialize the swizzler
     SkAutoTDelete<SkSwizzler> swizzler(this->initializeSwizzler(info, ctable, options));
     if (nullptr == swizzler.get()) {
         return kInvalidConversion;
@@ skipping 22 matching lines @@
     SkAutoTDelete<SkStream> streamDeleter(stream);
     SkISize size;
     if (!read_header(stream, &size)) {
         return nullptr;
     }
     SkImageInfo info = SkImageInfo::Make(size.width(), size.height(),
             kGray_8_SkColorType, kOpaque_SkAlphaType);
     return new SkWbmpCodec(info, streamDeleter.detach());
 }
 
-class SkWbmpScanlineDecoder : public SkScanlineDecoder {
-public:
-    /*
-     * Takes ownership of all pointer paramters.
-     */
-    SkWbmpScanlineDecoder(SkWbmpCodec* codec)
-        : INHERITED(codec->getInfo())
-        , fCodec(codec)
-        , fColorTable(nullptr)
-        , fSwizzler(nullptr)
-        , fSrcBuffer(codec->fSrcRowBytes)
-    {}
+SkCodec::Result SkWbmpCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
+    void* dstRow = dst;
+    for (int y = 0; y < count; ++y) {
+        Result rowResult = this->readRow(fSrcBuffer.get());
+        if (kSuccess != rowResult) {
+            return rowResult;
+        }
+        fSwizzler->swizzle(dstRow, fSrcBuffer.get());
+        dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
+    }
+    return kSuccess;
+}
 
-    SkCodec::Result onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
-        void* dstRow = dst;
-        for (int y = 0; y < count; ++y) {
-            SkCodec::Result rowResult = fCodec->readRow(fSrcBuffer.get());
-            if (SkCodec::kSuccess != rowResult) {
-                return rowResult;
-            }
-            fSwizzler->swizzle(dstRow, fSrcBuffer.get());
-            dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
+SkCodec::Result SkWbmpCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
+        const Options& options, SkPMColor inputColorTable[], int* inputColorCount) {
+    if (!this->rewindIfNeeded()) {
+        return kCouldNotRewind;
+    }
+    if (options.fSubset) {
+        // Subsets are not supported.
+        return kUnimplemented;
+    }
+    if (dstInfo.dimensions() != this->getInfo().dimensions()) {
+        if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
+                return kInvalidScale;
         }
-        return SkCodec::kSuccess;
     }
 
-    SkCodec::Result onStart(const SkImageInfo& dstInfo,
-            const SkCodec::Options& options, SkPMColor inputColorTable[],
-            int* inputColorCount) {
-        if (!fCodec->rewindIfNeeded()) {
-            return SkCodec::kCouldNotRewind;
-        }
-        if (options.fSubset) {
-            // Subsets are not supported.
-            return SkCodec::kUnimplemented;
-        }
-        if (dstInfo.dimensions() != this->getInfo().dimensions()) {
-            if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
-                return SkCodec::kInvalidScale;
-            }
-        }
-
-        if (!valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType())) {
-            return SkCodec::kInvalidConversion;
-        }
-
-        // Fill in the color table
-        setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
-
-        // Copy the color table to a pointer that can be owned by the scanline decoder
-        if (kIndex_8_SkColorType == dstInfo.colorType()) {
-            fColorTable.reset(new SkColorTable(inputColorTable, 2));
-        }
-
-        // Initialize the swizzler
-        fSwizzler.reset(fCodec->initializeSwizzler(dstInfo,
-                get_color_ptr(fColorTable.get()), options));
-        if (nullptr == fSwizzler.get()) {
-            return SkCodec::kInvalidConversion;
-        }
-
-        return SkCodec::kSuccess;
+    if (!valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType())) {
+        return kInvalidConversion;
     }
 
-    SkEncodedFormat onGetEncodedFormat() const {
-        return kWBMP_SkEncodedFormat;
+    // Fill in the color table
+    setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
+
+    // Copy the color table to a pointer that can be owned by the scanline decoder
+    if (kIndex_8_SkColorType == dstInfo.colorType()) {
+        fColorTable.reset(new SkColorTable(inputColorTable, 2));
     }
 
-private:
-    SkAutoTDelete<SkWbmpCodec>   fCodec;
-    SkAutoTUnref<SkColorTable>   fColorTable;
-    SkAutoTDelete<SkSwizzler>    fSwizzler;
-    SkAutoTMalloc<uint8_t>       fSrcBuffer;
-
-    typedef SkScanlineDecoder INHERITED;
-};
-
-SkScanlineDecoder* SkWbmpCodec::NewSDFromStream(SkStream* stream) {
-    SkAutoTDelete<SkWbmpCodec> codec(static_cast<SkWbmpCodec*>(
-            SkWbmpCodec::NewFromStream(stream)));
-    if (!codec) {
-        return nullptr;
+    // Initialize the swizzler
+    fSwizzler.reset(this->initializeSwizzler(dstInfo,
+            get_color_ptr(fColorTable.get()), options));
+    if (nullptr == fSwizzler.get()) {
+        return kInvalidConversion;
     }
 
-    // Return the new scanline decoder
-    return new SkWbmpScanlineDecoder(codec.detach());
+    fSrcBuffer.reset(fSrcRowBytes);
+
+    return kSuccess;
 }
+