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

extensions/browser/load_monitoring_extension_host_queue.h

 // Copyright 2015 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_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_
 #define EXTENSIONS_BROWSER_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_
 
 #include <stddef.h>
 
+#include <memory>
 #include <set>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/time/time.h"
 #include "extensions/browser/deferred_start_render_host_observer.h"
 #include "extensions/browser/extension_host_queue.h"
 
 namespace extensions {
 
 // An ExtensionHostQueue which just monitors, and later reports, how many
 // ExtensionHosts are being loaded for some period of time.
 class LoadMonitoringExtensionHostQueue
     : public ExtensionHostQueue,
       public DeferredStartRenderHostObserver {
  public:
   // Construction for testing.
   // Allows overriding the default timeout and triggering a callback when
   // monitoring has finished (timeout has elapsed and UMA is logged).
   using FinishedCallback = base::Callback<void(size_t,  // num_queued
                                                size_t,  // max_loaded
                                                size_t,  // max_awaiting_loading
                                                size_t   // max_active_loading
                                                )>;
-  LoadMonitoringExtensionHostQueue(scoped_ptr<ExtensionHostQueue> delegate,
+  LoadMonitoringExtensionHostQueue(std::unique_ptr<ExtensionHostQueue> delegate,
                                    base::TimeDelta monitor_time,
                                    const FinishedCallback& finished_callback);
 
   // Production code should use this constructor.
   //
   // Monitoring will not start until the first Add()ed
   // DeferredStartRenderHost starts loading, or StartMonitoring() is called.
   explicit LoadMonitoringExtensionHostQueue(
-      scoped_ptr<ExtensionHostQueue> delegate);
+      std::unique_ptr<ExtensionHostQueue> delegate);
 
   ~LoadMonitoringExtensionHostQueue() override;
 
   // Starts monitoring.
   //
   // This can be called multiple times, but it has no effect if monitoring has
   // already started (or finished). Monitoring cannot be restarted.
   //
   // Note that monitoring will automatically start when Add() is called, so it
   // may not be necessary to call this at all.
@@ skipping 15 matching lines @@
   // Starts/finishes monitoring |host|, though either will have no effect if
   // monitoring has already finished.
   void StartMonitoringHost(const DeferredStartRenderHost* host);
   void FinishMonitoringHost(const DeferredStartRenderHost* host);
 
   // Called when monitoring should finish. Metrics are recorded, and from this
   // point on no monitoring will take place.
   void FinishMonitoring();
 
   // Delegate actually loading DeferredStartRenderHosts to another queue.
-  scoped_ptr<ExtensionHostQueue> delegate_;
+  std::unique_ptr<ExtensionHostQueue> delegate_;
 
   // The amount of time to monitor for. By default this is 1 minute, but it can
   // be overriden by tests.
   base::TimeDelta monitor_time_;
 
   // A callback to run when monitoring has finished. Intended for testing.
   FinishedCallback finished_callback_;
 
   // The hosts which are waiting to start loading.
   std::set<const DeferredStartRenderHost*> awaiting_loading_;
@@ skipping 14 matching lines @@
   size_t max_active_loading_;
 
   base::WeakPtrFactory<LoadMonitoringExtensionHostQueue> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadMonitoringExtensionHostQueue);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_LOAD_MONITORING_EXTENSION_HOST_QUEUE_H_