Oilpan: Make PersistentNode hold a raw pointer

Source/platform/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 32 matching lines @@
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
 template<typename T> class HeapTerminatedArray;
 
 class PersistentNode {
 public:
-    explicit PersistentNode(TraceCallback trace)
-        : m_trace(trace)
+    PersistentNode(void* raw, TraceCallback trace)
+        : m_raw(raw)
+        , m_trace(trace)
     {
     }
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     bool isHeapObjectAlive() { return m_trace; }
 
     virtual ~PersistentNode()
     {
         ASSERT(isHeapObjectAlive());
         m_trace = nullptr;
     }
 
     // Ideally the trace method should be virtual and automatically dispatch
     // to the most specific implementation. However having a virtual method
     // on PersistentNode leads to too eager template instantiation with MSVC
     // which leads to include cycles.
     // Instead we call the constructor with a TraceCallback which knows the
     // type of the most specific child and calls trace directly. See
     // TraceMethodDelegate in Visitor.h for how this is done.
     void trace(Visitor* visitor)
     {
         m_trace(visitor, this);
     }
 
 protected:
+    void* m_raw;
     TraceCallback m_trace;
 
 private:
     PersistentNode* m_next;
     PersistentNode* m_prev;
 
     template<typename RootsAccessor, typename Owner> friend class PersistentBase;
     friend class PersistentAnchor;
     friend class ThreadState;
 };
@@ skipping 43 matching lines @@
         typename RootsAccessor::Lock lock;
         ASSERT(m_roots == RootsAccessor::roots()); // Check that the thread is using the same roots list.
         ASSERT(isHeapObjectAlive());
         ASSERT(m_next->isHeapObjectAlive());
         ASSERT(m_prev->isHeapObjectAlive());
         m_next->m_prev = m_prev;
         m_prev->m_next = m_next;
     }
 
 protected:
