Make WebPrivatePtr capable of wrapping garbage collected objects.

Source/heap/Handle.h

Index: Source/heap/Handle.h
diff --git a/Source/heap/Handle.h b/Source/heap/Handle.h
index 41b840703f0dc09172a6114ec4a17e9f617573d5..0f632a1e8e8fb2e73e9b90b9b88386142075091d 100644
--- a/Source/heap/Handle.h
+++ b/Source/heap/Handle.h
@@ -542,78 +542,43 @@ private:
     Collection m_collection;
 };
 
-// Template aliases for the transition period where we want to support
-// both reference counting and garbage collection based on a
+// CPP-defined type names for the transition period where we want to
+// support both reference counting and garbage collection based on a
 // compile-time flag.
 //
-// With clang we can use c++11 template aliases which is really what
-// we want. For GCC and MSVC we simulate the template aliases with
-// stylized macros until we can use template aliases.
+// C++11 template aliases were initially used (with clang only, not
+// with GCC nor MSVC.) However, supporting both CPP defines and
+// template aliases is problematic from outside a WebCore namespace
+// when Oilpan is disabled: e.g.,
+// WebCore::RefCountedWillBeGarbageCollected as a template alias would
+// uniquely resolve from within any namespace, but if it is backed by
+// a CPP #define, it would expand to WebCore::RefCounted, and not the
+// required WTF::RefCounted.
+//
+// Having the CPP expansion instead be fully namespace qualified, and the
+// transition type be unqualified, would dually not work for template
+// aliases. So, slightly unfortunately, fall back/down to the lowest
+// commmon denominator of using CPP macros only.
 #if ENABLE(OILPAN)
-
-#if COMPILER(CLANG)
-template<typename T> using PassRefPtrWillBeRawPtr = RawPtr<T>;
-template<typename T> using RefCountedWillBeGarbageCollected = GarbageCollected<T>;
-template<typename T> using RefCountedWillBeGarbageCollectedFinalized = GarbageCollectedFinalized<T>;
-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)
+#define PassRefPtrWillBeRawPtr WTF::RawPtr
+#define RefCountedWillBeGarbageCollected WebCore::GarbageCollected
+#define RefCountedWillBeGarbageCollectedFinalized WebCore::GarbageCollectedFinalized
+#define RefCountedWillBeRefCountedGarbageCollected WebCore::RefCountedGarbageCollected
+#define RefPtrWillBePersistent WebCore::Persistent
+#define RefPtrWillBeRawPtr WTF::RawPtr
+#define RefPtrWillBeMember WebCore::Member
+#define RawPtrWillBeMember WebCore::Member
+#define RawPtrWillBeWeakMember WebCore::WeakMember
+#define OwnPtrWillBeMember WebCore::Member
+#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 WillBeHeapVector WebCore::HeapVector
+#define WillBePersistentHeapVector WebCore::PersistentHeapVector
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr)
 {
@@ -651,69 +616,25 @@ public:
     ~DummyBase() { }
 };
 
-#if COMPILER(CLANG)
-template<typename T> using PassRefPtrWillBeRawPtr = PassRefPtr<T>;
-template<typename T> using RefCountedWillBeGarbageCollected = RefCounted<T>;
-template<typename T> using RefCountedWillBeGarbageCollectedFinalized = RefCounted<T>;
-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)
+#define PassRefPtrWillBeRawPtr WTF::PassRefPtr
+#define RefCountedWillBeGarbageCollected WTF::RefCounted
+#define RefCountedWillBeGarbageCollectedFinalized WTF::RefCounted
+#define RefCountedWillBeRefCountedGarbageCollected WTF::RefCounted
+#define RefPtrWillBePersistent WTF::RefPtr
+#define RefPtrWillBeRawPtr WTF::RefPtr
+#define RefPtrWillBeMember WTF::RefPtr
+#define RawPtrWillBeMember WTF::RawPtr
+#define RawPtrWillBeWeakMember WTF::RawPtr
+#define OwnPtrWillBeMember 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 WillBeHeapVector WTF::Vector
+#define WillBePersistentHeapVector WTF::Vector
 
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefWillBeNoop(T* ptr) { return adoptRef(ptr); }
 template<typename T> PassRefPtrWillBeRawPtr<T> adoptRefCountedWillBeRefCountedGarbageCollected(T* ptr) { return adoptRef(ptr); }