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

extensions/browser/api/vpn_provider/vpn_service.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/vpn_provider/vpn_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 81 matching lines @@
 }
 
 VpnService::VpnConfiguration::~VpnConfiguration() {
 }
 
 void VpnService::VpnConfiguration::OnPacketReceived(
     const std::vector<char>& data) {
   if (!vpn_service_) {
     return;
   }
-  scoped_ptr<base::ListValue> event_args =
+  std::unique_ptr<base::ListValue> event_args =
       api_vpn::OnPacketReceived::Create(data);
   vpn_service_->SendSignalToExtension(
       extension_id_, extensions::events::VPN_PROVIDER_ON_PACKET_RECEIVED,
       api_vpn::OnPacketReceived::kEventName, std::move(event_args));
 }
 
 void VpnService::VpnConfiguration::OnPlatformMessage(uint32_t message) {
   if (!vpn_service_) {
     return;
   }
   DCHECK_GE(api_vpn::PLATFORM_MESSAGE_LAST, message);
 
   api_vpn::PlatformMessage platform_message =
       static_cast<api_vpn::PlatformMessage>(message);
 
   if (platform_message == api_vpn::PLATFORM_MESSAGE_CONNECTED) {
     vpn_service_->SetActiveConfiguration(this);
   } else if (platform_message == api_vpn::PLATFORM_MESSAGE_DISCONNECTED ||
              platform_message == api_vpn::PLATFORM_MESSAGE_ERROR) {
     vpn_service_->SetActiveConfiguration(nullptr);
   }
 
   // TODO(kaliamoorthi): Update the lower layers to get the error message and
   // pass in the error instead of std::string().
-  scoped_ptr<base::ListValue> event_args = api_vpn::OnPlatformMessage::Create(
-      configuration_name_, platform_message, std::string());
+  std::unique_ptr<base::ListValue> event_args =
+      api_vpn::OnPlatformMessage::Create(configuration_name_, platform_message,
+                                         std::string());
 
   vpn_service_->SendSignalToExtension(
       extension_id_, extensions::events::VPN_PROVIDER_ON_PLATFORM_MESSAGE,
       api_vpn::OnPlatformMessage::kEventName, std::move(event_args));
 }
 
 VpnService::VpnService(
     content::BrowserContext* browser_context,
     const std::string& userid_hash,
     extensions::ExtensionRegistry* extension_registry,
@@ skipping 79 matching lines @@
 
   if (service_path_to_configuration_map_.find(service_path) ==
       service_path_to_configuration_map_.end()) {
     // Ignore removal of a configuration unknown to VPN service, which means the
     // configuration was created internally by the platform.
     return;
   }
 
   VpnConfiguration* configuration =
       service_path_to_configuration_map_[service_path];
-  scoped_ptr<base::ListValue> event_args =
+  std::unique_ptr<base::ListValue> event_args =
       api_vpn::OnConfigRemoved::Create(configuration->configuration_name());
   SendSignalToExtension(configuration->extension_id(),
                         extensions::events::VPN_PROVIDER_ON_CONFIG_REMOVED,
                         api_vpn::OnConfigRemoved::kEventName,
                         std::move(event_args));
 
   DestroyConfigurationInternal(configuration);
 }
 
 void VpnService::OnPropertiesSet(const std::string& service_path,
@@ skipping 36 matching lines @@
   VpnConfiguration* configuration =
       CreateConfigurationInternal(extension_id, configuration_name, key);
   configuration->set_service_path(service_path);
   service_path_to_configuration_map_[service_path] = configuration;
   shill_client_->AddShillThirdPartyVpnObserver(configuration->object_path(),
                                                configuration);
 }
 
 void VpnService::OnGetPropertiesFailure(
     const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
-}
+    std::unique_ptr<base::DictionaryValue> error_data) {}
 
 void VpnService::NetworkListChanged() {
   NetworkStateHandler::NetworkStateList network_list;
   network_state_handler_->GetVisibleNetworkListByType(NetworkTypePattern::VPN(),
                                                       &network_list);
   for (auto& iter : network_list) {
     if (service_path_to_configuration_map_.find(iter->path()) !=
         service_path_to_configuration_map_.end()) {
       continue;
     }
@@ skipping 208 matching lines @@
   service_path_to_configuration_map_[service_path] = configuration;
   shill_client_->AddShillThirdPartyVpnObserver(configuration->object_path(),
                                                configuration);
   callback.Run();
 }
 
 void VpnService::OnCreateConfigurationFailure(
     const VpnService::FailureCallback& callback,
     VpnConfiguration* configuration,
     const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
+    std::unique_ptr<base::DictionaryValue> error_data) {
   DestroyConfigurationInternal(configuration);
   callback.Run(error_name, std::string());
 }
 
 void VpnService::OnRemoveConfigurationSuccess(
     const VpnService::SuccessCallback& callback) {
   callback.Run();
 }
 
 void VpnService::OnRemoveConfigurationFailure(
     const VpnService::FailureCallback& callback,
     const std::string& error_name,
-    scoped_ptr<base::DictionaryValue> error_data) {
+    std::unique_ptr<base::DictionaryValue> error_data) {
   callback.Run(error_name, std::string());
 }
 
 void VpnService::SendSignalToExtension(
     const std::string& extension_id,
     extensions::events::HistogramValue histogram_value,
     const std::string& event_name,
-    scoped_ptr<base::ListValue> event_args) {
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+    std::unique_ptr<base::ListValue> event_args) {
+  std::unique_ptr<extensions::Event> event(new extensions::Event(
       histogram_value, event_name, std::move(event_args), browser_context_));
 
   event_router_->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void VpnService::SetActiveConfiguration(
     VpnService::VpnConfiguration* configuration) {
   active_configuration_ = configuration;
 }
 
@@ skipping 21 matching lines @@
   delete configuration;
 }
 
 bool VpnService::DoesActiveConfigurationExistAndIsAccessAuthorized(
     const std::string& extension_id) {
   return active_configuration_ &&
          active_configuration_->extension_id() == extension_id;
 }
 
 }  // namespace chromeos