Some usability ideas around 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.
@@ skipping 47 matching lines @@
             if (hash == s.hash && key == Traits::GetKey(s.val)) {
                 return &s.val;
             }
             index = this->next(index, n);
         }
         SkASSERT(fCapacity == 0);
         return NULL;
     }
 
     // Call fn on every entry in the table.  You may mutate the entries, but be very careful.
-    template <typename Arg>
-    void foreach(void(*fn)(T*, Arg), Arg arg) {
+    template <typename Fn>  // f(T*)
+    void foreach(Fn&& fn) {
         for (int i = 0; i < fCapacity; i++) {
-            Slot& s = fSlots[i];
-            if (!s.empty()) {
-                fn(&s.val, arg);
+            if (!fSlots[i].empty()) {
+                fn(&fSlots[i].val);
             }
         }
     }
+
+    // Call fn on every entry in the table.  You may not mutate anything.
+    template <typename Fn>  // f(T) or f(const T&)
+    void foreach(Fn&& fn) const {
+        for (int i = 0; i < fCapacity; i++) {
+            if (!fSlots[i].empty()) {
+                fn(fSlots[i].val);
+            }
+        }
+    }
 
 private:
     T* uncheckedSet(const T& val) {
         const K& key = Traits::GetKey(val);
         uint32_t hash = Hash(key);
         int index = hash & (fCapacity-1);
         for (int n = 0; n < fCapacity; n++) {
             Slot& s = fSlots[index];
             if (s.empty()) {
                 // New entry.
@@ skipping 51 matching lines @@
         T val;
         uint32_t hash;
     };
 
     int fCount, fCapacity;
     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&)>
+template <typename K, typename V, uint32_t(*HashK)(const K&) = &SkGoodHash>
 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(); }
 
@@ skipping 10 matching lines @@
     // If there is key/value entry in the table with this key, return a pointer to the value.
     // If not, return NULL.
     V* find(const K& key) const {
         if (Pair* p = fTable.find(key)) {
             return &p->val;
         }
         return NULL;
     }
 
     // Call fn on every key/value pair in the table.  You may mutate the value but not the key.
-    void foreach(void(*fn)(K, V*)) { fTable.foreach(ForEach, fn); }
+    template <typename Fn>  // f(K, V*) or f(const K&, V*)
+    void foreach(Fn&& fn) {
+        fTable.foreach([&fn](Pair* p){ fn(p->key, &p->val); });
+    }
+
+    // Call fn on every key/value pair in the table.  You may not mutate anything.
+    template <typename Fn>  // f(K, V), f(const K&, V), f(K, const V&) or f(const K&, const V&).
+    void foreach(Fn&& fn) const {
+        fTable.foreach([&fn](const Pair& p){ fn(p.key, p.val); });
+    }
 
 private:
     struct Pair {
         K key;
         V val;
         static const K& GetKey(const Pair& p) { return p.key; }
         static uint32_t Hash(const K& key) { return HashK(key); }
     };
-    static void ForEach(Pair* p, void (*fn)(K, V*)) { fn(p->key, &p->val); }
 
     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&)>
+template <typename T, uint32_t(*HashT)(const T&) = &SkGoodHash>
 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