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