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

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 17 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef Handle_h
 #define Handle_h
 
 #include "heap/Heap.h"
 #include "heap/ThreadState.h"
 #include "heap/Visitor.h"
 
+#include "wtf/Ptr.h"
+#include "wtf/RefCounted.h"
+
 namespace WebCore {
 
 template<typename T> class Member;
 
 class PersistentNode {
 public:
     explicit PersistentNode(TraceCallback trace) : m_trace(trace) { }
 
     virtual ~PersistentNode() { }
 
@@ skipping 119 matching lines @@
 
     Persistent(const Persistent& other) : m_raw(other) { }
 
     template<typename U>
     Persistent(const Persistent<U>& other) : m_raw(other) { }
 
     template<typename U>
     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;
         return *this;
     }
 
     virtual ~Persistent()
     {
         m_raw = 0;
     }
@@ skipping 11 matching lines @@
         T* result = m_raw;
         m_raw = 0;
         return result;
     }
 
     T& operator*() const { return *m_raw; }
 
     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; }
 
     Persistent& operator=(std::nullptr_t)
     {
         m_raw = 0;
         return *this;
     }
 
     Persistent& operator=(const Persistent& other)
@@ skipping 179 matching lines @@
 // Comparison operators between (Weak)Members and Persistents
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Member<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Member<T>& a, const Persistent<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Member<T>& a, const Persistent<U>& b) { return a.get() != b.get(); }
 template<typename T, typename U> inline bool operator==(const Persistent<T>& a, const Member<U>& b) { return a.get() == b.get(); }
 template<typename T, typename U> inline bool operator!=(const Persistent<T>& a, const Member<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<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 {
 
 template <typename T> struct VectorTraits<WebCore::Member<T> > : VectorTraitsBase<false, WebCore::Member<T> > {
     static const bool needsDestruction = false;
     static const bool canInitializeWithMemset = true;
     static const bool canMoveWithMemcpy = true;
 };
 
@@ skipping 91 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