rename SkBitmapChecksummer as SkBitmapHasher, and prepare for it to possibly use

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.
  *
  * If you make changes to this, re-run the self-tests at gm/tests/run.sh
  * to make sure they still pass... you may need to change the expected
  * results of the self-test.
  */
 
 #include "gm.h"
 #include "gm_error.h"
 #include "gm_expectations.h"
 #include "system_preferences.h"
 #include "SkBitmap.h"
-#include "SkBitmapChecksummer.h"
+#include "SkBitmapHasher.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDeferredCanvas.h"
 #include "SkDevice.h"
 #include "SkDrawFilter.h"
 #include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
@@ skipping 362 matching lines @@
      *
      * TODO(epoger): Come up with a better solution that allows us to
      * compare full pixel data, including alpha channel, while still being
      * robust in the face of transformations to/from PNG files.
      * Options include:
      *
      * 1. Continue to call force_all_opaque(), but ONLY for bitmaps that
      *    will be written to, or compared against, PNG files.
      *    PRO: Preserve/compare alpha channel info for the non-PNG cases
      *         (comparing different renderModes in-memory)
-     *    CON: The bitmaps (and checksums) for these non-PNG cases would be
+     *    CON: The bitmaps (and hash digests) for these non-PNG cases would be
      *         different than those for the PNG-compared cases, and in the
      *         case of a failed renderMode comparison, how would we write the
      *         image to disk for examination?
      *
-     * 2. Always compute image checksums from PNG format (either
+     * 2. Always compute image hash digests from PNG format (either
      *    directly from the the bytes of a PNG file, or capturing the
      *    bytes we would have written to disk if we were writing the
      *    bitmap out as a PNG).
      *    PRO: I think this would allow us to never force opaque, and to
      *         the extent that alpha channel data can be preserved in a PNG
      *         file, we could observe it.
-     *    CON: If we read a bitmap from disk, we need to take its checksum
+     *    CON: If we read a bitmap from disk, we need to take its hash digest
      *         from the source PNG (we can't compute it from the bitmap we
      *         read out of the PNG, because we will have already premultiplied
      *         the alpha).
      *    CON: Seems wasteful to convert a bitmap to PNG format just to take
-     *         its checksum. (Although we're wasting lots of effort already
+     *         its hash digest. (Although we're wasting lots of effort already
      *         calling force_all_opaque().)
      *
      * 3. Make the alpha premultiply/unpremultiply routines 100% consistent,
      *    so we can transform images back and forth without fear of off-by-one
      *    errors.
      *    CON: Math is hard.
      *
      * 4. Perform a "close enough" comparison of bitmaps (+/- 1 bit in each
      *    channel), rather than demanding absolute equality.
-     *    CON: Can't do this with checksums.
+     *    CON: Can't do this with hash digests.
      */
     static void complete_bitmap(SkBitmap* bitmap) {
         force_all_opaque(*bitmap);
     }
 
     static void installFilter(SkCanvas* canvas);
 
     static void invokeGM(GM* gm, SkCanvas* canvas, bool isPDF, bool isDeferred) {
         SkAutoCanvasRestore acr(canvas, true);
 
@@ skipping 241 matching lines @@
                                                  (int)SkGetPackedA32(actualPixel)));
                 }
             }
         }
         gm_fprintf(stderr, "---- %s: %d (of %d) differing pixels,"
                    " max per-channel mismatch R=%d G=%d B=%d A=%d\n",
                    testName, differingPixels, width*height, errR, errG, errB, errA);
     }
 
     /**
-     * Compares actual checksum to expectations, returning the set of errors
+     * 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 baseNameString name of test without renderModeDescriptor added
      * @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 SkString& baseNameString,
                                              const char renderModeDescriptor[],
                                              bool addToJsonSummary) {
         ErrorCombination errors;
-        Checksum actualChecksum = SkBitmapChecksummer::Compute64(actualBitmap);
+        SkHashDigest actualBitmapHash;
+        // TODO(epoger): Better handling for error returned by ComputeDigest()?
+        // For now, we just report a digest of 0 in error cases, like before.
+        if (!SkBitmapHasher::ComputeDigest(actualBitmap, &actualBitmapHash)) {
+            actualBitmapHash = 0;
+        }
         SkString completeNameString = baseNameString;
         completeNameString.append(renderModeDescriptor);
         const char* completeName = completeNameString.c_str();
 
         if (expectations.empty()) {
             errors.add(kMissingExpectations_ErrorType);
-        } else if (!expectations.match(actualChecksum)) {
+        } else if (!expectations.match(actualBitmapHash)) {
             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, renderModeDescriptor,
                                   baseNameString.c_str(), "png");
                 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);
             }
         }
         RecordTestResults(errors, baseNameString, renderModeDescriptor);
 
         if (addToJsonSummary) {
-            add_actual_results_to_json_summary(completeName, actualChecksum, errors,
+            add_actual_results_to_json_summary(completeName, actualBitmapHash, errors,
                                                expectations.ignoreFailure());
             add_expected_results_to_json_summary(completeName, expectations);
         }
 
         return errors;
     }
 
     /**
      * Add this result to the appropriate JSON collection of actual results,
      * depending on status.
      */
     void add_actual_results_to_json_summary(const char testName[],
-                                            Checksum actualChecksum,
+                                            const SkHashDigest& actualBitmapHash,
                                             ErrorCombination result,
                                             bool ignoreFailure) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_AnyStatus_Checksum] =
