base/prefs/pref_value_store_unittest.cc

   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 }