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

chrome/browser/extensions/api/easy_unlock_private/easy_unlock_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 "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_api.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_connection_manager.h"
 #include "chrome/browser/extensions/api/easy_unlock_private/easy_unlock_private_crypto_delegate.h"
@@ skipping 106 matching lines @@
     crypto_delegate_ = EasyUnlockPrivateCryptoDelegate::Create();
   return crypto_delegate_.get();
 }
 
 EasyUnlockPrivateGetStringsFunction::EasyUnlockPrivateGetStringsFunction() {
 }
 EasyUnlockPrivateGetStringsFunction::~EasyUnlockPrivateGetStringsFunction() {
 }
 
 bool EasyUnlockPrivateGetStringsFunction::RunSync() {
-  scoped_ptr<base::DictionaryValue> strings(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> strings(new base::DictionaryValue);
 
 #if defined(OS_CHROMEOS)
   const base::string16 device_type = ash::GetChromeOSDeviceName();
 #else
   // TODO(isherman): Set an appropriate device name for non-ChromeOS devices.
   const base::string16 device_type = base::ASCIIToUTF16("Chromeschnozzle");
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(OS_CHROMEOS)
   const user_manager::UserManager* manager = user_manager::UserManager::Get();
@@ skipping 211 matching lines @@
   return true;
 }
 
 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 
 EasyUnlockPrivatePerformECDHKeyAgreementFunction::
 ~EasyUnlockPrivatePerformECDHKeyAgreementFunction() {}
 
 bool EasyUnlockPrivatePerformECDHKeyAgreementFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::PerformECDHKeyAgreement::Params> params =
+  std::unique_ptr<easy_unlock_private::PerformECDHKeyAgreement::Params> params =
       easy_unlock_private::PerformECDHKeyAgreement::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   GetCryptoDelegate(browser_context())->PerformECDHKeyAgreement(
       *params,
       base::Bind(&EasyUnlockPrivatePerformECDHKeyAgreementFunction::OnData,
                  this));
   return true;
 }
 
@@ skipping 32 matching lines @@
   SendResponse(true);
 }
 
 EasyUnlockPrivateCreateSecureMessageFunction::
 EasyUnlockPrivateCreateSecureMessageFunction() {}
 
 EasyUnlockPrivateCreateSecureMessageFunction::
 ~EasyUnlockPrivateCreateSecureMessageFunction() {}
 
 bool EasyUnlockPrivateCreateSecureMessageFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::CreateSecureMessage::Params> params =
+  std::unique_ptr<easy_unlock_private::CreateSecureMessage::Params> params =
       easy_unlock_private::CreateSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   GetCryptoDelegate(browser_context())->CreateSecureMessage(
       *params,
       base::Bind(&EasyUnlockPrivateCreateSecureMessageFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivateCreateSecureMessageFunction::OnData(
     const std::string& message) {
   // TODO(tbarzic): Improve error handling.
   if (!message.empty()) {
     results_ = easy_unlock_private::CreateSecureMessage::Results::Create(
         std::vector<char>(message.begin(), message.end()));
   }
   SendResponse(true);
 }
 
 EasyUnlockPrivateUnwrapSecureMessageFunction::
 EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 
 EasyUnlockPrivateUnwrapSecureMessageFunction::
 ~EasyUnlockPrivateUnwrapSecureMessageFunction() {}
 
 bool EasyUnlockPrivateUnwrapSecureMessageFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::UnwrapSecureMessage::Params> params =
+  std::unique_ptr<easy_unlock_private::UnwrapSecureMessage::Params> params =
       easy_unlock_private::UnwrapSecureMessage::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   GetCryptoDelegate(browser_context())->UnwrapSecureMessage(
       *params,
       base::Bind(&EasyUnlockPrivateUnwrapSecureMessageFunction::OnData,
                  this));
   return true;
 }
 
 void EasyUnlockPrivateUnwrapSecureMessageFunction::OnData(
     const std::string& data) {
   // TODO(tbarzic): Improve error handling.
   if (!data.empty()) {
     results_ = easy_unlock_private::UnwrapSecureMessage::Results::Create(
         std::vector<char>(data.begin(), data.end()));
   }
   SendResponse(true);
 }
 
 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
     EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 
 EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::
     ~EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction() {}
 
 bool EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::SeekBluetoothDeviceByAddress::Params> params(
-      easy_unlock_private::SeekBluetoothDeviceByAddress::Params::Create(
+  std::unique_ptr<easy_unlock_private::SeekBluetoothDeviceByAddress::Params>
+      params(easy_unlock_private::SeekBluetoothDeviceByAddress::Params::Create(
           *args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   proximity_auth::bluetooth_util::SeekDeviceByAddress(
       params->device_address,
       base::Bind(
           &EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekSuccess,
           this),
       base::Bind(
           &EasyUnlockPrivateSeekBluetoothDeviceByAddressFunction::OnSeekFailure,
@@ skipping 34 matching lines @@
                  this));
 }
 
 EasyUnlockPrivateUpdateScreenlockStateFunction::
     EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
 EasyUnlockPrivateUpdateScreenlockStateFunction::
     ~EasyUnlockPrivateUpdateScreenlockStateFunction() {}
 
 bool EasyUnlockPrivateUpdateScreenlockStateFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::UpdateScreenlockState::Params> params(
+  std::unique_ptr<easy_unlock_private::UpdateScreenlockState::Params> params(
       easy_unlock_private::UpdateScreenlockState::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   if (EasyUnlockService::Get(profile)->UpdateScreenlockState(
           ToScreenlockState(params->state)))
     return true;
 
   SetError("Not allowed");
   return false;
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
     EasyUnlockPrivateSetPermitAccessFunction() {
 }
 
 EasyUnlockPrivateSetPermitAccessFunction::
     ~EasyUnlockPrivateSetPermitAccessFunction() {
 }
 
 bool EasyUnlockPrivateSetPermitAccessFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetPermitAccess::Params> params(
+  std::unique_ptr<easy_unlock_private::SetPermitAccess::Params> params(
       easy_unlock_private::SetPermitAccess::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)
       ->SetPermitAccess(*params->permit_access.ToValue());
 
   return true;
 }
 
 EasyUnlockPrivateGetPermitAccessFunction::
     EasyUnlockPrivateGetPermitAccessFunction() {
 }
 
 EasyUnlockPrivateGetPermitAccessFunction::
     ~EasyUnlockPrivateGetPermitAccessFunction() {
 }
 
 bool EasyUnlockPrivateGetPermitAccessFunction::RunSync() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           proximity_auth::switches::kEnableBluetoothLowEnergyDiscovery)) {
     ReturnPermitAccessForExperiment();
     return true;
   }
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   const base::DictionaryValue* permit_value =
       EasyUnlockService::Get(profile)->GetPermitAccess();
   if (permit_value) {
-    scoped_ptr<easy_unlock_private::PermitRecord> permit =
+    std::unique_ptr<easy_unlock_private::PermitRecord> permit =
         easy_unlock_private::PermitRecord::FromValue(*permit_value);
     results_ = easy_unlock_private::GetPermitAccess::Results::Create(*permit);
   }
 
   return true;
 }
 
 void EasyUnlockPrivateGetPermitAccessFunction::GetKeyPairForExperiment(
     std::string* user_public_key,
     std::string* user_private_key) {
@@ skipping 20 matching lines @@
     SendResponse(true);
     return;
   }
 
   std::string b64_public_key, b64_private_key;
   GetKeyPairForExperiment(&b64_public_key, &b64_private_key);
 
   // Fill in the permit access JSON dictionary.
   proximity_auth::ProximityAuthClient* client =
       easy_unlock_service->proximity_auth_client();
-  scoped_ptr<base::DictionaryValue> permit_access(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> permit_access(
+      new base::DictionaryValue());
   permit_access->SetString("permitId",
                            "permit://google.com/" + client->GetAccountId());
   permit_access->SetString("id", b64_public_key);
   permit_access->SetString("type", "access");
   permit_access->SetString("data", b64_private_key);
 
   PA_LOG(INFO) << "Returning permit access for "
                << "chrome.easyUnlockPrivate.getPermitAccess:\n"
                << "  id: " << b64_public_key;
 
-  scoped_ptr<easy_unlock_private::PermitRecord> result =
+  std::unique_ptr<easy_unlock_private::PermitRecord> result =
       easy_unlock_private::PermitRecord::FromValue(*permit_access);
   results_ = easy_unlock_private::GetPermitAccess::Results::Create(*result);
 }
 
 EasyUnlockPrivateClearPermitAccessFunction::
     EasyUnlockPrivateClearPermitAccessFunction() {
 }
 
 EasyUnlockPrivateClearPermitAccessFunction::
     ~EasyUnlockPrivateClearPermitAccessFunction() {
 }
 
 bool EasyUnlockPrivateClearPermitAccessFunction::RunSync() {
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)->ClearPermitAccess();
   return true;
 }
 
 EasyUnlockPrivateSetRemoteDevicesFunction::
     EasyUnlockPrivateSetRemoteDevicesFunction() {
 }
 
 EasyUnlockPrivateSetRemoteDevicesFunction::
     ~EasyUnlockPrivateSetRemoteDevicesFunction() {
 }
 
 bool EasyUnlockPrivateSetRemoteDevicesFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetRemoteDevices::Params> params(
+  std::unique_ptr<easy_unlock_private::SetRemoteDevices::Params> params(
       easy_unlock_private::SetRemoteDevices::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   base::ListValue devices;
   for (const easy_unlock_private::Device& device : params->devices)
     devices.Append(device.ToValue());
 
   // Store the BLE device if we are trying out the BLE experiment.
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 104 matching lines @@
     const std::string& persistent_symmetric_key) {
   std::string b64_public_key, b64_psk;
   base::Base64UrlEncode(device.public_key(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &b64_public_key);
   base::Base64UrlEncode(persistent_symmetric_key,
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &b64_psk);
 
   // Fill in the JSON dictionary containing a single unlock key's data.
-  scoped_ptr<base::DictionaryValue> device_dictionary(
+  std::unique_ptr<base::DictionaryValue> device_dictionary(
       new base::DictionaryValue());
   device_dictionary->SetString("name", device.friendly_device_name());
   device_dictionary->SetString("bluetoothAddress", device.bluetooth_address());
   device_dictionary->SetString("psk", b64_psk);
 
   // Fill in the permit license for the unlock key.
-  scoped_ptr<base::DictionaryValue> permit_license(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> permit_license(
+      new base::DictionaryValue());
   permit_license->SetString("permitId", permit_id_);
   permit_license->SetString("id", b64_public_key);
   permit_license->SetString("type", "license");
   permit_license->SetString("data", b64_public_key);
   device_dictionary->Set("permitRecord", std::move(permit_license));
 
   remote_devices_->Append(std::move(device_dictionary));
 
   // If all PSKs are derived, then return from the API call.
   PA_LOG(INFO) << "Derived PSK for " << b64_public_key << ": "
                << remote_devices_->GetSize() << "/" << expected_devices_count_;
   if (remote_devices_->GetSize() == expected_devices_count_) {
     SetResult(std::move(remote_devices_));
     SendResponse(true);
   }
 }
 
 EasyUnlockPrivateGetSignInChallengeFunction::
     EasyUnlockPrivateGetSignInChallengeFunction() {
 }
 
 EasyUnlockPrivateGetSignInChallengeFunction::
     ~EasyUnlockPrivateGetSignInChallengeFunction() {
 }
 
 bool EasyUnlockPrivateGetSignInChallengeFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::GetSignInChallenge::Params> params(
+  std::unique_ptr<easy_unlock_private::GetSignInChallenge::Params> params(
       easy_unlock_private::GetSignInChallenge::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
 #if defined(OS_CHROMEOS)
   Profile* profile = Profile::FromBrowserContext(browser_context());
   const std::string challenge =
       EasyUnlockService::Get(profile)->GetChallenge();
   if (!challenge.empty() && !params->nonce.empty()) {
     EasyUnlockTpmKeyManager* key_manager =
         EasyUnlockTpmKeyManagerFactory::GetInstance()->Get(profile);
@@ skipping 27 matching lines @@
 
 EasyUnlockPrivateTrySignInSecretFunction::
     EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 EasyUnlockPrivateTrySignInSecretFunction::
     ~EasyUnlockPrivateTrySignInSecretFunction() {
 }
 
 bool EasyUnlockPrivateTrySignInSecretFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::TrySignInSecret::Params> params(
+  std::unique_ptr<easy_unlock_private::TrySignInSecret::Params> params(
       easy_unlock_private::TrySignInSecret::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)->FinalizeSignin(std::string(
       params->sign_in_secret.begin(), params->sign_in_secret.end()));
   return true;
 }
 
 EasyUnlockPrivateGetUserInfoFunction::EasyUnlockPrivateGetUserInfoFunction() {
@@ skipping 32 matching lines @@
 EasyUnlockPrivateGetConnectionInfoFunction::
     EasyUnlockPrivateGetConnectionInfoFunction() {
 }
 
 EasyUnlockPrivateGetConnectionInfoFunction::
     ~EasyUnlockPrivateGetConnectionInfoFunction() {
 }
 
 bool EasyUnlockPrivateGetConnectionInfoFunction::DoWork(
     scoped_refptr<device::BluetoothAdapter> adapter) {
-  scoped_ptr<easy_unlock_private::GetConnectionInfo::Params> params =
+  std::unique_ptr<easy_unlock_private::GetConnectionInfo::Params> params =
       easy_unlock_private::GetConnectionInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   device::BluetoothDevice* device = adapter->GetDevice(params->device_address);
 
   std::string error;
   if (!device)
     error = "Invalid Bluetooth device.";
   else if (!device->IsConnected())
     error = "Bluetooth device not connected.";
 
   if (!error.empty()) {
     SetError(error);
     SendResponse(false);
     return true;
   }
 
   device->GetConnectionInfo(base::Bind(
       &EasyUnlockPrivateGetConnectionInfoFunction::OnConnectionInfo, this));
   return false;
 }
 
 void EasyUnlockPrivateGetConnectionInfoFunction::OnConnectionInfo(
     const device::BluetoothDevice::ConnectionInfo& connection_info) {
-  scoped_ptr<base::ListValue> results(new base::ListValue());
+  std::unique_ptr<base::ListValue> results(new base::ListValue());
   results->AppendInteger(connection_info.rssi);
   results->AppendInteger(connection_info.transmit_power);
   results->AppendInteger(connection_info.max_transmit_power);
   SetResultList(std::move(results));
   SendResponse(true);
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     EasyUnlockPrivateShowErrorBubbleFunction() {
 }
 
 EasyUnlockPrivateShowErrorBubbleFunction::
     ~EasyUnlockPrivateShowErrorBubbleFunction() {
 }
 
 bool EasyUnlockPrivateShowErrorBubbleFunction::RunSync() {
   content::WebContents* web_contents = GetAssociatedWebContents();
   if (!web_contents) {
     SetError("A foreground app window is required.");
     return true;
   }
 
-  scoped_ptr<easy_unlock_private::ShowErrorBubble::Params> params(
+  std::unique_ptr<easy_unlock_private::ShowErrorBubble::Params> params(
       easy_unlock_private::ShowErrorBubble::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   if (params->link_range.start < 0 ||
       params->link_range.end < 0 ||
       base::saturated_cast<size_t>(params->link_range.end) >
           params->message.size()) {
     SetError("Invalid link range.");
     return true;
   }
@@ skipping 33 matching lines @@
 
 EasyUnlockPrivateSetAutoPairingResultFunction::
     EasyUnlockPrivateSetAutoPairingResultFunction() {
 }
 
 EasyUnlockPrivateSetAutoPairingResultFunction::
     ~EasyUnlockPrivateSetAutoPairingResultFunction() {
 }
 
 bool EasyUnlockPrivateSetAutoPairingResultFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetAutoPairingResult::Params> params =
+  std::unique_ptr<easy_unlock_private::SetAutoPairingResult::Params> params =
       easy_unlock_private::SetAutoPairingResult::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   std::string error_message;
   if (params->result.error_message)
     error_message = *params->result.error_message;
 
   Profile* profile = Profile::FromBrowserContext(browser_context());
   EasyUnlockService::Get(profile)
       ->SetAutoPairingResult(params->result.success, error_message);
 
   return true;
 }
 
 EasyUnlockPrivateFindSetupConnectionFunction::
     EasyUnlockPrivateFindSetupConnectionFunction()
     : bluetooth_throttler_(new proximity_auth::BluetoothThrottlerImpl(
-          make_scoped_ptr(new base::DefaultTickClock()))) {}
+          base::WrapUnique(new base::DefaultTickClock()))) {}
 
 EasyUnlockPrivateFindSetupConnectionFunction::
     ~EasyUnlockPrivateFindSetupConnectionFunction() {
   // |connection_finder_| has a raw pointer to |bluetooth_throttler_|, so it
   // should be destroyed first.
   connection_finder_.reset();
   bluetooth_throttler_.reset();
 }
 
 void EasyUnlockPrivateFindSetupConnectionFunction::
     OnConnectionFinderTimedOut() {
   SetError("No connection found.");
   connection_finder_.reset();
   SendResponse(false);
 }
 
 void EasyUnlockPrivateFindSetupConnectionFunction::OnConnectionFound(
-    scoped_ptr<proximity_auth::Connection> connection) {
+    std::unique_ptr<proximity_auth::Connection> connection) {
   // Connection are not persistent by default.
   std::string device_address = connection->remote_device().bluetooth_address;
   bool persistent = false;
   int connection_id =
       GetConnectionManager(browser_context())
           ->AddConnection(extension(), std::move(connection), persistent);
   results_ = easy_unlock_private::FindSetupConnection::Results::Create(
       connection_id, device_address);
   SendResponse(true);
 }
 
 bool EasyUnlockPrivateFindSetupConnectionFunction::RunAsync() {
-  scoped_ptr<easy_unlock_private::FindSetupConnection::Params> params =
+  std::unique_ptr<easy_unlock_private::FindSetupConnection::Params> params =
       easy_unlock_private::FindSetupConnection::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // Creates a BLE connection finder to look for any device advertising
   // |params->setup_service_uuid|.
   connection_finder_.reset(
       new proximity_auth::BluetoothLowEnergyConnectionFinder(
           proximity_auth::RemoteDevice(), params->setup_service_uuid,
           proximity_auth::BluetoothLowEnergyConnectionFinder::FIND_ANY_DEVICE,
           nullptr, bluetooth_throttler_.get(), 3));
@@ skipping 10 matching lines @@
   return true;
 }
 
 EasyUnlockPrivateSetupConnectionStatusFunction::
     EasyUnlockPrivateSetupConnectionStatusFunction() {}
 
 EasyUnlockPrivateSetupConnectionStatusFunction::
     ~EasyUnlockPrivateSetupConnectionStatusFunction() {}
 
 bool EasyUnlockPrivateSetupConnectionStatusFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetupConnectionStatus::Params> params =
+  std::unique_ptr<easy_unlock_private::SetupConnectionStatus::Params> params =
       easy_unlock_private::SetupConnectionStatus::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   api::easy_unlock_private::ConnectionStatus status =
       GetConnectionManager(browser_context())
           ->ConnectionStatus(extension(), params->connection_id);
   results_ =
       easy_unlock_private::SetupConnectionStatus::Results::Create(status);
   if (status == api::easy_unlock_private::CONNECTION_STATUS_NONE)
     SetError("Invalid connectionId");
   return true;
 }
 
 EasyUnlockPrivateSetupConnectionDisconnectFunction::
     EasyUnlockPrivateSetupConnectionDisconnectFunction() {}
 
 EasyUnlockPrivateSetupConnectionDisconnectFunction::
     ~EasyUnlockPrivateSetupConnectionDisconnectFunction() {}
 
 bool EasyUnlockPrivateSetupConnectionDisconnectFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetupConnectionDisconnect::Params> params =
-      easy_unlock_private::SetupConnectionDisconnect::Params::Create(*args_);
+  std::unique_ptr<easy_unlock_private::SetupConnectionDisconnect::Params>
+      params = easy_unlock_private::SetupConnectionDisconnect::Params::Create(
+          *args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   bool success = GetConnectionManager(browser_context())
                      ->Disconnect(extension(), params->connection_id);
   if (!success)
     SetError("Invalid connectionId.");
   return true;
 }
 
 EasyUnlockPrivateSetupConnectionSendFunction::
     EasyUnlockPrivateSetupConnectionSendFunction() {}
 
 EasyUnlockPrivateSetupConnectionSendFunction::
     ~EasyUnlockPrivateSetupConnectionSendFunction() {}
 
 bool EasyUnlockPrivateSetupConnectionSendFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetupConnectionSend::Params> params =
+  std::unique_ptr<easy_unlock_private::SetupConnectionSend::Params> params =
       easy_unlock_private::SetupConnectionSend::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string payload(params->data.begin(), params->data.end());
   bool success = GetConnectionManager(browser_context())
                      ->SendMessage(extension(), params->connection_id, payload);
   if (!success)
     SetError("Invalid connectionId.");
   return true;
 }
 
 EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::
     EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction() {}
 
 EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::
     ~EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction() {}
 
 bool EasyUnlockPrivateSetupConnectionGetDeviceAddressFunction::RunSync() {
-  scoped_ptr<easy_unlock_private::SetupConnectionGetDeviceAddress::Params>
+  std::unique_ptr<easy_unlock_private::SetupConnectionGetDeviceAddress::Params>
       params =
           easy_unlock_private::SetupConnectionGetDeviceAddress::Params::Create(
               *args_);
   EXTENSION_FUNCTION_VALIDATE(params);
   std::string device_address =
       GetConnectionManager(browser_context())
           ->GetDeviceAddress(extension(), params->connection_id);
   results_ =
       easy_unlock_private::SetupConnectionGetDeviceAddress::Results::Create(
           device_address);
   if (device_address.empty())
     SetError("Invalid connectionId.");
   return true;
 }
 
 }  // namespace extensions