Add subsetting to SkScaledCodec

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 53 matching lines @@
     if (size) {
         *size = SkISize::Make(SkToS32(width), SkToS32(height));
     }
     return true;
 }
 
 bool SkWbmpCodec::onRewind() {
     return read_header(this->stream(), nullptr);
 }
 
-SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info,
-        const SkPMColor* ctable, const Options& opts) {
+SkSwizzler* SkWbmpCodec::initializeSwizzler(const SkImageInfo& info, const SkPMColor* ctable,
+        const Options& opts, int subsetLeft, int subsetWidth) {
     // Create the swizzler based on the desired color type
     switch (info.colorType()) {
         case kIndex_8_SkColorType:
         case kN32_SkColorType:
         case kRGB_565_SkColorType:
         case kGray_8_SkColorType:
-            return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized, 
-                                              this->getInfo());
+            return SkSwizzler::CreateSwizzler(SkSwizzler::kBit, ctable, info, opts.fZeroInitialized,
+                    this->getInfo(), subsetLeft, subsetWidth);
         default:
             return nullptr;
     }
 }
 
 bool SkWbmpCodec::readRow(uint8_t* row) {
     return this->stream()->read(row, fSrcRowBytes) == fSrcRowBytes;
 }
 
 SkWbmpCodec::SkWbmpCodec(const SkImageInfo& info, SkStream* stream)
@@ skipping 24 matching lines @@
 
     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()) {
+    SkAutoTDelete<SkSwizzler> swizzler(this->initializeSwizzler(info, ctable, options, 0,
+            info.width()));
+    if (NULL == 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) {
         if (!this->readRow(src.get())) {
             *rowsDecoded = y;
@@ skipping 26 matching lines @@
         if (!this->readRow(fSrcBuffer.get())) {
             return y;
         }
         fSwizzler->swizzle(dstRow, fSrcBuffer.get());
         dstRow = SkTAddOffset<void>(dstRow, dstRowBytes);
     }
     return count;
 }
 
 SkCodec::Result SkWbmpCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
-        const Options& options, SkPMColor inputColorTable[], int* inputColorCount) {
+        const Options& options, SkPMColor inputColorTable[], int* inputColorCount, int subsetLeft,
+        int subsetWidth) {
     if (options.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         if (!SkScaledCodec::DimensionsSupportedForSampling(this->getInfo(), dstInfo)) {
                 return kInvalidScale;
         }
     }
 
     if (!valid_alpha(dstInfo.alphaType(), this->getInfo().alphaType())) {
         return kInvalidConversion;
     }
 
     // Fill in the color table
     setup_color_table(dstInfo.colorType(), inputColorTable, inputColorCount);
 
     // Copy the color table to a pointer that can be owned by the scanline decoder
     if (kIndex_8_SkColorType == dstInfo.colorType()) {
         fColorTable.reset(new SkColorTable(inputColorTable, 2));
     }
 
     // Initialize the swizzler
-    fSwizzler.reset(this->initializeSwizzler(dstInfo,
-            get_color_ptr(fColorTable.get()), options));
+    fSwizzler.reset(this->initializeSwizzler(dstInfo, get_color_ptr(fColorTable.get()), options,
+            subsetLeft, subsetWidth));
     if (nullptr == fSwizzler.get()) {
         return kInvalidConversion;
     }
 
     fSrcBuffer.reset(fSrcRowBytes);
 
     return kSuccess;
 }