Convert //content from scoped_ptr to std::unique_ptr

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
@@ skipping 294 matching lines @@
           []() { return GetDiscoverySession(); }));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetPowerValueAdapter(int8_t tx_power,
                                                          int8_t rssi) {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
-  scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
+  std::unique_ptr<NiceMockBluetoothDevice> device(
+      GetHeartRateDevice(adapter.get()));
 
   ON_CALL(*device, GetInquiryTxPower()).WillByDefault(Return(tx_power));
   ON_CALL(*device, GetInquiryRSSI()).WillByDefault(Return(rssi));
 
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
@@ skipping 27 matching lines @@
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetBaseDevice(adapter.get(), "❤❤❤❤❤❤❤❤❤"));
 
   return adapter;
 }
 
 // Adds a device to |adapter| and notifies all observers about that new device.
 // Mocks can call this asynchronously to cause changes in the middle of a test.
 static void AddDevice(scoped_refptr<NiceMockBluetoothAdapter> adapter,
-                      scoped_ptr<NiceMockBluetoothDevice> new_device) {
+                      std::unique_ptr<NiceMockBluetoothDevice> new_device) {
   NiceMockBluetoothDevice* new_device_ptr = new_device.get();
   adapter->AddMockDevice(std::move(new_device));
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
                     DeviceAdded(adapter.get(), new_device_ptr));
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetSecondDiscoveryFindsHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
@@ skipping 25 matching lines @@
   adapter->AddMockDevice(GetHeartRateDevice(adapter.get()));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetMissingCharacteristicHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
-  scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
+  std::unique_ptr<NiceMockBluetoothDevice> device(
+      GetHeartRateDevice(adapter.get()));
 
-  scoped_ptr<NiceMockBluetoothGattService> generic_access(
+  std::unique_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device.get(), kGenericAccessServiceUUID));
-  scoped_ptr<NiceMockBluetoothGattService> heart_rate(
+  std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device.get(), kHeartRateServiceUUID));
 
   // Intentionally NOT adding a characteristic to heart_rate service.
 
   device->AddMockService(std::move(generic_access));
   device->AddMockService(std::move(heart_rate));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDelayedServicesDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
-  scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
+  std::unique_ptr<NiceMockBluetoothDevice> device(
+      GetHeartRateDevice(adapter.get()));
 
   MockBluetoothAdapter* adapter_ptr = adapter.get();
   MockBluetoothDevice* device_ptr = device.get();
 
   // Override the previous mock implementation of CreateGattConnection that
   // this a NotifyServicesDiscovered task. Instead thsi adapter will not post
   // that task until GetGattServices is called.
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter_ptr, device_ptr]() {
-            return make_scoped_ptr(new NiceMockBluetoothGattConnection(
+            return base::WrapUnique(new NiceMockBluetoothGattConnection(
                 adapter_ptr, device_ptr->GetAddress()));
           }));
 
   ON_CALL(*device, GetGattServices())
       .WillByDefault(Invoke([adapter_ptr, device_ptr] {
         std::vector<BluetoothGattService*> services =
             device_ptr->GetMockServices();
 
         if (services.size() > 0) {
           return services;
         }
 
-        scoped_ptr<NiceMockBluetoothGattService> heart_rate(
+        std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
             GetBaseGATTService(device_ptr, kHeartRateServiceUUID));
 
         device_ptr->AddMockService(std::move(heart_rate));
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&NotifyServicesDiscovered,
                                   base::RetainedRef(adapter_ptr), device_ptr));
 
         DCHECK(services.size() == 0);
         return services;
       }));
 
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
-  scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
+  std::unique_ptr<NiceMockBluetoothDevice> device(
+      GetHeartRateDevice(adapter.get()));
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
 
   device->AddMockService(GetGenericAccessService(device.get()));
   device->AddMockService(GetHeartRateService(adapter.get(), device.get()));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kBlacklistTestServiceUUID));
   uuids.push_back(BluetoothUUID(kDeviceInformationServiceUUID));
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
   uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
   uuids.push_back(BluetoothUUID(kHumanInterfaceDeviceServiceUUID));
 
