Disallow cross-thread Persistent<> read access.

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 91 matching lines @@
     return m_raw == reinterpret_cast<T*>(-1);
   }
 
   T* release() {
     T* result = m_raw;
     assign(nullptr);
     return result;
   }
 
   void clear() { assign(nullptr); }
-  T& operator*() const { return *m_raw; }
+  T& operator*() const {
+    checkPointer();
+    return *m_raw;
+  }
   explicit operator bool() const { return m_raw; }
-  operator T*() const { return m_raw; }
+  operator T*() const {
+    checkPointer();
+    return m_raw;
+  }
   T* operator->() const { return *this; }
-  T* get() const { return m_raw; }
+
+  T* get() const {
+    checkPointer();
+    return m_raw;
+  }
 
   template <typename U>
   PersistentBase& operator=(U* other) {
     assign(other);
     return *this;
   }
 
   PersistentBase& operator=(std::nullptr_t) {
     assign(nullptr);
     return *this;
@@ skipping 109 matching lines @@
     if (!m_persistentNode)
       return;
     ThreadState* state = ThreadStateFor<ThreadingTrait<T>::Affinity>::state();
     ASSERT(state->checkThread());
     // Persistent handle must be created and destructed in the same thread.
     ASSERT(m_state == state);
     state->freePersistentNode(m_persistentNode);
     m_persistentNode = nullptr;
   }
 
-  void checkPointer() {
+  void checkPointer() const {
 #if DCHECK_IS_ON()
     if (!m_raw || isHashTableDeletedValue())
       return;
 
     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.
@@ skipping 536 matching lines @@
   static blink::CrossThreadPersistent<T> Unwrap(
       const blink::CrossThreadWeakPersistent<T>& wrapped) {
     blink::CrossThreadPersistentRegion::LockScope persistentLock(
         blink::ProcessHeap::crossThreadPersistentRegion());
     return blink::CrossThreadPersistent<T>(wrapped.get());
   }
 };
 }
 
 #endif  // Persistent_h