add -r to DM

dm/DM.cpp

 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
 #include "OverwriteLine.h"
 #include "ProcStats.h"
 #include "SkBBHFactory.h"
+#include "SkChecksum.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkMD5.h"
 #include "SkOSFile.h"
+#include "SkTDynamicHash.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "Timer.h"
 
 DEFINE_string(images, "resources", "Images to decode.");
 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>/<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.");
 
+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);
@@ skipping 14 matching lines @@
                                            , name.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();
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
+struct Gold : public SkString {
+    Gold(ImplicitString sink, ImplicitString src, ImplicitString name, ImplicitString md5)
+        : SkString("") {
+        this->append(sink);
+        this->append(src);
+        this->append(name);
+        this->append(md5);
+        while (this->size() % 4) {
+            this->append("!");  // Pad out if needed so we can pass this to Murmur3.
+        }
+    }
+    static const Gold& GetKey(const Gold& g) { return g; }
+    static uint32_t Hash(const Gold& g) {
+        return SkChecksum::Murmur3((const uint32_t*)g.c_str(), g.size());
+    }
+};
+static SkTDynamicHash<Gold, Gold> gGold;
+
+static void add_gold(JsonWriter::BitmapResult r) {
+    gGold.add(new Gold(r.config, r.sourceType, r.name, r.md5));  // We'll let these leak. Lazybones.
+}
+
+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; };
 
 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) {
     SkAutoTDelete<Src> src(s);
@@ skipping 174 matching lines @@
             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,
                                     name.c_str(),
                                     err.c_str()));
             }
+            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++) {

[hal.canary, 2015/01/27 22:44:55]

I want SkString SkMD5::toString();

+                    md5.appendf("%02x", digest.data[i]);
+                }
+            }
+
+            if (!FLAGS_readPath.isEmpty() &&
+                !gGold.find(Gold(task->sink.tag, task->src.tag, name, md5))) {
+                fail(SkStringPrintf("%s not found for %s %s %s in %s",
+                                    md5.c_str(),
+                                    task->sink.tag,
+                                    task->src.tag,
+                                    name.c_str(),
+                                    FLAGS_readPath[0]));
+            }
+
             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);
+                if (data->getLength()) {
+                    WriteToDisk(*task, md5, ext, data, data->getLength(), NULL);
                 } else {
-                    SkAutoTDelete<SkStreamAsset> data(stream.detachAsStream());
-                    WriteToDisk(*task, data, data->getLength(), NULL, ext);
+                    WriteToDisk(*task, md5, ext, NULL, 0, &bitmap);
                 }
             }
         }
         timer.end();
         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,
+                            SkString md5,
+                            const char* ext,
                             SkStream* data, size_t len,
-                            const SkBitmap* bitmap,
-                            const char* ext) {
-        SkMD5 hash;
-        hash.writeStream(data, len);
-        SkMD5::Digest digest;
-        hash.finish(digest);
-
+                            const SkBitmap* bitmap) {
         JsonWriter::BitmapResult result;
         result.name       = task.src->name();
         result.config     = task.sink.tag;
         result.sourceType = task.src.tag;
         result.ext        = ext;
-        for (int i = 0; i < 16; i++) {
-            result.md5.appendf("%02x", digest.data[i]);
-        }
+        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) {
@@ skipping 12 matching lines @@
             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;
         }
 
-        data->rewind();
         if (bitmap) {
             // We can't encode A8 bitmaps as PNGs.  Convert them to 8888 first.
             SkBitmap converted;
             if (bitmap->info().colorType() == kAlpha_8_SkColorType) {
                 if (!bitmap->copyTo(&converted, kN32_SkColorType)) {
                     fail("Can't convert A8 to 8888.\n");
                     return;
                 }
                 bitmap = &converted;
             }
@@ skipping 74 matching lines @@
         run_test(&gGPUTests[i]);
     }
 }
 
 int dm_main();
 int dm_main() {
     SetupCrashHandler();
     SkAutoGraphics ag;
     SkTaskGroup::Enabler enabled(FLAGS_threads);
 
+    gather_gold();
+
     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,
     // but Sinks that identify as part of a particular enclave run serially on a single thread.
@@ skipping 39 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