Move request_queue/_impl to //extensions

extensions/browser/updater/request_queue.h

 // 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_
+#ifndef EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_H_
+#define EXTENSIONS_BROWSER_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>
+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();
@@ skipping 34 matching lines @@
 
  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);
+  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>
+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_;
-  }
+  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) {}
+  explicit iterator(const typename Container::iterator& it) : it_(it) {}
 
   typename Container::iterator it_;
 };
 
-
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_H_
+#endif  // EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_H_