Remove raw base::DictionaryValue::Set

services/preferences/tracked/pref_hash_filter_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_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 664 matching lines @@
 TEST_P(PrefHashFilterTest, StampSuperMACAltersStore) {
   mock_pref_hash_store_->set_stamp_super_mac_result(true);
   DoFilterOnLoad(true);
   // No paths stored, since they all return |UNCHANGED|. The StampSuperMAC
   // result is the only reason the prefs were considered altered.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 }
 
 TEST_P(PrefHashFilterTest, FilterTrackedPrefUpdate) {
   base::DictionaryValue root_dict;
-  // Ownership of |string_value| is transfered to |root_dict|.
-  base::Value* string_value = new base::Value("string value");
-  root_dict.Set(kAtomicPref, string_value);
+  base::Value* string_value = root_dict.SetString(kAtomicPref, "string value");
 
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value =
       mock_pref_hash_store_->stored_value(kAtomicPref);
@@ skipping 35 matching lines @@
 
   DoFilterOnLoad(false);
 
   // Verify that the validity was reported.
   ASSERT_EQ(initial_untrusted + 1, histogram->SnapshotSamples()->GetCount(0));
   ASSERT_EQ(initial_trusted + 1, histogram->SnapshotSamples()->GetCount(1));
 }
 
 TEST_P(PrefHashFilterTest, FilterSplitPrefUpdate) {
   base::DictionaryValue root_dict;
-  // Ownership of |dict_value| is transfered to |root_dict|.
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  base::DictionaryValue* dict_value = root_dict.SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
-  root_dict.Set(kSplitPref, dict_value);
 
   // No path should be stored on FilterUpdate.
   pref_hash_filter_->FilterUpdate(kSplitPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // One path should be stored on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(1u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value =
       mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_value.first);
   ASSERT_EQ(PrefTrackingStrategy::SPLIT, stored_value.second);
 
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
   VerifyRecordedReset(false);
 }
 
 TEST_P(PrefHashFilterTest, FilterUntrackedPrefUpdate) {
   base::DictionaryValue root_dict;
-  root_dict.Set("untracked", new base::Value("some value"));
+  root_dict.SetString("untracked", "some value");
   pref_hash_filter_->FilterUpdate("untracked");
 
   // No paths should be stored on FilterUpdate.
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // Nor on FilterSerializeData.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // No transaction should even be started on FilterSerializeData() if there are
   // no updates to perform.
   ASSERT_EQ(0u, mock_pref_hash_store_->transactions_performed());
 }
 
 TEST_P(PrefHashFilterTest, MultiplePrefsFilterSerializeData) {
   base::DictionaryValue root_dict;
-  // Ownership of the following values is transfered to |root_dict|.
-  base::Value* int_value1 = new base::Value(1);
-  base::Value* int_value2 = new base::Value(2);
-  base::Value* int_value3 = new base::Value(3);
-  base::Value* int_value4 = new base::Value(4);
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
-  dict_value->Set("a", new base::Value(true));
-  root_dict.Set(kAtomicPref, int_value1);
-  root_dict.Set(kAtomicPref2, int_value2);
-  root_dict.Set(kAtomicPref3, int_value3);
-  root_dict.Set("untracked", int_value4);
-  root_dict.Set(kSplitPref, dict_value);
+  base::Value* int_value1 = root_dict.SetInteger(kAtomicPref, 1);
+  root_dict.SetInteger(kAtomicPref2, 2);
+  root_dict.SetInteger(kAtomicPref3, 3);
+  root_dict.SetInteger("untracked", 4);
+  base::DictionaryValue* dict_value = root_dict.SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
+  dict_value->SetBoolean("a", true);
 
   // Only update kAtomicPref, kAtomicPref3, and kSplitPref.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   pref_hash_filter_->FilterUpdate(kAtomicPref3);
   pref_hash_filter_->FilterUpdate(kSplitPref);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // Update kAtomicPref3 again, nothing should be stored still.
-  base::Value* int_value5 = new base::Value(5);
-  root_dict.Set(kAtomicPref3, int_value5);
+  base::Value* int_value5 = root_dict.SetInteger(kAtomicPref3, 5);
   ASSERT_EQ(0u, mock_pref_hash_store_->stored_paths_count());
 
   // On FilterSerializeData, only kAtomicPref, kAtomicPref3, and kSplitPref
   // should get a new hash.
   pref_hash_filter_->FilterSerializeData(&root_dict);
   ASSERT_EQ(3u, mock_pref_hash_store_->stored_paths_count());
   MockPrefHashStore::ValuePtrStrategyPair stored_value_atomic1 =
       mock_pref_hash_store_->stored_value(kAtomicPref);
   ASSERT_EQ(int_value1, stored_value_atomic1.first);
   ASSERT_EQ(PrefTrackingStrategy::ATOMIC, stored_value_atomic1.second);
@@ skipping 47 matching lines @@
       mock_validation_delegate_record_->GetEventForPath(kSplitPref);
   ASSERT_EQ(PrefTrackingStrategy::SPLIT, validated_split_pref->strategy);
   ASSERT_FALSE(validated_split_pref->is_personal);
   const MockValidationDelegateRecord::ValidationEvent* validated_atomic_pref =
       mock_validation_delegate_record_->GetEventForPath(kAtomicPref);
   ASSERT_EQ(PrefTrackingStrategy::ATOMIC, validated_atomic_pref->strategy);
   ASSERT_TRUE(validated_atomic_pref->is_personal);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueUnknown) {
-  // Ownership of these values is transfered to |pref_store_contents_|.
-  base::Value* string_value = new base::Value("string value");
-  pref_store_contents_->Set(kAtomicPref, string_value);
+  base::Value* string_value =
+      pref_store_contents_->SetString(kAtomicPref, "string value");
 
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  base::DictionaryValue* dict_value = pref_store_contents_->SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
-  pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         ValueState::UNTRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         ValueState::UNTRUSTED_UNKNOWN_VALUE);
   // If we are enforcing, expect this to report changes.
   DoFilterOnLoad(GetParam() >= EnforcementLevel::ENFORCE_ON_LOAD);
@@ skipping 38 matching lines @@
     const base::Value* split_value_in_store;
     ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
     ASSERT_EQ(dict_value, split_value_in_store);
     ASSERT_EQ(dict_value, stored_split_value.first);
 
     VerifyRecordedReset(false);
   }
 }
 
 TEST_P(PrefHashFilterTest, InitialValueTrustedUnknown) {
-  // Ownership of this value is transfered to |pref_store_contents_|.
-  base::Value* string_value = new base::Value("test");
-  pref_store_contents_->Set(kAtomicPref, string_value);
+  base::Value* string_value =
+      pref_store_contents_->SetString(kAtomicPref, "test");
 
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  auto* dict_value = pref_store_contents_->SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
-  pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref,
                                         ValueState::TRUSTED_UNKNOWN_VALUE);
   mock_pref_hash_store_->SetCheckResult(kSplitPref,
                                         ValueState::TRUSTED_UNKNOWN_VALUE);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
