Oilpan: Remove PersistentBase

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 46 matching lines @@
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     bool isHeapObjectAlive() { return m_trace; }
 
     virtual ~PersistentNode()
     {
         ASSERT(isHeapObjectAlive());
         m_trace = nullptr;
     }
 
+    // This operator= is important. Without having the operator=, m_next and
+    // m_prev are inproperly copied and it breaks the link list of the
+    // persistent handles.
+    inline PersistentNode& operator=(const PersistentNode& otherref) { return *this; }
+
+private:
     // 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)
+    void tracePersistentNode(Visitor* visitor)
     {
         m_trace(visitor, this);
     }
 
-protected:
     TraceCallback m_trace;
-
-private:
     PersistentNode* m_next;
     PersistentNode* m_prev;
 
-    template<typename RootsAccessor, typename Owner> friend class PersistentBase;
+    template<typename T> friend class CrossThreadPersistent;
+    template<typename T> friend class Persistent;
+    template<typename Collection> friend class PersistentHeapCollectionBase;
     friend class PersistentAnchor;
+    friend class PersistentNode;
     friend class ThreadState;
 };
 
-// RootsAccessor for Persistent that provides access to thread-local list
-// of persistent handles. Can only be used to create handles that
-// are constructed and destructed on the same thread.
-template<ThreadAffinity Affinity>
-class ThreadLocalPersistents {
-public:
-    static PersistentNode* roots() { return state()->roots(); }
-
-    // No locking required. Just check that we are at the right thread.
-    class Lock {
-    public:
-        Lock() { state()->checkThread(); }
-    };
-
-private:
-    static ThreadState* state() { return ThreadStateFor<Affinity>::state(); }
-};
-
-// RootsAccessor for Persistent that provides synchronized access to global
-// list of persistent handles. Can be used for persistent handles that are
-// passed between threads.
-class GlobalPersistents {
-public:
-    static PersistentNode* roots() { return &ThreadState::globalRoots(); }
-
-    class Lock {
-    public:
-        Lock() : m_locker(ThreadState::globalRootsMutex()) { }
-    private:
-        MutexLocker m_locker;
-    };
-};
-
-// Base class for persistent handles. RootsAccessor specifies which list to
-// link resulting handle into. Owner specifies the class containing trace
-// method.
-template<typename RootsAccessor, typename Owner>
-class PersistentBase : public PersistentNode {
-public:
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
-    ~PersistentBase()
-    {
-        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)
-#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;
-        m_next->m_prev = this;
-    }
-
-    inline PersistentBase& operator=(const PersistentBase& otherref) { return *this; }
-
-#if ENABLE(ASSERT)
-private:
-    PersistentNode* m_roots;
-#endif
-};
-
 // A dummy Persistent handle that ensures the list of persistents is never null.
 // This removes a test from a hot path.
 class PersistentAnchor : public PersistentNode {
 public:
-    void trace(Visitor* visitor)
+    void tracePersistentNodes(Visitor* visitor)
     {
         for (PersistentNode* current = m_next; current != this; current = current->m_next)
-            current->trace(visitor);
+            current->tracePersistentNode(visitor);
     }
 
     int numberOfPersistents()
     {
         int numberOfPersistents = 0;
         for (PersistentNode* current = m_next; current != this; current = current->m_next)
             ++numberOfPersistents;
         return numberOfPersistents;
     }
 
     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.
     }
 
