Move request_queue/_impl to //extensions

chrome/browser/extensions/updater/request_queue.h

Index: chrome/browser/extensions/updater/request_queue.h
diff --git a/chrome/browser/extensions/updater/request_queue.h b/chrome/browser/extensions/updater/request_queue.h
deleted file mode 100644
index c14788169505b63d35581564b109fa47b443f26f..0000000000000000000000000000000000000000
--- a/chrome/browser/extensions/updater/request_queue.h
+++ /dev/null
@@ -1,147 +0,0 @@
-// 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.
-
-#ifndef CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_H_
-#define CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_H_
-
-#include <deque>
-#include <utility>
-
-#include "base/callback.h"
-#include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/time/time.h"
-#include "base/timer/timer.h"
-#include "net/base/backoff_entry.h"
-
-namespace extensions {
-
-// This class keeps track of a queue of requests, and contains the logic to
-// retry requests with some backoff policy. Each request has a
-// net::BackoffEntry instance associated with it.
-//
-// The general flow when using this class would be something like this:
-//   - requests are queued up by calling ScheduleRequest.
-//   - when a request is ready to be executed, RequestQueue removes the
-//     request from the queue, assigns it as active request, and calls
-//     the callback that was passed to the constructor.
-//   - (optionally) when a request has completed unsuccessfully call
-//     RetryRequest to put the request back in the queue, using the
-//     backoff policy and minimum backoff delay to determine when to
-//     next schedule this request.
-//   - call reset_active_request() to indicate that the active request has
-//     been dealt with.
-//   - call StartNextRequest to schedule the next pending request (if any).
-template<typename T>
-class RequestQueue {
- public:
-  class iterator;
-
-  RequestQueue(const net::BackoffEntry::Policy* backoff_policy,
-               const base::Closure& start_request_callback);
-  ~RequestQueue();
-
-  // Returns the request that is currently being processed.
-  T* active_request();
-
-  // Returns the number of times the current request has been retried already.
-  int active_request_failure_count();
-
-  // Signals RequestQueue that processing of the current request has completed.
-  scoped_ptr<T> reset_active_request();
-
-  // Add the given request to the queue, and starts the next request if no
-  // request is currently being processed.
-  void ScheduleRequest(scoped_ptr<T> request);
-
-  bool empty() const;
-  size_t size() const;
-
-  // Returns the earliest release time of all requests currently in the queue.
-  base::TimeTicks NextReleaseTime() const;
-
-  // Starts the next request, if no request is currently active. This will
-  // synchronously call the start_request_callback if the release time of the
-  // earliest available request is in the past, otherwise it will call that
-  // callback asynchronously after enough time has passed.
-  void StartNextRequest();
-
-  // Tell RequestQueue to put the current request back in the queue, after
-  // applying the backoff policy to determine when to next try this request.
-  // If the policy results in a backoff delay smaller than |min_backoff_delay|,
-  // that delay is used instead.
-  void RetryRequest(const base::TimeDelta& min_backoff_delay);
-
-  iterator begin();
-  iterator end();
-
-  // Change the backoff policy used by the queue.
-  void set_backoff_policy(const net::BackoffEntry::Policy* backoff_policy);
-
- private:
-  struct Request {
-    Request(net::BackoffEntry* backoff_entry, T* request)
-        : backoff_entry(backoff_entry), request(request) {}
-    linked_ptr<net::BackoffEntry> backoff_entry;
-    linked_ptr<T> request;
-  };
-
-  // Compares the release time of two pending requests.
-  static bool CompareRequests(const Request& a,
-                              const Request& b);
-
-  // Pushes a request with a given backoff entry onto the queue.
-  void PushImpl(scoped_ptr<T> request,
-                scoped_ptr<net::BackoffEntry> backoff_entry);
-
-  // The backoff policy used to determine backoff delays.
-  const net::BackoffEntry::Policy* backoff_policy_;
-
-  // Callback to call when a new request has become the active request.
-  base::Closure start_request_callback_;
-
-  // Priority queue of pending requests. Not using std::priority_queue since
-  // the code needs to be able to iterate over all pending requests.
-  std::deque<Request> pending_requests_;
-
-  // Active request and its associated backoff entry.
-  scoped_ptr<T> active_request_;
-  scoped_ptr<net::BackoffEntry> active_backoff_entry_;
-
-  // Timer to schedule calls to StartNextRequest, if the first pending request
-  // hasn't passed its release time yet.
-  base::Timer timer_;
-};
-
-// Iterator class that wraps a std::deque<> iterator, only giving access to the
-// actual request part of each item.
-template<typename T>
-class RequestQueue<T>::iterator {
- public:
-  iterator() {}
-
-  T* operator*() { return it_->request.get(); }
-  T* operator->() { return it_->request.get(); }
-  iterator& operator++() {
-    ++it_;
-    return *this;
-  }
-  bool operator!=(const iterator& b) const {
-    return it_ != b.it_;
-  }
-
- private:
-  friend class RequestQueue<T>;
-  typedef std::deque<typename RequestQueue<T>::Request> Container;
-
-  explicit iterator(const typename Container::iterator& it)
-      : it_(it) {}
-
-  typename Container::iterator it_;
-};
-
-
-}  // namespace extensions
-
-#endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_H_