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

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_apitest.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 <stdint.h>
+
+#include <memory>
 #include <utility>
 
-#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 #include "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_device.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_descriptor.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_service.h"
@@ skipping 187 matching lines @@
     ON_CALL(*desc1_, GetValue()).WillByDefault(ReturnRefOfCopy(default_value));
   }
 
  protected:
   BluetoothLowEnergyEventRouter* event_router() {
     return extensions::BluetoothLowEnergyAPI::Get(browser()->profile())
         ->event_router();
   }
 
   testing::StrictMock<MockBluetoothAdapter>* mock_adapter_;
-  scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device0_;
-  scoped_ptr<testing::NiceMock<MockBluetoothDevice> > device1_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattService> > service0_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattService> > service1_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc0_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc1_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattCharacteristic> > chrc2_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattDescriptor> > desc0_;
-  scoped_ptr<testing::NiceMock<MockBluetoothGattDescriptor> > desc1_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothDevice>> device0_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothDevice>> device1_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattService>> service0_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattService>> service1_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattCharacteristic>> chrc0_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattCharacteristic>> chrc1_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattCharacteristic>> chrc2_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattDescriptor>> desc0_;
+  std::unique_ptr<testing::NiceMock<MockBluetoothGattDescriptor>> desc1_;
 
  private:
   scoped_refptr<extensions::Extension> empty_extension_;
 };
 
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   ::std::tr1::get<k>(args).Run();
 }
 
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p0)) {
   ::std::tr1::get<k>(args).Run(p0);
 }
 
 ACTION_TEMPLATE(InvokeCallbackWithScopedPtrArg,
                 HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
                 AND_1_VALUE_PARAMS(p0)) {
-  ::std::tr1::get<k>(args).Run(scoped_ptr<T>(p0));
+  ::std::tr1::get<k>(args).Run(std::unique_ptr<T>(p0));
 }
 
 BluetoothGattConnection* CreateGattConnection(
     scoped_refptr<device::BluetoothAdapter> adapter,
     const std::string& device_address,
     bool expect_disconnect) {
   testing::NiceMock<MockBluetoothGattConnection>* conn =
       new testing::NiceMock<MockBluetoothGattConnection>(adapter,
                                                          device_address);
   EXPECT_CALL(*conn, Disconnect()).Times(expect_disconnect ? 1 : 0);
@@ skipping 968 matching lines @@
   catcher.RestrictToBrowserContext(browser()->profile());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(kTestLeDeviceAddress0))
       .WillRepeatedly(Return(device0_.get()));
 
   BluetoothDevice::GattConnectionCallback connect_callback;
 
   testing::NiceMock<MockBluetoothGattConnection>* conn =
       new testing::NiceMock<MockBluetoothGattConnection>(mock_adapter_,
                                                          kTestLeDeviceAddress0);
-  scoped_ptr<BluetoothGattConnection> conn_ptr(conn);
+  std::unique_ptr<BluetoothGattConnection> conn_ptr(conn);
   EXPECT_CALL(*conn, Disconnect()).Times(1);
 
   EXPECT_CALL(*device0_, CreateGattConnection(_, _))
       .Times(1)
       .WillOnce(SaveArg<0>(&connect_callback));
 
   ExtensionTestMessageListener listener(true);
   ASSERT_TRUE(LoadExtension(test_data_dir_.AppendASCII(
       "bluetooth_low_energy/connect_in_progress")));
 
@@ skipping 117 matching lines @@
   EXPECT_TRUE(listener.WaitUntilSatisfied());
 
   listener.Reply("go");
   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   event_router()->GattServiceRemoved(mock_adapter_, device0_.get(),
                                      service0_.get());
 }
 
 }  // namespace