Allow creating non-thread-local Persistents that can be passed between threads.

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/Locker.h"
 #include "wtf/RawPtr.h"
 #include "wtf/RefCounted.h"
 
 namespace WebCore {
 
 template<typename T> class Member;
 
 class PersistentNode {
 public:
     explicit PersistentNode(TraceCallback trace)
@@ skipping 21 matching lines @@
         m_trace(visitor, this);
     }
 
 protected:
     TraceCallback m_trace;
 
 private:
     PersistentNode* m_next;
     PersistentNode* m_prev;
 
-    template<ThreadAffinity affinity, typename Owner> friend class PersistentBase;
+    template<typename RootsAccessor, typename Owner> friend class PersistentBase;
     friend class PersistentAnchor;
     friend class ThreadState;
 };
 
-template<ThreadAffinity Affinity, typename Owner>
+// 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 requires. Just checks that we are at the right thread.

[Mads Ager (chromium), 2014/02/17 15:00:13]

required

[Vyacheslav Egorov (Chromium), 2014/02/17 15:52:35]

Done.

+    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:
     ~PersistentBase()
     {
 #ifndef NDEBUG
         ASSERT(isAlive());
         ASSERT(m_next->isAlive());
         ASSERT(m_prev->isAlive());
-        m_threadState->checkThread();
+        ASSERT(m_roots == RootsAccessor::roots()); // Check that the thread is using the same roots list.
 #endif
+        typename RootsAccessor::Lock lock;

[Mads Ager (chromium), 2014/02/17 15:00:13]

Shouldn't you lock before the debug-mode code? The debug mode code is looking at
m_next and m_prev which could be modified at the same time from another thread.

[Vyacheslav Egorov (Chromium), 2014/02/17 15:52:35]

Good catch. Fixed.

         m_next->m_prev = m_prev;
         m_prev->m_next = m_next;
     }
 
 protected:
     inline PersistentBase()
         : PersistentNode(TraceMethodDelegate<Owner, &Owner::trace>::trampoline)
 #ifndef NDEBUG
-        , m_threadState(state())
+        , m_roots(RootsAccessor::roots())
 #endif
     {
-#ifndef NDEBUG
-        m_threadState->checkThread();
-#endif
-        ThreadState* threadState = state();
-        m_prev = threadState->roots();
-        m_next = threadState->roots()->m_next;
-        threadState->roots()->m_next = this;
+        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 explicit PersistentBase(const PersistentBase& otherref)
         : PersistentNode(otherref.m_trace)
 #ifndef NDEBUG
-        , m_threadState(state())
+        , m_roots(RootsAccessor::roots())
 #endif
     {
-#ifndef NDEBUG
-        m_threadState->checkThread();
-#endif
-        ASSERT(otherref.m_threadState == m_threadState);
+        typename RootsAccessor::Lock lock;
+        ASSERT(otherref.m_roots == m_roots); // Handles must belong to the same list.
         PersistentBase* other = const_cast<PersistentBase*>(&otherref);
         m_prev = other;
         m_next = other->m_next;
         other->m_next = this;
         m_next->m_prev = this;
     }
 
-    inline PersistentBase& operator=(const PersistentBase& otherref)
-    {
-        return *this;
-    }
-
-    static ThreadState* state() { return ThreadStateFor<Affinity>::state(); }
+    inline PersistentBase& operator=(const PersistentBase& otherref) { return *this; }
 
 #ifndef NDEBUG
 private:
-    ThreadState* m_threadState;
+    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*) { }
+    void trace(Visitor* visitor)
+    {
+        for (PersistentNode* current = m_next; current != this; current = current->m_next)
+            current->trace(visitor);
+    }
 
 private:
     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.
     }
     PersistentAnchor() : PersistentNode(TraceMethodDelegate<PersistentAnchor, &PersistentAnchor::trace>::trampoline)
     {
         m_next = this;
         m_prev = this;
     }
 
     friend class ThreadState;
 };
 
 // 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.
-template<typename T>
-class Persistent : public PersistentBase<ThreadingTrait<T>::Affinity, Persistent<T> > {
+template<typename T, typename RootsAccessor>

[Mads Ager (chromium), 2014/02/17 15:03:43]

Should we have a default template argument here?

[Vyacheslav Egorov (Chromium), 2014/02/17 15:52:35]

Forward declaration from Heap.h provides default argument. I will add a comment
to make it apparent.

+class Persistent : public PersistentBase<RootsAccessor, Persistent<T> > {
 public:
     Persistent() : m_raw(0) { }
 
     Persistent(T* raw) : m_raw(raw) { }
 
     Persistent(const Persistent& other) : m_raw(other) { }
 
     template<typename U>
     Persistent(const Persistent<U>& other) : m_raw(other) { }
 
@@ skipping 70 matching lines @@
     T* get() const { return m_raw; }
 
 private:
     T* m_raw;
 };
 
 // FIXME: derive affinity based on the collection.
 template<typename Collection, ThreadAffinity Affinity = AnyThread>
 class PersistentHeapCollectionBase
     : public Collection
-    , public PersistentBase<Affinity, PersistentHeapCollectionBase<Collection, Affinity> > {
+    , public PersistentBase<ThreadLocalPersistents<Affinity>, PersistentHeapCollectionBase<Collection, Affinity> > {
     // Never allocate these objects with new. Use Persistent<Collection> instead.
     DISALLOW_ALLOCATION();
 public:
     void trace(Visitor* visitor) { visitor->trace(*static_cast<Collection*>(this)); }
 };
 
 template<
     typename KeyArg,
     typename MappedArg,
     typename HashArg = typename DefaultHash<KeyArg>::Hash,
@@ skipping 186 matching lines @@
 template<typename T, size_t inlineCapacity>
 class IndexingBehavior<CollectionPersistent<Vector<T, inlineCapacity, WTF::DefaultAllocator> > > {
     typedef CollectionPersistent<Vector<T, inlineCapacity, WTF::DefaultAllocator> > CollectionPersistentType;
 public:
     T& operator[] (size_t i) { return (**static_cast<CollectionPersistentType*>(this))[i]; }
     const T& operator[] (size_t i) const { return (**static_cast<const CollectionPersistentType*>(this))[i]; }
 };
 
 template<typename Collection, ThreadAffinity Affinity>
 class CollectionPersistent
-    : public PersistentBase<Affinity, CollectionPersistent<Collection, Affinity> >
+    : public PersistentBase<ThreadLocalPersistents<Affinity>, CollectionPersistent<Collection, Affinity> >
     , public IndexingBehavior<CollectionPersistent<Collection, Affinity> > {
 public:
     typedef Collection CollectionType;
     typedef typename Collection::iterator iterator;
     typedef typename Collection::const_iterator const_iterator;
 
     CollectionPersistent() { }
     explicit CollectionPersistent(size_t size) : m_collection(Collection(size)) { }
     explicit CollectionPersistent(const Collection& collection) : m_collection(collection) { }
     CollectionPersistent& operator=(const Collection& collection) { m_collection = collection; return *this; }
@@ skipping 310 matching lines @@
 };
 
 template<typename T> inline T* getPtr(const WebCore::Member<T>& p)
 {
     return p.get();
 }
 
 } // namespace WTF
 
 #endif