add --readJsonSummaryPath to render_pictures

tools/render_pictures_main.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "LazyDecodeBitmap.h"
 #include "CopyTilesRenderer.h"
 #include "SkBitmap.h"
@@ skipping 13 matching lines @@
 #include "PictureRenderer.h"
 #include "PictureRenderingFlags.h"
 #include "picture_utils.h"
 
 // Flags used by this file, alphabetically:
 DEFINE_int32(clone, 0, "Clone the picture n times before rendering.");
 DECLARE_bool(deferImageDecoding);
 DEFINE_int32(maxComponentDiff, 256, "Maximum diff on a component, 0 - 256. Components that differ "
              "by more than this amount are considered errors, though all diffs are reported. "
              "Requires --validate.");
+DEFINE_string(readJsonSummaryPath, "", "JSON file to read image expectations from.");
 DECLARE_string(readPath);
 DEFINE_bool(writeChecksumBasedFilenames, false,
             "When writing out images, use checksum-based filenames.");
 DEFINE_bool(writeEncodedImages, false, "Any time the skp contains an encoded image, write it to a "
             "file rather than decoding it. Requires writePath to be set. Skips drawing the full "
             "skp to a file. Not compatible with deferImageDecoding.");
 DEFINE_string(writeJsonSummaryPath, "", "File to write a JSON summary of image results to.");
 DEFINE_string2(writePath, w, "", "Directory to write the rendered images into.");
 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
             "file, instead of an image for each tile.");
@@ skipping 203 matching lines @@
 /**
  * Render the SKP file(s) within inputPath, writing their bitmap images into outputDir.
  *
  * @param inputPath path to an individual SKP file, or a directory of SKP files
  * @param outputDir if not NULL, write the image(s) generated into this directory
  * @param renderer PictureRenderer to use to render the SKPs
  * @param jsonSummaryPtr if not NULL, add the image(s) generated to this summary
  */
 static bool render_picture(const SkString& inputPath, const SkString* outputDir,
                            sk_tools::PictureRenderer& renderer,
-                           sk_tools::ImageResultsSummary *jsonSummaryPtr) {
+                           sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
     int diffs[256] = {0};
     SkBitmap* bitmap = NULL;
     renderer.setJsonSummaryPtr(jsonSummaryPtr);
     bool success = render_picture_internal(inputPath,
         FLAGS_writeWholeImage ? NULL : outputDir,
         renderer,
         FLAGS_validate || FLAGS_writeWholeImage ? &bitmap : NULL);
 
     if (!success || ((FLAGS_validate || FLAGS_writeWholeImage) && bitmap == NULL)) {
         SkDebugf("Failed to draw the picture.\n");
@@ skipping 73 matching lines @@
     if (FLAGS_writeWholeImage) {
         sk_tools::force_all_opaque(*bitmap);
 
         SkString inputFilename, outputPath;
         sk_tools::get_basename(&inputFilename, inputPath);
         sk_tools::make_filepath(&outputPath, *outputDir, inputFilename);
         sk_tools::replace_char(&outputPath, '.', '_');
         outputPath.append(".png");
 
         if (NULL != jsonSummaryPtr) {
+            sk_tools::ImageDigest imageDigest(*bitmap);
             SkString outputFileBasename;
             sk_tools::get_basename(&outputFileBasename, outputPath);
-            jsonSummaryPtr->add(inputFilename.c_str(), outputFileBasename.c_str(), *bitmap);
+            jsonSummaryPtr->add(inputFilename.c_str(), outputFileBasename.c_str(), imageDigest);
         }
 
         if (NULL != outputDir) {
             if (!SkImageEncoder::EncodeFile(outputPath.c_str(), *bitmap,
                                             SkImageEncoder::kPNG_Type, 100)) {
                 SkDebugf("Failed to draw the picture.\n");
                 success = false;
             }
         }
     }
     SkDELETE(bitmap);
 
     return success;
 }
 
 
 static int process_input(const char* input, const SkString* outputDir,
                          sk_tools::PictureRenderer& renderer,
-                         sk_tools::ImageResultsSummary *jsonSummaryPtr) {
+                         sk_tools::ImageResultsAndExpectations *jsonSummaryPtr) {
     SkOSFile::Iter iter(input, "skp");
     SkString inputFilename;
     int failures = 0;
     SkDebugf("process_input, %s\n", input);
     if (iter.next(&inputFilename)) {
         do {
             SkString inputPath;
             SkString inputAsSkString(input);
             sk_tools::make_filepath(&inputPath, inputAsSkString, inputFilename);
             if (!render_picture(inputPath, outputDir, renderer, jsonSummaryPtr)) {
@@ skipping 59 matching lines @@
     if (renderer.get() == NULL) {
         exit(-1);
     }
 
     SkAutoGraphics ag;
 
     SkString outputDir;
     if (FLAGS_writePath.count() == 1) {
         outputDir.set(FLAGS_writePath[0]);
     }
-    sk_tools::ImageResultsSummary jsonSummary;
-    sk_tools::ImageResultsSummary* jsonSummaryPtr = NULL;
+    sk_tools::ImageResultsAndExpectations jsonSummary;
+    sk_tools::ImageResultsAndExpectations* jsonSummaryPtr = NULL;
     if (FLAGS_writeJsonSummaryPath.count() == 1) {
         jsonSummaryPtr = &jsonSummary;
+        if (FLAGS_readJsonSummaryPath.count() == 1) {
+            SkASSERT(jsonSummary.readExpectationsFile(FLAGS_readJsonSummaryPath[0]));
+        }
     }
 
     int failures = 0;
     for (int i = 0; i < FLAGS_readPath.count(); i ++) {
         failures += process_input(FLAGS_readPath[i], &outputDir, *renderer.get(), jsonSummaryPtr);
     }
     if (failures != 0) {
         SkDebugf("Failed to render %i pictures.\n", failures);
         return 1;
     }
@@ skipping 12 matching lines @@
         jsonSummary.writeToFile(FLAGS_writeJsonSummaryPath[0]);
     }
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif