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 68 matching lines @@
         case kN32_SkColorType:
         case kRGB_565_SkColorType:
         case kGray_8_SkColorType:
             return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized, 
                                               this->getInfo());
         default:
             return nullptr;
     }
 }
 
-SkCodec::Result SkWbmpCodec::readRow(uint8_t* row) {
-    if (this->stream()->read(row, fSrcRowBytes) != fSrcRowBytes) {
-        return kIncompleteInput;
-    }
-    return kSuccess;
+bool SkWbmpCodec::readRow(uint8_t* row) {
+    return this->stream()->read(row, fSrcRowBytes) == fSrcRowBytes;
 }
 
 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) {
+                                         int* ctableCount,
+                                         int* rowsDecoded) {
     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 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;
     }
 
     // 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) {
-            return rowResult;
+        if (!this->readRow(src.get())) {
+            *rowsDecoded = y;
+            return kIncompleteInput;
         }
         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());
 }
 
-SkCodec::Result SkWbmpCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
+int 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;
+        if (!this->readRow(fSrcBuffer.get())) {
+            return y;
         }
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
         dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
     }
-    return kSuccess;
+    return count;
 }
 
 SkCodec::Result SkWbmpCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
         const Options& options, SkPMColor inputColorTable[], int* inputColorCount) {
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
@@ skipping 17 matching lines @@
     fSwizzler.reset(this->initializeSwizzler(dstInfo,
             get_color_ptr(fColorTable.get()), options));
     if (nullptr == fSwizzler.get()) {
         return kInvalidConversion;
     }
 
     fSrcBuffer.reset(fSrcRowBytes);
 
     return kSuccess;
 }
-