Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

components/proximity_auth/proximity_monitor_impl.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 COMPONENTS_PROXIMITY_AUTH_PROXIMITY_MONITOR_IMPL_H
 #define COMPONENTS_PROXIMITY_AUTH_PROXIMITY_MONITOR_IMPL_H
 
+#include <memory>
+
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "components/proximity_auth/proximity_monitor.h"
 #include "components/proximity_auth/remote_device.h"
 #include "device/bluetooth/bluetooth_device.h"
 
 namespace base {
 class TickClock;
 class TimeTicks;
 }
 
 namespace device {
 class BluetoothAdapter;
 }
 
 namespace proximity_auth {
 
 class ProximityMonitorObserver;
 
 // The concrete implemenation of the proximity monitor interface.
 class ProximityMonitorImpl : public ProximityMonitor {
  public:
   // The |observer| is not owned, and must outlive |this| instance.
   ProximityMonitorImpl(const RemoteDevice& remote_device,
-                       scoped_ptr<base::TickClock> clock);
+                       std::unique_ptr<base::TickClock> clock);
   ~ProximityMonitorImpl() override;
 
   // ProximityMonitor:
   void Start() override;
   void Stop() override;
   Strategy GetStrategy() const override;
   bool IsUnlockAllowed() const override;
   bool IsInRssiRange() const override;
   void RecordProximityMetricsOnAuthSuccess() override;
   void AddObserver(ProximityMonitorObserver* observer) override;
@@ skipping 73 matching lines @@
   bool remote_device_is_in_proximity_;
 
   // Whether the proximity monitor is active, i.e. should possibly be scanning
   // for proximity to the remote device.
   bool is_active_;
 
   // The exponentailly weighted rolling average of the RSSI, used to smooth the
   // RSSI readings. Null if the monitor is inactive, has not recently observed
   // an RSSI reading, or the most recent connection info included an invalid
   // measurement.
-  scoped_ptr<double> rssi_rolling_average_;
+  std::unique_ptr<double> rssi_rolling_average_;
 
   // The last TX power reading. Null if the monitor is inactive, has not
   // recently observed a TX power reading, or the most recent connection info
   // included an invalid measurement.
-  scoped_ptr<TransmitPowerReading> last_transmit_power_reading_;
+  std::unique_ptr<TransmitPowerReading> last_transmit_power_reading_;
 
   // The timestamp of the last zero RSSI reading. An RSSI value of 0 is special
   // because both devices adjust their transmit powers such that the RSSI is in
   // this golden range, if possible. Null if the monitor is inactive, has not
   // recently observed an RSSI reading, or the most recent connection info
   // included an invalid measurement.
-  scoped_ptr<base::TimeTicks> last_zero_rssi_timestamp_;
+  std::unique_ptr<base::TimeTicks> last_zero_rssi_timestamp_;
 
   // Used to access non-decreasing time measurements.
-  scoped_ptr<base::TickClock> clock_;
+  std::unique_ptr<base::TickClock> clock_;
 
   // Used to vend weak pointers for polling. Using a separate factory for these
   // weak pointers allows the weak pointers to be invalidated when polling
   // stops, which effectively cancels the scheduled tasks.
   base::WeakPtrFactory<ProximityMonitorImpl> polling_weak_ptr_factory_;
 
   // Used to vend all other weak pointers.
   base::WeakPtrFactory<ProximityMonitorImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProximityMonitorImpl);
 };
 
 }  // namespace proximity_auth
 
 #endif  // COMPONENTS_PROXIMITY_AUTH_PROXIMITY_MONITOR_IMPL_H