Remove raw base::DictionaryValue::Set

services/preferences/tracked/pref_hash_store_impl_unittest.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 "services/preferences/tracked/pref_hash_store_impl.h"
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/values.h"
@@ skipping 33 matching lines @@
   // Quick sanity checks here, see pref_hash_calculator_unittest.cc for more
   // complete tests.
   EXPECT_EQ(computed_mac_1, pref_hash_store.ComputeMac("path1", &string_1));
   EXPECT_NE(computed_mac_1, computed_mac_2);
   EXPECT_NE(computed_mac_1, computed_mac_3);
   EXPECT_EQ(64U, computed_mac_1.size());
 }
 
 TEST_F(PrefHashStoreImplTest, ComputeSplitMacs) {
   base::DictionaryValue dict;
-  dict.Set("a", new base::Value("string1"));
-  dict.Set("b", new base::Value("string2"));
+  dict.SetString("a", "string1");
+  dict.SetString("b", "string2");
   PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
 
   std::unique_ptr<base::DictionaryValue> computed_macs =
       pref_hash_store.ComputeSplitMacs("foo.bar", &dict);
 
   std::string mac_1;
   std::string mac_2;
   ASSERT_TRUE(computed_macs->GetString("a", &mac_1));
   ASSERT_TRUE(computed_macs->GetString("b", &mac_2));
 
@@ skipping 23 matching lines @@
 
     transaction->StoreHash("path1", &string_1);
     EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckValue("path1", &string_1));
     EXPECT_EQ(ValueState::CLEARED, transaction->CheckValue("path1", NULL));
     transaction->StoreHash("path1", NULL);
     EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", NULL));
     EXPECT_EQ(ValueState::CHANGED, transaction->CheckValue("path1", &string_2));
 
     base::DictionaryValue dict;
-    dict.Set("a", new base::Value("foo"));
-    dict.Set("d", new base::Value("bad"));
-    dict.Set("b", new base::Value("bar"));
-    dict.Set("c", new base::Value("baz"));
+    dict.SetString("a", "foo");
+    dict.SetString("d", "bad");
+    dict.SetString("b", "bar");
+    dict.SetString("c", "baz");
 
     transaction->StoreHash("path1", &dict);
     EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", &dict));
   }
 
   ASSERT_FALSE(GetHashStoreContents()->GetSuperMac().empty());
 
   {
     // |pref_hash_store2| should trust its initial hashes dictionary and thus
     // trust new unknown values.
@@ skipping 191 matching lines @@
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", false);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
     EXPECT_EQ(ValueState::UNTRUSTED_UNKNOWN_VALUE,
               transaction->CheckValue("new_path", &string_1));
   }
 }
 
 TEST_F(PrefHashStoreImplTest, SplitHashStoreAndCheck) {
   base::DictionaryValue dict;
-  dict.Set("a", new base::Value("to be replaced"));
-  dict.Set("b", new base::Value("same"));
-  dict.Set("o", new base::Value("old"));
+  dict.SetString("a", "to be replaced");
+  dict.SetString("b", "same");
+  dict.SetString("o", "old");
 
   base::DictionaryValue modified_dict;
-  modified_dict.Set("a", new base::Value("replaced"));
-  modified_dict.Set("b", new base::Value("same"));
-  modified_dict.Set("c", new base::Value("new"));
+  modified_dict.SetString("a", "replaced");
+  modified_dict.SetString("b", "same");
+  modified_dict.SetString("c", "new");
 
   base::DictionaryValue empty_dict;
 
   std::vector<std::string> invalid_keys;
 
   {
     PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
@@ skipping 89 matching lines @@
 
   std::vector<std::string> invalid_keys;
 
   {
     PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
     // Store hashes for a random dict to be overwritten below.
     base::DictionaryValue initial_dict;
-    initial_dict.Set("a", new base::Value("foo"));
+    initial_dict.SetString("a", "foo");
     transaction->StoreSplitHash("path1", &initial_dict);
 
     // Verify stored empty dictionary matches NULL and empty dictionary back.
     transaction->StoreSplitHash("path1", &empty_dict);
     EXPECT_EQ(ValueState::UNCHANGED,
               transaction->CheckSplitValue("path1", NULL, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
     EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckSplitValue(
                                          "path1", &empty_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
@@ skipping 12 matching lines @@
     // |pref_hash_store2| should trust its initial hashes dictionary (and thus
     // trust new unknown values) even though the last action done was to clear
     // the hashes for path1 by setting its value to NULL (this is a regression
     // test ensuring that the internal action of clearing some hashes does
     // update the stored hash of hashes).
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
 
     base::DictionaryValue tested_dict;
-    tested_dict.Set("a", new base::Value("foo"));
-    tested_dict.Set("b", new base::Value("bar"));
+    tested_dict.SetString("a", "foo");
+    tested_dict.SetString("b", "bar");
     EXPECT_EQ(
         ValueState::TRUSTED_UNKNOWN_VALUE,
         transaction->CheckSplitValue("new_path", &tested_dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
 }
 
 // Test that the PrefHashStore returns TRUSTED_UNKNOWN_VALUE when checking for
 // a split preference even if there is an existing atomic preference's hash
 // stored. There is no point providing a migration path for preferences
 // switching strategies after their initial release as split preferences are
 // turned into split preferences specifically because the atomic hash isn't
 // considered useful.
 TEST_F(PrefHashStoreImplTest, TrustedUnknownSplitValueFromExistingAtomic) {
   base::Value string("string1");
 
   base::DictionaryValue dict;
-  dict.Set("a", new base::Value("foo"));
-  dict.Set("d", new base::Value("bad"));
-  dict.Set("b", new base::Value("bar"));
-  dict.Set("c", new base::Value("baz"));
+  dict.SetString("a", "foo");
+  dict.SetString("d", "bad");
+  dict.SetString("b", "bar");
+  dict.SetString("c", "baz");
 
   {
     PrefHashStoreImpl pref_hash_store(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store.BeginTransaction(GetHashStoreContents()));
 
     transaction->StoreHash("path1", &string);
     EXPECT_EQ(ValueState::UNCHANGED, transaction->CheckValue("path1", &string));
   }
 
   {
     // Load a new |pref_hash_store2| in which the hashes dictionary is trusted.
     PrefHashStoreImpl pref_hash_store2(std::string(32, 0), "device_id", true);
     std::unique_ptr<PrefHashStoreTransaction> transaction(
         pref_hash_store2.BeginTransaction(GetHashStoreContents()));
     std::vector<std::string> invalid_keys;
     EXPECT_EQ(ValueState::TRUSTED_UNKNOWN_VALUE,
               transaction->CheckSplitValue("path1", &dict, &invalid_keys));
     EXPECT_TRUE(invalid_keys.empty());
   }
 }