Handle cross-thread weak persistents during global weak processing.

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 166 matching lines @@
             return;
         }
         uninitialize();
     }
 
     template<typename VisitorDispatcher>
     void tracePersistent(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 (weaknessConfiguration == WeakPersistentConfiguration)
-            visitor->registerWeakMembers(this, m_raw, handleWeakPersistent);
-        else
+        if (weaknessConfiguration == WeakPersistentConfiguration) {
+            if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration)
+                visitor->registerWeakCellWithCallback(reinterpret_cast<void**>(this), handleWeakPersistent);
+            else
+                visitor->registerWeakMembers(this, m_raw, handleWeakPersistent);

[haraken, 2016/06/29 00:41:54]

Is there any reason you don't want to move this one to global weak processing?

[sof, 2016/06/29 05:13:47]

It would be untidy to do so, as Persistent<>s have a same-ThreadState
assumption, which is asserted for when freeing the PersistentNode.

+        } else {
             visitor->mark(m_raw);
+        }
     }
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
     void initialize()
     {
         ASSERT(!m_persistentNode);
         if (!m_raw || isHashTableDeletedValue())
             return;
 
         TraceCallback traceCallback = TraceMethodDelegate<PersistentBase, &PersistentBase::tracePersistent>::trampoline;
@@ skipping 38 matching lines @@
         //
         //   (a) a pointer to the head of an on-heap object.
         //   (b) a pointer to the head of an on-heap mixin object.
         //
         // Otherwise, ThreadHeap::isHeapObjectAlive will crash when it calls
         // header->checkHeader().
         ThreadHeap::isHeapObjectAlive(m_raw);
 #endif
     }
 
-    static void handleWeakPersistent(Visitor* self, void* object)
+    static void handleWeakPersistent(Visitor* self, void* persistentPointer)
     {
         using Base = PersistentBase<typename std::remove_const<T>::type, weaknessConfiguration, crossThreadnessConfiguration>;
-        Base* persistent = reinterpret_cast<Base*>(object);
-        if (persistent->get() && !ObjectAliveTrait<T>::isHeapObjectAlive(persistent->get()))
+        Base* persistent = reinterpret_cast<Base*>(persistentPointer);
+        T* object = persistent->get();
+        if (object && !ObjectAliveTrait<T>::isHeapObjectAlive(object))
             persistent->clear();
     }
 
     // m_raw is accessed most, so put it at the first field.
     T* m_raw;
     PersistentNode* m_persistentNode = nullptr;
 #if ENABLE(ASSERT)
     ThreadState* m_state = nullptr;
 #endif
 };
@@ skipping 454 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