@@ skipping 22 matching lines @@
   const base::Value* split_value_in_store;
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
   ASSERT_EQ(dict_value, split_value_in_store);
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
       mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(dict_value, stored_split_value.first);
   ASSERT_EQ(PrefTrackingStrategy::SPLIT, stored_split_value.second);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueChanged) {
-  // Ownership of this value is transfered to |pref_store_contents_|.
-  base::Value* int_value = new base::Value(1234);
-  pref_store_contents_->Set(kAtomicPref, int_value);
+  base::Value* int_value = pref_store_contents_->SetInteger(kAtomicPref, 1234);
 
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  base::DictionaryValue* dict_value = pref_store_contents_->SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   dict_value->SetInteger("c", 56);
   dict_value->SetBoolean("d", false);
-  pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kSplitPref, ValueState::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
   mock_invalid_keys.push_back("c");
@@ skipping 80 matching lines @@
   ASSERT_EQ(PrefTrackingStrategy::ATOMIC, stored_atomic_value.second);
 
   ASSERT_FALSE(pref_store_contents_->Get(kSplitPref, NULL));
   MockPrefHashStore::ValuePtrStrategyPair stored_split_value =
       mock_pref_hash_store_->stored_value(kSplitPref);
   ASSERT_EQ(NULL, stored_split_value.first);
   ASSERT_EQ(PrefTrackingStrategy::SPLIT, stored_split_value.second);
 }
 
 TEST_P(PrefHashFilterTest, InitialValueUnchangedLegacyId) {
-  // Ownership of these values is transfered to |pref_store_contents_|.
-  base::Value* string_value = new base::Value("string value");
-  pref_store_contents_->Set(kAtomicPref, string_value);
+  base::Value* string_value =
+      pref_store_contents_->SetString(kAtomicPref, "string value");
 
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  base::DictionaryValue* dict_value = pref_store_contents_->SetDictionary(
+      kSplitPref, base::MakeUnique<base::DictionaryValue>());
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
-  pref_store_contents_->Set(kSplitPref, dict_value);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::SECURE_LEGACY);
   mock_pref_hash_store_->SetCheckResult(kSplitPref, ValueState::SECURE_LEGACY);
   DoFilterOnLoad(false);
   ASSERT_EQ(arraysize(kTestTrackedPrefs),
             mock_pref_hash_store_->checked_paths_count());
   ASSERT_EQ(1u, mock_pref_hash_store_->transactions_performed());
