Remove FundamentalValue

components/user_prefs/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 "components/user_prefs/tracked/pref_hash_filter.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <memory>
@@ skipping 784 matching lines @@
   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::FundamentalValue(1);
-  base::Value* int_value2 = new base::FundamentalValue(2);
-  base::Value* int_value3 = new base::FundamentalValue(3);
-  base::Value* int_value4 = new base::FundamentalValue(4);
+  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::FundamentalValue(true));
+  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);
 
   // 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::FundamentalValue(5);
+  base::Value* int_value5 = new base::Value(5);
   root_dict.Set(kAtomicPref3, int_value5);
   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);
@@ skipping 172 matching lines @@
   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(PrefHashFilter::TRACKING_STRATEGY_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::FundamentalValue(1234);
+  base::Value* int_value = new base::Value(1234);
   pref_store_contents_->Set(kAtomicPref, int_value);
 
   base::DictionaryValue* dict_value = new 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));
@@ skipping 152 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, DontResetReportOnly) {
   // Ownership of these values is transfered to |pref_store_contents_|.
-  base::Value* int_value1 = new base::FundamentalValue(1);
-  base::Value* int_value2 = new base::FundamentalValue(2);
-  base::Value* report_only_val = new base::FundamentalValue(3);
+  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;
   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));
@@ skipping 54 matching lines @@
     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::FundamentalValue(1);
-  base::Value* int_value2 = new base::FundamentalValue(2);
+  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::FundamentalValue(true));
+  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);
 
   // Skip updating kAtomicPref2.
   pref_hash_filter_->FilterUpdate(kAtomicPref);
   pref_hash_filter_->FilterUpdate(kSplitPref);
 
   PrefHashFilter::OnWriteCallbackPair callbacks =
       pref_hash_filter_->FilterSerializeData(&root_dict);
@@ skipping 25 matching lines @@
 
   // 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::FundamentalValue(1);
+  base::Value* int_value1 = new base::Value(1);
   root_dict.Set(kAtomicPref, int_value1);
 
   // 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::FundamentalValue(1234);
+  base::Value* int_value = new base::Value(1234);
   pref_store_contents_->Set(kAtomicPref, int_value);
 
   base::DictionaryValue* dict_value = new 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);
 
   mock_external_validation_pref_hash_store_->SetCheckResult(
@@ skipping 29 matching lines @@
                     PrefHashStoreTransaction::CHANGED));
   ASSERT_EQ(arraysize(kTestTrackedPrefs) - 2u,
             mock_validation_delegate_.CountExternalValidationsOfState(
                 PrefHashStoreTransaction::UNCHANGED));
 }
 
 INSTANTIATE_TEST_CASE_P(PrefHashFilterTestInstance,
                         PrefHashFilterTest,
                         testing::Values(PrefHashFilter::NO_ENFORCEMENT,
                                         PrefHashFilter::ENFORCE_ON_LOAD));