add --descriptions flag to render_pictures tool

tools/image_expectations.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 "SkBitmap.h"
 #include "SkBitmapHasher.h"
 #include "SkData.h"
@@ skipping 10 matching lines @@
  * TODO(epoger): Similar constants are already maintained in 2 other places:
  * gm/gm_json.py and gm/gm_expectations.cpp. We shouldn't add yet a third place.
  * Figure out a way to share the definitions instead.
  *
  * Note that, as of https://codereview.chromium.org/226293002 , the JSON
  * schema used here has started to differ from the one in gm_expectations.cpp .
  * TODO(epoger): Consider getting GM and render_pictures to use the same JSON
  * output module.
  */
 const static char kJsonKey_ActualResults[] = "actual-results";
+const static char kJsonKey_Descriptions[] = "descriptions";
 const static char kJsonKey_ExpectedResults[] = "expected-results";
 const static char kJsonKey_Header[] = "header";
 const static char kJsonKey_Header_Type[] = "type";
 const static char kJsonKey_Header_Revision[] = "revision";
 const static char kJsonKey_Image_ChecksumAlgorithm[] = "checksumAlgorithm";
 const static char kJsonKey_Image_ChecksumValue[] = "checksumValue";
 const static char kJsonKey_Image_ComparisonResult[] = "comparisonResult";
 const static char kJsonKey_Image_Filepath[] = "filepath";
 const static char kJsonKey_Image_IgnoreFailure[] = "ignoreFailure";
 const static char kJsonKey_Source_TiledImages[] = "tiled-images";
@@ skipping 129 matching lines @@
         actualImage[kJsonKey_Image_ComparisonResult] = comparisonResult;
 
         // Add this actual result to our collection.
         if (NULL == tileNumber) {
             fActualResults[sourceName][kJsonKey_Source_WholeImage] = actualImage;
         } else {
             fActualResults[sourceName][kJsonKey_Source_TiledImages][*tileNumber] = actualImage;
         }
     }
 
+    void ImageResultsAndExpectations::addDescription(const char *key, const char *value) {
+        fDescriptions[key] = value;
+    }
+
     bool ImageResultsAndExpectations::matchesExpectation(const char *sourceName,
                                                          const ImageDigest &digest,
                                                          const int *tileNumber) {
         if (fExpectedResults.isNull()) {
             return false;
         }
 
         Json::Value expectedImage;
         if (NULL == tileNumber) {
             expectedImage = fExpectedResults[sourceName][kJsonKey_Source_WholeImage];
         } else {
             expectedImage = fExpectedResults[sourceName][kJsonKey_Source_TiledImages][*tileNumber];
         }
         if (expectedImage.isNull()) {
             return false;
         }
 
         Json::Value actualChecksumAlgorithm = digest.getHashType().c_str();
         Json::Value actualChecksumValue = Json::UInt64(digest.getHashValue());
         return ((actualChecksumAlgorithm == expectedImage[kJsonKey_Image_ChecksumAlgorithm]) &&
                 (actualChecksumValue == expectedImage[kJsonKey_Image_ChecksumValue]));
     }
 
     void ImageResultsAndExpectations::writeToFile(const char *filename) const {
         Json::Value header;
         header[kJsonKey_Header_Type] = kJsonValue_Header_Type;
         header[kJsonKey_Header_Revision] = kJsonValue_Header_Revision;
         Json::Value root;
+        root[kJsonKey_ActualResults] = fActualResults;
+        root[kJsonKey_Descriptions] = fDescriptions;
         root[kJsonKey_Header] = header;
-        root[kJsonKey_ActualResults] = fActualResults;
         std::string jsonStdString = root.toStyledString();
         SkFILEWStream stream(filename);
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
 
     /*static*/ bool ImageResultsAndExpectations::Parse(SkFILE *filePtr,
                                                        Json::Value *jsonRoot) {
         SkAutoDataUnref dataRef(SkData::NewFromFILE(filePtr));
         if (NULL == dataRef.get()) {
             return false;
         }
 
         const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data());
         size_t size = dataRef.get()->size();
         Json::Reader reader;
         if (!reader.parse(bytes, bytes+size, *jsonRoot)) {
             return false;
         }
 
         return true;
     }
 
 } // namespace sk_tools