Only Register() platform specific content settings types on different platforms

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 153 matching lines @@
   // 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;
 
+// ios doean't have KEYGEN to be migrated.
+#if !defined(OS_IOS)
   MigrateOldSettings();

[raymes, 2016/05/20 19:10:16]

Maybe we can just rename this to MigrateKeygenSettings and remove the array/loop
in the function since we only have one type :)

[lshang, 2016/05/24 11:55:45]

Good suggestion! I made a separate
CL(https://codereview.chromium.org/2006553002/) to do this, for clarity of code
change history, because this is not much related to this CL:P

-
+#endif
   RecordNumberOfExceptions();
 }
 
 // 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 281 matching lines @@
                                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);
+    const content_settings::ContentSettingsInfo* info =
+        content_settings::ContentSettingsRegistry::GetInstance()->Get(type);
+    if (info) {
+      WebsiteSettingsInfo::ScopingType scoping_type =
+          info->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());
+      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.
+          SetContentSettingCustomScope(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);
         }
-        // Remove the old pattern.
-        SetContentSettingCustomScope(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);
       }
     }
   }
 }
 
 void HostContentSettingsMap::RecordNumberOfExceptions() {
   for (const content_settings::WebsiteSettingsInfo* info :
        *content_settings::WebsiteSettingsRegistry::GetInstance()) {
     ContentSettingsType content_type = info->type();
     const std::string type_name = info->name();
@@ skipping 341 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 base::WrapUnique(rule.value.get()->DeepCopy());
     }
   }
   return std::unique_ptr<base::Value>();
 }