Oilpan: Move ThreadableWebSocketChannelClientWrapper to Oilpan's heap

Source/core/dom/CrossThreadTask.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 39 matching lines @@
 };
 
 template<typename T> struct CrossThreadTaskTraits<PassRefPtr<T> > {
     typedef PassRefPtr<T> ParamType;
 };
 
 template<typename T> struct CrossThreadTaskTraits<PassOwnPtr<T> > {
     typedef PassOwnPtr<T> ParamType;
 };
 
+// FIXME: Oilpan: Using a RawPtr is not safe.
+// We need to move ExecutionContextTask to the heap and make this a Member.
+template<typename T> struct CrossThreadTaskTraits<RawPtr<T> > {
+    typedef RawPtr<T> ParamType;

[haraken, 2014/05/27 15:01:44]

In order to make the plugin happy, I need to add IGNORE_GC_PLUGIN macros to the
RawPtr. However, we don't want to add IGNORE_GC_PLUGIN to the following 36
parameters like this.

  IGNORE_GC_PLUGIN("...")
  PX m_parameterX;

Is there any way to avoid that?

(Also I noticed that it wouldn't be easy to move ExecutionContextTask to the
heap. If we move ExecutionContextTask to the heap, we need to implement a
trace() method that traces Members. However, there is no easy way to know what
parameters are Members. It might be possible to create an IsMember template, but
we don't want to write it for the 36 parameters...)

[zerny-chromium, 2014/05/28 06:03:19]

You can do an ignore on the classes:

  class GC_PLUGIN_IGNORE("bugnr") CrossThreadTask1;
  ...
  class GC_PLUGIN_IGNORE("bugnr") CrossThreadTask8;
We could add a trace to the CrossThreadTaskTraits specialization so the member
version expands to a trace and the non-member to a noop.

template<typename T> struct CrossThreadTaskTraits<Member<T> > {
  typedef Member<T> ParamType;
  void trace(Visitor* v, ParamType p) { v->trace(p); }
};

and then unconditionally call the traits trace on all params.

+};
+
 template<typename P1, typename MP1>
 class CrossThreadTask1 : public ExecutionContextTask {
 public:
     typedef void (*Method)(ExecutionContext*, MP1);
     typedef CrossThreadTask1<P1, MP1> CrossThreadTask;
     typedef typename CrossThreadTaskTraits<P1>::ParamType Param1;
 
     static PassOwnPtr<CrossThreadTask> create(Method method, Param1 parameter1)
     {
         return adoptPtr(new CrossThreadTask(method, parameter1));
@@ skipping 398 matching lines @@
                                                        method,
                                                        CrossThreadCopier<P1>::copy(parameter1), CrossThreadCopier<P2>::copy(parameter2),
                                                        CrossThreadCopier<P3>::copy(parameter3), CrossThreadCopier<P4>::copy(parameter4),
                                                        CrossThreadCopier<P5>::copy(parameter5), CrossThreadCopier<P6>::copy(parameter6),
                                                        CrossThreadCopier<P7>::copy(parameter7), CrossThreadCopier<P8>::copy(parameter8));
 }
 
 } // namespace WebCore
 
 #endif // CrossThreadTask_h