Add HeapHashCountedSet

Source/platform/heap/Visitor.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 18 matching lines @@
  */
 
 #ifndef Visitor_h
 #define Visitor_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/ThreadState.h"
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/Forward.h"
+#include "wtf/HashCountedSet.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTraits.h"
 #include "wtf/InstanceCounter.h"
 #include "wtf/LinkedHashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TypeTraits.h"
 #include "wtf/WeakPtr.h"
@@ skipping 242 matching lines @@
     {
         OffHeapCollectionTraceTrait<LinkedHashSet<T, U> >::trace(this, hashSet);
     }
 
     template<typename T, size_t N>
     void trace(const Deque<T, N>& deque)
     {
         OffHeapCollectionTraceTrait<Deque<T, N> >::trace(this, deque);
     }
 
+    template<typename T, typename U, typename V>
+    void trace(const HashCountedSet<T, U, V>& set)
+    {
+        OffHeapCollectionTraceTrait<HashCountedSet<T, U, V> >::trace(this, set);
+    }
+
     template<typename T, typename U, typename V, typename W, typename X>
     void trace(const HashMap<T, U, V, W, X, WTF::DefaultAllocator>& map)
     {
         OffHeapCollectionTraceTrait<HashMap<T, U, V, W, X, WTF::DefaultAllocator> >::trace(this, map);
     }
 
     // OwnPtrs that are traced are treated as part objects and the
     // trace method of the owned object is called.
     template<typename T>
     void trace(const OwnPtr<T>& t)
@@ skipping 228 matching lines @@
 
     static void trace(Visitor* visitor, const Deque& deque)
     {
         if (deque.isEmpty())
             return;
         for (typename Deque::const_iterator it = deque.begin(), end = deque.end(); it != end; ++it)
             TraceTrait<T>::trace(visitor, const_cast<T*>(&(*it)));
     }
 };
 
+template<typename T, typename U, typename V>
+struct OffHeapCollectionTraceTrait<WTF::HashCountedSet<T, U, V> > {
+    typedef WTF::HashCountedSet<T, U, V> Set;
+
+    static void trace(Visitor* visitor, const Set& set)
+    {
+        if (set.isEmpty())
+            return;
+        for (typename Set::const_iterator it = set.begin(), end = set.end(); it != end; ++it)
+            TraceTrait<T>::trace(visitor, const_cast<T*>(&(it->key)));
+    }
+};
+
 template<typename T, typename Traits = WTF::VectorTraits<T> >
 class HeapVectorBacking;
 
 template<typename Table>
 class HeapHashTableBacking {
 public:
     static void finalize(void* pointer);
 };
 
 template<typename T>
@@ skipping 145 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif