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

extensions/browser/api/bluetooth/bluetooth_private_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 "extensions/browser/api/bluetooth/bluetooth_private_api.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 124 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivateSetAdapterStateFunction::
     BluetoothPrivateSetAdapterStateFunction() {}
 
 BluetoothPrivateSetAdapterStateFunction::
     ~BluetoothPrivateSetAdapterStateFunction() {}
 
 bool BluetoothPrivateSetAdapterStateFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::SetAdapterState::Params> params(
+  std::unique_ptr<bt_private::SetAdapterState::Params> params(
       bt_private::SetAdapterState::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (!adapter->IsPresent()) {
     SetError(kAdapterNotPresent);
     SendResponse(false);
     return true;
   }
 
   const bt_private::NewAdapterState& new_state = params->adapter_state;
@@ skipping 87 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivateSetPairingResponseFunction::
     BluetoothPrivateSetPairingResponseFunction() {}
 
 BluetoothPrivateSetPairingResponseFunction::
     ~BluetoothPrivateSetPairingResponseFunction() {}
 
 bool BluetoothPrivateSetPairingResponseFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::SetPairingResponse::Params> params(
+  std::unique_ptr<bt_private::SetPairingResponse::Params> params(
       bt_private::SetPairingResponse::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const bt_private::SetPairingResponseOptions& options = params->options;
 
   BluetoothEventRouter* router =
       BluetoothAPI::Get(browser_context())->event_router();
   if (!router->GetPairingDelegate(GetExtensionId())) {
     SetError(kPairingNotEnabled);
     SendResponse(false);
     return true;
@@ skipping 40 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivateDisconnectAllFunction::BluetoothPrivateDisconnectAllFunction() {
 }
 
 BluetoothPrivateDisconnectAllFunction::
     ~BluetoothPrivateDisconnectAllFunction() {}
 
 bool BluetoothPrivateDisconnectAllFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::DisconnectAll::Params> params(
+  std::unique_ptr<bt_private::DisconnectAll::Params> params(
       bt_private::DisconnectAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
     return true;
   }
 
@@ skipping 32 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivateForgetDeviceFunction::BluetoothPrivateForgetDeviceFunction() {}
 
 BluetoothPrivateForgetDeviceFunction::~BluetoothPrivateForgetDeviceFunction() {}
 
 bool BluetoothPrivateForgetDeviceFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::ForgetDevice::Params> params(
+  std::unique_ptr<bt_private::ForgetDevice::Params> params(
       bt_private::ForgetDevice::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
     return true;
   }
 
@@ skipping 14 matching lines @@
     scoped_refptr<device::BluetoothAdapter> adapter,
     const std::string& device_address) {
   SetError(kForgetDeviceError);
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool BluetoothPrivateSetDiscoveryFilterFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<SetDiscoveryFilter::Params> params(
+  std::unique_ptr<SetDiscoveryFilter::Params> params(
       SetDiscoveryFilter::Params::Create(*args_));
   auto& df_param = params->discovery_filter;
 
-  scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter;
+  std::unique_ptr<device::BluetoothDiscoveryFilter> discovery_filter;
 
   // If all filter fields are empty, we are clearing filter. If any field is
   // set, then create proper filter.
   if (df_param.uuids.get() || df_param.rssi.get() || df_param.pathloss.get() ||
       df_param.transport != bt_private::TransportType::TRANSPORT_TYPE_NONE) {
     uint8_t transport;
 
     switch (df_param.transport) {
       case bt_private::TransportType::TRANSPORT_TYPE_LE:
         transport = device::BluetoothDiscoveryFilter::Transport::TRANSPORT_LE;
@@ skipping 51 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivateConnectFunction::BluetoothPrivateConnectFunction() {}
 
 BluetoothPrivateConnectFunction::~BluetoothPrivateConnectFunction() {}
 
 bool BluetoothPrivateConnectFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::Connect::Params> params(
+  std::unique_ptr<bt_private::Connect::Params> params(
       bt_private::Connect::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
     return true;
   }
 
@@ skipping 81 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 BluetoothPrivatePairFunction::BluetoothPrivatePairFunction() {}
 
 BluetoothPrivatePairFunction::~BluetoothPrivatePairFunction() {}
 
 bool BluetoothPrivatePairFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<bt_private::Pair::Params> params(
+  std::unique_ptr<bt_private::Pair::Params> params(
       bt_private::Pair::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
   if (!device) {
     SetError(kDeviceNotFoundError);
     SendResponse(false);
     return true;
   }
 
@@ skipping 25 matching lines @@
     device::BluetoothDevice::ConnectErrorCode error) {
   SetError(kPairingFailed);
   SendResponse(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 }  // namespace api
 
 }  // namespace extensions