Check thread is attached when creating a Persistent

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 228 matching lines @@
         state->freePersistentNode(m_persistentNode);
         m_persistentNode = nullptr;
     }
 
     void checkPointer()
     {
 #if DCHECK_IS_ON()
         if (!m_raw || isHashTableDeletedValue())
             return;
 
-        if (crossThreadnessConfiguration != CrossThreadPersistentConfiguration && m_creationThreadState) {
+        if (crossThreadnessConfiguration != CrossThreadPersistentConfiguration) {
             ThreadState* current = ThreadState::current();
             DCHECK(current);
+            // m_creationThreadState may be null when this is used in a heap
+            // collection which initialized the Persistent with memset and the
+            // constructor wasn't called.
+            if (m_creationThreadState) {

[haraken, 2016/08/19 06:31:31]

Maybe would it be worth distinguishing the two cases?

1) m_creationThreadState was not set because the constructor was not called.

2) m_creationThreadState was set to nullptr because this is a
CrossThreadPersistent.

To distinguish the two cases, you can set a value other than nullptr for the
case 2).

                 // Member should point to objects that belong in the same ThreadHeap.
                 DCHECK_EQ(&ThreadState::fromObject(m_raw)->heap(), &m_creationThreadState->heap());
                 // Member should point to objects that belong in the same ThreadHeap.
                 DCHECK_EQ(&current->heap(), &m_creationThreadState->heap());
+            }
         }
 
 #if defined(ADDRESS_SANITIZER)
         // ThreadHeap::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.
         //
         // Otherwise, ThreadHeap::isHeapObjectAlive will crash when it calls
         // header->checkHeader().
         ThreadHeap::isHeapObjectAlive(m_raw);
 #endif
 #endif
     }
 
     void saveCreationThreadHeap()
     {
 #if DCHECK_IS_ON()
-        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration)
+        if (crossThreadnessConfiguration == CrossThreadPersistentConfiguration) {
             m_creationThreadState = nullptr;
-        else
+        } else {
             m_creationThreadState = ThreadState::current();
+            DCHECK(m_creationThreadState);
+        }
 #endif
     }
 
     static void handleWeakPersistent(Visitor* self, void* persistentPointer)
     {
         using Base = PersistentBase<typename std::remove_const<T>::type, weaknessConfiguration, crossThreadnessConfiguration>;
         Base* persistent = reinterpret_cast<Base*>(persistentPointer);
         T* object = persistent->get();
         if (object && !ObjectAliveTrait<T>::isHeapObjectAlive(object))
             persistent->clear();
@@ skipping 466 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