Create HeapLinkedHashSet and LinkedHashSet, ordered heap-friendly hash sets.

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 21 matching lines @@
 #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/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTraits.h"
+#include "wtf/LinkedHashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TypeTraits.h"
 
 #ifndef NDEBUG
 #define DEBUG_ONLY(x) x
 #else
 #define DEBUG_ONLY(x)
 #endif
 
 namespace WebCore {
 
 class FinalizedHeapObjectHeader;
 template<typename T> class GarbageCollectedFinalized;
 class HeapObjectHeader;
 template<typename T> class Member;
 template<typename T> class WeakMember;
 class Visitor;
 
-template<bool needsTracing, bool isWeak, bool markWeakMembersStrongly, typename T, typename Traits> struct CollectionBackingTraceTrait;
+enum ShouldWeakPointersBeMarkedStrongly {
+    WeakPointersActStrong,
+    WeakPointersActWeak
+};
+
+template<bool needsTracing, bool isWeak, ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
 
 // The TraceMethodDelegate is used to convert a trace method for type T to a TraceCallback.
 // This allows us to pass a type's trace method as a parameter to the PersistentNode
 // constructor. The PersistentNode constructor needs the specific trace method due an issue
 // with the Windows compiler which instantiates even unused variables. This causes problems
 // in header files where we have only forward declarations of classes.
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
     static void trampoline(Visitor* visitor, void* self) { (reinterpret_cast<T*>(self)->*method)(visitor); }
 };
@@ skipping 182 matching lines @@
     {
         OffHeapCollectionTraceTrait<HashSet<T, U, V, WTF::DefaultAllocator> >::trace(this, hashSet);
     }
 
     template<typename T, size_t inlineCapacity, typename U>
     void trace(const ListHashSet<T, inlineCapacity, U>& hashSet)
     {
         OffHeapCollectionTraceTrait<ListHashSet<T, inlineCapacity, U> >::trace(this, hashSet);
     }
 
+    template<typename T, typename U>
+    void trace(const LinkedHashSet<T, U>& hashSet)
+    {
+        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, 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);
@@ skipping 125 matching lines @@
 struct OffHeapCollectionTraceTrait<WTF::HashSet<T, HashFunctions, Traits, WTF::DefaultAllocator> > {
     typedef WTF::HashSet<T, HashFunctions, Traits, WTF::DefaultAllocator> HashSet;
 
     static void trace(Visitor* visitor, const HashSet& set)
     {
         if (set.isEmpty())
             return;
         if (WTF::ShouldBeTraced<Traits>::value) {
             HashSet& iterSet = const_cast<HashSet&>(set);
             for (typename HashSet::iterator it = iterSet.begin(), end = iterSet.end(); it != end; ++it)
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, false, T, Traits>::mark(visitor, *it);
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<Traits>::value, Traits::isWeak, WeakPointersActWeak, T, Traits>::mark(visitor, *it);
         }
         COMPILE_ASSERT(!Traits::isWeak, WeakOffHeapCollectionsConsideredDangerous0);
     }
 };
 
 template<typename T, size_t inlineCapacity, typename HashFunctions>
 struct OffHeapCollectionTraceTrait<WTF::ListHashSet<T, inlineCapacity, HashFunctions> > {
     typedef WTF::ListHashSet<T, inlineCapacity, HashFunctions> ListHashSet;
 
     static void trace(Visitor* visitor, const ListHashSet& set)
     {
         if (set.isEmpty())
             return;
         ListHashSet& iterSet = const_cast<ListHashSet&>(set);
         for (typename ListHashSet::iterator it = iterSet.begin(), end = iterSet.end(); it != end; ++it)
             visitor->trace(*it);
     }
 };
 
+template<typename T, typename HashFunctions>
+struct OffHeapCollectionTraceTrait<WTF::LinkedHashSet<T, HashFunctions> > {
+    typedef WTF::LinkedHashSet<T, HashFunctions> LinkedHashSet;
+
+    static void trace(Visitor* visitor, const LinkedHashSet& set)
+    {
+        if (set.isEmpty())
+            return;
+        LinkedHashSet& iterSet = const_cast<LinkedHashSet&>(set);
+        for (typename LinkedHashSet::iterator it = iterSet.begin(), end = iterSet.end(); it != end; ++it)
+            visitor->trace(*it);
+    }
+};
+
 template<typename Key, typename Value, typename HashFunctions, typename KeyTraits, typename ValueTraits>
 struct OffHeapCollectionTraceTrait<WTF::HashMap<Key, Value, HashFunctions, KeyTraits, ValueTraits, WTF::DefaultAllocator> > {
     typedef WTF::HashMap<Key, Value, HashFunctions, KeyTraits, ValueTraits, WTF::DefaultAllocator> HashMap;
 
     static void trace(Visitor* visitor, const HashMap& map)
     {
         if (map.isEmpty())
             return;
         if (WTF::ShouldBeTraced<KeyTraits>::value || WTF::ShouldBeTraced<ValueTraits>::value) {
             HashMap& iterMap = const_cast<HashMap&>(map);
             for (typename HashMap::iterator it = iterMap.begin(), end = iterMap.end(); it != end; ++it) {
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<KeyTraits>::value, KeyTraits::isWeak, false, Key, KeyTraits>::mark(visitor, it->key);
-                CollectionBackingTraceTrait<WTF::ShouldBeTraced<ValueTraits>::value, ValueTraits::isWeak, false, Value, ValueTraits>::mark(visitor, it->value);
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<KeyTraits>::value, KeyTraits::isWeak, WeakPointersActWeak, Key, KeyTraits>::mark(visitor, it->key);
+                CollectionBackingTraceTrait<WTF::ShouldBeTraced<ValueTraits>::value, ValueTraits::isWeak, WeakPointersActWeak, Value, ValueTraits>::mark(visitor, it->value);
             }
         }
         COMPILE_ASSERT(!KeyTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous1);
         COMPILE_ASSERT(!ValueTraits::isWeak, WeakOffHeapCollectionsConsideredDangerous2);
     }
 };
 
 // We trace vectors by using the trace trait on each element, which means you
 // can have vectors of general objects (not just pointers to objects) that can
 // be traced.
@@ skipping 166 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif