SameThreadCheckedMember<>: verify same-thread usage of heap references.

third_party/WebKit/Source/platform/heap/Member.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 Member_h
 #define Member_h
 
 #include "wtf/Allocator.h"
 #include "wtf/HashFunctions.h"
 #include "wtf/HashTraits.h"
@@ skipping 234 matching lines @@
  protected:
   template <bool x,
             WTF::WeakHandlingFlag y,
             WTF::ShouldWeakPointersBeMarkedStrongly z,
             typename U,
             typename V>
   friend struct CollectionBackingTraceTrait;
   friend class Visitor;
 };
 
+// A checked version of Member<>, verifying that only same-thread references
+// are kept in the smart pointer. Intended to be used to diagnose unclean
+// thread reference usage in release builds. It simply exposes the debug-only
+// MemberBase<> checking we already have in place for select usage to diagnose
+// per-thread issues.
+template <typename T>
+class SameThreadCheckedMember : public Member<T> {

[haraken, 2016/12/21 12:52:16]

Instead of introducing SafeThreadCheckedMember and duplicating some code, would
it be an option to introduce T::EnableSameThreadCheck and make Member<T> use
CHECK if T::EnableSameThreadCheck is true? In this case, we can add
ENABLE_SAME_THREAD_CHECK() to the MessagePort class.

(Sorry if it will lead to dropping this CL...)

[sof, 2016/12/21 12:56:36]

Where would you store the "created ThreadState" ?

+  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
+  typedef Member<T> Parent;
+
+ public:
+  SameThreadCheckedMember() : Parent() { saveCreationThreadState(); }
+  SameThreadCheckedMember(std::nullptr_t) : Parent(nullptr) {
+    saveCreationThreadState();
+  }
+
+  SameThreadCheckedMember(T* raw) : Parent(raw) {
+    saveCreationThreadState();
+    checkPointer();
+  }
+
+  SameThreadCheckedMember(T& raw) : Parent(raw) {
+    saveCreationThreadState();
+    checkPointer();
+  }
+
+  SameThreadCheckedMember(WTF::HashTableDeletedValueType x) : Parent(x) {
+    saveCreationThreadState();
+    checkPointer();
+  }
+
+  SameThreadCheckedMember(const SameThreadCheckedMember& other)
+      : Parent(other) {
+    saveCreationThreadState();
+  }
+  template <typename U>
+  SameThreadCheckedMember(const SameThreadCheckedMember<U>& other)
+      : Parent(other) {
+    saveCreationThreadState();
+    checkPointer();
+  }
+
+  template <typename U>
+  SameThreadCheckedMember(const Persistent<U>& other) : Parent(other) {
+    saveCreationThreadState();
+    checkPointer();
+  }
+
+  template <typename U>
+  SameThreadCheckedMember& operator=(const Persistent<U>& other) {
+    Parent::operator=(other);
+    checkPointer();
+    return *this;
+  }
+
+  template <typename U>
+  SameThreadCheckedMember& operator=(const SameThreadCheckedMember<U>& other) {
+    Parent::operator=(other);
+    checkPointer();
+    return *this;
+  }
+
+  template <typename U>
+  SameThreadCheckedMember& operator=(const WeakMember<U>& other) {
+    Parent::operator=(other);
+    checkPointer();
+    return *this;
+  }
+
+  template <typename U>
+  SameThreadCheckedMember& operator=(U* other) {
+    Parent::operator=(other);
+    checkPointer();
+    return *this;
+  }
+
+  SameThreadCheckedMember& operator=(std::nullptr_t) {
+    Parent::operator=(nullptr);
+    return *this;
+  }
+
+ protected:
+  template <bool x,
+            WTF::WeakHandlingFlag y,
+            WTF::ShouldWeakPointersBeMarkedStrongly z,
+            typename U,
+            typename V>
+  friend struct CollectionBackingTraceTrait;
+  friend class Visitor;
+
+ private:
+  void checkPointer() {
+    if (!this->m_raw)
+      return;
+    // HashTable can store a special value (which is not aligned to the
+    // allocation granularity) to Member<> to represent a deleted entry.
+    // Thus we treat a pointer that is not aligned to the granularity
+    // as a valid pointer.
+    if (reinterpret_cast<intptr_t>(this->m_raw) % allocationGranularity)
+      return;
+
+    ThreadState* current = ThreadState::current();
+    DCHECK(current);
+    // m_creationThreadState may be null when this is used in a heap
+    // collection which initialized the Member with memset and the
+    // constructor wasn't called.
+    if (m_creationThreadState) {
+      // Member should point to objects that belong in the same ThreadHeap.
+      CHECK_EQ(&ThreadState::fromObject(this->m_raw)->heap(),
+               &m_creationThreadState->heap());
+      // Member should point to objects that belong in the same ThreadHeap.
+      CHECK_EQ(&current->heap(), &m_creationThreadState->heap());
+    } else {
+      CHECK_EQ(&ThreadState::fromObject(this->m_raw)->heap(), &current->heap());
+    }
+  }
+
+  void saveCreationThreadState() {
+    m_creationThreadState = ThreadState::current();
+    // All Members should be created in an attached thread, but an empty
+    // value Member may be created on an unattached thread by a heap
+    // collection iterator.
+    CHECK(this->m_creationThreadState || !this->m_raw);
+  }
+
+  const ThreadState* m_creationThreadState;
+};
+
 // WeakMember is similar to Member in that it is used to point to other oilpan
 // heap allocated objects.
 // However instead of creating a strong pointer to the object, the WeakMember
 // creates a weak pointer, which does not keep the pointee alive. Hence if all
 // pointers to to a heap allocated object are weak the object will be garbage
 // collected. At the time of GC the weak pointers will automatically be set to
 // null.
 template <typename T>
 class WeakMember : public MemberBase<T, TracenessMemberConfiguration::Traced> {
   typedef MemberBase<T, TracenessMemberConfiguration::Traced> Parent;
@@ skipping 131 matching lines @@
   using Hash = MemberHash<T>;
 };
 
 template <typename T>
 struct DefaultHash<blink::UntracedMember<T>> {
   STATIC_ONLY(DefaultHash);
   using Hash = MemberHash<T>;
 };
 
 template <typename T>
+struct DefaultHash<blink::SameThreadCheckedMember<T>> {
+  STATIC_ONLY(DefaultHash);
+  using Hash = MemberHash<T>;
+};
+
+template <typename T>
 struct DefaultHash<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(DefaultHash);
   using Hash = MemberHash<T>;
 };
 
 template <typename T>
 struct IsTraceable<blink::Member<T>> {
   STATIC_ONLY(IsTraceable);
   static const bool value = true;
 };
 
 template <typename T>
 struct IsWeak<blink::WeakMember<T>> {
   STATIC_ONLY(IsWeak);
   static const bool value = true;
 };
 
 template <typename T>
 struct IsTraceable<blink::WeakMember<T>> {
   STATIC_ONLY(IsTraceable);
   static const bool value = true;
 };
 
 template <typename T>
+struct IsTraceable<blink::SameThreadCheckedMember<T>> {
+  STATIC_ONLY(IsTraceable);
+  static const bool value = true;
+};
+
+template <typename T>
 struct IsTraceable<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(IsTraceable);
   static const bool value = true;
 };
 
 }  // namespace WTF
 
 #endif  // Member_h