Remove stl_util's deletion functions from chromeos/.

chromeos/dbus/fake_shill_profile_client.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/dbus/fake_shill_profile_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.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/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 struct FakeShillProfileClient::ProfileProperties {
   base::DictionaryValue entries;  // Dictionary of Service Dictionaries
   base::DictionaryValue properties;  // Dictionary of Profile properties
 };
 
 namespace {
 
 void PassDictionary(
     const ShillProfileClient::DictionaryValueCallbackWithoutStatus& callback,
     const base::DictionaryValue* dictionary) {
   callback.Run(*dictionary);
 }
 
 }  // namespace
 
-FakeShillProfileClient::FakeShillProfileClient() {
-}
+FakeShillProfileClient::FakeShillProfileClient() {}
 
-FakeShillProfileClient::~FakeShillProfileClient() {
-  base::STLDeleteValues(&profiles_);
-}
+FakeShillProfileClient::~FakeShillProfileClient() {}
 
-void FakeShillProfileClient::Init(dbus::Bus* bus) {
-}
+void FakeShillProfileClient::Init(dbus::Bus* bus) {}
 
 void FakeShillProfileClient::AddPropertyChangedObserver(
     const dbus::ObjectPath& profile_path,
     ShillPropertyChangedObserver* observer) {
 }
 
 void FakeShillProfileClient::RemovePropertyChangedObserver(
     const dbus::ObjectPath& profile_path,
     ShillPropertyChangedObserver* observer) {
 }
@@ skipping 65 matching lines @@
 
 ShillProfileClient::TestInterface* FakeShillProfileClient::GetTestInterface() {
   return this;
 }
 
 void FakeShillProfileClient::AddProfile(const std::string& profile_path,
                                         const std::string& userhash) {
   if (GetProfile(dbus::ObjectPath(profile_path), ErrorCallback()))
     return;
 
-  ProfileProperties* profile = new ProfileProperties;
+  std::unique_ptr<ProfileProperties> profile =
+      base::MakeUnique<ProfileProperties>();
   profile->properties.SetStringWithoutPathExpansion(shill::kUserHashProperty,
                                                     userhash);
-  profiles_[profile_path] = profile;
+  profiles_[profile_path] = std::move(profile);
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddProfile(profile_path);
 }
 
 void FakeShillProfileClient::AddEntry(const std::string& profile_path,
                                       const std::string& entry_path,
                                       const base::DictionaryValue& properties) {
   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
                                           ErrorCallback());
   DCHECK(profile);
@@ skipping 59 matching lines @@
     return false;
   }
 
   profile->entries.SetWithoutPathExpansion(service_path,
                                            service_properties->DeepCopy());
   return true;
 }
 
 void FakeShillProfileClient::GetProfilePaths(
     std::vector<std::string>* profiles) {
-  for (ProfileMap::iterator iter = profiles_.begin();
-       iter != profiles_.end(); ++iter) {
+  for (auto iter = profiles_.begin(); iter != profiles_.end(); ++iter)
     profiles->push_back(iter->first);
-  }
 }
 
 bool FakeShillProfileClient::GetService(const std::string& service_path,
                                         std::string* profile_path,
                                         base::DictionaryValue* properties) {
   properties->Clear();
-  for (ProfileMap::const_iterator iter = profiles_.begin();
-       iter != profiles_.end(); ++iter) {
-    const ProfileProperties* profile = iter->second;
+  for (auto iter = profiles_.begin(); iter != profiles_.end(); ++iter) {
+    const ProfileProperties* profile = iter->second.get();
     const base::DictionaryValue* entry;
     if (!profile->entries.GetDictionaryWithoutPathExpansion(
             service_path, &entry)) {
       continue;
     }
     *profile_path = iter->first;
     properties->MergeDictionary(entry);
     return true;
   }
   return false;
 }
 
 void FakeShillProfileClient::ClearProfiles() {
-  base::STLDeleteValues(&profiles_);
+  profiles_.clear();
 }
 
 FakeShillProfileClient::ProfileProperties* FakeShillProfileClient::GetProfile(
     const dbus::ObjectPath& profile_path,
     const ErrorCallback& error_callback) {
-  ProfileMap::const_iterator found = profiles_.find(profile_path.value());
+  auto found = profiles_.find(profile_path.value());
   if (found == profiles_.end()) {
     if (!error_callback.is_null())
       error_callback.Run("Error.InvalidProfile", "Invalid profile");
-    return NULL;
+    return nullptr;
   }
 
-  return found->second;
+  return found->second.get();
 }
 
 }  // namespace chromeos