extensions: Use stl utilities from the base namespace

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 225 matching lines @@
   network_configuration_handler_->AddObserver(this);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&VpnService::NetworkListChanged, weak_factory_.GetWeakPtr()));
 }
 
 VpnService::~VpnService() {
   network_configuration_handler_->RemoveObserver(this);
   network_state_handler_->RemoveObserver(this, FROM_HERE);
   extension_registry_->RemoveObserver(this);
-  STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
-                                       key_to_configuration_map_.end());
+  base::STLDeleteContainerPairSecondPointers(key_to_configuration_map_.begin(),
+                                             key_to_configuration_map_.end());
 }
 
 void VpnService::SendShowAddDialogToExtension(const std::string& extension_id) {
   SendSignalToExtension(extension_id,
                         extensions::events::VPN_PROVIDER_ON_UI_EVENT,
                         api_vpn::OnUIEvent::kEventName,
                         api_vpn::OnUIEvent::Create(
                             api_vpn::UI_EVENT_SHOWADDDIALOG, std::string()));
 }
 
@@ skipping 128 matching lines @@
                                      const std::string& extension_name,
                                      const std::string& configuration_name,
                                      const SuccessCallback& success,
                                      const FailureCallback& failure) {
   if (configuration_name.empty()) {
     failure.Run(std::string(), std::string("Empty name not supported."));
     return;
   }
 
   const std::string key = GetKey(extension_id, configuration_name);
-  if (ContainsKey(key_to_configuration_map_, key)) {
+  if (base::ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(), std::string("Name not unique."));
     return;
   }
 
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForUserhash(userid_hash_);
   if (!profile) {
     failure.Run(
         std::string(),
         std::string("No user profile for unshared network configuration."));
@@ skipping 29 matching lines @@
       base::Bind(&VpnService::OnCreateConfigurationFailure,
                  weak_factory_.GetWeakPtr(), failure, configuration));
 }
 
 void VpnService::DestroyConfiguration(const std::string& extension_id,
                                       const std::string& configuration_id,
                                       const SuccessCallback& success,
                                       const FailureCallback& failure) {
   // The ID is the configuration name for now. This may change in the future.
   const std::string key = GetKey(extension_id, configuration_id);
-  if (!ContainsKey(key_to_configuration_map_, key)) {
+  if (!base::ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(), std::string("Unauthorized access."));
     return;
   }
 
   VpnConfiguration* configuration = key_to_configuration_map_[key];
   const std::string service_path = configuration->service_path();
   if (service_path.empty()) {
     failure.Run(std::string(), std::string("Pending create."));
     return;
   }
@@ skipping 52 matching lines @@
 
   shill_client_->UpdateConnectionState(active_configuration_->object_path(),
                                        static_cast<uint32_t>(state), success,
                                        failure);
 }
 
 bool VpnService::VerifyConfigExistsForTesting(
     const std::string& extension_id,
     const std::string& configuration_name) {
   const std::string key = GetKey(extension_id, configuration_name);
-  return ContainsKey(key_to_configuration_map_, key);
+  return base::ContainsKey(key_to_configuration_map_, key);
 }
 
 bool VpnService::VerifyConfigIsConnectedForTesting(
     const std::string& extension_id) {
   return DoesActiveConfigurationExistAndIsAccessAuthorized(extension_id);
 }
 
 void VpnService::DestroyConfigurationsForExtension(
     const extensions::Extension* extension) {
   std::vector<VpnConfiguration*> to_be_destroyed;
@@ skipping 127 matching lines @@
 void VpnService::Bind(
     const std::string& extension_id,
     const std::string& configuration_id,
     const std::string& configuration_name,
     const SuccessCallback& success,
     const FailureCallback& failure,
     std::unique_ptr<content::PepperVpnProviderResourceHostProxy>
         pepper_vpn_provider_proxy) {
   // The ID is the configuration name for now. This may change in the future.
   const std::string key = GetKey(extension_id, configuration_id);
-  if (!ContainsKey(key_to_configuration_map_, key)) {
+  if (!base::ContainsKey(key_to_configuration_map_, key)) {
     failure.Run(std::string(),
                 std::string("Unauthorized access. "
                             "The configuration does not exist."));
     return;
   }
 
   VpnConfiguration* configuration = key_to_configuration_map_[key];
   if (active_configuration_ != configuration) {
     failure.Run(std::string(), std::string("Unauthorized access. "
                                            "The configuration is not active."));
@@ skipping 18 matching lines @@
   configuration->set_pepper_proxy(std::move(pepper_vpn_provider_proxy));
 
   success.Run();
 }
 
 std::unique_ptr<content::VpnServiceProxy> VpnService::GetVpnServiceProxy() {
   return base::WrapUnique(new VpnServiceProxyImpl(weak_factory_.GetWeakPtr()));
 }
 
 }  // namespace chromeos