Make SkSHA1 and SkM5 use common SkDigestHash result type

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 696 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 SkString& baseNameString,
                                              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.
+        BITMAP_HASH_TYPE actualBitmapHash;
         if (!SkBitmapHasher::ComputeDigest(actualBitmap, &actualBitmapHash)) {
-            actualBitmapHash = 0;
+            // TODO(epoger): Better handling for error returned by ComputeDigest()?
+            // For now, we just leave actualBitmapHash empty.
         }
         SkString completeNameString = baseNameString;
         completeNameString.append(renderModeDescriptor);
         const char* completeName = completeNameString.c_str();
 
         if (expectations.empty()) {
             errors.add(kMissingExpectations_ErrorType);
         } else if (!expectations.match(actualBitmapHash)) {
             addToJsonSummary = true;
             // The error mode we record depends on whether this was running
@@ skipping 29 matching lines @@
         }
 
         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[],
-                                            const SkHashDigest& actualBitmapHash,
+                                            const BITMAP_HASH_TYPE& actualBitmapHash,
                                             ErrorCombination result,
                                             bool ignoreFailure) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_AnyStatus_Checksum] =
             asJsonValue(actualBitmapHash);
         if (result.isEmpty()) {
             this->fJsonActualResults_Succeeded[testName] = actualResults;
         } else {
             if (ignoreFailure) {
                 // TODO: Once we have added the ability to compare
@@ skipping 75 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(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.
-            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.
+            BITMAP_HASH_TYPE actualBitmapHash;
             if (!SkBitmapHasher::ComputeDigest(actualBitmap, &actualBitmapHash)) {
-                actualBitmapHash = 0;
+                // TODO(epoger): Better handling for error returned by ComputeDigest()?
+                // For now, we just leave actualBitmapHash empty.
             }
             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
@@ skipping 702 matching lines @@
         if (i > 0) {
             total.append(", ");
         }
         total.append("\"");
         total.append(gRec[configs[i]].fName);
         total.append("\"");
     }
     return total;
 }
 
+// Set this temporary macro to print out timing info.
+#define EPOGER_TIMER
+#ifdef EPOGER_TIMER
+#include "SkTime.h"
+#endif
+
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
 
 #if SK_ENABLE_INST_COUNT
     gPrintInstCount = true;
 #endif
 
+#ifdef EPOGER_TIMER
+    SkMSec startTime = SkTime::GetMSecs();
+#endif
+
     SkGraphics::Init();
     // we don't need to see this during a run
     gSkSuppressFontCachePurgeSpew = true;
 
     setSystemPreferences();
     GMMain gmmain;
 
     SkTDArray<size_t> configs;
     SkTDArray<size_t> excludeConfigs;
     bool userConfig = false;
@@ skipping 228 matching lines @@
     }
 
     SkTArray<SkString> modes;
     gmmain.GetRenderModesEncountered(modes);
     bool reportError = false;
     if (gmmain.NumSignificantErrors() > 0) {
         reportError = true;
     }
     int expectedNumberOfTests = gmsRun * (configs.count() + modes.count());
 
+#ifdef EPOGER_TIMER
+    SkMSec middleTime = SkTime::GetMSecs();
+#endif
+
     // Output summary to stdout.
     if (FLAGS_verbose) {
         gm_fprintf(stdout, "Ran %d GMs\n", gmsRun);
         gm_fprintf(stdout, "... over %2d configs [%s]\n", configs.count(),
                    list_all_config_names(configs).c_str());
         gm_fprintf(stdout, "...  and %2d modes   [%s]\n", modes.count(), list_all(modes).c_str());
         gm_fprintf(stdout, "... so there should be a total of %d tests.\n", expectedNumberOfTests);
     }
     gmmain.ListErrors(FLAGS_verbose);
 
     // TODO(epoger): Enable this check for Android, too, once we resolve
     // https://code.google.com/p/skia/issues/detail?id=1222
     // ('GM is unexpectedly skipping tests on Android')
 #ifndef SK_BUILD_FOR_ANDROID
     if (expectedNumberOfTests != gmmain.fTestsRun) {
         gm_fprintf(stderr, "expected %d tests, but ran or skipped %d tests\n",
                    expectedNumberOfTests, gmmain.fTestsRun);
         reportError = true;
     }
 #endif
 
+#ifdef EPOGER_TIMER
+    Json::Value actualResults;
+    actualResults[kJsonKey_ActualResults_Failed] =
+        gmmain.fJsonActualResults_Failed;
+    actualResults[kJsonKey_ActualResults_FailureIgnored] =
+        gmmain.fJsonActualResults_FailureIgnored;
+    actualResults[kJsonKey_ActualResults_NoComparison] =
+        gmmain.fJsonActualResults_NoComparison;
+    actualResults[kJsonKey_ActualResults_Succeeded] =
+        gmmain.fJsonActualResults_Succeeded;
+    Json::Value root;
+    root[kJsonKey_ActualResults] = actualResults;
+    root[kJsonKey_ExpectedResults] = gmmain.fJsonExpectedResults;
+    std::string jsonStdString = root.toStyledString();
+    printf("%s\n", jsonStdString.c_str());
+#endif
+
     if (FLAGS_writeJsonSummaryPath.count() == 1) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] =
             gmmain.fJsonActualResults_Failed;
         actualResults[kJsonKey_ActualResults_FailureIgnored] =
             gmmain.fJsonActualResults_FailureIgnored;
         actualResults[kJsonKey_ActualResults_NoComparison] =
             gmmain.fJsonActualResults_NoComparison;
         actualResults[kJsonKey_ActualResults_Succeeded] =
             gmmain.fJsonActualResults_Succeeded;
@@ skipping 17 matching lines @@
             gm_fprintf(stdout, "config: %s %x\n", config.fName, gr);
             gr->printCacheStats();
         }
     }
 #endif
 
     delete grFactory;
 #endif
     SkGraphics::Term();
 
+#ifdef EPOGER_TIMER
+    SkMSec endTime = SkTime::GetMSecs();
+    printf("EPOGER timings: start-middle=%d msecs, start-end=%d msecs\n",
+           (middleTime - startTime), (endTime - startTime));
+#endif
+
     return (reportError) ? -1 : 0;
 }
 
 void GMMain::installFilter(SkCanvas* canvas) {
     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