And now NewRunnableMethod(), you die.

base/task.h

 // Copyright (c) 2012 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 52 matching lines @@
 
   // Not all tasks support cancellation.
   virtual void Cancel() = 0;
 };
 
 template<typename T>
 void DeletePointer(T* obj) {
   delete obj;
 }
 
-// RunnableMethodTraits --------------------------------------------------------
-//
-// This traits-class is used by RunnableMethod to manage the lifetime of the
-// callee object.  By default, it is assumed that the callee supports AddRef
-// and Release methods.  A particular class can specialize this template to
-// define other lifetime management.  For example, if the callee is known to
-// live longer than the RunnableMethod object, then a RunnableMethodTraits
-// struct could be defined with empty RetainCallee and ReleaseCallee methods.
-//
-// The DISABLE_RUNNABLE_METHOD_REFCOUNT macro is provided as a convenient way
-// for declaring a RunnableMethodTraits that disables refcounting.
-
-template <class T>
-struct RunnableMethodTraits {
-  RunnableMethodTraits() {
-#ifndef NDEBUG
-    origin_thread_id_ = base::PlatformThread::CurrentId();
-#endif
-  }
-
-  ~RunnableMethodTraits() {
-#ifndef NDEBUG
-    // If destroyed on a separate thread, then we had better have been using
-    // thread-safe reference counting!
-    if (origin_thread_id_ != base::PlatformThread::CurrentId())
-      DCHECK(T::ImplementsThreadSafeReferenceCounting());
-#endif
-  }
-
-  void RetainCallee(T* obj) {
-#ifndef NDEBUG
-    // Catch NewRunnableMethod being called in an object's constructor.  This
-    // isn't safe since the method can be invoked before the constructor
-    // completes, causing the object to be deleted.
-    obj->AddRef();
-    obj->Release();
-#endif
-    obj->AddRef();
-  }
-
-  void ReleaseCallee(T* obj) {
-    obj->Release();
-  }
-
- private:
-#ifndef NDEBUG
-  base::PlatformThreadId origin_thread_id_;
-#endif
-};
-
-// Convenience macro for declaring a RunnableMethodTraits that disables
-// refcounting of a class.  This is useful if you know that the callee
-// will outlive the RunnableMethod object and thus do not need the ref counts.
-//
-// The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the
-// global namespace scope.  Example:
-//
-//   namespace foo {
-//   class Bar {
-//     ...
-//   };
-//   }  // namespace foo
-//
-//   DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar);
-//
-// 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 --------------------------------------------------------------
-//
-// 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
-// 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]])
-
-// 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(
-        (base::internal::ParamsUseScopedRefptrCorrectly<Params>::value),
-        badrunnablemethodparams);
-  }
-
-  ~RunnableMethod() {
-    ReleaseCallee();
-    obj_ = reinterpret_cast<T*>(base::kDeadTask);
-  }
-
-  virtual void Run() {
-    if (obj_)
-      DispatchToMethod(obj_, meth_, params_);
-  }
-
-  virtual void Cancel() {
-    ReleaseCallee();
-  }
-
- private:
-  void ReleaseCallee() {
-    T* obj = obj_;
-    obj_ = NULL;
-    if (obj)
-      traits_.ReleaseCallee(obj);
-  }
-
-  T* obj_;
-  Method meth_;
-  Params params_;
-  RunnableMethodTraits<T> traits_;
-};
-
-template <class T, class Method>
-inline CancelableTask* NewRunnableMethod(T* object, Method method) {
-  return new RunnableMethod<T, Method, Tuple0>(object, method, MakeTuple());
-}
-
-template <class T, class Method, class A>
-inline CancelableTask* NewRunnableMethod(T* object, Method method, const A& a) {
-  return new RunnableMethod<T, Method, Tuple1<A> >(object,
-                                                   method,
-                                                   MakeTuple(a));
-}
-
-template <class T, class Method, class A, class B>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-const A& a, const B& b) {
-  return new RunnableMethod<T, Method, Tuple2<A, B> >(object, method,
-                                                      MakeTuple(a, b));
-}
-
-template <class T, class Method, class A, class B, class C>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                          const A& a, const B& b, const C& c) {
-  return new RunnableMethod<T, Method, Tuple3<A, B, C> >(object, method,
-                                                         MakeTuple(a, b, c));
-}
-
-template <class T, class Method, class A, class B, class C, class D>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                          const A& a, const B& b,
-                                          const C& c, const D& d) {
-  return new RunnableMethod<T, Method, Tuple4<A, B, C, D> >(object, method,
-                                                            MakeTuple(a, b,
-                                                                      c, d));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                          const A& a, const B& b,
-                                          const C& c, const D& d, const E& e) {
-  return new RunnableMethod<T,
-                            Method,
-                            Tuple5<A, B, C, D, E> >(object,
-                                                    method,
-                                                    MakeTuple(a, b, c, d, e));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E,
-          class F>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                          const A& a, const B& b,
-                                          const C& c, const D& d, const E& e,
-                                          const F& f) {
-  return new RunnableMethod<T,
-                            Method,
-                            Tuple6<A, B, C, D, E, F> >(object,
-                                                       method,
-                                                       MakeTuple(a, b, c, d, e,
-                                                                 f));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E,
-          class F, class G>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                         const A& a, const B& b,
-                                         const C& c, const D& d, const E& e,
-                                         const F& f, const G& g) {
-  return new RunnableMethod<T,
-                            Method,
-                            Tuple7<A, B, C, D, E, F, G> >(object,
-                                                          method,
-                                                          MakeTuple(a, b, c, d,
-                                                                    e, f, g));
-}
-
-template <class T, class Method, class A, class B, class C, class D, class E,
-          class F, class G, class H>
-inline CancelableTask* NewRunnableMethod(T* object, Method method,
-                                         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 RunnableMethod<T,
-                            Method,
-                            Tuple8<A, B, C, D, E, F, G, H> >(object,
-                                                             method,
-                                                             MakeTuple(a, b, c,
-                                                                       d, e, f,
-                                                                       g, h));
+template<typename T>
+void ReleasePointer(T* obj) {
+  obj->Release();
 }
 
 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);
@@ skipping 54 matching lines @@
   Task* task_;
   bool* should_leak_task_;
   static bool kTaskLeakingDefault;
 };
 
 }  // namespace subtle
 
 }  // namespace base
 
 #endif  // BASE_TASK_H_