-            asJsonValue(actualChecksum);
+            asJsonValue(actualBitmapHash);
         if (result.isEmpty()) {
             this->fJsonActualResults_Succeeded[testName] = actualResults;
         } else {
             if (ignoreFailure) {
                 // TODO: Once we have added the ability to compare
                 // actual results against expectations in a JSON file
                 // (where we can set ignore-failure to either true or
                 // false), add test cases that exercise ignored
                 // failures (both for kMissingExpectations_ErrorType
                 // and kExpectationsMismatch_ErrorType).
                 this->fJsonActualResults_FailureIgnored[testName] =
                     actualResults;
             } else {
                 if (result.includes(kMissingExpectations_ErrorType)) {
                     // TODO: What about the case where there IS an
-                    // expected image checksum, but that gm test
+                    // expected image hash digest, but that gm test
                     // doesn't actually run?  For now, those cases
                     // will always be ignored, because gm only looks
                     // at expectations that correspond to gm tests
                     // that were actually run.
                     //
                     // Once we have the ability to express
                     // expectations as a JSON file, we should fix this
                     // (and add a test case for which an expectation
                     // is given but the test is never run).
                     this->fJsonActualResults_NoComparison[testName] =
@@ skipping 37 matching lines @@
         GM* gm, const ConfigData& gRec, const char writePath[],
         SkBitmap& actualBitmap, SkDynamicMemoryWStream* pdf) {
 
         SkString name = make_name(gm->shortName(), gRec.fName);
         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
-             * checksums. The current implementation of expectationsSource
-             * get this by computing the checksum of a single PNG file on disk.
+             * 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 checksum returned here may not match the
-             * checksum of actualBitmap, which *has* been run through
+             * 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(name.c_str());
             errors.add(compare_to_expectations(expectations, actualBitmap,
                                                name, "", true));
         } else {
             // If we are running without expectations, we still want to
             // record the actual results.
-            Checksum actualChecksum =
-                SkBitmapChecksummer::Compute64(actualBitmap);
-            add_actual_results_to_json_summary(name.c_str(), actualChecksum,
+            SkHashDigest actualBitmapHash;
+            // TODO(epoger): Better handling for error returned by ComputeDigest()?
+            // For now, we just report a digest of 0 in error cases, like before.
+            if (!SkBitmapHasher::ComputeDigest(actualBitmap, &actualBitmapHash)) {
+                actualBitmapHash = 0;
+            }
+            add_actual_results_to_json_summary(name.c_str(), actualBitmapHash,
                                                ErrorCombination(kMissingExpectations_ErrorType),
                                                false);
             RecordTestResults(ErrorCombination(kMissingExpectations_ErrorType), name, "");
         }
 
         // 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)) {
@@ skipping 224 matching lines @@
     bool fUseFileHierarchy;
     ErrorCombination fIgnorableErrorCombination;
 
     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 checksums, etc.) from.
+    // Where to read expectations (expected image hash digests, etc.) from.
     // If unset, we don't do comparisons.
     SkAutoTUnref<ExpectationsSource> fExpectationsSource;
 
     // JSON summaries that we generate as we go (just for output).
     Json::Value fJsonExpectedResults;
     Json::Value fJsonActualResults_Failed;
     Json::Value fJsonActualResults_FailureIgnored;
     Json::Value fJsonActualResults_NoComparison;
     Json::Value fJsonActualResults_Succeeded;
 
@@ skipping 759 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