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