Add scanline decoding to SkCodec.

dm/DMSrcSink.cpp

 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkCommonFlags.h"
 #include "SkCodec.h"
 #include "SkDocument.h"
 #include "SkError.h"
 #include "SkMultiPictureDraw.h"
 #include "SkNullCanvas.h"
 #include "SkOSFile.h"
 #include "SkPictureRecorder.h"
 #include "SkRandom.h"
+#include "SkScanlineDecoder.h"
+#include "SkStream.h"
 #include "SkSVGCanvas.h"
-#include "SkStream.h"
 #include "SkXMLWriter.h"
 
-DEFINE_bool(codec, false, "Use SkCodec instead of SkImageDecoder");
+DEFINE_bool(codec, true, "Use SkCodec instead of SkImageDecoder");
 
 namespace DM {
 
 GMSrc::GMSrc(skiagm::GMRegistry::Factory factory) : fFactory(factory) {}
 
 Error GMSrc::draw(SkCanvas* canvas) const {
     SkAutoTDelete<skiagm::GM> gm(fFactory(NULL));
     canvas->concat(gm->getInitialTransform());
     gm->draw(canvas);
     return "";
@@ skipping 34 matching lines @@
             info = info.makeColorType(dstColorType);
             if (info.alphaType() == kUnpremul_SkAlphaType) {
                 // FIXME: Currently we cannot draw unpremultiplied sources.
                 info = info.makeAlphaType(kPremul_SkAlphaType);
             }
             if (!bitmap.tryAllocPixels(info)) {
                 return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
                                       info.width(), info.height());
             }
             SkAutoLockPixels alp(bitmap);
-            const SkImageGenerator::Result result = codec->getPixels(info, bitmap.getPixels(),
-                                                                     bitmap.rowBytes());
-            switch (result) {
-                case SkImageGenerator::kSuccess:
-                // We consider incomplete to be valid, since we should still decode what is
-                // available.
-                case SkImageGenerator::kIncompleteInput:
-                    break;
-                case SkImageGenerator::kInvalidConversion:
-                    return Error::Nonfatal("Incompatible colortype conversion");
-                default:
-                    // Everything else is considered a failure.
-                    return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
+            SkAutoTDelete<SkScanlineDecoder> scanlineDecoder(codec->getScanlineDecoder(info));
+            if (NULL == scanlineDecoder) {
+                return Error::Nonfatal("Cannot use scanline decoder for all images");
+            }
+
+            for (int y = 0; y < info.height(); ++y) {
+                const SkImageGenerator::Result result =
+                        scanlineDecoder->getNextScanline(bitmap.getAddr(0, y));
+                switch (result) {
+                    case SkImageGenerator::kSuccess:
+                        // We consider incomplete to be valid, since we should still decode what is
+                        // available.
+                    case SkImageGenerator::kIncompleteInput:
+                        break;
+                    default:
+                        // Everything else is considered a failure.
+                        return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
+                }
+            }
+
+            const SkImageGenerator::Result result = scanlineDecoder->finish();
+            if (result != SkImageGenerator::kSuccess) {
+                return SkStringPrintf("failed in finish!");
             }
         } else {
             if (!SkImageDecoder::DecodeMemory(encoded->data(), encoded->size(), &bitmap,
                                               dstColorType, SkImageDecoder::kDecodePixels_Mode)) {
                 return SkStringPrintf("Couldn't decode %s.", fPath.c_str());
             }
             if (kRGB_565_SkColorType == dstColorType && !bitmap.isOpaque()) {
                 // Do not draw a bitmap with alpha to a destination without alpha.
                 return Error::Nonfatal("Uninteresting to decode image with alpha into 565.");
             }
@@ skipping 439 matching lines @@
             surfaces.unrefAll();
             return "";
         }
         SkISize size() const SK_OVERRIDE { return fSize; }
         Name name() const SK_OVERRIDE { sk_throw(); return ""; }  // No one should be calling this.
     } proxy(fW, fH, pic, src.size());
     return fSink->draw(proxy, bitmap, stream, log);
 }
 
 }  // namespace DM