Oilpan: Move ThreadableWebSocketChannelClientWrapper to Oilpan's heap

Source/platform/CrossThreadCopier.h

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CrossThreadCopier_h
 #define CrossThreadCopier_h
 
 #include "platform/PlatformExport.h"
+#include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
 #include "wtf/Forward.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 #include "wtf/TypeTraits.h"
 
 namespace WebCore {
 
     class IntRect;
     class IntSize;
     class KURL;
     class ResourceError;
     class ResourceRequest;
     class ResourceResponse;
+    class ThreadableWebSocketChannelClientWrapper;
     struct CrossThreadResourceResponseData;
     struct CrossThreadResourceRequestData;
     struct ThreadableLoaderOptions;
 
     template<typename T> struct CrossThreadCopierPassThrough {
         typedef T Type;
         static Type copy(const T& parameter)
         {
             return parameter;
         }
@@ skipping 36 matching lines @@
     };
 
     template<typename T> struct CrossThreadCopierBase<false, false, PassOwnPtr<T> > {
         typedef PassOwnPtr<T> Type;
         static Type copy(Type ownPtr)
         {
             return ownPtr;
         }
     };
 
+    template<> struct CrossThreadCopierBase<false, false, ThreadableWebSocketChannelClientWrapper*> {

[haraken, 2014/05/07 07:45:16]

I must admit that I'm not understanding what I'm doing.

I added this template specialization to make the CL compilable and pass all
tests, but I'm not quite sure if this is right.

template experts: I'd be happy if you could give me any advice.

[tkent, 2014/05/07 08:10:41]

The generated code would be ok.  We don't need special handling on copying a
pointer to an on-heap object over threads.
However, referring to a class in a modules here is a kind of layering violation.
We should have a specialization for IsSubclassOfTemplate<T, GarbageCollected>.

Also, this change is not enough. We need a specialization for
CrossThreadTaskTraits so that m_parameterN in CrossTheradTaskM becomes
CrossThreadPersistent.

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

Done. Please take a look, I'm not familiar with templates :)

+        typedef ThreadableWebSocketChannelClientWrapper* Type;
+        static Type copy(Type rawPtr)
+        {
+            return rawPtr;
+        }
+    };
+
     template<> struct CrossThreadCopierBase<false, false, KURL> {
         typedef KURL Type;
         PLATFORM_EXPORT static Type copy(const KURL&);
     };
 
     template<> struct CrossThreadCopierBase<false, false, String> {
         typedef String Type;
         PLATFORM_EXPORT static Type copy(const String&);
     };
 
@@ skipping 54 matching lines @@
 
     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
     {
         return AllowAccessLaterWrapper<T>(value);
     }
 
 
 } // namespace WebCore
 
 #endif // CrossThreadCopier_h