chrome/browser/extensions/updater/request_queue_impl.h

   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 #ifndef CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_IMPL_H_
   6 #define CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_IMPL_H_
   7
   8 #include <algorithm>
   9
  10 #include "base/bind.h"
  11 #include "base/compiler_specific.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/stl_util.h"
  14 #include "chrome/browser/extensions/updater/request_queue.h"
  15
  16 namespace extensions {
  17
  18 template<typename T>
  19 RequestQueue<T>::RequestQueue(
  20     const net::BackoffEntry::Policy* const backoff_policy,
  21     const base::Closure& start_request_callback)
  22     : backoff_policy_(backoff_policy),
  23       start_request_callback_(start_request_callback),
  24       timer_(false, false) {
  25 }
  26
  27 template<typename T>
  28 RequestQueue<T>::~RequestQueue() {}
  29
  30 template<typename T>
  31 T* RequestQueue<T>::active_request() {
  32   return active_request_.get();
  33 }
  34
  35 template<typename T>
  36 int RequestQueue<T>::active_request_failure_count() {
  37   return active_backoff_entry_->failure_count();
  38 }
  39
  40 template<typename T>
  41 scoped_ptr<T> RequestQueue<T>::reset_active_request() {
  42   active_backoff_entry_.reset();
  43   return active_request_.Pass();
  44 }
  45
  46 template<typename T>
  47 void RequestQueue<T>::ScheduleRequest(scoped_ptr<T> request) {
  48   PushImpl(request.Pass(), scoped_ptr<net::BackoffEntry>(
  49       new net::BackoffEntry(backoff_policy_)));
  50   StartNextRequest();
  51 }
  52
  53 template<typename T>
  54 void RequestQueue<T>::PushImpl(scoped_ptr<T> request,
  55                                scoped_ptr<net::BackoffEntry> backoff_entry) {
  56   pending_requests_.push_back(Request(
  57       backoff_entry.release(), request.release()));
  58   std::push_heap(pending_requests_.begin(), pending_requests_.end(),
  59                  CompareRequests);
  60 }
  61
  62 template<typename T>
  63 bool RequestQueue<T>::empty() const {
  64   return pending_requests_.empty();
  65 }
  66
  67 template<typename T>
  68 size_t RequestQueue<T>::size() const {
  69   return pending_requests_.size();
  70 }
  71
  72 template<typename T>
  73 base::TimeTicks RequestQueue<T>::NextReleaseTime() const {
  74   return pending_requests_.front().backoff_entry->GetReleaseTime();
  75 }
  76
  77 template<typename T>
  78 void RequestQueue<T>::StartNextRequest() {
  79   if (active_request_)
  80     // Already running a request, assume this method will be called again when
  81     // the request is done.
  82     return;
  83
  84   if (empty())
  85     // No requests in the queue, so we're done.
  86     return;
  87
  88   base::TimeTicks next_release = NextReleaseTime();
  89   base::TimeTicks now = base::TimeTicks::Now();
  90   if (next_release > now) {
  91     // Not ready for the next update check yet, call this method when it is
  92     // time.
  93     timer_.Start(FROM_HERE, next_release - now,
  94           base::Bind(&RequestQueue<T>::StartNextRequest,
  95                      base::Unretained(this)));
  96     return;
  97   }
  98
  99   // pop_heap swaps the first and last elements of pending_requests_, and after
 100   // that assures that the rest of pending_requests_ (excluding the
 101   // now last/formerly first element) forms a proper heap. After pop_heap
 102   // [begin, end-1) is a valid heap, and *(end - 1) contains the element that
 103   // used to be at the top of the heap. Since no elements are actually
 104   // removed from the container it is safe to read the entry being removed after
 105   // pop_heap is called (but before pop_back is called).
 106   std::pop_heap(pending_requests_.begin(), pending_requests_.end(),
 107                 CompareRequests);
 108
 109   active_backoff_entry_.reset(pending_requests_.back().backoff_entry.release());
 110   active_request_.reset(pending_requests_.back().request.release());
 111
 112   pending_requests_.pop_back();
 113
 114   start_request_callback_.Run();
 115 }
 116
 117 template<typename T>
 118 void RequestQueue<T>::RetryRequest(const base::TimeDelta& min_backoff_delay) {
 119   active_backoff_entry_->InformOfRequest(false);
 120   if (active_backoff_entry_->GetTimeUntilRelease() < min_backoff_delay) {
 121     active_backoff_entry_->SetCustomReleaseTime(
 122         base::TimeTicks::Now() + min_backoff_delay);
 123   }
 124   PushImpl(active_request_.Pass(), active_backoff_entry_.Pass());
 125 }
 126
 127 template<typename T>
 128 typename RequestQueue<T>::iterator RequestQueue<T>::begin() {
 129   return iterator(pending_requests_.begin());
 130 }
 131
 132 template<typename T>
 133 typename RequestQueue<T>::iterator RequestQueue<T>::end() {
 134   return iterator(pending_requests_.end());
 135 }
 136
 137 template<typename T>
 138 void RequestQueue<T>::set_backoff_policy(
 139     const net::BackoffEntry::Policy* backoff_policy) {
 140   backoff_policy_ = backoff_policy;
 141 }
 142
 143 // static
 144 template<typename T>
 145 bool RequestQueue<T>::CompareRequests(
 146     const Request& a,
 147     const Request& b) {
 148   return a.backoff_entry->GetReleaseTime() >
 149          b.backoff_entry->GetReleaseTime();
 150 }
 151
 152 }  // namespace extensions
 153
 154 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_IMPL_H_