base::Bind: Remove NewRunnableFunction.

base/task.h

 // Copyright (c) 2011 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.
 
 // ============================================================================
 // ****************************************************************************
 // *  THIS HEADER IS DEPRECATED, SEE base/callback.h FOR NEW IMPLEMENTATION   *
 // ****************************************************************************
 // ============================================================================
 // ============================================================================
@@ skipping 286 matching lines @@
 //
 // This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the
 // class.
 #define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \
   template <>                                      \
   struct RunnableMethodTraits<TypeName> {          \
     void RetainCallee(TypeName* manager) {}        \
     void ReleaseCallee(TypeName* manager) {}       \
   }
 
-// RunnableMethod and RunnableFunction -----------------------------------------
+// RunnableMethod --------------------------------------------------------------
 //
 // Runnable methods are a type of task that call a function on an object when
-// they are run. We implement both an object and a set of NewRunnableMethod and
-// NewRunnableFunction functions for convenience. These functions are
-// overloaded and will infer the template types, simplifying calling code.
+// they are run. We implement both an object and a set of NewRunnableMethod
+// functions for convenience. These functions are overloaded and will infer the
+// template types, simplifying calling code.
 //
 // The template definitions all use the following names:
 // T                - the class type of the object you're supplying
 //                    this is not needed for the Static version of the call
 // Method/Function  - the signature of a pointer to the method or function you
 //                    want to call
 // Param            - the parameter(s) to the method, possibly packed as a Tuple
 // A                - the first parameter (if any) to the method
 // B                - the second parameter (if any) to the method
 //
 // Put these all together and you get an object that can call a method whose
 // signature is:
 //   R T::MyFunction([A[, B]])
 //
 // Usage:
 // PostTask(FROM_HERE, NewRunnableMethod(object, &Object::method[, a[, b]])
-// PostTask(FROM_HERE, NewRunnableFunction(&function[, a[, b]])
 
 // RunnableMethod and NewRunnableMethod implementation -------------------------
 
 template <class T, class Method, class Params>
 class RunnableMethod : public CancelableTask {
  public:
   RunnableMethod(T* obj, Method meth, const Params& params)
       : obj_(obj), meth_(meth), params_(params) {
     traits_.RetainCallee(obj_);
     COMPILE_ASSERT(
@@ skipping 111 matching lines @@
                                          const F& f, const G& g, const H& h) {
   return new RunnableMethod<T,
                             Method,
                             Tuple8<A, B, C, D, E, F, G, H> >(object,
                                                              method,
                                                              MakeTuple(a, b, c,
                                                                        d, e, f,
                                                                        g, h));
 }
 
-// RunnableFunction and NewRunnableFunction implementation ---------------------
-
-template <class Function, class Params>
-class RunnableFunction : public Task {
- public:
-  RunnableFunction(Function function, const Params& params)
-      : function_(function), params_(params) {
-    COMPILE_ASSERT(
-        (base::internal::ParamsUseScopedRefptrCorrectly<Params>::value),
-        badrunnablefunctionparams);
-  }
-
-  ~RunnableFunction() {
-    function_ = reinterpret_cast<Function>(base::kDeadTask);
-  }
-
-  virtual void Run() {
-    if (function_)
-      DispatchToFunction(function_, params_);
-  }
-
- private:
-  Function function_;
-  Params params_;
-};
-
-template <class Function>
-inline Task* NewRunnableFunction(Function function) {
-  return new RunnableFunction<Function, Tuple0>(function, MakeTuple());
-}
-
-template <class Function, class A>
-inline Task* NewRunnableFunction(Function function, const A& a) {
-  return new RunnableFunction<Function, Tuple1<A> >(function, MakeTuple(a));
-}
-
-template <class Function, class A, class B>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b) {
-  return new RunnableFunction<Function, Tuple2<A, B> >(function,
-                                                       MakeTuple(a, b));
-}
-
-template <class Function, class A, class B, class C>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c) {
-  return new RunnableFunction<Function, Tuple3<A, B, C> >(function,
-                                                          MakeTuple(a, b, c));
-}
-
-template <class Function, class A, class B, class C, class D>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c, const D& d) {
-  return new RunnableFunction<Function, Tuple4<A, B, C, D> >(function,
-                                                             MakeTuple(a, b,
-                                                                       c, d));
-}
-
-template <class Function, class A, class B, class C, class D, class E>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c, const D& d, const E& e) {
-  return new RunnableFunction<Function, Tuple5<A, B, C, D, E> >(function,
-                                                                MakeTuple(a, b,
-                                                                          c, d,
-                                                                          e));
-}
-
-template <class Function, class A, class B, class C, class D, class E,
-          class F>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c, const D& d, const E& e,
-                                 const F& f) {
-  return new RunnableFunction<Function, Tuple6<A, B, C, D, E, F> >(function,
-      MakeTuple(a, b, c, d, e, f));
-}
-
-template <class Function, class A, class B, class C, class D, class E,
-          class F, class G>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c, const D& d, const E& e, const F& f,
-                                 const G& g) {
-  return new RunnableFunction<Function, Tuple7<A, B, C, D, E, F, G> >(function,
-      MakeTuple(a, b, c, d, e, f, g));
-}
-
-template <class Function, class A, class B, class C, class D, class E,
-          class F, class G, class H>
-inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
-                                 const C& c, const D& d, const E& e, const F& f,
-                                 const G& g, const H& h) {
-  return new RunnableFunction<Function, Tuple8<A, B, C, D, E, F, G, H> >(
-      function, MakeTuple(a, b, c, d, e, f, g, h));
-}
-
 namespace base {
 
 // ScopedTaskRunner is akin to scoped_ptr for Tasks.  It ensures that the Task
 // is executed and deleted no matter how the current scope exits.
 class BASE_EXPORT ScopedTaskRunner {
  public:
   // Takes ownership of the task.
   explicit ScopedTaskRunner(Task* task);
   ~ScopedTaskRunner();
 
@@ skipping 52 matching lines @@
   Task* task_;
   bool* should_leak_task_;
   static bool kTaskLeakingDefault;
 };
 
 }  // namespace subtle
 
 }  // namespace base
 
 #endif  // BASE_TASK_H_