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

third_party/WebKit/Source/platform/heap/HeapAllocator.h

 // Copyright 2015 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 HeapAllocator_h
 #define HeapAllocator_h
 
 #include "platform/heap/Heap.h"
 #include "platform/heap/Persistent.h"
 #include "platform/heap/TraceTraits.h"
@@ skipping 461 matching lines @@
 template <typename T>
 struct VectorTraits<blink::Member<T>> : VectorTraitsBase<blink::Member<T>> {
   STATIC_ONLY(VectorTraits);
   static const bool needsDestruction = false;
   static const bool canInitializeWithMemset = true;
   static const bool canClearUnusedSlotsWithMemset = true;
   static const bool canMoveWithMemcpy = true;
 };
 
 template <typename T>
+struct VectorTraits<blink::SameThreadCheckedMember<T>>
+    : VectorTraitsBase<blink::SameThreadCheckedMember<T>> {
+  STATIC_ONLY(VectorTraits);
+  static const bool needsDestruction = false;
+  static const bool canInitializeWithMemset = true;
+  static const bool canClearUnusedSlotsWithMemset = true;
+  static const bool canMoveWithMemcpy = true;
+  static const bool canSwapUsingCopyOrMove = false;
+};
+
+template <typename T>
 struct VectorTraits<blink::TraceWrapperMember<T>>
     : VectorTraitsBase<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(VectorTraits);
   static const bool needsDestruction = false;
   static const bool canInitializeWithMemset = true;
   static const bool canClearUnusedSlotsWithMemset = true;
   static const bool canMoveWithMemcpy = true;
   static const bool canSwapUsingCopyOrMove = false;
 };
 
@@ skipping 104 matching lines @@
 
   template <typename U>
   static void store(const U& value, blink::Member<T>& storage) {
     storage = value;
   }
 
   static PeekOutType peek(const blink::Member<T>& value) { return value; }
 };
 
 template <typename T>
+struct HashTraits<blink::SameThreadCheckedMember<T>>
+    : SimpleClassHashTraits<blink::SameThreadCheckedMember<T>> {
+  STATIC_ONLY(HashTraits);
+  // FIXME: The distinction between PeekInType and PassInType is there for
+  // the sake of the reference counting handles. When they are gone the two
+  // types can be merged into PassInType.
+  // FIXME: Implement proper const'ness for iterator types. Requires support
+  // in the marking Visitor.
+  using PeekInType = T*;
+  using PassInType = T*;
+  using IteratorGetType = blink::SameThreadCheckedMember<T>*;
+  using IteratorConstGetType = const blink::SameThreadCheckedMember<T>*;
+  using IteratorReferenceType = blink::SameThreadCheckedMember<T>&;
+  using IteratorConstReferenceType = const blink::SameThreadCheckedMember<T>&;
+  static IteratorReferenceType getToReferenceConversion(IteratorGetType x) {
+    return *x;
+  }
+  static IteratorConstReferenceType getToReferenceConstConversion(
+      IteratorConstGetType x) {
+    return *x;
+  }
+
+  using PeekOutType = T*;
+
+  template <typename U>
+  static void store(const U& value,
+                    blink::SameThreadCheckedMember<T>& storage) {
+    storage = value;
+  }
+
+  static PeekOutType peek(const blink::SameThreadCheckedMember<T>& value) {
+    return value;
+  }
+
+  static blink::SameThreadCheckedMember<T> emptyValue() {
+    return blink::SameThreadCheckedMember<T>(nullptr, nullptr);
+  }
+};
+
+template <typename T>
 struct HashTraits<blink::TraceWrapperMember<T>>
     : SimpleClassHashTraits<blink::TraceWrapperMember<T>> {
   STATIC_ONLY(HashTraits);
   // FIXME: The distinction between PeekInType and PassInType is there for
   // the sake of the reference counting handles. When they are gone the two
   // types can be merged into PassInType.
   // FIXME: Implement proper const'ness for iterator types. Requires support
   // in the marking Visitor.
   using PeekInType = T*;
   using PassInType = T*;
@@ skipping 169 matching lines @@
     const blink::HeapHashCountedSet<Value, HashFunctions, Traits>& set,
     VectorType& vector) {
   copyToVector(static_cast<const HashCountedSet<Value, HashFunctions, Traits,
                                                 blink::HeapAllocator>&>(set),
                vector);
 }
 
 }  // namespace WTF
 
 #endif