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