Fill incomplete images in SkCodec parent class

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 89 matching lines @@
 
 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) {
+                                         int* ctableCount,
+                                         int* incompleteScanlines) {
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (info.dimensions() != this->getInfo().dimensions()) {
         return kInvalidScale;
     }
@@ skipping 12 matching lines @@
         return kInvalidConversion;
     }
 
     // Perform the decode
     SkISize size = info.dimensions();
     SkAutoTMalloc<uint8_t> src(fSrcRowBytes);
     void* dstRow = dst;
     for (int y = 0; y < size.height(); ++y) {
         Result rowResult = this->readRow(src.get());
         if (kSuccess != rowResult) {
+            *incompleteScanlines = size.height() - y;
             return rowResult;
         }
         swizzler->swizzle(dstRow, src.get());
         dstRow = SkTAddOffset<void>(dstRow, rowBytes);
     }
     return kSuccess;
 }
 
 bool SkWbmpCodec::IsWbmp(SkStream* stream) {
     return read_header(stream, nullptr);
 }
 
 SkCodec* SkWbmpCodec::NewFromStream(SkStream* stream) {
     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())
+        : INHERITED(codec, codec->getInfo())
         , fCodec(codec)
         , fColorTable(nullptr)
         , fSwizzler(nullptr)
         , fSrcBuffer(codec->fSrcRowBytes)
     {}
 
-    SkCodec::Result onGetScanlines(void* dst, int count, size_t dstRowBytes) override {
+    uint32_t 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;
+                return y;
             }
             fSwizzler->swizzle(dstRow, fSrcBuffer.get());
             dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
         }
-        return SkCodec::kSuccess;
+        return count;
     }
 
     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.
@@ skipping 25 matching lines @@
         }
 
         return SkCodec::kSuccess;
     }
 
     SkEncodedFormat onGetEncodedFormat() const {
         return kWBMP_SkEncodedFormat;
     }
 
 private:
-    SkAutoTDelete<SkWbmpCodec>   fCodec;
+    SkWbmpCodec*                 fCodec; // Owned by parent class
     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;
     }
 
     // Return the new scanline decoder
     return new SkWbmpScanlineDecoder(codec.detach());
 }