components/prefs/pref_service_unittest.cc

   1 // Copyright 2012 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <stddef.h>
   6 #include <stdint.h>
   7
   8 #include <string>
   9
  10 #include "base/callback_helpers.h"
  11 #include "base/time/time.h"
  12 #include "base/values.h"
  13 #include "components/prefs/json_pref_store.h"
  14 #include "components/prefs/mock_pref_change_callback.h"
  15 #include "components/prefs/pref_change_registrar.h"
  16 #include "components/prefs/pref_notifier_impl.h"
  17 #include "components/prefs/pref_registry_simple.h"
  18 #include "components/prefs/pref_service_factory.h"
  19 #include "components/prefs/pref_value_store.h"
  20 #include "components/prefs/testing_pref_service.h"
  21 #include "components/prefs/testing_pref_store.h"
  22 #include "testing/gmock/include/gmock/gmock.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24
  25 using testing::_;
  26 using testing::Mock;
  27
  28 namespace {
  29
  30 const char kPrefName[] = "pref.name";
  31 const char kStandaloneBrowserPref[] = "standalone_browser_pref";
  32
  33 }  // namespace
  34
  35 TEST(PrefServiceTest, NoObserverFire) {
  36   TestingPrefServiceSimple prefs;
  37
  38   const char pref_name[] = "homepage";
  39   prefs.registry()->RegisterStringPref(pref_name, std::string());
  40
  41   const char new_pref_value[] = "http://www.google.com/";
  42   MockPrefChangeCallback obs(&prefs);
  43   PrefChangeRegistrar registrar;
  44   registrar.Init(&prefs);
  45   registrar.Add(pref_name, obs.GetCallback());
  46
  47   // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
  48   const base::Value expected_value(new_pref_value);
  49   obs.Expect(pref_name, &expected_value);
  50   prefs.SetString(pref_name, new_pref_value);
  51   Mock::VerifyAndClearExpectations(&obs);
  52
  53   // Setting the pref to the same value should not set the pref value a second
  54   // time.
  55   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
  56   prefs.SetString(pref_name, new_pref_value);
  57   Mock::VerifyAndClearExpectations(&obs);
  58
  59   // Clearing the pref should cause the pref to fire.
  60   const base::Value expected_default_value((std::string()));
  61   obs.Expect(pref_name, &expected_default_value);
  62   prefs.ClearPref(pref_name);
  63   Mock::VerifyAndClearExpectations(&obs);
  64
  65   // Clearing the pref again should not cause the pref to fire.
  66   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
  67   prefs.ClearPref(pref_name);
  68   Mock::VerifyAndClearExpectations(&obs);
  69 }
  70
  71 TEST(PrefServiceTest, HasPrefPath) {
  72   TestingPrefServiceSimple prefs;
  73
  74   const char path[] = "fake.path";
  75
  76   // Shouldn't initially have a path.
  77   EXPECT_FALSE(prefs.HasPrefPath(path));
  78
  79   // Register the path. This doesn't set a value, so the path still shouldn't
  80   // exist.
  81   prefs.registry()->RegisterStringPref(path, std::string());
  82   EXPECT_FALSE(prefs.HasPrefPath(path));
  83
  84   // Set a value and make sure we have a path.
  85   prefs.SetString(path, "blah");
  86   EXPECT_TRUE(prefs.HasPrefPath(path));
  87 }
  88
  89 TEST(PrefServiceTest, Observers) {
  90   const char pref_name[] = "homepage";
  91
  92   TestingPrefServiceSimple prefs;
  93   prefs.SetUserPref(pref_name, base::Value("http://www.cnn.com"));
  94   prefs.registry()->RegisterStringPref(pref_name, std::string());
  95
  96   const char new_pref_value[] = "http://www.google.com/";
  97   const base::Value expected_new_pref_value(new_pref_value);
  98   MockPrefChangeCallback obs(&prefs);
  99   PrefChangeRegistrar registrar;
 100   registrar.Init(&prefs);
 101   registrar.Add(pref_name, obs.GetCallback());
 102
 103   PrefChangeRegistrar registrar_two;
 104   registrar_two.Init(&prefs);
 105
 106   // This should fire the checks in MockPrefChangeCallback::OnPreferenceChanged.
 107   obs.Expect(pref_name, &expected_new_pref_value);
 108   prefs.SetString(pref_name, new_pref_value);
 109   Mock::VerifyAndClearExpectations(&obs);
 110
 111   // Now try adding a second pref observer.
 112   const char new_pref_value2[] = "http://www.youtube.com/";
 113   const base::Value expected_new_pref_value2(new_pref_value2);
 114   MockPrefChangeCallback obs2(&prefs);
 115   obs.Expect(pref_name, &expected_new_pref_value2);
 116   obs2.Expect(pref_name, &expected_new_pref_value2);
 117   registrar_two.Add(pref_name, obs2.GetCallback());
 118   // This should fire the checks in obs and obs2.
 119   prefs.SetString(pref_name, new_pref_value2);
 120   Mock::VerifyAndClearExpectations(&obs);
 121   Mock::VerifyAndClearExpectations(&obs2);
 122
 123   // Set a recommended value.
 124   const base::Value recommended_pref_value("http://www.gmail.com/");
 125   obs.Expect(pref_name, &expected_new_pref_value2);
 126   obs2.Expect(pref_name, &expected_new_pref_value2);
 127   // This should fire the checks in obs and obs2 but with an unchanged value
 128   // as the recommended value is being overridden by the user-set value.
 129   prefs.SetRecommendedPref(pref_name, recommended_pref_value.Clone());
 130   Mock::VerifyAndClearExpectations(&obs);
 131   Mock::VerifyAndClearExpectations(&obs2);
 132
 133   // Make sure obs2 still works after removing obs.
 134   registrar.Remove(pref_name);
 135   EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
 136   obs2.Expect(pref_name, &expected_new_pref_value);
 137   // This should only fire the observer in obs2.
 138   prefs.SetString(pref_name, new_pref_value);
 139   Mock::VerifyAndClearExpectations(&obs);
 140   Mock::VerifyAndClearExpectations(&obs2);
 141 }
 142
 143 // Make sure that if a preference changes type, so the wrong type is stored in
 144 // the user pref file, it uses the correct fallback value instead.
 145 TEST(PrefServiceTest, GetValueChangedType) {
 146   const int kTestValue = 10;
 147   TestingPrefServiceSimple prefs;
 148   prefs.registry()->RegisterIntegerPref(kPrefName, kTestValue);
 149
 150   // Check falling back to a recommended value.
 151   prefs.SetUserPref(kPrefName, base::Value("not an integer"));
 152   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
 153   ASSERT_TRUE(pref);
 154   const base::Value* value = pref->GetValue();
 155   ASSERT_TRUE(value);
 156   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 157   ASSERT_TRUE(value->is_int());
 158   EXPECT_EQ(kTestValue, value->GetInt());
 159 }
 160
 161 TEST(PrefServiceTest, GetValueAndGetRecommendedValue) {
 162   const int kDefaultValue = 5;
 163   const int kUserValue = 10;
 164   const int kRecommendedValue = 15;
 165   TestingPrefServiceSimple prefs;
 166   prefs.registry()->RegisterIntegerPref(kPrefName, kDefaultValue);
 167
 168   // Create pref with a default value only.
 169   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
 170   ASSERT_TRUE(pref);
 171
 172   // Check that GetValue() returns the default value.
 173   const base::Value* value = pref->GetValue();
 174   ASSERT_TRUE(value);
 175   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 176   ASSERT_TRUE(value->is_int());
 177   EXPECT_EQ(kDefaultValue, value->GetInt());
 178
 179   // Check that GetRecommendedValue() returns no value.
 180   value = pref->GetRecommendedValue();
 181   ASSERT_FALSE(value);
 182
 183   // Set a user-set value.
 184   prefs.SetUserPref(kPrefName, base::Value(kUserValue));
 185
 186   // Check that GetValue() returns the user-set value.
 187   value = pref->GetValue();
 188   ASSERT_TRUE(value);
 189   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 190   ASSERT_TRUE(value->is_int());
 191   EXPECT_EQ(kUserValue, value->GetInt());
 192
 193   // Check that GetRecommendedValue() returns no value.
 194   value = pref->GetRecommendedValue();
 195   ASSERT_FALSE(value);
 196
 197   // Set a recommended value.
 198   prefs.SetRecommendedPref(kPrefName, base::Value(kRecommendedValue));
 199
 200   // Check that GetValue() returns the user-set value.
 201   value = pref->GetValue();
 202   ASSERT_TRUE(value);
 203   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 204   ASSERT_TRUE(value->is_int());
 205   EXPECT_EQ(kUserValue, value->GetInt());
 206
 207   // Check that GetRecommendedValue() returns the recommended value.
 208   value = pref->GetRecommendedValue();
 209   ASSERT_TRUE(value);
 210   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 211   ASSERT_TRUE(value->is_int());
 212   EXPECT_EQ(kRecommendedValue, value->GetInt());
 213
 214   // Remove the user-set value.
 215   prefs.RemoveUserPref(kPrefName);
 216
 217   // Check that GetValue() returns the recommended value.
 218   value = pref->GetValue();
 219   ASSERT_TRUE(value);
 220   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 221   ASSERT_TRUE(value->is_int());
 222   EXPECT_EQ(kRecommendedValue, value->GetInt());
 223
 224   // Check that GetRecommendedValue() returns the recommended value.
 225   value = pref->GetRecommendedValue();
 226   ASSERT_TRUE(value);
 227   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 228   ASSERT_TRUE(value->is_int());
 229   EXPECT_EQ(kRecommendedValue, value->GetInt());
 230 }
 231
 232 TEST(PrefServiceTest, SetTimeValue_RegularTime) {
 233   TestingPrefServiceSimple prefs;
 234
 235   // Register a null time as the default.
 236   prefs.registry()->RegisterTimePref(kPrefName, base::Time());
 237   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 238
 239   // Set a time and make sure that we can read it without any loss of precision.
 240   const base::Time time = base::Time::Now();
 241   prefs.SetTime(kPrefName, time);
 242   EXPECT_EQ(time, prefs.GetTime(kPrefName));
 243 }
 244
 245 TEST(PrefServiceTest, SetTimeValue_NullTime) {
 246   TestingPrefServiceSimple prefs;
 247
 248   // Register a non-null time as the default.
 249   const base::Time default_time =
 250       base::Time::FromDeltaSinceWindowsEpoch(base::Microseconds(12345));
 251   prefs.registry()->RegisterTimePref(kPrefName, default_time);
 252   EXPECT_FALSE(prefs.GetTime(kPrefName).is_null());
 253
 254   // Set a null time and make sure that it remains null upon deserialization.
 255   prefs.SetTime(kPrefName, base::Time());
 256   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 257 }
 258
 259 TEST(PrefServiceTest, SetTimeDeltaValue_RegularTimeDelta) {
 260   TestingPrefServiceSimple prefs;
 261
 262   // Register a zero time delta as the default.
 263   prefs.registry()->RegisterTimeDeltaPref(kPrefName, base::TimeDelta());
 264   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 265
 266   // Set a time delta and make sure that we can read it without any loss of
 267   // precision.
 268   const base::TimeDelta delta = base::Time::Now() - base::Time();
 269   prefs.SetTimeDelta(kPrefName, delta);
 270   EXPECT_EQ(delta, prefs.GetTimeDelta(kPrefName));
 271 }
 272
 273 TEST(PrefServiceTest, SetTimeDeltaValue_ZeroTimeDelta) {
 274   TestingPrefServiceSimple prefs;
 275
 276   // Register a non-zero time delta as the default.
 277   const base::TimeDelta default_delta = base::Microseconds(12345);
 278   prefs.registry()->RegisterTimeDeltaPref(kPrefName, default_delta);
 279   EXPECT_FALSE(prefs.GetTimeDelta(kPrefName).is_zero());
 280
 281   // Set a zero time delta and make sure that it remains zero upon
 282   // deserialization.
 283   prefs.SetTimeDelta(kPrefName, base::TimeDelta());
 284   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 285 }
 286
 287 // A PrefStore which just stores the last write flags that were used to write
 288 // values to it.
 289 class WriteFlagChecker : public TestingPrefStore {
 290  public:
 291   WriteFlagChecker() {}
 292
 293   void ReportValueChanged(const std::string& key, uint32_t flags) override {
 294     SetLastWriteFlags(flags);
 295   }
 296
 297   void SetValue(const std::string& key,
 298                 base::Value value,
 299                 uint32_t flags) override {
 300     SetLastWriteFlags(flags);
 301   }
 302
 303   void SetValueSilently(const std::string& key,
 304                         base::Value value,
 305                         uint32_t flags) override {
 306     SetLastWriteFlags(flags);
 307   }
 308
 309   void RemoveValue(const std::string& key, uint32_t flags) override {
 310     SetLastWriteFlags(flags);
 311   }
 312
 313   uint32_t GetLastFlagsAndClear() {
 314     CHECK(last_write_flags_set_);
 315     uint32_t result = last_write_flags_;
 316     last_write_flags_set_ = false;
 317     last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 318     return result;
 319   }
 320
 321   bool last_write_flags_set() { return last_write_flags_set_; }
 322
 323  private:
 324   ~WriteFlagChecker() override {}
 325
 326   void SetLastWriteFlags(uint32_t flags) {
 327     CHECK(!last_write_flags_set_);
 328     last_write_flags_set_ = true;
 329     last_write_flags_ = flags;
 330   }
 331
 332   bool last_write_flags_set_ = false;
 333   uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 334 };
 335
 336 TEST(PrefServiceTest, WriteablePrefStoreFlags) {
 337   scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker);
 338   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
 339   PrefServiceFactory factory;
 340   factory.set_user_prefs(flag_checker);
 341   std::unique_ptr<PrefService> prefs(factory.Create(registry.get()));
 342
 343   // The first 8 bits of write flags are reserved for subclasses. Create a
 344   // custom flag in this range
 345   uint32_t kCustomRegistrationFlag = 1 << 2;
 346
 347   // A map of the registration flags that will be tested and the write flags
 348   // they are expected to convert to.
 349   struct RegistrationToWriteFlags {
 350     const char* pref_name;
 351     uint32_t registration_flags;
 352     uint32_t write_flags;
 353   };
 354   const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
 355       {"none",
 356        PrefRegistry::NO_REGISTRATION_FLAGS,
 357        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 358       {"lossy",
 359        PrefRegistry::LOSSY_PREF,
 360        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
 361       {"custom",
 362        kCustomRegistrationFlag,
 363        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 364       {"lossyandcustom",
 365        PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
 366        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
 367
 368   for (size_t i = 0; i < std::size(kRegistrationToWriteFlags); ++i) {
 369     RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
 370     registry->RegisterDictionaryPref(entry.pref_name,
 371                                      entry.registration_flags);
 372
 373     SCOPED_TRACE("Currently testing pref with name: " +
 374                  std::string(entry.pref_name));
 375
 376     prefs->GetMutableUserPref(entry.pref_name, base::Value::Type::DICTIONARY);
 377     EXPECT_TRUE(flag_checker->last_write_flags_set());
 378     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 379
 380     prefs->ReportUserPrefChanged(entry.pref_name);
 381     EXPECT_TRUE(flag_checker->last_write_flags_set());
 382     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 383
 384     prefs->ClearPref(entry.pref_name);
 385     EXPECT_TRUE(flag_checker->last_write_flags_set());
 386     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 387
 388     prefs->SetUserPrefValue(entry.pref_name,
 389                             base::Value(base::Value::Type::DICTIONARY));
 390     EXPECT_TRUE(flag_checker->last_write_flags_set());
 391     EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
 392   }
 393 }
 394
 395 class PrefServiceSetValueTest : public testing::Test {
 396  protected:
 397   static const char kName[];
 398   static const char kValue[];
 399
 400   PrefServiceSetValueTest() : observer_(&prefs_) {}
 401
 402   TestingPrefServiceSimple prefs_;
 403   MockPrefChangeCallback observer_;
 404 };
 405
 406 const char PrefServiceSetValueTest::kName[] = "name";
 407 const char PrefServiceSetValueTest::kValue[] = "value";
 408
 409 TEST_F(PrefServiceSetValueTest, SetStringValue) {
 410   const char default_string[] = "default";
 411   const base::Value default_value(default_string);
 412   prefs_.registry()->RegisterStringPref(kName, default_string);
 413
 414   PrefChangeRegistrar registrar;
 415   registrar.Init(&prefs_);
 416   registrar.Add(kName, observer_.GetCallback());
 417
 418   // Changing the controlling store from default to user triggers notification.
 419   observer_.Expect(kName, &default_value);
 420   prefs_.Set(kName, default_value);
 421   Mock::VerifyAndClearExpectations(&observer_);
 422
 423   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 424   prefs_.Set(kName, default_value);
 425   Mock::VerifyAndClearExpectations(&observer_);
 426
 427   base::Value new_value(kValue);
 428   observer_.Expect(kName, &new_value);
 429   prefs_.Set(kName, new_value);
 430   Mock::VerifyAndClearExpectations(&observer_);
 431 }
 432
 433 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) {
 434   prefs_.registry()->RegisterDictionaryPref(kName);
 435   PrefChangeRegistrar registrar;
 436   registrar.Init(&prefs_);
 437   registrar.Add(kName, observer_.GetCallback());
 438
 439   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 440   prefs_.RemoveUserPref(kName);
 441   Mock::VerifyAndClearExpectations(&observer_);
 442
 443   base::DictionaryValue new_value;
 444   new_value.SetString(kName, kValue);
 445   observer_.Expect(kName, &new_value);
 446   prefs_.Set(kName, new_value);
 447   Mock::VerifyAndClearExpectations(&observer_);
 448
 449   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 450   prefs_.Set(kName, new_value);
 451   Mock::VerifyAndClearExpectations(&observer_);
 452
 453   base::DictionaryValue empty;
 454   observer_.Expect(kName, &empty);
 455   prefs_.Set(kName, empty);
 456   Mock::VerifyAndClearExpectations(&observer_);
 457 }
 458
 459 TEST_F(PrefServiceSetValueTest, SetListValue) {
 460   prefs_.registry()->RegisterListPref(kName);
 461   PrefChangeRegistrar registrar;
 462   registrar.Init(&prefs_);
 463   registrar.Add(kName, observer_.GetCallback());
 464
 465   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 466   prefs_.RemoveUserPref(kName);
 467   Mock::VerifyAndClearExpectations(&observer_);
 468
 469   base::ListValue new_value;
 470   new_value.Append(kValue);
 471   observer_.Expect(kName, &new_value);
 472   prefs_.Set(kName, new_value);
 473   Mock::VerifyAndClearExpectations(&observer_);
 474
 475   EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
 476   prefs_.Set(kName, new_value);
 477   Mock::VerifyAndClearExpectations(&observer_);
 478
 479   base::ListValue empty;
 480   observer_.Expect(kName, &empty);
 481   prefs_.Set(kName, empty);
 482   Mock::VerifyAndClearExpectations(&observer_);
 483 }
 484
 485 class PrefStandaloneBrowserPrefsTest : public testing::Test {
 486  protected:
 487   PrefStandaloneBrowserPrefsTest()
 488       : user_pref_store_(base::MakeRefCounted<TestingPrefStore>()),
 489         standalone_browser_pref_store_(
 490             base::MakeRefCounted<TestingPrefStore>()),
 491         pref_registry_(base::MakeRefCounted<PrefRegistrySimple>()) {}
 492
 493   ~PrefStandaloneBrowserPrefsTest() override = default;
 494
 495   void SetUp() override {
 496     auto pref_notifier = std::make_unique<PrefNotifierImpl>();
 497     auto pref_value_store = std::make_unique<PrefValueStore>(
 498         nullptr /* managed_prefs */, nullptr /* supervised_user_prefs */,
 499         nullptr /* extension_prefs */, standalone_browser_pref_store_.get(),
 500         new TestingPrefStore(), user_pref_store_.get(),
 501         nullptr /* recommended_prefs */, pref_registry_->defaults().get(),
 502         pref_notifier.get());
 503     pref_service_ = std::make_unique<PrefService>(
 504         std::move(pref_notifier), std::move(pref_value_store), user_pref_store_,
 505         standalone_browser_pref_store_, pref_registry_, base::DoNothing(),
 506         false);
 507     pref_registry_->RegisterIntegerPref(kStandaloneBrowserPref, 4);
 508   }
 509
 510   std::unique_ptr<PrefService> pref_service_;
 511   scoped_refptr<TestingPrefStore> user_pref_store_;
 512   scoped_refptr<TestingPrefStore> standalone_browser_pref_store_;
 513   scoped_refptr<PrefRegistrySimple> pref_registry_;
 514 };
 515
 516 // Check that the standalone browser pref store is correctly initialized,
 517 // written to, read, and has correct precedence.
 518 TEST_F(PrefStandaloneBrowserPrefsTest, CheckStandaloneBrowserPref) {
 519   const PrefService::Preference* preference =
 520       pref_service_->FindPreference(kStandaloneBrowserPref);
 521   EXPECT_TRUE(preference->IsDefaultValue());
 522   EXPECT_EQ(base::Value(4), *(preference->GetValue()));
 523   user_pref_store_->SetInteger(kStandaloneBrowserPref, 11);
 524   EXPECT_EQ(base::Value(11), *(preference->GetValue()));
 525   // The standalone_browser_pref_store has higher precedence.
 526   standalone_browser_pref_store_->SetInteger(kStandaloneBrowserPref, 10);
 527   ASSERT_EQ(base::Value(10), *(preference->GetValue()));
 528   // Removing user_pref_store value shouldn't change the pref value.
 529   user_pref_store_->RemoveValue(kStandaloneBrowserPref,
 530                                 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 531   ASSERT_EQ(base::Value(10), *(preference->GetValue()));
 532   // Now removing the standalone_browser_pref_store value should revert the
 533   // value to default.
 534   standalone_browser_pref_store_->RemoveValue(
 535       kStandaloneBrowserPref, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
 536   EXPECT_EQ(base::Value(4), *(preference->GetValue()));
 537 }