Update DM to allow Src's to have optional options.

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 scanline", "Source types to test.");
+DEFINE_string(src, "tests gm skp image", "Source types to test.");
+DEFINE_string(srcOptions, "decode subset codec scanline",

[mtklein, 2015/04/02 20:11:58]

Seems like we could skip this.  You're not planning on having bots change this,
are you?

[djsollen, 2015/04/02 20:24:15]

Done.

+              "Options to be applied to the any source types that accepts options. The\n"
+              "only source type that currently accepts option is image  E.g.\n"
+              "'--srcOptions codec scanline' will only execute the codec and scanline "
+              "variations of the image src.");
 DEFINE_bool(nameByHash, false,
             "If true, write to FLAGS_writePath[0]/<hash>.png instead of "
-            "to FLAGS_writePath[0]/<config>/<sourceType>/<name>.png");
+            "to FLAGS_writePath[0]/<config>/<sourceType>/<sourceOptions>/<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, "",
-        "Space-separated config/src/name triples to blacklist.  '_' matches anything.  E.g. \n"
-        "'--blacklist gpu skp _' will blacklist all SKPs drawn into the gpu config.\n"
-        "'--blacklist gpu skp _ 8888 gm aarects' will also blacklist the aarects GM on 8888.");
+        "Space-separated config/src/srcOptions/name quadruples to blacklist.  '_' matches anything.  E.g. \n"
+        "'--blacklist gpu skp _ _' will blacklist all SKPs drawn into the gpu config.\n"
+        "'--blacklist gpu skp _ _ 8888 gm _ aarects' will also blacklist the aarects GM on 8888.");
 
 DEFINE_string2(readPath, r, "", "If set check for equality with golden results in this directory.");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 using namespace DM;
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 SK_DECLARE_STATIC_MUTEX(gFailuresMutex);
 static SkTArray<SkString> gFailures;
 
 static void fail(ImplicitString err) {
     SkAutoMutexAcquire lock(gFailuresMutex);
     SkDebugf("\n\nFAILURE: %s\n\n", err.c_str());
     gFailures.push_back(err);
 }
 
 static int32_t gPending = 0;  // Atomic.  Total number of running and queued tasks.
 
 SK_DECLARE_STATIC_MUTEX(gRunningMutex);
 static SkTArray<SkString> gRunning;
 
 static void done(double ms,
-                 ImplicitString config, ImplicitString src, ImplicitString name,
-                 ImplicitString note, ImplicitString log) {
-    SkString id = SkStringPrintf("%s %s %s", config.c_str(), src.c_str(), name.c_str());
+                 ImplicitString config, ImplicitString src, ImplicitString srcOptions,
+                 ImplicitString name, ImplicitString note, ImplicitString log) {
+    SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
+                                                srcOptions.c_str(), name.c_str());
     {
         SkAutoMutexAcquire lock(gRunningMutex);
         for (int i = 0; i < gRunning.count(); i++) {
             if (gRunning[i] == id) {
                 gRunning.removeShuffle(i);
                 break;
             }
         }
     }
     if (!FLAGS_verbose) {
@@ skipping 10 matching lines @@
                                        , id.c_str()
                                        , note.c_str()
                                        , log.c_str());
     // We write our dm.json file every once in a while in case we crash.
     // Notice this also handles the final dm.json when pending == 0.
     if (pending % 500 == 0) {
         JsonWriter::DumpJson();
     }
 }
 
