Replace GrTHash with SkTDynamicHash

src/gpu/GrBinHashKey.h

Index: src/gpu/GrBinHashKey.h
diff --git a/src/gpu/GrBinHashKey.h b/src/gpu/GrBinHashKey.h
index 585a1a1c018850503b393e4e8cd9741ca3fb839a..06ff93180855f806d1e3af22260ce65c969ed151 100644
--- a/src/gpu/GrBinHashKey.h
+++ b/src/gpu/GrBinHashKey.h
@@ -10,9 +10,67 @@
 #ifndef GrBinHashKey_DEFINED
 #define GrBinHashKey_DEFINED
 
+#include "SkChecksum.h"
 #include "GrTypes.h"
 
 /**
+ *  GrMurmur3HashKey is a hash key class that can take a data chunk of any predetermined
+ *  length. It uses the Murmur3 hash function. It is intended to be used with
+ *  SkTDynamicHash (where GrBinHashKey is for GrTHashTable).
+ */
+template<size_t KEY_SIZE_IN_BYTES>
+class GrMurmur3HashKey {
+public:
+    GrMurmur3HashKey() {
+        this->reset();
+    }
+
+    void reset() {
+        fHash = 0;
+#ifdef SK_DEBUG
+        fIsValid = false;
+#endif
+    }
+
+    void setKeyData(const uint32_t* data) {
+        SK_COMPILE_ASSERT(KEY_SIZE_IN_BYTES % 4 == 0, key_size_mismatch);
+        memcpy(fData, data, KEY_SIZE_IN_BYTES);
+
+        fHash = SkChecksum::Murmur3(fData, KEY_SIZE_IN_BYTES);
+#ifdef SK_DEBUG
+        fIsValid = true;
+#endif
+    }
+
+    bool operator==(const GrMurmur3HashKey& other) const {
+        if (fHash != other.fHash) {

[mtklein, 2014/07/19 14:38:57]

I've always had half a mind to cache the hash inside the table, so this happens
for every user without having to code up another class like this.  Any opinion? 
I always hold back for fear of imposing storage overhead on use cases that don't
need the caching, but maybe we should just try it out if all the big boys are
caching hashes.

[robertphillips, 2014/07/20 16:12:30]

I think it is worth a try.

+            return false;
+        }
+
+        return !memcmp(fData, other.fData, KEY_SIZE_IN_BYTES);
+    }
+
+    uint32_t getHash() const {
+        SkASSERT(fIsValid);
+        return fHash;
+    }
+
+    const uint8_t* getData() const {
+        SkASSERT(fIsValid);
+        return reinterpret_cast<const uint8_t*>(fData);
+    }
+
+private:
+    uint32_t fHash;
+    uint32_t fData[KEY_SIZE_IN_BYTES / sizeof(uint32_t)];  // Buffer for key storage.
+
+#ifdef SK_DEBUG
+public:
+    bool                fIsValid;
+#endif
+};
+
+/**
  *  GrBinHashKey is a hash key class that can take a data chunk of any predetermined
  *  length. The hash function used is the One-at-a-Time Hash
  *  (http://burtleburtle.net/bob/hash/doobs.html).