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

Source/heap/Handle.h

 /*
  * Copyright (C) 2014 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 32 matching lines @@
 
 namespace WebCore {
 
 template<typename T> class HeapTerminatedArray;
 
 #define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage)                                          \
     typedef typename WTF::RemoveConst<T>::Type NonConstType;                                          \
     typedef WTF::IsSubclassOfTemplate<NonConstType, GarbageCollected> GarbageCollectedSubclass;       \
     typedef WTF::IsSubclass<NonConstType, GarbageCollectedMixin> GarbageCollectedMixinSubclass;       \
     typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapHashSet> HeapHashSetSubclass;                \
+    typedef WTF::IsSubclassOfTemplate3<NonConstType, HeapLinkedHashSet> HeapLinkedHashSetSubclass;    \
     typedef WTF::IsSubclassOfTemplate5<NonConstType, HeapHashMap> HeapHashMapSubclass;                \
     typedef WTF::IsSubclassOfTemplateTypenameSize<NonConstType, HeapVector> HeapVectorSubclass;       \
     typedef WTF::IsSubclassOfTemplate<NonConstType, HeapTerminatedArray> HeapTerminatedArraySubclass; \
     COMPILE_ASSERT(GarbageCollectedSubclass::value ||                                                 \
         GarbageCollectedMixinSubclass::value ||                                                       \
         HeapHashSetSubclass::value ||                                                                 \
+        HeapLinkedHashSetSubclass::value ||                                                           \
         HeapHashMapSubclass::value ||                                                                 \
         HeapVectorSubclass::value ||                                                                  \
         HeapTerminatedArraySubclass::value,                                                           \
         ErrorMessage);
 
 template<typename T> class Member;
 
 class PersistentNode {
 public:
     explicit PersistentNode(TraceCallback trace)
@@ skipping 320 matching lines @@
     typename KeyTraitsArg = HashTraits<KeyArg>,
     typename MappedTraitsArg = HashTraits<MappedArg> >
 class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> > { };
 
 template<
     typename ValueArg,
     typename HashArg = typename DefaultHash<ValueArg>::Hash,
     typename TraitsArg = HashTraits<ValueArg> >
 class PersistentHeapHashSet : public PersistentHeapCollectionBase<HeapHashSet<ValueArg, HashArg, TraitsArg> > { };
 
+template<
+    typename ValueArg,
+    typename HashArg = typename DefaultHash<ValueArg>::Hash,
+    typename TraitsArg = HashTraits<ValueArg> >
+class PersistentHeapLinkedHashSet : public PersistentHeapCollectionBase<HeapLinkedHashSet<ValueArg, HashArg, TraitsArg> > { };
+
 template<typename T, size_t inlineCapacity = 0>
 class PersistentHeapVector : public PersistentHeapCollectionBase<HeapVector<T, inlineCapacity> > {
 public:
     PersistentHeapVector() { }
 
     template<size_t otherCapacity>
     PersistentHeapVector(const HeapVector<T, otherCapacity>& other)
         : PersistentHeapCollectionBase<HeapVector<T, inlineCapacity> >(other)
     {
     }
@@ skipping 32 matching lines @@
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
     template<typename U>
     Member(const Persistent<U>& other) : m_raw(other) { }
 
     Member(const Member& other) : m_raw(other) { }
 
     template<typename U>
     Member(const Member<U>& other) : m_raw(other) { }
 
+    template<typename U>
+    Member(const RawPtr<U>& other) : m_raw(other) { }
+
     T* release()
     {
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     template<typename U>
     U* as() const
     {
@@ skipping 136 matching lines @@
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInWeakMember);
     }
 
     template<typename U>
     WeakMember(const Persistent<U>& other) : Member<T>(other) { }
 
     template<typename U>
     WeakMember(const Member<U>& other) : Member<T>(other) { }
 
     template<typename U>
+    WeakMember(const RawPtr<U>& other) : Member<T>(other) { }
+
+    template<typename U>
     WeakMember& operator=(const Persistent<U>& other)
     {
         this->m_raw = other;
         return *this;
     }
 
     template<typename U>
     WeakMember& operator=(const Member<U>& other)
     {
         this->m_raw = other;
@@ skipping 69 matching lines @@
 #define OwnPtrWillBeMember WebCore::Member
 #define OwnPtrWillBePersistent WebCore::Persistent
 #define OwnPtrWillBeRawPtr WTF::RawPtr
 #define PassOwnPtrWillBeRawPtr WTF::RawPtr
 #define NoBaseWillBeGarbageCollected WebCore::GarbageCollected
 #define NoBaseWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinalized
 #define WillBeHeapHashMap WebCore::HeapHashMap
 #define WillBePersistentHeapHashMap WebCore::PersistentHeapHashMap
 #define WillBeHeapHashSet WebCore::HeapHashSet
 #define WillBePersistentHeapHashSet WebCore::PersistentHeapHashSet
+#define WillBeHeapLinkedHashSet WebCore::HeapLinkedHashSet
+#define WillBePersistentHeapLinkedHashSet WebCore::PersistentHeapLinkedHashSet
 #define WillBeHeapVector WebCore::HeapVector
 #define WillBePersistentHeapVector WebCore::PersistentHeapVector
 #define WillBeGarbageCollectedMixin WebCore::GarbageCollectedMixin
 #define WillBeHeapSupplement WebCore::HeapSupplement
 #define WillBeHeapSupplementable WebCore::HeapSupplementable
 #define WillBeHeapTerminatedArray WebCore::HeapTerminatedArray
 #define WillBeHeapTerminatedArrayBuilder WebCore::HeapTerminatedArrayBuilder
 #define WillBeHeapLinkedStack WebCore::HeapLinkedStack
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr)
@@ skipping 50 matching lines @@
 #define OwnPtrWillBeMember WTF::OwnPtr
 #define OwnPtrWillBePersistent WTF::OwnPtr
 #define OwnPtrWillBeRawPtr WTF::OwnPtr
 #define PassOwnPtrWillBeRawPtr WTF::PassOwnPtr
 #define NoBaseWillBeGarbageCollected WebCore::DummyBase
 #define NoBaseWillBeGarbageCollectedFinalized WebCore::DummyBase
 #define WillBeHeapHashMap WTF::HashMap
 #define WillBePersistentHeapHashMap WTF::HashMap
 #define WillBeHeapHashSet WTF::HashSet
 #define WillBePersistentHeapHashSet WTF::HashSet
+#define WillBeHeapLinkedHashSet WTF::LinkedHashSet
+#define WillBePersistentLinkedHeapHashSet WTF::LinkedHashSet
 #define WillBeHeapVector WTF::Vector
 #define WillBePersistentHeapVector WTF::Vector
 #define WillBeGarbageCollectedMixin WebCore::DummyBase<void>
 #define WillBeHeapSupplement WebCore::Supplement
 #define WillBeHeapSupplementable WebCore::Supplementable
 #define WillBeHeapTerminatedArray WTF::TerminatedArray
 #define WillBeHeapTerminatedArrayBuilder WTF::TerminatedArrayBuilder
 #define WillBeHeapLinkedStack WTF::LinkedStack
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { return adoptRef(ptr); }
@@ skipping 161 matching lines @@
 template<typename T, size_t N>
 struct NeedsTracing<Vector<T, N> > {
     static const bool value = false;
 };
 
 template<typename T, size_t N>
 struct NeedsTracing<Deque<T, N> > {
     static const bool value = false;
 };
 
-template<typename T>
-struct NeedsTracing<HashSet<T> > {
+template<typename T, typename U, typename V>
+struct NeedsTracing<HashSet<T, U, V> > {
     static const bool value = false;
 };
 
-template<typename T>
-struct NeedsTracing<ListHashSet<T> > {
+template<typename T, size_t U, typename V>
+struct NeedsTracing<ListHashSet<T, U, V> > {
     static const bool value = false;
 };
 
-template<typename T, typename U>
-struct NeedsTracing<HashMap<T, U> > {
+template<typename T, typename U, typename V>
+struct NeedsTracing<LinkedHashSet<T, U, V> > {
     static const bool value = false;
 };
 
+template<typename T, typename U, typename V, typename W, typename X>
+struct NeedsTracing<HashMap<T, U, V, W, X> > {
+    static const bool value = false;
+};
+
 } // namespace WTF
 
 #endif