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

components/proximity_auth/ble/bluetooth_low_energy_connection_finder_unittest.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/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "components/proximity_auth/ble/bluetooth_low_energy_device_whitelist.h"
 #include "components/proximity_auth/fake_connection.h"
 #include "components/proximity_auth/proximity_auth_test_util.h"
 #include "components/proximity_auth/remote_device.h"
 #include "components/proximity_auth/wire_message.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
@@ skipping 38 matching lines @@
       FinderStrategy finder_strategy)
       : BluetoothLowEnergyConnectionFinder(CreateLERemoteDeviceForTest(),
                                            kServiceUUID,
                                            finder_strategy,
                                            device_whitelist,
                                            nullptr,
                                            kMaxNumberOfAttempts) {}
 
   ~MockBluetoothLowEnergyConnectionFinder() override {}
 
-  // Mock methods don't support return type scoped_ptr<>. This is a possible
-  // workaround: mock a proxy method to be called by the target overrided method
-  // (CreateConnection).
+  // Mock methods don't support return type std::unique_ptr<>. This is a
+  // possible workaround: mock a proxy method to be called by the target
+  // overridden method (CreateConnection).
   MOCK_METHOD0(CreateConnectionProxy, Connection*());
 
   // Creates a mock connection and sets an expectation that the mock connection
   // finder's CreateConnection() method will be called and will return the
   // created connection. Returns a reference to the created connection.
   // NOTE: The returned connection's lifetime is managed by the connection
   // finder.
   FakeConnection* ExpectCreateConnection() {
-    scoped_ptr<FakeConnection> connection(
+    std::unique_ptr<FakeConnection> connection(
         new FakeConnection(CreateLERemoteDeviceForTest()));
     FakeConnection* connection_alias = connection.get();
     EXPECT_CALL(*this, CreateConnectionProxy())
         .WillOnce(Return(connection.release()));
     return connection_alias;
   }
 
   MOCK_METHOD0(CloseGattConnectionProxy, void(void));
 
  protected:
-  scoped_ptr<Connection> CreateConnection(
+  std::unique_ptr<Connection> CreateConnection(
       const std::string& device_address) override {
-    return make_scoped_ptr(CreateConnectionProxy());
+    return base::WrapUnique(CreateConnectionProxy());
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockBluetoothLowEnergyConnectionFinder);
 };
 
 }  // namespace
 
 class ProximityAuthBluetoothLowEnergyConnectionFinderTest
     : public testing::Test {
@@ skipping 18 matching lines @@
     std::vector<const device::BluetoothDevice*> devices;
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
 
     ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
     ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(true));
 
     ON_CALL(*device_whitelist_, HasDeviceWithAddress(_))
         .WillByDefault(Return(false));
   }
 
