Add methods for determining which PrefStore contains a given preference, and ...

chrome/browser/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 "app/test/data/resource.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/dummy_pref_store.h"
 #include "chrome/browser/pref_value_store.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Mock;
 
 // Names of the preferences used in this test program.
 namespace prefs {
   const wchar_t kCurrentThemeID[] = L"extensions.theme.id";
   const wchar_t kDeleteCache[] = L"browser.clear_data.cache";
-  const wchar_t kExtensionPref[] = L"extension.pref";
   const wchar_t kHomepage[] = L"homepage";
   const wchar_t kMaxTabs[] = L"tabs.max_tabs";
   const wchar_t kMissingPref[] = L"this.pref.does_not_exist";
   const wchar_t kRecommendedPref[] = L"this.pref.recommended_value_only";
   const wchar_t kSampleDict[] = L"sample.dict";
   const wchar_t kSampleList[] = L"sample.list";
 }
 
 // Potentailly expected values of all preferences used in this test program.
 // The "user" namespace is defined globally in an ARM system header, so we need
@@ skipping 198 matching lines @@
   user_pref_store_->set_prefs_written(false);
   pref_value_store_->WritePrefs();
   ASSERT_TRUE(user_pref_store_->get_prefs_written());
 }
 
 TEST_F(PrefValueStoreTest, SetUserPrefValue) {
   Value* new_value = NULL;
   Value* actual_value = NULL;
 
   // Test that enforced values can not be set.
-  ASSERT_TRUE(pref_value_store_->PrefValueIsManaged(prefs::kHomepage));
+  ASSERT_TRUE(pref_value_store_->PrefValueInManagedStore(prefs::kHomepage));
   // The Ownership is tranfered to |PrefValueStore|.
   new_value = Value::CreateStringValue(L"http://www.youtube.com");
   pref_value_store_->SetUserPrefValue(prefs::kHomepage, new_value);
 
   ASSERT_TRUE(pref_value_store_->GetValue(prefs::kHomepage, &actual_value));
   std::wstring value_str;
   actual_value->GetAsString(&value_str);
   ASSERT_EQ(enforced_pref::kHomepageValue, value_str);
 
   // User preferences values can be set
-  ASSERT_FALSE(pref_value_store_->PrefValueIsManaged(prefs::kMaxTabs));
+  ASSERT_FALSE(pref_value_store_->PrefValueInManagedStore(prefs::kMaxTabs));
   actual_value = NULL;
   pref_value_store_->GetValue(prefs::kMaxTabs, &actual_value);
   int int_value;
   EXPECT_TRUE(actual_value->GetAsInteger(&int_value));
   EXPECT_EQ(user_pref::kMaxTabsValue, int_value);
 
   new_value = Value::CreateIntegerValue(1);
   pref_value_store_->SetUserPrefValue(prefs::kMaxTabs, new_value);
   actual_value = NULL;
   pref_value_store_->GetValue(prefs::kMaxTabs, &actual_value);
@@ skipping 15 matching lines @@
   pref_value_store_->SetUserPrefValue(prefs::kSampleList, expected_list_value);
 
   actual_value = NULL;
   key = prefs::kSampleList;
   pref_value_store_->GetValue(key, &actual_value);
 
   ASSERT_EQ(expected_list_value, actual_value);
   ASSERT_TRUE(expected_list_value->Equals(actual_value));
 }
 
-TEST_F(PrefValueStoreTest, PrefValueIsManaged) {
+TEST_F(PrefValueStoreTest, PrefValueInManagedStore) {
   // Test an enforced preference.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomepage));
-  EXPECT_TRUE(pref_value_store_->PrefValueIsManaged(prefs::kHomepage));
+  EXPECT_TRUE(pref_value_store_->PrefValueInManagedStore(prefs::kHomepage));
+
+  // Test an extension preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
+  EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
+      prefs::kCurrentThemeID));
 
   // Test a user preference.
   ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kMaxTabs));
-  EXPECT_FALSE(pref_value_store_->PrefValueIsManaged(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_->PrefValueIsManaged(prefs::kRecommendedPref));
+  EXPECT_FALSE(pref_value_store_->PrefValueInManagedStore(
+      prefs::kRecommendedPref));
 
   // 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_->PrefValueIsManaged(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(
+      prefs::kHomepage));
+
+  // Test an extension preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
+  EXPECT_TRUE(pref_value_store_->PrefValueInExtensionStore(
+      prefs::kCurrentThemeID));
+  EXPECT_TRUE(pref_value_store_->PrefValueFromExtensionStore(
+      prefs::kCurrentThemeID));
+
+  // Test a user preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kMaxTabs));
+  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 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.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kHomepage));
+  EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(prefs::kHomepage));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(prefs::kHomepage));
+
+  // Test an extension preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kCurrentThemeID));
+  EXPECT_TRUE(pref_value_store_->PrefValueInUserStore(
+      prefs::kCurrentThemeID));
+  EXPECT_FALSE(pref_value_store_->PrefValueFromUserStore(
+      prefs::kCurrentThemeID));
+
+  // Test a user preference.
+  ASSERT_TRUE(pref_value_store_->HasPrefPath(prefs::kMaxTabs));
+  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 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));
+}