// Copyright (c) 2012 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 classes collaborate to keep a list of open requests and to
// make sure that requests do not outlive either of the objects involved in the
// transaction.
//
// If you do not need to return data to the consumer, do not use this system,
// just use the regular Task/RunnableMethod stuff.
//
// The CancelableRequest object is used internally to each provider to track
// request data and callback information.
//
// Example consumer calling |StartRequest| on a frontend service:
//
//   class MyClass {
//     void MakeRequest() {
//       frontend_service->StartRequest(
//           some_input1, some_input2,
//           &callback_consumer_,
//           base::Bind(&MyClass:RequestComplete, base::Unretained(this)));
//       // StartRequest() returns a Handle which may be retained for use with
//       // CancelRequest() if required, e.g. in MyClass's destructor.
//     }
//
//     void RequestComplete(int status) {
//       ...
//     }
//
//    private:
//     CancelableRequestConsumer callback_consumer_;
//   };
//
//
// Example frontend provider. It receives requests and forwards them to the
// backend on another thread:
//
//   class Frontend : public CancelableRequestProvider {
//     typedef Callback1<int>::Type RequestCallbackType;
//
//     Handle StartRequest(int some_input1, int some_input2,
//                         CancelableRequestConsumerBase* consumer,
//                         RequestCallbackType* callback) {
//       scoped_refptr<CancelableRequest<RequestCallbackType> > request(
//           new CancelableRequest<RequestCallbackType>(callback));
//       AddRequest(request, consumer);
//
//       // Send the parameters and the request to the backend thread.
//       backend_thread_->PostTask(
//           FROM_HERE,
//           base::Bind(&Backend::DoRequest, backend_, request,
//                             some_input1, some_input2));
//
//       // The handle will have been set by AddRequest.
//       return request->handle();
//     }
//   };
//
//
// Example backend provider that does work and dispatches the callback back
// to the original thread. Note that we need to pass it as a scoped_refptr so
// that the object will be kept alive if the request is canceled (releasing
// the provider's reference to it).
//
//   class Backend {
//     void DoRequest(
//         scoped_refptr< CancelableRequest<Frontend::RequestCallbackType> >
//             request,
//         int some_input1, int some_input2) {
//       if (request->canceled())
//         return;
//
//       ... do your processing ...
//
//       // Depending on your typedefs, one of these two forms will be more
//       // convenient:
//       request->ForwardResult(Tuple1<int>(return_value));
//
//       // -- or --  (inferior in this case)
//       request->ForwardResult(Frontend::RequestCallbackType::TupleType(
//           return_value));
//     }
//   };

#ifndef CHROME_BROWSER_CANCELABLE_REQUEST_H_
#define CHROME_BROWSER_CANCELABLE_REQUEST_H_
#pragma once

#include <map>
#include <vector>

#include "base/basictypes.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/callback_internal.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 "build/build_config.h"

class CancelableRequestBase;
class CancelableRequestConsumerBase;

// CancelableRequestProvider --------------------------------------------------
//
// This class is threadsafe. Requests may be added or canceled from any thread,
// but a task must only be canceled from the same thread it was initially run
// on.
//
// It is intended that providers inherit from this class to provide the
// necessary functionality.

class CancelableRequestProvider {
 public:
  // Identifies a specific request from this provider.
  typedef int Handle;

  CancelableRequestProvider();
  virtual ~CancelableRequestProvider();

  // Called by the enduser of the request to cancel it. This MUST be called on
  // the same thread that originally issued the request (which is also the same
  // thread that would have received the callback if it was not canceled).
  // handle must be for a valid pending (not yet complete or cancelled) request.
  void CancelRequest(Handle handle);

 protected:
  // Adds a new request and initializes it. This is called by a derived class
  // to add a new request. The request's Init() will be called (which is why
  // the consumer is required. The handle to the new request is returned.
  Handle AddRequest(CancelableRequestBase* request,
                    CancelableRequestConsumerBase* consumer);

  // Called by the CancelableRequest when the request has executed. It will
  // be removed from the list of pending requests (as opposed to canceling,
  // which will also set some state on the request).
  void RequestCompleted(Handle handle);

 private:
  typedef std::map<Handle, scoped_refptr<CancelableRequestBase> >
      CancelableRequestMap;

  // Only call this when you already have acquired pending_request_lock_.
  void CancelRequestLocked(const CancelableRequestMap::iterator& item);

  friend class CancelableRequestBase;

  base::Lock pending_request_lock_;

  // Lists all outstanding requests. Protected by the |lock_|.
  CancelableRequestMap pending_requests_;

  // The next handle value we will return. Protected by the |lock_|.
  int next_handle_;

  DISALLOW_COPY_AND_ASSIGN(CancelableRequestProvider);
};

// CancelableRequestConsumer --------------------------------------------------
//
// Classes wishing to make requests on a provider should have an instance of
// this class. Callers will need to pass a pointer to this consumer object
// when they make the request. It will automatically track any pending
// requests, and will automatically cancel them on destruction to prevent the
// accidental calling of freed memory.
//
// It is recommended to just have this class as a member variable since there
// is nothing to be gained by inheriting from it other than polluting your
// namespace.
//
// THIS CLASS IS NOT THREADSAFE (unlike the provider). You must make requests
// and get callbacks all from the same thread.

// Base class used to notify of new requests.
class CancelableRequestConsumerBase {
 protected:
  friend class CancelableRequestBase;
  friend class CancelableRequestProvider;

  virtual ~CancelableRequestConsumerBase() {
  }

  // Adds a new request to the list of requests that are being tracked. This
  // is called by the provider when a new request is created.
  virtual void OnRequestAdded(CancelableRequestProvider* provider,
                              CancelableRequestProvider::Handle handle) = 0;

  // Removes the given request from the list of pending requests. Called
  // by the CancelableRequest immediately after the callback has executed for a
  // given request, and by the provider when a request is canceled.
  virtual void OnRequestRemoved(CancelableRequestProvider* provider,
                                CancelableRequestProvider::Handle handle) = 0;

  // Sent to provider before executing a callback.
  virtual void WillExecute(CancelableRequestProvider* provider,
                           CancelableRequestProvider::Handle handle) = 0;

  // Sent after executing a callback.
  virtual void DidExecute(CancelableRequestProvider* provider,
                          CancelableRequestProvider::Handle handle) = 0;
};

// Template for clients to use. It allows them to associate random "client
// data" with a specific request. The default value for this type is 0.
// The type T should be small and easily copyable (like a pointer
// or an integer).
template<class T>
class CancelableRequestConsumerTSimple
    : public CancelableRequestConsumerBase {
 public:
  CancelableRequestConsumerTSimple();

  // Cancel any outstanding requests so that we do not get called back after we
  // are destroyed. As these requests are removed, the providers will call us
  // back on OnRequestRemoved, which will then update the list. To iterate
  // successfully while the list is changing out from under us, we make a copy.
  virtual ~CancelableRequestConsumerTSimple();

  // Associates some random data with a specified request. The request MUST be
  // outstanding, or it will assert. This is intended to be called immediately
  // after a request is issued.
  void SetClientData(CancelableRequestProvider* p,
                     CancelableRequestProvider::Handle h,
                     T client_data);

  // Retrieves previously associated data for a specified request. The request
  // MUST be outstanding, or it will assert. This is intended to be called
  // during processing of a callback to retrieve extra data.
  T GetClientData(CancelableRequestProvider* p,
                  CancelableRequestProvider::Handle h);

  // Returns the data associated with the current request being processed. This
  // is only valid during the time a callback is being processed.
  T GetClientDataForCurrentRequest();

  // Returns true if there are any pending requests.
  bool HasPendingRequests() const;

  // Returns the number of pending requests.
  size_t PendingRequestCount() const;

  // Cancels all requests outstanding.
  void CancelAllRequests();

  // Cancels all requests outstanding matching the client data.
  void CancelAllRequestsForClientData(T client_data);

  // Returns the handle for the first request that has the specified client data
  // (in |handle|). Returns true if there is a request for the specified client
  // data, false otherwise.
  bool GetFirstHandleForClientData(T client_data,
                                   CancelableRequestProvider::Handle* handle);

  // Gets the client data for all pending requests.
  void GetAllClientData(std::vector<T>* data);

 protected:
  struct PendingRequest {
    PendingRequest(CancelableRequestProvider* p,
                   CancelableRequestProvider::Handle h)
        : provider(p), handle(h) {
    }

    PendingRequest() : provider(NULL), handle(0) {}

    // Comparison operator for stl.
    bool operator<(const PendingRequest& other) const {
      if (provider != other.provider)
        return provider < other.provider;
      return handle < other.handle;
    }

    bool is_valid() const { return provider != NULL; }

    CancelableRequestProvider* provider;
    CancelableRequestProvider::Handle handle;
  };
  typedef std::map<PendingRequest, T> PendingRequestList;

  virtual T get_initial_t() const;

  virtual void OnRequestAdded(CancelableRequestProvider* provider,
                              CancelableRequestProvider::Handle handle);

  virtual void OnRequestRemoved(CancelableRequestProvider* provider,
                                CancelableRequestProvider::Handle handle);

  virtual void WillExecute(CancelableRequestProvider* provider,
                           CancelableRequestProvider::Handle handle);

  virtual void DidExecute(CancelableRequestProvider* provider,
                          CancelableRequestProvider::Handle handle);

  // Lists all outstanding requests.
  PendingRequestList pending_requests_;

  // This is valid while processing a request and is used to identify the
  // provider/handle of request.
  PendingRequest current_request_;
};

template<class T>
CancelableRequestConsumerTSimple<T>::CancelableRequestConsumerTSimple() {
}

template<class T>
CancelableRequestConsumerTSimple<T>::~CancelableRequestConsumerTSimple() {
  CancelAllRequests();
}

template<class T>
void CancelableRequestConsumerTSimple<T>::SetClientData(
    CancelableRequestProvider* p,
    CancelableRequestProvider::Handle h,
    T client_data) {
  PendingRequest request(p, h);
  DCHECK(pending_requests_.find(request) != pending_requests_.end());
  pending_requests_[request] = client_data;
}

template<class T>
T CancelableRequestConsumerTSimple<T>::GetClientData(
    CancelableRequestProvider* p,
    CancelableRequestProvider::Handle h) {
  PendingRequest request(p, h);
  DCHECK(pending_requests_.find(request) != pending_requests_.end());
  return pending_requests_[request];
}

template<class T>
T CancelableRequestConsumerTSimple<T>::GetClientDataForCurrentRequest() {
  DCHECK(current_request_.is_valid());
  return GetClientData(current_request_.provider, current_request_.handle);
}

template<class T>
bool CancelableRequestConsumerTSimple<T>::HasPendingRequests() const {
  return !pending_requests_.empty();
}

template<class T>
size_t CancelableRequestConsumerTSimple<T>::PendingRequestCount() const {
  return pending_requests_.size();
}

template<class T>
void CancelableRequestConsumerTSimple<T>::CancelAllRequests() {
  // TODO(atwilson): This code is not thread safe as it is called from the
  // consumer thread (via the destructor) and accesses pending_requests_
  // without acquiring the provider lock (http://crbug.com/85970).
  PendingRequestList copied_requests(pending_requests_);
  for (typename PendingRequestList::iterator i = copied_requests.begin();
       i != copied_requests.end(); ++i) {
    i->first.provider->CancelRequest(i->first.handle);
  }
  copied_requests.clear();

  // That should have cleared all the pending items.
  DCHECK(pending_requests_.empty());
}

template<class T>
void CancelableRequestConsumerTSimple<T>::CancelAllRequestsForClientData(
    T client_data) {
  PendingRequestList copied_requests(pending_requests_);
  for (typename PendingRequestList::const_iterator i = copied_requests.begin();
      i != copied_requests.end(); ++i) {
    if (i->second == client_data)
      i->first.provider->CancelRequest(i->first.handle);
  }
  copied_requests.clear();
}

template<class T>
bool CancelableRequestConsumerTSimple<T>::GetFirstHandleForClientData(
    T client_data,
    CancelableRequestProvider::Handle* handle) {
  for (typename PendingRequestList::const_iterator i =
           pending_requests_.begin(); i != pending_requests_.end(); ++i) {
    if (i->second == client_data) {
      *handle = i->first.handle;
      return true;
    }
  }
  *handle = 0;
  return false;
}

template<class T>
void CancelableRequestConsumerTSimple<T>::GetAllClientData(
    std::vector<T>* data) {
  DCHECK(data);
  for (typename PendingRequestList::iterator i = pending_requests_.begin();
       i != pending_requests_.end(); ++i)
    data->push_back(i->second);
}

template<class T>
T CancelableRequestConsumerTSimple<T>::get_initial_t() const {
  return 0;
}

template<class T>
void CancelableRequestConsumerTSimple<T>::OnRequestAdded(
    CancelableRequestProvider* provider,
    CancelableRequestProvider::Handle handle) {
  // Make sure we're not mixing/matching providers (since the provider is
  // responsible for providing thread safety until http://crbug.com/85970 is
  // fixed, we can't use the same consumer with multiple providers).
#ifndef NDEBUG
  if (!pending_requests_.empty())
    DCHECK(pending_requests_.begin()->first.provider == provider);
#endif
  DCHECK(pending_requests_.find(PendingRequest(provider, handle)) ==
         pending_requests_.end());
  pending_requests_[PendingRequest(provider, handle)] = get_initial_t();
}

template<class T>
void CancelableRequestConsumerTSimple<T>::OnRequestRemoved(
    CancelableRequestProvider* provider,
    CancelableRequestProvider::Handle handle) {
  typename PendingRequestList::iterator i =
      pending_requests_.find(PendingRequest(provider, handle));
  if (i == pending_requests_.end()) {
    NOTREACHED() << "Got a complete notification for a nonexistent request";
    return;
  }

  pending_requests_.erase(i);
}

template<class T>
void CancelableRequestConsumerTSimple<T>::WillExecute(
    CancelableRequestProvider* provider,
    CancelableRequestProvider::Handle handle) {
  current_request_ = PendingRequest(provider, handle);
}

template<class T>
void CancelableRequestConsumerTSimple<T>::DidExecute(
    CancelableRequestProvider* provider,
    CancelableRequestProvider::Handle handle) {
  current_request_ = PendingRequest();
}

// See CancelableRequestConsumerTSimple. The default value for T
// is given in |initial_t|.
template<class T, T initial_t>
class CancelableRequestConsumerT
    : public CancelableRequestConsumerTSimple<T> {
 public:
  CancelableRequestConsumerT();
  virtual ~CancelableRequestConsumerT();

 protected:
  virtual T get_initial_t() const;
};

template<class T, T initial_t>
CancelableRequestConsumerT<T, initial_t>::CancelableRequestConsumerT() {
}

template<class T, T initial_t>
CancelableRequestConsumerT<T, initial_t>::~CancelableRequestConsumerT() {
}

template<class T, T initial_t>
T CancelableRequestConsumerT<T, initial_t>::get_initial_t() const {
  return initial_t;
}

// Some clients may not want to store data. Rather than do some complicated
// thing with virtual functions to allow some consumers to store extra data and
// some not to, we just define a default one that stores some dummy data.
typedef CancelableRequestConsumerT<int, 0> CancelableRequestConsumer;

// MSVC doesn't like complex extern templates and DLLs.
#if !defined(COMPILER_MSVC)
// The vast majority of CancelableRequestConsumers are instantiated on <int>,
// so prevent that template from being expanded in normal code.
extern template class CancelableRequestConsumerTSimple<int>;

// We'll also want to extern-template the most common, typedef-ed
// CancelableRequestConsumerT.
extern template class CancelableRequestConsumerT<int, 0>;
#endif

// CancelableRequest ----------------------------------------------------------
//
// The request object that is used by a CancelableRequestProvider to send
// results to a CancelableRequestConsumer. This request handles the returning
// of results from a thread where the request is being executed to the thread
// and callback where the results are used. IT SHOULD BE PASSED AS A
// scoped_refptr TO KEEP IT ALIVE.
//
// It does not handle input parameters to the request. The caller must either
// transfer those separately or derive from this class to add the desired
// parameters.
//
// When the processing is complete on this message, the caller MUST call
// ForwardResult() with the return arguments that will be passed to the
// callback. If the request has been canceled, Return is optional (it will not
// do anything). If you do not have to return to the caller, the cancelable
// request system should not be used! (just use regular fire-and-forget tasks).
//
// Callback parameters are passed by value. In some cases, the request will
// want to return a large amount of data (for example, an image). One good
// approach is to derive from the CancelableRequest and make the data object
// (for example, a std::vector) owned by the CancelableRequest. The pointer
// to this data would be passed for the callback parameter. Since the
// CancelableRequest outlives the callback call, the data will be valid on the
// other thread for the callback, but will still be destroyed properly.

// Non-templatized base class that provides cancellation
class CancelableRequestBase
    : public base::RefCountedThreadSafe<CancelableRequestBase> {
 public:
  friend class CancelableRequestProvider;

  // Initializes most things to empty, Init() must be called to complete
  // initialization of the object. This will be done by the provider when the
  // request is dispatched.
  //
  // This must be called on the same thread the callback will be executed on, it
  // will save that thread for later.
  //
  // This two-phase init is done so that the constructor can have no parameters,
  // which makes it much more convenient for derived classes, which can be
  // common. The derived classes need only declare the variables they provide in
  // the constructor rather than many lines of internal tracking data that are
  // passed to the base class (us).
  //
  // In addition, not all of the information (for example, the handle) is known
  // at construction time.
  CancelableRequestBase();

  CancelableRequestConsumerBase* consumer() const {
    return consumer_;
  }

  CancelableRequestProvider::Handle handle() const {
    return handle_;
  }

  // The canceled flag indicates that the request should not be executed.
  // A request can never be uncanceled, so only a setter for true is provided.
  // This can be called multiple times, but only from one thread.
  void set_canceled() {
    canceled_.Set();
  }
  bool canceled() {
    return canceled_.IsSet();
  }

 protected:
  friend class base::RefCountedThreadSafe<CancelableRequestBase>;
  virtual ~CancelableRequestBase();

  // Initializes the object with the particulars from the provider. It may only
  // be called once (it is called by the provider, which is a friend).
  void Init(CancelableRequestProvider* provider,
            CancelableRequestProvider::Handle handle,
            CancelableRequestConsumerBase* consumer);

  // 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);

  // Tells the provider that the request is complete, which then tells the
  // consumer.
  void NotifyCompleted() const {
    provider_->RequestCompleted(handle());
    consumer_->DidExecute(provider_, handle_);
  }

  // Cover method for CancelableRequestConsumerBase::WillExecute.
  void WillExecute() {
    consumer_->WillExecute(provider_, handle_);
  }

  // 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);

  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
// those on a subclass of this.
//
// We have decided to allow users to treat derived classes of this as structs,
// so you can add members without getters and setters (which just makes the
// code harder to read). Don't use underscores after these vars. For example:
//
//   typedef Callback1<int>::Type DoodieCallback;
//
//   class DoodieRequest : public CancelableRequest<DoodieCallback> {
//    public:
//     DoodieRequest(CallbackType* callback) : CancelableRequest(callback) {
//     }
//
//    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";
  }

  // Dispatches the parameters to the correct thread so the callback can be
  // executed there. The caller does not need to check for cancel before
  // calling this. It is optional in the cancelled case. In the non-cancelled
  // case, this 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.
  void ForwardResult(const TupleType& param) {
    DCHECK(callback_.get());
    if (!canceled()) {
      if (callback_thread_ == MessageLoop::current()) {
        // We can do synchronous callbacks when we're on the same thread.
        ExecuteCallback(param);
      } else {
        callback_thread_->PostTask(
            FROM_HERE,
            base::Bind(&CancelableRequest<CB>::ExecuteCallback, this, param));
      }
    }
  }

  // Like |ForwardResult| but this never does a synchronous callback.
  void ForwardResultAsync(const TupleType& param) {
    DCHECK(callback_.get());
    if (!canceled()) {
      callback_thread_->PostTask(
          FROM_HERE,
          base::Bind(&CancelableRequest<CB>::ExecuteCallback, this, param));
    }
  }

 protected:
  virtual ~CancelableRequest() {}

 private:
  // Executes the callback and notifies the provider and the consumer that this
  // request has been completed. This must be called on the callback_thread_.
  void ExecuteCallback(const TupleType& param) {
    if (!canceled_.IsSet()) {
      WillExecute();

      // Execute the callback.
      callback_->RunWithParams(param);
    }

    // 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();
  }

  // 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 using this class, the provider MUST call Init() (on the base class)
// 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1, a2), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1, a2, a3), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType a4) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1, a2, a3, a4), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType a4,
      typename base::internal::CallbackParamTraits<A5>::ForwardType a5) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType a4,
      typename base::internal::CallbackParamTraits<A5>::ForwardType 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(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType a4,
      typename base::internal::CallbackParamTraits<A5>::ForwardType a5,
      typename base::internal::CallbackParamTraits<A6>::ForwardType a6) {
    if (canceled()) return;
    DoForward(base::Bind(callback_, a1, a2, a3, a4, a5, a6), false);
  }

  void ForwardResultAsync(
      typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
      typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
      typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
      typename base::internal::CallbackParamTraits<A4>::ForwardType a4,
      typename base::internal::CallbackParamTraits<A5>::ForwardType a5,
      typename base::internal::CallbackParamTraits<A6>::ForwardType 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 fill in the contents of the vector,
//    forwarding the result like so:
//    request->ForwardResult(FooRequest::TupleType(request->handle(),
//                                                 &request->value));
//
// Tip: for passing more than one value, use a Tuple for the value.
template<typename CB, typename Type>
class CancelableRequest1 : public CancelableRequest<CB> {
 public:
  explicit CancelableRequest1(
      const typename CancelableRequest<CB>::CallbackType& callback)
      : CancelableRequest<CB>(callback), value() {
  }

  // The value.
  Type value;

 protected:
  virtual ~CancelableRequest1() {}
};

#endif  // CHROME_BROWSER_CANCELABLE_REQUEST_H_