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