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

extensions/browser/api/networking_private/networking_private_chromeos.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/networking_private/networking_private_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 108 matching lines @@
       state = private_api::DEVICE_STATE_TYPE_ENABLING;
       break;
     case NetworkStateHandler::TECHNOLOGY_ENABLED:
       state = private_api::DEVICE_STATE_TYPE_ENABLED;
       break;
     case NetworkStateHandler::TECHNOLOGY_PROHIBITED:
       state = private_api::DEVICE_STATE_TYPE_PROHIBITED;
       break;
   }
   DCHECK_NE(private_api::DEVICE_STATE_TYPE_NONE, state);
-  scoped_ptr<private_api::DeviceStateProperties> properties(
+  std::unique_ptr<private_api::DeviceStateProperties> properties(
       new private_api::DeviceStateProperties);
   properties->type = private_api::ParseNetworkType(type);
   properties->state = state;
   if (device && state == private_api::DEVICE_STATE_TYPE_ENABLED)
     properties->scanning.reset(new bool(device->scanning()));
   if (device && type == ::onc::network_config::kCellular) {
     properties->sim_present.reset(new bool(!device->IsSimAbsent()));
     if (!device->sim_lock_type().empty())
       properties->sim_lock_type.reset(new std::string(device->sim_lock_type()));
   }
   device_state_list->push_back(std::move(properties));
 }
 
 void NetworkHandlerFailureCallback(
     const NetworkingPrivateDelegate::FailureCallback& callback,
     const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
+    std::unique_ptr<base::DictionaryValue> error_data) {
   callback.Run(error_name);
 }
 
 void RequirePinSuccess(
     const std::string& device_path,
     const std::string& current_pin,
     const std::string& new_pin,
     const extensions::NetworkingPrivateChromeOS::VoidCallback& success_callback,
     const extensions::NetworkingPrivateChromeOS::FailureCallback&
         failure_callback) {
@@ skipping 43 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
-    scoped_ptr<VerifyDelegate> verify_delegate)
+    std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
       browser_context_(browser_context),
       weak_ptr_factory_(this) {}
 
 NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {
 }
 
 void NetworkingPrivateChromeOS::GetProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
@@ skipping 51 matching lines @@
   }
 
   const chromeos::NetworkState* network_state =
       GetStateHandler()->GetNetworkStateFromServicePath(
           service_path, false /* configured_only */);
   if (!network_state) {
     failure_callback.Run(networking_private::kErrorNetworkUnavailable);
     return;
   }
 
-  scoped_ptr<base::DictionaryValue> network_properties =
+  std::unique_ptr<base::DictionaryValue> network_properties =
       chromeos::network_util::TranslateNetworkStateToONC(network_state);
   AppendThirdPartyProviderName(network_properties.get());
 
   success_callback.Run(std::move(network_properties));
 }
 
 void NetworkingPrivateChromeOS::SetProperties(
     const std::string& guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->SetProperties(
       service_path, *properties, success_callback,
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkHandlerCreateCallback(
     const NetworkingPrivateDelegate::StringCallback& callback,
     const std::string& service_path,
     const std::string& guid) {
   callback.Run(guid);
 }
 
 void NetworkingPrivateChromeOS::CreateNetwork(
     bool shared,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string user_id_hash, error;
   // Do not allow configuring a non-shared network from a non-primary user.
   if (!shared &&
       !GetPrimaryUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
@@ skipping 20 matching lines @@
 
 void NetworkingPrivateChromeOS::GetNetworks(
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
   NetworkTypePattern pattern =
       chromeos::onc::NetworkTypePatternFromOncType(network_type);
-  scoped_ptr<base::ListValue> network_properties_list =
+  std::unique_ptr<base::ListValue> network_properties_list =
       chromeos::network_util::TranslateNetworkListToONC(
           pattern, configured_only, visible_only, limit);
 
   for (base::Value* value : *network_properties_list) {
     base::DictionaryValue* network_dict = nullptr;
     value->GetAsDictionary(&network_dict);
     DCHECK(network_dict);
     if (GetThirdPartyVPNDictionary(network_dict))
       AppendThirdPartyProviderName(network_dict);
   }
@@ skipping 176 matching lines @@
 
   // Only set a new pin if require_pin is true.
   std::string set_new_pin = require_pin ? new_pin : "";
   NetworkHandler::Get()->network_device_handler()->RequirePin(
       device_state->path(), require_pin, current_pin,
       base::Bind(&RequirePinSuccess, device_state->path(), current_pin,
                  set_new_pin, success_callback, failure_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
-scoped_ptr<base::ListValue>
+std::unique_ptr<base::ListValue>
 NetworkingPrivateChromeOS::GetEnabledNetworkTypes() {
   chromeos::NetworkStateHandler* state_handler = GetStateHandler();
 
-  scoped_ptr<base::ListValue> network_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> network_list(new base::ListValue);
 
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Ethernet()))
     network_list->AppendString(::onc::network_type::kEthernet);
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()))
     network_list->AppendString(::onc::network_type::kWiFi);
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()))
     network_list->AppendString(::onc::network_type::kWimax);
   if (state_handler->IsTechnologyEnabled(NetworkTypePattern::Cellular()))
     network_list->AppendString(::onc::network_type::kCellular);
 
   return network_list;
 }
 
-scoped_ptr<NetworkingPrivateDelegate::DeviceStateList>
+std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList>
 NetworkingPrivateChromeOS::GetDeviceStateList() {
   std::set<std::string> technologies_found;
   NetworkStateHandler::DeviceStateList devices;
   NetworkHandler::Get()->network_state_handler()->GetDeviceList(&devices);
 
-  scoped_ptr<DeviceStateList> device_state_list(new DeviceStateList);
+  std::unique_ptr<DeviceStateList> device_state_list(new DeviceStateList);
   for (const DeviceState* device : devices) {
     std::string onc_type =
         chromeos::network_util::TranslateShillTypeToONC(device->type());
     AppendDeviceState(onc_type, device, device_state_list.get());
     technologies_found.insert(onc_type);
   }
 
   // For any technologies that we do not have a DeviceState entry for, append
   // an entry if the technolog is available.
   const char* technology_types[] = {::onc::network_type::kEthernet,
@@ skipping 33 matching lines @@
   GetStateHandler()->RequestScan();
   return true;
 }
 
 // Private methods
 
 void NetworkingPrivateChromeOS::GetPropertiesCallback(
     const DictionaryCallback& callback,
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
-  scoped_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
+  std::unique_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
   AppendThirdPartyProviderName(dictionary_copy.get());
   callback.Run(std::move(dictionary_copy));
 }
 
 // Populate ThirdPartyVPN.kProviderName for third-party VPNs.
 void NetworkingPrivateChromeOS::AppendThirdPartyProviderName(
     base::DictionaryValue* dictionary) {
   base::DictionaryValue* third_party_vpn =
       GetThirdPartyVPNDictionary(dictionary);
   if (!third_party_vpn)
@@ skipping 12 matching lines @@
       break;
     }
   }
 }
 
 void NetworkingPrivateChromeOS::ConnectFailureCallback(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback,
     const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
+    std::unique_ptr<base::DictionaryValue> error_data) {
   // TODO(stevenjb): Temporary workaround to show the configuration UI.
   // Eventually the caller (e.g. Settings) should handle any failures and
   // show its own configuration UI. crbug.com/380937.
   if (ui_delegate()->HandleConnectFailed(guid, error_name)) {
     success_callback.Run();
     return;
   }
   failure_callback.Run(error_name);
 }
 
 }  // namespace extensions