-  scoped_ptr<NiceMockBluetoothDevice> device(
+  std::unique_ptr<NiceMockBluetoothDevice> device(
       GetConnectableDevice(adapter.get(), "Blacklist Test Device", uuids));
 
   device->AddMockService(GetBlacklistTestService(device.get()));
   device->AddMockService(GetDeviceInformationService(device.get()));
   device->AddMockService(GetGenericAccessService(device.get()));
   device->AddMockService(GetHeartRateService(adapter.get(), device.get()));
   device->AddMockService(
       GetBaseGATTService(device.get(), kHumanInterfaceDeviceServiceUUID));
   adapter->AddMockDevice(std::move(device));
 
@@ skipping 17 matching lines @@
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingGATTOperationsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   const std::string errorsServiceUUID = errorUUID(0xA0);
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorsServiceUUID));
 
-  scoped_ptr<NiceMockBluetoothDevice> device(
+  std::unique_ptr<NiceMockBluetoothDevice> device(
       GetConnectableDevice(adapter.get(), "Errors Device", uuids));
 
-  scoped_ptr<NiceMockBluetoothGattService> service(
+  std::unique_ptr<NiceMockBluetoothGattService> service(
       GetBaseGATTService(device.get(), errorsServiceUUID));
 
   for (int error = BluetoothGattService::GATT_ERROR_UNKNOWN;
        error <= BluetoothGattService::GATT_ERROR_NOT_SUPPORTED; error++) {
     service->AddMockCharacteristic(GetErrorCharacteristic(
         service.get(),
         static_cast<BluetoothGattService::GattErrorCode>(error)));
   }
 
   device->AddMockService(std::move(service));
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // Discovery Sessions
 
 // static
-scoped_ptr<NiceMockBluetoothDiscoverySession>
+std::unique_ptr<NiceMockBluetoothDiscoverySession>
 LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
-  scoped_ptr<NiceMockBluetoothDiscoverySession> discovery_session(
+  std::unique_ptr<NiceMockBluetoothDiscoverySession> discovery_session(
       new NiceMockBluetoothDiscoverySession());
 
   ON_CALL(*discovery_session, Stop(_, _))
       .WillByDefault(RunCallback<0 /* success_callback */>());
 
   return discovery_session;
 }
 
 // Devices
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetBaseDevice(
     MockBluetoothAdapter* adapter,
     const std::string& device_name,
     device::BluetoothDevice::UUIDList uuids,
     const std::string& address) {
-  scoped_ptr<NiceMockBluetoothDevice> device(new NiceMockBluetoothDevice(
+  std::unique_ptr<NiceMockBluetoothDevice> device(new NiceMockBluetoothDevice(
       adapter, 0x1F00 /* Bluetooth class */, device_name, address,
       true /* paired */, true /* connected */));
 
   ON_CALL(*device, GetUUIDs()).WillByDefault(Return(uuids));
 
   // Using Invoke allows the device returned from this method to be futher
   // modified and have more services added to it. The call to ::GetGattServices
   // will invoke ::GetMockServices, returning all services added up to that
   // time.
   ON_CALL(*device, GetGattServices())
       .WillByDefault(
           Invoke(device.get(), &MockBluetoothDevice::GetMockServices));
   // The call to BluetoothDevice::GetGattService will invoke ::GetMockService
   // which returns a service matching the identifier provided if the service
   // was added to the mock.
   ON_CALL(*device, GetGattService(_))
       .WillByDefault(
           Invoke(device.get(), &MockBluetoothDevice::GetMockService));
 
   ON_CALL(*device, GetVendorIDSource())
       .WillByDefault(Return(BluetoothDevice::VENDOR_ID_BLUETOOTH));
   ON_CALL(*device, GetVendorID()).WillByDefault(Return(0xFFFF));
   ON_CALL(*device, GetProductID()).WillByDefault(Return(1));
   ON_CALL(*device, GetDeviceID()).WillByDefault(Return(2));
 
   return device;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetBatteryDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kBatteryServiceUUID));
 
   return GetBaseDevice(adapter, "Battery Device", uuids, makeMACAddress(0x1));
 }
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetGlucoseDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
   uuids.push_back(BluetoothUUID(kGlucoseServiceUUID));
   uuids.push_back(BluetoothUUID(kTxPowerServiceUUID));
 
   return GetBaseDevice(adapter, "Glucose Device", uuids, makeMACAddress(0x2));
 }
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetConnectableDevice(
     device::MockBluetoothAdapter* adapter,
     const std::string& device_name,
     BluetoothDevice::UUIDList uuids,
     const std::string& address) {
-  scoped_ptr<NiceMockBluetoothDevice> device(
+  std::unique_ptr<NiceMockBluetoothDevice> device(
       GetBaseDevice(adapter, device_name, uuids, address));
 
   MockBluetoothDevice* device_ptr = device.get();
 
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, device_ptr]() {
             base::ThreadTaskRunnerHandle::Get()->PostTask(
                 FROM_HERE, base::Bind(&NotifyServicesDiscovered,
                                       base::RetainedRef(adapter), device_ptr));
-            return make_scoped_ptr(new NiceMockBluetoothGattConnection(
+            return base::WrapUnique(new NiceMockBluetoothGattConnection(
                 adapter, device_ptr->GetAddress()));
           }));
 
   return device;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetUnconnectableDevice(
     MockBluetoothAdapter* adapter,
     BluetoothDevice::ConnectErrorCode error_code,
     const std::string& device_name) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorUUID(error_code)));
 
