When running DM, write test failures to json.

dm/DMJsonWriter.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMJsonWriter.h"
 
 #include "SkCommonFlags.h"
 #include "SkJSONCPP.h"
 #include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkThread.h"
 
 namespace DM {
 
 SkTArray<JsonWriter::BitmapResult> gBitmapResults;
 SK_DECLARE_STATIC_MUTEX(gBitmapResultLock);
 
 void JsonWriter::AddBitmapResult(const BitmapResult& result) {
     SkAutoMutexAcquire lock(&gBitmapResultLock);
     gBitmapResults.push_back(result);
 }
 
+SkTArray<skiatest::Failure> gFailures;
+SK_DECLARE_STATIC_MUTEX(gFailureLock);
+
+void JsonWriter::AddTestFailure(const skiatest::Failure& failure) {
+    SkAutoMutexAcquire lock(gFailureLock);
+    gFailures.push_back(failure);
+}
+
 void JsonWriter::DumpJson() {
     if (FLAGS_writePath.isEmpty()) {
         return;
     }
 
     Json::Value root;
 
     for (int i = 1; i < FLAGS_properties.count(); i += 2) {
         root[FLAGS_properties[i-1]] = FLAGS_properties[i];
     }
     for (int i = 1; i < FLAGS_key.count(); i += 2) {
         root["key"][FLAGS_key[i-1]] = FLAGS_key[i];
     }
 
     {
         SkAutoMutexAcquire lock(&gBitmapResultLock);
         for (int i = 0; i < gBitmapResults.count(); i++) {
             Json::Value result;
             result["key"]["name"]            = gBitmapResults[i].name.c_str();
             result["key"]["config"]          = gBitmapResults[i].config.c_str();
             result["key"]["mode"]            = gBitmapResults[i].mode.c_str();
             result["options"]["source_type"] = gBitmapResults[i].sourceType.c_str();
             result["md5"]                    = gBitmapResults[i].md5.c_str();
 
             root["results"].append(result);
         }
     }
 
+    {
+        const char* test_results = "test_results";

[scroggo, 2014/11/05 20:40:17]

This block writes out the test results in the format listed in the change
description. I'm not attached to that format, so if something would be better
for the bots or a human to read, please let me know.

[mtklein, 2014/11/06 15:24:05]

It's probably OK to just write "test_results" where it's used. :)

[mtklein, 2014/11/06 15:24:05]

You're adding this, so you tell us what's a good format.  No humans or bots
currently look at this, because it doesn't exist. :)

[scroggo, 2014/11/06 16:52:32]

I was being cautious since I used it twice. I've removed one of those uses, so
there's no reason for it anymore.

+        SkAutoMutexAcquire lock(gFailureLock);
+        root[test_results]["num_failures"] = gFailures.count();

[mtklein, 2014/11/06 15:24:05]

Isn't this redundant?  It's sort of clear from the length of the failures list.

[scroggo, 2014/11/06 16:52:32]

It is redundant, but I thought maybe it's easier to have one place to look than
to count? That said, what we really care about is that there exists some
failure, rather than the precise number. I'll remove.

+        for (int i = 0; i < gFailures.count(); i++) {
+            Json::Value result;
+            result["file_name"]     = gFailures[i].fileName.c_str();
+            result["line_no"]       = gFailures[i].lineNo;
+            result["condition"]     = gFailures[i].condition.c_str();
+            result["message"]       = gFailures[i].message.c_str();
+
+            root[test_results]["failures"].append(result);
+        }
+    }
+
     SkString path = SkOSPath::Join(FLAGS_writePath[0], "dm.json");
     SkFILEWStream stream(path.c_str());
     stream.writeText(Json::StyledWriter().write(root).c_str());
     stream.flush();
 }
 
 } // namespace DM