Rename managed user pref store to supervised user pref store.

base/prefs/pref_value_store_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 19 matching lines @@
 class MockPrefModelAssociator {
  public:
   MOCK_METHOD1(ProcessPrefChange, void(const std::string&));
 };
 
 }  // namespace
 
 // Names of the preferences used in this test.
 namespace prefs {
 const char kManagedPref[] = "this.pref.managed";
-const char kManagedUserPref[] = "this.pref.managed_user";
+const char kSupervisedUserPref[] = "this.pref.supervised_user";
 const char kCommandLinePref[] = "this.pref.command_line";
 const char kExtensionPref[] = "this.pref.extension";
 const char kUserPref[] = "this.pref.user";
 const char kRecommendedPref[] = "this.pref.recommended";
 const char kDefaultPref[] = "this.pref.default";
 const char kMissingPref[] = "this.pref.does_not_exist";
 }
 
 // Potentially expected values of all preferences used in this test program.
 namespace managed_pref {
 const char kManagedValue[] = "managed:managed";
 }
 
-namespace managed_user_pref {
-const char kManagedValue[] = "managed_user:managed";
-const char kManagedUserValue[] = "managed_user:managed_user";
+namespace supervised_user_pref {
+const char kManagedValue[] = "supervised_user:managed";
+const char kSupervisedUserValue[] = "supervised_user:supervised_user";
 }
 
 namespace extension_pref {
 const char kManagedValue[] = "extension:managed";
-const char kManagedUserValue[] = "extension:managed_user";
+const char kSupervisedUserValue[] = "extension:supervised_user";
 const char kExtensionValue[] = "extension:extension";
 }
 
 namespace command_line_pref {
 const char kManagedValue[] = "command_line:managed";
-const char kManagedUserValue[] = "command_line:managed_user";
+const char kSupervisedUserValue[] = "command_line:supervised_user";
 const char kExtensionValue[] = "command_line:extension";
 const char kCommandLineValue[] = "command_line:command_line";
 }
 
 namespace user_pref {
 const char kManagedValue[] = "user:managed";
-const char kManagedUserValue[] = "managed_user:managed_user";
+const char kSupervisedUserValue[] = "supervised_user:supervised_user";
 const char kExtensionValue[] = "user:extension";
 const char kCommandLineValue[] = "user:command_line";
 const char kUserValue[] = "user:user";
 }
 
 namespace recommended_pref {
 const char kManagedValue[] = "recommended:managed";
-const char kManagedUserValue[] = "recommended:managed_user";
+const char kSupervisedUserValue[] = "recommended:supervised_user";
 const char kExtensionValue[] = "recommended:extension";
 const char kCommandLineValue[] = "recommended:command_line";
 const char kUserValue[] = "recommended:user";
 const char kRecommendedValue[] = "recommended:recommended";
 }
 
 namespace default_pref {
 const char kManagedValue[] = "default:managed";
-const char kManagedUserValue[] = "default:managed_user";
+const char kSupervisedUserValue[] = "default:supervised_user";
 const char kExtensionValue[] = "default:extension";
 const char kCommandLineValue[] = "default:command_line";
 const char kUserValue[] = "default:user";
 const char kRecommendedValue[] = "default:recommended";
 const char kDefaultValue[] = "default:default";
 }
 
 class PrefValueStoreTest : public testing::Test {
  protected:
   virtual void SetUp() {
     // Create TestingPrefStores.
     CreateManagedPrefs();
-    CreateManagedUserPrefs();
+    CreateSupervisedUserPrefs();
     CreateExtensionPrefs();
     CreateCommandLinePrefs();
     CreateUserPrefs();
     CreateRecommendedPrefs();
     CreateDefaultPrefs();
     sync_associator_.reset(new MockPrefModelAssociator());
 
     // Create a fresh PrefValueStore.
-    pref_value_store_.reset(new PrefValueStore(managed_pref_store_.get(),
-                                               managed_user_pref_store_.get(),
-                                               extension_pref_store_.get(),
-                                               command_line_pref_store_.get(),
-                                               user_pref_store_.get(),
-                                               recommended_pref_store_.get(),
-                                               default_pref_store_.get(),
-                                               &pref_notifier_));
+    pref_value_store_.reset(
+        new PrefValueStore(managed_pref_store_.get(),
+                           supervised_user_pref_store_.get(),
+                           extension_pref_store_.get(),
+                           command_line_pref_store_.get(),
+                           user_pref_store_.get(),
+                           recommended_pref_store_.get(),
+                           default_pref_store_.get(),
+                           &pref_notifier_));
 
     pref_value_store_->set_callback(
         base::Bind(&MockPrefModelAssociator::ProcessPrefChange,
                    base::Unretained(sync_associator_.get())));
   }
 
   void CreateManagedPrefs() {
     managed_pref_store_ = new TestingPrefStore;
     managed_pref_store_->SetString(
         prefs::kManagedPref,
         managed_pref::kManagedValue);
   }
 
-  void CreateManagedUserPrefs() {
-    managed_user_pref_store_ = new TestingPrefStore;
-    managed_user_pref_store_->SetString(
+  void CreateSupervisedUserPrefs() {
+    supervised_user_pref_store_ = new TestingPrefStore;
+    supervised_user_pref_store_->SetString(
         prefs::kManagedPref,
-        managed_user_pref::kManagedValue);
-    managed_user_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        managed_user_pref::kManagedUserValue);
+        supervised_user_pref::kManagedValue);
+    supervised_user_pref_store_->SetString(
+        prefs::kSupervisedUserPref,
+        supervised_user_pref::kSupervisedUserValue);
   }
 
   void CreateExtensionPrefs() {
     extension_pref_store_ = new TestingPrefStore;
     extension_pref_store_->SetString(
         prefs::kManagedPref,
         extension_pref::kManagedValue);
     extension_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        extension_pref::kManagedUserValue);
+        prefs::kSupervisedUserPref,
+        extension_pref::kSupervisedUserValue);
     extension_pref_store_->SetString(
         prefs::kExtensionPref,
         extension_pref::kExtensionValue);
   }
 
   void CreateCommandLinePrefs() {
     command_line_pref_store_ = new TestingPrefStore;
     command_line_pref_store_->SetString(
         prefs::kManagedPref,
         command_line_pref::kManagedValue);
     command_line_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        command_line_pref::kManagedUserValue);
+        prefs::kSupervisedUserPref,
+        command_line_pref::kSupervisedUserValue);
     command_line_pref_store_->SetString(
         prefs::kExtensionPref,
         command_line_pref::kExtensionValue);
     command_line_pref_store_->SetString(
         prefs::kCommandLinePref,
         command_line_pref::kCommandLineValue);
   }
 
   void CreateUserPrefs() {
     user_pref_store_ = new TestingPrefStore;
     user_pref_store_->SetString(
         prefs::kManagedPref,
         user_pref::kManagedValue);
     user_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        user_pref::kManagedUserValue);
+        prefs::kSupervisedUserPref,
+        user_pref::kSupervisedUserValue);
     user_pref_store_->SetString(
         prefs::kCommandLinePref,
         user_pref::kCommandLineValue);
     user_pref_store_->SetString(
         prefs::kExtensionPref,
         user_pref::kExtensionValue);
     user_pref_store_->SetString(
         prefs::kUserPref,
         user_pref::kUserValue);
   }
 
   void CreateRecommendedPrefs() {
     recommended_pref_store_ = new TestingPrefStore;
     recommended_pref_store_->SetString(
         prefs::kManagedPref,
         recommended_pref::kManagedValue);
     recommended_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        recommended_pref::kManagedUserValue);
+        prefs::kSupervisedUserPref,
+        recommended_pref::kSupervisedUserValue);
     recommended_pref_store_->SetString(
         prefs::kCommandLinePref,
         recommended_pref::kCommandLineValue);
     recommended_pref_store_->SetString(
         prefs::kExtensionPref,
         recommended_pref::kExtensionValue);
     recommended_pref_store_->SetString(
         prefs::kUserPref,
         recommended_pref::kUserValue);
     recommended_pref_store_->SetString(
         prefs::kRecommendedPref,
         recommended_pref::kRecommendedValue);
   }
 
   void CreateDefaultPrefs() {
     default_pref_store_ = new TestingPrefStore;
     default_pref_store_->SetString(
-        prefs::kManagedUserPref,
-        default_pref::kManagedUserValue);
+        prefs::kSupervisedUserPref,
+        default_pref::kSupervisedUserValue);
     default_pref_store_->SetString(
         prefs::kManagedPref,
         default_pref::kManagedValue);
     default_pref_store_->SetString(
         prefs::kCommandLinePref,
         default_pref::kCommandLineValue);
     default_pref_store_->SetString(
         prefs::kExtensionPref,
         default_pref::kExtensionValue);
     default_pref_store_->SetString(
@@ skipping 15 matching lines @@
   void CheckAndClearValueChangeNotifications() {
     Mock::VerifyAndClearExpectations(&pref_notifier_);
     Mock::VerifyAndClearExpectations(sync_associator_.get());
   }
 
   MockPrefNotifier pref_notifier_;
   scoped_ptr<MockPrefModelAssociator> sync_associator_;
   scoped_ptr<PrefValueStore> pref_value_store_;
 
   scoped_refptr<TestingPrefStore> managed_pref_store_;
-  scoped_refptr<TestingPrefStore> managed_user_pref_store_;
+  scoped_refptr<TestingPrefStore> supervised_user_pref_store_;
   scoped_refptr<TestingPrefStore> extension_pref_store_;
   scoped_refptr<TestingPrefStore> command_line_pref_store_;
   scoped_refptr<TestingPrefStore> user_pref_store_;
   scoped_refptr<TestingPrefStore> recommended_pref_store_;
   scoped_refptr<TestingPrefStore> default_pref_store_;
 };
 
 TEST_F(PrefValueStoreTest, GetValue) {
   const base::Value* value;
 
   // The following tests read a value from the PrefService. The preferences are
   // set in a way such that all lower-priority stores have a value and we can
   // test whether overrides work correctly.
 
   // Test getting a managed value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedPref,
                                           base::Value::TYPE_STRING, &value));
   std::string actual_str_value;
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(managed_pref::kManagedValue, actual_str_value);
 
-  // Test getting a managed user value.
+  // Test getting a supervised user value.
   value = NULL;
-  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedUserPref,
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kSupervisedUserPref,
                                           base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
-  EXPECT_EQ(managed_user_pref::kManagedUserValue, actual_str_value);
+  EXPECT_EQ(supervised_user_pref::kSupervisedUserValue, actual_str_value);
 
   // Test getting an extension value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref,
                                           base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(extension_pref::kExtensionValue, actual_str_value);
 
   // Test getting a command-line value.
   value = NULL;
@@ skipping 42 matching lines @@
 
   // Test getting recommended value when a managed value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kManagedPref,
       base::Value::TYPE_STRING, &value));
   std::string actual_str_value;
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kManagedValue, actual_str_value);
 
-  // Test getting recommended value when a managed user value is present.
+  // Test getting recommended value when a supervised user value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
-      prefs::kManagedUserPref,
+      prefs::kSupervisedUserPref,
       base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
-  EXPECT_EQ(recommended_pref::kManagedUserValue, actual_str_value);
+  EXPECT_EQ(recommended_pref::kSupervisedUserValue, actual_str_value);
 
   // Test getting recommended value when an extension value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
       prefs::kExtensionPref,
       base::Value::TYPE_STRING, &value));
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(recommended_pref::kExtensionValue, actual_str_value);
 
   // Test getting recommended value when a command-line value is present.
@@ skipping 38 matching lines @@
   ASSERT_FALSE(value);
 }
 
 TEST_F(PrefValueStoreTest, PrefChanges) {
   // Check pref controlled by highest-priority store.
   ExpectValueChangeNotifications(prefs::kManagedPref);
   managed_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
-  managed_user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  supervised_user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
   extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
   command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
@@ skipping 56 matching lines @@
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kDefaultPref);
   default_pref_store_->NotifyPrefValueChanged(prefs::kDefaultPref);
   CheckAndClearValueChangeNotifications();
 }
 
 TEST_F(PrefValueStoreTest, OnInitializationCompleted) {
   EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(0);
   managed_pref_store_->SetInitializationCompleted();
-  managed_user_pref_store_->SetInitializationCompleted();
+  supervised_user_pref_store_->SetInitializationCompleted();
   extension_pref_store_->SetInitializationCompleted();
   command_line_pref_store_->SetInitializationCompleted();
   recommended_pref_store_->SetInitializationCompleted();
   default_pref_store_->SetInitializationCompleted();
   Mock::VerifyAndClearExpectations(&pref_notifier_);
 
   // The notification should only be triggered after the last store is done.
   EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(1);
   user_pref_store_->SetInitializationCompleted();
   Mock::VerifyAndClearExpectations(&pref_notifier_);
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInManagedStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kCommandLinePref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kManagedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kCommandLinePref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kManagedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kExtensionPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueFromExtensionStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kCommandLinePref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueFromUserStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueFromRecommendedStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kCommandLinePref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kCommandLinePref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kRecommendedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kDefaultPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueUserModifiable) {
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
       prefs::kRecommendedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
       prefs::kDefaultPref));
   EXPECT_TRUE(pref_value_store_->PrefValueUserModifiable(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueExtensionModifiable) {
   EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
-      prefs::kManagedUserPref));
+      prefs::kSupervisedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kExtensionPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kCommandLinePref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kRecommendedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kDefaultPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kMissingPref));
 }