Oilpan: Move ThreadableWebSocketChannelClientWrapper to Oilpan's heap

Source/platform/CrossThreadCopier.h

Index: Source/platform/CrossThreadCopier.h
diff --git a/Source/platform/CrossThreadCopier.h b/Source/platform/CrossThreadCopier.h
index 0adbf860d1a5026e9614682c7c7555deb1022c9c..a4c33c88939202668c57d9d535b92f31d38124da 100644
--- a/Source/platform/CrossThreadCopier.h
+++ b/Source/platform/CrossThreadCopier.h
@@ -32,6 +32,7 @@
 #define CrossThreadCopier_h
 
 #include "platform/PlatformExport.h"
+#include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
 #include "wtf/Forward.h"
 #include "wtf/PassOwnPtr.h"
@@ -60,25 +61,25 @@ namespace WebCore {
         }
     };
 
-    template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, typename T> struct CrossThreadCopierBase;
+    template<bool isConvertibleToInteger, bool isThreadSafeRefCounted, bool isGarbageCollected, typename T> struct CrossThreadCopierBase;
 
     // Integers get passed through without any changes.
-    template<typename T> struct CrossThreadCopierBase<true, false, T> : public CrossThreadCopierPassThrough<T> {
+    template<typename T> struct CrossThreadCopierBase<true, false, false, T> : public CrossThreadCopierPassThrough<T> {
     };
 
     // To allow a type to be passed across threads using its copy constructor, add a forward declaration of the type and
     // a CopyThreadCopierBase<false, false, TypeName> : public CrossThreadCopierPassThrough<TypeName> { }; to this file.
-    template<> struct CrossThreadCopierBase<false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
+    template<> struct CrossThreadCopierBase<false, false, false, ThreadableLoaderOptions> : public CrossThreadCopierPassThrough<ThreadableLoaderOptions> {
     };
 
-    template<> struct CrossThreadCopierBase<false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
+    template<> struct CrossThreadCopierBase<false, false, false, IntRect> : public CrossThreadCopierPassThrough<IntRect> {
     };
 
-    template<> struct CrossThreadCopierBase<false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
+    template<> struct CrossThreadCopierBase<false, false, false, IntSize> : public CrossThreadCopierPassThrough<IntSize> {
     };
 
     // Custom copy methods.
-    template<typename T> struct CrossThreadCopierBase<false, true, T> {
+    template<typename T> struct CrossThreadCopierBase<false, true, false, T> {
         typedef typename WTF::RemoveTemplate<T, RefPtr>::Type TypeWithoutRefPtr;
         typedef typename WTF::RemoveTemplate<TypeWithoutRefPtr, PassRefPtr>::Type TypeWithoutPassRefPtr;
         typedef typename WTF::RemovePointer<TypeWithoutPassRefPtr>::Type RefCountedType;
@@ -96,7 +97,7 @@ namespace WebCore {
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, PassOwnPtr<T> > {
         typedef PassOwnPtr<T> Type;
         static Type copy(Type ownPtr)
         {
@@ -104,36 +105,45 @@ namespace WebCore {
         }
     };
 
-    template<> struct CrossThreadCopierBase<false, false, KURL> {
+    template<> struct CrossThreadCopierBase<false, false, false, KURL> {
         typedef KURL Type;
         PLATFORM_EXPORT static Type copy(const KURL&);
     };
 
-    template<> struct CrossThreadCopierBase<false, false, String> {
+    template<> struct CrossThreadCopierBase<false, false, false, String> {
         typedef String Type;
         PLATFORM_EXPORT static Type copy(const String&);
     };
 
-    template<> struct CrossThreadCopierBase<false, false, ResourceError> {
+    template<> struct CrossThreadCopierBase<false, false, false, ResourceError> {
         typedef ResourceError Type;
         PLATFORM_EXPORT static Type copy(const ResourceError&);
     };
 
-    template<> struct CrossThreadCopierBase<false, false, ResourceRequest> {
+    template<> struct CrossThreadCopierBase<false, false, false, ResourceRequest> {
         typedef PassOwnPtr<CrossThreadResourceRequestData> Type;
         PLATFORM_EXPORT static Type copy(const ResourceRequest&);
     };
 
-    template<> struct CrossThreadCopierBase<false, false, ResourceResponse> {
+    template<> struct CrossThreadCopierBase<false, false, false, ResourceResponse> {
         typedef PassOwnPtr<CrossThreadResourceResponseData> Type;
         PLATFORM_EXPORT static Type copy(const ResourceResponse&);
     };
 
+    template<typename T> struct CrossThreadCopierBase<false, false, true, T> {
+        typedef T Type;
+        static Type copy(Type ptr)
+        {
+            return ptr;
+        }
+    };
+
     template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
-                                                                                 WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
-                                                                                     || WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, ThreadSafeRefCounted>::value
-                                                                                     || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, PassRefPtr>::Type, ThreadSafeRefCounted>::value,
-                                                                                 T> {
+        WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
+            || WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, ThreadSafeRefCounted>::value
+            || WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, PassRefPtr>::Type, ThreadSafeRefCounted>::value,
+        WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, GarbageCollected>::value,

[haraken, 2014/05/07 11:18:33]

zerny@: In order to pass a Persistent to createCallbackTask, I need to add
something like:

WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type,
GarbageCollected>::value || WTF::IsSubclassOfTemplate<typename
WTF::RemoveTemplate<T, Persistent>::Type, GarbageCollected>::value

but this didn't compile :(

[zerny-chromium, 2014/05/07 11:56:39]

Something like that should work. Do you need to WebCore:: qualify Persistent?

+        T> {
     };
 
     template<typename T> struct AllowCrossThreadAccessWrapper {
@@ -144,7 +154,7 @@ namespace WebCore {
         T* m_value;
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, AllowCrossThreadAccessWrapper<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowCrossThreadAccessWrapper<T> > {
         typedef T* Type;
         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
     };
@@ -164,7 +174,7 @@ namespace WebCore {
         T* m_value;
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, AllowAccessLaterWrapper<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowAccessLaterWrapper<T> > {
         typedef T* Type;
         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
     };