GM: now that we use MD5 instead of CityHash, the JSON should say so

gm/gm_expectations.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm_expectations.h"
 #include "SkBitmapHasher.h"
 #include "SkImageDecoder.h"
 
 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message")
 
 const static char kJsonKey_ActualResults[]   = "actual-results";
 const static char kJsonKey_ActualResults_Failed[]        = "failed";
 const static char kJsonKey_ActualResults_FailureIgnored[]= "failure-ignored";
 const static char kJsonKey_ActualResults_NoComparison[]  = "no-comparison";
 const static char kJsonKey_ActualResults_Succeeded[]     = "succeeded";
-const static char kJsonKey_ActualResults_AnyStatus_BitmapCityhash[]  = "bitmap-cityhash";
+#ifdef BITMAPHASHER_USES_TRUNCATED_MD5
+const static char kJsonKey_ActualResults_AnyStatus_BitmapHash[]  = "bitmap-64bitMD5";
+#else
+const static char kJsonKey_ActualResults_AnyStatus_BitmapHash[]  = "bitmap-cityhash";
+#endif
 
 const static char kJsonKey_ExpectedResults[] = "expected-results";
-const static char kJsonKey_ExpectedResults_AllowedBitmapCityhashes[] = "allowed-bitmap-cityhashes";
+#ifdef BITMAPHASHER_USES_TRUNCATED_MD5
+const static char kJsonKey_ExpectedResults_AllowedBitmapHashes[] = "allowed-bitmap-64bitMD5s";
+#else
+const static char kJsonKey_ExpectedResults_AllowedBitmapHashes[] = "allowed-bitmap-cityhashes";
+#endif
 const static char kJsonKey_ExpectedResults_IgnoreFailure[]           = "ignore-failure";
 
 namespace skiagm {
 
     // TODO(epoger): This currently assumes that the result SkHashDigest was
-    // generated as a CityHash of an SkBitmap.  We'll need to allow for other
-    // hash types to cover non-bitmaps, MD5 instead of CityHash, etc.
+    // generated as an SkHashDigest of an SkBitmap.  We'll need to allow for other
+    // hash types to cover non-bitmaps.
     Json::Value ActualResultAsJsonValue(const SkHashDigest& result) {
         Json::Value jsonValue;
-        jsonValue[kJsonKey_ActualResults_AnyStatus_BitmapCityhash] = asJsonValue(result);
+        jsonValue[kJsonKey_ActualResults_AnyStatus_BitmapHash] = asJsonValue(result);
         return jsonValue;
     }
 
     Json::Value CreateJsonTree(Json::Value expectedResults,
                                Json::Value actualResultsFailed,
                                Json::Value actualResultsFailureIgnored,
                                Json::Value actualResultsNoComparison,
                                Json::Value actualResultsSucceeded) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] = actualResultsFailed;
@@ skipping 15 matching lines @@
 
     Expectations::Expectations(const SkBitmap& bitmap, bool ignoreFailure) {
         fBitmap = bitmap;
         fIgnoreFailure = ignoreFailure;
         SkHashDigest digest;
         // 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(bitmap, &digest)) {
             digest = 0;
         }
-        fAllowedBitmapCityhashes.push_back() = digest;
+        fAllowedBitmapChecksums.push_back() = digest;
     }
 
     Expectations::Expectations(Json::Value jsonElement) {
         if (jsonElement.empty()) {
             fIgnoreFailure = kDefaultIgnoreFailure;
         } else {
             Json::Value ignoreFailure = jsonElement[kJsonKey_ExpectedResults_IgnoreFailure];
             if (ignoreFailure.isNull()) {
                 fIgnoreFailure = kDefaultIgnoreFailure;
             } else if (!ignoreFailure.isBool()) {
                 gm_fprintf(stderr, "found non-boolean json value"
                            " for key '%s' in element '%s'\n",
                            kJsonKey_ExpectedResults_IgnoreFailure,
                            jsonElement.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
                 fIgnoreFailure = kDefaultIgnoreFailure;
             } else {
                 fIgnoreFailure = ignoreFailure.asBool();
             }
 
             Json::Value allowedChecksums =
-                jsonElement[kJsonKey_ExpectedResults_AllowedBitmapCityhashes];
+                jsonElement[kJsonKey_ExpectedResults_AllowedBitmapHashes];
             if (allowedChecksums.isNull()) {
                 // ok, we'll just assume there aren't any expected checksums to compare against
             } else if (!allowedChecksums.isArray()) {
                 gm_fprintf(stderr, "found non-array json value"
                            " for key '%s' in element '%s'\n",
-                           kJsonKey_ExpectedResults_AllowedBitmapCityhashes,
+                           kJsonKey_ExpectedResults_AllowedBitmapHashes,
                            jsonElement.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
             } else {
                 for (Json::ArrayIndex i=0; i<allowedChecksums.size(); i++) {
                     Json::Value checksumElement = allowedChecksums[i];
                     if (!checksumElement.isIntegral()) {
                         gm_fprintf(stderr, "found non-integer checksum"
                                    " in json element '%s'\n",
                                    jsonElement.toStyledString().c_str());
                         DEBUGFAIL_SEE_STDERR;
                     } else {
-                        fAllowedBitmapCityhashes.push_back() = asChecksum(checksumElement);
+                        fAllowedBitmapChecksums.push_back() = asChecksum(checksumElement);
                     }
                 }
             }
         }
     }
 
     bool Expectations::match(Checksum actualChecksum) const {
-        for (int i=0; i < this->fAllowedBitmapCityhashes.count(); i++) {
-            Checksum allowedChecksum = this->fAllowedBitmapCityhashes[i];
+        for (int i=0; i < this->fAllowedBitmapChecksums.count(); i++) {
+            Checksum allowedChecksum = this->fAllowedBitmapChecksums[i];
             if (allowedChecksum == actualChecksum) {
                 return true;
             }
         }
         return false;
     }
 
     Json::Value Expectations::asJsonValue() const {
         Json::Value allowedChecksumArray;
-        if (!this->fAllowedBitmapCityhashes.empty()) {
-            for (int i=0; i < this->fAllowedBitmapCityhashes.count(); i++) {
-                Checksum allowedChecksum = this->fAllowedBitmapCityhashes[i];
+        if (!this->fAllowedBitmapChecksums.empty()) {
+            for (int i=0; i < this->fAllowedBitmapChecksums.count(); i++) {
+                Checksum allowedChecksum = this->fAllowedBitmapChecksums[i];
                 allowedChecksumArray.append(Json::UInt64(allowedChecksum));
             }
         }
 
         Json::Value jsonValue;
-        jsonValue[kJsonKey_ExpectedResults_AllowedBitmapCityhashes] = allowedChecksumArray;
+        jsonValue[kJsonKey_ExpectedResults_AllowedBitmapHashes] = allowedChecksumArray;
         jsonValue[kJsonKey_ExpectedResults_IgnoreFailure] = this->ignoreFailure();
         return jsonValue;
     }
 
 
     // IndividualImageExpectationsSource class...
 
     Expectations IndividualImageExpectationsSource::get(const char *testName) {
         SkString path = make_filename(fRootDir.c_str(), "", testName,
                                       "png");
@@ skipping 60 matching lines @@
         Json::Reader reader;
         if (!reader.parse(bytes, bytes+size, *jsonRoot)) {
             gm_fprintf(stderr, "error parsing JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
         return true;
     }
 
 }