Make SkSHA1 and SkM5 use common SkDigestHash result type

gm/gm_expectations.h

Index: gm/gm_expectations.h
===================================================================
--- gm/gm_expectations.h	(revision 8685)
+++ gm/gm_expectations.h	(working copy)
@@ -12,6 +12,7 @@
 #include "SkBitmap.h"
 #include "SkBitmapHasher.h"
 #include "SkData.h"
+#include "SkHashDigest.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
 #include "SkRefCnt.h"
@@ -46,6 +47,23 @@
 namespace skiagm {
 
     // The actual type we use to represent a checksum is hidden in here.
+#ifdef BITMAP_HASH_TYPE_SkHashDigest
+    typedef SkHashDigest Checksum;
+    static inline Json::Value asJsonValue(Checksum checksum) {
+        // TODO(epoger): This creates a new copy of the string representation
+        // of the checksum, by calling Json::duplicateStringValue().
+        // We may want to investigate calling Json::Value(const StaticString &value)
+        // instead, which eliminates the copy but requires that StaticString
+        // to "stick around".
+        return Json::Value(checksum.toHexString().c_str());

[epoger, 2013/04/18 18:07:13]

If this code got the hash digest back as an SkData instead of as an
SkHashDigest, it would need its own code to convert between hex string and the
raw data.  I think it's handy that SkHashDigest provides that...

+    }
+    static inline Checksum asChecksum(Json::Value jsonValue) {
+        SkHashDigest digest;
+        // TODO(epoger): handle error in copyFromHexString()?
+        digest.copyFromHexString(jsonValue.asCString());
+        return digest;
+    }
+#else
     typedef Json::UInt64 Checksum;
     static inline Json::Value asJsonValue(Checksum checksum) {
         return checksum;
@@ -53,6 +71,7 @@
     static inline Checksum asChecksum(Json::Value jsonValue) {
         return jsonValue.asUInt64();
     }
+#endif
 
     static void gm_fprintf(FILE *stream, const char format[], ...) {
         va_list args;
@@ -94,11 +113,10 @@
         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.
+            BITMAP_HASH_TYPE digest;
             if (!SkBitmapHasher::ComputeDigest(bitmap, &digest)) {
-                digest = 0;
+                // TODO(epoger): Better handling for error returned by ComputeDigest()?
+                // For now, we just leave digest empty...
             }
             fAllowedChecksums.push_back() = digest;
         }
@@ -140,6 +158,16 @@
                 } else {
                     for (Json::ArrayIndex i=0; i<allowedChecksums.size(); i++) {
                         Json::Value checksumElement = allowedChecksums[i];
+#ifdef BITMAP_HASH_TYPE_SkHashDigest
+                        if (!checksumElement.isString()) {
+                            gm_fprintf(stderr, "found non-string checksum"
+                                       " in json element '%s'\n",
+                                       jsonElement.toStyledString().c_str());
+                            DEBUGFAIL_SEE_STDERR;
+                        } else {
+                            fAllowedChecksums.push_back() = asChecksum(checksumElement);
+                        }
+#else
                         if (!checksumElement.isIntegral()) {
                             gm_fprintf(stderr, "found non-integer checksum"
                                        " in json element '%s'\n",
@@ -148,6 +176,7 @@
                         } else {
                             fAllowedChecksums.push_back() = asChecksum(checksumElement);
                         }
+#endif
                     }
                 }
             }
@@ -170,7 +199,7 @@
          */
         bool match(Checksum actualChecksum) const {
             for (int i=0; i < this->fAllowedChecksums.count(); i++) {
-                Checksum allowedChecksum = this->fAllowedChecksums[i];
+                BITMAP_HASH_TYPE allowedChecksum = this->fAllowedChecksums[i];
                 if (allowedChecksum == actualChecksum) {
                     return true;
                 }
@@ -197,7 +226,7 @@
             Json::Value allowedChecksumArray;
             if (!this->fAllowedChecksums.empty()) {
                 for (int i=0; i < this->fAllowedChecksums.count(); i++) {
-                    Checksum allowedChecksum = this->fAllowedChecksums[i];
+                    BITMAP_HASH_TYPE allowedChecksum = this->fAllowedChecksums[i];
                     allowedChecksumArray.append(asJsonValue(allowedChecksum));
                 }
             }
@@ -207,7 +236,7 @@
     private:
         const static bool kDefaultIgnoreFailure = false;
 
-        SkTArray<Checksum> fAllowedChecksums;
+        SkTArray<BITMAP_HASH_TYPE> fAllowedChecksums;
         bool fIgnoreFailure;
         SkBitmap fBitmap;
     };