Make SkSHA1 and SkM5 use common SkDigestHash result type

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>
 #include "gm.h"
 #include "SkBitmap.h"
 #include "SkBitmapHasher.h"
 #include "SkData.h"
+#include "SkHashDigest.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 
 #ifdef SK_BUILD_FOR_WIN
     // json includes xlocale which generates warning 4530 because we're compiling without
     // exceptions; see https://code.google.com/p/skia/issues/detail?id=1067
     #pragma warning(push)
@@ skipping 14 matching lines @@
 const static char kJsonKey_ActualResults_Succeeded[]     = "succeeded";
 const static char kJsonKey_ActualResults_AnyStatus_Checksum[]    = "checksum";
 
 const static char kJsonKey_ExpectedResults[] = "expected-results";
 const static char kJsonKey_ExpectedResults_Checksums[]     = "checksums";
 const static char kJsonKey_ExpectedResults_IgnoreFailure[] = "ignore-failure";
 
 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;
     }
     static inline Checksum asChecksum(Json::Value jsonValue) {
         return jsonValue.asUInt64();
     }
+#endif
 
     static void gm_fprintf(FILE *stream, const char format[], ...) {
         va_list args;
         va_start(args, format);
         fprintf(stream, "GM: ");
         vfprintf(stream, format, args);
         va_end(args);
     }
 
     static SkString make_filename(const char path[],
@@ skipping 21 matching lines @@
             fIgnoreFailure = ignoreFailure;
         }
 
         /**
          * Expect exactly one image (appropriate for the case when we
          * are comparing against a single PNG file).
          */
         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;
         }
 
         /**
          * 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.
@@ skipping 21 matching lines @@
                     // 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,
                                jsonElement.toStyledString().c_str());
                     DEBUGFAIL_SEE_STDERR;
                 } 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",
                                        jsonElement.toStyledString().c_str());
                             DEBUGFAIL_SEE_STDERR;
                         } else {
                             fAllowedChecksums.push_back() = asChecksum(checksumElement);
                         }
+#endif
                     }
                 }
             }
         }
 
         /**
          * 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(); }
 
         /**
          * 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];
+                BITMAP_HASH_TYPE allowedChecksum = this->fAllowedChecksums[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];
+                    BITMAP_HASH_TYPE allowedChecksum = this->fAllowedChecksums[i];
                     allowedChecksumArray.append(asJsonValue(allowedChecksum));
                 }
             }
             return allowedChecksumArray;
         }
 
     private:
         const static bool kDefaultIgnoreFailure = false;
 
-        SkTArray<Checksum> fAllowedChecksums;
+        SkTArray<BITMAP_HASH_TYPE> fAllowedChecksums;
         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