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

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.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 "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_api.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
 
@@ skipping 114 matching lines @@
     BrowserContext* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return extensions::BluetoothLowEnergyAPI::Get(context)->event_router();
 }
 
 void DoWorkCallback(const base::Callback<bool()>& callback) {
   DCHECK(!callback.is_null());
   callback.Run();
 }
 
-scoped_ptr<device::BluetoothAdvertisement::ManufacturerData>
+std::unique_ptr<device::BluetoothAdvertisement::ManufacturerData>
 CreateManufacturerData(
     std::vector<apibtle::ManufacturerData>* manufacturer_data) {
-  scoped_ptr<device::BluetoothAdvertisement::ManufacturerData> created_data(
-      new device::BluetoothAdvertisement::ManufacturerData());
+  std::unique_ptr<device::BluetoothAdvertisement::ManufacturerData>
+      created_data(new device::BluetoothAdvertisement::ManufacturerData());
   for (const auto& it : *manufacturer_data) {
     std::vector<uint8_t> data(it.data.size());
     std::copy(it.data.begin(), it.data.end(), data.begin());
     (*created_data)[it.id] = data;
   }
   return created_data;
 }
 
-scoped_ptr<device::BluetoothAdvertisement::ServiceData> CreateServiceData(
+std::unique_ptr<device::BluetoothAdvertisement::ServiceData> CreateServiceData(
     std::vector<apibtle::ServiceData>* service_data) {
-  scoped_ptr<device::BluetoothAdvertisement::ServiceData> created_data(
+  std::unique_ptr<device::BluetoothAdvertisement::ServiceData> created_data(
       new device::BluetoothAdvertisement::ServiceData());
   for (const auto& it : *service_data) {
     std::vector<uint8_t> data(it.data.size());
     std::copy(it.data.begin(), it.data.end(), data.begin());
     (*created_data)[it.uuid] = data;
   }
   return created_data;
 }
 
 }  // namespace
@@ skipping 67 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::Connect::Params> params(
+  std::unique_ptr<apibtle::Connect::Params> params(
       apibtle::Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::ConnectProperties* properties = params.get()->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->Connect(
       persistent,
@@ skipping 22 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::Disconnect::Params> params(
+  std::unique_ptr<apibtle::Disconnect::Params> params(
       apibtle::Disconnect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->Disconnect(
       extension(),
       params->device_address,
       base::Bind(&BluetoothLowEnergyDisconnectFunction::SuccessCallback, this),
       base::Bind(&BluetoothLowEnergyDisconnectFunction::ErrorCallback, this));
 
   return true;
@@ skipping 16 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetService::Params> params(
+  std::unique_ptr<apibtle::GetService::Params> params(
       apibtle::GetService::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Service service;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetService(params->service_id, &service);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
@@ skipping 12 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetServices::Params> params(
+  std::unique_ptr<apibtle::GetServices::Params> params(
       apibtle::GetServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::ServiceList service_list;
   if (!event_router->GetServices(params->device_address, &service_list)) {
     SetError(kErrorNotFound);
     SendResponse(false);
     return false;
   }
 
@@ skipping 10 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetCharacteristic::Params> params(
+  std::unique_ptr<apibtle::GetCharacteristic::Params> params(
       apibtle::GetCharacteristic::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Characteristic characteristic;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetCharacteristic(
           extension(), params->characteristic_id, &characteristic);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
@@ skipping 16 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetCharacteristics::Params> params(
+  std::unique_ptr<apibtle::GetCharacteristics::Params> params(
       apibtle::GetCharacteristics::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::CharacteristicList characteristic_list;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetCharacteristics(
           extension(), params->service_id, &characteristic_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetCharacteristics::Result::Create as it doesn't convert lists of
   // enums correctly.
-  scoped_ptr<base::ListValue> result(new base::ListValue());
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
   for (apibtle::Characteristic& characteristic : characteristic_list)
     result->Append(apibtle::CharacteristicToValue(&characteristic));
 
   SetResult(result.release());
   SendResponse(true);
 
   return true;
 }
 
 bool BluetoothLowEnergyGetIncludedServicesFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetIncludedServices::Params> params(
+  std::unique_ptr<apibtle::GetIncludedServices::Params> params(
       apibtle::GetIncludedServices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::ServiceList service_list;
   BluetoothLowEnergyEventRouter::Status status =
       event_router->GetIncludedServices(params->service_id, &service_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
@@ skipping 12 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetDescriptor::Params> params(
+  std::unique_ptr<apibtle::GetDescriptor::Params> params(
       apibtle::GetDescriptor::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   apibtle::Descriptor descriptor;
   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptor(
       extension(), params->descriptor_id, &descriptor);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
@@ skipping 15 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::GetDescriptors::Params> params(
+  std::unique_ptr<apibtle::GetDescriptors::Params> params(
       apibtle::GetDescriptors::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothLowEnergyEventRouter::DescriptorList descriptor_list;
   BluetoothLowEnergyEventRouter::Status status = event_router->GetDescriptors(
       extension(), params->characteristic_id, &descriptor_list);
   if (status != BluetoothLowEnergyEventRouter::kStatusSuccess) {
     SetError(StatusToString(status));
     SendResponse(false);
     return false;
   }
 
   // Manually construct the result instead of using
   // apibtle::GetDescriptors::Result::Create as it doesn't convert lists of
   // enums correctly.
-  scoped_ptr<base::ListValue> result(new base::ListValue());
+  std::unique_ptr<base::ListValue> result(new base::ListValue());
   for (apibtle::Descriptor& descriptor : descriptor_list)
     result->Append(apibtle::DescriptorToValue(&descriptor));
 
   SetResult(result.release());
   SendResponse(true);
 
   return true;
 }
 
 bool BluetoothLowEnergyReadCharacteristicValueFunction::DoWork() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::ReadCharacteristicValue::Params> params(
+  std::unique_ptr<apibtle::ReadCharacteristicValue::Params> params(
       apibtle::ReadCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->characteristic_id;
   event_router->ReadCharacteristicValue(
       extension(),
       instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadCharacteristicValueFunction::SuccessCallback,
           this),
@@ skipping 37 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::WriteCharacteristicValue::Params> params(
+  std::unique_ptr<apibtle::WriteCharacteristicValue::Params> params(
       apibtle::WriteCharacteristicValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteCharacteristicValue(
       extension(),
       params->characteristic_id,
       value,
       base::Bind(
           &BluetoothLowEnergyWriteCharacteristicValueFunction::SuccessCallback,
@@ skipping 23 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::StartCharacteristicNotifications::Params> params(
+  std::unique_ptr<apibtle::StartCharacteristicNotifications::Params> params(
       apibtle::StartCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   bool persistent = false;  // Not persistent by default.
   apibtle::NotificationProperties* properties = params.get()->properties.get();
   if (properties)
     persistent = properties->persistent;
 
   event_router->StartCharacteristicNotifications(
       persistent,
@@ skipping 27 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::StopCharacteristicNotifications::Params> params(
+  std::unique_ptr<apibtle::StopCharacteristicNotifications::Params> params(
       apibtle::StopCharacteristicNotifications::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   event_router->StopCharacteristicNotifications(
       extension(),
       params->characteristic_id,
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
                      SuccessCallback,
                  this),
       base::Bind(&BluetoothLowEnergyStopCharacteristicNotificationsFunction::
@@ skipping 21 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::ReadDescriptorValue::Params> params(
+  std::unique_ptr<apibtle::ReadDescriptorValue::Params> params(
       apibtle::ReadDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   instance_id_ = params->descriptor_id;
   event_router->ReadDescriptorValue(
       extension(),
       instance_id_,
       base::Bind(
           &BluetoothLowEnergyReadDescriptorValueFunction::SuccessCallback,
           this),
@@ skipping 36 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::WriteDescriptorValue::Params> params(
+  std::unique_ptr<apibtle::WriteDescriptorValue::Params> params(
       apibtle::WriteDescriptorValue::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   std::vector<uint8_t> value(params->value.begin(), params->value.end());
   event_router->WriteDescriptorValue(
       extension(),
       params->descriptor_id,
       value,
       base::Bind(
           &BluetoothLowEnergyWriteDescriptorValueFunction::SuccessCallback,
@@ skipping 94 matching lines @@
       GetEventRouter(browser_context());
 
   // The adapter must be initialized at this point, but return an error instead
   // of asserting.
   if (!event_router->HasAdapter()) {
     SetError(kErrorAdapterNotInitialized);
     SendResponse(false);
     return false;
   }
 
-  scoped_ptr<apibtle::RegisterAdvertisement::Params> params(
+  std::unique_ptr<apibtle::RegisterAdvertisement::Params> params(
       apibtle::RegisterAdvertisement::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
-  scoped_ptr<device::BluetoothAdvertisement::Data> advertisement_data(
+  std::unique_ptr<device::BluetoothAdvertisement::Data> advertisement_data(
       new device::BluetoothAdvertisement::Data(
           params->advertisement.type ==
                   apibtle::AdvertisementType::ADVERTISEMENT_TYPE_BROADCAST
               ? device::BluetoothAdvertisement::AdvertisementType::
                     ADVERTISEMENT_TYPE_BROADCAST
               : device::BluetoothAdvertisement::AdvertisementType::
                     ADVERTISEMENT_TYPE_PERIPHERAL));
 
   advertisement_data->set_service_uuids(
       std::move(params->advertisement.service_uuids));
@@ skipping 66 matching lines @@
     return false;
   }
 
   BluetoothLowEnergyEventRouter* event_router =
       GetEventRouter(browser_context());
 
   // If we don't have an initialized adapter, unregistering is a no-op.
   if (!event_router->HasAdapter())
     return true;
 
-  scoped_ptr<apibtle::UnregisterAdvertisement::Params> params(
+  std::unique_ptr<apibtle::UnregisterAdvertisement::Params> params(
       apibtle::UnregisterAdvertisement::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get() != NULL);
 
   BluetoothApiAdvertisement* advertisement =
       GetAdvertisement(params->advertisement_id);
   if (!advertisement) {
     error_ = kStatusAdvertisementDoesNotExist;
     SendResponse(false);
     return false;
   }
@@ skipping 25 matching lines @@
       SetError(kStatusAdvertisementDoesNotExist);
       break;
     default:
       SetError(kErrorOperationFailed);
   }
   SendResponse(false);
 }
 
 }  // namespace api
 }  // namespace extensions