GM: create GmResultDigest that encapsulates digest type ("bitmap-64bitMD5") and value (12345)

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 "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 711 matching lines @@
      *        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 char *shortName, const char *configName,
                                              const char *renderModeDescriptor,
                                              bool addToJsonSummary) {
         ErrorCombination errors;
-        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;
-        }
+        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(actualBitmapHash)) {
+        } 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);
                 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, shortNamePlusConfig, renderModeDescriptor);
 
         if (addToJsonSummary) {
-            add_actual_results_to_json_summary(completeName, actualBitmapHash, errors,
+            add_actual_results_to_json_summary(completeName, actualResultDigest, 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 errors encountered.
      */
     void add_actual_results_to_json_summary(const char testName[],
-                                            const SkHashDigest& actualResult,
+                                            const GmResultDigest &actualResultDigest,
                                             ErrorCombination errors,
                                             bool ignoreFailure) {
-        Json::Value jsonActualResults = ActualResultAsJsonValue(actualResult);
+        Json::Value jsonActualResults = actualResultDigest.asJsonTypeValuePair();
         if (errors.isEmpty()) {
             this->fJsonActualResults_Succeeded[testName] = jsonActualResults;
         } 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).
@@ skipping 65 matching lines @@
              * 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,
                                                gm->shortName(), gRec.fName, "", true));
         } else {
             // If we are running without expectations, we still want to
             // record the actual results.
-            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(nameWithExtension.c_str(), actualBitmapHash,
+            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.
@@ skipping 1173 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