And now NewRunnableMethod(), you die.

base/task.h

Index: base/task.h
diff --git a/base/task.h b/base/task.h
index 9666a65c0b5c26df0e406e1a571bcad5c8ba3c3c..f22300a6c99b8d6888f1967cdded494fa20a0ee9 100644
--- a/base/task.h
+++ b/base/task.h
@@ -70,231 +70,9 @@ 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 {