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 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 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.
+#if ENABLE(OILPAN)
+
+#if COMPILER(CLANG)
+template<typename T> using PassRefPtrWillBePtr = Ptr<T>;
+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
+#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> PassRefPtrWillBePtr<T> adoptRefWillBeNoop(T* ptr) { return adoptRef(ptr); }
+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