Create a DefaultPrefStore to hold registered application-default preference v...

chrome/browser/prefs/pref_value_store_unittest.cc

 // Copyright (c) 2010 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 "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/prefs/dummy_pref_store.h"
 #include "chrome/browser/prefs/pref_value_store.h"
@@ skipping 17 matching lines @@
 // Names of the preferences used in this test program.
 namespace prefs {
   const char kCurrentThemeID[] = "extensions.theme.id";
   const char kDeleteCache[] = "browser.clear_data.cache";
   const char kHomepage[] = "homepage";
   const char kMaxTabs[] = "tabs.max_tabs";
   const char kMissingPref[] = "this.pref.does_not_exist";
   const char kRecommendedPref[] = "this.pref.recommended_value_only";
   const char kSampleDict[] = "sample.dict";
   const char kSampleList[] = "sample.list";
+  const char kDefaultPref[] = "default.pref";
 
   // This must match the actual pref name so the command-line store knows about
   // it.
   const char kApplicationLocale[] = "intl.app_locale";
 }
 
 // Potentially expected values of all preferences used in this test program.
 // The "user" namespace is defined globally in an ARM system header, so we need
 // something different here.
 namespace user_pref {
@@ skipping 17 matching lines @@
   const char kApplicationLocaleValue[] = "hi-MOM";
   const char kCurrentThemeIDValue[] = "zyxwvut";
   const char kHomepageValue[] = "http://www.ferretcentral.org";
 }
 
 namespace recommended_pref {
   const int kMaxTabsValue = 10;
   const bool kRecommendedPrefValue = true;
 }
 
+namespace default_pref {
+  const int kDefaultValue = 7;
+}
+
 class PrefValueStoreTest : public testing::Test {
  protected:
   virtual void SetUp() {
     // Create dummy user preferences.
     enforced_prefs_= CreateEnforcedPrefs();
     extension_prefs_ = CreateExtensionPrefs();
     command_line_prefs_ = CreateCommandLinePrefs();
     user_prefs_ = CreateUserPrefs();
     recommended_prefs_ = CreateRecommendedPrefs();
+    default_prefs_ = CreateDefaultPrefs();
 
     // Create |DummyPrefStore|s.
     enforced_pref_store_ = new DummyPrefStore();
     enforced_pref_store_->set_prefs(enforced_prefs_);
     extension_pref_store_ = new DummyPrefStore();
     extension_pref_store_->set_prefs(extension_prefs_);
     command_line_pref_store_ = new DummyPrefStore();
     command_line_pref_store_->set_prefs(command_line_prefs_);
     user_pref_store_ = new DummyPrefStore();
     user_pref_store_->set_read_only(false);
     user_pref_store_->set_prefs(user_prefs_);
     recommended_pref_store_ = new DummyPrefStore();
     recommended_pref_store_->set_prefs(recommended_prefs_);
+    default_pref_store_ = new DummyPrefStore();
+    default_pref_store_->set_prefs(default_prefs_);
 
     // Create a new pref-value-store.
     pref_value_store_ = new TestingPrefService::TestingPrefValueStore(
         enforced_pref_store_,
         extension_pref_store_,
         command_line_pref_store_,
         user_pref_store_,
-        recommended_pref_store_);
+        recommended_pref_store_,
+        default_pref_store_);
 
     ui_thread_.reset(new ChromeThread(ChromeThread::UI, &loop_));
     file_thread_.reset(new ChromeThread(ChromeThread::FILE, &loop_));
   }
 
   // Creates a new dictionary and stores some sample user preferences
   // in it.
   DictionaryValue* CreateUserPrefs() {
     DictionaryValue* user_prefs = new DictionaryValue();
     user_prefs->SetBoolean(prefs::kDeleteCache, user_pref::kDeleteCacheValue);
@@ skipping 41 matching lines @@
         prefs::kRecommendedPref,
         recommended_pref::kRecommendedPrefValue);
 
     // Expected differing paths must be added in lexicographic order
     // to work properly
     expected_differing_paths_.push_back("tabs");
     expected_differing_paths_.push_back(prefs::kMaxTabs);
     expected_differing_paths_.push_back("this");
     expected_differing_paths_.push_back("this.pref");
     expected_differing_paths_.push_back(prefs::kRecommendedPref);
