Prepare CompositorWorker for per thread heap

third_party/WebKit/Source/platform/heap/Persistent.h

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef Persistent_h
 #define Persistent_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Member.h"
 #include "platform/heap/PersistentNode.h"
@@ skipping 96 matching lines @@
         assign(nullptr);
         return result;
     }
 
     void clear() { assign(nullptr); }
     T& operator*() const { return *m_raw; }
     explicit operator bool() const { return m_raw; }
     operator T*() const { return m_raw; }
     T* operator->() const { return *this; }
     T* get() const { return m_raw; }
+    T* getInternal() const { return m_raw; }
 
     template<typename U>
     PersistentBase& operator=(U* other)
     {
         assign(other);
         return *this;
     }
 
     PersistentBase& operator=(std::nullptr_t)
     {
@@ skipping 303 matching lines @@
     CrossThreadPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadPersistent(T* raw) : Parent(raw) { }
     CrossThreadPersistent(T& raw) : Parent(raw) { }
     CrossThreadPersistent(const CrossThreadPersistent& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const CrossThreadPersistent<U>& other) : Parent(other) { }
     template<typename U>
     CrossThreadPersistent(const Member<U>& other) : Parent(other) { }
     CrossThreadPersistent(WTF::HashTableDeletedValueType x) : Parent(x) { }
 
-    T* atomicGet() { return Parent::atomicGet(); }
-
     template<typename U>
     CrossThreadPersistent& operator=(U* other)
     {
         Parent::operator=(other);
         return *this;
     }
 
     CrossThreadPersistent& operator=(std::nullptr_t)
     {
         Parent::operator=(nullptr);
@@ skipping 12 matching lines @@
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
+
+    template<typename U>
+    static CrossThreadPersistent<U> protectWeak(const PersistentBase<U, WeakPersistentConfiguration, CrossThreadPersistentConfiguration>& other)
+    {
+        CrossThreadPersistentRegion::LockScope persistentLock(ProcessHeap::crossThreadPersistentRegion());
+        return CrossThreadPersistent<U>(other.getInternal());
+    }
 };
 
 // Combines the behavior of CrossThreadPersistent and WeakPersistent.
 template<typename T>
 class CrossThreadWeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadWeakPersistent() : Parent() { }
     CrossThreadWeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadWeakPersistent(T* raw) : Parent(raw) { }
@@ skipping 29 matching lines @@
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
+
+    T* atomicGet() { return Parent::atomicGet(); }
+
+    T& operator*() const
+    {
+        DCHECK(!Parent::get() || !ThreadState::current() || !ThreadState::current()->perThreadHeapEnabled() || &ThreadState::fromObject(Parent::get())->heap() == &ThreadState::current()->heap());

[haraken, 2016/09/02 09:39:18]

Should we drop the '|| !ThreadState::current()->perThreadHeapEnabled()' part?

It's unsafe to let a thread use a CrossThreadWeakPersistent even if the
per-thread heap is not enabled on *this* thread (i.e., it's unsafe if the
per-thread heap is enabled on a GCing thread).

[keishi, 2016/09/07 10:14:42]

Done.

+        return Parent::operator*();
+    }
+    explicit operator bool() const
+    {
+        DCHECK(!Parent::get() || !ThreadState::current() || !ThreadState::current()->perThreadHeapEnabled() || &ThreadState::fromObject(Parent::get())->heap() == &ThreadState::current()->heap());
+        return Parent::operator bool();
+    }
+    operator T*() const
+    {
+        DCHECK(!Parent::get() || !ThreadState::current() || !ThreadState::current()->perThreadHeapEnabled() || &ThreadState::fromObject(Parent::get())->heap() == &ThreadState::current()->heap());
+        return Parent::operator T*();
+    }
+    T* operator->() const
+    {
+        DCHECK(!Parent::get() || !ThreadState::current() || !ThreadState::current()->perThreadHeapEnabled() || &ThreadState::fromObject(Parent::get())->heap() == &ThreadState::current()->heap());
+        return Parent::operator->();
+    }
+    T* get() const
+    {
+        DCHECK(!Parent::get() || !ThreadState::current() || !ThreadState::current()->perThreadHeapEnabled() || &ThreadState::fromObject(Parent::get())->heap() == &ThreadState::current()->heap());
+        return Parent::get();
+    }
 };
 
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF PartitionAllocator 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::PartitionAllocator);
     IS_PERSISTENT_REFERENCE_TYPE();
 public:
@@ skipping 229 matching lines @@
 
 template <typename T>
 struct IsWeakReceiver<blink::WeakPersistent<T>> : std::true_type {};
 
 template <typename T>
 struct IsWeakReceiver<blink::CrossThreadWeakPersistent<T>> : std::true_type {};
 
 }
 
 #endif // Persistent_h