Remove raw base::DictionaryValue::SetWithoutPathExpansion in //chromeos

chromeos/dbus/fake_shill_manager_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_manager_client.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_shill_device_client.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_ipconfig_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
@@ skipping 147 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakeShillManagerClient::PassStubGeoNetworks,
                             weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void FakeShillManagerClient::SetProperty(const std::string& name,
                                          const base::Value& value,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   VLOG(2) << "SetProperty: " << name;
-  stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
+  stub_properties_.SetWithoutPathExpansion(
+      name, base::MakeUnique<base::Value>(value));
   CallNotifyObserversPropertyChanged(name);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::RequestScan(const std::string& type,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   VLOG(1) << "RequestScan: " << type;
   // For Stub purposes, default to a Wifi scan.
   std::string device_type = shill::kTypeWifi;
@@ skipping 248 matching lines @@
     }
   }
 }
 
 void FakeShillManagerClient::AddGeoNetwork(
     const std::string& technology,
     const base::DictionaryValue& network) {
   base::ListValue* list_value = NULL;
   if (!stub_geo_networks_.GetListWithoutPathExpansion(technology,
                                                       &list_value)) {
-    list_value = new base::ListValue;
-    stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
+    list_value = stub_geo_networks_.SetListWithoutPathExpansion(
+        technology, base::MakeUnique<base::ListValue>());
   }
-  list_value->Append(network.CreateDeepCopy());
+  list_value->GetList().push_back(network);
 }
 
 void FakeShillManagerClient::AddProfile(const std::string& profile_path) {
   const char* key = shill::kProfilesProperty;
   if (GetListProperty(key)->AppendIfNotPresent(
           base::MakeUnique<base::Value>(profile_path))) {
     CallNotifyObserversPropertyChanged(key);
   }
 }
 
@@ skipping 500 matching lines @@
   }
   for (auto& observer : observer_list_)
     observer.OnPropertyChanged(property, *value);
 }
 
 base::ListValue* FakeShillManagerClient::GetListProperty(
     const std::string& property) {
   base::ListValue* list_property = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
       property, &list_property)) {
-    list_property = new base::ListValue;
-    stub_properties_.SetWithoutPathExpansion(property, list_property);
+    list_property = stub_properties_.SetListWithoutPathExpansion(
+        property, base::MakeUnique<base::ListValue>());
   }
   return list_property;
 }
 
 bool FakeShillManagerClient::TechnologyEnabled(const std::string& type) const {
   if (type == shill::kTypeVPN)
     return true;  // VPN is always "enabled" since there is no associated device
   if (type == shill::kTypeEthernetEap)
     return true;
   bool enabled = false;
@@ skipping 17 matching lines @@
     enabled_list->AppendIfNotPresent(base::MakeUnique<base::Value>(type));
   else
     enabled_list->Remove(base::Value(type), NULL);
   CallNotifyObserversPropertyChanged(
       shill::kEnabledTechnologiesProperty);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
   // May affect available services.
   SortManagerServices(true);
 }
 
-base::ListValue* FakeShillManagerClient::GetEnabledServiceList(
+std::unique_ptr<base::ListValue> FakeShillManagerClient::GetEnabledServiceList(
     const std::string& property) const {
-  base::ListValue* new_service_list = new base::ListValue;
+  auto new_service_list = base::MakeUnique<base::ListValue>();
   const base::ListValue* service_list;
   if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) {
     ShillServiceClient::TestInterface* service_client =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     for (base::ListValue::const_iterator iter = service_list->begin();
          iter != service_list->end(); ++iter) {
       std::string service_path;
       if (!iter->GetAsString(&service_path))
         continue;
       const base::DictionaryValue* properties =
@@ skipping 195 matching lines @@
       LOG(WARNING) << "Invalid state: " << state << " for " << type;
       result = shill::kStateIdle;
     }
   }
   VLOG(1) << "Initial state for: " << type << " = " << result
           << " Enabled: " << *enabled;
   return result;
 }
 
 }  // namespace chromeos