-    return recommended_prefs;  }
+    return recommended_prefs;
+  }
+
+  DictionaryValue* CreateDefaultPrefs() {
+    DictionaryValue* default_prefs = new DictionaryValue();
+    default_prefs->SetInteger(prefs::kDefaultPref, default_pref::kDefaultValue);
+    return default_prefs;
+  }
 
   DictionaryValue* CreateSampleDictValue() {
     DictionaryValue* sample_dict = new DictionaryValue();
     sample_dict->SetBoolean("issample", true);
     sample_dict->SetInteger("value", 4);
     sample_dict->SetString("descr", "Sample Test Dictionary");
     return sample_dict;
   }
 
   ListValue* CreateSampleListValue() {
@@ skipping 10 matching lines @@
   }
 
   MessageLoop loop_;
 
   scoped_refptr<TestingPrefService::TestingPrefValueStore> pref_value_store_;
 
   // |PrefStore|s are owned by the |PrefValueStore|.
   DummyPrefStore* enforced_pref_store_;
   DummyPrefStore* extension_pref_store_;
   DummyPrefStore* command_line_pref_store_;
+  DummyPrefStore* user_pref_store_;
   DummyPrefStore* recommended_pref_store_;
-  DummyPrefStore* user_pref_store_;
+  DummyPrefStore* default_pref_store_;
 
   // A vector of the preferences paths in the managed and recommended
   // PrefStores that are set at the beginning of a test. Can be modified
   // by the test to track changes that it makes to the preferences
   // stored in the managed and recommended PrefStores.
   std::vector<std::string> expected_differing_paths_;
 
   // Preferences are owned by the individual |DummyPrefStores|.
   DictionaryValue* enforced_prefs_;
   DictionaryValue* extension_prefs_;
   DictionaryValue* command_line_prefs_;
   DictionaryValue* user_prefs_;
   DictionaryValue* recommended_prefs_;
+  DictionaryValue* default_prefs_;
 
  private:
   scoped_ptr<ChromeThread> ui_thread_;
   scoped_ptr<ChromeThread> file_thread_;
 };
 
 TEST_F(PrefValueStoreTest, IsReadOnly) {
   enforced_pref_store_->set_read_only(true);
   extension_pref_store_->set_read_only(true);
   command_line_pref_store_->set_read_only(true);
   user_pref_store_->set_read_only(true);
   recommended_pref_store_->set_read_only(true);
+  default_pref_store_->set_read_only(true);
   EXPECT_TRUE(pref_value_store_->ReadOnly());
 
   user_pref_store_->set_read_only(false);
   EXPECT_FALSE(pref_value_store_->ReadOnly());
 }
 
 TEST_F(PrefValueStoreTest, GetValue) {
   Value* value;
 
   // Test getting an enforced value overwriting a user-defined and
@@ skipping 31 matching lines @@
   EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
   EXPECT_EQ(user_pref::kMaxTabsValue, actual_int_value);
 
   // Test getting a recommended value.
   value = NULL;
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kRecommendedPref, &value));
   actual_bool_value = false;
   EXPECT_TRUE(value->GetAsBoolean(&actual_bool_value));
   EXPECT_EQ(recommended_pref::kRecommendedPrefValue, actual_bool_value);
 
+  // Test getting a default value.
+  value = NULL;
+  ASSERT_TRUE(pref_value_store_->GetValue(prefs::kDefaultPref, &value));
+  actual_int_value = -1;
+  EXPECT_TRUE(value->GetAsInteger(&actual_int_value));
+  EXPECT_EQ(default_pref::kDefaultValue, actual_int_value);
+
   // Test getting a preference value that the |PrefValueStore|
   // does not contain.
   FundamentalValue tmp_dummy_value(true);
   Value* v_null = &tmp_dummy_value;
   ASSERT_FALSE(pref_value_store_->GetValue(prefs::kMissingPref, &v_null));
   ASSERT_TRUE(v_null == NULL);
 }
 
 TEST_F(PrefValueStoreTest, HasPrefPath) {
   // Enforced preference
   EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomepage));
   // User preference
   EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kDeleteCache));
   // Recommended preference
   EXPECT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