+    template<typename VisitorDispatcher>
+    void trace(VisitorDispatcher visitor)
+    {
+        ASSERT_NOT_REACHED();
+    }
+
 private:
     PersistentAnchor() : PersistentNode(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>> {
+class Persistent : public PersistentNode {
 public:
-    Persistent() : m_raw(nullptr) { }
+    Persistent() : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(nullptr)

[haraken, 2015/06/08 04:31:29]

It is unfortunate that we have to write "TraceMethodDelegate<Persistent<T>,
&Persistent<T>::trace>::trampoline" every time.

At first, I tried to introduce:

  using Delegate = TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>;

but this didn't work because the using statement requires a full definition of T
(which means that we need to include T.h when using Persistent<T>).

Thus I decided just to use "TraceMethodDelegate<Persistent<T>,
&Persistent<T>::trace>::trampoline".

+    {
+        initialize();
+    }
 
-    Persistent(std::nullptr_t) : m_raw(nullptr) { }
+    Persistent(std::nullptr_t) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(nullptr)
+    {
+        initialize();
+    }
 
-    Persistent(T* raw) : m_raw(raw)
+    Persistent(T* raw) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(raw)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    explicit Persistent(T& raw) : m_raw(&raw)
+    Persistent(T& raw) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(&raw)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    Persistent(const Persistent& other) : m_raw(other)
+    Persistent(const Persistent& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Persistent<U>& other) : m_raw(other)
+    Persistent(const Persistent<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const Member<U>& other) : m_raw(other)
+    Persistent(const Member<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    Persistent(const RawPtr<U>& other) : m_raw(other.get())
+    Persistent(const RawPtr<U>& other) : PersistentNode(TraceMethodDelegate<Persistent<T>, &Persistent<T>::trace>::trampoline), m_raw(other.get())
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     void clear() { m_raw = nullptr; }
 
     virtual ~Persistent()
     {
+        uninitialize();
         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);
@@ skipping 63 matching lines @@
     {
         m_raw = other;
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
+    void initialize()
+    {
+        ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
+        state->checkThread();
+        m_prev = state->roots();
+        m_next = m_prev->m_next;
+        m_prev->m_next = this;
+        m_next->m_prev = this;
+    }
+
+    void uninitialize()
+    {
+        ASSERT(isHeapObjectAlive());
+        ASSERT(m_next->isHeapObjectAlive());
+        ASSERT(m_prev->isHeapObjectAlive());
+        m_next->m_prev = m_prev;
+        m_prev->m_next = m_next;
+    }
+
     void checkPointer()
     {
 #if ENABLE(ASSERT)
         if (!m_raw)
             return;
 
         // Heap::isHeapObjectAlive(m_raw) checks that m_raw 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.
@@ skipping 15 matching lines @@
     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>> {
+class CrossThreadPersistent : public PersistentNode {
 public:
-    CrossThreadPersistent() : m_raw(nullptr) { }
+    CrossThreadPersistent() : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(nullptr)
+    {
+        initialize();
+    }
 
-    CrossThreadPersistent(std::nullptr_t) : m_raw(nullptr) { }
+    CrossThreadPersistent(std::nullptr_t) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(nullptr)
+    {
+        initialize();
+    }
 
-    CrossThreadPersistent(T* raw) : m_raw(raw)
+    CrossThreadPersistent(T* raw) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(raw)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    explicit CrossThreadPersistent(T& raw) : m_raw(&raw)
+    CrossThreadPersistent(T& raw) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(&raw)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
-    CrossThreadPersistent(const CrossThreadPersistent& other) : m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : m_raw(other)
+    CrossThreadPersistent(const CrossThreadPersistent<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const Member<U>& other) : m_raw(other)
+    CrossThreadPersistent(const Member<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other)
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     template<typename U>
-    CrossThreadPersistent(const RawPtr<U>& other) : m_raw(other.get())
+    CrossThreadPersistent(const RawPtr<U>& other) : PersistentNode(TraceMethodDelegate<CrossThreadPersistent<T>, &CrossThreadPersistent<T>::trace>::trampoline), m_raw(other.get())
     {
+        initialize();
         checkPointer();
         recordBacktrace();
     }
 
     void clear() { m_raw = nullptr; }
 
     virtual ~CrossThreadPersistent()
     {
+        uninitialize();
         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);
@@ skipping 63 matching lines @@
     {
         m_raw = other;
         checkPointer();
         recordBacktrace();
         return *this;
     }
 
     T* get() const { return m_raw; }
 
 private:
+    void initialize()
+    {
+        MutexLocker m_locker(ThreadState::globalRootsMutex());
+        m_prev = &ThreadState::globalRoots();
+        m_next = m_prev->m_next;
+        m_prev->m_next = this;
+        m_next->m_prev = this;
+    }
+
+    void uninitialize()
+    {
+        MutexLocker m_locker(ThreadState::globalRootsMutex());
+        ASSERT(isHeapObjectAlive());
+        ASSERT(m_next->isHeapObjectAlive());
+        ASSERT(m_prev->isHeapObjectAlive());
+        m_next->m_prev = m_prev;
+        m_prev->m_next = m_next;
+    }
+
     void checkPointer()
     {
 #if ENABLE(ASSERT)
         if (!m_raw)
             return;
         // Heap::isHeapObjectAlive(m_raw) checks that m_raw 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.
@@ skipping 12 matching lines @@
     }
 
     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>> {
+template<typename Collection>
+class PersistentHeapCollectionBase : public Collection, public PersistentNode {
     // 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() { }
+    PersistentHeapCollectionBase() : PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline)
+    {
+        initialize();
+    }
 
-    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : Collection(other) { }
+    PersistentHeapCollectionBase(const PersistentHeapCollectionBase& other) : Collection(other), PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline)
+    {
+        initialize();
+    }
 
     template<typename OtherCollection>
-    PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other) { }
+    PersistentHeapCollectionBase(const OtherCollection& other) : Collection(other), PersistentNode(TraceMethodDelegate<PersistentHeapCollectionBase<Collection>, &PersistentHeapCollectionBase<Collection>::trace>::trampoline)
+    {
+        initialize();
+    }
+
+    ~PersistentHeapCollectionBase()
+    {
+        uninitialize();
+    }
 
     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));
     }
+
+private:
+    void initialize()
+    {
+        ThreadState* state = ThreadState::current();
+        m_prev = state->roots();
+        m_next = m_prev->m_next;
+        m_prev->m_next = this;
+        m_next->m_prev = this;
+    }
+
+    void uninitialize()
+    {
+        ASSERT(isHeapObjectAlive());
+        ASSERT(m_next->isHeapObjectAlive());
+        ASSERT(m_prev->isHeapObjectAlive());
+        m_next->m_prev = m_prev;
+        m_prev->m_next = m_next;
+    }
 };
 
 template<
     typename KeyArg,
     typename MappedArg,
     typename HashArg = typename DefaultHash<KeyArg>::Hash,
     typename KeyTraitsArg = HashTraits<KeyArg>,
     typename MappedTraitsArg = HashTraits<MappedArg>>
 class PersistentHeapHashMap : public PersistentHeapCollectionBase<HeapHashMap<KeyArg, MappedArg, HashArg, KeyTraitsArg, MappedTraitsArg>> { };
 
@@ skipping 674 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