Add image decoding mode to DM.

dm/DM.cpp

 // Main binary for DM.
 // For a high-level overview, please see dm/README.
 
 #include "CrashHandler.h"
 #include "LazyDecodeBitmap.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkString.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "sk_tool_utils_flags.h"
 
 #include "DMCpuGMTask.h"
 #include "DMGpuGMTask.h"
 #include "DMGpuSupport.h"
+#include "DMImageTask.h"
 #include "DMJsonWriter.h"
 #include "DMPDFTask.h"
 #include "DMReporter.h"
 #include "DMSKPTask.h"
 #include "DMTask.h"
 #include "DMTaskRunner.h"
 #include "DMTestTask.h"
 
 #ifdef SK_BUILD_POPPLER
 #  include "SkPDFRasterizer.h"
@@ skipping 12 matching lines @@
 using skiatest::Test;
 using skiatest::TestRegistry;
 
 static const char kGpuAPINameGL[] = "gl";
 static const char kGpuAPINameGLES[] = "gles";
 
 DEFINE_bool(gms, true, "Run GMs?");
 DEFINE_bool(tests, true, "Run tests?");
 DEFINE_bool(reportUsedChars, false, "Output test font construction data to be pasted into"
                                     " create_test_font.cpp.");
+DEFINE_string(images, "resources", "Path to directory containing images to decode.");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 // "FooBar" -> "foobar".  Obviously, ASCII only.
 static SkString lowercase(SkString s) {
     for (size_t i = 0; i < s.size(); i++) {
         s[i] = tolower(s[i]);
     }
     return s;
 }
@@ skipping 49 matching lines @@
     for (int i = 0; i < tests.count(); i++) {
         SkAutoTDelete<Test> test(tests[i](NULL));
         if (test->isGPUTest()) {
             tasks->add(SkNEW_ARGS(DM::GpuTestTask, (reporter, tasks, tests[i])));
         } else {
             tasks->add(SkNEW_ARGS(DM::CpuTestTask, (reporter, tasks, tests[i])));
         }
     }
 }
 
-static void find_skps(SkTArray<SkString>* skps) {
-    if (FLAGS_skps.isEmpty()) {
+static void find_files(const char* dir,
+                       const char* suffixes[],
+                       size_t num_suffixes,
+                       SkTArray<SkString>* files) {
+    if (0 == strcmp(dir, "")) {
         return;
     }
 
-    SkOSFile::Iter it(FLAGS_skps[0], ".skp");
     SkString filename;
-    while (it.next(&filename)) {
-        if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, filename.c_str())) {
-            skps->push_back(SkOSPath::Join(FLAGS_skps[0], filename.c_str()));
+    for (size_t i = 0; i < num_suffixes; i++) {
+        SkOSFile::Iter it(dir, suffixes[i]);
+        while (it.next(&filename)) {
+            if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, filename.c_str())) {
+                files->push_back(SkOSPath::Join(dir, filename.c_str()));
+            }
         }
     }
 }
 
 static void kick_off_skps(const SkTArray<SkString>& skps,
                           DM::Reporter* reporter,
                           DM::TaskRunner* tasks) {
     for (int i = 0; i < skps.count(); ++i) {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(skps[i].c_str()));
         if (stream.get() == NULL) {
             SkDebugf("Could not read %s.\n", skps[i].c_str());
             exit(1);
         }
         SkAutoTUnref<SkPicture> pic(
                 SkPicture::CreateFromStream(stream.get(), &sk_tools::LazyDecodeBitmap));
         if (pic.get() == NULL) {
             SkDebugf("Could not read %s as an SkPicture.\n", skps[i].c_str());
             exit(1);
         }
 
         SkString filename = SkOSPath::Basename(skps[i].c_str());
         tasks->add(SkNEW_ARGS(DM::SKPTask, (reporter, tasks, pic, filename)));
         tasks->add(SkNEW_ARGS(DM::PDFTask, (reporter, tasks, pic, filename, RASTERIZE_PDF_PROC)));
     }
 }
 
+static void kick_off_images(const SkTArray<SkString>& images,
+                            DM::Reporter* reporter,
+                            DM::TaskRunner* tasks) {
+    for (int i = 0; i < images.count(); i++) {
+        SkAutoTUnref<SkData> image(SkData::NewFromFileName(images[i].c_str()));
+        if (!image) {
+            SkDebugf("Could not read %s.\n", images[i].c_str());
+            exit(1);
+        }
+        SkString filename = SkOSPath::Basename(images[i].c_str());
+        tasks->add(SkNEW_ARGS(DM::ImageTask, (reporter, tasks, image, filename)));
+        tasks->add(SkNEW_ARGS(DM::ImageTask, (reporter, tasks, image, filename, 5/*subsets*/)));
+    }
+}
+
+
 static void report_failures(const SkTArray<SkString>& failures) {
     if (failures.count() == 0) {
         return;
     }
 
     SkDebugf("Failures:\n");
     for (int i = 0; i < failures.count(); i++) {
         SkDebugf("  %s\n", failures[i].c_str());
     }
     SkDebugf("%d failures.\n", failures.count());
@@ skipping 42 matching lines @@
     SkTDArray<GMRegistry::Factory> gms;
     if (FLAGS_gms) {
         append_matching_factories<GM>(GMRegistry::Head(), &gms);
     }
 
     SkTDArray<TestRegistry::Factory> tests;
     if (FLAGS_tests) {
         append_matching_factories<Test>(TestRegistry::Head(), &tests);
     }
 
+
     SkTArray<SkString> skps;
-    find_skps(&skps);
+    if (!FLAGS_skps.isEmpty()) {
+        const char* suffixes[] = { "skp" };
+        find_files(FLAGS_skps[0], suffixes, SK_ARRAY_COUNT(suffixes), &skps);
+    }
 
-    SkDebugf("%d GMs x %d configs, %d tests, %d pictures\n",
-             gms.count(), configs.count(), tests.count(), skps.count());
+    SkTArray<SkString> images;
+    if (!FLAGS_images.isEmpty()) {
+        const char* suffixes[] = { "bmp", "gif", "jpg", "png", "webp", "ktx", "astc" };
+        find_files(FLAGS_images[0], suffixes, SK_ARRAY_COUNT(suffixes), &images);
+    }
+
+    SkDebugf("%d GMs x %d configs, %d tests, %d pictures, %d images\n",
+             gms.count(), configs.count(), tests.count(), skps.count(), images.count());
     DM::Reporter reporter;
 
     DM::TaskRunner tasks;
     kick_off_tests(tests, &reporter, &tasks);
     kick_off_gms(gms, configs, gpuAPI, &reporter, &tasks);
     kick_off_skps(skps, &reporter, &tasks);
+    kick_off_images(images, &reporter, &tasks);
     tasks.wait();
 
     DM::JsonWriter::DumpJson();
 
     SkDebugf("\n");
 #ifdef SK_DEBUG
     if (FLAGS_portableFonts && FLAGS_reportUsedChars) {
         sk_tool_utils::report_used_chars();
     }
 #endif
 
     SkTArray<SkString> failures;
     reporter.getFailures(&failures);
     report_failures(failures);
     return failures.count() > 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