Migrate old settings for ContentSettingTypes with wildcard as secondary_pattern

components/content_settings/core/browser/host_content_settings_map.cc

 // Copyright (c) 2012 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 "components/content_settings/core/browser/host_content_settings_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 148 matching lines @@
   // This ensures that content settings are cleared for the guest profile. This
   // wouldn't be needed except that we used to allow settings to be stored for
   // the guest profile and so we need to ensure those get cleared.
   if (is_guest_profile)
     pref_provider->ClearPrefs();
 
   content_settings::ObservableProvider* default_provider =
       new content_settings::DefaultProvider(prefs_, is_off_the_record_);
   default_provider->AddObserver(this);
   content_settings_providers_[DEFAULT_PROVIDER] = default_provider;
+
+  MigrateOldSettings();
 }
 
 // static
 void HostContentSettingsMap::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // Ensure the content settings are all registered.
   content_settings::ContentSettingsRegistry::GetInstance();
 
   registry->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, 0);
 
@@ skipping 253 matching lines @@
                                  primary_url, secondary_url);
   ContentSettingsPattern primary_pattern = patterns.first;
   ContentSettingsPattern secondary_pattern = patterns.second;
   if (!primary_pattern.IsValid() || !secondary_pattern.IsValid())
     return;
 
   SetContentSetting(primary_pattern, secondary_pattern, content_type,
                     resource_identifier, setting);
 }
 
+void HostContentSettingsMap::MigrateOldSettings() {
+  const ContentSettingsType kMigrateContentSettingTypes[] = {
+      // Only content types of scoping type: REQUESTING_DOMAIN_ONLY_SCOPE,
+      // REQUESTING_ORIGIN_ONLY_SCOPE and TOP_LEVEL_DOMAIN_ONLY_SCOPE need to be
+      // migrated.
+      CONTENT_SETTINGS_TYPE_KEYGEN};
+  for (const ContentSettingsType& type : kMigrateContentSettingTypes) {
+    WebsiteSettingsInfo::ScopingType scoping_type =
+        content_settings::ContentSettingsRegistry::GetInstance()
+            ->Get(type)
+            ->website_settings_info()
+            ->scoping_type();
+    DCHECK_NE(
+        scoping_type,
+        WebsiteSettingsInfo::REQUESTING_ORIGIN_AND_TOP_LEVEL_ORIGIN_SCOPE);
+
+    ContentSettingsForOneType settings;
+    GetSettingsForOneType(type, std::string(), &settings);
+    for (const ContentSettingPatternSource& setting_entry : settings) {
+      // Migrate user preference settings only.
+      if (setting_entry.source != "preference")
+        continue;
+      // Migrate old-format settings only.
+      if (setting_entry.secondary_pattern !=
+          ContentSettingsPattern::Wildcard()) {
+        GURL url(setting_entry.primary_pattern.ToString());
+        // Pull out the value of the old-format setting. Only do this if the
+        // patterns are as we expect them to be, otherwise the setting will just
+        // be removed for safety.
+        ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+        if (setting_entry.primary_pattern == setting_entry.secondary_pattern &&
+            url.is_valid()) {
+          content_setting = GetContentSetting(url, url, type, std::string());
+        }
+        // Remove the old pattern.
+        SetContentSetting(setting_entry.primary_pattern,
+                          setting_entry.secondary_pattern, type, std::string(),
+                          CONTENT_SETTING_DEFAULT);
+        // Set the new pattern.
+        SetContentSettingDefaultScope(url, GURL(), type, std::string(),
+                                      content_setting);
+      }
+    }
+  }
+}
+
 ContentSetting HostContentSettingsMap::GetContentSettingAndMaybeUpdateLastUsage(
     const GURL& primary_url,
     const GURL& secondary_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ContentSetting setting = GetContentSetting(
       primary_url, secondary_url, content_type, resource_identifier);
   if (setting == CONTENT_SETTING_ALLOW) {
@@ skipping 319 matching lines @@
         rule.secondary_pattern.Matches(secondary_url)) {
       if (primary_pattern)
         *primary_pattern = rule.primary_pattern;
       if (secondary_pattern)
         *secondary_pattern = rule.secondary_pattern;
       return make_scoped_ptr(rule.value.get()->DeepCopy());
     }
   }
   return scoped_ptr<base::Value>();
 }