components/prefs/pref_value_store_unittest.cc

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