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