rename SkBitmapChecksummer as SkBitmapHasher, and prepare for it to possibly use

tests/BitmapHasherTest.cpp

Index: tests/BitmapHasherTest.cpp
===================================================================
--- tests/BitmapHasherTest.cpp	(revision 8614)
+++ tests/BitmapHasherTest.cpp	(working copy)
@@ -1,6 +1,6 @@
 
 /*
- * Copyright 2012 Google Inc.
+ * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
@@ -8,105 +8,24 @@
 #include "Test.h"
 
 #include "SkBitmap.h"
-#include "SkBitmapChecksummer.h"
-#include "SkChecksum.h"
-#include "SkCityHash.h"
+#include "SkBitmapHasher.h"
 #include "SkColor.h"
 
 // Word size that is large enough to hold results of any checksum type.
 typedef uint64_t checksum_result;
 
 namespace skiatest {
-    class ChecksumTestClass : public Test {
+    class BitmapHasherTestClass : public Test {
     public:
-        static Test* Factory(void*) {return SkNEW(ChecksumTestClass); }
+        static Test* Factory(void*) {return SkNEW(BitmapHasherTestClass); }
     protected:
-        virtual void onGetName(SkString* name) { name->set("Checksum"); }
+        virtual void onGetName(SkString* name) { name->set("BitmapHasher"); }
         virtual void onRun(Reporter* reporter) {
             this->fReporter = reporter;
             RunTest();
         }
     private:
-        enum Algorithm {
-            kSkChecksum,
-            kSkCityHash32,
-            kSkCityHash64
-        };
 
-        // Call Compute(data, size) on the appropriate checksum algorithm,
-        // depending on this->fWhichAlgorithm.
-        checksum_result ComputeChecksum(const char *data, size_t size) {
-            switch(fWhichAlgorithm) {
-            case kSkChecksum:
-                REPORTER_ASSERT_MESSAGE(fReporter,
-                                        reinterpret_cast<uintptr_t>(data) % 4 == 0,
-                                        "test data pointer is not 32-bit aligned");
-                REPORTER_ASSERT_MESSAGE(fReporter, SkIsAlign4(size),
-                                        "test data size is not 32-bit aligned");
-                return SkChecksum::Compute(reinterpret_cast<const uint32_t *>(data), size);
-            case kSkCityHash32:
-                return SkCityHash::Compute32(data, size);
-            case kSkCityHash64:
-                return SkCityHash::Compute64(data, size);
-            default:
-                SkString message("fWhichAlgorithm has unknown value ");
-                message.appendf("%d", fWhichAlgorithm);
-                fReporter->reportFailed(message);
-            }
-            // we never get here
-            return 0;
-        }
-
-        // Confirm that the checksum algorithm (specified by fWhichAlgorithm)
-        // generates the same results if called twice over the same data.
-        void TestChecksumSelfConsistency(size_t buf_size) {
-            SkAutoMalloc storage(buf_size);
-            char* ptr = reinterpret_cast<char *>(storage.get());
-
-            REPORTER_ASSERT(fReporter,
-                            GetTestDataChecksum(8, 0) ==
-                            GetTestDataChecksum(8, 0));
-            REPORTER_ASSERT(fReporter,
-                            GetTestDataChecksum(8, 0) !=
-                            GetTestDataChecksum(8, 1));
-
-            sk_bzero(ptr, buf_size);
-            checksum_result prev = 0;
-
-            // assert that as we change values (from 0 to non-zero) in
-            // our buffer, we get a different value
-            for (size_t i = 0; i < buf_size; ++i) {
-                ptr[i] = (i & 0x7f) + 1; // need some non-zero value here
-
-                // Try checksums of different-sized chunks, but always
-                // 32-bit aligned and big enough to contain all the
-                // nonzero bytes.  (Remaining bytes will still be zero
-                // from the initial sk_bzero() call.)
-                size_t checksum_size = (((i/4)+1)*4);
-                REPORTER_ASSERT(fReporter, checksum_size <= buf_size);
-
-                checksum_result curr = ComputeChecksum(ptr, checksum_size);
-                REPORTER_ASSERT(fReporter, prev != curr);
-                checksum_result again = ComputeChecksum(ptr, checksum_size);
-                REPORTER_ASSERT(fReporter, again == curr);
-                prev = curr;
-            }
-        }
-
-        // Return the checksum of a buffer of bytes 'len' long.
-        // The pattern of values within the buffer will be consistent
-        // for every call, based on 'seed'.
-        checksum_result GetTestDataChecksum(size_t len, char seed=0) {
-            SkAutoMalloc storage(len);
-            char* start = reinterpret_cast<char *>(storage.get());
-            char* ptr = start;
-            for (size_t i = 0; i < len; ++i) {
-                *ptr++ = ((seed+i) & 0x7f);
-            }
-            checksum_result result = ComputeChecksum(start, len);
-            return result;
-        }
-
         // Fill in bitmap with test data.
         void CreateTestBitmap(SkBitmap &bitmap, SkBitmap::Config config, int width, int height,
                               SkColor color) {
@@ -117,69 +36,29 @@
         }
 
         void RunTest() {
-            // Test self-consistency of checksum algorithms.
-            fWhichAlgorithm = kSkChecksum;
-            TestChecksumSelfConsistency(128);
-            fWhichAlgorithm = kSkCityHash32;
-            TestChecksumSelfConsistency(128);
-            fWhichAlgorithm = kSkCityHash64;
-            TestChecksumSelfConsistency(128);
-
-            // Test checksum results that should be consistent across
-            // versions and platforms.
-            fWhichAlgorithm = kSkChecksum;
-            REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0);
-            fWhichAlgorithm = kSkCityHash32;
-            REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0xdc56d17a);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(4)   == 0x616e1132);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(8)   == 0xeb0fd2d6);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x5321e430);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x924a10e4);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xd4de9dc9);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0xecf0325d);
-            fWhichAlgorithm = kSkCityHash64;
-            REPORTER_ASSERT(fReporter, ComputeChecksum(NULL, 0) == 0x9ae16a3b2f90404fULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(4)   == 0x82bffd898958e540ULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(8)   == 0xad5a13e1e8e93b98ULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(128) == 0x10b153630af1f395ULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(132) == 0x7db71dc4adcc6647ULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(256) == 0xeee763519b91b010ULL);
-            REPORTER_ASSERT(fReporter, GetTestDataChecksum(260) == 0x2fe19e0b2239bc23ULL);
-
-            // TODO: note the weakness exposed by these collisions...
-            // We need to improve the SkChecksum algorithm.
-            // We would prefer that these asserts FAIL!
-            // Filed as https://code.google.com/p/skia/issues/detail?id=981
-            // ('SkChecksum algorithm allows for way too many collisions')
-            fWhichAlgorithm = kSkChecksum;
-            REPORTER_ASSERT(fReporter,
-                GetTestDataChecksum(128) == GetTestDataChecksum(256));
-            REPORTER_ASSERT(fReporter,
-                GetTestDataChecksum(132) == GetTestDataChecksum(260));
-
-            // Test SkBitmapChecksummer
+            // Test SkBitmapHasher
             SkBitmap bitmap;
+            SkHashDigest digest;
             // initial test case
             CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 333, 555, SK_ColorBLUE);
-            REPORTER_ASSERT(fReporter,
-                            SkBitmapChecksummer::Compute64(bitmap) == 0x18f9df68b1b02f38ULL);
+            REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &digest));
+            REPORTER_ASSERT(fReporter, digest == 0x18f9df68b1b02f38ULL);
             // same pixel data but different dimensions should yield a different checksum
             CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_ColorBLUE);
-            REPORTER_ASSERT(fReporter,
-                            SkBitmapChecksummer::Compute64(bitmap) == 0x6b0298183f786c8eULL);
+            REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &digest));
+            REPORTER_ASSERT(fReporter, digest == 0x6b0298183f786c8eULL);
             // same dimensions but different color should yield a different checksum
             CreateTestBitmap(bitmap, SkBitmap::kARGB_8888_Config, 555, 333, SK_ColorGREEN);
-            REPORTER_ASSERT(fReporter,
-                            SkBitmapChecksummer::Compute64(bitmap) == 0xc6b4b3f6fadaaf37ULL);
+            REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &digest));
+            REPORTER_ASSERT(fReporter, digest == 0xc6b4b3f6fadaaf37ULL);
             // same pixel colors in a different config should yield the same checksum
             CreateTestBitmap(bitmap, SkBitmap::kARGB_4444_Config, 555, 333, SK_ColorGREEN);
-            REPORTER_ASSERT(fReporter,
-                            SkBitmapChecksummer::Compute64(bitmap) == 0xc6b4b3f6fadaaf37ULL);
+            REPORTER_ASSERT(fReporter, SkBitmapHasher::ComputeDigest(bitmap, &digest));
+            REPORTER_ASSERT(fReporter, digest == 0xc6b4b3f6fadaaf37ULL);
         }
 
         Reporter* fReporter;
-        Algorithm fWhichAlgorithm;
     };
 
-    static TestRegistry gReg(ChecksumTestClass::Factory);
+    static TestRegistry gReg(BitmapHasherTestClass::Factory);
 }