-  void OnConnectionFound(scoped_ptr<Connection> connection) {
+  void OnConnectionFound(std::unique_ptr<Connection> connection) {
     last_found_connection_ = std::move(connection);
   }
 
   void FindAndExpectStartDiscovery(
       BluetoothLowEnergyConnectionFinder& connection_finder) {
     device::BluetoothAdapter::DiscoverySessionCallback discovery_callback;
-    scoped_ptr<device::MockBluetoothDiscoverySession> discovery_session(
+    std::unique_ptr<device::MockBluetoothDiscoverySession> discovery_session(
         new NiceMock<device::MockBluetoothDiscoverySession>());
     last_discovery_session_alias_ = discovery_session.get();
 
     // Starting a discovery session. StartDiscoveryWithFilterRaw is a proxy for
     // StartDiscoveryWithFilter.
     EXPECT_CALL(*adapter_, StartDiscoverySessionWithFilterRaw(_, _, _))
         .WillOnce(SaveArg<1>(&discovery_callback));
     EXPECT_CALL(*adapter_, AddObserver(_));
     ON_CALL(*last_discovery_session_alias_, IsActive())
         .WillByDefault(Return(true));
@@ skipping 12 matching lines @@
                      bool paired) {
     std::vector<device::BluetoothUUID> uuids;
     uuids.push_back(device::BluetoothUUID(uuid));
     ON_CALL(*device_, GetUUIDs()).WillByDefault(Return(uuids));
     ON_CALL(*device_, GetAddress()).WillByDefault(Return(address));
     ON_CALL(*device_, IsPaired()).WillByDefault(Return(paired));
   }
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   ConnectionFinder::ConnectionCallback connection_callback_;
-  scoped_ptr<device::MockBluetoothDevice> device_;
-  scoped_ptr<Connection> last_found_connection_;
-  scoped_ptr<MockBluetoothLowEnergyDeviceWhitelist> device_whitelist_;
+  std::unique_ptr<device::MockBluetoothDevice> device_;
+  std::unique_ptr<Connection> last_found_connection_;
+  std::unique_ptr<MockBluetoothLowEnergyDeviceWhitelist> device_whitelist_;
   device::MockBluetoothDiscoverySession* last_discovery_session_alias_;
 
  private:
   base::MessageLoop message_loop_;
 };
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionFinderTest,
        ConstructAndDestroyDoesntCrash) {
   // Destroying a BluetoothConnectionFinder for which Find() has not been called
   // should not crash.
@@ skipping 16 matching lines @@
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionFinderTest,
        Find_StopsDiscoverySessionBeforeDestroying) {
   BluetoothLowEnergyConnectionFinder connection_finder(
       CreateLERemoteDeviceForTest(), kServiceUUID,
       BluetoothLowEnergyConnectionFinder::FIND_PAIRED_DEVICE,
       device_whitelist_.get(), nullptr, kMaxNumberOfAttempts);
 
   device::BluetoothAdapter::DiscoverySessionCallback discovery_callback;
-  scoped_ptr<device::MockBluetoothDiscoverySession> discovery_session(
+  std::unique_ptr<device::MockBluetoothDiscoverySession> discovery_session(
       new NiceMock<device::MockBluetoothDiscoverySession>());
   device::MockBluetoothDiscoverySession* discovery_session_alias =
       discovery_session.get();
 
   EXPECT_CALL(*adapter_, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillOnce(SaveArg<1>(&discovery_callback));
   ON_CALL(*discovery_session_alias, IsActive()).WillByDefault(Return(true));
   EXPECT_CALL(*adapter_, AddObserver(_));
   connection_finder.Find(connection_callback_);
 
@@ skipping 181 matching lines @@
       .WillOnce(SaveArg<1>(&discovery_callback));
 
   // Connection fails.
   {
     base::RunLoop run_loop;
     connection->SetStatus(Connection::DISCONNECTED);
     run_loop.RunUntilIdle();
   }
 
   // Restarting the discovery session.
-  scoped_ptr<device::MockBluetoothDiscoverySession> discovery_session(
+  std::unique_ptr<device::MockBluetoothDiscoverySession> discovery_session(
       new NiceMock<device::MockBluetoothDiscoverySession>());
   last_discovery_session_alias_ = discovery_session.get();
   ON_CALL(*last_discovery_session_alias_, IsActive())
       .WillByDefault(Return(true));
   ASSERT_FALSE(discovery_callback.is_null());
   discovery_callback.Run(std::move(discovery_session));
 
   // Preparing to create a GATT connection to the right device.
   PrepareDevice(kServiceUUID, kTestRemoteDeviceBluetoothAddress, true);
   connection = connection_finder.ExpectCreateConnection();
@@ skipping 26 matching lines @@
   ON_CALL(*last_discovery_session_alias_, IsActive())
       .WillByDefault(Return(false));
   connection_finder.AdapterPoweredChanged(adapter_.get(), false);
   connection_finder.AdapterPresentChanged(adapter_.get(), false);
 
   // Adding the adapter.
   ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
   ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(true));
 
   device::BluetoothAdapter::DiscoverySessionCallback discovery_callback;
-  scoped_ptr<device::MockBluetoothDiscoverySession> discovery_session(
+  std::unique_ptr<device::MockBluetoothDiscoverySession> discovery_session(
       new NiceMock<device::MockBluetoothDiscoverySession>());
   last_discovery_session_alias_ = discovery_session.get();
 
   // Restarting the discovery session.
   EXPECT_CALL(*adapter_, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillOnce(SaveArg<1>(&discovery_callback));
   connection_finder.AdapterPresentChanged(adapter_.get(), true);
   connection_finder.AdapterPoweredChanged(adapter_.get(), true);
   ON_CALL(*last_discovery_session_alias_, IsActive())
       .WillByDefault(Return(true));
@@ skipping 11 matching lines @@
   // Completing the connection.
   base::RunLoop run_loop;
   ASSERT_FALSE(last_found_connection_);
   connection->SetStatus(Connection::IN_PROGRESS);
   connection->SetStatus(Connection::CONNECTED);
   run_loop.RunUntilIdle();
   EXPECT_TRUE(last_found_connection_);
 }
 
 }  // namespace proximity_auth