Move all knowledge of X sampling into SkScaledCodec

src/codec/SkBmpRLECodec.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 "SkBmpRLECodec.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 25 matching lines @@
  */
 SkCodec::Result SkBmpRLECodec::onGetPixels(const SkImageInfo& dstInfo,
                                            void* dst, size_t dstRowBytes,
                                            const Options& opts,
                                            SkPMColor* inputColorPtr,
                                            int* inputColorCount) {
     if (opts.fSubset) {
         // Subsets are not supported.
         return kUnimplemented;
     }
+    // FIXME: This may be my misunderstanding of this class, but it seems like
+    // scaling could be supported?

[msarett, 2015/10/01 19:34:33]

Yes sampling in the x dimension is already implemented.  We could consider
implementing sampling in the y dimension so that this class supports scaling
natively.

I'm still not quite sure that this is best though.

[scroggo, 2015/10/01 21:16:57]

What do you think is the right way to handle it? In my patch, RLE will no longer
work with SkScaledCodec, which has to be able get a sampler to update. If this
class handles sampling itself, we don't need to worry about that.

[msarett, 2015/10/01 22:53:06]

I haven't given this enough thought yet.

In my mind, it would be ideal for SkScaledCodec to handle it, but I'm in favor
of doing it natively if its more efficient to do it natively (which it is, based
on the ideas we've discussed so far).

     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);
@@ skipping 206 matching lines @@
 
     // Copy the color table to the client if necessary
     copy_color_table(dstInfo, this->fColorTable, inputColorPtr, inputColorCount);
 
     // Initialize a buffer for encoded RLE data
     if (!this->initializeStreamBuffer()) {
         SkCodecPrintf("Error: cannot initialize stream buffer.\n");
         return SkCodec::kInvalidConversion;
     }
 
-    SkScaledCodec::ComputeSampleSize(dstInfo, this->getInfo(), &fSampleX, NULL);
+    SkScaledCodec::ComputeSampleSize(dstInfo.dimensions(), this->getInfo().dimensions(),
+                                     &fSampleX, NULL);
 
     return SkCodec::kSuccess;
 }
 
 /*
  * Performs the bitmap decoding for RLE input format
  * RLE decoding is performed all at once, rather than a one row at a time
  */
 SkCodec::Result SkBmpRLECodec::decodeRows(const SkImageInfo& dstInfo,
                                           void* dst, size_t dstRowBytes,
@@ skipping 176 matching lines @@
 
                 // Set the indicated number of pixels
                 for (int which = 0; x < endX; x++) {
                     setPixel(dst, dstRowBytes, dstInfo, x, y, indices[which]);
                     which = !which;
                 }
             }
         }
     }
 }