Fill incomplete images in SkCodec parent class

src/codec/SkBmpMaskCodec.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 "SkBmpMaskCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 11 matching lines @@
     , fSrcBuffer(new uint8_t [fSrcRowBytes])
 {}
 
 /*
  * Initiates the bitmap decode
  */
 SkCodec::Result SkBmpMaskCodec::onGetPixels(const SkImageInfo& dstInfo,
                                             void* dst, size_t dstRowBytes,
                                             const Options& opts,
                                             SkPMColor* inputColorPtr,
-                                            int* inputColorCount) {
+                                            int* inputColorCount,
+                                            int* incompleteScanlines) {
     if (!this->rewindIfNeeded()) {
         return kCouldNotRewind;
     }
     if (opts.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         SkCodecPrintf("Error: scaling not supported.\n");
         return kInvalidScale;
     }
 
     if (!conversion_possible(dstInfo, this->getInfo())) {
         SkCodecPrintf("Error: cannot convert input type to output type.\n");
         return kInvalidConversion;
     }
 
     Result result = this->prepareToDecode(dstInfo, opts, inputColorPtr, inputColorCount);
     if (kSuccess != result) {
         return result;
     }
 
-    return this->decodeRows(dstInfo, dst, dstRowBytes, opts);
+    uint32_t rows = this->decodeRows(dstInfo, dst, dstRowBytes, opts);
+    if (rows != dstInfo.height()) {
+        *incompleteScanlines = dstInfo.height() - rows;

[scroggo, 2015/09/25 15:55:05]

It's a little weird to me that onGetScanlines returns the number of rows that
were decoded, and onGetPixels returns the number that were *not* decoded. I
think this would be better to return the number successfully decoded. This means
you don't need to subtract here (and presumably, in the other subclasses), but
can subtract once in the base class.

[msarett, 2015/10/01 12:44:52]

Done.

+        return kIncompleteInput;
+    }
+    return kSuccess;
 }
 
 bool SkBmpMaskCodec::initializeSwizzler(const SkImageInfo& dstInfo) {
     // Create the swizzler
     fMaskSwizzler.reset(SkMaskSwizzler::CreateMaskSwizzler(
             dstInfo, this->getInfo(), fMasks, this->bitsPerPixel()));
 
     if (nullptr == fMaskSwizzler.get()) {
         return false;
     }
 
     return true;
 }
 
 SkCodec::Result SkBmpMaskCodec::prepareToDecode(const SkImageInfo& dstInfo,
         const SkCodec::Options& options, SkPMColor inputColorPtr[], int* inputColorCount) {
     // Initialize a the mask swizzler
     if (!this->initializeSwizzler(dstInfo)) {
         SkCodecPrintf("Error: cannot initialize swizzler.\n");
         return SkCodec::kInvalidConversion;
     }
 
     return SkCodec::kSuccess;
 }
 
 /*
  * Performs the decoding
  */
-SkCodec::Result SkBmpMaskCodec::decodeRows(const SkImageInfo& dstInfo,
+uint32_t SkBmpMaskCodec::decodeRows(const SkImageInfo& dstInfo,
                                            void* dst, size_t dstRowBytes,
                                            const Options& opts) {
     // Iterate over rows of the image
     uint8_t* srcRow = fSrcBuffer.get();
     const int height = dstInfo.height();
     for (int y = 0; y < height; y++) {
         // Read a row of the input
         if (this->stream()->read(srcRow, fSrcRowBytes) != fSrcRowBytes) {
             SkCodecPrintf("Warning: incomplete input stream.\n");
-            // Fill the destination image on failure
-            void* dstStart = this->getDstStartRow(dst, dstRowBytes, y);
-            uint32_t fillColor = get_fill_color_or_index(dstInfo.alphaType());
-            SkSwizzler::Fill(dstStart, dstInfo, dstRowBytes, height - y,
-                    fillColor, nullptr, opts.fZeroInitialized);
-            return kIncompleteInput;
+            return y;
         }
 
         // Decode the row in destination format
         uint32_t row = this->getDstRow(y, height);
         void* dstRow = SkTAddOffset<void>(dst, row * dstRowBytes);
         fMaskSwizzler->swizzle(dstRow, srcRow);
     }
 
     // Finished decoding the entire image
-    return kSuccess;
+    return height;
 }