Replace CallClosureTask::create(bind()) with createCrossThreadTask()

Source/core/dom/ExecutionContextTask.h

 /*
  * Copyright (C) 2013 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.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ExecutionContextTask_h
 #define ExecutionContextTask_h
 
 #include "wtf/FastAllocBase.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
+#include "wtf/WeakPtr.h"
 
 namespace WebCore {
 
 class ExecutionContext;
 
 class ExecutionContextTask {
     WTF_MAKE_NONCOPYABLE(ExecutionContextTask);
     WTF_MAKE_FAST_ALLOCATED;
 public:
     ExecutionContextTask() { }
     virtual ~ExecutionContextTask() { }
     virtual void performTask(ExecutionContext*) = 0;
     // Certain tasks get marked specially so that they aren't discarded, and are executed, when the context is shutting down its message queue.
     virtual bool isCleanupTask() const { return false; }
 };
 
 class CallClosureTask FINAL : public ExecutionContextTask {
 public:
+    virtual void performTask(ExecutionContext*) OVERRIDE { m_closure(); }
+
+private:
+    // Do not use create other than in createCallClosureTask. http://crbug.com/390851

[yhirano, 2014/07/10 04:55:42]

"Do not use |create| ..." or "Do not use create() ..." is easier to understand.

[hiroshige, 2014/07/10 07:16:32]

Done.

     static PassOwnPtr<CallClosureTask> create(const Closure& closure)
     {
         return adoptPtr(new CallClosureTask(closure));
     }
-    virtual void performTask(ExecutionContext*) OVERRIDE { m_closure(); }
-
-private:
     explicit CallClosureTask(const Closure& closure) : m_closure(closure) { }
     Closure m_closure;
+
+    // Templates for member function of class C + raw pointer (C*)
+    // which do not use CrossThreadCopier for the raw pointer
+    template<typename R, typename C>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(), C*);

[tkent, 2014/07/10 03:36:14]

These |friend|s are ugly and overkill.  Keeping the factory public and adding
the |do not use| comment is enough.

[hiroshige, 2014/07/10 07:16:32]

Done.

+    template<typename R, typename C, typename P2, typename A2>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2), C*, const A2&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3), C*, const A2&, const A3&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4), C*, const A2&, const A3&, const A4&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4, typename P5, typename A5>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4, P5), C*, const A2&, const A3&, const A4&, const A5&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4, typename P5, typename A5, typename P6, typename A6>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4, P5, P6), C*, const A2&, const A3&, const A4&, const A5&, const A6&);
+    // Templates for member function of class C + weak pointer (const WeakPtr<C>&)
+    // which do not use CrossThreadCopier for the weak pointer
+    template<typename R, typename C>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(), const WeakPtr<C>&);
+    template<typename R, typename C, typename P2, typename A2>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2), const WeakPtr<C>&, const A2&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3), const WeakPtr<C>&, const A2&, const A3&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4), const WeakPtr<C>&, const A2&, const A3&, const A4&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4, typename P5, typename A5>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4, P5), const WeakPtr<C>&, const A2&, const A3&, const A4&, const A5&);
+    template<typename R, typename C, typename P2, typename A2, typename P3, typename A3, typename P4, typename A4, typename P5, typename A5, typename P6, typename A6>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(R (C::*)(P2, P3, P4, P5, P6), const WeakPtr<C>&, const A2&, const A3&, const A4&, const A5&, const A6&);
+    // Other cases; use CrossThreadCopier for all arguments
+    template<typename FunctionType>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType);
+    template<typename FunctionType, typename A1>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&);
+    template<typename FunctionType, typename A1, typename A2>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&, const A2&);
+    template<typename FunctionType, typename A1, typename A2, typename A3>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&, const A2&, const A3&);
+    template<typename FunctionType, typename A1, typename A2, typename A3, typename A4>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&, const A2&, const A3&, const A4&);
+    template<typename FunctionType, typename A1, typename A2, typename A3, typename A4, typename A5>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&, const A2&, const A3&, const A4&, const A5&);
+    template<typename FunctionType, typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
+    friend PassOwnPtr<ExecutionContextTask> createCallClosureTask(FunctionType, const A1&, const A2&, const A3&, const A4&, const A5&, const A6&);
 };
 
 } // namespace
 
 #endif