Move CrossThreadCopier from platform/ to wtf/

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"
 #include "platform/heap/Visitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Atomics.h"
+#include "wtf/CrossThreadCopier.h"
 
 namespace blink {
 
 // Marker used to annotate persistent objects and collections with,
 // so as to enable reliable testing for persistent references via
 // a type trait (see TypeTraits.h's IsPersistentReferenceType<>.)
 #define IS_PERSISTENT_REFERENCE_TYPE()               \
     public:                                          \
         using IsPersistentReferenceTypeMarker = int; \
     private:
@@ skipping 403 matching lines @@
     }
 
     template<typename U>
     CrossThreadPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
+} // namespace blink
+
+namespace WTF {
+
+template<typename T>
+struct CrossThreadCopier<blink::CrossThreadPersistent<T>> : public CrossThreadCopierPassThrough<blink::CrossThreadPersistent<T>> {
+    STATIC_ONLY(CrossThreadCopier);
+};
+
+} // namespace WTF
+
+namespace blink {
+
 // Combines the behavior of CrossThreadPersistent and WeakPersistent.
 template<typename T>
 class CrossThreadWeakPersistent : public PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> {
     typedef PersistentBase<T, WeakPersistentConfiguration, CrossThreadPersistentConfiguration> Parent;
 public:
     CrossThreadWeakPersistent() : Parent() { }
     CrossThreadWeakPersistent(std::nullptr_t) : Parent(nullptr) { }
     CrossThreadWeakPersistent(T* raw) : Parent(raw) { }
     CrossThreadWeakPersistent(T& raw) : Parent(raw) { }
     CrossThreadWeakPersistent(const CrossThreadWeakPersistent& other) : Parent(other) { }
@@ skipping 29 matching lines @@
     }
 
     template<typename U>
     CrossThreadWeakPersistent& operator=(const Member<U>& other)
     {
         Parent::operator=(other);
         return *this;
     }
 };
 
+} // namespace blink
+
+namespace WTF {
+
+template<typename T>
+struct CrossThreadCopier<blink::CrossThreadWeakPersistent<T>> : public CrossThreadCopierPassThrough<blink::CrossThreadWeakPersistent<T>> {
+    STATIC_ONLY(CrossThreadCopier);
+};
+
+} // namespace WTF
+
+namespace blink {
+
 template<typename Collection>
 class PersistentHeapCollectionBase : public Collection {
     // We overload the various new and delete operators with using the WTF PartitionAllocator to ensure persistent
     // heap collections are always allocated off-heap. This allows persistent collections to be used in
     // DEFINE_STATIC_LOCAL et. al.
     WTF_USE_ALLOCATOR(PersistentHeapCollectionBase, WTF::PartitionAllocator);
     IS_PERSISTENT_REFERENCE_TYPE();
 public:
     PersistentHeapCollectionBase()
     {
@@ skipping 227 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