Remove base::FundamentalValue

components/prefs/overlay_user_pref_store_unittest.cc

 // Copyright (c) 2012 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/prefs/overlay_user_pref_store.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "components/prefs/pref_store_observer_mock.h"
 #include "components/prefs/testing_pref_store.h"
@@ skipping 34 matching lines @@
 
   scoped_refptr<TestingPrefStore> underlay_;
   scoped_refptr<OverlayUserPrefStore> overlay_;
 };
 
 TEST_F(OverlayUserPrefStoreTest, Observer) {
   PrefStoreObserverMock obs;
   overlay_->AddObserver(&obs);
 
   // Check that underlay first value is reported.
-  underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(42),
+  underlay_->SetValue(overlay_key, base::MakeUnique<Value>(42),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(overlay_key);
 
   // Check that underlay overwriting is reported.
-  underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(43),
+  underlay_->SetValue(overlay_key, base::MakeUnique<Value>(43),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(overlay_key);
 
   // Check that overwriting change in overlay is reported.
-  overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(44),
+  overlay_->SetValue(overlay_key, base::MakeUnique<Value>(44),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(overlay_key);
 
   // Check that hidden underlay change is not reported.
-  underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(45),
+  underlay_->SetValue(overlay_key, base::MakeUnique<Value>(45),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 
   // Check that overlay remove is reported.
   overlay_->RemoveValue(overlay_key,
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(overlay_key);
 
   // Check that underlay remove is reported.
   underlay_->RemoveValue(overlay_key,
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(overlay_key);
 
   // Check respecting of silence.
-  overlay_->SetValueSilently(overlay_key,
-                             base::MakeUnique<FundamentalValue>(46),
+  overlay_->SetValueSilently(overlay_key, base::MakeUnique<Value>(46),
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 
   overlay_->RemoveObserver(&obs);
 
   // Check successful unsubscription.
-  underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(47),
+  underlay_->SetValue(overlay_key, base::MakeUnique<Value>(47),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(48),
+  overlay_->SetValue(overlay_key, base::MakeUnique<Value>(48),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 }
 
 TEST_F(OverlayUserPrefStoreTest, GetAndSet) {
   const Value* value = NULL;
   EXPECT_FALSE(overlay_->GetValue(overlay_key, &value));
   EXPECT_FALSE(underlay_->GetValue(overlay_key, &value));
 
-  underlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(42),
+  underlay_->SetValue(overlay_key, base::MakeUnique<Value>(42),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   // Value shines through:
   EXPECT_TRUE(overlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 
   EXPECT_TRUE(underlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 
-  overlay_->SetValue(overlay_key, base::MakeUnique<FundamentalValue>(43),
+  overlay_->SetValue(overlay_key, base::MakeUnique<Value>(43),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   EXPECT_TRUE(overlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   EXPECT_TRUE(underlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 
   overlay_->RemoveValue(overlay_key,
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   // Value shines through:
   EXPECT_TRUE(overlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 
   EXPECT_TRUE(underlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 }
 
 // Check that GetMutableValue does not return the dictionary of the underlay.
 TEST_F(OverlayUserPrefStoreTest, ModifyDictionaries) {
   underlay_->SetValue(overlay_key, base::WrapUnique(new DictionaryValue),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   Value* modify = NULL;
   EXPECT_TRUE(overlay_->GetMutableValue(overlay_key, &modify));
   ASSERT_TRUE(modify);
@@ skipping 14 matching lines @@
 }
 
 // Here we consider a global preference that is not overlayed.
 TEST_F(OverlayUserPrefStoreTest, GlobalPref) {
   PrefStoreObserverMock obs;
   overlay_->AddObserver(&obs);
 
   const Value* value = NULL;
 
   // Check that underlay first value is reported.
-  underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(regular_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(regular_key);
 
   // Check that underlay overwriting is reported.
-  underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(43)),
+  underlay_->SetValue(regular_key, base::WrapUnique(new Value(43)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(regular_key);
 
   // Check that we get this value from the overlay
   EXPECT_TRUE(overlay_->GetValue(regular_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   // Check that overwriting change in overlay is reported.
-  overlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(44)),
+  overlay_->SetValue(regular_key, base::WrapUnique(new Value(44)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(regular_key);
 
   // Check that we get this value from the overlay and the underlay.
   EXPECT_TRUE(overlay_->GetValue(regular_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(44).Equals(value));
+  EXPECT_TRUE(base::Value(44).Equals(value));
   EXPECT_TRUE(underlay_->GetValue(regular_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(44).Equals(value));
+  EXPECT_TRUE(base::Value(44).Equals(value));
 
   // Check that overlay remove is reported.
   overlay_->RemoveValue(regular_key,
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(regular_key);
 
   // Check that value was removed from overlay and underlay
   EXPECT_FALSE(overlay_->GetValue(regular_key, &value));
   EXPECT_FALSE(underlay_->GetValue(regular_key, &value));
 
   // Check respecting of silence.
-  overlay_->SetValueSilently(regular_key,
-                             base::WrapUnique(new FundamentalValue(46)),
+  overlay_->SetValueSilently(regular_key, base::WrapUnique(new Value(46)),
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 
   overlay_->RemoveObserver(&obs);
 
   // Check successful unsubscription.
-  underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(47)),
+  underlay_->SetValue(regular_key, base::WrapUnique(new Value(47)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(48)),
+  overlay_->SetValue(regular_key, base::WrapUnique(new Value(48)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 }
 
 // Check that names mapping works correctly.
 TEST_F(OverlayUserPrefStoreTest, NamesMapping) {
   PrefStoreObserverMock obs;
   overlay_->AddObserver(&obs);
 
   const Value* value = NULL;
 
   // Check that if there is no override in the overlay, changing underlay value
   // is reported as changing an overlay value.
-  underlay_->SetValue(mapped_underlay_key,
-                      base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(mapped_underlay_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(mapped_overlay_key);
 
   // Check that underlay overwriting is reported.
-  underlay_->SetValue(mapped_underlay_key,
-                      base::WrapUnique(new FundamentalValue(43)),
+  underlay_->SetValue(mapped_underlay_key, base::WrapUnique(new Value(43)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(mapped_overlay_key);
 
   // Check that we get this value from the overlay with both keys
   EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
   // In this case, overlay reads directly from the underlay.
   EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   // Check that overwriting change in overlay is reported.
-  overlay_->SetValue(mapped_overlay_key,
-                     base::WrapUnique(new FundamentalValue(44)),
+  overlay_->SetValue(mapped_overlay_key, base::WrapUnique(new Value(44)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(mapped_overlay_key);
 
   // Check that we get an overriden value from overlay, while reading the
   // value from underlay still holds an old value.
   EXPECT_TRUE(overlay_->GetValue(mapped_overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(44).Equals(value));
+  EXPECT_TRUE(base::Value(44).Equals(value));
   EXPECT_TRUE(overlay_->GetValue(mapped_underlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
   EXPECT_TRUE(underlay_->GetValue(mapped_underlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   // Check that hidden underlay change is not reported.
-  underlay_->SetValue(mapped_underlay_key,
-                      base::WrapUnique(new FundamentalValue(45)),
+  underlay_->SetValue(mapped_underlay_key, base::WrapUnique(new Value(45)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 
   // Check that overlay remove is reported.
   overlay_->RemoveValue(mapped_overlay_key,
                         WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(mapped_overlay_key);
 
   // Check that underlay remove is reported.
   underlay_->RemoveValue(mapped_underlay_key,
                          WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   obs.VerifyAndResetChangedKey(mapped_overlay_key);
 
   // Check that value was removed.
   EXPECT_FALSE(overlay_->GetValue(mapped_overlay_key, &value));
   EXPECT_FALSE(overlay_->GetValue(mapped_underlay_key, &value));
 
   // Check respecting of silence.
   overlay_->SetValueSilently(mapped_overlay_key,
-                             base::WrapUnique(new FundamentalValue(46)),
+                             base::WrapUnique(new Value(46)),
                              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 
   overlay_->RemoveObserver(&obs);
 
   // Check successful unsubscription.
-  underlay_->SetValue(mapped_underlay_key,
-                      base::WrapUnique(new FundamentalValue(47)),
+  underlay_->SetValue(mapped_underlay_key, base::WrapUnique(new Value(47)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(mapped_overlay_key,
-                     base::WrapUnique(new FundamentalValue(48)),
+  overlay_->SetValue(mapped_overlay_key, base::WrapUnique(new Value(48)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   EXPECT_TRUE(obs.changed_keys.empty());
 }
 
 // Check that mutable values are removed correctly.
 TEST_F(OverlayUserPrefStoreTest, ClearMutableValues) {
   // Set in overlay and underlay the same preference.
-  underlay_->SetValue(overlay_key, base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(overlay_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(overlay_key, base::WrapUnique(new FundamentalValue(43)),
+  overlay_->SetValue(overlay_key, base::WrapUnique(new Value(43)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   const Value* value = nullptr;
   // Check that an overlay preference is returned.
   EXPECT_TRUE(overlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
   overlay_->ClearMutableValues();
 
   // Check that an underlay preference is returned.
   EXPECT_TRUE(overlay_->GetValue(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 }
 
 TEST_F(OverlayUserPrefStoreTest, GetValues) {
   // To check merge behavior, create underlay and overlay so each has a key the
   // other doesn't have and they have one key in common.
-  underlay_->SetValue(regular_key, base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(regular_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(overlay_key, base::WrapUnique(new FundamentalValue(43)),
+  overlay_->SetValue(overlay_key, base::WrapUnique(new Value(43)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  underlay_->SetValue(shared_key, base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(shared_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(shared_key, base::WrapUnique(new FundamentalValue(43)),
+  overlay_->SetValue(shared_key, base::WrapUnique(new Value(43)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  underlay_->SetValue(mapped_underlay_key,
-                      base::WrapUnique(new FundamentalValue(42)),
+  underlay_->SetValue(mapped_underlay_key, base::WrapUnique(new Value(42)),
                       WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
-  overlay_->SetValue(mapped_overlay_key,
-                     base::WrapUnique(new FundamentalValue(43)),
+  overlay_->SetValue(mapped_overlay_key, base::WrapUnique(new Value(43)),
                      WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 
   auto values = overlay_->GetValues();
   const Value* value = nullptr;
   // Check that an overlay preference is returned.
   ASSERT_TRUE(values->Get(overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   // Check that an underlay preference is returned.
   ASSERT_TRUE(values->Get(regular_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(42).Equals(value));
+  EXPECT_TRUE(base::Value(42).Equals(value));
 
   // Check that the overlay is preferred.
   ASSERT_TRUE(values->Get(shared_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
 
   // Check that mapping works.
   ASSERT_TRUE(values->Get(mapped_overlay_key, &value));
-  EXPECT_TRUE(base::FundamentalValue(43).Equals(value));
+  EXPECT_TRUE(base::Value(43).Equals(value));
   EXPECT_FALSE(values->Get(mapped_underlay_key, &value));
 }
 
 }  // namespace base