Remove stl_util's deletion functions from chromeos/.

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>
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_policy_observer.h"
@@ skipping 47 matching lines @@
 void LogErrorWithDict(const tracked_objects::Location& from_where,
                       const std::string& error_name,
                       std::unique_ptr<base::DictionaryValue> error_data) {
   device_event_log::AddEntry(from_where.file_name(), from_where.line_number(),
                              device_event_log::LOG_TYPE_NETWORK,
                              device_event_log::LOG_LEVEL_ERROR, error_name);
 }
 
 const base::DictionaryValue* GetByGUID(const GuidToPolicyMap& policies,
                                        const std::string& guid) {
-  GuidToPolicyMap::const_iterator it = policies.find(guid);
+  auto it = policies.find(guid);
   if (it == policies.end())
     return NULL;
-  return it->second;
+  return it->second.get();
 }
 
 }  // namespace
 
 struct ManagedNetworkConfigurationHandlerImpl::Policies {
   ~Policies();
 
   GuidToPolicyMap per_network_config;
   base::DictionaryValue global_network_config;
 };
 
-ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {
-  base::STLDeleteValues(&per_network_config);
-}
+ManagedNetworkConfigurationHandlerImpl::Policies::~Policies() {}
 
 void ManagedNetworkConfigurationHandlerImpl::AddObserver(
     NetworkPolicyObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::RemoveObserver(
     NetworkPolicyObserver* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 310 matching lines @@
   }
 
   policies->global_network_config.MergeDictionary(&global_network_config);
 
   // Update prohibited technologies.
   const base::ListValue* prohibited_list = nullptr;
   if (policies->global_network_config.GetListWithoutPathExpansion(
           ::onc::global_network_config::kDisableNetworkTypes,
           &prohibited_list) &&
       prohibited_technologies_handler_) {
-    // Prohobited technologies are only allowed in user policy.
+    // Prohibited technologies are only allowed in user policy.
     DCHECK_EQ(::onc::ONC_SOURCE_DEVICE_POLICY, onc_source);
 
     prohibited_technologies_handler_->SetProhibitedTechnologies(
         prohibited_list);
   }
 
   GuidToPolicyMap old_per_network_config;
   policies->per_network_config.swap(old_per_network_config);
 
   // This stores all GUIDs of policies that have changed or are new.
   std::set<std::string> modified_policies;
 
   for (base::ListValue::const_iterator it = network_configs_onc.begin();
        it != network_configs_onc.end(); ++it) {
-    const base::DictionaryValue* network = NULL;
+    base::DictionaryValue* network = NULL;
     (*it)->GetAsDictionary(&network);
     DCHECK(network);
 
     std::string guid;
     network->GetStringWithoutPathExpansion(::onc::network_config::kGUID, &guid);
     DCHECK(!guid.empty());
 
     if (policies->per_network_config.count(guid) > 0) {
       NET_LOG_ERROR("ONC from " + ToDebugString(onc_source, userhash) +
                     " contains several entries for the same GUID ", guid);
-      delete policies->per_network_config[guid];
     }
-    const base::DictionaryValue* new_entry = network->DeepCopy();
-    policies->per_network_config[guid] = new_entry;
+    base::DictionaryValue* new_entry = network->DeepCopy();
+    policies->per_network_config[guid] = base::WrapUnique(new_entry);
 
-    const base::DictionaryValue* old_entry = old_per_network_config[guid];
+    base::DictionaryValue* old_entry = old_per_network_config[guid].get();
     if (!old_entry || !old_entry->Equals(new_entry))
       modified_policies.insert(guid);
   }
 
-  base::STLDeleteValues(&old_per_network_config);
+  old_per_network_config.clear();
   ApplyOrQueuePolicies(userhash, &modified_policies);
   FOR_EACH_OBSERVER(NetworkPolicyObserver, observers_,
                     PoliciesChanged(userhash));
 }
 
 bool ManagedNetworkConfigurationHandlerImpl::IsAnyPolicyApplicationRunning()
     const {
   return !policy_applicators_.empty() || !queued_modified_policies_.empty();
 }
 
@@ skipping 43 matching lines @@
 
   const Policies* policies = GetPoliciesForProfile(profile);
   if (!policies) {
     VLOG(1) << "The relevant policy is not initialized, "
             << "postponing policy application.";
     // See SetPolicy.
     return;
   }
 
   std::set<std::string> policy_guids;
-  for (GuidToPolicyMap::const_iterator it =
-           policies->per_network_config.begin();
+  for (auto it = policies->per_network_config.begin();
        it != policies->per_network_config.end(); ++it) {
     policy_guids.insert(it->first);
   }
 
   const bool started_policy_application =
       ApplyOrQueuePolicies(profile.userhash, &policy_guids);
   DCHECK(started_policy_application);
 }
 
 void ManagedNetworkConfigurationHandlerImpl::OnProfileRemoved(
@@ skipping 312 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