-    inline PersistentBase()
-        : PersistentNode(TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
+    inline PersistentBase(void* raw)
+        : PersistentNode(raw, TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
 #if ENABLE(ASSERT)
         , m_roots(RootsAccessor::roots())
 #endif
     {
         // Persistent must belong to a thread that will GC it.
         ASSERT(m_roots == GlobalPersistents::roots() || ThreadState::current());
         typename RootsAccessor::Lock lock;
         m_prev = RootsAccessor::roots();
         m_next = m_prev->m_next;
         m_prev->m_next = this;
@@ skipping 28 matching lines @@
 
     virtual ~PersistentAnchor()
     {
         // FIXME: oilpan: Ideally we should have no left-over persistents at this point. However currently there is a
         // large number of objects leaked when we tear down the main thread. Since some of these might contain a
         // persistent or e.g. be RefCountedGarbageCollected we cannot guarantee there are no remaining Persistents at
         // this point.
     }
 
 private:
-    PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
+    PersistentAnchor() : PersistentNode(nullptr, TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
 template<typename T>
 class CrossThreadPersistent;
 
 // Persistent handles are used to store pointers into the
 // managed heap. As long as the Persistent handle is alive
 // the GC will keep the object pointed to alive. Persistent
 // handles can be stored in objects and they are not scoped.
 // 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.
 //
 // We have to construct and destruct Persistent in the same thread.
 template<typename T>
 class Persistent : public PersistentBase<ThreadLocalPersistents<ThreadingTrait<T>::Affinity>, Persistent<T>> {
 public:
-    Persistent() : m_raw(nullptr) { }
+    typedef PersistentBase<ThreadLocalPersistents<ThreadingTrait<T>::Affinity>, Persistent<T>> ThreadLocalPersistentBase;
 
-    Persistent(std::nullptr_t) : m_raw(nullptr) { }
+    Persistent() : ThreadLocalPersistentBase(nullptr) { }
 
-    Persistent(T* raw) : m_raw(raw)
+    Persistent(std::nullptr_t) : ThreadLocalPersistentBase(nullptr) { }
+
+    Persistent(T* raw) : ThreadLocalPersistentBase(raw)
     {
         checkPointer();
         recordBacktrace();
     }
 
-    explicit Persistent(T& raw) : m_raw(&raw)
+    Persistent(T& raw) : ThreadLocalPersistentBase(&raw)
     {
         checkPointer();
         recordBacktrace();
     }
 
-    Persistent(const Persistent& other) : m_raw(other)
+    Persistent(const Persistent& other) : ThreadLocalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Persistent<U>& other) : m_raw(other)
+    Persistent(const Persistent<U>& other) : ThreadLocalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Member<U>& other) : m_raw(other)
+    Persistent(const Member<U>& other) : ThreadLocalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const RawPtr<U>& other) : m_raw(other.get())
+    Persistent(const RawPtr<U>& other) : ThreadLocalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
-    void clear() { m_raw = nullptr; }
+    void clear()
+    {
+        this->m_raw = nullptr;
+    }
 
     virtual ~Persistent()
     {
-        m_raw = nullptr;
+        this->m_raw = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
 #if ENABLE(GC_PROFILING)
         visitor->setHostInfo(this, m_tracingName.isEmpty() ? "Persistent" : m_tracingName);
 #endif
-        visitor->mark(m_raw);
+        visitor->mark(get());
     }
 
     RawPtr<T> release()
     {
-        RawPtr<T> result = m_raw;
-        m_raw = nullptr;
+        RawPtr<T> result = get();
+        this->m_raw = nullptr;
         return result;
     }
 
-    T& operator*() const { return *m_raw; }
+    T& operator*() const { return *get(); }
 
-    bool operator!() const { return !m_raw; }
+    bool operator!() const { return !get(); }
 
-    operator T*() const { return m_raw; }
-    operator RawPtr<T>() const { return m_raw; }
+    operator T*() const { return get(); }
+    operator RawPtr<T>() const { return get(); }
 
     T* operator->() const { return *this; }
 
     template<typename U>
     Persistent& operator=(U* other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other);
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     Persistent& operator=(std::nullptr_t)
     {
-        m_raw = nullptr;
+        this->m_raw = nullptr;
         return *this;
     }
 
     Persistent& operator=(const Persistent& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const Persistent<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const Member<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     Persistent& operator=(const RawPtr<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
-    T* get() const { return m_raw; }
+    T* get() const { return reinterpret_cast<T*>(this->m_raw); }
 
 private:
     void checkPointer()
     {
 #if ENABLE(ASSERT)
-        if (!m_raw)
+        if (!get())
             return;
 
-        // Heap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
+        // Heap::isHeapObjectAlive() checks that the pointer is a traceable
         // object. In other words, it checks that the pointer is either of:
         //
         //   (a) a pointer to the head of an on-heap object.
         //   (b) a pointer to the head of an on-heap mixin object.
         //
         // Otherwise, Heap::isHeapObjectAlive will crash when it calls
         // header->checkHeader().
-        Heap::isHeapObjectAlive(m_raw);
+        Heap::isHeapObjectAlive(get());
 #endif
     }
 
 #if ENABLE(GC_PROFILING)
     void recordBacktrace()
     {
-        if (m_raw)
+        if (get())
             m_tracingName = Heap::createBacktraceString();
     }
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
-    T* m_raw;
 };
 
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
 class CrossThreadPersistent : public PersistentBase<GlobalPersistents, CrossThreadPersistent<T>> {
 public:
-    CrossThreadPersistent() : m_raw(nullptr) { }
+    typedef PersistentBase<GlobalPersistents, CrossThreadPersistent<T>> GlobalPersistentBase;
 
-    CrossThreadPersistent(std::nullptr_t) : m_raw(nullptr) { }
+    CrossThreadPersistent() : GlobalPersistentBase(nullptr) { }
 
-    CrossThreadPersistent(T* raw) : m_raw(raw)
+    CrossThreadPersistent(std::nullptr_t) : GlobalPersistentBase(nullptr) { }
+
+    CrossThreadPersistent(T* raw) : GlobalPersistentBase(raw)
     {
         checkPointer();
         recordBacktrace();
     }
 
-    explicit CrossThreadPersistent(T& raw) : m_raw(&raw)
+    CrossThreadPersistent(T& raw) : GlobalPersistentBase(&raw)
     {
         checkPointer();
         recordBacktrace();
     }
 
-    CrossThreadPersistent(const CrossThreadPersistent& other) : m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent& other) : GlobalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : GlobalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const Member<U>& other) : m_raw(other)
+    CrossThreadPersistent(const Member<U>& other) : GlobalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const RawPtr<U>& other) : m_raw(other.get())
+    CrossThreadPersistent(const RawPtr<U>& other) : GlobalPersistentBase(static_cast<T*>(other.get()))
     {
         checkPointer();
         recordBacktrace();
     }
 
-    void clear() { m_raw = nullptr; }
+    void clear()
+    {
+        this->m_raw = nullptr;
+    }
 
     virtual ~CrossThreadPersistent()
     {
-        m_raw = nullptr;
+        this->m_raw = nullptr;
     }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
 #if ENABLE(GC_PROFILING)
         visitor->setHostInfo(this, m_tracingName.isEmpty() ? "CrossThreadPersistent" : m_tracingName);
 #endif
-        visitor->mark(m_raw);
+        visitor->mark(get());
     }
 
     RawPtr<T> release()
     {
-        RawPtr<T> result = m_raw;
-        m_raw = nullptr;
+        RawPtr<T> result = get();
+        this->m_raw = nullptr;
         return result;
     }
 
