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

content/browser/cancelable_request.h

 // 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.
 
 // CancelableRequestProviders and Consumers work together to make requests that
 // execute on a background thread in the provider and return data to the
 // consumer. These class collaborate to keep a list of open requests and to
 // make sure that requests to not outlive either of the objects involved in the
 // transaction.
 //
@@ skipping 73 matching lines @@
 //   };
 
 #ifndef CONTENT_BROWSER_CANCELABLE_REQUEST_H_
 #define CONTENT_BROWSER_CANCELABLE_REQUEST_H_
 #pragma once
 
 #include <map>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
@@ skipping 466 matching lines @@
   void NotifyCompleted() const {
     provider_->RequestCompleted(handle());
     consumer_->DidExecute(provider_, handle_);
   }
 
   // Cover method for CancelableRequestConsumerBase::WillExecute.
   void WillExecute() {
     consumer_->WillExecute(provider_, handle_);
   }
 
+  // Attempts to execute callback on |callback_thread_| if the request has not
+  // been canceled yet.
+  void DoForward(const base::Closure& forwarded_call, bool force_async) {

[brettw, 2011/10/01 16:26:12]

This should be non-inline (the whole point of the "base" class is to reduce
duplicated inline code).

[awong, 2011/10/03 05:18:39]

Done.

+    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);
+    }
+  }
+
   // The message loop that this request was created on. The callback will
   // happen on the same thread.
   MessageLoop* callback_thread_;
 
   // The provider for this request. When we execute, we will notify this that
   // request is complete to it can remove us from the requests it tracks.
   CancelableRequestProvider* provider_;
 
   // Notified after we execute that the request is complete.  This should only
   // be accessed if !canceled_.IsSet(), otherwise the pointer is invalid.
   CancelableRequestConsumerBase* consumer_;
 
   // The handle to this request inside the provider. This will be initialized
   // to 0 when the request is created, and the provider will set it once the
   // request has been dispatched.
   CancelableRequestProvider::Handle handle_;
 
   // Set if the caller cancels this request. No callbacks should be made when
   // this is set.
   base::CancellationFlag canceled_;
 
  private:
+  // Executes the |forwarded_call| and notifies the provider and the consumer
+  // that this request has been completed. This must be called on the
+  // |callback_thread_|.
+  void ExecuteCallback(const base::Closure& forwarded_call) {

[brettw, 2011/10/01 16:26:12]

Ditto

[awong, 2011/10/03 05:18:39]

Done.

+    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();
+  }
+
   DISALLOW_COPY_AND_ASSIGN(CancelableRequestBase);
 };
 
 // Templatized class. This is the one you should use directly or inherit from.
 // The callback can be invoked by calling the ForwardResult() method. For this,
 // you must either pack the parameters into a tuple, or use DispatchToMethod
 // (in tuple.h).
 //
 // If you inherit to add additional input parameters or to do more complex
 // memory management (see the bigger comment about this above), you can put
@@ skipping 12 matching lines @@
 //
 //    private:
 //     ~DoodieRequest() {}
 //
 //     int input_arg1;
 //     std::wstring input_arg2;
 //   };
 template<typename CB>
 class CancelableRequest : public CancelableRequestBase {
  public:
+  // TODO(ajwong): After all calls have been migrated, remove this template in
+  // favor of the specialization on base::Callback<Sig>.
   typedef CB CallbackType;          // CallbackRunner<...>
   typedef typename CB::TupleType TupleType;  // Tuple of the callback args.
 
   // The provider MUST call Init() (on the base class) before this is valid.
   // This class will take ownership of the callback object and destroy it when
   // appropriate.
   explicit CancelableRequest(CallbackType* callback)
       : CancelableRequestBase(),
         callback_(callback) {
     DCHECK(callback) << "We should always have a callback";
@@ skipping 49 matching lines @@
     // cancel this request; we must check canceled again.
     if (!canceled_.IsSet())
       NotifyCompleted();
   }
 
   // This should only be executed if !canceled_.IsSet(),
   // otherwise the pointers may be invalid.
   scoped_ptr<CallbackType> callback_;
 };
 
+// CancelableRequest<> wraps a normal base::Callback<> for use in the
+// CancelableRequest framework.
+//
+// When suing this class, the provider MUST call Init() (on the base class)

[brettw, 2011/10/01 16:26:12]

suing -> using

[awong, 2011/10/03 05:18:39]

Done.

+// before this is valid.
+//
+// The two functions ForwardResult(), and ForwardResultAsync() are used to
+// invoke the wrapped callback on the correct thread.  They are the same
+// except that ForwardResult() will run the callback synchronously if
+// we are already on the right thread.
+//
+// The caller does not need to check for cancel before calling ForwardResult()
+// or ForwardResultAsync(). If the request has not been canceled, one of the
+// these MUST be called.
+//
+// If there are any pointers in the parameters, they must live at least as
+// long as the request so that it can be forwarded to the other thread.
+// For complex objects, this would typically be done by having a derived
+// request own the data itself.
+//
+// The following specializations handle different arities of base::Callbacks<>.
+template<>
+class CancelableRequest<base::Closure> : public CancelableRequestBase {
+ public:
+  typedef base::Closure CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(void) {
+    if (canceled()) return;
+    DoForward(callback_, false);
+  }
+
+  void ForwardResultAsync() {
+    if (canceled()) return;
+    DoForward(callback_, true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1>
+class CancelableRequest<base::Callback<void(A1)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1), false);
+  }
+
+  void ForwardResultAsync(const A1& a1) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1, typename A2>
+class CancelableRequest<base::Callback<void(A1,A2)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1,A2)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1, const A2& a2) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2), false);
+  }
+
+  void ForwardResultAsync(const A1& a1, const A2& a2) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1, typename A2, typename A3>
+class CancelableRequest<base::Callback<void(A1,A2,A3)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1,A2,A3)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1, const A2& a2, const A3& a3) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3), false);
+  }
+
+  void ForwardResultAsync(const A1& a1, const A2& a2, const A3& a3) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1, typename A2, typename A3, typename A4>
+class CancelableRequest<base::Callback<void(A1, A2, A3, A4)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1, A2, A3, A4)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1, const A2& a2, const A3& a3, const A4& a4) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4), false);
+  }
+
+  void ForwardResultAsync(const A1& a1, const A2& a2, const A3& a3,
+                          const A4& a4) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1, typename A2, typename A3, typename A4, typename A5>
+class CancelableRequest<base::Callback<void(A1, A2, A3, A4, A5)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1, A2, A3, A4, A5)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+                     const A5& a5) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5), false);
+  }
+
+  void ForwardResultAsync(const A1& a1, const A2& a2, const A3& a3,
+                          const A4& a4, const A5& a5) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
+template<typename A1, typename A2, typename A3, typename A4, typename A5,
+         typename A6>
+class CancelableRequest<base::Callback<void(A1, A2, A3, A4, A5, A6)> > :
+    public CancelableRequestBase {
+ public:
+  typedef base::Callback<void(A1, A2, A3, A4, A5, A6)> CallbackType;
+
+  explicit CancelableRequest(const CallbackType& callback)
+      : CancelableRequestBase(),
+        callback_(callback) {
+    DCHECK(!callback.is_null()) << "Callback must be initialized.";
+  }
+
+  void ForwardResult(const A1& a1, const A2& a2, const A3& a3, const A4& a4,
+                     const A5& a5, const A6& a6) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5, a6), false);
+  }
+
+  void ForwardResultAsync(const A1& a1, const A2& a2, const A3& a3,
+                          const A4& a4, const A5& a5, const A6& a6) {
+    if (canceled()) return;
+    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5, a6), true);
+  }
+
+ protected:
+  virtual ~CancelableRequest() {}
+
+ private:
+  CallbackType callback_;
+};
+
 // A CancelableRequest with a single value. This is intended for use when
 // the provider provides a single value. The provider fills the result into
 // the value, and notifies the request with a pointer to the value. For example,
 // HistoryService has many methods that callback with a vector. Use the
 // following pattern for this:
 // 1. Define the callback:
 //      typedef Callback2<Handle, std::vector<Foo>*>::Type FooCallback;
 // 2. Define the CancelableRequest1 type.
 //    typedef CancelableRequest1<FooCallback, std::vector<Foo>> FooRequest;
 // 3. The provider method should then fillin the contents of the vector,
@@ skipping 11 matching lines @@
   }
 
   // The value.
   Type value;
 
  protected:
   virtual ~CancelableRequest1() {}
 };
 
 #endif  // CONTENT_BROWSER_CANCELABLE_REQUEST_H_