Remove raw DictionaryValue::Set in //components

components/policy/core/common/configuration_policy_provider_test.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 "components/policy/core/common/configuration_policy_provider_test.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 283 matching lines @@
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, DictionaryValue) {
   base::DictionaryValue expected_value;
   expected_value.SetBoolean("bool", true);
   expected_value.SetDouble("double", 123.456);
   expected_value.SetInteger("int", 123);
   expected_value.SetString("string", "omg");
 
-  base::ListValue* list = new base::ListValue();
+  auto list = base::MakeUnique<base::ListValue>();
   list->AppendString("first");
   list->AppendString("second");
-  expected_value.Set("array", list);
+  expected_value.Set("array", std::move(list));
 
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetString("sub", "value");
-  list = new base::ListValue();
-  std::unique_ptr<base::DictionaryValue> sub(new base::DictionaryValue());
+  list = base::MakeUnique<base::ListValue>();
+  auto sub = base::MakeUnique<base::DictionaryValue>();
   sub->SetInteger("aaa", 111);
   sub->SetInteger("bbb", 222);
   list->Append(std::move(sub));
-  sub.reset(new base::DictionaryValue());
+  sub = base::MakeUnique<base::DictionaryValue>();
   sub->SetString("ccc", "333");
   sub->SetString("ddd", "444");
   list->Append(std::move(sub));
-  dict->Set("sublist", list);
-  expected_value.Set("dictionary", dict);
+  dict->Set("sublist", std::move(list));
+  expected_value.Set("dictionary", std::move(dict));
 
   CheckValue(test_keys::kKeyDictionary,
              expected_value,
              base::Bind(&PolicyProviderTestHarness::InstallDictionaryPolicy,
                         base::Unretained(test_harness_.get()),
                         test_keys::kKeyDictionary,
                         &expected_value));
 }
 
 TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
@@ skipping 31 matching lines @@
 Configuration3rdPartyPolicyProviderTest::
     ~Configuration3rdPartyPolicyProviderTest() {}
 
 TEST_P(Configuration3rdPartyPolicyProviderTest, Load3rdParty) {
   base::DictionaryValue policy_dict;
   policy_dict.SetBoolean("bool", true);
   policy_dict.SetDouble("double", 123.456);
   policy_dict.SetInteger("int", 789);
   policy_dict.SetString("string", "string value");
 
-  base::ListValue* list = new base::ListValue();
+  auto list = base::MakeUnique<base::ListValue>();
   for (int i = 0; i < 2; ++i) {
-    std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
+    auto dict = base::MakeUnique<base::DictionaryValue>();
     dict->SetInteger("subdictindex", i);
-    dict->Set("subdict", policy_dict.DeepCopy());
+    dict->Set("subdict", base::MakeUnique<base::Value>(policy_dict));
     list->Append(std::move(dict));
   }
-  policy_dict.Set("list", list);
-  policy_dict.Set("dict", policy_dict.DeepCopy());
+  policy_dict.Set("list", std::move(list));
+  policy_dict.Set("dict", base::MakeUnique<base::Value>(policy_dict));
 
   // Install these policies as a Chrome policy.
   test_harness_->InstallDictionaryPolicy(test_keys::kKeyDictionary,
                                          &policy_dict);
   // Install them as 3rd party policies too.
   base::DictionaryValue policy_3rdparty;
   policy_3rdparty.Set("extensions.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
-                      policy_dict.DeepCopy());
+                      base::MakeUnique<base::Value>(policy_dict));
   policy_3rdparty.Set("extensions.bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
-                      policy_dict.DeepCopy());
+                      base::MakeUnique<base::Value>(policy_dict));
   // Install invalid 3rd party policies that shouldn't be loaded. These also
   // help detecting memory leaks in the code paths that detect invalid input.
-  policy_3rdparty.Set("invalid-domain.component", policy_dict.DeepCopy());
-  policy_3rdparty.Set("extensions.cccccccccccccccccccccccccccccccc",
-                      new base::Value("invalid-value"));
+  policy_3rdparty.Set("invalid-domain.component",
+                      base::MakeUnique<base::Value>(policy_dict));
+  policy_3rdparty.SetString("extensions.cccccccccccccccccccccccccccccccc",
+                            "invalid-value");
   test_harness_->Install3rdPartyPolicy(&policy_3rdparty);
 
   provider_->RefreshPolicies();
   base::RunLoop().RunUntilIdle();
 
   PolicyMap expected_policy;
   expected_policy.Set(test_keys::kKeyDictionary, test_harness_->policy_level(),
                       test_harness_->policy_scope(),
                       test_harness_->policy_source(),
                       policy_dict.CreateDeepCopy(), nullptr);
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
       .CopyFrom(expected_policy);
   expected_policy.Clear();
   expected_policy.LoadFrom(&policy_dict,
                            test_harness_->policy_level(),
                            test_harness_->policy_scope(),
                            test_harness_->policy_source());
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"))
       .CopyFrom(expected_policy);
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS,
                                       "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"))
       .CopyFrom(expected_policy);
   EXPECT_TRUE(provider_->policies().Equals(expected_bundle));
 }
 
 }  // namespace policy