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

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 "gm.h"
@@ skipping 12 matching lines @@
     #pragma warning(disable : 4530)
 #endif
 #include "json/reader.h"
 #include "json/value.h"
 #ifdef SK_BUILD_FOR_WIN
     #pragma warning(pop)
 #endif
 
 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();
-    }
-
     void gm_fprintf(FILE *stream, const char format[], ...);
 
     /**
      * Assembles rootPath and relativePath into a single path, like this:
      * rootPath/relativePath
      *
      * Uses SkPATH_SEPARATOR, to work on all platforms.
      *
      * TODO(epoger): This should probably move into SkOSFile.h
      */
     SkString SkPathJoin(const char *rootPath, const char *relativePath);
 
-    Json::Value ActualResultAsJsonValue(const SkHashDigest& result);
+    Json::Value ActualResultAsJsonValue(uint64_t result);
 
     Json::Value CreateJsonTree(Json::Value expectedResults,
                                Json::Value actualResultsFailed,
                                Json::Value actualResultsFailureIgnored,
                                Json::Value actualResultsNoComparison,
                                Json::Value actualResultsSucceeded);
 
     /**
-     * Test expectations (allowed image checksums, etc.)
+     * The digest of a GM test result.
+     *
+     * Currently, this is always a uint64_t hash digest of an SkBitmap...
+     * but we will add other flavors soon.
+     */
+    class GmResultDigest {

[epoger, 2013/05/23 18:19:12]

In patchset 2, we replace the Checksum typedef with a new GmResultDigest class
that specifies both digest type and value.

Currently, there is only one result digest type ("bitmap-64bitMD5"), which takes
a uint64_t value.  This is exactly the same as before, so there is no behavioral
change, and the GM self-tests still pass.

+    public:
+        /**
+         * Create a ResultDigest representing an actual image result.
+         */
+        GmResultDigest(const SkBitmap &bitmap);
+
+        /**
+         * Create a ResultDigest representing an allowed result
+         * checksum within JSON expectations file.
+         *
+         * TODO(epoger): Replace this constructor with one that takes
+         * a JSON type/value pair, such as ["bitmap-64bitMD5", 12345].
+         */
+        GmResultDigest(uint64_t checksum);
+
+        /**
+         * Returns true if this and other GmResultDigest could
+         * represent identical results.
+         */
+        bool equals(const GmResultDigest &other) const;
+
+        /**
+         * Returns a JSON type/value pair representing this result,
+         * such as ["bitmap-64bitMD5", 12345].
+         */
+        Json::Value asJsonTypeValuePair() const;
+
+        /**
+         * Returns the value of this GmResultDigest (perhaps a bitmap hash?)
+         * as a Json::Value.
+         *
+         * TODO(epoger): delete this method; make callers use
+         * asJsonTypeValuePair() instead, so that the callers won't
+         * make any assumptions about what type of ResultDigest this
+         * is.
+         */
+        Json::Value getValueAsJsonValue() const;
+
+    private:
+        uint64_t fHashDigest;
+    };
+
+    /**
+     * Test expectations (allowed image results, etc.)
      */
     class Expectations {
     public:
         /**
          * No expectations at all.
          */
         Expectations(bool ignoreFailure=kDefaultIgnoreFailure);
 
         /**
          * Expect exactly one image (appropriate for the case when we
          * are comparing against a single PNG file).
          */
         Expectations(const SkBitmap& bitmap, bool ignoreFailure=kDefaultIgnoreFailure);
 
         /**
          * 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);
 
         /**
          * Returns true iff we want to ignore failed expectations.
          */
         bool ignoreFailure() const { return this->fIgnoreFailure; }
 
         /**
-         * Returns true iff there are no allowed checksums.
+         * Returns true iff there are no allowed results.
          */
-        bool empty() const { return this->fAllowedBitmapChecksums.empty(); }
+        bool empty() const { return this->fAllowedResultDigests.empty(); }
 
         /**
-         * Returns true iff actualChecksum matches any allowedChecksum,
+         * Returns true iff resultDigest matches any allowed result,
          * regardless of fIgnoreFailure.  (The caller can check
          * that separately.)
          */
-        bool match(Checksum actualChecksum) const;
+        bool match(GmResultDigest resultDigest) const;
 
         /**
          * 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 expectations.
          */
         Json::Value asJsonValue() const;
 
     private:
         const static bool kDefaultIgnoreFailure = false;
 
-        SkTArray<Checksum> fAllowedBitmapChecksums;
+        SkTArray<GmResultDigest> fAllowedResultDigests;
         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 83 matching lines @@
          * Returns true if successful.
          */
         static bool Parse(const char *jsonPath, Json::Value *jsonRoot);
 
         Json::Value fJsonRoot;
         Json::Value fJsonExpectedResults;
     };
 
 }
 #endif