Move request_queue/_impl to //extensions

extensions/browser/updater/request_queue_impl.h

Index: extensions/browser/updater/request_queue_impl.h
diff --git a/chrome/browser/extensions/updater/request_queue_impl.h b/extensions/browser/updater/request_queue_impl.h
similarity index 69%
rename from chrome/browser/extensions/updater/request_queue_impl.h
rename to extensions/browser/updater/request_queue_impl.h
index db167e83cd6d92208bde684db451439628ddb715..309dc824362f1ffdf28292ebba5d36899815129b 100644
--- a/chrome/browser/extensions/updater/request_queue_impl.h
+++ b/extensions/browser/updater/request_queue_impl.h
@@ -2,8 +2,8 @@
 // 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_IMPL_H_
-#define CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_IMPL_H_
+#ifndef EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_IMPL_H_
+#define EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_IMPL_H_
 
 #include <algorithm>
 
@@ -11,11 +11,11 @@
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
-#include "chrome/browser/extensions/updater/request_queue.h"
+#include "extensions/browser/updater/request_queue.h"
 
 namespace extensions {
 
-template<typename T>
+template <typename T>
 RequestQueue<T>::RequestQueue(
     const net::BackoffEntry::Policy* const backoff_policy,
     const base::Closure& start_request_callback)
@@ -24,57 +24,59 @@ RequestQueue<T>::RequestQueue(
       timer_(false, false) {
 }
 
-template<typename T>
-RequestQueue<T>::~RequestQueue() {}
+template <typename T>
+RequestQueue<T>::~RequestQueue() {
+}
 
-template<typename T>
+template <typename T>
 T* RequestQueue<T>::active_request() {
   return active_request_.get();
 }
 
-template<typename T>
+template <typename T>
 int RequestQueue<T>::active_request_failure_count() {
   return active_backoff_entry_->failure_count();
 }
 
-template<typename T>
+template <typename T>
 scoped_ptr<T> RequestQueue<T>::reset_active_request() {
   active_backoff_entry_.reset();
   return active_request_.Pass();
 }
 
-template<typename T>
+template <typename T>
 void RequestQueue<T>::ScheduleRequest(scoped_ptr<T> request) {
-  PushImpl(request.Pass(), scoped_ptr<net::BackoffEntry>(
-      new net::BackoffEntry(backoff_policy_)));
+  PushImpl(
+      request.Pass(),
+      scoped_ptr<net::BackoffEntry>(new net::BackoffEntry(backoff_policy_)));
   StartNextRequest();
 }
 
-template<typename T>
+template <typename T>
 void RequestQueue<T>::PushImpl(scoped_ptr<T> request,
                                scoped_ptr<net::BackoffEntry> backoff_entry) {
-  pending_requests_.push_back(Request(
-      backoff_entry.release(), request.release()));
-  std::push_heap(pending_requests_.begin(), pending_requests_.end(),
-                 CompareRequests);
+  pending_requests_.push_back(
+      Request(backoff_entry.release(), request.release()));
+  std::push_heap(
+      pending_requests_.begin(), pending_requests_.end(), CompareRequests);
 }
 
-template<typename T>
+template <typename T>
 bool RequestQueue<T>::empty() const {
   return pending_requests_.empty();
 }
 
-template<typename T>
+template <typename T>
 size_t RequestQueue<T>::size() const {
   return pending_requests_.size();
 }
 
-template<typename T>
+template <typename T>
 base::TimeTicks RequestQueue<T>::NextReleaseTime() const {
   return pending_requests_.front().backoff_entry->GetReleaseTime();
 }
 
-template<typename T>
+template <typename T>
 void RequestQueue<T>::StartNextRequest() {
   if (active_request_)
     // Already running a request, assume this method will be called again when
@@ -90,9 +92,10 @@ void RequestQueue<T>::StartNextRequest() {
   if (next_release > now) {
     // Not ready for the next update check yet, call this method when it is
     // time.
-    timer_.Start(FROM_HERE, next_release - now,
-          base::Bind(&RequestQueue<T>::StartNextRequest,
-                     base::Unretained(this)));
+    timer_.Start(
+        FROM_HERE,
+        next_release - now,
+        base::Bind(&RequestQueue<T>::StartNextRequest, base::Unretained(this)));
     return;
   }
 
@@ -103,8 +106,8 @@ void RequestQueue<T>::StartNextRequest() {
   // used to be at the top of the heap. Since no elements are actually
   // removed from the container it is safe to read the entry being removed after
   // pop_heap is called (but before pop_back is called).
-  std::pop_heap(pending_requests_.begin(), pending_requests_.end(),
-                CompareRequests);
+  std::pop_heap(
+      pending_requests_.begin(), pending_requests_.end(), CompareRequests);
 
   active_backoff_entry_.reset(pending_requests_.back().backoff_entry.release());
   active_request_.reset(pending_requests_.back().request.release());
@@ -114,41 +117,38 @@ void RequestQueue<T>::StartNextRequest() {
   start_request_callback_.Run();
 }
 
-template<typename T>
+template <typename T>
 void RequestQueue<T>::RetryRequest(const base::TimeDelta& min_backoff_delay) {
   active_backoff_entry_->InformOfRequest(false);
   if (active_backoff_entry_->GetTimeUntilRelease() < min_backoff_delay) {
-    active_backoff_entry_->SetCustomReleaseTime(
-        base::TimeTicks::Now() + min_backoff_delay);
+    active_backoff_entry_->SetCustomReleaseTime(base::TimeTicks::Now() +
+                                                min_backoff_delay);
   }
   PushImpl(active_request_.Pass(), active_backoff_entry_.Pass());
 }
 
-template<typename T>
+template <typename T>
 typename RequestQueue<T>::iterator RequestQueue<T>::begin() {
   return iterator(pending_requests_.begin());
 }
 
-template<typename T>
+template <typename T>
 typename RequestQueue<T>::iterator RequestQueue<T>::end() {
   return iterator(pending_requests_.end());
 }
 
-template<typename T>
+template <typename T>
 void RequestQueue<T>::set_backoff_policy(
     const net::BackoffEntry::Policy* backoff_policy) {
   backoff_policy_ = backoff_policy;
 }
 
 // static
-template<typename T>
-bool RequestQueue<T>::CompareRequests(
-    const Request& a,
-    const Request& b) {
-  return a.backoff_entry->GetReleaseTime() >
-         b.backoff_entry->GetReleaseTime();
+template <typename T>
+bool RequestQueue<T>::CompareRequests(const Request& a, const Request& b) {
+  return a.backoff_entry->GetReleaseTime() > b.backoff_entry->GetReleaseTime();
 }
 
 }  // namespace extensions
 
-#endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_REQUEST_QUEUE_IMPL_H_
+#endif  // EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_IMPL_H_