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.
10 #include "base/stl_util.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"
30 const char kPrefName[] = "pref.name";
31 const char kManagedPref[] = "managed_pref";
32 const char kRecommendedPref[] = "recommended_pref";
33 const char kSupervisedPref[] = "supervised_pref";
37 TEST(PrefServiceTest, NoObserverFire) {
38 TestingPrefServiceSimple prefs;
40 const char pref_name[] = "homepage";
41 prefs.registry()->RegisterStringPref(pref_name, std::string());
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());
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);
55 // Setting the pref to the same value should not set the pref value a second
57 EXPECT_CALL(obs, OnPreferenceChanged(_)).Times(0);
58 prefs.SetString(pref_name, new_pref_value);
59 Mock::VerifyAndClearExpectations(&obs);
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);
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);
73 TEST(PrefServiceTest, HasPrefPath) {
74 TestingPrefServiceSimple prefs;
76 const char path[] = "fake.path";
78 // Shouldn't initially have a path.
79 EXPECT_FALSE(prefs.HasPrefPath(path));
81 // Register the path. This doesn't set a value, so the path still shouldn't
83 prefs.registry()->RegisterStringPref(path, std::string());
84 EXPECT_FALSE(prefs.HasPrefPath(path));
86 // Set a value and make sure we have a path.
87 prefs.SetString(path, "blah");
88 EXPECT_TRUE(prefs.HasPrefPath(path));
91 TEST(PrefServiceTest, Observers) {
92 const char pref_name[] = "homepage";
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());
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());
106 PrefChangeRegistrar registrar_two;
107 registrar_two.Init(&prefs);
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);
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);
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);
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);
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);
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);
157 const base::Value* value = pref->GetValue();
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);
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);
172 // Create pref with a default value only.
173 const PrefService::Preference* pref = prefs.FindPreference(kPrefName);
176 // Check that GetValue() returns the default value.
177 const base::Value* value = pref->GetValue();
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);
184 // Check that GetRecommendedValue() returns no value.
185 value = pref->GetRecommendedValue();
188 // Set a user-set value.
189 prefs.SetUserPref(kPrefName, std::make_unique<base::Value>(kUserValue));
191 // Check that GetValue() returns the user-set value.
192 value = pref->GetValue();
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);
199 // Check that GetRecommendedValue() returns no value.
200 value = pref->GetRecommendedValue();
203 // Set a recommended value.
204 prefs.SetRecommendedPref(kPrefName,
205 std::make_unique<base::Value>(kRecommendedValue));
207 // Check that GetValue() returns the user-set value.
208 value = pref->GetValue();
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);
215 // Check that GetRecommendedValue() returns the recommended value.
216 value = pref->GetRecommendedValue();
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);
223 // Remove the user-set value.
224 prefs.RemoveUserPref(kPrefName);
226 // Check that GetValue() returns the recommended value.
227 value = pref->GetValue();
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);
234 // Check that GetRecommendedValue() returns the recommended value.
235 value = pref->GetRecommendedValue();
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);
243 TEST(PrefServiceTest, SetTimeValue_RegularTime) {
244 TestingPrefServiceSimple prefs;
246 // Register a null time as the default.
247 prefs.registry()->RegisterTimePref(kPrefName, base::Time());
248 EXPECT_TRUE(prefs.GetTime(kPrefName).is_null());
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));
256 TEST(PrefServiceTest, SetTimeValue_NullTime) {
257 TestingPrefServiceSimple prefs;
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());
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());
270 TEST(PrefServiceTest, SetTimeDeltaValue_RegularTimeDelta) {
271 TestingPrefServiceSimple prefs;
273 // Register a zero time delta as the default.
274 prefs.registry()->RegisterTimeDeltaPref(kPrefName, base::TimeDelta());
275 EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
277 // Set a time delta and make sure that we can read it without any loss of
279 const base::TimeDelta delta = base::Time::Now() - base::Time();
280 prefs.SetTimeDelta(kPrefName, delta);
281 EXPECT_EQ(delta, prefs.GetTimeDelta(kPrefName));
284 TEST(PrefServiceTest, SetTimeDeltaValue_ZeroTimeDelta) {
285 TestingPrefServiceSimple prefs;
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());
293 // Set a zero time delta and make sure that it remains zero upon
295 prefs.SetTimeDelta(kPrefName, base::TimeDelta());
296 EXPECT_TRUE(prefs.GetTimeDelta(kPrefName).is_zero());
299 // A PrefStore which just stores the last write flags that were used to write
301 class WriteFlagChecker : public TestingPrefStore {
303 WriteFlagChecker() {}
305 void ReportValueChanged(const std::string& key, uint32_t flags) override {
306 SetLastWriteFlags(flags);
309 void SetValue(const std::string& key,
310 std::unique_ptr<base::Value> value,
311 uint32_t flags) override {
312 SetLastWriteFlags(flags);
315 void SetValueSilently(const std::string& key,
316 std::unique_ptr<base::Value> value,
317 uint32_t flags) override {
318 SetLastWriteFlags(flags);
321 void RemoveValue(const std::string& key, uint32_t flags) override {
322 SetLastWriteFlags(flags);
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;
333 bool last_write_flags_set() { return last_write_flags_set_; }
336 ~WriteFlagChecker() override {}
338 void SetLastWriteFlags(uint32_t flags) {
339 CHECK(!last_write_flags_set_);
340 last_write_flags_set_ = true;
341 last_write_flags_ = flags;
344 bool last_write_flags_set_ = false;
345 uint32_t last_write_flags_ = WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS;
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()));
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;
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;
366 const RegistrationToWriteFlags kRegistrationToWriteFlags[] = {
368 PrefRegistry::NO_REGISTRATION_FLAGS,
369 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
371 PrefRegistry::LOSSY_PREF,
372 WriteablePrefStore::LOSSY_PREF_WRITE_FLAG},
374 kCustomRegistrationFlag,
375 WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS},
377 PrefRegistry::LOSSY_PREF | kCustomRegistrationFlag,
378 WriteablePrefStore::LOSSY_PREF_WRITE_FLAG}};
380 for (size_t i = 0; i < base::size(kRegistrationToWriteFlags); ++i) {
381 RegistrationToWriteFlags entry = kRegistrationToWriteFlags[i];
382 registry->RegisterDictionaryPref(entry.pref_name,
383 std::make_unique<base::DictionaryValue>(),
384 entry.registration_flags);
386 SCOPED_TRACE("Currently testing pref with name: " +
387 std::string(entry.pref_name));
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());
393 prefs->ReportUserPrefChanged(entry.pref_name);
394 EXPECT_TRUE(flag_checker->last_write_flags_set());
395 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
397 prefs->ClearPref(entry.pref_name);
398 EXPECT_TRUE(flag_checker->last_write_flags_set());
399 EXPECT_EQ(entry.write_flags, flag_checker->GetLastFlagsAndClear());
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());
408 class PrefServiceSetValueTest : public testing::Test {
410 static const char kName[];
411 static const char kValue[];
413 PrefServiceSetValueTest() : observer_(&prefs_) {}
415 TestingPrefServiceSimple prefs_;
416 MockPrefChangeCallback observer_;
419 const char PrefServiceSetValueTest::kName[] = "name";
420 const char PrefServiceSetValueTest::kValue[] = "value";
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);
427 PrefChangeRegistrar registrar;
428 registrar.Init(&prefs_);
429 registrar.Add(kName, observer_.GetCallback());
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_);
436 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
437 prefs_.Set(kName, default_value);
438 Mock::VerifyAndClearExpectations(&observer_);
440 base::Value new_value(kValue);
441 observer_.Expect(kName, &new_value);
442 prefs_.Set(kName, new_value);
443 Mock::VerifyAndClearExpectations(&observer_);
446 TEST_F(PrefServiceSetValueTest, SetDictionaryValue) {
447 prefs_.registry()->RegisterDictionaryPref(kName);
448 PrefChangeRegistrar registrar;
449 registrar.Init(&prefs_);
450 registrar.Add(kName, observer_.GetCallback());
452 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
453 prefs_.RemoveUserPref(kName);
454 Mock::VerifyAndClearExpectations(&observer_);
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_);
462 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
463 prefs_.Set(kName, new_value);
464 Mock::VerifyAndClearExpectations(&observer_);
466 base::DictionaryValue empty;
467 observer_.Expect(kName, &empty);
468 prefs_.Set(kName, empty);
469 Mock::VerifyAndClearExpectations(&observer_);
472 TEST_F(PrefServiceSetValueTest, SetListValue) {
473 prefs_.registry()->RegisterListPref(kName);
474 PrefChangeRegistrar registrar;
475 registrar.Init(&prefs_);
476 registrar.Add(kName, observer_.GetCallback());
478 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
479 prefs_.RemoveUserPref(kName);
480 Mock::VerifyAndClearExpectations(&observer_);
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_);
488 EXPECT_CALL(observer_, OnPreferenceChanged(_)).Times(0);
489 prefs_.Set(kName, new_value);
490 Mock::VerifyAndClearExpectations(&observer_);
492 base::ListValue empty;
493 observer_.Expect(kName, &empty);
494 prefs_.Set(kName, empty);
495 Mock::VerifyAndClearExpectations(&observer_);
498 class PrefValueStoreChangeTest : public testing::Test {
500 PrefValueStoreChangeTest()
501 : user_pref_store_(base::MakeRefCounted<TestingPrefStore>()),
502 pref_registry_(base::MakeRefCounted<PrefRegistrySimple>()) {}
504 ~PrefValueStoreChangeTest() override = default;
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);
521 std::unique_ptr<PrefService> pref_service_;
522 scoped_refptr<TestingPrefStore> user_pref_store_;
523 scoped_refptr<PrefRegistrySimple> pref_registry_;
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()));
541 user_pref_store_->SetInteger(kManagedPref, 10);
542 EXPECT_TRUE(preference->IsUserControlled());
543 ASSERT_EQ(base::Value(10), *(preference->GetValue()));
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()));
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()));
558 // Test overriding the supervised and recommended PrefStore with already set
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()));
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());
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);
597 // Test overriding the managed and supervised PrefStore with already set
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
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);
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);