+  // Default preference
+  EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
   // Unknown preference
   EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefHasChanged) {
-  // Pref controlled by highest-priority store, set to same value in same store.
+  // Setup.
   const char managed_pref_path[] = "managed_pref";
-  const char same_str[] = "same value";
-  scoped_ptr<Value> same_value(Value::CreateStringValue(same_str));
-  enforced_pref_store_->prefs()->SetString(managed_pref_path, same_str);
+  enforced_pref_store_->prefs()->SetString(managed_pref_path, "managed value");
+  const char user_pref_path[] = "user_pref";
+  user_pref_store_->prefs()->SetString(user_pref_path, "user value");
+  const char default_pref_path[] = "default_pref";
+  default_pref_store_->prefs()->SetString(default_pref_path, "default value");
+
+  // Check pref controlled by highest-priority store.
+  EXPECT_TRUE(pref_value_store_->PrefHasChanged(managed_pref_path,
+      static_cast<PrefNotifier::PrefStoreType>(0)));
   EXPECT_FALSE(pref_value_store_->PrefHasChanged(managed_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0), same_value.get()));
+      PrefNotifier::USER_STORE));
 
-  // Pref controlled by highest-priority store, set to different value in
-  // same store.
-  const char other_str[] = "other value";
-  scoped_ptr<Value> other_value(Value::CreateStringValue(other_str));
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(managed_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0), other_value.get()));
+  // Check pref controlled by user store.
+  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
+      static_cast<PrefNotifier::PrefStoreType>(0)));
+  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
+      PrefNotifier::USER_STORE));
+  EXPECT_FALSE(pref_value_store_->PrefHasChanged(user_pref_path,
+      PrefNotifier::PREF_STORE_TYPE_MAX));
 
-  // Pref controlled by user store, set to same value in user store, no lower
-  // store has a value.
-  const char user_pref_path[] = "user_pref";
-  user_pref_store_->prefs()->SetString(user_pref_path, same_str);
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE, same_value.get()));
-
-  // Pref controlled by user store, set to new value in user store, no lower
-  // store has a value.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE, other_value.get()));
-
-  // Pref controlled by user store, set to same value in user store, some lower
-  // store has a value.
-  const char third_str[] = "third value";
-  recommended_pref_store_->prefs()->SetString(user_pref_path, third_str);
-  // This is not necessarily the correct behavior, but it is the current
-  // behavior. See comments in pref_value_store.h and .cc.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE, same_value.get()));
-
-  // Pref controlled by user store, set to new value in user store, some lower
-  // store has a value.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE, other_value.get()));
-
-  // Pref controlled by user store, set to same value in managed store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::MANAGED_STORE, same_value.get()));
-
-  // Pref controlled by user store, set to new value in managed store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::MANAGED_STORE, other_value.get()));
-
-  // Pref controlled by highest-priority store, set to any value in user store.
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(managed_pref_path,
-      PrefNotifier::USER_STORE, same_value.get()));
-
-  // Pref controlled by lowest-priority store, set to same value in same store.
-  const char recommended_pref_path[] = "recommended_pref";
-  recommended_pref_store_->prefs()->SetString(recommended_pref_path, same_str);
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(recommended_pref_path,
-      PrefNotifier::PREF_STORE_TYPE_MAX, same_value.get()));
-
-  // Pref controlled by lowest-priority store, set to different value in same
-  // store.
-  EXPECT_TRUE(pref_value_store_->PrefHasChanged(recommended_pref_path,
-      PrefNotifier::PREF_STORE_TYPE_MAX, other_value.get()));
+  // Check pref controlled by default-pref store.
+  EXPECT_TRUE(pref_value_store_->PrefHasChanged(default_pref_path,
+      PrefNotifier::USER_STORE));
+  EXPECT_TRUE(pref_value_store_->PrefHasChanged(default_pref_path,
+      PrefNotifier::DEFAULT_STORE));
 }
 
 TEST_F(PrefValueStoreTest, ReadPrefs) {
   pref_value_store_->ReadPrefs();
   // The ReadPrefs method of the |DummyPrefStore| deletes the |pref_store|s
   // internal dictionary and creates a new empty dictionary. Hence this
   // dictionary does not contain any of the preloaded preferences.
   // This shows that the ReadPrefs method of the |DummyPrefStore| was called.
   EXPECT_FALSE(pref_value_store_->HasPrefPath(prefs::kDeleteCache));
 }
