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

components/proximity_auth/bluetooth_connection_finder_unittest.cc

 // Copyright 2014 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/bluetooth_connection_finder.h"
 
+#include <memory>
 #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/time/time.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"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
@@ skipping 22 matching lines @@
   void SetStatus(Connection::Status status) {
     // This object should not be destroyed after setting the status and calling
     // observers.
     do_not_destroy_ = true;
     Connection::SetStatus(status);
     do_not_destroy_ = false;
   }
 
  private:
   void Disconnect() override {}
-  void SendMessageImpl(scoped_ptr<WireMessage> message) override {}
+  void SendMessageImpl(std::unique_ptr<WireMessage> message) override {}
 
   // If true, we do not expect |this| object to be destroyed until this value is
   // toggled back to false.
   bool do_not_destroy_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnection);
 };
 
 class MockBluetoothConnectionFinder : public BluetoothConnectionFinder {
  public:
   MockBluetoothConnectionFinder()
       : BluetoothConnectionFinder(CreateClassicRemoteDeviceForTest(),
                                   device::BluetoothUUID(kUuid),
                                   base::TimeDelta()) {}
   ~MockBluetoothConnectionFinder() override {}
 
   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.
   MockConnection* ExpectCreateConnection() {
-    scoped_ptr<MockConnection> connection(new NiceMock<MockConnection>());
+    std::unique_ptr<MockConnection> connection(new NiceMock<MockConnection>());
     MockConnection* connection_alias = connection.get();
     EXPECT_CALL(*this, CreateConnectionProxy())
         .WillOnce(Return(connection.release()));
     return connection_alias;
   }
 
   using BluetoothConnectionFinder::AdapterPresentChanged;
   using BluetoothConnectionFinder::AdapterPoweredChanged;
 
   void ClearSeekCallbacks() {
     seek_callback_ = base::Closure();
     seek_error_callback_ = bluetooth_util::ErrorCallback();
   }
 
   const base::Closure& seek_callback() { return seek_callback_; }
   const bluetooth_util::ErrorCallback& seek_error_callback() {
     return seek_error_callback_;
   }
 
  protected:
   // BluetoothConnectionFinder:
-  scoped_ptr<Connection> CreateConnection() override {
-    return make_scoped_ptr(CreateConnectionProxy());
+  std::unique_ptr<Connection> CreateConnection() override {
+    return base::WrapUnique(CreateConnectionProxy());
   }
 
   void SeekDeviceByAddress(
       const std::string& bluetooth_address,
       const base::Closure& callback,
       const bluetooth_util::ErrorCallback& error_callback) override {
     EXPECT_EQ(kTestRemoteDeviceBluetoothAddress, bluetooth_address);
     seek_callback_ = callback;
     seek_error_callback_ = error_callback;
   }
@@ skipping 28 matching lines @@
     ON_CALL(*adapter_, IsPresent()).WillByDefault(Return(true));
     ON_CALL(*adapter_, IsPowered()).WillByDefault(Return(true));
 
     // By default, the remote device is known to |adapter_| so
     // |SeekDeviceByAddress()| will not be called.
     ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(bluetooth_device_.get()));
   }
 
   MOCK_METHOD1(OnConnectionFoundProxy, void(Connection* connection));
-  void OnConnectionFound(scoped_ptr<Connection> connection) {
+  void OnConnectionFound(std::unique_ptr<Connection> connection) {
     OnConnectionFoundProxy(connection.get());
     last_found_connection_ = std::move(connection);
   }
 
   // Starts |connection_finder_|. If |expect_connection| is true, then we set an
   // expectation that an in-progress connection will be created and returned.
   MockConnection* StartConnectionFinder(bool expect_connection) {
     MockConnection* connection = nullptr;
     if (expect_connection)
       connection = connection_finder_.ExpectCreateConnection();
     connection_finder_.Find(connection_callback_);
     return connection;
   }
 
   // Given an in-progress |connection| returned by |StartConnectionFinder()|,
   // simulate it transitioning to the CONNECTED state.
   void SimulateDeviceConnection(MockConnection* connection) {
     connection->SetStatus(Connection::IN_PROGRESS);
     base::RunLoop run_loop;
     EXPECT_CALL(*this, OnConnectionFoundProxy(_));
     connection->SetStatus(Connection::CONNECTED);
     run_loop.RunUntilIdle();
   }
 
   scoped_refptr<device::MockBluetoothAdapter> adapter_;
   StrictMock<MockBluetoothConnectionFinder> connection_finder_;
-  scoped_ptr<device::MockBluetoothDevice> bluetooth_device_;
+  std::unique_ptr<device::MockBluetoothDevice> bluetooth_device_;
   ConnectionFinder::ConnectionCallback connection_callback_;
 
  private:
   // Save a pointer to the last found connection, to extend its lifetime.
-  scoped_ptr<Connection> last_found_connection_;
+  std::unique_ptr<Connection> last_found_connection_;
 
   base::MessageLoop message_loop_;
 };
 
 TEST_F(ProximityAuthBluetoothConnectionFinderTest,
        ConstructAndDestroyDoesntCrash) {
   // Destroying a BluetoothConnectionFinder for which Find() has not been called
   // should not crash.
   BluetoothConnectionFinder connection_finder(
       CreateClassicRemoteDeviceForTest(), device::BluetoothUUID(kUuid),
@@ skipping 162 matching lines @@
 
   // Successfully connect to the Bluetooth device.
   ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
       .WillByDefault(Return(bluetooth_device_.get()));
   MockConnection* connection = connection_finder_.ExpectCreateConnection();
   connection_finder_.seek_callback().Run();
   SimulateDeviceConnection(connection);
 }
 
 }  // namespace proximity_auth