-  scoped_ptr<NiceMockBluetoothDevice> device(
+  std::unique_ptr<NiceMockBluetoothDevice> device(
       GetBaseDevice(adapter, device_name, uuids, makeMACAddress(error_code)));
 
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   return device;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothDevice>
+std::unique_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetHeartRateDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
   uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
 
   return GetConnectableDevice(adapter, "Heart Rate Device", uuids);
 }
 
 // Services
 
 // static
-scoped_ptr<NiceMockBluetoothGattService>
+std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTService(
     MockBluetoothDevice* device,
     const std::string& uuid) {
-  scoped_ptr<NiceMockBluetoothGattService> service(
+  std::unique_ptr<NiceMockBluetoothGattService> service(
       new NiceMockBluetoothGattService(
           device, uuid /* identifier */, BluetoothUUID(uuid),
           true /* is_primary */, false /* is_local */));
 
   ON_CALL(*service, GetCharacteristics())
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristics));
 
   ON_CALL(*service, GetCharacteristic(_))
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristic));
 
   return service;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothGattService>
+std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestService(
     device::MockBluetoothDevice* device) {
-  scoped_ptr<NiceMockBluetoothGattService> blacklist_test_service(
+  std::unique_ptr<NiceMockBluetoothGattService> blacklist_test_service(
       GetBaseGATTService(device, kBlacklistTestServiceUUID));
 
-  scoped_ptr<NiceMockBluetoothGattCharacteristic>
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       blacklist_exclude_reads_characteristic(GetBaseGATTCharacteristic(
           "Excluded Reads Characteristic", blacklist_test_service.get(),
           kBlacklistExcludeReadsCharacteristicUUID,
           BluetoothGattCharacteristic::PROPERTY_READ |
               BluetoothGattCharacteristic::PROPERTY_WRITE));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*blacklist_exclude_reads_characteristic,
           ReadRemoteCharacteristic(_, _))
       .WillByDefault(
           Invoke([](const BluetoothGattCharacteristic::ValueCallback&,
                     const BluetoothGattCharacteristic::ErrorCallback&) {
             NOTREACHED();
           }));
 
   // Write response.
   ON_CALL(*blacklist_exclude_reads_characteristic,
           WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<1 /* success callback */>());
 
   blacklist_test_service->AddMockCharacteristic(
       std::move(blacklist_exclude_reads_characteristic));
 
   return blacklist_test_service;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothGattService>
+std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetDeviceInformationService(
     device::MockBluetoothDevice* device) {
-  scoped_ptr<NiceMockBluetoothGattService> device_information(
+  std::unique_ptr<NiceMockBluetoothGattService> device_information(
       GetBaseGATTService(device, kDeviceInformationServiceUUID));
 
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> serial_number_string(
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic> serial_number_string(
       GetBaseGATTCharacteristic(
           "Serial Number String", device_information.get(),
           kSerialNumberStringUUID, BluetoothGattCharacteristic::PROPERTY_READ));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*serial_number_string, ReadRemoteCharacteristic(_, _))
       .WillByDefault(
           Invoke([](const BluetoothGattCharacteristic::ValueCallback&,
                     const BluetoothGattCharacteristic::ErrorCallback&) {
             NOTREACHED();
           }));
 
   device_information->AddMockCharacteristic(std::move(serial_number_string));
 
   return device_information;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothGattService>
+std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetGenericAccessService(
     device::MockBluetoothDevice* device) {
-  scoped_ptr<NiceMockBluetoothGattService> generic_access(
+  std::unique_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device, kGenericAccessServiceUUID));
 
   {  // Device Name:
-    scoped_ptr<NiceMockBluetoothGattCharacteristic> device_name(
+    std::unique_ptr<NiceMockBluetoothGattCharacteristic> device_name(
         GetBaseGATTCharacteristic(
             "Device Name", generic_access.get(), kDeviceNameUUID,
             BluetoothGattCharacteristic::PROPERTY_READ |
                 BluetoothGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::string device_name_str = device->GetDeviceName();
     std::vector<uint8_t> device_name_value(device_name_str.begin(),
                                            device_name_str.end());
 
     ON_CALL(*device_name, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(device_name_value));
 
     // Write response.
     ON_CALL(*device_name, WriteRemoteCharacteristic(_, _, _))
         .WillByDefault(RunCallback<1 /* success callback */>());
 
     generic_access->AddMockCharacteristic(std::move(device_name));
   }
 
   {  // Peripheral Privacy Flag:
-    scoped_ptr<NiceMockBluetoothGattCharacteristic> peripheral_privacy_flag(
-        GetBaseGATTCharacteristic(
+    std::unique_ptr<NiceMockBluetoothGattCharacteristic>
+        peripheral_privacy_flag(GetBaseGATTCharacteristic(
             "Peripheral Privacy Flag", generic_access.get(),
             kPeripheralPrivacyFlagUUID,
             BluetoothGattCharacteristic::PROPERTY_READ |
                 BluetoothGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::vector<uint8_t> value(1);
     value[0] = false;
 
     ON_CALL(*peripheral_privacy_flag, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(value));
 
     // Crash if WriteRemoteCharacteristic called. Not using GoogleMock's Expect
     // because this is used in layout tests that may not report a mock
     // expectation error correctly as a layout test failure.
     ON_CALL(*peripheral_privacy_flag, WriteRemoteCharacteristic(_, _, _))
         .WillByDefault(
             Invoke([](const std::vector<uint8_t>&, const base::Closure&,
                       const BluetoothGattCharacteristic::ErrorCallback&) {
               NOTREACHED();
             }));
 
     generic_access->AddMockCharacteristic(std::move(peripheral_privacy_flag));
   }
 
   return generic_access;
 }
 
 // static
-scoped_ptr<NiceMockBluetoothGattService>
+std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetHeartRateService(
     MockBluetoothAdapter* adapter,
     MockBluetoothDevice* device) {
-  scoped_ptr<NiceMockBluetoothGattService> heart_rate(
+  std::unique_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device, kHeartRateServiceUUID));
 
   // Heart Rate Measurement
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
       GetBaseGATTCharacteristic("Heart Rate Measurement", heart_rate.get(),
                                 kHeartRateMeasurementUUID,
                                 BluetoothGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       heart_rate_measurement.get();
 
   ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, measurement_ptr]() {
-            scoped_ptr<NiceMockBluetoothGattNotifySession> notify_session(
+            std::unique_ptr<NiceMockBluetoothGattNotifySession> notify_session(
                 GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
 
             std::vector<uint8_t> rate(1 /* size */);
             rate[0] = 60;
 
             notify_session->StartTestNotifications(adapter, measurement_ptr,
                                                    rate);
 
             return notify_session;
           }));
 
   // Body Sensor Location Characteristic (Chest)
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location_chest(
-      GetBaseGATTCharacteristic("Body Sensor Location Chest", heart_rate.get(),
-                                kBodySensorLocation,
-                                BluetoothGattCharacteristic::PROPERTY_READ));
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic>
+      body_sensor_location_chest(GetBaseGATTCharacteristic(
+          "Body Sensor Location Chest", heart_rate.get(), kBodySensorLocation,
+          BluetoothGattCharacteristic::PROPERTY_READ));
   BluetoothGattCharacteristic* location_chest_ptr =
       body_sensor_location_chest.get();
 
   ON_CALL(*body_sensor_location_chest, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_chest_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter->GetObservers(),
                               GattCharacteristicValueChanged(
                                   adapter, location_chest_ptr, location));
             return location;
           }));
 
   // Body Sensor Location Characteristic (Wrist)
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location_wrist(
-      GetBaseGATTCharacteristic("Body Sensor Location Wrist", heart_rate.get(),
-                                kBodySensorLocation,
-                                BluetoothGattCharacteristic::PROPERTY_READ));
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic>
+      body_sensor_location_wrist(GetBaseGATTCharacteristic(
+          "Body Sensor Location Wrist", heart_rate.get(), kBodySensorLocation,
+          BluetoothGattCharacteristic::PROPERTY_READ));
   BluetoothGattCharacteristic* location_wrist_ptr =
       body_sensor_location_wrist.get();
 
   ON_CALL(*body_sensor_location_wrist, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, location_wrist_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 2;  // Wrist
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter->GetObservers(),
                               GattCharacteristicValueChanged(
                                   adapter, location_wrist_ptr, location));
             return location;
           }));
 
   heart_rate->AddMockCharacteristic(std::move(heart_rate_measurement));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_chest));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_wrist));
 
   return heart_rate;
 }
 
 // Characteristics
 
 // static
