Add support for a managed user pref store to PrefService.

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 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 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";
 }
 
 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";
 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";
 const char kRecommendedValue[] = "default:recommended";
 const char kDefaultValue[] = "default:default";
 }
 
 class PrefValueStoreTest : public testing::Test {
  protected:
   virtual void SetUp() {
     // Create TestingPrefStores.
     CreateManagedPrefs();
+    CreateManagedUserPrefs();
     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_->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(
+        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);
   }
 
   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);
+    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);
+    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);
+    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);
+    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(
         prefs::kUserPref,
@@ skipping 14 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> 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.
+  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,
                                           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;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kCommandLinePref,
@@ skipping 41 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.
+  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(
       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.
   value = NULL;
@@ skipping 37 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);
+  CheckAndClearValueChangeNotifications();
+
+  ExpectValueChangeNotifications(prefs::kManagedPref);
   extension_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
   command_line_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
 
   ExpectValueChangeNotifications(prefs::kManagedPref);
   user_pref_store_->NotifyPrefValueChanged(prefs::kManagedPref);
   CheckAndClearValueChangeNotifications();
@@ skipping 53 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();
   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));
+  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));
+  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));
+  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));
   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));
+  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));
+  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));
+  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));
+  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));
   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));
 }