Persistent variants of the GC collection types.

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 245 matching lines @@
         m_raw = other;
         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
     T* m_raw;
 };
 
+template<
+    typename KeyArg,
+    typename MappedArg,
+    typename HashArg = typename DefaultHash<KeyArg>::Hash,
+    typename KeyTraitsArg = HashTraits<KeyArg>,
+    typename MappedTraitsArg = HashTraits<MappedArg> >
+class PersistentHeapHashMap : public HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> {
+public:
+    PersistentHeapHashMap() : m_self(this) { }
+private:
+    Persistent<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg> > m_self;
+};
+
+template<
+    typename ValueArg,
+    typename HashArg = typename DefaultHash<ValueArg>::Hash,
+    typename TraitsArg = HashTraits<ValueArg> >
+class PersistentHeapHashSet : public HeapHashSet<ValueArg, HashArg, TraitsArg> {
+public:
+    PersistentHeapHashSet() : m_self(this) { }
+private:
+    Persistent<HeapHashSet<ValueArg, HashArg, TraitsArg> > m_self;
+};
+
+template<typename T, size_t inlineCapacity = 0>
+class PersistentHeapVector : public HeapVector<T, inlineCapacity> {
+public:
+    PersistentHeapVector() : m_self(this) { }
+private:
+    Persistent<HeapVector<T, inlineCapacity> > m_self;
+};
+
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
 template<typename T>
 class Member {
 public:
     Member() : m_raw(0) { }
 
@@ skipping 208 matching lines @@
 template<typename T> using RefCountedWillBeRefCountedGarbageCollected = RefCountedGarbageCollected<T>;
 template<typename T> using RefPtrWillBePersistent = Persistent<T>;
 template<typename T> using RefPtrWillBeRawPtr = RawPtr<T>;
 template<typename T> using RefPtrWillBeMember = Member<T>;
 template<typename T> using RawPtrWillBeMember = Member<T>;
 template<typename T> using RawPtrWillBeWeakMember = WeakMember<T>;
 template<typename T> using OwnPtrWillBeMember = Member<T>;
 template<typename T> using PassOwnPtrWillBeRawPtr = RawPtr<T>;
 template<typename T> using NoBaseWillBeGarbageCollected = GarbageCollected<T>;
 template<typename T> using NoBaseWillBeGarbageCollectedFinalized = GarbageCollectedFinalized<T>;
+template<
+    typename K,
+    typename V,
+    typename H = typename DefaultHash<K>::Hash,
+    typename KT = HashTraits<K>,
+    typename VT = HashTraits<V> >
+using WillBeHeapHashMap = HeapHashMap<K, V, H, KT, VT>;
+template<
+    typename K,
+    typename V,
+    typename H = typename DefaultHash<K>::Hash,
+    typename KT = HashTraits<K>,
+    typename VT = HashTraits<V> >
+using WillBePersistentHeapHashMap = PersistentHeapHashMap<K, V, H, KT, VT>;
+template<
+    typename V,
+    typename H = typename DefaultHash<V>::Hash,
+    typename T = HashTraits<V> >
+using WillBeHeapHashSet = HeapHashSet<V, H, T>;
+template<
+    typename V,
+    typename H = typename DefaultHash<V>::Hash,
+    typename T = HashTraits<V> >
+using WillBePersistentHeapHashSet = PersistentHeapHashSet<V, H, T>;
+template<typename T, size_t inlineCapacity = 0>
+using WillBeHeapVector = HeapVector<T, inlineCapacity>;
+template<typename T, size_t inlineCapacity = 0>
+using WillBePersistentHeapVector = PersistentHeapVector<T, inlineCapacity>;
 #else // !COMPILER(CLANG)
 #define PassRefPtrWillBeRawPtr RawPtr
 #define RefCountedWillBeGarbageCollected GarbageCollected
 #define RefCountedWillBeGarbageCollectedFinalized GarbageCollectedFinalized
 #define RefCountedWillBeRefCountedGarbageCollected RefCountedGarbageCollected
 #define RefPtrWillBePersistent Persistent
 #define RefPtrWillBeRawPtr RawPtr
 #define RefPtrWillBeMember Member
 #define RawPtrWillBeMember Member
 #define RawPtrWillBeWeakMember WeakMember
 #define OwnPtrWillBeMember Member
 #define PassOwnPtrWillBeRawPtr RawPtr
 #define NoBaseWillBeGarbageCollected GarbageCollected
 #define NoBaseWillBeGarbageCollectedFinalized GarbageCollectedFinalized
+#define WillBeHeapHashMap HeapHashMap
+#define WillBePersistentHeapHashMap PersistentHeapHashMap
+#define WillBeHeapHashSet HeapHashSet
+#define WillBePersistentHeapHashSet PersistentHeapHashSet
+#define WillBeHeapVector HeapVector
+#define WillBePersistentHeapVector PersistentHeapVector
 #endif // COMPILER(CLANG)
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { return PassRefPtrWillBeRawPtr<T>(ptr); }
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefCountedWillBeRefCountedGarbageCollected(T* ptr)
 {
     return PassRefPtrWillBeRawPtr<T>(adoptRefCountedGarbageCollected(ptr));
 }
 
 template<typename T> PassOwnPtrWillBeRawPtr<T> adoptPtrWillBeNoop(T* ptr) { return PassOwnPtrWillBeRawPtr<T>(ptr); }
@@ skipping 14 matching lines @@
 template<typename T> using RefCountedWillBeRefCountedGarbageCollected = RefCounted<T>;
 template<typename T> using RefPtrWillBePersistent = RefPtr<T>;
 template<typename T> using RefPtrWillBeRawPtr = RefPtr<T>;
 template<typename T> using RefPtrWillBeMember = RefPtr<T>;
 template<typename T> using RawPtrWillBeMember = RawPtr<T>;
 template<typename T> using RawPtrWillBeWeakMember = RawPtr<T>;
 template<typename T> using OwnPtrWillBeMember = OwnPtr<T>;
 template<typename T> using PassOwnPtrWillBeRawPtr = PassOwnPtr<T>;
 template<typename T> using NoBaseWillBeGarbageCollected = DummyBase<T>;
 template<typename T> using NoBaseWillBeGarbageCollectedFinalized = DummyBase<T>;
+template<
+    typename K,
+    typename V,
+    typename H = typename DefaultHash<K>::Hash,
+    typename KT = HashTraits<K>,
+    typename VT = HashTraits<V> >
+using WillBeHeapHashMap = HashMap<K, V, H, KT, VT>;
+template<
+    typename K,
+    typename V,
+    typename H = typename DefaultHash<K>::Hash,
+    typename KT = HashTraits<K>,
+    typename VT = HashTraits<V> >
+using WillBePersistentHeapHashMap = HashMap<K, V, H, KT, VT>;
+template<
+    typename V,
+    typename H = typename DefaultHash<V>::Hash,
+    typename T = HashTraits<V> >
+using WillBeHeapHashSet = HashSet<V, H, T>;
+template<
+    typename V,
+    typename H = typename DefaultHash<V>::Hash,
+    typename T = HashTraits<V> >
+using WillBePersistentHeapHashSet = HashSet<V, H, T>;
+template<typename T, size_t inlineCapacity = 0>
+using WillBeHeapVector = Vector<T, inlineCapacity>;
+template<typename T, size_t inlineCapacity = 0>
+using WillBePersistentHeapVector = Vector<T, inlineCapacity>;
 #else // !COMPILER(CLANG)
 #define PassRefPtrWillBeRawPtr PassRefPtr
 #define RefCountedWillBeGarbageCollected RefCounted
 #define RefCountedWillBeGarbageCollectedFinalized RefCounted
 #define RefCountedWillBeRefCountedGarbageCollected RefCounted
 #define RefPtrWillBePersistent RefPtr
 #define RefPtrWillBeRawPtr RefPtr
 #define RefPtrWillBeMember RefPtr
 #define RawPtrWillBeMember RawPtr
 #define RawPtrWillBeWeakMember RawPtr
 #define OwnPtrWillBeMember OwnPtr
 #define PassOwnPtrWillBeRawPtr PassOwnPtr
 #define NoBaseWillBeGarbageCollected DummyBase
 #define NoBaseWillBeGarbageCollectedFinalized DummyBase
+#define WillBeHeapHashMap HashMap
+#define WillBePersistentHeapHashMap HashMap
+#define WillBeHeapHashSet HashSet
+#define WillBePersistentHeapHashSet HashSet
+#define WillBeHeapVector Vector
+#define WillBePersistentHeapVector Vector
 #endif // COMPILER(CLANG)
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { return adoptRef(ptr); }
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefCountedWillBeRefCountedGarbageCollected(T* ptr) { return adoptRef(ptr); }
 template<typename T> PassOwnPtrWillBeRawPtr<T> adoptPtrWillBeNoop(T* ptr) { return adoptPtr(ptr); }
 
 #endif // ENABLE(OILPAN)
 
 } // namespace WebCore
 
@@ skipping 99 matching lines @@
 };
 
 template<typename Key, typename Value, typename Extractor, typename Traits, typename KeyTraits>
 struct IsWeak<WebCore::HeapHashTableBacking<Key, Value, Extractor, Traits, KeyTraits> > {
     static const bool value = Traits::isWeak;
 };
 
 } // namespace WTF
 
 #endif