Revert of SkScaledCodec class

include/codec/SkScanlineDecoder.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkScanlineDecoder_DEFINED
 #define SkScanlineDecoder_DEFINED
 
@@ skipping 28 matching lines @@
     /**
      *  Clean up after reading/skipping scanlines.
      *
      *  It is possible that not all scanlines will have been read/skipped.  In
      *  fact, in the case of subset decodes, it is likely that there will be
      *  scanlines at the bottom of the image that have been ignored.
      */
     virtual ~SkScanlineDecoder() {}
 
     /**
-     *  Return a size that approximately supports the desired scale factor.
-     *  The codec may not be able to scale efficiently to the exact scale
-     *  factor requested, so return a size that approximates that scale.
-     *  The returned value is the codec's suggestion for the closest valid
-     *  scale that it can natively support
-     *  FIXME: share this with SkCodec
-     */
-    SkISize getScaledDimensions(float desiredScale) {
-        return this->onGetScaledDimensions(desiredScale);
-    }
-
-    /**
      *  Returns the default info, corresponding to the encoded data.
      */
     const SkImageInfo& getInfo() { return fSrcInfo; }
 
     /**
      *  Initialize on the first scanline, with the specified options.
      *
      *  This must be called in order to call getScanlnies or skipScanlines. If
      *  it has been called before, this will require rewinding the stream.
      *
@@ skipping 69 matching lines @@
      *  of the encoded data, but then never use any colors which have alpha
      *  less than 100%. This function can be called *after* decoding to
      *  determine if such an image truly had alpha. Calling it before decoding
      *  is undefined.
      *  FIXME: see skbug.com/3582.
      */
     bool reallyHasAlpha() const {
         return this->onReallyHasAlpha();
     }
 
-    /**
-     *  Format of the encoded data.
-     */
-    SkEncodedFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
-
-    /**
-     * returns true if the image must be scaled, in the y direction, after reading, not during.
-     * To scale afterwards, we first decode every line and then sample the lines we want afterwards.
-     * An example is interlaced pngs, where calling getScanlines once (regardless of the count
-     * used) needs to read the entire image, therefore it is inefficient to call
-     * getScanlines more than once. Instead, it should only ever be called with all the
-     * rows needed.
-     */
-    bool requiresPostYSampling() {
-        return this->onRequiresPostYSampling();
-    }
-
 protected:
     SkScanlineDecoder(const SkImageInfo& srcInfo)
         : fSrcInfo(srcInfo)
         , fDstInfo()
         , fCurrScanline(0) {}
 
-    virtual SkISize onGetScaledDimensions(float /* desiredScale */) {
-        // By default, scaling is not supported.
-        return this->getInfo().dimensions();
-    }
-
-    virtual SkEncodedFormat onGetEncodedFormat() const = 0;
-
     virtual bool onReallyHasAlpha() const { return false; }
 
-    /**
-     * returns true if the image type is hard to sample and must be scaled after reading, not during
-     * An example is interlaced pngs, where the entire image must be read for each decode
-     */
-    virtual bool onRequiresPostYSampling() { return false; }
-
     const SkImageInfo& dstInfo() const { return fDstInfo; }
 
 private:
     const SkImageInfo   fSrcInfo;
     SkImageInfo         fDstInfo;
     int                 fCurrScanline;
 
     virtual SkCodec::Result onStart(const SkImageInfo& dstInfo,
                                     const SkCodec::Options& options,
                                     SkPMColor ctable[], int* ctableCount) = 0;
 
     // Naive default version just calls onGetScanlines on temp memory.
     virtual SkCodec::Result onSkipScanlines(int countLines) {
         SkAutoMalloc storage(fDstInfo.minRowBytes());
         // Note that we pass 0 to rowBytes so we continue to use the same memory.
         // Also note that while getScanlines checks that rowBytes is big enough,
         // onGetScanlines bypasses that check.
         // Calling the virtual method also means we do not double count
         // countLines.
         return this->onGetScanlines(storage.get(), countLines, 0);
     }
 
     virtual SkCodec::Result onGetScanlines(void* dst, int countLines,
                                                     size_t rowBytes) = 0;
 
 };
 #endif // SkScanlineDecoder_DEFINED