Port GrGLCaps over to use SkTHash.

src/core/SkTHash.h

 #ifndef SkTHash_DEFINED
 #define SkTHash_DEFINED
 
 #include "SkTypes.h"
 #include "SkTemplates.h"
 
 // Before trying to use SkTHashTable, look below to see if SkTHashMap or SkTHashSet works for you.
 // They're easier to use, usually perform the same, and have fewer sharp edges.
 
 // T and K are treated as ordinary copyable C++ types.
 // Traits must have:
 //   - static K GetKey(T)
 //   - static uint32_t Hash(K)
 // If the key is large and stored inside T, you may want to make K a const&.
 // Similarly, if T is large you might want it to be a pointer.
 template <typename T, typename K, typename Traits = T>
 class SkTHashTable : SkNoncopyable {
 public:
     SkTHashTable() : fCount(0), fCapacity(0) {}
 
+    // Clear the table.
+    void reset() {
+        this->~SkTHashTable();
+        SkNEW_PLACEMENT(this, SkTHashTable);
+    }
+
     // How many entries are in the table?
     int count() const { return fCount; }
 
     // !!!!!!!!!!!!!!!!!                 CAUTION                   !!!!!!!!!!!!!!!!!
     // set(), find() and foreach() all allow mutable access to table entries.
     // If you change an entry so that it no longer has the same key, all hell
     // will break loose.  Do not do that!
     //
     // Please prefer to use SkTHashMap or SkTHashSet, which do not have this danger.
 
@@ skipping 106 matching lines @@
     SkAutoTArray<Slot> fSlots;
 };
 
 // Maps K->V.  A more user-friendly wrapper around SkTHashTable, suitable for most use cases.
 // K and V are treated as ordinary copyable C++ types, with no assumed relationship between the two.
 template <typename K, typename V, uint32_t(*HashK)(const K&)>
 class SkTHashMap : SkNoncopyable {
 public:
     SkTHashMap() {}
 
+    // Clear the map.
+    void reset() { fTable.reset(); }
+
     // How many key/value pairs are in the table?
     int count() const { return fTable.count(); }
 
     // N.B. The pointers returned by set() and find() are valid only until the next call to set().
 
     // Set key to val in the table, replacing any previous value with the same key.
     // We copy both key and val, and return a pointer to the value copy now in the table.
     V* set(const K& key, const V& val) {
         Pair in = { key, val };
         Pair* out = fTable.set(in);
@@ skipping 23 matching lines @@
 
     SkTHashTable<Pair, K> fTable;
 };
 
 // A set of T.  T is treated as an ordiary copyable C++ type.
 template <typename T, uint32_t(*HashT)(const T&)>
 class SkTHashSet : SkNoncopyable {
 public:
     SkTHashSet() {}
 
+    // Clear the set.
+    void reset() { fTable.reset(); }
+
     // How many items are in the set?
     int count() const { return fTable.count(); }
 
     // Copy an item into the set.
     void add(const T& item) { fTable.set(item); }
 
     // Is this item in the set?
     bool contains(const T& item) const { return SkToBool(fTable.find(item)); }
 
 private:
     struct Traits {
         static const T& GetKey(const T& item) { return item; }
         static uint32_t Hash(const T& item) { return HashT(item); }
     };
     SkTHashTable<T, T, Traits> fTable;
 };
 
 #endif//SkTHash_DEFINED