GM: specify that currently used checksums are CityHashes of SkBitmaps

gm/gm_expectations.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef gm_expectations_DEFINED
 #define gm_expectations_DEFINED
 
 #include <stdarg.h>
@@ skipping 14 matching lines @@
     #pragma warning(disable : 4530)
 #endif
 #include "json/reader.h"
 #include "json/value.h"
 #ifdef SK_BUILD_FOR_WIN
     #pragma warning(pop)
 #endif
 
 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message")
 
+// EPOGER: move these into a .cpp file so we know nobody else uses them?
 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_Checksum[]    = "checksum";
+const static char kJsonKey_ActualResults_AnyStatus_BitmapCityhash[]  = "bitmap-cityhash";
 
 const static char kJsonKey_ExpectedResults[] = "expected-results";
-const static char kJsonKey_ExpectedResults_Checksums[]     = "checksums";
-const static char kJsonKey_ExpectedResults_IgnoreFailure[] = "ignore-failure";
+const static char kJsonKey_ExpectedResults_AllowedBitmapCityhashes[] = "allowed-bitmap-cityhashes";
+const static char kJsonKey_ExpectedResults_IgnoreFailure[]           = "ignore-failure";
 
 namespace skiagm {
 
     // The actual type we use to represent a checksum is hidden in here.
     typedef Json::UInt64 Checksum;
     static inline Json::Value asJsonValue(Checksum checksum) {
         return checksum;
     }
     static inline Checksum asChecksum(Json::Value jsonValue) {
         return jsonValue.asUInt64();
@@ skipping 38 matching lines @@
          */
         Expectations(const SkBitmap& bitmap, bool ignoreFailure=kDefaultIgnoreFailure) {
             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;
             }
-            fAllowedChecksums.push_back() = digest;
+            fAllowedBitmapCityhashes.push_back() = digest;
         }
 
         /**
          * Create Expectations from a JSON element as found within the
          * kJsonKey_ExpectedResults section.
          *
          * It's fine if the jsonElement is null or empty; in that case, we just
          * don't have any 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_Checksums];
+                Json::Value allowedChecksums = jsonElement[kJsonKey_ExpectedResults_AllowedBitmapCityhashes];
                 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_Checksums,
+                               kJsonKey_ExpectedResults_AllowedBitmapCityhashes,
                                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 {
-                            fAllowedChecksums.push_back() = asChecksum(checksumElement);
+                            fAllowedBitmapCityhashes.push_back() = asChecksum(checksumElement);
                         }
                     }
                 }
             }
         }
 
         /**
          * Returns true iff we want to ignore failed expectations.
          */
         bool ignoreFailure() const { return this->fIgnoreFailure; }
 
         /**
          * Returns true iff there are no allowed checksums.
          */
-        bool empty() const { return this->fAllowedChecksums.empty(); }
+        bool empty() const { return this->fAllowedBitmapCityhashes.empty(); }
 
         /**
          * Returns true iff actualChecksum matches any allowedChecksum,
          * regardless of fIgnoreFailure.  (The caller can check
          * that separately.)
          */
         bool match(Checksum actualChecksum) const {
-            for (int i=0; i < this->fAllowedChecksums.count(); i++) {
-                Checksum allowedChecksum = this->fAllowedChecksums[i];
+            for (int i=0; i < this->fAllowedBitmapCityhashes.count(); i++) {
+                Checksum allowedChecksum = this->fAllowedBitmapCityhashes[i];
                 if (allowedChecksum == actualChecksum) {
                     return true;
                 }
             }
             return false;
         }
 
         /**
          * If this Expectation is based on a single SkBitmap, return a
          * pointer to that SkBitmap. Otherwise (if the Expectation is
          * empty, or if it was based on a list of checksums rather
          * than a single bitmap), returns NULL.
          */
         const SkBitmap *asBitmap() const {
             return (SkBitmap::kNo_Config == fBitmap.config()) ? NULL : &fBitmap;
         }
 
         /**
          * Return a JSON representation of the allowed checksums.
          * This does NOT include any information about whether to
          * ignore failures.
          */
         Json::Value allowedChecksumsAsJson() const {
             Json::Value allowedChecksumArray;
-            if (!this->fAllowedChecksums.empty()) {
-                for (int i=0; i < this->fAllowedChecksums.count(); i++) {
-                    Checksum allowedChecksum = this->fAllowedChecksums[i];
+            if (!this->fAllowedBitmapCityhashes.empty()) {
+                for (int i=0; i < this->fAllowedBitmapCityhashes.count(); i++) {
+                    Checksum allowedChecksum = this->fAllowedBitmapCityhashes[i];
                     allowedChecksumArray.append(asJsonValue(allowedChecksum));
                 }
             }
             return allowedChecksumArray;
         }
 
     private:
         const static bool kDefaultIgnoreFailure = false;
 
-        SkTArray<Checksum> fAllowedChecksums;
+        SkTArray<Checksum> fAllowedBitmapCityhashes;
         bool fIgnoreFailure;
         SkBitmap fBitmap;
     };
 
     /**
      * Abstract source of Expectations objects for individual tests.
      */
     class ExpectationsSource : public SkRefCnt {
     public:
         virtual Expectations get(const char *testName) = 0;
@@ skipping 142 matching lines @@
             }
             return true;
         }
 
         Json::Value fJsonRoot;
         Json::Value fJsonExpectedResults;
     };
 
 }
 #endif