Remove SetWithoutPathExpansion

chromeos/dbus/fake_shill_service_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_service_client.h"
 
+#include <utility>
+
 #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/strings/string_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_device_client.h"
@@ skipping 296 matching lines @@
 
   std::string profile_path;
   if (properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                 &profile_path) &&
       !profile_path.empty()) {
     DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
         UpdateService(profile_path, service_path);
   }
 
   if (!ipconfig_path.empty()) {
-    properties->SetWithoutPathExpansion(shill::kIPConfigProperty,
-                                        new base::Value(ipconfig_path));
+    properties->SetStringWithoutPathExpansion(shill::kIPConfigProperty,
+                                              ipconfig_path);
   }
 
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddManagerService(service_path, true);
 }
 
 base::DictionaryValue* FakeShillServiceClient::SetServiceProperties(
     const std::string& service_path,
     const std::string& guid,
     const std::string& name,
@@ skipping 70 matching lines @@
   if (base::StartsWith(property, "Provider.", case_sensitive) ||
       base::StartsWith(property, "OpenVPN.", case_sensitive) ||
       base::StartsWith(property, "L2TPIPsec.", case_sensitive)) {
     // These properties are only nested within the Provider dictionary if read
     // from Shill. Properties that start with "Provider" need to have that
     // stripped off, other properties are nested in the "Provider" dictionary
     // as-is.
     std::string key = property;
     if (base::StartsWith(property, "Provider.", case_sensitive))
       key = property.substr(strlen("Provider."));
-    base::DictionaryValue* provider = new base::DictionaryValue;
-    provider->SetWithoutPathExpansion(key, value.DeepCopy());
-    new_properties.SetWithoutPathExpansion(shill::kProviderProperty, provider);
+    base::DictionaryValue* provider = nullptr;
+    provider->SetWithoutPathExpansion(key, value.CreateDeepCopy());
+    new_properties.SetWithoutPathExpansion(
+        shill::kProviderProperty, base::MakeUnique<base::DictionaryValue>());
+    new_properties.GetDictionaryWithoutPathExpansion(shill::kProviderProperty,
+                                                     &provider);
     changed_property = shill::kProviderProperty;
   } else if (value.GetType() == base::Value::Type::DICTIONARY) {
     const base::DictionaryValue* new_dict = NULL;
     value.GetAsDictionary(&new_dict);
     CHECK(new_dict);
     std::unique_ptr<base::Value> cur_value;
     base::DictionaryValue* cur_dict;
     if (dict->RemoveWithoutPathExpansion(property, &cur_value) &&
         cur_value->GetAsDictionary(&cur_dict)) {
       cur_dict->Clear();
       cur_dict->MergeDictionary(new_dict);
-      new_properties.SetWithoutPathExpansion(property, cur_value.release());
+      new_properties.SetWithoutPathExpansion(property, std::move(cur_value));
     } else {
-      new_properties.SetWithoutPathExpansion(property, value.DeepCopy());
+      new_properties.SetWithoutPathExpansion(property, value.CreateDeepCopy());
     }
     changed_property = property;
   } else {
-    new_properties.SetWithoutPathExpansion(property, value.DeepCopy());
+    new_properties.SetWithoutPathExpansion(property, value.CreateDeepCopy());
     changed_property = property;
   }
 
   dict->MergeDictionary(&new_properties);
 
   // Add or update the profile entry.
   ShillProfileClient::TestInterface* profile_test =
       DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
   if (property == shill::kProfileProperty) {
     std::string profile_path;
@@ skipping 114 matching lines @@
     if (path == service_path)
       continue;
     base::DictionaryValue* properties;
     if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &properties))
       NOTREACHED();
 
     std::string type;
     properties->GetString(shill::kTypeProperty, &type);
     if (type != service_type)
       continue;
-    properties->SetWithoutPathExpansion(shill::kStateProperty,
-                                        new base::Value(shill::kStateIdle));
+    properties->SetStringWithoutPathExpansion(shill::kStateProperty,
+                                              shill::kStateIdle);
   }
 }
 
 void FakeShillServiceClient::SetCellularActivated(
     const dbus::ObjectPath& service_path,
     const ErrorCallback& error_callback) {
   SetProperty(service_path, shill::kActivationStateProperty,
               base::Value(shill::kActivationStateActivated),
               base::Bind(&base::DoNothing), error_callback);
   SetProperty(service_path, shill::kConnectableProperty, base::Value(true),
@@ skipping 34 matching lines @@
             base::Value(shill::kErrorBadPassphrase)));
   } else {
     // Set Online.
     VLOG(1) << "Setting state to Online " << service_path;
     SetServiceProperty(service_path, shill::kStateProperty,
                        base::Value(shill::kStateOnline));
   }
 }
 
 }  // namespace chromeos