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
20using testing::_;
21using testing::AnyNumber;
22using testing::Mock;
23using testing::Invoke;
24
25namespace {
26
27// Allows to capture pref notifications through gmock.
28class 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.
37namespace prefs {
38const char kManagedPlatformPref[] = "this.pref.managed_platform";
39const char kManagedCloudPref[] = "this.pref.managed_cloud";
40const char kCommandLinePref[] = "this.pref.command_line";
41const char kExtensionPref[] = "this.pref.extension";
42const char kUserPref[] = "this.pref.user";
43const char kRecommendedPlatformPref[] = "this.pref.recommended_platform";
44const char kRecommendedCloudPref[] = "this.pref.recommended_cloud";
45const char kDefaultPref[] = "this.pref.default";
46const char kMissingPref[] = "this.pref.does_not_exist";
47}
48
49// Potentially expected values of all preferences used in this test program.
50namespace managed_platform_pref {
51const char kManagedPlatformValue[] = "managed_platform:managed_platform";
52}
53
54namespace managed_cloud_pref {
55const char kManagedPlatformValue[] = "managed_cloud:managed_platform";
56const char kManagedCloudValue[] = "managed_cloud:managed_cloud";
57}
58
59namespace extension_pref {
60const char kManagedPlatformValue[] = "extension:managed_platform";
61const char kManagedCloudValue[] = "extension:managed_cloud";
62const char kExtensionValue[] = "extension:extension";
63}
64
65namespace command_line_pref {
66const char kManagedPlatformValue[] = "command_line:managed_platform";
67const char kManagedCloudValue[] = "command_line:managed_cloud";
68const char kExtensionValue[] = "command_line:extension";
69const char kCommandLineValue[] = "command_line:command_line";
70}
71
72namespace user_pref {
73const char kManagedPlatformValue[] = "user:managed_platform";
74const char kManagedCloudValue[] = "user:managed_cloud";
75const char kExtensionValue[] = "user:extension";
76const char kCommandLineValue[] = "user:command_line";
77const char kUserValue[] = "user:user";
78}
79
80namespace recommended_platform_pref {
81const char kManagedPlatformValue[] = "recommended_platform:managed_platform";
82const char kManagedCloudValue[] = "recommended_platform:managed_cloud";
83const char kExtensionValue[] = "recommended_platform:extension";
84const char kCommandLineValue[] = "recommended_platform:command_line";
85const char kUserValue[] = "recommended_platform:user";
86const char kRecommendedPlatformValue[] =
87    "recommended_platform:recommended_platform";
88}
89
90namespace recommended_cloud_pref {
91const char kManagedPlatformValue[] = "recommended_cloud:managed_platform";
92const char kManagedCloudValue[] = "recommended_cloud:managed_cloud";
93const char kExtensionValue[] = "recommended_cloud:extension";
94const char kCommandLineValue[] = "recommended_cloud:command_line";
95const char kUserValue[] = "recommended_cloud:user";
96const char kRecommendedPlatformValue[] =
97    "recommended_cloud:recommended_platform";
98const char kRecommendedCloudValue[] = "recommended_cloud:recommended_cloud";
99}
100
101namespace default_pref {
102const char kManagedPlatformValue[] = "default:managed_platform";
103const char kManagedCloudValue[] = "default:managed_cloud";
104const char kExtensionValue[] = "default:extension";
105const char kCommandLineValue[] = "default:command_line";
106const char kUserValue[] = "default:user";
107const char kRecommendedPlatformValue[] = "default:recommended_platform";
108const char kRecommendedCloudValue[] = "default:recommended_cloud";
109const char kDefaultValue[] = "default:default";
110}
111
112class PrefValueStoreTest : public testing::Test {
113 protected:
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
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
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
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
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
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
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
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
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
291TEST_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
365TEST_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
453TEST_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
470TEST_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
491TEST_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
512TEST_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
533TEST_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
554TEST_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
575TEST_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
596TEST_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
617TEST_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