chromeos: Use stl utilities from the base namespace

chromeos/network/managed_network_configuration_handler_impl.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 "chromeos/network/managed_network_configuration_handler_impl.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
@@ skipping 80 matching lines @@
 }  // namespace
 
 struct ManagedNetworkConfigurationHandlerImpl::Policies {
   ~Policies();
 
   GuidToPolicyMap per_network_config;
   base::DictionaryValue global_network_config;
 };
 
 ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {
-  STLDeleteValues(&per_network_config);
+  base::STLDeleteValues(&per_network_config);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::AddObserver(
     NetworkPolicyObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::RemoveObserver(
     NetworkPolicyObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 296 matching lines @@
     const std::string& userhash,
     const base::ListValue& network_configs_onc,
     const base::DictionaryValue& global_network_config) {
   VLOG(1) << "Setting policies from " << ToDebugString(onc_source, userhash)
           << ".";
 
   // |userhash| must be empty for device policies.
   DCHECK(onc_source != ::onc::ONC_SOURCE_DEVICE_POLICY ||
          userhash.empty());
   Policies* policies = NULL;
-  if (ContainsKey(policies_by_user_, userhash)) {
+  if (base::ContainsKey(policies_by_user_, userhash)) {
     policies = policies_by_user_[userhash].get();
   } else {
     policies = new Policies;
     policies_by_user_[userhash] = base::WrapUnique(policies);
   }
 
   policies->global_network_config.MergeDictionary(&global_network_config);
 
   // Update prohibited technologies.
   const base::ListValue* prohibited_list = nullptr;
@@ skipping 30 matching lines @@
       delete policies->per_network_config[guid];
     }
     const base::DictionaryValue* new_entry = network->DeepCopy();
     policies->per_network_config[guid] = new_entry;
 
     const base::DictionaryValue* old_entry = old_per_network_config[guid];
     if (!old_entry || !old_entry->Equals(new_entry))
       modified_policies.insert(guid);
   }
 
-  STLDeleteValues(&old_per_network_config);
+  base::STLDeleteValues(&old_per_network_config);
   ApplyOrQueuePolicies(userhash, &modified_policies);
   FOR_EACH_OBSERVER(NetworkPolicyObserver, observers_,
                     PoliciesChanged(userhash));
 }
 
 bool ManagedNetworkConfigurationHandlerImpl::IsAnyPolicyApplicationRunning()
     const {
   return !policy_applicators_.empty() || !queued_modified_policies_.empty();
 }
 
 bool ManagedNetworkConfigurationHandlerImpl::ApplyOrQueuePolicies(
     const std::string& userhash,
     std::set<std::string>* modified_policies) {
   DCHECK(modified_policies);
 
   const NetworkProfile* profile =
       network_profile_handler_->GetProfileForUserhash(userhash);
   if (!profile) {
     VLOG(1) << "The relevant Shill profile isn't initialized yet, postponing "
             << "policy application.";
     // OnProfileAdded will apply all policies for this userhash.
     return false;
   }
 
-  if (ContainsKey(policy_applicators_, userhash)) {
+  if (base::ContainsKey(policy_applicators_, userhash)) {
     // A previous policy application is still running. Queue the modified
     // policies.
     // Note, even if |modified_policies| is empty, this means that a policy
     // application will be queued.
     queued_modified_policies_[userhash].insert(modified_policies->begin(),
                                                modified_policies->end());
     VLOG(1) << "Previous PolicyApplicator still running. Postponing policy "
                "application.";
     return false;
   }
@@ skipping 90 matching lines @@
 
 void ManagedNetworkConfigurationHandlerImpl::OnPoliciesApplied(
     const NetworkProfile& profile) {
   const std::string& userhash = profile.userhash;
   VLOG(1) << "Policy application for user '" << userhash << "' finished.";
 
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(
       FROM_HERE, policy_applicators_[userhash].release());
   policy_applicators_.erase(userhash);
 
-  if (ContainsKey(queued_modified_policies_, userhash)) {
+  if (base::ContainsKey(queued_modified_policies_, userhash)) {
     std::set<std::string> modified_policies;
     queued_modified_policies_[userhash].swap(modified_policies);
     // Remove |userhash| from the queue.
     queued_modified_policies_.erase(userhash);
     ApplyOrQueuePolicies(userhash, &modified_policies);
   } else {
     FOR_EACH_OBSERVER(
         NetworkPolicyObserver, observers_, PoliciesApplied(userhash));
   }
 }
@@ skipping 241 matching lines @@
     std::unique_ptr<base::DictionaryValue> network_properties,
     GetDevicePropertiesCallback send_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   NET_LOG_ERROR("Error getting device properties", service_path);
   send_callback.Run(service_path, std::move(network_properties));
 }
 
 
 }  // namespace chromeos