Alternative approach to supporting ref counting and garbage collection

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 104 matching lines @@
 // Persistent handles must not be used to contain pointers
 // between objects that are in the managed heap. They are only
 // meant to point to managed heap objects from variables/members
 // outside the managed heap.
 //
 // A Persistent is always a GC root from the point of view of
 // the garbage collector.
 template<typename T>
 class Persistent : public PersistentBase<ThreadingTrait<T>::Affinity, Persistent<T> > {
 public:
+#if ENABLE(OILPAN)
+    typedef Persistent<T> FromRefPtr;
+#else
+    typedef RefPtr<T> FromRefPtr;
+#endif
+
     Persistent() : m_raw(0) { }
 
     Persistent(T* raw) : m_raw(raw) { }
 
     Persistent(std::nullptr_t) : m_raw(0) { }
 
     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 23 matching lines @@
 };
 
 // Members are used in classes to contain strong pointers to other oilpan heap
 // allocated objects.
 // All Member fields of a class must be traced in the class' trace method.
 // During the mark phase of the GC all live objects are marked as live and
 // all Member fields of a live object will be traced marked as live as well.
 template<typename T>
 class Member {
 public:
+#if ENABLE(OILPAN)
+    typedef Member<T> FromRefPtr;
+    typedef Member<T> FromOwnPtr;
+#else
+    typedef RefPtr<T> FromRefPtr;
+    typedef OwnPtr<T> FromOwnPtr;
+#endif
+
     Member() : m_raw(0) { }
 
     Member(T* raw) : m_raw(raw) { }
 
     Member(std::nullptr_t) : m_raw(0) { }
 
     Member(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1)) { }
 
     bool isHashTableDeletedValue() const { return m_raw == reinterpret_cast<T*>(-1); }
 
@@ skipping 79 matching lines @@
 
 // WeakMember is similar to Member in that it is used to point to other oilpan
 // heap allocated objects.
 // However instead of creating a strong pointer to the object, the WeakMember creates
 // a weak pointer, which does not keep the pointee alive. Hence if all pointers to
 // to a heap allocated object are weak the object will be garbage collected. At the
 // time of GC the weak pointers will automatically be set to null.
 template<typename T>
 class WeakMember : public Member<T> {
 public:
+#if ENABLE(OILPAN)
+    typedef WeakMember<T> FromPtr;
+#else
+    typedef Ptr<T> FromPtr;
+#endif
+
     WeakMember() : Member<T>() { }
 
     WeakMember(T* raw) : Member<T>(raw) { }
 
     WeakMember(std::nullptr_t) : Member<T>(nullptr) { }
 
     WeakMember(WTF::HashTableDeletedValueType x) : Member<T>(x) { }
 
     template<typename U>
     WeakMember(const Persistent<U>& other) : Member<T>(other) { }
@@ skipping 37 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(); }
 
+#if ENABLE(OILPAN)
+template<typename T>
+typename Ptr<T>::FromPassRefPtr adoptRefWillBeNoop(T* ptr)
+{
+    return Ptr<T>(ptr);
+}
+
+template<typename T>
+typename Ptr<T>::FromPassOwnPtr adoptPtrWillBeNoop(T* ptr)
+{
+    return Ptr<T>(ptr);
+}
+#else
+template<typename T>
+typename Ptr<T>::FromPassRefPtr adoptRefWillBeNoop(T* ptr)
+{
+    return adoptRef(ptr);
+}
+
+template<typename T>
+typename Ptr<T>::FromPassOwnPtr adoptPtrWillBeNoop(T* ptr)
+{
+    return adoptPtr(ptr);
+}
+#endif
+
 } // 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