-static void start(ImplicitString config, ImplicitString src, ImplicitString name) {
-    SkString id = SkStringPrintf("%s %s %s", config.c_str(), src.c_str(), name.c_str());
+static void start(ImplicitString config, ImplicitString src,
+                  ImplicitString srcOptions, ImplicitString name) {
+    SkString id = SkStringPrintf("%s %s %s %s", config.c_str(), src.c_str(),
+                                                srcOptions.c_str(), name.c_str());
     SkAutoMutexAcquire lock(gRunningMutex);
     gRunning.push_back(id);
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 struct Gold : public SkString {
     Gold() : SkString("") {}
-    Gold(ImplicitString sink, ImplicitString src, ImplicitString name, ImplicitString md5)
+    Gold(ImplicitString sink, ImplicitString src, ImplicitString srcOptions,
+         ImplicitString name, ImplicitString md5)
         : SkString("") {
         this->append(sink);
         this->append(src);
+        this->append(srcOptions);
         this->append(name);
         this->append(md5);
     }
     static uint32_t Hash(const Gold& g) { return SkGoodHash((const SkString&)g); }
 };
 static SkTHashSet<Gold, Gold::Hash> gGold;
 
 static void add_gold(JsonWriter::BitmapResult r) {
-    gGold.add(Gold(r.config, r.sourceType, r.name, r.md5));
+    gGold.add(Gold(r.config, r.sourceType, r.sourceOptions, r.name, r.md5));
 }
 
 static void gather_gold() {
     if (!FLAGS_readPath.isEmpty()) {
         SkString path(FLAGS_readPath[0]);
         path.append("/dm.json");
         if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
             fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
         }
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 template <typename T>
-struct Tagged : public SkAutoTDelete<T> { const char* tag; };
+struct Tagged : public SkAutoTDelete<T> {
+  const char* tag;
+  const char* options;
+};
 
 static const bool kMemcpyOK = true;
 
 static SkTArray<Tagged<Src>,  kMemcpyOK>  gSrcs;
 static SkTArray<Tagged<Sink>, kMemcpyOK> gSinks;
 
-static void push_src(const char* tag, Src* s) {
+static void push_src(const char* tag, const char* options, Src* s) {
     SkAutoTDelete<Src> src(s);
     if (FLAGS_src.contains(tag) &&
+        (strcmp(options, "") == 0 || FLAGS_srcOptions.contains(options)) &&
         !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
         Tagged<Src>& s = gSrcs.push_back();
         s.reset(src.detach());
         s.tag = tag;
+        s.options = options;
     }
 }
 
 static bool codec_supported(const char* ext) {
     // FIXME: Once other versions of SkCodec are available, we can add them to this
     // list (and eventually we can remove this check once they are all supported).
     static const char* const exts[] = {
         "bmp", "gif", "png", "ico", "wbmp",
         "BMP", "GIF", "PNG", "ICO", "WBMP"
     };
 
     for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
         if (0 == strcmp(exts[i], ext)) {
             return true;
         }
     }
     return false;
 }
 
 static void gather_srcs() {
     for (const skiagm::GMRegistry* r = skiagm::GMRegistry::Head(); r; r = r->next()) {
-        push_src("gm", new GMSrc(r->factory()));
+        push_src("gm", "", new GMSrc(r->factory()));
     }
     for (int i = 0; i < FLAGS_skps.count(); i++) {
         const char* path = FLAGS_skps[i];
         if (sk_isdir(path)) {
             SkOSFile::Iter it(path, "skp");
             for (SkString file; it.next(&file); ) {
-                push_src("skp", new SKPSrc(SkOSPath::Join(path, file.c_str())));
+                push_src("skp", "", new SKPSrc(SkOSPath::Join(path, file.c_str())));
             }
         } else {
-            push_src("skp", new SKPSrc(path));
+            push_src("skp", "", new SKPSrc(path));
         }
     }
     static const char* const exts[] = {
         "bmp", "gif", "jpg", "jpeg", "png", "webp", "ktx", "astc", "wbmp", "ico",
         "BMP", "GIF", "JPG", "JPEG", "PNG", "WEBP", "KTX", "ASTC", "WBMP", "ICO",
     };
     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
+                    push_src("image", "decode", new ImageSrc(path)); // Decode entire image
+                    push_src("image", "subset", new ImageSrc(path, 2)); // Decode into 2x2 subsets
                     if (codec_supported(exts[j])) {
-                        push_src("codec", new CodecSrc(path, CodecSrc::kNormal_Mode));
-                        push_src("scanline", new CodecSrc(path, CodecSrc::kScanline_Mode));
+                        push_src("image", "codec", new CodecSrc(path, CodecSrc::kNormal_Mode));
+                        push_src("image", "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, CodecSrc::kNormal_Mode));
-            push_src("scanline", new CodecSrc(flag, CodecSrc::kScanline_Mode));
+            push_src("image", "decode", new ImageSrc(flag)); // Decode entire image.
+            push_src("image", "subset", new ImageSrc(flag, 2)); // Decode into 2 x 2 subsets
+            push_src("image", "codec", new CodecSrc(flag, CodecSrc::kNormal_Mode));
+            push_src("image", "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 116 matching lines @@
         if (sink) {
             push_sink(config, sink);
         }
     }
 }
 
 static bool match(const char* needle, const char* haystack) {
     return 0 == strcmp("_", needle) || NULL != strstr(haystack, needle);
 }
 
-static ImplicitString is_blacklisted(const char* sink, const char* src, const char* name) {
+static ImplicitString is_blacklisted(const char* sink, const char* src,
+                                     const char* srcOptions, const char* name) {
     for (int i = 0; i < FLAGS_blacklist.count() - 2; i += 3) {
         if (match(FLAGS_blacklist[i+0], sink) &&
-            match(FLAGS_blacklist[i+1],  src) &&
-            match(FLAGS_blacklist[i+2], name)) {
-            return SkStringPrintf("%s %s %s",
-                                  FLAGS_blacklist[i+0], FLAGS_blacklist[i+1], FLAGS_blacklist[i+2]);
+            match(FLAGS_blacklist[i+1], src) &&
+            match(FLAGS_blacklist[i+2], srcOptions) &&
+            match(FLAGS_blacklist[i+3], name)) {
+            return SkStringPrintf("%s %s %s %s",
+                                  FLAGS_blacklist[i+0], FLAGS_blacklist[i+1],
+                                  FLAGS_blacklist[i+2], FLAGS_blacklist[i+3]);
         }
     }
     return "";
 }
 
 // The finest-grained unit of work we can run: draw a single Src into a single Sink,
 // report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
 struct Task {
     Task(const Tagged<Src>& src, const Tagged<Sink>& sink) : src(src), sink(sink) {}
     const Tagged<Src>&  src;
     const Tagged<Sink>& sink;
 
     static void Run(Task* task) {
         SkString name = task->src->name();
         SkString note;
-        SkString whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag, name.c_str());
+        SkString whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag,
+                                                 task->src.options, name.c_str());
         if (!whyBlacklisted.isEmpty()) {
             note.appendf(" (--blacklist %s)", whyBlacklisted.c_str());
         }
         SkString log;
         WallTimer timer;
         timer.start();
         if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
-            start(task->sink.tag, task->src.tag, name.c_str());
+            start(task->sink.tag, task->src.tag, task->src.options, name.c_str());
             Error err = task->sink->draw(*task->src, &bitmap, &stream, &log);
             if (!err.isEmpty()) {
                 timer.end();
                 if (err.isFatal()) {
-                    fail(SkStringPrintf("%s %s %s: %s",
+                    fail(SkStringPrintf("%s %s %s %s: %s",
                                         task->sink.tag,
                                         task->src.tag,
+                                        task->src.options,
                                         name.c_str(),
                                         err.c_str()));
                 } else {
                     note.appendf(" (skipped: %s)", err.c_str());
                 }
-                done(timer.fWall, task->sink.tag, task->src.tag, name, note, log);
+                done(timer.fWall, task->sink.tag, task->src.tag, task->src.options,
+                     name, note, log);
                 return;
             }
             SkAutoTDelete<SkStreamAsset> data(stream.detachAsStream());
 
             SkString md5;
             if (!FLAGS_writePath.isEmpty() || !FLAGS_readPath.isEmpty()) {
                 SkMD5 hash;
                 if (data->getLength()) {
                     hash.writeStream(data, data->getLength());
                     data->rewind();
                 } else {
                     hash.write(bitmap.getPixels(), bitmap.getSize());
                 }
                 SkMD5::Digest digest;
                 hash.finish(digest);
                 for (int i = 0; i < 16; i++) {
                     md5.appendf("%02x", digest.data[i]);
                 }
             }
 
             if (!FLAGS_readPath.isEmpty() &&
-                !gGold.contains(Gold(task->sink.tag, task->src.tag, name, md5))) {
-                fail(SkStringPrintf("%s not found for %s %s %s in %s",
+                !gGold.contains(Gold(task->sink.tag, task->src.tag,
+                                     task->src.options, name, md5))) {
+                fail(SkStringPrintf("%s not found for %s %s %s %s in %s",
                                     md5.c_str(),
                                     task->sink.tag,
                                     task->src.tag,
+                                    task->src.options,
                                     name.c_str(),
                                     FLAGS_readPath[0]));
             }
 
             if (!FLAGS_writePath.isEmpty()) {
                 const char* ext = task->sink->fileExtension();
                 if (data->getLength()) {
                     WriteToDisk(*task, md5, ext, data, data->getLength(), NULL);
                     SkASSERT(bitmap.drawsNothing());
                 } else if (!bitmap.drawsNothing()) {
                     WriteToDisk(*task, md5, ext, NULL, 0, &bitmap);
                 }
             }
         }
         timer.end();
-        done(timer.fWall, task->sink.tag, task->src.tag, name, note, log);
+        done(timer.fWall, task->sink.tag, task->src.tag, task->src.options, name, note, log);
     }
 
     static void WriteToDisk(const Task& task,
                             SkString md5,
                             const char* ext,
                             SkStream* data, size_t len,
                             const SkBitmap* bitmap) {
         JsonWriter::BitmapResult result;
-        result.name       = task.src->name();
-        result.config     = task.sink.tag;
-        result.sourceType = task.src.tag;
-        result.ext        = ext;
-        result.md5        = md5;
+        result.name          = task.src->name();
+        result.config        = task.sink.tag;
+        result.sourceType    = task.src.tag;
+        result.sourceOptions = task.src.options;
+        result.ext           = ext;
+        result.md5           = md5;
         JsonWriter::AddBitmapResult(result);
 
         const char* dir = FLAGS_writePath[0];
         if (0 == strcmp(dir, "@")) {  // Needed for iOS.
             dir = FLAGS_resourcePath[0];
         }
         sk_mkdir(dir);
 
         SkString path;
         if (FLAGS_nameByHash) {
             path = SkOSPath::Join(dir, result.md5.c_str());
             path.append(".");
             path.append(ext);
             if (sk_exists(path.c_str())) {
                 return;  // Content-addressed.  If it exists already, we're done.
             }
         } else {
             path = SkOSPath::Join(dir, task.sink.tag);
             sk_mkdir(path.c_str());
             path = SkOSPath::Join(path.c_str(), task.src.tag);
             sk_mkdir(path.c_str());
+            if (strcmp(task.src.options, "") == 0) {

[mtklein, 2015/04/02 20:11:58]

!= ?

[djsollen, 2015/04/02 20:24:15]

Done.

+              path = SkOSPath::Join(path.c_str(), task.src.options);
+              sk_mkdir(path.c_str());
+            }
             path = SkOSPath::Join(path.c_str(), task.src->name().c_str());
             path.append(".");
             path.append(ext);
         }
 
         SkFILEWStream file(path.c_str());
         if (!file.isValid()) {
             fail(SkStringPrintf("Can't open %s for writing.\n", path.c_str()));
             return;
         }
@@ skipping 62 matching lines @@
             JsonWriter::AddTestFailure(failure);
         }
         bool allowExtendedTest() const override {
             return FLAGS_pathOpsExtended;
         }
         bool verbose() const override { return FLAGS_veryVerbose; }
     } reporter;
     WallTimer timer;
     timer.start();
     if (!FLAGS_dryRun) {
-        start("unit", "test", test->name);
+        start("unit", "test", "", test->name);
         GrContextFactory factory;
         test->proc(&reporter, &factory);
     }
     timer.end();
-    done(timer.fWall, "unit", "test", test->name, "", "");
+    done(timer.fWall, "unit", "test", "", test->name, "", "");
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 // If we're isolating all GPU-bound work to one thread (the default), this function runs all that.
 static void run_enclave_and_gpu_tests(SkTArray<Task>* tasks) {
     run_enclave(tasks);
     for (int i = 0; i < gGPUTests.count(); i++) {
         run_test(&gGPUTests[i]);
     }
@@ skipping 91 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