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

extensions/browser/api/vpn_provider/vpn_provider_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/vpn_provider/vpn_provider_api.h"
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "extensions/browser/api/vpn_provider/vpn_service.h"
 #include "extensions/browser/api/vpn_provider/vpn_service_factory.h"
 #include "extensions/common/api/vpn_provider.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace extensions {
 
@@ skipping 160 matching lines @@
     Respond(Error(error_name));
   } else {
     Respond(Error(error_message));
   }
 }
 
 VpnProviderCreateConfigFunction::~VpnProviderCreateConfigFunction() {
 }
 
 ExtensionFunction::ResponseAction VpnProviderCreateConfigFunction::Run() {
-  scoped_ptr<api_vpn::CreateConfig::Params> params(
+  std::unique_ptr<api_vpn::CreateConfig::Params> params(
       api_vpn::CreateConfig::Params::Create(*args_));
   if (!params) {
     return RespondNow(Error("Invalid arguments."));
   }
 
   chromeos::VpnService* service =
       chromeos::VpnServiceFactory::GetForBrowserContext(browser_context());
   if (!service) {
     return RespondNow(Error("Invalid profile."));
   }
 
   // Use the configuration name as ID. In the future, a different ID scheme may
   // be used, requiring a mapping between the two.
   service->CreateConfiguration(
       extension_id(), extension()->name(), params->name,
       base::Bind(
           &VpnProviderCreateConfigFunction::SignalCallCompletionSuccessWithId,
           this, params->name),
       base::Bind(&VpnProviderNotifyConnectionStateChangedFunction::
                      SignalCallCompletionFailure,
                  this));
 
   return RespondLater();
 }
 
 VpnProviderDestroyConfigFunction::~VpnProviderDestroyConfigFunction() {
 }
 
 ExtensionFunction::ResponseAction VpnProviderDestroyConfigFunction::Run() {
-  scoped_ptr<api_vpn::DestroyConfig::Params> params(
+  std::unique_ptr<api_vpn::DestroyConfig::Params> params(
       api_vpn::DestroyConfig::Params::Create(*args_));
   if (!params) {
     return RespondNow(Error("Invalid arguments."));
   }
 
   chromeos::VpnService* service =
       chromeos::VpnServiceFactory::GetForBrowserContext(browser_context());
   if (!service) {
     return RespondNow(Error("Invalid profile."));
   }
 
   service->DestroyConfiguration(
       extension_id(), params->id,
       base::Bind(&VpnProviderDestroyConfigFunction::SignalCallCompletionSuccess,
                  this),
       base::Bind(&VpnProviderNotifyConnectionStateChangedFunction::
                      SignalCallCompletionFailure,
                  this));
 
   return RespondLater();
 }
 
 VpnProviderSetParametersFunction::~VpnProviderSetParametersFunction() {
 }
 
 ExtensionFunction::ResponseAction VpnProviderSetParametersFunction::Run() {
-  scoped_ptr<api_vpn::SetParameters::Params> params(
+  std::unique_ptr<api_vpn::SetParameters::Params> params(
       api_vpn::SetParameters::Params::Create(*args_));
   if (!params) {
     return RespondNow(Error("Invalid arguments."));
   }
 
   chromeos::VpnService* service =
       chromeos::VpnServiceFactory::GetForBrowserContext(browser_context());
   if (!service) {
     return RespondNow(Error("Invalid profile."));
   }
@@ skipping 14 matching lines @@
                      SignalCallCompletionFailure,
                  this));
 
   return RespondLater();
 }
 
 VpnProviderSendPacketFunction::~VpnProviderSendPacketFunction() {
 }
 
 ExtensionFunction::ResponseAction VpnProviderSendPacketFunction::Run() {
-  scoped_ptr<api_vpn::SendPacket::Params> params(
+  std::unique_ptr<api_vpn::SendPacket::Params> params(
       api_vpn::SendPacket::Params::Create(*args_));
   if (!params) {
     return RespondNow(Error("Invalid arguments."));
   }
 
   chromeos::VpnService* service =
       chromeos::VpnServiceFactory::GetForBrowserContext(browser_context());
   if (!service) {
     return RespondNow(Error("Invalid profile."));
   }
 
   service->SendPacket(
       extension_id(), params->data,
       base::Bind(&VpnProviderSendPacketFunction::SignalCallCompletionSuccess,
                  this),
       base::Bind(&VpnProviderNotifyConnectionStateChangedFunction::
                      SignalCallCompletionFailure,
                  this));
 
   return RespondLater();
 }
 
 VpnProviderNotifyConnectionStateChangedFunction::
     ~VpnProviderNotifyConnectionStateChangedFunction() {
 }
 
 ExtensionFunction::ResponseAction
 VpnProviderNotifyConnectionStateChangedFunction::Run() {
-  scoped_ptr<api_vpn::NotifyConnectionStateChanged::Params> params(
+  std::unique_ptr<api_vpn::NotifyConnectionStateChanged::Params> params(
       api_vpn::NotifyConnectionStateChanged::Params::Create(*args_));
   if (!params) {
     return RespondNow(Error("Invalid arguments."));
   }
 
   chromeos::VpnService* service =
       chromeos::VpnServiceFactory::GetForBrowserContext(browser_context());
   if (!service) {
     return RespondNow(Error("Invalid profile."));
   }
 
   service->NotifyConnectionStateChanged(
       extension_id(), params->state,
       base::Bind(&VpnProviderNotifyConnectionStateChangedFunction::
                      SignalCallCompletionSuccess,
                  this),
       base::Bind(&VpnProviderNotifyConnectionStateChangedFunction::
                      SignalCallCompletionFailure,
                  this));
 
   return RespondLater();
 }
 
 }  // namespace extensions