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

chrome/browser/prefs/pref_value_store_unittest.cc

Index: chrome/browser/prefs/pref_value_store_unittest.cc
===================================================================
--- chrome/browser/prefs/pref_value_store_unittest.cc	(revision 59196)
+++ chrome/browser/prefs/pref_value_store_unittest.cc	(working copy)
@@ -35,6 +35,7 @@
   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.
@@ -72,6 +73,10 @@
   const bool kRecommendedPrefValue = true;
 }
 
+namespace default_pref {
+  const int kDefaultValue = 7;
+}
+
 class PrefValueStoreTest : public testing::Test {
  protected:
   virtual void SetUp() {
@@ -81,6 +86,7 @@
     command_line_prefs_ = CreateCommandLinePrefs();
     user_prefs_ = CreateUserPrefs();
     recommended_prefs_ = CreateRecommendedPrefs();
+    default_prefs_ = CreateDefaultPrefs();
 
     // Create |DummyPrefStore|s.
     enforced_pref_store_ = new DummyPrefStore();
@@ -94,6 +100,8 @@
     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(
@@ -101,7 +109,8 @@
         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_));
@@ -163,8 +172,15 @@
     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);
@@ -194,8 +210,9 @@
   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
@@ -209,6 +226,7 @@
   DictionaryValue* command_line_prefs_;
   DictionaryValue* user_prefs_;
   DictionaryValue* recommended_prefs_;
+  DictionaryValue* default_prefs_;
 
  private:
   scoped_ptr<ChromeThread> ui_thread_;
@@ -221,6 +239,7 @@
   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);
@@ -272,6 +291,13 @@
   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);
@@ -287,74 +313,40 @@
   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);
-  EXPECT_FALSE(pref_value_store_->PrefHasChanged(managed_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0), same_value.get()));
+  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");
 
-  // 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));
+  // Check pref controlled by highest-priority store.
   EXPECT_TRUE(pref_value_store_->PrefHasChanged(managed_pref_path,
-      static_cast<PrefNotifier::PrefStoreType>(0), other_value.get()));
+      static_cast<PrefNotifier::PrefStoreType>(0)));
+  EXPECT_FALSE(pref_value_store_->PrefHasChanged(managed_pref_path,
+      PrefNotifier::USER_STORE));
 
-  // 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.
+  // Check pref controlled by user store.
   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.
+      static_cast<PrefNotifier::PrefStoreType>(0)));
   EXPECT_TRUE(pref_value_store_->PrefHasChanged(user_pref_path,
-      PrefNotifier::USER_STORE, same_value.get()));
+      PrefNotifier::USER_STORE));
+  EXPECT_FALSE(pref_value_store_->PrefHasChanged(user_pref_path,
+      PrefNotifier::PREF_STORE_TYPE_MAX));
 
-  // 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) {
@@ -448,6 +440,11 @@
   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));
@@ -486,6 +483,13 @@
   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(
@@ -526,12 +530,52 @@
   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