-scoped_ptr<NiceMockBluetoothGattCharacteristic>
+std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
     const std::string& identifier,
     MockBluetoothGattService* service,
     const std::string& uuid,
     BluetoothGattCharacteristic::Properties properties) {
-  return make_scoped_ptr(new NiceMockBluetoothGattCharacteristic(
+  return base::WrapUnique(new NiceMockBluetoothGattCharacteristic(
       service, identifier, BluetoothUUID(uuid), false /* is_local */,
       properties, NULL /* permissions */));
 }
 
 // static
-scoped_ptr<NiceMockBluetoothGattCharacteristic>
+std::unique_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetErrorCharacteristic(
     MockBluetoothGattService* service,
     BluetoothGattService::GattErrorCode error_code) {
   uint32_t error_alias = error_code + 0xA1;  // Error UUIDs start at 0xA1.
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
+  std::unique_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
       GetBaseGATTCharacteristic(
           // Use the UUID to generate unique identifiers.
           "Error Characteristic " + errorUUID(error_alias), service,
           errorUUID(error_alias),
           BluetoothGattCharacteristic::PROPERTY_READ |
               BluetoothGattCharacteristic::PROPERTY_WRITE |
               BluetoothGattCharacteristic::PROPERTY_INDICATE));
 
   // Read response.
   ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
   ON_CALL(*characteristic, StartNotifySession(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   return characteristic;
 }
 
 // Notify sessions
 
 // static
-scoped_ptr<NiceMockBluetoothGattNotifySession>
+std::unique_ptr<NiceMockBluetoothGattNotifySession>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTNotifySession(
     const std::string& characteristic_identifier) {
-  scoped_ptr<NiceMockBluetoothGattNotifySession> session(
+  std::unique_ptr<NiceMockBluetoothGattNotifySession> session(
       new NiceMockBluetoothGattNotifySession(characteristic_identifier));
 
   ON_CALL(*session, Stop(_))
       .WillByDefault(testing::DoAll(
           InvokeWithoutArgs(
               session.get(),
               &MockBluetoothGattNotifySession::StopTestNotifications),
           RunCallback<0>()));
 
   return session;
@@ skipping 51 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content