Add template aliases to support both reference counting and garbage collection for a transition per…

Source/heap/Handle.h

Index: Source/heap/Handle.h
diff --git a/Source/heap/Handle.h b/Source/heap/Handle.h
index 8ca68efd6659e0b5cb1843000e0705793977f97d..cfce89a2b68d3472bf88cb34d07ccff086ee8482 100644
--- a/Source/heap/Handle.h
+++ b/Source/heap/Handle.h
@@ -35,6 +35,9 @@
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
+#include "wtf/Ptr.h"
+#include "wtf/RefCounted.h"
+
 namespace WebCore {
 
 template<typename T> class Member;
@@ -174,6 +177,9 @@ public:
     Persistent(const Member<U>& other) : m_raw(other) { }
 
     template<typename U>
+    Persistent(const Ptr<U>& other) : m_raw(other.get()) { }
+
+    template<typename U>
     Persistent& operator=(U* other)
     {
         m_raw = other;
@@ -205,6 +211,7 @@ public:
     bool operator!() const { return !m_raw; }
 
     operator T*() const { return m_raw; }
+    operator Ptr<T>() const { return Ptr<T>(m_raw); }
 
     T* operator->() const { return *this; }
 
@@ -404,6 +411,88 @@ template<typename T, typename U> inline bool operator!=(const Persistent<T>& a,
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 
+// Template aliases for the transition period where we want to support
+// both reference counting and garbage collection based on the
+// enable_oilpan 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.
+#if ENABLE_OILPAN

[Vyacheslav Egorov (Chromium), 2014/01/15 14:21:10]

Should not this be #if ENABLE(OILPAN) ?

[Mads Ager (chromium), 2014/01/15 14:51:14]

Yes, thanks.

+
+#if COMPILER(CLANG)

[Vyacheslav Egorov (Chromium), 2014/01/15 14:21:10]

While this is indeed very robust compared to defines, I think it might be better
to use the same code on all platforms we deploy to. 

I would say that OilPan move most likely will be complete before we will find
ourselves in situation where we can use template aliases on all platforms.

[Mads Ager (chromium), 2014/01/15 14:51:14]

I agree with that assessment. The reason for using the template aliases here was
that it will keep us honest and makes it clear that these are just templated
typedefs. It will keep us from doing nasty things with the macros that is not
just a typedef.

+template<typename T> using PassRefPtrWillBePtr = Ptr<T>;

[jbroman, 2014/01/15 14:37:09]

Why use template aliases on Clang if we're still going to be using preprocessor
macros for other compilers? This would be even more weird if other reviewers
insist on SHOUTY_CASE macros.

Also, maybe consider whether this condition should use a wtf/Compiler.h macro
(e.g. COMPILER_SUPPORTS(CXX_TEMPLATE_ALIASES)). Not sure this is the right place
for assumptions about which features which compilers support.

[Mads Ager (chromium), 2014/01/15 14:51:14]

To keep us honest so that we cannot do anything nasty with the macros that is
not just a typedef. This approach only works if we allow the CamelCase macros.

+template<typename T> using RefCountedWillBeGarbageCollected = GarbageCollected<T>;
+template<typename T> using RefCountedWillBeGarbageCollectedFinalized = GarbageCollectedFinalized<T>;
+template<typename T> using RefPtrWillBePersistent = Persistent<T>;
+template<typename T> using RefPtrWillBePtr = Ptr<T>;
+template<typename T> using RefPtrWillBeMember = Member<T>;
+template<typename T> using PtrWillBeMember = Member<T>;
+template<typename T> using PtrWillBeWeakMember = WeakMember<T>;
+template<typename T> using OwnPtrWillBeMember = Member<T>;
+template<typename T> using PassOwnPtrWillBePtr = Ptr<T>;
+template<typename T> using NoBaseWillBeGarbageCollected = GarbageCollected<T>;
+template<typename T> using NoBaseWillBeGarbageCollectedFinalized = GarbageCollectedFinalized<T>;
+#else // !COMPILER(CLANG)
+#define PassRefPtrWillBePtr Ptr

[Vyacheslav Egorov (Chromium), 2014/01/15 14:21:10]

There are two lists which might be a hassle to keep in sync (also conditional
define is enormous in size. How about

#if ENABLE(OILPAN)
#  define SWITCH(Current, WillBe) WillBe
#else
#  define SWITCH(Current, WillBe) Current
#endif

#define PassRefPtrWillBePtr SWITCH(PassRefPtr, Ptr)
#define OwnPtrWillBeMember SWITCH(OwnPtr, Member)
// ... etc ...

#undef SWITCH

I think this is easier to read and maintain.

If you decide to keep CLANG variant too we can think about unifying all of them
into this.

[Mads Ager (chromium), 2014/01/15 14:51:14]

That can be done and it sounds like a good idea. I'll do that if we can agree
that this is a reasonable compromise.

+#define RefCountedWillBeGarbageCollected GarbageCollected
+#define RefCountedWillBeGarbageCollectedFinalized GarbageCollectedFinalized
+#define RefPtrWillBePersistent Persistent
+#define RefPtrWillBePtr Ptr
+#define RefPtrWillBeMember Member
+#define PtrWillBeMember Member
+#define PtrWillBeWeakMember WeakMember
+#define OwnPtrWillBeMember Member
+#define PassOwnPtrWillBePtr Ptr
+#define NoBaseWillBeGarbageCollected GarbageCollected
+#define NoBaseWillBeGarbageCollectedFinalized GarbageCollectedFinalized
+#endif // COMPILER(CLANG)
+
+template<typename T> PassRefPtrWillBePtr<T> adoptRefWillBeNoop(T* ptr) { return PassRefPtrWillBePtr<T>(ptr); }
+template<typename T> PassOwnPtrWillBePtr<T> adoptPtrWillBeNoop(T* ptr) { return PassOwnPtrWillBePtr<T>(ptr); }
+
+#else // !ENABLE_OILPAN
+
+template<typename T>
+class DummyBase {
+public:
+    DummyBase() { }
+    ~DummyBase() { }
+};
+
+#if COMPILER(CLANG)
+template<typename T> using PassRefPtrWillBePtr = PassRefPtr<T>;
+template<typename T> using RefCountedWillBeGarbageCollected = RefCounted<T>;
+template<typename T> using RefCountedWillBeGarbageCollectedFinalized = RefCounted<T>;
+template<typename T> using RefPtrWillBePersistent = RefPtr<T>;
+template<typename T> using RefPtrWillBePtr = RefPtr<T>;
+template<typename T> using RefPtrWillBeMember = RefPtr<T>;
+template<typename T> using PtrWillBeMember = Ptr<T>;
+template<typename T> using PtrWillBeWeakMember = Ptr<T>;
+template<typename T> using OwnPtrWillBeMember = OwnPtr<T>;
+template<typename T> using PassOwnPtrWillBePtr = PassOwnPtr<T>;
+template<typename T> using NoBaseWillBeGarbageCollected = DummyBase<T>;
+template<typename T> using NoBaseWillBeGarbageCollectedFinalized = DummyBase<T>;
+#else // !COMPILER(CLANG)
+#define PassRefPtrWillBePtr PassRefPtr
+#define RefCountedWillBeGarbageCollected RefCounted
+#define RefCountedWillBeGarbageCollectedFinalized RefCounted
+#define RefPtrWillBePersistent RefPtr
+#define RefPtrWillBePtr RefPtr
+#define RefPtrWillBeMember RefPtr
+#define PtrWillBeMember Ptr
+#define PtrWillBeWeakMember Ptr
+#define OwnPtrWillBeMember OwnPtr
+#define PassOwnPtrWillBePtr PassOwnPtr
+#define NoBaseWillBeGarbageCollected DummyBase
+#define NoBaseWillBeGarbageCollectedFinalized DummyBase
+#endif // COMPILER(CLANG)
+
+template<typename T> PassRefPtr<T> adoptRefWillBeNoop(T* ptr) { return adoptRef(ptr); }

[jbroman, 2014/01/15 14:37:09]

nit: Above this is declared as returning PassRefPtrWillBePtr<T>; here it is
declared as returning PassRefPtr<T>. On the other hand, adoptPtrWillBeNoop has
the same signature here and above. Probably better to be consistent about using
the aliases or not in these declarations.

[Mads Ager (chromium), 2014/01/15 14:51:14]

Yes, that was a typo that happened to be the right thing here. Thanks. :)

+template<typename T> PassOwnPtrWillBePtr<T> adoptPtrWillBeNoop(T* ptr) { return adoptPtr(ptr); }
+
+#endif // ENABLE_OILPAN
+
 } // namespace WebCore
 
 namespace WTF {