@@ skipping 73 matching lines @@
 
   // Test a user preference.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kMaxTabs));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kMaxTabs));
 
   // Test a preference from the recommended pref store.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
       prefs::kRecommendedPref));
 
+  // Test a preference from the default pref store.
+  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
+      prefs::kDefaultPref));
+
   // Test a preference for which the PrefValueStore does not contain a value.
   ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInExtensionStore) {
   // Test an enforced preference.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomepage));
   EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(prefs::kHomepage));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
@@ skipping 18 matching lines @@
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(prefs::kMaxTabs));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(prefs::kMaxTabs));
 
   // Test a preference from the recommended pref store.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kRecommendedPref));
 
+  // Test a preference from the default pref store.
+  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
+      prefs::kDefaultPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
+      prefs::kDefaultPref));
+
   // Test a preference for which the PrefValueStore does not contain a value.
   ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInExtensionStore(
       prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromExtensionStore(
       prefs::kMissingPref));
 }
 
 TEST_F(PrefValueStoreTest, PrefValueInUserStore) {
   // Test an enforced preference.
@@ skipping 20 matching lines @@
   EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kMaxTabs));
   EXPECT_TRUE(pref_value_store_->PrefValueFromUserStore(prefs::kMaxTabs));
 
   // Test a preference from the recommended pref store.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(
       prefs::kRecommendedPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
       prefs::kRecommendedPref));
 
+  // Test a preference from the default pref store.
+  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kDefaultPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kDefaultPref));
+
   // Test a preference for which the PrefValueStore does not contain a value.
   ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueInUserStore(prefs::kMissingPref));
   EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kMissingPref));
 }
 
+TEST_F(PrefValueStoreTest, PrefValueFromDefaultStore) {
+  // Test an enforced preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomepage));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(prefs::kHomepage));
+
+  // Test an extension preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
+      prefs::kCurrentThemeID));
+
+  // Test a command-line preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kApplicationLocale));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
+      prefs::kApplicationLocale));
+
+  // Test a user preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kMaxTabs));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(prefs::kMaxTabs));
+
+  // Test a preference from the recommended pref store.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kRecommendedPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromDefaultStore(
+      prefs::kRecommendedPref));
+
+  // Test a preference from the default pref store.
+  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kDefaultPref));
+  EXPECT_TRUE(
+      pref_value_store_->PrefValueFromDefaultStore(prefs::kDefaultPref));
+
+  // Test a preference for which the PrefValueStore does not contain a value.
+  ASSERT_FALSE(pref_value_store_->HasPrefPath(prefs::kMissingPref));
+  EXPECT_FALSE(
+      pref_value_store_->PrefValueFromDefaultStore(prefs::kMissingPref));
+}
+
 TEST_F(PrefValueStoreTest, TestPolicyRefresh) {
   // pref_value_store_ is initialized by PrefValueStoreTest to have values
   // in both it's managed and recommended store. By replacing them with
   // dummy stores, all of the paths of the prefs originally managed and
   // recommended stores should change.
   MockPolicyRefreshCallback callback;
   EXPECT_CALL(callback, DoCallback(_)).Times(0);
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(
@@ skipping 109 matching lines @@
   Mock::VerifyAndClearExpectations(&callback1);
   Mock::VerifyAndClearExpectations(&callback2);
   Mock::VerifyAndClearExpectations(&callback3);
 
   EXPECT_CALL(callback1, DoCallback(expected_differing_paths_)).Times(1);
   std::vector<std::string> no_differing_paths;
   EXPECT_CALL(callback2, DoCallback(no_differing_paths)).Times(1);
   EXPECT_CALL(callback3, DoCallback(no_differing_paths)).Times(1);
   loop_.RunAllPending();
 }