Add interface to CancelableRequest that allows use of base::Callback<>.

content/browser/cancelable_request.cc

 // 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.
 
 #include "content/browser/cancelable_request.h"
 
 CancelableRequestProvider::CancelableRequestProvider()
     : next_handle_(1) {
 }
 
@@ skipping 89 matching lines @@
 }
 
 void CancelableRequestBase::Init(CancelableRequestProvider* provider,
                                  CancelableRequestProvider::Handle handle,
                                  CancelableRequestConsumerBase* consumer) {
   DCHECK(handle_ == 0 && provider_ == NULL && consumer_ == NULL);
   provider_ = provider;
   consumer_ = consumer;
   handle_ = handle;
 }
+
+void CancelableRequestBase::DoForward(const base::Closure& forwarded_call,
+                                      bool force_async) {
+  if (force_async || callback_thread_ != MessageLoop::current()) {
+    callback_thread_->PostTask(
+        FROM_HERE,
+        base::Bind(&CancelableRequestBase::ExecuteCallback, this,
+                   forwarded_call));
+  } else {
+    // We can do synchronous callbacks when we're on the same thread.
+    ExecuteCallback(forwarded_call);
+  }
+}
+
+void CancelableRequestBase::ExecuteCallback(
+    const base::Closure& forwarded_call) {
+  DCHECK_EQ(callback_thread_, MessageLoop::current());
+
+  if (!canceled_.IsSet()) {
+    WillExecute();
+
+    // Execute the callback.
+    forwarded_call.Run();
+  }
+
+  // Notify the provider that the request is complete. The provider will
+  // notify the consumer for us. Note that it is possible for the callback to
+  // cancel this request; we must check canceled again.
+  if (!canceled_.IsSet())
+    NotifyCompleted();
+}