Make WebPrivatePtr capable of wrapping garbage collected objects.

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 492 matching lines @@
         ASSERT(this == static_cast<PersistentNode*>(this));
         const char* n = FieldAnnotationBase::fromAddress(this);
         return n ? n : "CollectionPersistent";
     }
 #endif
 
 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.
+// [

[Mads Ager (chromium), 2014/02/18 09:15:39]

I would remove the '[' and ']' here.

+// 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)
 {
     static const bool notRefCountedGarbageCollected = !WTF::IsSubclassOfTemplate<T, RefCountedGarbageCollected>::value;
     static const bool notRefCounted = !WTF::IsSubclassOfTemplate<T, RefCounted>::value;
     COMPILE_ASSERT(notRefCountedGarbageCollected, useAdoptRefCountedWillBeRefCountedGarbageCollected);
     COMPILE_ASSERT(notRefCounted, youMustAdopt);
     return PassRefPtrWillBeRawPtr<T>(ptr);
 }
 
@@ skipping 17 matching lines @@
 
 #else // !ENABLE(OILPAN)
 
 template<typename T>
 class DummyBase {
 public:
     DummyBase() { }
     ~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); }
 template<typename T> PassOwnPtrWillBeRawPtr<T> adoptPtrWillBeNoop(T* ptr) { return adoptPtr(ptr); }
 
 #define WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED WTF_MAKE_FAST_ALLOCATED
 
 #endif // ENABLE(OILPAN)
 
 } // namespace WebCore
@@ skipping 105 matching lines @@
 };
 
 template<typename T> inline T* getPtr(const WebCore::Member<T>& p)
 {
     return p.get();
 }
 
 } // namespace WTF
 
 #endif