Remove the migration code from content_settings::PrefProvider.

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"
 
 class AbstractPreferenceMergeTest : public testing::Test {
  protected:
   void SetUp() override { pref_service_ = profile_.GetPrefs(); }
 
   void SetContentPattern(base::DictionaryValue* patterns_dict,
                          const std::string& expression,
-                         const std::string& content_type,
                          int setting) {
     base::DictionaryValue* expression_dict;
     bool found =
         patterns_dict->GetDictionaryWithoutPathExpansion(expression,
                                                          &expression_dict);
     if (!found) {
       expression_dict = new base::DictionaryValue;
       patterns_dict->SetWithoutPathExpansion(expression, expression_dict);
     }
     expression_dict->SetWithoutPathExpansion(
-        content_type, new base::FundamentalValue(setting));
+        "setting", new base::FundamentalValue(setting));
   }
 
   void SetPrefToEmpty(const std::string& pref_name) {
     scoped_ptr<base::Value> empty_value;
     const PrefService::Preference* pref =
         pref_service_->FindPreference(pref_name.c_str());
     ASSERT_TRUE(pref);
     base::Value::Type type = pref->GetType();
     if (type == base::Value::TYPE_DICTIONARY)
       empty_value.reset(new base::DictionaryValue);
@@ skipping 154 matching lines @@
                                            server_url_list_));
   EXPECT_TRUE(merged_value->Equals(original.get()));
 }
 
 class DictionaryPreferenceMergeTest : public AbstractPreferenceMergeTest {
  protected:
   DictionaryPreferenceMergeTest() :
       expression0_("expression0"),
       expression1_("expression1"),
       expression2_("expression2"),
-      content_type0_("content_type0"),
-      content_type1_("content_type1") {}
+      expression3_("expression3"),
+      expression4_("expression4") {}
 
   void SetUp() override {
     AbstractPreferenceMergeTest::SetUp();
-    SetContentPattern(&server_patterns_, expression0_, content_type0_, 1);
-    SetContentPattern(&server_patterns_, expression0_, content_type1_, 2);
-    SetContentPattern(&server_patterns_, expression1_, content_type0_, 1);
+    SetContentPattern(&server_patterns_, expression0_, 1);
+    SetContentPattern(&server_patterns_, expression1_, 2);
+    SetContentPattern(&server_patterns_, expression2_, 1);
   }
 
   std::string expression0_;
   std::string expression1_;
   std::string expression2_;
-  std::string content_type0_;
-  std::string content_type1_;
+  std::string expression3_;
+  std::string expression4_;
   base::DictionaryValue server_patterns_;
 };
 
 TEST_F(DictionaryPreferenceMergeTest, LocalEmpty) {
-  SetPrefToEmpty(prefs::kContentSettingsPatternPairs);
+  SetPrefToEmpty(prefs::kContentSettingsImagesPatternPairs);
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
+      pref_service_->FindPreference(prefs::kContentSettingsImagesPatternPairs);
   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::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsCookiesPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
+    SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
+      pref_service_->FindPreference(prefs::kContentSettingsCookiesPatternPairs);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
                                            *null_value));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(prefs::kContentSettingsPatternPairs);
+      pref_service_->GetDictionary(prefs::kContentSettingsCookiesPatternPairs);
   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::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsPluginsPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
+    SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   const PrefService::Preference* pref =
-      pref_service_->FindPreference(prefs::kContentSettingsPatternPairs);
+      pref_service_->FindPreference(
+          prefs::kContentSettingsPluginsPatternPairs);
   scoped_ptr<base::Value> merged_value(
       PrefModelAssociator::MergePreference(pref->name(),
                                            *pref->GetValue(),
                                            *empty_value));
   const base::DictionaryValue* local_dict_value =
-      pref_service_->GetDictionary(prefs::kContentSettingsPatternPairs);
+      pref_service_->GetDictionary(
+          prefs::kContentSettingsPluginsPatternPairs);
   EXPECT_TRUE(merged_value->Equals(local_dict_value));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, MergeNoConflicts) {
   {
     DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsJavaScriptPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression2_, content_type0_, 1);
+    SetContentPattern(local_dict_value, expression3_, 1);
   }
 
   scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
-     prefs::kContentSettingsPatternPairs,
-      *pref_service_->FindPreference(prefs::kContentSettingsPatternPairs)->
-          GetValue(),
+     prefs::kContentSettingsJavaScriptPatternPairs,
+      *pref_service_->FindPreference(
+          prefs::kContentSettingsJavaScriptPatternPairs)->GetValue(),
       server_patterns_));
 
   base::DictionaryValue expected;
