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

extensions/browser/api/networking_private/networking_private_service_client.cc

 // Copyright 2013 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_service_client.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/sequenced_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "components/onc/onc_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/api/networking_private/networking_private_delegate_observer.h"
 
 using content::BrowserThread;
 using wifi::WiFiService;
 
 namespace extensions {
 
 namespace {
 
 const char kNetworkingPrivateSequenceTokenName[] = "NetworkingPrivate";
 
 // Deletes WiFiService object on the worker thread.
-void ShutdownWifiServiceOnWorkerThread(scoped_ptr<WiFiService> wifi_service) {
+void ShutdownWifiServiceOnWorkerThread(
+    std::unique_ptr<WiFiService> wifi_service) {
   DCHECK(wifi_service.get());
 }
 
 }  // namespace
 
 NetworkingPrivateServiceClient::ServiceCallbacks::ServiceCallbacks() {
 }
 
 NetworkingPrivateServiceClient::ServiceCallbacks::~ServiceCallbacks() {
 }
 
 NetworkingPrivateServiceClient::NetworkingPrivateServiceClient(
-    scoped_ptr<WiFiService> wifi_service,
-    scoped_ptr<VerifyDelegate> verify_delegate)
+    std::unique_ptr<WiFiService> wifi_service,
+    std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
       wifi_service_(std::move(wifi_service)),
       weak_factory_(this) {
   sequence_token_ = BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
       kNetworkingPrivateSequenceTokenName);
   task_runner_ =
       BrowserThread::GetBlockingPool()
           ->GetSequencedTaskRunnerWithShutdownBehavior(
               sequence_token_, base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   task_runner_->PostTask(
@@ skipping 65 matching lines @@
 // NetworkingPrivateServiceClient implementation
 
 void NetworkingPrivateServiceClient::GetProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->get_properties_callback = success_callback;
 
-  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   base::DictionaryValue* properties_ptr = properties.get();
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&WiFiService::GetProperties,
                             base::Unretained(wifi_service_.get()), guid,
                             properties_ptr, error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(), service_callbacks->id, guid,
                  base::Passed(&properties), base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::GetManagedProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->get_properties_callback = success_callback;
 
-  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   base::DictionaryValue* properties_ptr = properties.get();
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&WiFiService::GetManagedProperties,
                             base::Unretained(wifi_service_.get()), guid,
                             properties_ptr, error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(), service_callbacks->id, guid,
                  base::Passed(&properties), base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::GetState(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->get_properties_callback = success_callback;
 
-  scoped_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> properties(new base::DictionaryValue);
   std::string* error = new std::string;
 
   base::DictionaryValue* properties_ptr = properties.get();
   task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&WiFiService::GetState, base::Unretained(wifi_service_.get()),
                  guid, properties_ptr, error),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetProperties,
                  weak_factory_.GetWeakPtr(), service_callbacks->id, guid,
                  base::Passed(&properties), base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::SetProperties(
     const std::string& guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->set_properties_callback = success_callback;
 
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&WiFiService::SetProperties,
                             base::Unretained(wifi_service_.get()), guid,
                             base::Passed(&properties), error),
       base::Bind(&NetworkingPrivateServiceClient::AfterSetProperties,
                  weak_factory_.GetWeakPtr(), service_callbacks->id,
                  base::Owned(error)));
 }
 
 void NetworkingPrivateServiceClient::CreateNetwork(
     bool shared,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const StringCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->create_network_callback = success_callback;
 
   std::string* network_guid = new std::string;
   std::string* error = new std::string;
 
   task_runner_->PostTaskAndReply(
@@ skipping 17 matching lines @@
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
   ServiceCallbacks* service_callbacks = AddServiceCallbacks();
   service_callbacks->failure_callback = failure_callback;
   service_callbacks->get_visible_networks_callback = success_callback;
 
-  scoped_ptr<base::ListValue> networks(new base::ListValue);
+  std::unique_ptr<base::ListValue> networks(new base::ListValue);
 
   // TODO(stevenjb/mef): Apply filters (configured, visible, limit).
 
   base::ListValue* networks_ptr = networks.get();
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&WiFiService::GetVisibleNetworks,
                             base::Unretained(wifi_service_.get()), network_type,
                             networks_ptr, false),
       base::Bind(&NetworkingPrivateServiceClient::AfterGetVisibleNetworks,
                  weak_factory_.GetWeakPtr(), service_callbacks->id,
@@ skipping 70 matching lines @@
 void NetworkingPrivateServiceClient::SetCellularSimState(
     const std::string& guid,
     bool require_pin,
     const std::string& current_pin,
     const std::string& new_pin,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   failure_callback.Run(networking_private::kErrorNotSupported);
 }
 
-scoped_ptr<base::ListValue>
+std::unique_ptr<base::ListValue>
 NetworkingPrivateServiceClient::GetEnabledNetworkTypes() {
-  scoped_ptr<base::ListValue> network_list;
+  std::unique_ptr<base::ListValue> network_list;
   network_list->AppendString(::onc::network_type::kWiFi);
   return network_list;
 }
 
-scoped_ptr<NetworkingPrivateDelegate::DeviceStateList>
+std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList>
 NetworkingPrivateServiceClient::GetDeviceStateList() {
-  scoped_ptr<DeviceStateList> device_state_list(new DeviceStateList);
-  scoped_ptr<api::networking_private::DeviceStateProperties> properties(
+  std::unique_ptr<DeviceStateList> device_state_list(new DeviceStateList);
+  std::unique_ptr<api::networking_private::DeviceStateProperties> properties(
       new api::networking_private::DeviceStateProperties);
   properties->type = api::networking_private::NETWORK_TYPE_WIFI;
   properties->state = api::networking_private::DEVICE_STATE_TYPE_ENABLED;
   device_state_list->push_back(std::move(properties));
   return device_state_list;
 }
 
 bool NetworkingPrivateServiceClient::EnableNetworkType(
     const std::string& type) {
   return false;
 }
 
 bool NetworkingPrivateServiceClient::DisableNetworkType(
     const std::string& type) {
   return false;
 }
 
 bool NetworkingPrivateServiceClient::RequestScan() {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&WiFiService::RequestNetworkScan,
                                     base::Unretained(wifi_service_.get())));
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void NetworkingPrivateServiceClient::AfterGetProperties(
     ServiceCallbacksID callback_id,
     const std::string& network_guid,
-    scoped_ptr<base::DictionaryValue> properties,
+    std::unique_ptr<base::DictionaryValue> properties,
     const std::string* error) {
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   if (!error->empty()) {
     DCHECK(!service_callbacks->failure_callback.is_null());
     service_callbacks->failure_callback.Run(*error);
   } else {
     DCHECK(!service_callbacks->get_properties_callback.is_null());
     service_callbacks->get_properties_callback.Run(std::move(properties));
   }
   RemoveServiceCallbacks(callback_id);
 }
 
 void NetworkingPrivateServiceClient::AfterGetVisibleNetworks(
     ServiceCallbacksID callback_id,
-    scoped_ptr<base::ListValue> networks) {
+    std::unique_ptr<base::ListValue> networks) {
   ServiceCallbacks* service_callbacks = callbacks_map_.Lookup(callback_id);
   DCHECK(service_callbacks);
   DCHECK(!service_callbacks->get_visible_networks_callback.is_null());
   service_callbacks->get_visible_networks_callback.Run(std::move(networks));
   RemoveServiceCallbacks(callback_id);
 }
 
 void NetworkingPrivateServiceClient::AfterSetProperties(
     ServiceCallbacksID callback_id,
     const std::string* error) {
@@ skipping 65 matching lines @@
 
 void NetworkingPrivateServiceClient::OnNetworkListChangedEventOnUIThread(
     const std::vector<std::string>& network_guids) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   FOR_EACH_OBSERVER(NetworkingPrivateDelegateObserver,
                     network_events_observers_,
                     OnNetworkListChangedEvent(network_guids));
 }
 
 }  // namespace extensions