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

chromeos/network/device_state.cc

 // Copyright (c) 2012 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/device_state.h"
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
+#include "base/values.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 DeviceState::DeviceState(const std::string& path)
     : ManagedState(MANAGED_TYPE_DEVICE, path),
       allow_roaming_(false),
       provider_requires_roaming_(false),
       support_network_scan_(false),
       scanning_(false),
       sim_retries_left_(0),
       sim_present_(true),
       eap_authentication_completed_(false) {
 }
 
 DeviceState::~DeviceState() {
 }
 
 bool DeviceState::PropertyChanged(const std::string& key,
                                   const base::Value& value) {
   // All property values get stored in |properties_|.
-  properties_.SetWithoutPathExpansion(key, value.DeepCopy());
+  properties_.SetWithoutPathExpansion(key,
+                                      base::MakeUnique<base::Value>(value));
 
   if (ManagedStatePropertyChanged(key, value))
     return true;
   if (key == shill::kAddressProperty) {
     return GetStringValue(key, value, &mac_address_);
   } else if (key == shill::kScanningProperty) {
     return GetBooleanValue(key, value, &scanning_);
   } else if (key == shill::kSupportNetworkScanProperty) {
     return GetBooleanValue(key, value, &support_network_scan_);
   } else if (key == shill::kCellularAllowRoamingProperty) {
@@ skipping 71 matching lines @@
 void DeviceState::IPConfigPropertiesChanged(
     const std::string& ip_config_path,
     const base::DictionaryValue& properties) {
   base::DictionaryValue* ip_config = nullptr;
   if (ip_configs_.GetDictionaryWithoutPathExpansion(
           ip_config_path, &ip_config)) {
     NET_LOG_EVENT("IPConfig Updated: " + ip_config_path, path());
     ip_config->Clear();
   } else {
     NET_LOG_EVENT("IPConfig Added: " + ip_config_path, path());
-    ip_config = new base::DictionaryValue;
-    ip_configs_.SetWithoutPathExpansion(ip_config_path, ip_config);
+    ip_config = ip_configs_.SetDictionaryWithoutPathExpansion(
+        ip_config_path, base::MakeUnique<base::DictionaryValue>());
   }
   ip_config->MergeDictionary(&properties);
 }
 
 std::string DeviceState::GetIpAddressByType(const std::string& type) const {
   for (base::DictionaryValue::Iterator iter(ip_configs_); !iter.IsAtEnd();
        iter.Advance()) {
     const base::DictionaryValue* ip_config;
     if (!iter.value().GetAsDictionary(&ip_config))
       continue;
@@ skipping 10 matching lines @@
     }
   }
   return std::string();
 }
 
 bool DeviceState::IsSimAbsent() const {
   return technology_family_ == shill::kTechnologyFamilyGsm && !sim_present_;
 }
 
 }  // namespace chromeos