Fill incomplete images in SkCodec parent class

src/codec/SkBmpCodec.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 "SkBmpCodec.h"
 #include "SkBmpMaskCodec.h"
 #include "SkBmpRLECodec.h"
@@ skipping 538 matching lines @@
     return height - y - 1;
 }
 
 /*
  * Get the destination row to start filling from
  * Used to fill the remainder of the image on incomplete input for bmps
  * This is tricky since bmps may be kTopDown or kBottomUp.  For kTopDown,
  * we start filling from where we left off, but for kBottomUp we start
  * filling at the top of the image.
  */
-void* SkBmpCodec::getDstStartRow(void* dst, size_t dstRowBytes, int32_t y) const {
+void* SkBmpCodec::onGetFillDst(void* dst, size_t dstRowBytes, uint32_t decodedScanlines) const {
     return (SkScanlineDecoder::kTopDown_SkScanlineOrder == fRowOrder) ?
-            SkTAddOffset<void*>(dst, y * dstRowBytes) : dst;
+            INHERITED::onGetFillDst(dst, dstRowBytes, decodedScanlines) : dst;
 }
 
 /*
  * Compute the number of colors in the color table
  */
 uint32_t SkBmpCodec::computeNumColors(uint32_t numColors) {
     // Zero is a default for maxColors
     // Also set numColors to maxColors when it is too large
     uint32_t maxColors = 1 << fBitsPerPixel;
     if (numColors == 0 || numColors >= maxColors) {
         return maxColors;
     }
     return numColors;
 }
 
 /*
  * Scanline decoder for bmps
  */
 class SkBmpScanlineDecoder : public SkScanlineDecoder {
 public:
     SkBmpScanlineDecoder(SkBmpCodec* codec)
-        : INHERITED(codec->getInfo())
+        : INHERITED(codec, codec->getInfo())
         , fCodec(codec)
     {}
 
     SkEncodedFormat onGetEncodedFormat() const override {
         return kBMP_SkEncodedFormat;
     }
 
     SkCodec::Result onStart(const SkImageInfo& dstInfo, const SkCodec::Options& options,
                             SkPMColor inputColorPtr[], int* inputColorCount) override {
         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 (!conversion_possible(dstInfo, this->getInfo())) {
             SkCodecPrintf("Error: cannot convert input type to output type.\n");
             return SkCodec::kInvalidConversion;
         }
 
         return fCodec->prepareToDecode(dstInfo, options, inputColorPtr, inputColorCount);
     }
 
-    SkCodec::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
+    uint32_t onGetScanlines(void* dst, int count, size_t rowBytes) override {
         // Create a new image info representing the portion of the image to decode
         SkImageInfo rowInfo = this->dstInfo().makeWH(this->dstInfo().width(), count);
 
         // Decode the requested rows
         return fCodec->decodeRows(rowInfo, dst, rowBytes, this->options());
     }
 
     SkScanlineOrder onGetScanlineOrder() const override {
         return fCodec->fRowOrder;
     }
 
-    int onGetY() const override {
-        return fCodec->getDstRow(this->INHERITED::onGetY(), this->dstInfo().height());
-    }
-
     // TODO(msarett): Override default skipping with something more clever.
 
 private:
-    SkAutoTDelete<SkBmpCodec> fCodec;
+    SkBmpCodec* fCodec; // Owned by parent class
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkBmpCodec::NewSDFromStream(SkStream* stream) {
     SkAutoTDelete<SkBmpCodec> codec(static_cast<SkBmpCodec*>(SkBmpCodec::NewFromStream(stream)));
     if (!codec) {
         return NULL;
     }
 
     return SkNEW_ARGS(SkBmpScanlineDecoder, (codec.detach()));
 }