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

chromeos/network/managed_network_configuration_handler_unittest.cc

 // Copyright (c) 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 <iostream>
 #include <memory>
 #include <sstream>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_shill_manager_client.h"
 #include "chromeos/dbus/mock_shill_profile_client.h"
 #include "chromeos/dbus/mock_shill_service_client.h"
@@ skipping 69 matching lines @@
  public:
   typedef ShillClientHelper::DictionaryValueCallbackWithoutStatus
       DictionaryValueCallbackWithoutStatus;
   typedef ShillClientHelper::ErrorCallback ErrorCallback;
 
   void AddProfile(const std::string& profile_path,
                   const std::string& userhash) {
     if (profile_entries_.HasKey(profile_path))
       return;
 
-    base::DictionaryValue* profile = new base::DictionaryValue;
-    profile_entries_.SetWithoutPathExpansion(profile_path, profile);
+    profile_entries_.SetWithoutPathExpansion(
+        profile_path, base::MakeUnique<base::DictionaryValue>());
     profile_to_user_[profile_path] = userhash;
   }
 
   void AddEntry(const std::string& profile_path,
                 const std::string& entry_path,
                 const base::DictionaryValue& entry) {
     base::DictionaryValue* entries = NULL;
     profile_entries_.GetDictionaryWithoutPathExpansion(profile_path, &entries);
     ASSERT_TRUE(entries);
 
-    base::DictionaryValue* new_entry = entry.DeepCopy();
+    auto new_entry = base::MakeUnique<base::DictionaryValue>(entry);
     new_entry->SetStringWithoutPathExpansion(shill::kProfileProperty,
                                              profile_path);
-    entries->SetWithoutPathExpansion(entry_path, new_entry);
+    entries->SetWithoutPathExpansion(entry_path, std::move(new_entry));
   }
 
   void GetProperties(const dbus::ObjectPath& profile_path,
                      const DictionaryValueCallbackWithoutStatus& callback,
                      const ErrorCallback& error_callback) {
     base::DictionaryValue* entries = NULL;
     profile_entries_.GetDictionaryWithoutPathExpansion(profile_path.value(),
                                                        &entries);
     ASSERT_TRUE(entries);
 
     std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
-    base::ListValue* entry_paths = new base::ListValue;
-    result->SetWithoutPathExpansion(shill::kEntriesProperty, entry_paths);
+    auto entry_paths = base::MakeUnique<base::ListValue>();
     for (base::DictionaryValue::Iterator it(*entries); !it.IsAtEnd();
          it.Advance()) {
       entry_paths->AppendString(it.key());
     }
+    result->SetWithoutPathExpansion(shill::kEntriesProperty,
+                                    std::move(entry_paths));
 
     ASSERT_TRUE(base::ContainsKey(profile_to_user_, profile_path.value()));
     const std::string& userhash = profile_to_user_[profile_path.value()];
     result->SetStringWithoutPathExpansion(shill::kUserHashProperty, userhash);
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&DereferenceAndCall, callback,
                               base::Owned(result.release())));
   }
 
@@ skipping 834 matching lines @@
   EXPECT_CALL(*mock_profile_client_,
               GetProperties(dbus::ObjectPath(kUser1ProfilePath), _, _));
 
   SetPolicy(::onc::ONC_SOURCE_USER_POLICY, kUser1, "policy/policy_wifi1.onc");
   managed_network_configuration_handler_->RemoveObserver(&policy_observer_);
   managed_network_configuration_handler_.reset();
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace chromeos