DM: add basic --blacklist <config> <srcType> <name> functionality.

dm/DM.cpp

 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "Timer.h"
 
 DEFINE_bool(tests, true, "Run tests?");
 DEFINE_string(images, "resources", "Images to decode.");
 //DEFINE_string(src, "gm skp image subset", "Source types to test.");
 DEFINE_string(src, "gm skp", "Source types to test.  TEMPORARILY DISABLED");
 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 0 1 0 0 0 1",
               "Matrix to apply when using 'matrix' 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.");
+
+
 __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);
@@ skipping 170 matching lines @@
                 break;
             }
             sink = next;
         }
         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) {
+    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]);
+        }
+    }
+    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 whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag, name.c_str());
         WallTimer timer;
         timer.start();
-        if (!FLAGS_dryRun) {
+        if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
             Error err = task->sink->draw(*task->src, &bitmap, &stream);
             if (!err.isEmpty()) {
                 fail(SkStringPrintf("%s %s %s: %s",
                                     task->sink.tag,
                                     task->src.tag,
-                                    task->src->name().c_str(),
+                                    name.c_str(),
                                     err.c_str()));
             }
             if (!FLAGS_writePath.isEmpty()) {
                 const char* ext = task->sink->fileExtension();
                 if (stream.bytesWritten() == 0) {
                     SkMemoryStream pixels(bitmap.getPixels(), bitmap.getSize());
                     WriteToDisk(*task, &pixels, bitmap.getSize(), &bitmap, ext);
                 } else {
                     SkAutoTDelete<SkStreamAsset> data(stream.detachAsStream());
                     WriteToDisk(*task, data, data->getLength(), NULL, ext);
                 }
             }
         }
         timer.end();
-        done(timer.fWall, task->sink.tag, task->src.tag, task->src->name());
+        if (!whyBlacklisted.isEmpty()) {
+            name.appendf(" (--blacklist, %s)", whyBlacklisted.c_str());
+        }
+        done(timer.fWall, task->sink.tag, task->src.tag, name);
     }
 
     static void WriteToDisk(const Task& task,
                             SkStream* data, size_t len,
                             const SkBitmap* bitmap,
                             const char* ext) {
         SkMD5 hash;
         hash.writeStream(data, len);
         SkMD5::Digest digest;
         hash.finish(digest);
@@ skipping 156 matching lines @@
         if (FLAGS_gpu_threading) {
             tg.batch(run_test,  gGPUTests.begin(),   gGPUTests.count());
         } else {
             for (int i = 0; i < gGPUTests.count(); i++) {
                 run_test(&gGPUTests[i]);
             }
         }
     tg.wait();
 
     // At this point we're back in single-threaded land.
-
-    if (!FLAGS_verbose) {
-        SkDebugf("\n");
-    }
+    SkDebugf("\n");
 
     JsonWriter::DumpJson();
 
     if (gFailures.count() > 0) {
         SkDebugf("Failures:\n");
         for (int i = 0; i < gFailures.count(); i++) {
             SkDebugf("\t%s", gFailures[i].c_str());
         }
         SkDebugf("%d failures\n", gFailures.count());
         return 1;
     }
     if (gPending > 0) {
         SkDebugf("Hrm, we didn't seem to run everything we intended to!  Please file a bug.\n");
         return 1;
     }
     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