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/bind_helpers.h"
  11 #include "base/stl_util.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   int actual_int_value = -1;
 162   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 163   EXPECT_EQ(kTestValue, actual_int_value);
 164 }
 165
 166 TEST(PrefServiceTest, GetValueAndGetRecommendedValue) {
 167   const int kDefaultValue = 5;
 168   const int kUserValue = 10;
 169   const int kRecommendedValue = 15;
 170   TestingPrefServiceSimple prefs;
 171   prefs.registry()->RegisterIntegerPref(kPrefName, kDefaultValue);
 172
 173   // Create pref with a default value only.
 174   const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
 175   ASSERT_TRUE(pref);
 176
 177   // Check that GetValue() returns the default value.
 178   const base::Value* value = pref->GetValue();
 179   ASSERT_TRUE(value);
 180   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 181   int actual_int_value = -1;
 182   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 183   EXPECT_EQ(kDefaultValue, actual_int_value);
 184
 185   // Check that GetRecommendedValue() returns no value.
 186   value = pref->GetRecommendedValue();
 187   ASSERT_FALSE(value);
 188
 189   // Set a user-set value.
 190   prefs.SetUserPref(kPrefName, std::make_unique<base::Value>(kUserValue));
 191
 192   // Check that GetValue() returns the user-set value.
 193   value = pref->GetValue();
 194   ASSERT_TRUE(value);
 195   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 196   actual_int_value = -1;
 197   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 198   EXPECT_EQ(kUserValue, actual_int_value);
 199
 200   // Check that GetRecommendedValue() returns no value.
 201   value = pref->GetRecommendedValue();
 202   ASSERT_FALSE(value);
 203
 204   // Set a recommended value.
 205   prefs.SetRecommendedPref(kPrefName,
 206                            std::make_unique<base::Value>(kRecommendedValue));
 207
 208   // Check that GetValue() returns the user-set value.
 209   value = pref->GetValue();
 210   ASSERT_TRUE(value);
 211   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 212   actual_int_value = -1;
 213   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 214   EXPECT_EQ(kUserValue, actual_int_value);
 215
 216   // Check that GetRecommendedValue() returns the recommended value.
 217   value = pref->GetRecommendedValue();
 218   ASSERT_TRUE(value);
 219   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 220   actual_int_value = -1;
 221   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 222   EXPECT_EQ(kRecommendedValue, actual_int_value);
 223
 224   // Remove the user-set value.
 225   prefs.RemoveUserPref(kPrefName);
 226
 227   // Check that GetValue() returns the recommended value.
 228   value = pref->GetValue();
 229   ASSERT_TRUE(value);
 230   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 231   actual_int_value = -1;
 232   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 233   EXPECT_EQ(kRecommendedValue, actual_int_value);
 234
 235   // Check that GetRecommendedValue() returns the recommended value.
 236   value = pref->GetRecommendedValue();
 237   ASSERT_TRUE(value);
 238   EXPECT_EQ(base::Value::Type::INTEGER, value->type());
 239   actual_int_value = -1;
 240   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
 241   EXPECT_EQ(kRecommendedValue, actual_int_value);
 242 }
 243
 244 TEST(PrefServiceTest, SetTimeValue_RegularTime) {
 245   TestingPrefServiceSimple prefs;
 246
 247   // Register a null time as the default.
 248   prefs.registry()->RegisterTimePref(kPrefName, base::Time());
 249   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 250
 251   // Set a time and make sure that we can read it without any loss of precision.
 252   const base::Time time = base::Time::Now();
 253   prefs.SetTime(kPrefName, time);
 254   EXPECT_EQ(time, prefs.GetTime(kPrefName));
 255 }
 256
 257 TEST(PrefServiceTest, SetTimeValue_NullTime) {
 258   TestingPrefServiceSimple prefs;
 259
 260   // Register a non-null time as the default.
 261   const base::Time default_time = base::Time::FromDeltaSinceWindowsEpoch(
 262       base::TimeDelta::FromMicroseconds(12345));
 263   prefs.registry()->RegisterTimePref(kPrefName, default_time);
 264   EXPECT_FALSE(prefs.GetTime(kPrefName).is_null());
 265
 266   // Set a null time and make sure that it remains null upon deserialization.
 267   prefs.SetTime(kPrefName, base::Time());
 268   EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
 269 }
 270
 271 TEST(PrefServiceTest, SetTimeDeltaValue_RegularTimeDelta) {
 272   TestingPrefServiceSimple prefs;
 273
 274   // Register a zero time delta as the default.
 275   prefs.registry()->RegisterTimeDeltaPref(kPrefName, base::TimeDelta());
 276   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 277
 278   // Set a time delta and make sure that we can read it without any loss of
 279   // precision.
 280   const base::TimeDelta delta = base::Time::Now() - base::Time();
 281   prefs.SetTimeDelta(kPrefName, delta);
 282   EXPECT_EQ(delta, prefs.GetTimeDelta(kPrefName));
 283 }
 284
 285 TEST(PrefServiceTest, SetTimeDeltaValue_ZeroTimeDelta) {
 286   TestingPrefServiceSimple prefs;
 287
 288   // Register a non-zero time delta as the default.
 289   const base::TimeDelta default_delta =
 290       base::TimeDelta::FromMicroseconds(12345);
 291   prefs.registry()->RegisterTimeDeltaPref(kPrefName, default_delta);
 292   EXPECT_FALSE(prefs.GetTimeDelta(kPrefName).is_zero());
 293
 294   // Set a zero time delta and make sure that it remains zero upon
 295   // deserialization.
 296   prefs.SetTimeDelta(kPrefName, base::TimeDelta());
 297   EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
 298 }
 299
 300 // A PrefStore which just stores the last write flags that were used to write
 301 // values to it.
 302 class WriteFlagChecker : public TestingPrefStore {
 303  public:
 304   WriteFlagChecker() {}
 305
 306   void ReportValueChanged(const std::string& key, uint32_t flags) override {
 307     SetLastWriteFlags(flags);
 308   }
 309
 310   void SetValue(const std::string& key,
 311                 std::unique_ptr<base::Value> value,
 312                 uint32_t flags) override {
 313     SetLastWriteFlags(flags);
 314   }
 315
 316   void SetValueSilently(const std::string& key,
 317                         std::unique_ptr<base::Value> value,
 318                         uint32_t flags) override {
 319     SetLastWriteFlags(flags);
 320   }
 321
 322   void RemoveValue(const std::string& key, uint32_t flags) override {
 323     SetLastWriteFlags(flags);
 324   }
 325
 326   uint32_t GetLastFlagsAndClear() {
 327     CHECK(last_write_flags_set_);
 328     uint32_t result = last_write_flags_;
 329     last_write_flags_set_ = false;
 330     last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 331     return result;
 332   }
 333
 334   bool last_write_flags_set() { return last_write_flags_set_; }
 335
 336  private:
 337   ~WriteFlagChecker() override {}
 338
 339   void SetLastWriteFlags(uint32_t flags) {
 340     CHECK(!last_write_flags_set_);
 341     last_write_flags_set_ = true;
 342     last_write_flags_ = flags;
 343   }
 344
 345   bool last_write_flags_set_ = false;
 346   uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
 347 };
 348
 349 TEST(PrefServiceTest, WriteablePrefStoreFlags) {
 350   scoped_refptr<WriteFlagChecker> flag_checker(new WriteFlagChecker);
 351   scoped_refptr<PrefRegistrySimple> registry(new PrefRegistrySimple);
 352   PrefServiceFactory factory;
 353   factory.set_user_prefs(flag_checker);
 354   std::unique_ptr<PrefService> prefs(factory.Create(registry.get()));
 355
 356   // The first 8 bits of write flags are reserved for subclasses. Create a
 357   // custom flag in this range
 358   uint32_t kCustomRegistrationFlag = 1 << 2;
 359
 360   // A map of the registration flags that will be tested and the write flags
 361   // they are expected to convert to.
 362   struct RegistrationToWriteFlags {
 363     const char* pref_name;
 364     uint32_t registration_flags;
 365     uint32_t write_flags;
 366   };
 367   const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
 368       {"none",
 369        PrefRegistry::NO_REGISTRATION_FLAGS,
 370        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 371       {"lossy",
 372        PrefRegistry::LOSSY_PREF,
 373        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
 374       {"custom",
 375        kCustomRegistrationFlag,
 376        WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
 377       {"lossyandcustom",
 378        PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
 379        WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
 380
 381   for (size_t i = 0; i < base::size(kRegistrationToWriteFlags); ++i) {
 382     RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
 383     registry->RegisterDictionaryPref(entry.pref_name,
 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                             base::Value(base::Value::Type::DICTIONARY));
 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 }