Allow CrossThreadPersistent in collections

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"
 #include "wtf/Allocator.h"
 #include "wtf/Assertions.h"
 #include "wtf/Deque.h"
 #include "wtf/HashCountedSet.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/HashTable.h"
 #include "wtf/LinkedHashSet.h"
 #include "wtf/ListHashSet.h"
@@ skipping 396 matching lines @@
 };
 
 template <typename T> struct VectorTraits<blink::UntracedMember<T>> : VectorTraitsBase<blink::UntracedMember<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, blink::WeaknessPersistentConfiguration weaknessConfiguration, blink::CrossThreadnessPersistentConfiguration crossThreadnessConfiguration>
+struct VectorTraits<blink::PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>>
+    : VectorTraitsBase<blink::PersistentBase<T, weaknessConfiguration, crossThreadnessConfiguration>> {
+    STATIC_ONLY(VectorTraits);
+    static const bool needsDestruction = true;
+    static const bool canInitializeWithMemset = true;
+    static const bool canClearUnusedSlotsWithMemset = false;
+    static const bool canMoveWithMemcpy = true;
+};
+
 template <typename T> struct VectorTraits<blink::HeapVector<T, 0>> : VectorTraitsBase<blink::HeapVector<T, 0>> {
     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::HeapDeque<T, 0>> : VectorTraitsBase<blink::HeapDeque<T, 0>> {
     STATIC_ONLY(VectorTraits);
@@ skipping 109 matching lines @@
     // regardless of whether they contain pointers to other heap allocated
     // objects.
     static const bool value = true;
 };
 
 template<typename T, size_t inlineCapacity>
 struct IsGarbageCollectedType<ListHashSetNode<T, blink::HeapListHashSetAllocator<T, inlineCapacity>>> {
     static const bool value = true;
 };
 
+template<typename T> struct HashTraits<blink::CrossThreadPersistent<T>> : SimpleClassHashTraits<blink::CrossThreadPersistent<T>> {

[sof, 2016/05/26 09:41:44]

Can we make this be over PersistentBase<> also, or do we need to split it out
into two specializations?

[keishi, 2016/05/26 11:38:17]

I tried PersistentBase but it didn't work so had to split it. But I created
HandleHashTrait to share the code.

+    STATIC_ONLY(HashTraits);
+    // TODO: 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.
+    // TODO: Implement proper const'ness for iterator types. Requires support
+    // in the marking Visitor.
+    using PeekInType = T*;
+    using PassInType = T*;
+    using IteratorGetType = blink::CrossThreadPersistent<T>*;
+    using IteratorConstGetType = const blink::CrossThreadPersistent<T>*;
+    using IteratorReferenceType = blink::CrossThreadPersistent<T>&;
+    using IteratorConstReferenceType = const blink::CrossThreadPersistent<T>&;
+    static IteratorReferenceType getToReferenceConversion(IteratorGetType x) { return *x; }
+    static IteratorConstReferenceType getToReferenceConstConversion(IteratorConstGetType x) { return *x; }
+    // TODO: Similarly, there is no need for a distinction between PeekOutType
+    // and PassOutType without reference counting.
+    using PeekOutType = T*;
+    using PassOutType = T*;
+
+    template<typename U>
+    static void store(const U& value, blink::CrossThreadPersistent<T>& storage) { storage = value; }
+
+    static PeekOutType peek(const blink::CrossThreadPersistent<T>& value) { return value; }
+    static PassOutType passOut(const blink::CrossThreadPersistent<T>& value) { return value; }
+};
+
 } // namespace WTF
 
 #endif