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

chromeos/dbus/shill_client_unittest_base.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/dbus/shill_client_unittest_base.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 24 matching lines @@
     return NULL;
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   while (array_reader.HasMoreData()) {
     dbus::MessageReader entry_reader(NULL);
     std::string key;
     std::string value;
     if (!array_reader.PopDictEntry(&entry_reader) ||
         !entry_reader.PopString(&key) ||
         !entry_reader.PopString(&value))
       return NULL;
-    result->SetWithoutPathExpansion(key, new base::Value(value));
+    result->SetStringWithoutPathExpansion(key, value);
   }
   return result.release();
 }
 
 }  // namespace
 
 ValueMatcher::ValueMatcher(const base::Value& value)
   : expected_value_(value.DeepCopy()) {}
 
 bool ValueMatcher::MatchAndExplain(const base::Value& value,
@@ skipping 251 matching lines @@
     EXPECT_TRUE(expected_dictionary->GetWithoutPathExpansion(key,
                                                              &expected_value));
     EXPECT_TRUE(value->Equals(expected_value));
   }
 }
 
 // static
 base::DictionaryValue*
 ShillClientUnittestBase::CreateExampleServiceProperties() {
   base::DictionaryValue* properties = new base::DictionaryValue;
-  properties->SetWithoutPathExpansion(
-      shill::kGuidProperty,
-      new base::Value("00000000-0000-0000-0000-000000000000"));
-  properties->SetWithoutPathExpansion(shill::kModeProperty,
-                                      new base::Value(shill::kModeManaged));
-  properties->SetWithoutPathExpansion(shill::kTypeProperty,
-                                      new base::Value(shill::kTypeWifi));
+  properties->SetStringWithoutPathExpansion(
+      shill::kGuidProperty, "00000000-0000-0000-0000-000000000000");
+  properties->SetStringWithoutPathExpansion(shill::kModeProperty,
+                                            shill::kModeManaged);
+  properties->SetStringWithoutPathExpansion(shill::kTypeProperty,
+                                            shill::kTypeWifi);
   shill_property_util::SetSSID("testssid", properties);
-  properties->SetWithoutPathExpansion(shill::kSecurityClassProperty,
-                                      new base::Value(shill::kSecurityPsk));
+  properties->SetStringWithoutPathExpansion(shill::kSecurityClassProperty,
+                                            shill::kSecurityPsk);
   return properties;
 }
 
 
 // static
 void ShillClientUnittestBase::ExpectNoResultValue(
     DBusMethodCallStatus call_status) {
   EXPECT_EQ(DBUS_METHOD_CALL_SUCCESS, call_status);
 }
 
@@ skipping 97 matching lines @@
 
 void ShillClientUnittestBase::OnCallMethodWithErrorCallback(
     dbus::MethodCall* method_call,
     int timeout_ms,
     const dbus::ObjectProxy::ResponseCallback& response_callback,
     const dbus::ObjectProxy::ErrorCallback& error_callback) {
   OnCallMethod(method_call, timeout_ms, response_callback);
 }
 
 }  // namespace chromeos