Replace GrTHash with SkTDynamicHash

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
 
@@ skipping 39 matching lines @@
             } while (!this->done() && (this->current() == Empty() || this->current() == Deleted()));
         }
 
     private:
         T* current() const { return fHash->fArray[fCurrentIndex]; }
 
         SkTDynamicHash* fHash;
         int fCurrentIndex;
     };
 
+    class ConstIter {
+    public:
+        explicit ConstIter(const SkTDynamicHash* hash) : fHash(hash), fCurrentIndex(-1) {
+            SkASSERT(hash);
+            ++(*this);
+        }
+        bool done() const {
+            SkASSERT(fCurrentIndex <= fHash->fCapacity);
+            return fCurrentIndex == fHash->fCapacity;
+        }
+        const T& operator*() const {
+            SkASSERT(!this->done());
+            return *this->current();
+        }
+        void operator++() {
+            do {
+                fCurrentIndex++;
+            } while (!this->done() && (this->current() == Empty() || this->current() == Deleted()));
+        }
+
+    private:
+        const T* current() const { return fHash->fArray[fCurrentIndex]; }
+
+        const SkTDynamicHash* fHash;
+        int fCurrentIndex;
+    };
+
     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++) {
             SkASSERT(index >= 0 && index < fCapacity);
             T* candidate = fArray[index];
             if (Empty() == candidate) {
                 return NULL;
             }
             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) {
         SkASSERT(NULL == this->find(GetKey(*newEntry)));
         this->maybeGrow();
         this->innerAdd(newEntry);
         SkASSERT(this->validate());
     }
 
-    // Remove the entry with this key.  We reqire that an entry with this key is present.
+    // Remove the entry with this key.  We require that an entry with this key is present.
     void remove(const Key& key) {
         SkASSERT(NULL != this->find(key));
         this->innerRemove(key);
         SkASSERT(this->validate());
     }
 
+    void rewind() {
+        if (NULL != fArray) {
+            sk_bzero(fArray, sizeof(T*)* fCapacity);
+        }
+        fCount = 0;
+        fDeleted = 0;
+    }
+
+    void reset() { 
+        fCount = 0; 
+        fDeleted = 0; 
+        fCapacity = 0; 
+        sk_free(fArray); 
+        fArray = NULL; 
+    }
+
+    // Note: functor is passed by value
+    template<class Functor>

[mtklein, 2014/07/17 19:36:20]

I'd add a space between template and <

[robertphillips, 2014/07/17 20:02:46]

Done.

+    void mutateAll(Functor f) {
+        for (int i = 0; i < fCapacity; ++i) {
+            if (Empty() != fArray[i] && Deleted() != fArray[i]) {
+                f(*fArray[i]);
+            }
+        }
+    }
+
 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++) {
             SkASSERT(index >= 0 && index < fCapacity);
@@ skipping 132 matching lines @@
     static const Key& GetKey(const T& t) { return Traits::GetKey(t); }
     static uint32_t Hash(const Key& key) { return Traits::Hash(key); }
 
     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