add --writeChecksumBasedFilenames flag 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 11 matching lines @@
 #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.");
 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. "
               "TODO(epoger): Currently, this only works if --writePath is also specified. "
               "See https://code.google.com/p/skia/issues/detail?id=2043 .");
 DEFINE_string2(writePath, w, "", "Directory to write the rendered images.");
 DEFINE_bool(writeWholeImage, false, "In tile mode, write the entire rendered image to a "
             "file, instead of an image for each tile.");
 DEFINE_bool(validate, false, "Verify that the rendered image contains the same pixels as "
@@ skipping 96 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Called only by render_picture().
  */
 static bool render_picture_internal(const SkString& inputPath, const SkString* outputDir,
                                     sk_tools::PictureRenderer& renderer,
                                     SkBitmap** out) {
     SkString inputFilename;
     sk_tools::get_basename(&inputFilename, inputPath);
+    SkString outputDirString;
+    if (NULL != outputDir && outputDir->size() > 0 && !FLAGS_writeEncodedImages) {
+        outputDirString.set(*outputDir);
+    }
 
     SkFILEStream inputStream;
     inputStream.setPath(inputPath.c_str());
     if (!inputStream.isValid()) {
         SkDebugf("Could not open file %s\n", inputPath.c_str());
         return false;
     }
 
     SkPicture::InstallPixelRefProc proc;
     if (FLAGS_deferImageDecoding) {
@@ skipping 24 matching lines @@
 
     for (int i = 0; i < FLAGS_clone; ++i) {
         SkPicture* clone = picture->clone();
         SkDELETE(picture);
         picture = clone;
     }
 
     SkDebugf("drawing... [%i %i] %s\n", picture->width(), picture->height(),
              inputPath.c_str());
 
-    renderer.init(picture);
+    renderer.init(picture, outputDirString, inputFilename, FLAGS_writeChecksumBasedFilenames);
 
     if (FLAGS_preprocess) {
         if (NULL != renderer.getCanvas()) {
             renderer.getCanvas()->EXPERIMENTAL_optimize(picture);
         }
     }
 
     renderer.setup();
 
-    SkString* outputPath = NULL;
-    if (NULL != outputDir && outputDir->size() > 0 && !FLAGS_writeEncodedImages) {
-        outputPath = SkNEW(SkString);
-        make_output_filepath(outputPath, *outputDir, inputFilename);
-    }
-
-    bool success = renderer.render(outputPath, out);
-    if (outputPath) {
-        if (!success) {
-            SkDebugf("Could not write to file %s\n", outputPath->c_str());
-        }
-        SkDELETE(outputPath);
+    bool success = renderer.render(out);
+    if (!success) {
+        SkDebugf("Failed to render %s\n", inputFilename.c_str());
     }
 
     renderer.end();
 
     SkDELETE(picture);
     return success;
 }
 
 static inline int getByte(uint32_t value, int index) {
     SkASSERT(0 <= index && index < 4);
@@ skipping 121 matching lines @@
             if(diffs[i] > 0) {
                 SkDebugf("Number of pixels with max diff of %i is %i\n", i, diffs[i]);
             }
         }
     }
 
     if (FLAGS_writeWholeImage) {
         sk_tools::force_all_opaque(*bitmap);
 
         if (NULL != jsonSummaryPtr) {
-            // EPOGER: This is a hacky way of constructing the filename associated with the
+            // TODO(epoger): This is a hacky way of constructing the filename associated with the
             // image checksum; we basically are repeating the logic of make_output_filepath()
             // and code below here, within here.
             // It would be better for the filename (without outputDir) to be passed in here,
             // and used both for the checksum file and writing into outputDir.
             //
-            // EPOGER: what about including the config type within hashFilename?  That way,
+            // TODO(epoger): what about including the config type within hashFilename?  That way,
             // we could combine results of different config types without conflicting filenames.
             SkString hashFilename;
             sk_tools::get_basename(&hashFilename, inputPath);
             hashFilename.remove(hashFilename.size() - 4, 4); // Remove ".skp"
             hashFilename.append(".png");
             jsonSummaryPtr->add(hashFilename.c_str(), *bitmap);
         }
 
         if (NULL != outputDir) {
             SkString inputFilename;
@@ skipping 125 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