SkTHash: hash from fnptr to functor type

include/private/SkTHash.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkTHash_DEFINED
 #define SkTHash_DEFINED
 
@@ skipping 173 matching lines @@
         T val;
         uint32_t hash;
     };
 
     int fCount, fRemoved, 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&) = &SkGoodHash>
+template <typename K, typename V, typename HashK = 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 35 matching lines @@
     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 uint32_t Hash(const K& key) { return HashK()(key); }
     };
 
     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&) = &SkGoodHash>
+template <typename T, typename HashT = 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(); }
 
@@ skipping 18 matching lines @@
 
     // Call fn on every item in the set.  You may not mutate anything.
     template <typename Fn>  // f(T), f(const T&)
     void foreach (Fn&& fn) const {
         fTable.foreach(fn);
     }
 
 private:
     struct Traits {
         static const T& GetKey(const T& item) { return item; }
-        static uint32_t Hash(const T& item) { return HashT(item); }
+        static uint32_t Hash(const T& item) { return HashT()(item); }
     };
     SkTHashTable<T, T, Traits> fTable;
 };
 
 #endif//SkTHash_DEFINED