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 "components/prefs/pref_value_store.h"
6
7 #include <memory>
8 #include <string>
9
10 #include "base/functional/bind.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/values.h"
13 #include "components/prefs/pref_notifier.h"
14 #include "components/prefs/testing_pref_store.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17
18 using testing::Mock;
19 using testing::_;
20
21 namespace {
22
23 // Allows to capture pref notifications through gmock.
24 class MockPrefNotifier : public PrefNotifier {
25 public:
26 MOCK_METHOD1(OnPreferenceChanged, void(const std::string&));
27 MOCK_METHOD1(OnInitializationCompleted, void(bool));
28 };
29
30 } // namespace
31
32 // Names of the preferences used in this test.
33 namespace prefs {
34 const char kManagedPref[] = "this.pref.managed";
35 const char kSupervisedUserPref[] = "this.pref.supervised_user";
36 const char kCommandLinePref[] = "this.pref.command_line";
37 const char kExtensionPref[] = "this.pref.extension";
38 const char kStandaloneBrowserPref[] = "this.pref.standalone_browser";
39 const char kUserPref[] = "this.pref.user";
40 const char kRecommendedPref[] = "this.pref.recommended";
41 const char kDefaultPref[] = "this.pref.default";
42 const char kMissingPref[] = "this.pref.does_not_exist";
43 }
44
45 // Potentially expected values of all preferences used in this test program.
46 namespace managed_pref {
47 const char kManagedValue[] = "managed:managed";
48 }
49
50 namespace supervised_user_pref {
51 const char kManagedValue[] = "supervised_user:managed";
52 const char kSupervisedUserValue[] = "supervised_user:supervised_user";
53 }
54
55 namespace extension_pref {
56 const char kManagedValue[] = "extension:managed";
57 const char kSupervisedUserValue[] = "extension:supervised_user";
58 const char kExtensionValue[] = "extension:extension";
59 }
60
61 namespace standalone_browser_pref {
62 const char kManagedValue[] = "standalone_browser:managed";
63 const char kSupervisedUserValue[] = "standalone_browser:supervised_user";
64 const char kExtensionValue[] = "standalone_browser:extension";
65 const char kStandaloneBrowserValue[] = "standalone_browser:standalone_browser";
66 } // namespace standalone_browser_pref
67
68 namespace command_line_pref {
69 const char kManagedValue[] = "command_line:managed";
70 const char kSupervisedUserValue[] = "command_line:supervised_user";
71 const char kExtensionValue[] = "command_line:extension";
72 const char kStandaloneBrowserValue[] = "command_line:standalone_browser";
73 const char kCommandLineValue[] = "command_line:command_line";
74 }
75
76 namespace user_pref {
77 const char kManagedValue[] = "user:managed";
78 const char kSupervisedUserValue[] = "supervised_user:supervised_user";
79 const char kExtensionValue[] = "user:extension";
80 const char kStandaloneBrowserValue[] = "user:standalone_browser";
81 const char kCommandLineValue[] = "user:command_line";
82 const char kUserValue[] = "user:user";
83 }
84
85 namespace recommended_pref {
86 const char kManagedValue[] = "recommended:managed";
87 const char kSupervisedUserValue[] = "recommended:supervised_user";
88 const char kExtensionValue[] = "recommended:extension";
89 const char kStandaloneBrowserValue[] = "recommended:standalone_browser";
90 const char kCommandLineValue[] = "recommended:command_line";
91 const char kUserValue[] = "recommended:user";
92 const char kRecommendedValue[] = "recommended:recommended";
93 }
94
95 namespace default_pref {
96 const char kManagedValue[] = "default:managed";
97 const char kSupervisedUserValue[] = "default:supervised_user";
98 const char kExtensionValue[] = "default:extension";
99 const char kStandaloneBrowserValue[] = "default:standalone_browser";
100 const char kCommandLineValue[] = "default:command_line";
101 const char kUserValue[] = "default:user";
102 const char kRecommendedValue[] = "default:recommended";
103 const char kDefaultValue[] = "default:default";
104 }
105
106 class PrefValueStoreTest : public testing::Test {
107 protected:
SetUp()108 void SetUp() override {
109 // Create TestingPrefStores.
110 CreateManagedPrefs();
111 CreateSupervisedUserPrefs();
112 CreateExtensionPrefs();
113 CreateStandaloneBrowserPrefs();
114 CreateCommandLinePrefs();
115 CreateUserPrefs();
116 CreateRecommendedPrefs();
117 CreateDefaultPrefs();
118
119 // Create a fresh PrefValueStore.
120 pref_value_store_ = std::make_unique<PrefValueStore>(
121 managed_pref_store_.get(), supervised_user_pref_store_.get(),
122 extension_pref_store_.get(), standalone_browser_pref_store_.get(),
123 command_line_pref_store_.get(), user_pref_store_.get(),
124 recommended_pref_store_.get(), default_pref_store_.get(),
125 &pref_notifier_);
126 }
127
CreateManagedPrefs()128 void CreateManagedPrefs() {
129 managed_pref_store_ = new TestingPrefStore;
130 managed_pref_store_->SetString(
131 prefs::kManagedPref,
132 managed_pref::kManagedValue);
133 }
134
CreateSupervisedUserPrefs()135 void CreateSupervisedUserPrefs() {
136 supervised_user_pref_store_ = new TestingPrefStore;
137 supervised_user_pref_store_->SetString(
138 prefs::kManagedPref,
139 supervised_user_pref::kManagedValue);
140 supervised_user_pref_store_->SetString(
141 prefs::kSupervisedUserPref,
142 supervised_user_pref::kSupervisedUserValue);
143 }
144
CreateExtensionPrefs()145 void CreateExtensionPrefs() {
146 extension_pref_store_ = new TestingPrefStore;
147 extension_pref_store_->SetString(
148 prefs::kManagedPref,
149 extension_pref::kManagedValue);
150 extension_pref_store_->SetString(
151 prefs::kSupervisedUserPref,
152 extension_pref::kSupervisedUserValue);
153 extension_pref_store_->SetString(
154 prefs::kExtensionPref,
155 extension_pref::kExtensionValue);
156 }
157
CreateStandaloneBrowserPrefs()158 void CreateStandaloneBrowserPrefs() {
159 standalone_browser_pref_store_ = new TestingPrefStore;
160 standalone_browser_pref_store_->SetString(
161 prefs::kManagedPref, standalone_browser_pref::kManagedValue);
162 standalone_browser_pref_store_->SetString(
163 prefs::kSupervisedUserPref,
164 standalone_browser_pref::kSupervisedUserValue);
165 standalone_browser_pref_store_->SetString(
166 prefs::kExtensionPref, standalone_browser_pref::kExtensionValue);
167 standalone_browser_pref_store_->SetString(
168 prefs::kStandaloneBrowserPref,
169 standalone_browser_pref::kStandaloneBrowserValue);
170 }
171
CreateCommandLinePrefs()172 void CreateCommandLinePrefs() {
173 command_line_pref_store_ = new TestingPrefStore;
174 command_line_pref_store_->SetString(
175 prefs::kManagedPref,
176 command_line_pref::kManagedValue);
177 command_line_pref_store_->SetString(
178 prefs::kSupervisedUserPref,
179 command_line_pref::kSupervisedUserValue);
180 command_line_pref_store_->SetString(
181 prefs::kExtensionPref,
182 command_line_pref::kExtensionValue);
183 command_line_pref_store_->SetString(
184 prefs::kStandaloneBrowserPref,
185 command_line_pref::kStandaloneBrowserValue);
186 command_line_pref_store_->SetString(
187 prefs::kCommandLinePref,
188 command_line_pref::kCommandLineValue);
189 }
190
CreateUserPrefs()191 void CreateUserPrefs() {
192 user_pref_store_ = new TestingPrefStore;
193 user_pref_store_->SetString(
194 prefs::kManagedPref,
195 user_pref::kManagedValue);
196 user_pref_store_->SetString(
197 prefs::kSupervisedUserPref,
198 user_pref::kSupervisedUserValue);
199 user_pref_store_->SetString(
200 prefs::kCommandLinePref,
201 user_pref::kCommandLineValue);
202 user_pref_store_->SetString(
203 prefs::kExtensionPref,
204 user_pref::kExtensionValue);
205 user_pref_store_->SetString(prefs::kStandaloneBrowserPref,
206 user_pref::kStandaloneBrowserValue);
207 user_pref_store_->SetString(
208 prefs::kUserPref,
209 user_pref::kUserValue);
210 }
211
CreateRecommendedPrefs()212 void CreateRecommendedPrefs() {
213 recommended_pref_store_ = new TestingPrefStore;
214 recommended_pref_store_->SetString(
215 prefs::kManagedPref,
216 recommended_pref::kManagedValue);
217 recommended_pref_store_->SetString(
218 prefs::kSupervisedUserPref,
219 recommended_pref::kSupervisedUserValue);
220 recommended_pref_store_->SetString(
221 prefs::kCommandLinePref,
222 recommended_pref::kCommandLineValue);
223 recommended_pref_store_->SetString(
224 prefs::kExtensionPref,
225 recommended_pref::kExtensionValue);
226 recommended_pref_store_->SetString(
227 prefs::kStandaloneBrowserPref,
228 recommended_pref::kStandaloneBrowserValue);
229 recommended_pref_store_->SetString(
230 prefs::kUserPref,
231 recommended_pref::kUserValue);
232 recommended_pref_store_->SetString(
233 prefs::kRecommendedPref,
234 recommended_pref::kRecommendedValue);
235 }
236
CreateDefaultPrefs()237 void CreateDefaultPrefs() {
238 default_pref_store_ = new TestingPrefStore;
239 default_pref_store_->SetString(
240 prefs::kSupervisedUserPref,
241 default_pref::kSupervisedUserValue);
242 default_pref_store_->SetString(
243 prefs::kManagedPref,
244 default_pref::kManagedValue);
245 default_pref_store_->SetString(
246 prefs::kCommandLinePref,
247 default_pref::kCommandLineValue);
248 default_pref_store_->SetString(
249 prefs::kExtensionPref,
250 default_pref::kExtensionValue);
251 default_pref_store_->SetString(prefs::kStandaloneBrowserPref,
252 default_pref::kStandaloneBrowserValue);
253 default_pref_store_->SetString(
254 prefs::kUserPref,
255 default_pref::kUserValue);
256 default_pref_store_->SetString(
257 prefs::kRecommendedPref,
258 default_pref::kRecommendedValue);
259 default_pref_store_->SetString(
260 prefs::kDefaultPref,
261 default_pref::kDefaultValue);
262 }
263
ExpectValueChangeNotifications(const std::string & name)264 void ExpectValueChangeNotifications(const std::string& name) {
265 EXPECT_CALL(pref_notifier_, OnPreferenceChanged(name));
266 }
267
CheckAndClearValueChangeNotifications()268 void CheckAndClearValueChangeNotifications() {
269 Mock::VerifyAndClearExpectations(&pref_notifier_);
270 }
271
272 MockPrefNotifier pref_notifier_;
273 std::unique_ptr<PrefValueStore> pref_value_store_;
274
275 scoped_refptr<TestingPrefStore> managed_pref_store_;
276 scoped_refptr<TestingPrefStore> supervised_user_pref_store_;
277 scoped_refptr<TestingPrefStore> extension_pref_store_;
278 scoped_refptr<TestingPrefStore> standalone_browser_pref_store_;
279 scoped_refptr<TestingPrefStore> command_line_pref_store_;
280 scoped_refptr<TestingPrefStore> user_pref_store_;
281 scoped_refptr<TestingPrefStore> recommended_pref_store_;
282 scoped_refptr<TestingPrefStore> default_pref_store_;
283 };
284
TEST_F(PrefValueStoreTest,GetValue)285 TEST_F(PrefValueStoreTest, GetValue) {
286 const base::Value* value;
287
288 // The following tests read a value from the PrefService. The preferences are
289 // set in a way such that all lower-priority stores have a value and we can
290 // test whether overrides work correctly.
291
292 // Test getting a managed value.
293 value = nullptr;
294 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedPref,
295 base::Value::Type::STRING, &value));
296 ASSERT_TRUE(value->is_string());
297 EXPECT_EQ(managed_pref::kManagedValue, value->GetString());
298
299 // Test getting a supervised user value.
300 value = nullptr;
301 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kSupervisedUserPref,
302 base::Value::Type::STRING, &value));
303 ASSERT_TRUE(value->is_string());
304 EXPECT_EQ(supervised_user_pref::kSupervisedUserValue, value->GetString());
305
306 // Test getting an extension value.
307 value = nullptr;
308 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref,
309 base::Value::Type::STRING, &value));
310 ASSERT_TRUE(value->is_string());
311 EXPECT_EQ(extension_pref::kExtensionValue, value->GetString());
312
313 // Test getting a command-line value.
314 value = nullptr;
315 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCommandLinePref,
316 base::Value::Type::STRING, &value));
317 ASSERT_TRUE(value->is_string());
318 EXPECT_EQ(command_line_pref::kCommandLineValue, value->GetString());
319
320 // Test getting a user-set value.
321 value = nullptr;
322 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kUserPref,
323 base::Value::Type::STRING, &value));
324 ASSERT_TRUE(value->is_string());
325 EXPECT_EQ(user_pref::kUserValue, value->GetString());
326
327 // Test getting a user set value overwriting a recommended value.
328 value = nullptr;
329 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref,
330 base::Value::Type::STRING, &value));
331 ASSERT_TRUE(value->is_string());
332 EXPECT_EQ(recommended_pref::kRecommendedValue, value->GetString());
333
334 // Test getting a default value.
335 value = nullptr;
336 ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref,
337 base::Value::Type::STRING, &value));
338 ASSERT_TRUE(value->is_string());
339 EXPECT_EQ(default_pref::kDefaultValue, value->GetString());
340
341 // Test getting a preference value that the |PrefValueStore|
342 // does not contain.
343 base::Value tmp_dummy_value(true);
344 value = &tmp_dummy_value;
345 ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref,
346 base::Value::Type::STRING, &value));
347 ASSERT_FALSE(value);
348 }
349
TEST_F(PrefValueStoreTest,GetRecommendedValue)350 TEST_F(PrefValueStoreTest, GetRecommendedValue) {
351 const base::Value* value;
352
353 // The following tests read a value from the PrefService. The preferences are
354 // set in a way such that all lower-priority stores have a value and we can
355 // test whether overrides do not clutter the recommended value.
356
357 // Test getting recommended value when a managed value is present.
358 value = nullptr;
359 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
360 prefs::kManagedPref,
361 base::Value::Type::STRING, &value));
362 ASSERT_TRUE(value->is_string());
363 EXPECT_EQ(recommended_pref::kManagedValue, value->GetString());
364
365 // Test getting recommended value when a supervised user value is present.
366 value = nullptr;
367 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
368 prefs::kSupervisedUserPref,
369 base::Value::Type::STRING, &value));
370 ASSERT_TRUE(value->is_string());
371 EXPECT_EQ(recommended_pref::kSupervisedUserValue, value->GetString());
372
373 // Test getting recommended value when an extension value is present.
374 value = nullptr;
375 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
376 prefs::kExtensionPref,
377 base::Value::Type::STRING, &value));
378 ASSERT_TRUE(value->is_string());
379 EXPECT_EQ(recommended_pref::kExtensionValue, value->GetString());
380
381 // Test getting recommended value when a command-line value is present.
382 value = nullptr;
383 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
384 prefs::kCommandLinePref,
385 base::Value::Type::STRING, &value));
386 ASSERT_TRUE(value->is_string());
387 EXPECT_EQ(recommended_pref::kCommandLineValue, value->GetString());
388
389 // Test getting recommended value when a user-set value is present.
390 value = nullptr;
391 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
392 prefs::kUserPref,
393 base::Value::Type::STRING, &value));
394 ASSERT_TRUE(value->is_string());
395 EXPECT_EQ(recommended_pref::kUserValue, value->GetString());
396
397 // Test getting recommended value when no higher-priority value is present.
398 value = nullptr;
399 ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
400 prefs::kRecommendedPref,
401 base::Value::Type::STRING, &value));
402 ASSERT_TRUE(value->is_string());
403 EXPECT_EQ(recommended_pref::kRecommendedValue, value->GetString());
404
405 // Test getting recommended value when no recommended value is present.
406 base::Value tmp_dummy_value(true);
407 value = &tmp_dummy_value;
408 ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
409 prefs::kDefaultPref,
410 base::Value::Type::STRING, &value));
411 ASSERT_FALSE(value);
412
413 // Test getting a preference value that the |PrefValueStore|
414 // does not contain.
415 value = &tmp_dummy_value;
416 ASSERT_FALSE(pref_value_store_->GetRecommendedValue(
417 prefs::kMissingPref,
418 base::Value::Type::STRING, &value));
419 ASSERT_FALSE(value);
420 }
421
TEST_F(PrefValueStoreTest,PrefChanges)422 TEST_F(PrefValueStoreTest, PrefChanges) {
423 // Check pref controlled by highest-priority store.
424 ExpectValueChangeNotifications(prefs::kManagedPref);
425 managed_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
426 CheckAndClearValueChangeNotifications();
427
428 ExpectValueChangeNotifications(prefs::kManagedPref);
429 supervised_user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
430 CheckAndClearValueChangeNotifications();
431
432 ExpectValueChangeNotifications(prefs::kManagedPref);
433 extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
434 CheckAndClearValueChangeNotifications();
435
436 ExpectValueChangeNotifications(prefs::kManagedPref);
437 command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
438 CheckAndClearValueChangeNotifications();
439
440 ExpectValueChangeNotifications(prefs::kManagedPref);
441 user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
442 CheckAndClearValueChangeNotifications();
443
444 ExpectValueChangeNotifications(prefs::kManagedPref);
445 recommended_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
446 CheckAndClearValueChangeNotifications();
447
448 ExpectValueChangeNotifications(prefs::kManagedPref);
449 default_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
450 CheckAndClearValueChangeNotifications();
451
452 // Check pref controlled by user store.
453 ExpectValueChangeNotifications(prefs::kUserPref);
454 managed_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
455 CheckAndClearValueChangeNotifications();
456
457 ExpectValueChangeNotifications(prefs::kUserPref);
458 extension_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
459 CheckAndClearValueChangeNotifications();
460
461 ExpectValueChangeNotifications(prefs::kUserPref);
462 command_line_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
463 CheckAndClearValueChangeNotifications();
464
465 ExpectValueChangeNotifications(prefs::kUserPref);
466 user_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
467 CheckAndClearValueChangeNotifications();
468
469 ExpectValueChangeNotifications(prefs::kUserPref);
470 recommended_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
471 CheckAndClearValueChangeNotifications();
472
473 ExpectValueChangeNotifications(prefs::kUserPref);
474 default_pref_store_->NotifyPrefValueChanged(prefs::kUserPref);
475 CheckAndClearValueChangeNotifications();
476
477 // Check pref controlled by default-pref store.
478 ExpectValueChangeNotifications(prefs::kDefaultPref);
479 managed_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
480 CheckAndClearValueChangeNotifications();
481
482 ExpectValueChangeNotifications(prefs::kDefaultPref);
483 extension_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
484 CheckAndClearValueChangeNotifications();
485
486 ExpectValueChangeNotifications(prefs::kDefaultPref);
487 command_line_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
488 CheckAndClearValueChangeNotifications();
489
490 ExpectValueChangeNotifications(prefs::kDefaultPref);
491 user_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
492 CheckAndClearValueChangeNotifications();
493
494 ExpectValueChangeNotifications(prefs::kDefaultPref);
495 recommended_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
496 CheckAndClearValueChangeNotifications();
497
498 ExpectValueChangeNotifications(prefs::kDefaultPref);
499 default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
500 CheckAndClearValueChangeNotifications();
501 }
502
TEST_F(PrefValueStoreTest,OnInitializationCompleted)503 TEST_F(PrefValueStoreTest, OnInitializationCompleted) {
504 EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(0);
505 managed_pref_store_->SetInitializationCompleted();
506 supervised_user_pref_store_->SetInitializationCompleted();
507 extension_pref_store_->SetInitializationCompleted();
508 standalone_browser_pref_store_->SetInitializationCompleted();
509 command_line_pref_store_->SetInitializationCompleted();
510 recommended_pref_store_->SetInitializationCompleted();
511 default_pref_store_->SetInitializationCompleted();
512 Mock::VerifyAndClearExpectations(&pref_notifier_);
513
514 // The notification should only be triggered after the last store is done.
515 EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(1);
516 user_pref_store_->SetInitializationCompleted();
517 Mock::VerifyAndClearExpectations(&pref_notifier_);
518 }
519
TEST_F(PrefValueStoreTest,PrefValueInManagedStore)520 TEST_F(PrefValueStoreTest, PrefValueInManagedStore) {
521 EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore(
522 prefs::kManagedPref));
523 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
524 prefs::kSupervisedUserPref));
525 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
526 prefs::kExtensionPref));
527 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
528 prefs::kStandaloneBrowserPref));
529 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
530 prefs::kCommandLinePref));
531 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
532 prefs::kUserPref));
533 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
534 prefs::kRecommendedPref));
535 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
536 prefs::kDefaultPref));
537 EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
538 prefs::kMissingPref));
539 }
540
TEST_F(PrefValueStoreTest,PrefValueInExtensionStore)541 TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) {
542 EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
543 prefs::kManagedPref));
544 EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
545 prefs::kSupervisedUserPref));
546 EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
547 prefs::kExtensionPref));
548 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
549 prefs::kStandaloneBrowserPref));
550 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
551 prefs::kCommandLinePref));
552 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
553 prefs::kUserPref));
554 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
555 prefs::kRecommendedPref));
556 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
557 prefs::kDefaultPref));
558 EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
559 prefs::kMissingPref));
560 }
561
TEST_F(PrefValueStoreTest,PrefValueInUserStore)562 TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
563 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
564 prefs::kManagedPref));
565 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
566 prefs::kSupervisedUserPref));
567 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
568 prefs::kExtensionPref));
569 EXPECT_TRUE(
570 pref_value_store_->PrefValueInUserStore(prefs::kStandaloneBrowserPref));
571 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
572 prefs::kCommandLinePref));
573 EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
574 prefs::kUserPref));
575 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
576 prefs::kRecommendedPref));
577 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
578 prefs::kDefaultPref));
579 EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
580 prefs::kMissingPref));
581 }
582
TEST_F(PrefValueStoreTest,PrefValueFromExtensionStore)583 TEST_F(PrefValueStoreTest, PrefValueFromExtensionStore) {
584 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
585 prefs::kManagedPref));
586 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
587 prefs::kSupervisedUserPref));
588 EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore(
589 prefs::kExtensionPref));
590 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
591 prefs::kStandaloneBrowserPref));
592 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
593 prefs::kCommandLinePref));
594 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
595 prefs::kUserPref));
596 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
597 prefs::kRecommendedPref));
598 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
599 prefs::kDefaultPref));
600 EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
601 prefs::kMissingPref));
602 }
603
TEST_F(PrefValueStoreTest,PrefValueFromUserStore)604 TEST_F(PrefValueStoreTest, PrefValueFromUserStore) {
605 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
606 prefs::kManagedPref));
607 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
608 prefs::kSupervisedUserPref));
609 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
610 prefs::kExtensionPref));
611 EXPECT_FALSE(
612 pref_value_store_->PrefValueFromUserStore(prefs::kStandaloneBrowserPref));
613 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
614 prefs::kCommandLinePref));
615 EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore(
616 prefs::kUserPref));
617 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
618 prefs::kRecommendedPref));
619 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
620 prefs::kDefaultPref));
621 EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
622 prefs::kMissingPref));
623 }
624
TEST_F(PrefValueStoreTest,PrefValueFromRecommendedStore)625 TEST_F(PrefValueStoreTest, PrefValueFromRecommendedStore) {
626 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
627 prefs::kManagedPref));
628 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
629 prefs::kSupervisedUserPref));
630 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
631 prefs::kExtensionPref));
632 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
633 prefs::kStandaloneBrowserPref));
634 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
635 prefs::kCommandLinePref));
636 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
637 prefs::kUserPref));
638 EXPECT_TRUE(pref_value_store_->PrefValueFromRecommendedStore(
639 prefs::kRecommendedPref));
640 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
641 prefs::kDefaultPref));
642 EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
643 prefs::kMissingPref));
644 }
645
TEST_F(PrefValueStoreTest,PrefValueFromDefaultStore)646 TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) {
647 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
648 prefs::kManagedPref));
649 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
650 prefs::kSupervisedUserPref));
651 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
652 prefs::kExtensionPref));
653 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
654 prefs::kStandaloneBrowserPref));
655 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
656 prefs::kCommandLinePref));
657 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
658 prefs::kUserPref));
659 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
660 prefs::kRecommendedPref));
661 EXPECT_TRUE(pref_value_store_->PrefValueFromDefaultStore(
662 prefs::kDefaultPref));
663 EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
664 prefs::kMissingPref));
665 }
666
TEST_F(PrefValueStoreTest,PrefValueUserModifiable)667 TEST_F(PrefValueStoreTest, PrefValueUserModifiable) {
668 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
669 prefs::kManagedPref));
670 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
671 prefs::kSupervisedUserPref));
672 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
673 prefs::kExtensionPref));
674 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
675 prefs::kStandaloneBrowserPref));
676 EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
677 prefs::kCommandLinePref));
678 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
679 prefs::kUserPref));
680 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
681 prefs::kRecommendedPref));
682 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
683 prefs::kDefaultPref));
684 EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
685 prefs::kMissingPref));
686 }
687
TEST_F(PrefValueStoreTest,PrefValueExtensionModifiable)688 TEST_F(PrefValueStoreTest, PrefValueExtensionModifiable) {
689 EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
690 prefs::kManagedPref));
691 EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
692 prefs::kSupervisedUserPref));
693 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
694 prefs::kExtensionPref));
695 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
696 prefs::kStandaloneBrowserPref));
697 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
698 prefs::kCommandLinePref));
699 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
700 prefs::kUserPref));
701 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
702 prefs::kRecommendedPref));
703 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
704 prefs::kDefaultPref));
705 EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
706 prefs::kMissingPref));
707 }
708