@@ skipping 26 matching lines @@
   ASSERT_EQ(PrefTrackingStrategy::SPLIT, stored_split_value.second);
   const base::Value* split_value_in_store;
   ASSERT_TRUE(pref_store_contents_->Get(kSplitPref, &split_value_in_store));
   ASSERT_EQ(dict_value, split_value_in_store);
   ASSERT_EQ(dict_value, stored_split_value.first);
 
   VerifyRecordedReset(false);
 }
 
 TEST_P(PrefHashFilterTest, DontResetReportOnly) {
-  // Ownership of these values is transfered to |pref_store_contents_|.
-  base::Value* int_value1 = new base::Value(1);
-  base::Value* int_value2 = new base::Value(2);
-  base::Value* report_only_val = new base::Value(3);
-  base::DictionaryValue* report_only_split_val = new base::DictionaryValue;
+  base::Value* int_value1 = pref_store_contents_->SetInteger(kAtomicPref, 1);
+  base::Value* int_value2 = pref_store_contents_->SetInteger(kAtomicPref2, 2);
+  base::Value* report_only_val =
+      pref_store_contents_->SetInteger(kReportOnlyPref, 3);
+  base::DictionaryValue* report_only_split_val =
+      pref_store_contents_->SetDictionary(
+          kReportOnlySplitPref, base::MakeUnique<base::DictionaryValue>());
   report_only_split_val->SetInteger("a", 1234);
-  pref_store_contents_->Set(kAtomicPref, int_value1);
-  pref_store_contents_->Set(kAtomicPref2, int_value2);
-  pref_store_contents_->Set(kReportOnlyPref, report_only_val);
-  pref_store_contents_->Set(kReportOnlySplitPref, report_only_split_val);
 
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kAtomicPref2, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlyPref, NULL));
   ASSERT_TRUE(pref_store_contents_->Get(kReportOnlySplitPref, NULL));
 
   mock_pref_hash_store_->SetCheckResult(kAtomicPref, ValueState::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kAtomicPref2, ValueState::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlyPref, ValueState::CHANGED);
   mock_pref_hash_store_->SetCheckResult(kReportOnlySplitPref,
@@ skipping 44 matching lines @@
     ASSERT_EQ(int_value2, value_in_store2);
     ASSERT_EQ(int_value2,
               mock_pref_hash_store_->stored_value(kAtomicPref2).first);
 
     VerifyRecordedReset(false);
   }
 }
 
 TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacks) {
   base::DictionaryValue root_dict;
-  // Ownership of the following values is transfered to |root_dict|.
-  base::Value* int_value1 = new base::Value(1);
-  base::Value* int_value2 = new base::Value(2);
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
-  dict_value->Set("a", new base::Value(true));
-  root_dict.Set(kAtomicPref, int_value1);
-  root_dict.Set(kAtomicPref2, int_value2);
-  root_dict.Set(kSplitPref, dict_value);
+  auto dict_value = base::MakeUnique<base::DictionaryValue>();
+  dict_value->SetBoolean("a", true);
+  root_dict.SetInteger(kAtomicPref, 1);
+  root_dict.SetInteger(kAtomicPref2, 2);
+  root_dict.Set(kSplitPref, std::move(dict_value));
 
   // Skip updating kAtomicPref2.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   pref_hash_filter_->FilterUpdate(kSplitPref);
 
   PrefHashFilter::OnWriteCallbackPair callbacks =
       pref_hash_filter_->FilterSerializeData(&root_dict);
 
   ASSERT_FALSE(callbacks.first.is_null());
 
@@ skipping 21 matching lines @@
                 kSplitPref, "a"));
 
   // The callbacks should write directly to the contents without going through
   // a pref hash store.
   ASSERT_EQ(0u,
             mock_external_validation_pref_hash_store_->stored_paths_count());
 }
 
 TEST_P(PrefHashFilterTest, CallFilterSerializeDataCallbacksWithFailure) {
   base::DictionaryValue root_dict;
-  // Ownership of the following values is transfered to |root_dict|.
-  base::Value* int_value1 = new base::Value(1);
-  root_dict.Set(kAtomicPref, int_value1);
+  root_dict.SetInteger(kAtomicPref, 1);
 
   // Only update kAtomicPref.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
 
   PrefHashFilter::OnWriteCallbackPair callbacks =
       pref_hash_filter_->FilterSerializeData(&root_dict);
 
   ASSERT_FALSE(callbacks.first.is_null());
 
   callbacks.first.Run();
 
   // The pref should have been cleared from the external validation store.
   ASSERT_EQ(
       1u, mock_external_validation_hash_store_contents_->cleared_paths_count());
 
   callbacks.second.Run(false);
 
   // Expect no writes to the external validation hash store contents.
   ASSERT_EQ(0u,
             mock_external_validation_pref_hash_store_->stored_paths_count());
   ASSERT_EQ(
       0u, mock_external_validation_hash_store_contents_->stored_hashes_count());
 }
 
 TEST_P(PrefHashFilterTest, ExternalValidationValueChanged) {
-  // Ownership of this value is transfered to |pref_store_contents_|.
-  base::Value* int_value = new base::Value(1234);
-  pref_store_contents_->Set(kAtomicPref, int_value);
+  pref_store_contents_->SetInteger(kAtomicPref, 1234);
 
-  base::DictionaryValue* dict_value = new base::DictionaryValue;
+  auto dict_value = base::MakeUnique<base::DictionaryValue>();
   dict_value->SetString("a", "foo");
   dict_value->SetInteger("b", 1234);
   dict_value->SetInteger("c", 56);
   dict_value->SetBoolean("d", false);
-  pref_store_contents_->Set(kSplitPref, dict_value);
+  pref_store_contents_->Set(kSplitPref, std::move(dict_value));
 
   mock_external_validation_pref_hash_store_->SetCheckResult(
       kAtomicPref, ValueState::CHANGED);
   mock_external_validation_pref_hash_store_->SetCheckResult(
       kSplitPref, ValueState::CHANGED);
 
   std::vector<std::string> mock_invalid_keys;
   mock_invalid_keys.push_back("a");
   mock_invalid_keys.push_back("c");
   mock_external_validation_pref_hash_store_->SetInvalidKeysResult(
@@ skipping 22 matching lines @@
                 ValueState::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_record_->CountExternalValidationsOfState(
                 ValueState::UNCHANGED));
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
                         PrefHashFilterTest,
                         testing::Values(EnforcementLevel::NO_ENFORCEMENT,
                                         EnforcementLevel::ENFORCE_ON_LOAD));