Support CrossThreadWeakPersistent PostTask on per thread heap enabled thread

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 53 matching lines @@
     }
 
     PersistentBase(const PersistentBase& other) : m_raw(other)
     {
         saveCreationThreadHeap();
         initialize();
         checkPointer();
     }
 
     template<typename U>
-    PersistentBase(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other) : m_raw(other)
+    PersistentBase(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other)
     {
         saveCreationThreadHeap();
-        initialize();
+        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration && weaknessConfiguration == WeakPersistentConfiguration) {
+            CrossThreadPersistentRegion::LockScope persistentLock(ProcessHeap::crossThreadPersistentRegion());

[haraken, 2016/08/18 13:15:31]

I wonder why you need to add the LockScope here. Isn't the MutexLock in
CrossThreadPersistentRegion::allocatePersistentNode enough?

[keishi, 2016/08/22 09:48:55]

The original code sets m_raw then calls allocatePersistentNode. I thought the
object might be collected before the call to allocatePersistentNode. (if per
thread heap is enabled)

[haraken, 2016/08/22 13:59:59]

I'd say that if that happens, it's a bug of the caller site. The caller site
must keep holding a strong reference to the |other| pointer until the assignment
has been complete.

Note that even if you have the LockScope, it cannot rescue the following
scenario:

...; // If a per-thread GC happens in another thread, the |other| pointer will
be collected.
LockScope scope(region()); // This is no help.
m_raw = other;

+            m_raw = other;
+            initialize();
+        } else {
+            m_raw = other;
+            initialize();
+        }
         checkPointer();
     }
 
     template<typename U>
     PersistentBase(const Member<U>& other) : m_raw(other)
     {
         saveCreationThreadHeap();
         initialize();
         checkPointer();
     }
@@ skipping 42 matching lines @@
 
     PersistentBase& operator=(const PersistentBase& other)
     {
         assign(other);
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const PersistentBase<U, weaknessConfiguration, crossThreadnessConfiguration>& other)
     {
-        assign(other);
+        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration && weaknessConfiguration == WeakPersistentConfiguration) {
+            CrossThreadPersistentRegion::LockScope persistentLock(ProcessHeap::crossThreadPersistentRegion());
+            assign(other);
+        } else {
+            assign(other);
+        }
         return *this;
     }
 
     template<typename U>
     PersistentBase& operator=(const Member<U>& other)
     {
         assign(other);
         return *this;
     }
 
@@ skipping 258 matching lines @@
     }
 
     template<typename U>
     WeakPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
+// 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) { }
+    CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
+    CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
+    template<typename U>
+    CrossThreadWeakPersistent(const CrossThreadWeakPersistent<U>& other) : Parent(other) { }
+    template<typename U>
+    CrossThreadWeakPersistent(const Member<U>& other) : Parent(other) { }
+    CrossThreadWeakPersistent(WTF::HashTableDeletedValueType x) : Parent(x) { }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(U* other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    CrossThreadWeakPersistent& operator=(std::nullptr_t)
+    {
+        Parent::operator=(nullptr);
+        return *this;
+    }
+
+    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+
+    template<typename U>
+    CrossThreadWeakPersistent& operator=(const Member<U>& other)
+    {
+        Parent::operator=(other);
+        return *this;
+    }
+};
+
 // Unlike Persistent, we can destruct a CrossThreadPersistent in a thread
 // different from the construction thread.
 template<typename T>
 class CrossThreadPersistent : public PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, NonWeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadPersistent() : Parent() { }
     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 CrossThreadWeakPersistent<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;
@@ skipping 16 matching lines @@
     {
         Parent::operator=(other);
         return *this;
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
-    }
-};
-
-// 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) { }
-    CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
-    CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
-    template<typename U>
-    CrossThreadWeakPersistent(const CrossThreadWeakPersistent<U>& other) : Parent(other) { }
-    template<typename U>
-    CrossThreadWeakPersistent(const Member<U>& other) : Parent(other) { }
-
-    template<typename U>
-    CrossThreadWeakPersistent& operator=(U* other)
-    {
-        Parent::operator=(other);
-        return *this;
-    }
-
-    CrossThreadWeakPersistent& operator=(std::nullptr_t)
-    {
-        Parent::operator=(nullptr);
-        return *this;
-    }
-
-    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent& other)
-    {
-        Parent::operator=(other);
-        return *this;
-    }
-
-    template<typename U>
-    CrossThreadWeakPersistent& operator=(const CrossThreadWeakPersistent<U>& other)
-    {
-        Parent::operator=(other);
-        return *this;
-    }
-
-    template<typename U>
-    CrossThreadWeakPersistent& operator=(const Member<U>& other)
-    {
-        Parent::operator=(other);
-        return *this;
     }
 };
 
 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();
@@ skipping 227 matching lines @@
 } // namespace WTF
 
 namespace base {
 
 template <typename T>
 struct IsWeakReceiver<blink::WeakPersistent<T>> : std::true_type {};
 
 template <typename T>
 struct IsWeakReceiver<blink::CrossThreadWeakPersistent<T>> : std::true_type {};
 
+template <typename T>
+blink::CrossThreadPersistent<T> Unwrap(const blink::CrossThreadWeakPersistent<T>& wrapped)
+{
+    return blink::CrossThreadPersistent<T>(wrapped);
+}
+
 }
 
 #endif // Persistent_h