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

components/proximity_auth/ble/bluetooth_low_energy_connection_finder.cc

 // 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.
 
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection_finder.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_device_whitelist.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
@@ skipping 177 matching lines @@
   }
 
   // Note: It's possible to connect to the paired directly, so when using
   // FIND_PAIRED_DEVICE strategy this is not necessary. However, the discovery
   // doesn't add a lot of latency, and the makes the code path for both
   // strategies more similar.
   StartDiscoverySession();
 }
 
 void BluetoothLowEnergyConnectionFinder::OnDiscoverySessionStarted(
-    scoped_ptr<device::BluetoothDiscoverySession> discovery_session) {
+    std::unique_ptr<device::BluetoothDiscoverySession> discovery_session) {
   PA_LOG(INFO) << "Discovery session started";
   discovery_session_ = std::move(discovery_session);
 }
 
 void BluetoothLowEnergyConnectionFinder::OnStartDiscoverySessionError() {
   PA_LOG(WARNING) << "Error starting discovery session";
 }
 
 void BluetoothLowEnergyConnectionFinder::StartDiscoverySession() {
   DCHECK(adapter_);
   if (discovery_session_ && discovery_session_->IsActive()) {
     PA_LOG(INFO) << "Discovery session already active";
     return;
   }
 
   // Discover only low energy (LE) devices with strong enough signal.
-  scoped_ptr<BluetoothDiscoveryFilter> filter(new BluetoothDiscoveryFilter(
+  std::unique_ptr<BluetoothDiscoveryFilter> filter(new BluetoothDiscoveryFilter(
       BluetoothDiscoveryFilter::Transport::TRANSPORT_LE));
   filter->SetRSSI(kMinDiscoveryRSSI);
 
   adapter_->StartDiscoverySessionWithFilter(
       std::move(filter),
       base::Bind(&BluetoothLowEnergyConnectionFinder::OnDiscoverySessionStarted,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(
           &BluetoothLowEnergyConnectionFinder::OnStartDiscoverySessionError,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothLowEnergyConnectionFinder::StopDiscoverySession() {
   PA_LOG(INFO) << "Stopping discovery session";
   // Destroying the discovery session also stops it.
   discovery_session_.reset();
 }
 
-scoped_ptr<Connection> BluetoothLowEnergyConnectionFinder::CreateConnection(
+std::unique_ptr<Connection>
+BluetoothLowEnergyConnectionFinder::CreateConnection(
     const std::string& device_address) {
   DCHECK(remote_device_.bluetooth_address.empty() ||
          remote_device_.bluetooth_address == device_address);
   remote_device_.bluetooth_address = device_address;
-  return make_scoped_ptr(new BluetoothLowEnergyConnection(
+  return base::WrapUnique(new BluetoothLowEnergyConnection(
       remote_device_, adapter_, remote_service_uuid_, bluetooth_throttler_,
       max_number_of_tries_));
 }
 
 void BluetoothLowEnergyConnectionFinder::OnConnectionStatusChanged(
     Connection* connection,
     Connection::Status old_status,
     Connection::Status new_status) {
   DCHECK_EQ(connection, connection_.get());
   PA_LOG(INFO) << "OnConnectionStatusChanged: " << old_status << " -> "
@@ skipping 44 matching lines @@
       return device;
   }
   return nullptr;
 }
 
 void BluetoothLowEnergyConnectionFinder::InvokeCallbackAsync() {
   connection_callback_.Run(std::move(connection_));
 }
 
 }  // namespace proximity_auth