SkTDynamicHash: remove need for Equals(const T&, const Key&) param.

src/core/SkTDynamicHash.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 SkTDynamicHash_DEFINED
 #define SkTDynamicHash_DEFINED
 
 #include "SkMath.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 
 template <typename T,
           typename Key,
           const Key& (GetKey)(const T&),
           uint32_t (Hash)(const Key&),
-          bool (Equal)(const T&, const Key&),
           int kGrowPercent = 75>  // Larger -> more memory efficient, but slower.
 class SkTDynamicHash {
 public:
     SkTDynamicHash() : fCount(0), fDeleted(0), fCapacity(0), fArray(NULL) {
         SkASSERT(this->validate());
     }
 
     ~SkTDynamicHash() {
         sk_free(fArray);
     }
@@ skipping 28 matching lines @@
     int count() const { return fCount; }
 
     // Return the entry with this key if we have it, otherwise NULL.
     T* find(const Key& key) const {
         int index = this->firstIndex(key);
         for (int round = 0; round < fCapacity; round++) {
             T* candidate = fArray[index];
             if (Empty() == candidate) {
                 return NULL;
             }
-            if (Deleted() != candidate && Equal(*candidate, key)) {
+            if (Deleted() != candidate && GetKey(*candidate) == key) {
                 return candidate;
             }
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
         return NULL;
     }
 
     // Add an entry with this key.  We require that no entry with newEntry's key is already present.
     void add(T* newEntry) {
@@ skipping 13 matching lines @@
 protected:
     // These methods are used by tests only.
 
     int capacity() const { return fCapacity; }
 
     // How many collisions do we go through before finding where this entry should be inserted?
     int countCollisions(const Key& key) const {
         int index = this->firstIndex(key);
         for (int round = 0; round < fCapacity; round++) {
             const T* candidate = fArray[index];
-            if (Empty() == candidate || Deleted() == candidate || Equal(*candidate, key)) {
+            if (Empty() == candidate || Deleted() == candidate || GetKey(*candidate) == key) {
                 return round;
             }
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
         return 0;
     }
 
 private:
     // We have two special values to indicate an empty or deleted entry.
@@ skipping 29 matching lines @@
             // Are all entries unique?
             for (int i = 0; i < fCapacity; i++) {
                 if (Empty() == fArray[i] || Deleted() == fArray[i]) {
                     continue;
                 }
                 for (int j = i+1; j < fCapacity; j++) {
                     if (Empty() == fArray[j] || Deleted() == fArray[j]) {
                         continue;
                     }
                     SKTDYNAMICHASH_CHECK(fArray[i] != fArray[j]);
-                    SKTDYNAMICHASH_CHECK(!Equal(*fArray[i], GetKey(*fArray[j])));
-                    SKTDYNAMICHASH_CHECK(!Equal(*fArray[j], GetKey(*fArray[i])));
+                    SKTDYNAMICHASH_CHECK(!(GetKey(*fArray[i]) == GetKey(*fArray[j])));
                 }
             }
         }
         #undef SKTDYNAMICHASH_CHECK
         return true;
     }
 
     void innerAdd(T* newEntry) {
         const Key& key = GetKey(*newEntry);
         int index = this->firstIndex(key);
@@ skipping 10 matching lines @@
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
     }
 
     void innerRemove(const Key& key) {
         const int firstIndex = this->firstIndex(key);
         int index = firstIndex;
         for (int round = 0; round < fCapacity; round++) {
             const T* candidate = fArray[index];
-            if (Deleted() != candidate && Equal(*candidate, key)) {
+            if (Deleted() != candidate && GetKey(*candidate) == key) {
                 fDeleted++;
                 fCount--;
                 fArray[index] = Deleted();
                 return;
             }
             index = this->nextIndex(index, round);
         }
         SkASSERT(fCapacity == 0);
     }
 
@@ skipping 34 matching lines @@
         return (index + round + 1) & this->hashMask();
     }
 
     int fCount;     // Number of non Empty(), non Deleted() entries in fArray.
     int fDeleted;   // Number of Deleted() entries in fArray.
     int fCapacity;  // Number of entries in fArray.  Always a power of 2.
     T** fArray;
 };
 
 #endif