Add support for a managed user pref store to PrefService.

TBR=phajdan.jr@chromium.org
BUG=280674

Review URL: https://chromiumcodereview.appspot.com/23592013

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@220274 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 103 insertions, 8 deletions

diff --git a/base/prefs/pref_service_builder.cc b/base/prefs/pref_service_builder.cc
index b3d3533..b79abdd 100644
--- a/base/prefs/pref_service_builder.cc
+++ b/base/prefs/pref_service_builder.cc
@@ -32,6 +32,11 @@ PrefServiceBuilder& PrefServiceBuilder::WithManagedPrefs(PrefStore* store) {
   return *this;
 }
 
+PrefServiceBuilder& PrefServiceBuilder::WithManagedUserPrefs(PrefStore* store) {
+  managed_user_prefs_ = store;
+  return *this;
+}
+
 PrefServiceBuilder& PrefServiceBuilder::WithExtensionPrefs(PrefStore* store) {
   extension_prefs_ = store;
   return *this;
@@ -77,6 +82,7 @@ PrefService* PrefServiceBuilder::Create(PrefRegistry* pref_registry) {
   PrefService* pref_service =
       new PrefService(pref_notifier,
                       new PrefValueStore(managed_prefs_.get(),
+                                         managed_user_prefs_.get(),
                                          extension_prefs_.get(),
                                          command_line_prefs_.get(),
                                          user_prefs_.get(),
@@ -93,6 +99,7 @@ PrefService* PrefServiceBuilder::Create(PrefRegistry* pref_registry) {
 
 void PrefServiceBuilder::ResetDefaultState() {
   managed_prefs_ = NULL;
+  managed_user_prefs_ = NULL;
   extension_prefs_ = NULL;
   command_line_prefs_ = NULL;
   user_prefs_ = NULL;
diff --git a/base/prefs/pref_service_builder.h b/base/prefs/pref_service_builder.h
index 4bd4fde..cf6a959 100644
--- a/base/prefs/pref_service_builder.h
+++ b/base/prefs/pref_service_builder.h
@@ -29,6 +29,7 @@ class BASE_PREFS_EXPORT PrefServiceBuilder {
   // Functions for setting the various parameters of the PrefService to build.
   // These take ownership of the |store| parameter.
   PrefServiceBuilder& WithManagedPrefs(PrefStore* store);
+  PrefServiceBuilder& WithManagedUserPrefs(PrefStore* store);
   PrefServiceBuilder& WithExtensionPrefs(PrefStore* store);
   PrefServiceBuilder& WithCommandLinePrefs(PrefStore* store);
   PrefServiceBuilder& WithUserPrefs(PersistentPrefStore* store);
@@ -55,6 +56,7 @@ class BASE_PREFS_EXPORT PrefServiceBuilder {
   virtual void ResetDefaultState();
 
   scoped_refptr<PrefStore> managed_prefs_;
+  scoped_refptr<PrefStore> managed_user_prefs_;
   scoped_refptr<PrefStore> extension_prefs_;
   scoped_refptr<PrefStore> command_line_prefs_;
   scoped_refptr<PersistentPrefStore> user_prefs_;
diff --git a/base/prefs/pref_value_store.cc b/base/prefs/pref_value_store.cc
index 96e9ea3..1095abb 100644
--- a/base/prefs/pref_value_store.cc
+++ b/base/prefs/pref_value_store.cc
@@ -47,6 +47,7 @@ void PrefValueStore::PrefStoreKeeper::OnInitializationCompleted(
 }
 
 PrefValueStore::PrefValueStore(PrefStore* managed_prefs,
+                               PrefStore* managed_user_prefs,
                                PrefStore* extension_prefs,
                                PrefStore* command_line_prefs,
                                PrefStore* user_prefs,
@@ -56,6 +57,7 @@ PrefValueStore::PrefValueStore(PrefStore* managed_prefs,
     : pref_notifier_(pref_notifier),
       initialization_failed_(false) {
   InitPrefStore(MANAGED_STORE, managed_prefs);
+  InitPrefStore(MANAGED_USER_STORE, managed_user_prefs);
   InitPrefStore(EXTENSION_STORE, extension_prefs);
   InitPrefStore(COMMAND_LINE_STORE, command_line_prefs);
   InitPrefStore(USER_STORE, user_prefs);
@@ -69,6 +71,7 @@ PrefValueStore::~PrefValueStore() {}
 
 PrefValueStore* PrefValueStore::CloneAndSpecialize(
     PrefStore* managed_prefs,
+    PrefStore* managed_user_prefs,
     PrefStore* extension_prefs,
     PrefStore* command_line_prefs,
     PrefStore* user_prefs,
@@ -78,6 +81,8 @@ PrefValueStore* PrefValueStore::CloneAndSpecialize(
   DCHECK(pref_notifier);
   if (!managed_prefs)
     managed_prefs = GetPrefStore(MANAGED_STORE);
+  if (!managed_user_prefs)
+    managed_user_prefs = GetPrefStore(MANAGED_USER_STORE);
   if (!extension_prefs)
     extension_prefs = GetPrefStore(EXTENSION_STORE);
   if (!command_line_prefs)
@@ -90,8 +95,8 @@ PrefValueStore* PrefValueStore::CloneAndSpecialize(
     default_prefs = GetPrefStore(DEFAULT_STORE);
 
   return new PrefValueStore(
-      managed_prefs, extension_prefs, command_line_prefs, user_prefs,
-      recommended_prefs, default_prefs, pref_notifier);
+      managed_prefs, managed_user_prefs, extension_prefs, command_line_prefs,
+      user_prefs, recommended_prefs, default_prefs, pref_notifier);
 }
 
 void PrefValueStore::set_callback(const PrefChangedCallback& callback) {
diff --git a/base/prefs/pref_value_store.h b/base/prefs/pref_value_store.h
index 4036e40..4f43962 100644
--- a/base/prefs/pref_value_store.h
+++ b/base/prefs/pref_value_store.h
@@ -44,6 +44,7 @@ class BASE_PREFS_EXPORT PrefValueStore {
   // |pref_notifier| facilitates broadcasting preference change notifications
   // to the world.
   PrefValueStore(PrefStore* managed_prefs,
+                 PrefStore* managed_user_prefs,
                  PrefStore* extension_prefs,
                  PrefStore* command_line_prefs,
                  PrefStore* user_prefs,
@@ -55,6 +56,7 @@ class BASE_PREFS_EXPORT PrefValueStore {
   // Creates a clone of this PrefValueStore with PrefStores overwritten
   // by the parameters passed, if unequal NULL.
   PrefValueStore* CloneAndSpecialize(PrefStore* managed_prefs,
+                                     PrefStore* managed_user_prefs,
                                      PrefStore* extension_prefs,
                                      PrefStore* command_line_prefs,
                                      PrefStore* user_prefs,
@@ -116,6 +118,7 @@ class BASE_PREFS_EXPORT PrefValueStore {
   // PrefStores must be listed here in order from highest to lowest priority.
   //   MANAGED contains all managed preference values that are provided by
   //      mandatory policies (e.g. Windows Group Policy or cloud policy).
+  //   MANAGED_USER contains preferences that are valid for managed users.
   //   EXTENSION contains preference values set by extensions.
   //   COMMAND_LINE contains preference values set by command-line switches.
   //   USER contains all user-set preference values.
@@ -127,6 +130,7 @@ class BASE_PREFS_EXPORT PrefValueStore {
     // an invalid marker, e.g. as a return value.
     INVALID_STORE = -1,
     MANAGED_STORE = 0,
+    MANAGED_USER_STORE,
     EXTENSION_STORE,
     COMMAND_LINE_STORE,
     USER_STORE,
diff --git a/base/prefs/pref_value_store_unittest.cc b/base/prefs/pref_value_store_unittest.cc
index b38c4ac..2e180c0 100644
--- a/base/prefs/pref_value_store_unittest.cc
+++ b/base/prefs/pref_value_store_unittest.cc
@@ -37,6 +37,7 @@ class MockPrefModelAssociator {
 // 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 kCommandLinePref[] = "this.pref.command_line";
 const char kExtensionPref[] = "this.pref.extension";
 const char kUserPref[] = "this.pref.user";
@@ -50,19 +51,27 @@ 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 extension_pref {
 const char kManagedValue[] = "extension:managed";
+const char kManagedUserValue[] = "extension:managed_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 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 kExtensionValue[] = "user:extension";
 const char kCommandLineValue[] = "user:command_line";
 const char kUserValue[] = "user:user";
@@ -70,6 +79,7 @@ const char kUserValue[] = "user:user";
 
 namespace recommended_pref {
 const char kManagedValue[] = "recommended:managed";
+const char kManagedUserValue[] = "recommended:managed_user";
 const char kExtensionValue[] = "recommended:extension";
 const char kCommandLineValue[] = "recommended:command_line";
 const char kUserValue[] = "recommended:user";
@@ -78,6 +88,7 @@ const char kRecommendedValue[] = "recommended:recommended";
 
 namespace default_pref {
 const char kManagedValue[] = "default:managed";
+const char kManagedUserValue[] = "default:managed_user";
 const char kExtensionValue[] = "default:extension";
 const char kCommandLineValue[] = "default:command_line";
 const char kUserValue[] = "default:user";
@@ -90,6 +101,7 @@ class PrefValueStoreTest : public testing::Test {
   virtual void SetUp() {
     // Create TestingPrefStores.
     CreateManagedPrefs();
+    CreateManagedUserPrefs();
     CreateExtensionPrefs();
     CreateCommandLinePrefs();
     CreateUserPrefs();
@@ -99,6 +111,7 @@ class PrefValueStoreTest : public testing::Test {
 
     // 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(),
@@ -118,12 +131,25 @@ class PrefValueStoreTest : public testing::Test {
         managed_pref::kManagedValue);
   }
 
+  void CreateManagedUserPrefs() {
+    managed_user_pref_store_ = new TestingPrefStore;
+    managed_user_pref_store_->SetString(
+        prefs::kManagedPref,
+        managed_user_pref::kManagedValue);
+    managed_user_pref_store_->SetString(
+        prefs::kManagedUserPref,
+        managed_user_pref::kManagedUserValue);
+  }
+
   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);
+    extension_pref_store_->SetString(
         prefs::kExtensionPref,
         extension_pref::kExtensionValue);
   }
@@ -134,6 +160,9 @@ class PrefValueStoreTest : public testing::Test {
         prefs::kManagedPref,
         command_line_pref::kManagedValue);
     command_line_pref_store_->SetString(
+        prefs::kManagedUserPref,
+        command_line_pref::kManagedUserValue);
+    command_line_pref_store_->SetString(
         prefs::kExtensionPref,
         command_line_pref::kExtensionValue);
     command_line_pref_store_->SetString(
@@ -147,6 +176,9 @@ class PrefValueStoreTest : public testing::Test {
         prefs::kManagedPref,
         user_pref::kManagedValue);
     user_pref_store_->SetString(
+        prefs::kManagedUserPref,
+        user_pref::kManagedUserValue);
+    user_pref_store_->SetString(
         prefs::kCommandLinePref,
         user_pref::kCommandLineValue);
     user_pref_store_->SetString(
@@ -163,6 +195,9 @@ class PrefValueStoreTest : public testing::Test {
         prefs::kManagedPref,
         recommended_pref::kManagedValue);
     recommended_pref_store_->SetString(
+        prefs::kManagedUserPref,
+        recommended_pref::kManagedUserValue);
+    recommended_pref_store_->SetString(
         prefs::kCommandLinePref,
         recommended_pref::kCommandLineValue);
     recommended_pref_store_->SetString(
@@ -179,6 +214,9 @@ class PrefValueStoreTest : public testing::Test {
   void CreateDefaultPrefs() {
     default_pref_store_ = new TestingPrefStore;
     default_pref_store_->SetString(
+        prefs::kManagedUserPref,
+        default_pref::kManagedUserValue);
+    default_pref_store_->SetString(
         prefs::kManagedPref,
         default_pref::kManagedValue);
     default_pref_store_->SetString(
@@ -213,6 +251,7 @@ class PrefValueStoreTest : public testing::Test {
   scoped_ptr<PrefValueStore> pref_value_store_;
 
   scoped_refptr<TestingPrefStore> managed_pref_store_;
+  scoped_refptr<TestingPrefStore> managed_user_pref_store_;
   scoped_refptr<TestingPrefStore> extension_pref_store_;
   scoped_refptr<TestingPrefStore> command_line_pref_store_;
   scoped_refptr<TestingPrefStore> user_pref_store_;
@@ -235,6 +274,13 @@ TEST_F(PrefValueStoreTest, GetValue) {
   EXPECT_TRUE(value->GetAsString(&actual_str_value));
   EXPECT_EQ(managed_pref::kManagedValue, actual_str_value);
 
+  // Test getting a managed user value.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kManagedUserPref,
+                                          base::Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(managed_user_pref::kManagedUserValue, actual_str_value);
+
   // Test getting an extension value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kExtensionPref,
@@ -296,6 +342,14 @@ TEST_F(PrefValueStoreTest, GetRecommendedValue) {
   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.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
+      prefs::kManagedUserPref,
+      base::Value::TYPE_STRING, &value));
+  EXPECT_TRUE(value->GetAsString(&actual_str_value));
+  EXPECT_EQ(recommended_pref::kManagedUserValue, actual_str_value);
+
   // Test getting recommended value when an extension value is present.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetRecommendedValue(
@@ -353,6 +407,10 @@ TEST_F(PrefValueStoreTest, PrefChanges) {
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
+  managed_user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
+  CheckAndClearValueChangeNotifications();
+
+  ExpectValueChangeNotifications(prefs::kManagedPref);
   extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
@@ -426,6 +484,7 @@ TEST_F(PrefValueStoreTest, PrefChanges) {
 TEST_F(PrefValueStoreTest, OnInitializationCompleted) {
   EXPECT_CALL(pref_notifier_, OnInitializationCompleted(true)).Times(0);
   managed_pref_store_->SetInitializationCompleted();
+  managed_user_pref_store_->SetInitializationCompleted();
   extension_pref_store_->SetInitializationCompleted();
   command_line_pref_store_->SetInitializationCompleted();
   recommended_pref_store_->SetInitializationCompleted();
@@ -442,6 +501,8 @@ TEST_F(PrefValueStoreTest, PrefValueInManagedStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
+      prefs::kManagedUserPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kCommandLinePref));
@@ -459,6 +520,8 @@ TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kManagedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
+      prefs::kManagedUserPref));
+  EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kCommandLinePref));
@@ -476,6 +539,8 @@ TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kManagedPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
+      prefs::kManagedUserPref));
+  EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kExtensionPref));
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
       prefs::kCommandLinePref));
@@ -492,6 +557,8 @@ TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
 TEST_F(PrefValueStoreTest, PrefValueFromExtensionStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kManagedPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
+      prefs::kManagedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
@@ -510,6 +577,8 @@ TEST_F(PrefValueStoreTest, PrefValueFromUserStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
+      prefs::kManagedUserPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kCommandLinePref));
@@ -527,6 +596,8 @@ TEST_F(PrefValueStoreTest, PrefValueFromRecommendedStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
+      prefs::kManagedUserPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromRecommendedStore(
       prefs::kCommandLinePref));
@@ -544,6 +615,8 @@ TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) {
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
+      prefs::kManagedUserPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
       prefs::kCommandLinePref));
@@ -561,6 +634,8 @@ TEST_F(PrefValueStoreTest, PrefValueUserModifiable) {
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kManagedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
+      prefs::kManagedUserPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kExtensionPref));
   EXPECT_FALSE(pref_value_store_->PrefValueUserModifiable(
       prefs::kCommandLinePref));
@@ -577,6 +652,8 @@ TEST_F(PrefValueStoreTest, PrefValueUserModifiable) {
 TEST_F(PrefValueStoreTest, PrefValueExtensionModifiable) {
   EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kManagedPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueExtensionModifiable(
+      prefs::kManagedUserPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
       prefs::kExtensionPref));
   EXPECT_TRUE(pref_value_store_->PrefValueExtensionModifiable(
diff --git a/base/prefs/testing_pref_service.cc b/base/prefs/testing_pref_service.cc
index b96268a..5899376 100644
--- a/base/prefs/testing_pref_service.cc
+++ b/base/prefs/testing_pref_service.cc
@@ -24,6 +24,7 @@ TestingPrefServiceBase<PrefService, PrefRegistry>::TestingPrefServiceBase(
           new PrefValueStore(managed_prefs,
                              NULL,
                              NULL,
+                             NULL,
                              user_prefs,
                              recommended_prefs,
                              pref_registry->defaults().get(),
@@ -39,12 +40,11 @@ TestingPrefServiceBase<PrefService, PrefRegistry>::TestingPrefServiceBase(
 
 TestingPrefServiceSimple::TestingPrefServiceSimple()
     : TestingPrefServiceBase<PrefService, PrefRegistry>(
-        new TestingPrefStore(),
-        new TestingPrefStore(),
-        new TestingPrefStore(),
-        new PrefRegistrySimple(),
-        new PrefNotifierImpl()) {
-}
+          new TestingPrefStore(),
+          new TestingPrefStore(),
+          new TestingPrefStore(),
+          new PrefRegistrySimple(),
+          new PrefNotifierImpl()) {}
 
 TestingPrefServiceSimple::~TestingPrefServiceSimple() {
 }