Add --uninterestingHashesFile to 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 "SkJSONCPP.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
+#include "SkTDict.h"
 #include "SkTHash.h"
 #include "SkTaskGroup.h"
 #include "SkThreadUtils.h"
 #include "Test.h"
 #include "Timer.h"
 
 DEFINE_string(src, "tests gm skp image", "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>/<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/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.");
 
+DEFINE_string(uninterestingHashesFile, "",
+        "JSON file containing a list of uninteresting hashes. If a result hashes to something in "
+        "this list, no image is written for that result.");
+
 __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 75 matching lines @@
         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()));
         }
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+static SkTDict<bool> gUninterestingHashes(0);

[mtklein, 2015/04/03 19:58:04]

Let's try:
  static SkTHashSet<SkString> gUninterestingHashes;

The loop would be

  for (const SkString& hash : lines) {
     gUninterestingHashes.add(hash);
  }

and the check:
  && !gUninterestingHashes.contains(md5) { 

[borenet, 2015/04/03 20:26:50]

Done.

+
+static void gather_uninteresting_hashes() {
+    if (!FLAGS_uninterestingHashesFile.isEmpty()) {
+        SkString path(FLAGS_uninterestingHashesFile[0]);
+        SkAutoTUnref<SkData> json(SkData::NewFromFileName(path.c_str()));
+        if (!json) {
+            fail(SkStringPrintf("Couldn't read %s to get the list of uninteresting hashes.",
+                                path.c_str()));
+        }
+
+        Json::Reader reader;
+        Json::Value root;
+        const char* data = (const char*)json->data();
+        if (!reader.parse(data, data+json->size(), root)) {
+            fail(SkStringPrintf("Couldn't parse JSON from %s.", path.c_str()));
+        }
+
+        for (unsigned i = 0; i < root.size(); i++) {
+            gUninterestingHashes.set(root[i].asCString(), true);
+        }
+    }
+}
+
+/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
+
 template <typename T>
 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;
@@ skipping 278 matching lines @@
                                      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()) {
+            if (!FLAGS_writePath.isEmpty() && !gUninterestingHashes.find(md5.c_str(), md5.size())) {
                 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();
@@ skipping 169 matching lines @@
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkTaskGroup::Enabler enabled(FLAGS_threads);
     if (FLAGS_leaks) {
         SkInstCountPrintLeaksOnExit();
     }
 
     start_keepalive();
 
     gather_gold();
+    gather_uninteresting_hashes();
 
     gather_srcs();
     gather_sinks();
     gather_tests();
 
     gPending = gSrcs.count() * gSinks.count() + gThreadedTests.count() + gGPUTests.count();
     SkDebugf("%d srcs * %d sinks + %d tests == %d tasks\n",
              gSrcs.count(), gSinks.count(), gThreadedTests.count() + gGPUTests.count(), gPending);
 
     // We try to exploit as much parallelism as is safe.  Most Src/Sink pairs run on any thread,
@@ skipping 40 matching lines @@
     }
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif