Revert 84060 - Remove cancel from RunnableFunctions.

BUG=NONE
TEST=BUILD

Review URL: http://codereview.chromium.org/6690031

TBR=dmaclach@chromium.org
Review URL: http://codereview.chromium.org/6927012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@84063 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 37 insertions, 24 deletions

diff --git a/base/task.h b/base/task.h
index 643e418..8030169 100644
--- a/base/task.h
+++ b/base/task.h
@@ -442,7 +442,7 @@ inline CancelableTask* NewRunnableMethod(T* object, Method method,
 // RunnableFunction and NewRunnableFunction implementation ---------------------
 
 template <class Function, class Params>
-class RunnableFunction : public Task {
+class RunnableFunction : public CancelableTask {
  public:
   RunnableFunction(Function function, const Params& params)
       : function_(function), params_(params) {
@@ -459,45 +459,53 @@ class RunnableFunction : public Task {
       DispatchToFunction(function_, params_);
   }
 
+  virtual void Cancel() {
+  }
+
  private:
   Function function_;
   Params params_;
 };
 
 template <class Function>
-inline Task* NewRunnableFunction(Function function) {
+inline CancelableTask* NewRunnableFunction(Function function) {
   return new RunnableFunction<Function, Tuple0>(function, MakeTuple());
 }
 
 template <class Function, class A>
-inline Task* NewRunnableFunction(Function function, const A& a) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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,
@@ -506,27 +514,32 @@ inline Task* NewRunnableFunction(Function function, const A& a, const B& b,
 
 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) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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) {
+inline CancelableTask* 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));
 }
diff --git a/remoting/client/chromoting_client.cc b/remoting/client/chromoting_client.cc
index 6d26d41..2e4e7334 100644
--- a/remoting/client/chromoting_client.cc
+++ b/remoting/client/chromoting_client.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -21,7 +21,7 @@ ChromotingClient::ChromotingClient(const ClientConfig& config,
                                    ChromotingView* view,
                                    RectangleUpdateDecoder* rectangle_decoder,
                                    InputHandler* input_handler,
-                                   Task* client_done)
+                                   CancelableTask* client_done)
     : config_(config),
       context_(context),
       connection_(connection),
diff --git a/remoting/client/chromoting_client.h b/remoting/client/chromoting_client.h
index 217af1b..31dd631 100644
--- a/remoting/client/chromoting_client.h
+++ b/remoting/client/chromoting_client.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -45,7 +45,7 @@ class ChromotingClient : public protocol::ConnectionToHost::HostEventCallback,
                    ChromotingView* view,
                    RectangleUpdateDecoder* rectangle_decoder,
                    InputHandler* input_handler,
-                   Task* client_done);
+                   CancelableTask* client_done);
   virtual ~ChromotingClient();
 
   void Start();
@@ -119,7 +119,7 @@ class ChromotingClient : public protocol::ConnectionToHost::HostEventCallback,
   InputHandler* input_handler_;
 
   // If non-NULL, this is called when the client is done.
-  Task* client_done_;
+  CancelableTask* client_done_;
 
   ConnectionState state_;