-    T& operator*() const { return *m_raw; }
+    T& operator*() const { return *get(); }
 
-    bool operator!() const { return !m_raw; }
+    bool operator!() const { return !get(); }
 
-    operator T*() const { return m_raw; }
-    operator RawPtr<T>() const { return m_raw; }
+    operator T*() const { return get(); }
+    operator RawPtr<T>() const { return get(); }
 
     T* operator->() const { return *this; }
 
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other);
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     CrossThreadPersistent& operator=(std::nullptr_t)
     {
-        m_raw = nullptr;
+        this->m_raw = nullptr;
         return *this;
     }
 
     CrossThreadPersistent& operator=(const CrossThreadPersistent& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const CrossThreadPersistent<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const Member<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const RawPtr<U>& other)
     {
-        m_raw = other;
+        this->m_raw = static_cast<T*>(other.get());
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
-    T* get() const { return m_raw; }
+    T* get() const { return reinterpret_cast<T*>(this->m_raw); }
 
 private:
     void checkPointer()
     {
 #if ENABLE(ASSERT)
-        if (!m_raw)
+        if (!get())
             return;
-        // Heap::isHeapObjectAlive(m_raw) checks that m_raw is a traceable
+        // Heap::isHeapObjectAlive() checks that the pointer is a traceable
         // object. In other words, it checks that the pointer is either of:
         //
         //   (a) a pointer to the head of an on-heap object.
         //   (b) a pointer to the head of an on-heap mixin object.
         //
         // Otherwise, Heap::isHeapObjectAlive will crash when it calls
         // header->checkHeader().
-        Heap::isHeapObjectAlive(m_raw);
+        Heap::isHeapObjectAlive(get());
 #endif
     }
 
 #if ENABLE(GC_PROFILING)
     void recordBacktrace()
     {
-        if (m_raw)
+        if (get())
             m_tracingName = Heap::createBacktraceString();
     }
 
     String m_tracingName;
 #else
     inline void recordBacktrace() const { }
 #endif
-    T* m_raw;
 };
 
 // FIXME: derive affinity based on the collection.
 template<typename Collection, ThreadAffinity Affinity = AnyThread>
 class PersistentHeapCollectionBase
     : public Collection
     , public PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity>> {
     // We overload the various new and delete operators with using the WTF DefaultAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::DefaultAllocator);
 public:
-    PersistentHeapCollectionBase() { }
+    typedef PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity>> CollectionPersistentBase;
 
-    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : Collection(other) { }
+    PersistentHeapCollectionBase() : CollectionPersistentBase(this) { }
+
+    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : Collection(other), CollectionPersistentBase(this) { }
 
     template<typename OtherCollection>
-    PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other) { }
+    PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other), CollectionPersistentBase(this) { }
 
     template<typename VisitorDispatcher>
     void trace(VisitorDispatcher visitor)
     {
         static_assert(sizeof(Collection), "Collection must be fully defined");
 #if ENABLE(GC_PROFILING)
         visitor->setHostInfo(this, "PersistentHeapCollectionBase");
 #endif
         visitor->trace(*static_cast<Collection*>(this));
     }
@@ skipping 66 matching lines @@
 
     Member(std::nullptr_t) : m_raw(nullptr)
     {
     }
 
     Member(T* raw) : m_raw(raw)
     {
         checkPointer();
     }
 
-    explicit Member(T& raw) : m_raw(&raw)
+    Member(T& raw) : m_raw(&raw)
     {
         checkPointer();
     }
 
     template<typename U>
     Member(const RawPtr<U>& other) : m_raw(other.get())
     {
         checkPointer();
     }
 
@@ skipping 597 matching lines @@
 struct ParamStorageTraits<RawPtr<T>> : public PointerParamStorageTraits<T*, blink::IsGarbageCollectedType<T>::value> {
     static_assert(sizeof(T), "T must be fully defined");
 };
 
 template<typename T>
 PassRefPtr<T> adoptRef(blink::RefCountedGarbageCollected<T>*) = delete;
 
 } // namespace WTF
 
 #endif