Use HashSet instead of Dynamic hash for tracking vulkan resources

src/gpu/vk/GrVkResource.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 GrVkResource_DEFINED
 #define GrVkResource_DEFINED
 
 #include "SkAtomics.h"
-#include "SkTDynamicHash.h"
 #include "SkRandom.h"
+#include "SkTHash.h"
 
 class GrVkGpu;
 
 // uncomment to enable tracing of resource refs
 #ifdef SK_DEBUG
 #define SK_TRACE_VK_RESOURCES
 #endif
 
 /** \class GrVkResource
 
   GrVkResource is the base class for Vulkan resources that may be shared by multiple
   objects. When an existing owner wants to share a reference, it calls ref().
   When an owner wants to release its reference, it calls unref(). When the
   shared object's reference count goes to zero as the result of an unref()
   call, its (virtual) destructor is called. It is an error for the
   destructor to be called explicitly (or via the object going out of scope on
   the stack or calling delete) if getRefCnt() > 1.
 
   This is nearly identical to SkRefCntBase. The exceptions are that unref()
   takes a GrVkGpu, and any derived classes must implement freeGPUData() and
   possibly abandonSubResources().
 */
 
 class GrVkResource : SkNoncopyable {
 public:
     // Simple refCount tracing, to ensure that everything ref'ed is unref'ed.
 #ifdef SK_TRACE_VK_RESOURCES
-    static const uint32_t& GetKey(const GrVkResource& r) { return r.fKey; }
-    static uint32_t Hash(const uint32_t& k) { return k; }
+    struct Hash {
+        uint32_t operator()(const GrVkResource* const& r) const {
+            SkASSERT(r);
+            return r->fKey;
+        }
+    };
 
     class Trace {
     public:
         ~Trace() {
-            if (fHash.count()) {
-                SkTDynamicHash<GrVkResource, uint32_t>::Iter iter(&fHash);
-                for (; !iter.done(); ++iter) {
-                    (*iter).dumpInfo();
-                }
-            }
-            SkASSERT(0 == fHash.count());
+            fHashSet.foreach([](const GrVkResource* r) {
+                r->dumpInfo();
+            });
+            SkASSERT(0 == fHashSet.count());
         }
-        void add(GrVkResource* r) { fHash.add(r); }
-        void remove(const GrVkResource* r) { fHash.remove(GetKey(*r)); }
+        void add(const GrVkResource* r) { fHashSet.add(r); }
+        void remove(const GrVkResource* r) { fHashSet.remove(r); }
 
     private:
-        SkTDynamicHash<GrVkResource, uint32_t> fHash;
+        SkTHashSet<const GrVkResource*, GrVkResource::Hash> fHashSet;
     };
     static Trace  fTrace;
 
     static uint32_t fKeyCounter;
 #endif
 
     /** Default construct, initializing the reference count to 1.
      */
     GrVkResource() : fRefCnt(1) {
 #ifdef SK_TRACE_VK_RESOURCES
@@ skipping 133 matching lines @@
         } else {
             this->unref(gpu);
         }
     }
 
 private:
     virtual void onRecycle(GrVkGpu* gpu) const = 0;
 };
 
 #endif