Fill incomplete images in SkCodec parent class

src/codec/SkBmpStandardCodec.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 "SkBmpStandardCodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 18 matching lines @@
     , fInIco(inIco)
 {}
 
 /*
  * Initiates the bitmap decode
  */
 SkCodec::Result SkBmpStandardCodec::onGetPixels(const SkImageInfo& dstInfo,
                                         void* dst, size_t dstRowBytes,
                                         const Options& opts,
                                         SkPMColor* inputColorPtr,
-                                        int* inputColorCount) {
+                                        int* inputColorCount,
+                                        int* rowsDecoded) {
     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;
     }
-    result = this->decodeRows(dstInfo, dst, dstRowBytes, opts);
-    if (kSuccess != result) {
-        return result;
+    uint32_t rows = this->decodeRows(dstInfo, dst, dstRowBytes, opts);
+    if (rows != dstInfo.height()) {
+        *rowsDecoded = rows;
+        return kIncompleteInput;
     }
     if (fInIco) {
         return this->decodeIcoMask(dstInfo, dst, dstRowBytes);
     }
     return kSuccess;
 }
 
 /*
  * Process the color table for the bmp input
  */
@@ skipping 150 matching lines @@
     if (!this->initializeSwizzler(dstInfo, options)) {
         SkCodecPrintf("Error: cannot initialize swizzler.\n");
         return SkCodec::kInvalidConversion;
     }
     return SkCodec::kSuccess;
 }
 
 /*
  * Performs the bitmap decoding for standard input format
  */
-SkCodec::Result SkBmpStandardCodec::decodeRows(const SkImageInfo& dstInfo,
+uint32_t SkBmpStandardCodec::decodeRows(const SkImageInfo& dstInfo,
                                                void* dst, size_t dstRowBytes,
                                                const Options& opts) {
     // Iterate over rows of the image
     const int height = dstInfo.height();
     for (int y = 0; y < height; y++) {
         // Read a row of the input
         if (this->stream()->read(fSrcBuffer.get(), fSrcRowBytes) != fSrcRowBytes) {
             SkCodecPrintf("Warning: incomplete input stream.\n");
-            // Fill the destination image on failure
-            void* dstStart = this->getDstStartRow(dst, dstRowBytes, y);
-            const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
-            uint32_t fillColorOrIndex = get_fill_color_or_index(dstInfo.alphaType());
-            SkSwizzler::Fill(dstStart, dstInfo, dstRowBytes, dstInfo.height() - y,
-                    fillColorOrIndex, colorPtr, opts.fZeroInitialized);
-            return kIncompleteInput;
+            return y;
         }
 
         // Decode the row in destination format
         uint32_t row = this->getDstRow(y, dstInfo.height());
 
         void* dstRow = SkTAddOffset<void>(dst, row * dstRowBytes);
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
     }
 
     // Finished decoding the entire image
-    return kSuccess;
+    return height;
 }
 
 // TODO (msarett): This function will need to be modified in order to perform row by row decodes
 //                 when the Ico scanline decoder is implemented.
 SkCodec::Result SkBmpStandardCodec::decodeIcoMask(const SkImageInfo& dstInfo,
         void* dst, size_t dstRowBytes) {
     // BMP in ICO have transparency, so this cannot be 565, and this mask
     // prevents us from using kIndex8. The below code depends on the output
     // being an SkPMColor.
     SkASSERT(dstInfo.colorType() == kN32_SkColorType);
@@ skipping 20 matching lines @@
             int modulus;
             SkTDivMod(x, 8, &quotient, &modulus);
             uint32_t shift = 7 - modulus;
             uint32_t alphaBit =
                     (fSrcBuffer.get()[quotient] >> shift) & 0x1;
             dstRow[x] &= alphaBit - 1;
         }
     }
     return kSuccess;
 }
+
+uint32_t SkBmpStandardCodec::onGetFillValue(SkColorType colorType, SkAlphaType alphaType) const {
+    const SkPMColor* colorPtr = get_color_ptr(fColorTable.get());
+    if (colorPtr) {
+        return get_color_table_fill_value(colorType, colorPtr, 0);
+    }
+    return INHERITED::onGetFillValue(colorType, alphaType);
+}