components/prefs/pref_service_unittest.cc

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