patch from issue 886233004 at patchset 40001 (http://crrev.com/886233004#ps40001)

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"
@@ skipping 31 matching lines @@
 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.
 
-static void done(double ms, ImplicitString config, ImplicitString src, ImplicitString name) {
+static void done(double ms,
+                 ImplicitString config, ImplicitString src, ImplicitString name,
+                 ImplicitString log) {
+    if (!log.isEmpty()) {
+        log.prepend("\n");
+    }
     int32_t pending = sk_atomic_dec(&gPending)-1;
-    SkDebugf("%s(%4dMB %5d) %s\t%s %s %s  ", FLAGS_verbose ? "\n" : kSkOverwriteLine
+    SkDebugf("%s(%4dMB %5d) %s\t%s %s %s%s", FLAGS_verbose ? "\n" : kSkOverwriteLine
                                            , sk_tools::getMaxResidentSetSizeMB()
                                            , pending
                                            , HumanizeMs(ms).c_str()
                                            , config.c_str()
                                            , src.c_str()
-                                           , name.c_str());
+                                           , name.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();
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 struct Gold : public SkString {
@@ skipping 99 matching lines @@
     }
     // Try a noop Src as a canary.  If it fails, skip this sink.
     struct : public Src {
         Error draw(SkCanvas*) const SK_OVERRIDE { return ""; }
         SkISize size() const SK_OVERRIDE { return SkISize::Make(16, 16); }
         Name name() const SK_OVERRIDE { return "noop"; }
     } noop;
 
     SkBitmap bitmap;
     SkDynamicMemoryWStream stream;
-    Error err = sink->draw(noop, &bitmap, &stream);
+    SkString log;
+    Error err = sink->draw(noop, &bitmap, &stream, &log);
     if (!err.isEmpty()) {
         SkDebugf("Skipping %s: %s\n", tag, err.c_str());
         return;
     }
 
     Tagged<Sink>& ts = gSinks.push_back();
     ts.reset(sink.detach());
     ts.tag = tag;
 }
 
@@ skipping 99 matching lines @@
 // 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());
+        SkString log;
         WallTimer timer;
         timer.start();
         if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
-            Error err = task->sink->draw(*task->src, &bitmap, &stream);
+            Error err = task->sink->draw(*task->src, &bitmap, &stream, &log);
             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;
@@ skipping 29 matching lines @@
                     SkASSERT(bitmap.drawsNothing());
                 } else if (!bitmap.drawsNothing()) {
                     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);
+        done(timer.fWall, task->sink.tag, task->src.tag, name, 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;
@@ skipping 100 matching lines @@
         }
         bool verbose() const SK_OVERRIDE { return FLAGS_veryVerbose; }
     } reporter;
     WallTimer timer;
     timer.start();
     if (!FLAGS_dryRun) {
         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 62 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