Convert //extensions/browser from scoped_ptr to std::unique_ptr

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 EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_H_
 #define EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_H_
 
 #include <stddef.h>
 
 #include <deque>
+#include <memory>
 #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.
 //
@@ skipping 18 matching lines @@
                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();
+  std::unique_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);
+  void ScheduleRequest(std::unique_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
@@ skipping 17 matching lines @@
     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);
+  void PushImpl(std::unique_ptr<T> request,
+                std::unique_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_;
+  std::unique_ptr<T> active_request_;
+  std::unique_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 {
@@ skipping 13 matching lines @@
   typedef std::deque<typename RequestQueue<T>::Request> Container;
 
   explicit iterator(const typename Container::iterator& it) : it_(it) {}
 
   typename Container::iterator it_;
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_UPDATER_REQUEST_QUEUE_H_