-  SetContentPattern(&expected, expression0_, content_type0_, 1);
-  SetContentPattern(&expected, expression0_, content_type1_, 2);
-  SetContentPattern(&expected, expression1_, content_type0_, 1);
-  SetContentPattern(&expected, expression2_, content_type0_, 1);
+  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::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsPopupsPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression0_, content_type0_, 2);
-    SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
-    SetContentPattern(local_dict_value, expression1_, content_type1_, 1);
-    SetContentPattern(local_dict_value, expression2_, content_type0_, 2);
+    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::kContentSettingsPatternPairs,
-      *pref_service_->FindPreference(prefs::kContentSettingsPatternPairs)->
-          GetValue(),
+      prefs::kContentSettingsPopupsPatternPairs,
+      *pref_service_->FindPreference(
+          prefs::kContentSettingsPopupsPatternPairs)->GetValue(),
       server_patterns_));
 
   base::DictionaryValue expected;
-  SetContentPattern(&expected, expression0_, content_type0_, 1);
-  SetContentPattern(&expected, expression0_, content_type1_, 2);
-  SetContentPattern(&expected, expression1_, content_type0_, 1);
-  SetContentPattern(&expected, expression1_, content_type1_, 1);
-  SetContentPattern(&expected, expression2_, content_type0_, 2);
+  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::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsMouseLockPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression0_, content_type0_, 1);
-    SetContentPattern(local_dict_value, expression0_, content_type1_, 2);
-    SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
+    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::kContentSettingsPatternPairs,
-      *pref_service_->
-          FindPreference(prefs::kContentSettingsPatternPairs)->GetValue(),
+      prefs::kContentSettingsMouseLockPatternPairs,
+      *pref_service_->FindPreference(
+          prefs::kContentSettingsMouseLockPatternPairs)->GetValue(),
       server_patterns_));
   EXPECT_TRUE(merged_value->Equals(&server_patterns_));
 }
 
 TEST_F(DictionaryPreferenceMergeTest, ConflictButServerWins) {
   {
     DictionaryPrefUpdate update(pref_service_,
-                                prefs::kContentSettingsPatternPairs);
+                                prefs::kContentSettingsFullScreenPatternPairs);
     base::DictionaryValue* local_dict_value = update.Get();
-    SetContentPattern(local_dict_value, expression0_, content_type0_, 2);
-    SetContentPattern(local_dict_value, expression0_, content_type1_, 2);
-    SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
+    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::kContentSettingsPatternPairs,
-      *pref_service_->
-          FindPreference(prefs::kContentSettingsPatternPairs)->GetValue(),
+      prefs::kContentSettingsFullScreenPatternPairs,
+      *pref_service_->FindPreference(
+          prefs::kContentSettingsFullScreenPatternPairs)->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"),
-      expression1_("expression1"),
-      content_type0_("content_type0") {}
+      expression1_("expression1") {}
 
   void SetUp() override {
     AbstractPreferenceMergeTest::SetUp();
     server_url_list_.Append(new base::StringValue(url0_));
-    SetContentPattern(&server_patterns_, expression0_, content_type0_, 1);
+    SetContentPattern(&server_patterns_, expression0_, 1);
   }
 
   bool MergeListPreference(const char* pref) {
     {
       ListPrefUpdate update(pref_service_, pref);
       base::ListValue* local_list_value = update.Get();
       local_list_value->Append(new base::StringValue(url1_));
     }
 
     scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
         pref,
         *pref_service_->GetUserPrefValue(pref),
         server_url_list_));
 
     base::ListValue expected;
     expected.Append(new base::StringValue(url0_));
     expected.Append(new base::StringValue(url1_));
     return merged_value->Equals(&expected);
   }
 
   bool MergeDictionaryPreference(const char* pref) {
     {
       DictionaryPrefUpdate update(pref_service_, pref);
       base::DictionaryValue* local_dict_value = update.Get();
-      SetContentPattern(local_dict_value, expression1_, content_type0_, 1);
+      SetContentPattern(local_dict_value, expression1_, 1);
     }
 
     scoped_ptr<base::Value> merged_value(PrefModelAssociator::MergePreference(
         pref,
         *pref_service_->GetUserPrefValue(pref),
         server_patterns_));
 
     base::DictionaryValue expected;
-    SetContentPattern(&expected, expression0_, content_type0_, 1);
-    SetContentPattern(&expected, expression1_, content_type0_, 1);
+    SetContentPattern(&expected, expression0_, 1);
+    SetContentPattern(&expected, expression1_, 1);
     return merged_value->Equals(&expected);
   }
 
   std::string url0_;
   std::string url1_;
   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));
 }