Test scanline decoding in DM.

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "DMSrcSinkAndroid.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkChecksum.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkInstCnt.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 #include "Test.h"
 #include "Timer.h"
 
-DEFINE_string(src, "tests gm skp image subset codec", "Source types to test.");
+DEFINE_string(src, "tests gm skp image subset codec scanline", "Source types to test.");
 DEFINE_bool(nameByHash, false,
             "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
             "to FLAGS_writePath[0]/<config>/<sourceType>/<name>.png");
 DEFINE_bool2(pathOpsExtended, x, false, "Run extended pathOps tests.");
 DEFINE_string(matrix, "1 0 0 1",
               "2x2 scale+skew matrix to apply or upright when using "
               "'matrix' or 'upright' in config.");
 DEFINE_bool(gpu_threading, false, "Allow GPU work to run on multiple threads?");
 
 DEFINE_string(blacklist, "",
@@ skipping 141 matching lines @@
     for (int i = 0; i < FLAGS_images.count(); i++) {
         const char* flag = FLAGS_images[i];
         if (sk_isdir(flag)) {
             for (size_t j = 0; j < SK_ARRAY_COUNT(exts); j++) {
                 SkOSFile::Iter it(flag, exts[j]);
                 for (SkString file; it.next(&file); ) {
                     SkString path = SkOSPath::Join(flag, file.c_str());
                     push_src("image", new ImageSrc(path));     // Decode entire image.
                     push_src("subset", new ImageSrc(path, 2)); // Decode into 2 x 2 subsets
                     if (codec_supported(exts[j])) {
-                        push_src("codec", new CodecSrc(path));     // Decode with SkCodec.
+                        push_src("codec", new CodecSrc(path, CodecSrc::kNormal_Mode));
+                        push_src("scanline", new CodecSrc(path, CodecSrc::kScanline_Mode));
                     }
                 }
             }
         } else if (sk_exists(flag)) {
             // assume that FLAGS_images[i] is a valid image if it is a file.
             push_src("image", new ImageSrc(flag));     // Decode entire image.
             push_src("subset", new ImageSrc(flag, 2)); // Decode into 2 x 2 subsets
-            push_src("codec", new CodecSrc(flag));     // Decode with SkCodec.
+            push_src("codec", new CodecSrc(flag, CodecSrc::kNormal_Mode));
+            push_src("scanline", new CodecSrc(flag, CodecSrc::kScanline_Mode));
         }
     }
 }
 
 static GrGLStandard get_gpu_api() {
     if (FLAGS_gpuAPI.contains("gl"))   { return kGL_GrGLStandard; }
     if (FLAGS_gpuAPI.contains("gles")) { return kGLES_GrGLStandard; }
     return kNone_GrGLStandard;
 }
 
@@ skipping 437 matching lines @@
     }
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif