GM: add --writeChecksumBasedFilenames option

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
@@ skipping 170 matching lines @@
 };
 
 static bool encode_to_dct_stream(SkWStream* stream, const SkBitmap& bitmap, const SkIRect& rect);
 
 const static ErrorCombination kDefaultIgnorableErrorTypes = ErrorCombination()
     .plus(kMissingExpectations_ErrorType)
     .plus(kIntentionallySkipped_ErrorType);
 
 class GMMain {
 public:
-    GMMain() : fUseFileHierarchy(false), fIgnorableErrorTypes(kDefaultIgnorableErrorTypes),
+    GMMain() : fUseFileHierarchy(false), fWriteChecksumBasedFilenames(false),
+               fIgnorableErrorTypes(kDefaultIgnorableErrorTypes),
                fMismatchPath(NULL), fTestsRun(0), fRenderModesEncountered(1) {}
 
     /**
      * Assemble shortNamePlusConfig from (surprise!) shortName and configName.
      *
      * The method for doing so depends on whether we are using hierarchical naming.
      * For example, shortName "selftest1" and configName "8888" could be assembled into
      * either "selftest1_8888" or "8888/selftest1".
      */
     SkString make_shortname_plus_config(const char *shortName, const char *configName) {
@@ skipping 16 matching lines @@
                            const char *configName,
                            const char *renderModeDescriptor,
                            const char *suffix) {
         SkString filename = make_shortname_plus_config(shortName, configName);
         filename.append(renderModeDescriptor);
         filename.appendUnichar('.');
         filename.append(suffix);
         return SkOSPath::SkPathJoin(path, filename.c_str());
     }
 
+    /**
+     * Assemble filename suitable for writing out an SkBitmap.
+     */
+    SkString make_bitmap_filename(const char *path,
+                                  const char *shortName,
+                                  const char *configName,
+                                  const char *renderModeDescriptor,
+                                  const GmResultDigest &bitmapDigest) {
+        if (fWriteChecksumBasedFilenames) {

[epoger, 2013/06/18 06:58:38]

At patchset 3, we are assembling the desired output paths, but because they
include multiple directory levels, we still need to create the intermediate
directories.

Here's the error I see when running the self-tests:

GM: FAILED to write
gm/tests/outputs/checksum-based-filenames/output-actual/writePath/bitmap-64bitMD5/selftest1/1209453360120438698.png
GM: FAILED to write
gm/tests/outputs/checksum-based-filenames/output-actual/writePath/bitmap-64bitMD5/selftest1/12927999507540085554.png
GM: expected 9 tests, but ran or skipped 11 tests

+            SkString completePath(path);
+            completePath.appendUnichar(SkPATH_SEPARATOR);
+            completePath.append(bitmapDigest.getHashType());
+            completePath.appendUnichar(SkPATH_SEPARATOR);
+            completePath.append(shortName);
+            completePath.appendUnichar(SkPATH_SEPARATOR);
+            completePath.append(bitmapDigest.getDigestValue());
+            completePath.appendUnichar('.');
+            completePath.append(kPNG_FileExtension);
+            return completePath;
+        } else {
+            return make_filename(path, shortName, configName, renderModeDescriptor,
+                                 kPNG_FileExtension);
+        }
+    }
+
     /* since PNG insists on unpremultiplying our alpha, we take no
        precision chances and force all pixels to be 100% opaque,
        otherwise on compare we may not get a perfect match.
     */
     static void force_all_opaque(const SkBitmap& bitmap) {
         SkBitmap::Config config = bitmap.config();
         switch (config) {
         case SkBitmap::kARGB_8888_Config:
             force_all_opaque_8888(bitmap);
             break;
         case SkBitmap::kRGB_565_Config:
             // nothing to do here; 565 bitmaps are inherently opaque
             break;
         default:
             gm_fprintf(stderr, "unsupported bitmap config %d\n", config);
             DEBUGFAIL_SEE_STDERR;
         }
     }
 
     static void force_all_opaque_8888(const SkBitmap& bitmap) {
         SkAutoLockPixels lock(bitmap);
         for (int y = 0; y < bitmap.height(); y++) {
             for (int x = 0; x < bitmap.width(); x++) {
                 *bitmap.getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
             }
         }
     }
 
+    // EPOGER: make sure to create any directories needed along the path
+    // EPOGER: make sure this works even if the destination file already exists -- just overwrite it
     static bool write_bitmap(const SkString& path, const SkBitmap& bitmap) {
         // TODO(epoger): Now that we have removed force_all_opaque()
         // from this method, we should be able to get rid of the
         // transformation to 8888 format also.
         SkBitmap copy;
         bitmap.copyTo(&copy, SkBitmap::kARGB_8888_Config);
         return SkImageEncoder::EncodeFile(path.c_str(), copy,
                                           SkImageEncoder::kPNG_Type, 100);
     }
 
@@ skipping 362 matching lines @@
         invokeGM(gm, &c, false, false);
         dev->endSheet();
         dev->endPortfolio();
 
 #endif
     }
 
     ErrorCombination write_reference_image(const ConfigData& gRec, const char writePath [],
                                            const char renderModeDescriptor [],
                                            const char *shortName, SkBitmap& bitmap,
+                                           GmResultDigest& bitmapDigest,
                                            SkDynamicMemoryWStream* document) {
         SkString path;
         bool success = false;
         if (gRec.fBackend == kRaster_Backend ||
             gRec.fBackend == kGPU_Backend ||
             (gRec.fBackend == kPDF_Backend && CAN_IMAGE_PDF)) {
 
-            path = make_filename(writePath, shortName, gRec.fName, renderModeDescriptor,
-                                 kPNG_FileExtension);
+            path = make_bitmap_filename(writePath, shortName, gRec.fName, renderModeDescriptor,
+                                        bitmapDigest);
             success = write_bitmap(path, bitmap);
         }
         if (kPDF_Backend == gRec.fBackend) {
             path = make_filename(writePath, shortName, gRec.fName, renderModeDescriptor,
                                  "pdf");
             success = write_document(path, *document);
         }
         if (kXPS_Backend == gRec.fBackend) {
             path = make_filename(writePath, shortName, gRec.fName, renderModeDescriptor,
                                  "xps");
@@ skipping 77 matching lines @@
 
     /**
      * Compares actual hash digest to expectations, returning the set of errors
      * (if any) that we saw along the way.
      *
      * If fMismatchPath has been set, and there are pixel diffs, then the
      * actual bitmap will be written out to a file within fMismatchPath.
      *
      * @param expectations what expectations to compare actualBitmap against
      * @param actualBitmap the image we actually generated
+     * @param actualResultDigest GmResultDigest of actualBitmap
      * @param shortName name of test, e.g. "selftest1"
      * @param configName name of config, e.g. "8888"
      * @param renderModeDescriptor e.g., "-rtree", "-deferred"
      * @param addToJsonSummary whether to add these results (both actual and
      *        expected) to the JSON summary. Regardless of this setting, if
      *        we find an image mismatch in this test, we will write these
      *        results to the JSON summary.  (This is so that we will always
      *        report errors across rendering modes, such as pipe vs tiled.
      *        See https://codereview.chromium.org/13650002/ )
      */
     ErrorCombination compare_to_expectations(Expectations expectations,
                                              const SkBitmap& actualBitmap,
+                                             const GmResultDigest& actualResultDigest,
                                              const char *shortName, const char *configName,
                                              const char *renderModeDescriptor,
                                              bool addToJsonSummary) {
         ErrorCombination errors;
-        GmResultDigest actualResultDigest(actualBitmap);
         SkString shortNamePlusConfig = make_shortname_plus_config(shortName, configName);
         SkString completeNameString(shortNamePlusConfig);
         completeNameString.append(renderModeDescriptor);
         completeNameString.append(".");
         completeNameString.append(kPNG_FileExtension);
         const char* completeName = completeNameString.c_str();
 
         if (expectations.empty()) {
             errors.add(kMissingExpectations_ErrorType);
         } else if (!expectations.match(actualResultDigest)) {
             addToJsonSummary = true;
             // The error mode we record depends on whether this was running
             // in a non-standard renderMode.
             if ('\0' == *renderModeDescriptor) {
                 errors.add(kExpectationsMismatch_ErrorType);
             } else {
                 errors.add(kRenderModeMismatch_ErrorType);
             }
 
             // Write out the "actuals" for any mismatches, if we have
             // been directed to do so.
             if (fMismatchPath) {
-                SkString path =
-                    make_filename(fMismatchPath, shortName, configName, renderModeDescriptor,
-                                  kPNG_FileExtension);
+                SkString path = make_bitmap_filename(fMismatchPath, shortName, configName,
+                                                     renderModeDescriptor, actualResultDigest);
                 write_bitmap(path, actualBitmap);
             }
 
             // If we have access to a single expected bitmap, log more
             // detail about the mismatch.
             const SkBitmap *expectedBitmapPtr = expectations.asBitmap();
             if (NULL != expectedBitmapPtr) {
                 report_bitmap_diffs(*expectedBitmapPtr, actualBitmap, completeName);
             }
         }
@@ skipping 68 matching lines @@
      * @param gRec
      * @param writePath unless this is NULL, write out actual images into this
      *        directory
      * @param actualBitmap bitmap generated by this run
      * @param pdf
      */
     ErrorCombination compare_test_results_to_stored_expectations(
         GM* gm, const ConfigData& gRec, const char writePath[],
         SkBitmap& actualBitmap, SkDynamicMemoryWStream* pdf) {
 
+        GmResultDigest actualResultDigest(actualBitmap);
         SkString shortNamePlusConfig = make_shortname_plus_config(gm->shortName(), gRec.fName);
         SkString nameWithExtension(shortNamePlusConfig);
         nameWithExtension.append(".");
         nameWithExtension.append(kPNG_FileExtension);
 
         ErrorCombination errors;
         ExpectationsSource *expectationsSource = this->fExpectationsSource.get();
         if (expectationsSource && (gRec.fFlags & kRead_ConfigFlag)) {
             /*
              * Get the expected results for this test, as one or more allowed
              * hash digests. The current implementation of expectationsSource
              * get this by computing the hash digest of a single PNG file on disk.
              *
              * TODO(epoger): This relies on the fact that
              * force_all_opaque() was called on the bitmap before it
              * was written to disk as a PNG in the first place. If
              * not, the hash digest returned here may not match the
              * hash digest of actualBitmap, which *has* been run through
              * force_all_opaque().
              * See comments above complete_bitmap() for more detail.
              */
             Expectations expectations = expectationsSource->get(nameWithExtension.c_str());
-            errors.add(compare_to_expectations(expectations, actualBitmap,
+            errors.add(compare_to_expectations(expectations, actualBitmap, actualResultDigest,
                                                gm->shortName(), gRec.fName, "", true));
         } else {
             // If we are running without expectations, we still want to
             // record the actual results.
-            GmResultDigest actualResultDigest(actualBitmap);
             add_actual_results_to_json_summary(nameWithExtension.c_str(), actualResultDigest,
                                                ErrorCombination(kMissingExpectations_ErrorType),
                                                false);
             RecordTestResults(ErrorCombination(kMissingExpectations_ErrorType),
                               shortNamePlusConfig, "");
         }
 
         // TODO: Consider moving this into compare_to_expectations(),
         // similar to fMismatchPath... for now, we don't do that, because
         // we don't want to write out the actual bitmaps for all
         // renderModes of all tests!  That would be a lot of files.
         if (writePath && (gRec.fFlags & kWrite_ConfigFlag)) {
             errors.add(write_reference_image(gRec, writePath, "", gm->shortName(),
-                                             actualBitmap, pdf));
+                                             actualBitmap, actualResultDigest, pdf));
         }
 
         return errors;
     }
 
     /**
      * Compare actualBitmap to referenceBitmap.
      *
      * @param shortName test name, e.g. "selftest1"
      * @param configName configuration name, e.g. "8888"
      * @param renderModeDescriptor
      * @param actualBitmap actual bitmap generated by this run
      * @param referenceBitmap bitmap we expected to be generated
      */
     ErrorCombination compare_test_results_to_reference_bitmap(
         const char *shortName, const char *configName, const char *renderModeDescriptor,
         SkBitmap& actualBitmap, const SkBitmap* referenceBitmap) {
 
         SkASSERT(referenceBitmap);
         Expectations expectations(*referenceBitmap);
-        return compare_to_expectations(expectations, actualBitmap, shortName,
+        GmResultDigest actualResultDigest(actualBitmap);
+        return compare_to_expectations(expectations, actualBitmap, actualResultDigest, shortName,
                                        configName, renderModeDescriptor, false);
     }
 
     static SkPicture* generate_new_picture(GM* gm, BbhType bbhType, uint32_t recordFlags,
                                            SkScalar scale = SK_Scalar1) {
         // Pictures are refcounted so must be on heap
         SkPicture* pict;
         int width = SkScalarCeilToInt(SkScalarMul(SkIntToScalar(gm->getISize().width()), scale));
         int height = SkScalarCeilToInt(SkScalarMul(SkIntToScalar(gm->getISize().height()), scale));
 
@@ skipping 189 matching lines @@
             }
         }
         return errors;
     }
 
     //
     // member variables.
     // They are public for now, to allow easier setting by tool_main().
     //
 
-    bool fUseFileHierarchy;
+    bool fUseFileHierarchy, fWriteChecksumBasedFilenames;
     ErrorCombination fIgnorableErrorTypes;
 
     const char* fMismatchPath;
 
     // collection of tests that have failed with each ErrorType
     SkTArray<SkString> fFailedTests[kLast_ErrorType+1];
     int fTestsRun;
     SkTDict<int> fRenderModesEncountered;
 
     // Where to read expectations (expected image hash digests, etc.) from.
@@ skipping 139 matching lines @@
                "any differences between those and the newly generated ones.");
 DEFINE_bool(replay, true, "Exercise the SkPicture replay test pass.");
 DEFINE_string2(resourcePath, i, "", "Directory that stores image resources.");
 DEFINE_bool(rtree, true, "Exercise the R-Tree variant of SkPicture test pass.");
 DEFINE_bool(serialize, true, "Exercise the SkPicture serialization & deserialization test pass.");
 DEFINE_bool(simulatePipePlaybackFailure, false, "Simulate a rendering failure in pipe mode only.");
 DEFINE_bool(tiledPipe, false, "Exercise tiled SkGPipe replay.");
 DEFINE_bool(tileGrid, true, "Exercise the tile grid variant of SkPicture.");
 DEFINE_string(tileGridReplayScales, "", "Space separated list of floating-point scale "
               "factors to be used for tileGrid playback testing. Default value: 1.0");
-DEFINE_string(writeJsonSummaryPath, "", "Write a JSON-formatted result summary to this file.");
 DEFINE_bool2(verbose, v, false, "Give more detail (e.g. list all GMs run, more info about "
              "each test).");
+DEFINE_bool(writeChecksumBasedFilenames, false, "When writing out actual images, use checksum-"
+            "based filenames, as rebaseline.py will use when downloading them from Google Storage");
+DEFINE_string(writeJsonSummaryPath, "", "Write a JSON-formatted result summary to this file.");
 DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
 DEFINE_string2(writePicturePath, p, "", "Write .skp files into this directory.");
 DEFINE_int32(pdfJpegQuality, -1, "Encodes images in JPEG at quality level N, "
              "which can be in range 0-100). N = -1 will disable JPEG compression. "
              "Default is N = 100, maximum quality.");
 
 static bool encode_to_dct_stream(SkWStream* stream, const SkBitmap& bitmap, const SkIRect& rect) {
     // Filter output of warnings that JPEG is not available for the image.
     if (bitmap.width() >= 65500 || bitmap.height() >= 65500) return false;
     if (FLAGS_pdfJpegQuality == -1) return false;
@@ skipping 436 matching lines @@
     SkTDArray<size_t> configs;
     SkTDArray<size_t> excludeConfigs;
     bool userConfig = false;
 
     SkString usage;
     usage.printf("Run the golden master tests.\n");
     SkCommandLineFlags::SetUsage(usage.c_str());
     SkCommandLineFlags::Parse(argc, argv);
 
     gmmain.fUseFileHierarchy = FLAGS_hierarchy;
+    gmmain.fWriteChecksumBasedFilenames = FLAGS_writeChecksumBasedFilenames;
     if (FLAGS_mismatchPath.count() == 1) {
         gmmain.fMismatchPath = FLAGS_mismatchPath[0];
     }
 
     for (int i = 0; i < FLAGS_config.count(); i++) {
         const char* config = FLAGS_config[i];
         userConfig = true;
         bool exclude = false;
         if (*config == kExcludeConfigChar) {
             exclude = true;
@@ skipping 311 matching lines @@
     if (FLAGS_forceBWtext) {
         canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
     }
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif