Home | History | Annotate | Download | only in common 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/common/cancelable_request.h"
      6 
      7 CancelableRequestProvider::CancelableRequestProvider()
      8     : next_handle_(1) {
      9 }
     10 
     11 CancelableRequestProvider::Handle CancelableRequestProvider::AddRequest(
     12     CancelableRequestBase* request,
     13     CancelableRequestConsumerBase* consumer) {
     14   Handle handle;
     15   {
     16     base::AutoLock lock(pending_request_lock_);
     17 
     18     handle = next_handle_;
     19     pending_requests_[next_handle_] = request;
     20     ++next_handle_;
     21     DCHECK(next_handle_)
     22         << "next_handle_ may have wrapped around to invalid state.";
     23   }
     24 
     25   consumer->OnRequestAdded(this, handle);
     26 
     27   request->Init(this, handle, consumer);
     28   return handle;
     29 }
     30 
     31 void CancelableRequestProvider::CancelRequest(Handle handle) {
     32   base::AutoLock lock(pending_request_lock_);
     33   CancelRequestLocked(pending_requests_.find(handle));
     34 }
     35 
     36 CancelableRequestProvider::~CancelableRequestProvider() {
     37   // There may be requests whose result callback has not been run yet. We need
     38   // to cancel them otherwise they may try and call us back after we've been
     39   // deleted, or do other bad things. This can occur on shutdown (or browser
     40   // context destruction) when a request is scheduled, completed (but not
     41   // dispatched), then the BrowserContext is deleted.
     42   base::AutoLock lock(pending_request_lock_);
     43   while (!pending_requests_.empty())
     44     CancelRequestLocked(pending_requests_.begin());
     45 }
     46 
     47 void CancelableRequestProvider::CancelRequestLocked(
     48     const CancelableRequestMap::iterator& item) {
     49   pending_request_lock_.AssertAcquired();
     50   if (item == pending_requests_.end()) {
     51     NOTREACHED() << "Trying to cancel an unknown request";
     52     return;
     53   }
     54 
     55   item->second->consumer()->OnRequestRemoved(this, item->first);
     56   item->second->set_canceled();
     57   pending_requests_.erase(item);
     58 }
     59 
     60 void CancelableRequestProvider::RequestCompleted(Handle handle) {
     61   CancelableRequestConsumerBase* consumer = NULL;
     62   {
     63     base::AutoLock lock(pending_request_lock_);
     64 
     65     CancelableRequestMap::iterator i = pending_requests_.find(handle);
     66     if (i == pending_requests_.end()) {
     67       NOTREACHED() << "Trying to cancel an unknown request";
     68       return;
     69     }
     70     consumer = i->second->consumer();
     71 
     72     // This message should only get sent if the class is not cancelled, or
     73     // else the consumer might be gone).
     74     DCHECK(!i->second->canceled());
     75 
     76     pending_requests_.erase(i);
     77   }
     78 
     79   // Notify the consumer that the request is gone
     80   consumer->OnRequestRemoved(this, handle);
     81 }
     82 
     83 // MSVC doesn't like complex extern templates and DLLs.
     84 #if !defined(COMPILER_MSVC)
     85 // Emit our most common CancelableRequestConsumer.
     86 template class CancelableRequestConsumerTSimple<int>;
     87 
     88 // And the most common subclass of it.
     89 template class CancelableRequestConsumerT<int, 0>;
     90 #endif
     91 
     92 CancelableRequestBase::CancelableRequestBase()
     93     : provider_(NULL),
     94       consumer_(NULL),
     95       handle_(0) {
     96   callback_thread_ = base::MessageLoop::current();
     97 }
     98 
     99 CancelableRequestBase::~CancelableRequestBase() {
    100 }
    101 
    102 void CancelableRequestBase::Init(CancelableRequestProvider* provider,
    103                                  CancelableRequestProvider::Handle handle,
    104                                  CancelableRequestConsumerBase* consumer) {
    105   DCHECK(handle_ == 0 && provider_ == NULL && consumer_ == NULL);
    106   provider_ = provider;
    107   consumer_ = consumer;
    108   handle_ = handle;
    109 }
    110 
    111 void CancelableRequestBase::DoForward(const base::Closure& forwarded_call,
    112                                       bool force_async) {
    113   if (force_async || callback_thread_ != base::MessageLoop::current()) {
    114     callback_thread_->PostTask(
    115         FROM_HERE,
    116         base::Bind(&CancelableRequestBase::ExecuteCallback, this,
    117                    forwarded_call));
    118   } else {
    119     // We can do synchronous callbacks when we're on the same thread.
    120     ExecuteCallback(forwarded_call);
    121   }
    122 }
    123 
    124 void CancelableRequestBase::ExecuteCallback(
    125     const base::Closure& forwarded_call) {
    126   DCHECK_EQ(callback_thread_, base::MessageLoop::current());
    127 
    128   if (!canceled_.IsSet()) {
    129     WillExecute();
    130 
    131     // Execute the callback.
    132     forwarded_call.Run();
    133   }
    134 
    135   // Notify the provider that the request is complete. The provider will
    136   // notify the consumer for us. Note that it is possible for the callback to
    137   // cancel this request; we must check canceled again.
    138   if (!canceled_.IsSet())
    139     NotifyCompleted();
    140 }
    141