Move pref names and default value into WebsiteSettingsInfo

chrome/browser/prefs/pref_model_associator_unittest.cc

 // Copyright (c) 2011 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/memory/scoped_ptr.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_model_associator.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// Any content settings pref name should do for these tests.
+const char* kContentSettingsPrefName =
+    "profile.content_settings.exceptions.cookies";
+
 class AbstractPreferenceMergeTest : public testing::Test {
  protected:
   void SetUp() override { pref_service_ = profile_.GetPrefs(); }
 
   void SetContentPattern(base::DictionaryValue* patterns_dict,
                          const std::string& expression,
                          int setting) {
     base::DictionaryValue* expression_dict;
     bool found =
         patterns_dict->GetDictionaryWithoutPathExpansion(expression,
@@ skipping 190 matching lines @@
 
   std::string expression0_;
   std::string expression1_;
   std::string expression2_;
   std::string expression3_;
   std::string expression4_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) {
-  SetPrefToEmpty(prefs::kContentSettingsImagesPatternPairs);
+  SetPrefToEmpty(kContentSettingsPrefName);
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kContentSettingsImagesPatternPairs);
+      pref_service_->FindPreference(kContentSettingsPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
                                            server_patterns_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ServerNull) {
   scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsCookiesPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kContentSettingsCookiesPatternPairs);
+      pref_service_->FindPreference(kContentSettingsPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
                                            *null_value));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(prefs::kContentSettingsCookiesPatternPairs);
+      pref_service_->GetDictionary(kContentSettingsPrefName);
   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ServerEmpty) {
   scoped_ptr<base::Value> empty_value(new base::DictionaryValue);
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsPluginsPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(
-          prefs::kContentSettingsPluginsPatternPairs);
+      pref_service_->FindPreference(kContentSettingsPrefName);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
                                            *empty_value));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(
-          prefs::kContentSettingsPluginsPatternPairs);
+      pref_service_->GetDictionary(kContentSettingsPrefName);
   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) {
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsJavaScriptPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-     prefs::kContentSettingsJavaScriptPatternPairs,
-      *pref_service_->FindPreference(
-          prefs::kContentSettingsJavaScriptPatternPairs)->GetValue(),
+      kContentSettingsPrefName,
+      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
       server_patterns_));
 
   base::DictionaryValue expected;
   SetContentPattern(&expected, expression0_, 1);
   SetContentPattern(&expected, expression1_, 2);
   SetContentPattern(&expected, expression2_, 1);
   SetContentPattern(&expected, expression3_, 1);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeConflicts) {
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsPopupsPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
     SetContentPattern(local_dict_value, expression3_, 1);
     SetContentPattern(local_dict_value, expression4_, 2);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      prefs::kContentSettingsPopupsPatternPairs,
-      *pref_service_->FindPreference(
-          prefs::kContentSettingsPopupsPatternPairs)->GetValue(),
+      kContentSettingsPrefName,
+      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
       server_patterns_));
 
   base::DictionaryValue expected;
   SetContentPattern(&expected, expression0_, 1);
   SetContentPattern(&expected, expression1_, 2);
   SetContentPattern(&expected, expression2_, 1);
   SetContentPattern(&expected, expression3_, 1);
   SetContentPattern(&expected, expression4_, 2);
   EXPECT_TRUE(merged_value->Equals(&expected));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, Equal) {
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsMouseLockPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 1);
     SetContentPattern(local_dict_value, expression1_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      prefs::kContentSettingsMouseLockPatternPairs,
-      *pref_service_->FindPreference(
-          prefs::kContentSettingsMouseLockPatternPairs)->GetValue(),
+      kContentSettingsPrefName,
+      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
       server_patterns_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) {
   {
-    DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsFullScreenPatternPairs);
+    DictionaryPrefUpdate update(pref_service_, kContentSettingsPrefName);
     base::DictionaryValue* local_dict_value = update.Get();
     SetContentPattern(local_dict_value, expression0_, 2);
     SetContentPattern(local_dict_value, expression1_, 2);
     SetContentPattern(local_dict_value, expression2_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-      prefs::kContentSettingsFullScreenPatternPairs,
-      *pref_service_->FindPreference(
-          prefs::kContentSettingsFullScreenPatternPairs)->GetValue(),
+      kContentSettingsPrefName,
+      *pref_service_->FindPreference(kContentSettingsPrefName)->GetValue(),
       server_patterns_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 class IndividualPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
   IndividualPreferenceMergeTest() :
       url0_("http://example.com/server0"),
       url1_("http://example.com/server1"),
       expression0_("expression0"),
@@ skipping 46 matching lines @@
   std::string expression0_;
   std::string expression1_;
   std::string content_type0_;
   base::ListValue server_url_list_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(IndividualPreferenceMergeTest, URLsToRestoreOnStartup) {
   EXPECT_TRUE(MergeListPreference(prefs::kURLsToRestoreOnStartup));
 }