Change the ScopedRunnableMethodFactory to use CancelableTasks so that...

base/task.h

 // Copyright (c) 2009 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.
 
 #ifndef BASE_TASK_H_
 #define BASE_TASK_H_
 
 #include "base/non_thread_safe.h"
 #include "base/raw_scoped_refptr_mismatch_checker.h"
 #include "base/tracked.h"
@@ skipping 65 matching lines @@
 // A ScopedRunnableMethodFactory creates runnable methods for a specified
 // object.  This is particularly useful for generating callbacks for
 // non-reference counted objects when the factory is a member of the object.
 template<class T>
 class ScopedRunnableMethodFactory {
  public:
   explicit ScopedRunnableMethodFactory(T* object) : weak_factory_(object) {
   }
 
   template <class Method>
-  inline Task* NewRunnableMethod(Method method) {
+  inline CancelableTask* NewRunnableMethod(Method method) {
     return new RunnableMethod<Method, Tuple0>(
         weak_factory_.GetWeakPtr(), method, MakeTuple());
   }
 
   template <class Method, class A>
-  inline Task* NewRunnableMethod(Method method, const A& a) {
+  inline CancelableTask* NewRunnableMethod(Method method, const A& a) {
     return new RunnableMethod<Method, Tuple1<A> >(
         weak_factory_.GetWeakPtr(), method, MakeTuple(a));
   }
 
   template <class Method, class A, class B>
-  inline Task* NewRunnableMethod(Method method, const A& a, const B& b) {
+  inline CancelableTask* NewRunnableMethod(Method method, const A& a,
+                                           const B& b) {
     return new RunnableMethod<Method, Tuple2<A, B> >(
         weak_factory_.GetWeakPtr(), method, MakeTuple(a, b));
   }
 
   template <class Method, class A, class B, class C>
-  inline Task* NewRunnableMethod(Method method,
+  inline CancelableTask* NewRunnableMethod(Method method,
                                  const A& a,
                                  const B& b,
                                  const C& c) {
     return new RunnableMethod<Method, Tuple3<A, B, C> >(
         weak_factory_.GetWeakPtr(), method, MakeTuple(a, b, c));
   }
 
   template <class Method, class A, class B, class C, class D>
-  inline Task* NewRunnableMethod(Method method,
+  inline CancelableTask* NewRunnableMethod(Method method,
                                  const A& a,
                                  const B& b,
                                  const C& c,
                                  const D& d) {
     return new RunnableMethod<Method, Tuple4<A, B, C, D> >(
         weak_factory_.GetWeakPtr(), method, MakeTuple(a, b, c, d));
   }
 
   template <class Method, class A, class B, class C, class D, class E>
-  inline Task* NewRunnableMethod(Method method,
+  inline CancelableTask* NewRunnableMethod(Method method,
                                  const A& a,
                                  const B& b,
                                  const C& c,
                                  const D& d,
                                  const E& e) {
     return new RunnableMethod<Method, Tuple5<A, B, C, D, E> >(
         weak_factory_.GetWeakPtr(), method, MakeTuple(a, b, c, d, e));
   }
 
   void RevokeAll() { weak_factory_.InvalidateWeakPtrs(); }
 
   bool empty() const { return !weak_factory_.HasWeakPtrs(); }
 
  protected:
   template <class Method, class Params>
-  class RunnableMethod : public Task {
+  class RunnableMethod : public CancelableTask {
    public:
-    RunnableMethod(const base::WeakPtr<T>& obj, Method meth, const Params& params)
+    RunnableMethod(const base::WeakPtr<T>& obj, Method meth,
+                   const Params& params)
         : obj_(obj),
           meth_(meth),
           params_(params) {
       COMPILE_ASSERT((MethodUsesScopedRefptrCorrectly<Method, Params>::value),
                      badscopedrunnablemethodparams);
     }
 
     virtual void Run() {
       if (obj_)
         DispatchToMethod(obj_.get(), meth_, params_);
     }
 
+    virtual void Cancel() {
+      obj_.reset();
+    }
+
    private:
     base::WeakPtr<T> obj_;
     Method meth_;
     Params params_;
 
     DISALLOW_COPY_AND_ASSIGN(RunnableMethod);
   };
 
  private:
   base::WeakPtrFactory<T> weak_factory_;
@@ skipping 284 matching lines @@
                                            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));
 }
 
 #endif  // BASE_TASK_H_