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

chromeos/dbus/fake_shill_device_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_device_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 103 matching lines @@
     const std::string& name,
     const base::Value& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* device_properties = NULL;
   if (!stub_devices_.GetDictionaryWithoutPathExpansion(device_path.value(),
                                                        &device_properties)) {
     PostNotFoundError(error_callback);
     return;
   }
-  device_properties->SetWithoutPathExpansion(name, value.DeepCopy());
+  device_properties->SetWithoutPathExpansion(
+      name, base::MakeUnique<base::Value>(value));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillDeviceClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), device_path, name));
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillDeviceClient::ClearProperty(
     const dbus::ObjectPath& device_path,
     const std::string& name,
@@ skipping 353 matching lines @@
   base::DictionaryValue* device_properties = NULL;
   if (!stub_devices_.GetDictionaryWithoutPathExpansion(device_path,
                                                        &device_properties)) {
     NOTREACHED() << "Device not found: " << device_path;
     return;
   }
 
   base::DictionaryValue* simlock_dict = nullptr;
   if (!device_properties->GetDictionaryWithoutPathExpansion(
           shill::kSIMLockStatusProperty, &simlock_dict)) {
-    simlock_dict = new base::DictionaryValue;
-    device_properties->SetWithoutPathExpansion(shill::kSIMLockStatusProperty,
-                                               simlock_dict);
+    simlock_dict = device_properties->SetDictionaryWithoutPathExpansion(
+        shill::kSIMLockStatusProperty,
+        base::MakeUnique<base::DictionaryValue>());
   }
   simlock_dict->Clear();
   simlock_dict->SetStringWithoutPathExpansion(shill::kSIMLockTypeProperty,
                                               status.type);
   simlock_dict->SetIntegerWithoutPathExpansion(
       shill::kSIMLockRetriesLeftProperty, status.retries_left);
   simlock_dict->SetBooleanWithoutPathExpansion(shill::kSIMLockEnabledProperty,
                                                status.lock_enabled);
   NotifyObserversPropertyChanged(dbus::ObjectPath(device_path),
                                  shill::kSIMLockStatusProperty);
@@ skipping 95 matching lines @@
   }
   for (auto& observer : GetObserverList(device_path))
     observer.OnPropertyChanged(property, *value);
 }
 
 base::DictionaryValue* FakeShillDeviceClient::GetDeviceProperties(
     const std::string& device_path) {
   base::DictionaryValue* properties = NULL;
   if (!stub_devices_.GetDictionaryWithoutPathExpansion(
       device_path, &properties)) {
-    properties = new base::DictionaryValue;
-    stub_devices_.SetWithoutPathExpansion(device_path, properties);
+    properties = stub_devices_.SetDictionaryWithoutPathExpansion(
+        device_path, base::MakeUnique<base::DictionaryValue>());
   }
   return properties;
 }
 
 FakeShillDeviceClient::PropertyObserverList&
 FakeShillDeviceClient::GetObserverList(const dbus::ObjectPath& device_path) {
   auto iter = observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = base::WrapUnique(observer_list);
   return *observer_list;
 }
 
 }  // namespace chromeos