Change HostContentSettingsMap::SetContentSetting to use GURLs instead of patterns

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 16 matching lines @@
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/browser/website_settings_registry.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "net/base/net_errors.h"
 #include "net/base/static_cookie_policy.h"
 #include "url/gurl.h"
 
+using content_settings::WebsiteSettingsInfo;
+
 namespace {
 
 typedef std::vector<content_settings::Rule> Rules;
 
 typedef std::pair<std::string, std::string> StringPair;
 
 struct ProviderNamesSourceMapEntry {
   const char* provider_name;
   content_settings::SettingSource provider_source;
 };
 
 const ProviderNamesSourceMapEntry kProviderNamesSourceMap[] = {
     {"platform_app", content_settings::SETTING_SOURCE_EXTENSION},
     {"policy", content_settings::SETTING_SOURCE_POLICY},
     {"supervised_user", content_settings::SETTING_SOURCE_SUPERVISED},
     {"extension", content_settings::SETTING_SOURCE_EXTENSION},
     {"preference", content_settings::SETTING_SOURCE_USER},
     {"default", content_settings::SETTING_SOURCE_USER},
 };
 
+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_COOKIES,
+    CONTENT_SETTINGS_TYPE_IMAGES,
+    CONTENT_SETTINGS_TYPE_JAVASCRIPT,
+    CONTENT_SETTINGS_TYPE_PLUGINS,
+    CONTENT_SETTINGS_TYPE_POPUPS,
+    CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+    CONTENT_SETTINGS_TYPE_MOUSELOCK,
+    CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+    CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+    CONTENT_SETTINGS_TYPE_PPAPI_BROKER,
+    CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
+    CONTENT_SETTINGS_TYPE_DURABLE_STORAGE,
+    CONTENT_SETTINGS_TYPE_KEYGEN,
+    CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS,
+    CONTENT_SETTINGS_TYPE_MIXEDSCRIPT};
+
 static_assert(
     arraysize(kProviderNamesSourceMap) ==
         HostContentSettingsMap::NUM_PROVIDER_TYPES,
     "kProviderNamesSourceMap should have NUM_PROVIDER_TYPES elements");
 
 // Returns true if the |content_type| supports a resource identifier.
 // Resource identifiers are supported (but not required) for plugins.
 bool SupportsResourceIdentifier(ContentSettingsType content_type) {
   return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
 }
@@ skipping 32 matching lines @@
         content_settings::ValueToContentSetting(value.get());
     if (setting != CONTENT_SETTING_ALLOW)
       return value;
     DCHECK(content_settings_info->IsSettingValid(CONTENT_SETTING_ASK));
     return content_settings::ContentSettingToValue(CONTENT_SETTING_ASK);
   }
 
   return value;
 }
 
+struct PatternPair {
+  ContentSettingsPattern primary_pattern;
+  ContentSettingsPattern secondary_pattern;
+};
+
+PatternPair GetPatternsFromScopingType(
+    WebsiteSettingsInfo::ScopingType scoping_type,
+    const GURL& primary_url,
+    const GURL& secondary_url) {
+  PatternPair patterns;
+
+  switch (scoping_type) {
+    case WebsiteSettingsInfo::TOP_LEVEL_DOMAIN_ONLY_SCOPE:
+    case WebsiteSettingsInfo::REQUESTING_DOMAIN_ONLY_SCOPE:
+      patterns.primary_pattern = ContentSettingsPattern::FromURL(primary_url);
+      patterns.secondary_pattern = ContentSettingsPattern::Wildcard();
+      break;
+    case WebsiteSettingsInfo::REQUESTING_ORIGIN_ONLY_SCOPE:
+      patterns.primary_pattern =
+          ContentSettingsPattern::FromURLNoWildcard(primary_url);
+      patterns.secondary_pattern = ContentSettingsPattern::Wildcard();
+      break;
+    case WebsiteSettingsInfo::REQUESTING_ORIGIN_AND_TOP_LEVEL_ORIGIN_SCOPE:
+      patterns.primary_pattern =
+          ContentSettingsPattern::FromURLNoWildcard(primary_url);
+      patterns.secondary_pattern =
+          ContentSettingsPattern::FromURLNoWildcard(secondary_url);
+      break;
+  }
+  return patterns;
+}
+
 }  // namespace
 
 HostContentSettingsMap::HostContentSettingsMap(PrefService* prefs,
                                                bool is_incognito_profile,
                                                bool is_guest_profile)
     :
 #ifndef NDEBUG
       used_from_thread_id_(base::PlatformThread::CurrentId()),
 #endif
       prefs_(prefs),
@@ skipping 11 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 126 matching lines @@
                                ContentSettingsPattern::Wildcard(), content_type,
                                std::string(), std::move(value));
 }
 
 void HostContentSettingsMap::SetWebsiteSettingDefaultScope(
     const GURL& requesting_url,
     const GURL& top_level_url,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     base::Value* value) {
-  using content_settings::WebsiteSettingsInfo;
-
   const WebsiteSettingsInfo* info =
       content_settings::WebsiteSettingsRegistry::GetInstance()->Get(
           content_type);
-  ContentSettingsPattern primary_pattern;
-  ContentSettingsPattern secondary_pattern;
-  switch (info->scoping_type()) {
-    case WebsiteSettingsInfo::TOP_LEVEL_DOMAIN_ONLY_SCOPE:
-      primary_pattern = ContentSettingsPattern::FromURL(top_level_url);
-      secondary_pattern = ContentSettingsPattern::Wildcard();
-      DCHECK(requesting_url.is_empty());
-      break;
-    case WebsiteSettingsInfo::REQUESTING_DOMAIN_ONLY_SCOPE:
-      primary_pattern = ContentSettingsPattern::FromURL(requesting_url);
-      secondary_pattern = ContentSettingsPattern::Wildcard();
-      DCHECK(top_level_url.is_empty());
-      break;
-    case WebsiteSettingsInfo::REQUESTING_ORIGIN_ONLY_SCOPE:
-      primary_pattern =
-          ContentSettingsPattern::FromURLNoWildcard(requesting_url);
-      secondary_pattern = ContentSettingsPattern::Wildcard();
-      DCHECK(top_level_url.is_empty());
-      break;
-    case WebsiteSettingsInfo::REQUESTING_ORIGIN_AND_TOP_LEVEL_ORIGIN_SCOPE:
-      primary_pattern =
-          ContentSettingsPattern::FromURLNoWildcard(requesting_url);
-      secondary_pattern =
-          ContentSettingsPattern::FromURLNoWildcard(top_level_url);
-      break;
-  }
+  PatternPair patterns = GetPatternsFromScopingType(
+      info->scoping_type(), requesting_url, top_level_url);
+  ContentSettingsPattern primary_pattern = patterns.primary_pattern;
+  ContentSettingsPattern secondary_pattern = patterns.secondary_pattern;
   if (!primary_pattern.IsValid() || !secondary_pattern.IsValid())
     return;
+
   SetWebsiteSettingCustomScope(primary_pattern, secondary_pattern, content_type,
                                resource_identifier, make_scoped_ptr(value));
 }
 
 void HostContentSettingsMap::SetWebsiteSettingCustomScope(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     const std::string& resource_identifier,
     scoped_ptr<base::Value> value) {
@@ skipping 101 matching lines @@
   if (setting != CONTENT_SETTING_DEFAULT) {
     DCHECK(content_settings::ContentSettingsRegistry::GetInstance()
                ->Get(content_type)
                ->IsSettingValid(setting));
     value.reset(new base::FundamentalValue(setting));
   }
   SetWebsiteSettingCustomScope(primary_pattern, secondary_pattern, content_type,
                                resource_identifier, std::move(value));
 }
 
+void HostContentSettingsMap::SetContentSettingDefaultScope(
+    const GURL& primary_url,
+    const GURL& secondary_url,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier,
+    ContentSetting setting) {
+  using content_settings::ContentSettingsInfo;
+  const ContentSettingsInfo* info =
+      content_settings::ContentSettingsRegistry::GetInstance()->Get(
+          content_type);
+  DCHECK(info);
+
+  PatternPair patterns =
+      GetPatternsFromScopingType(info->website_settings_info()->scoping_type(),
+                                 primary_url, secondary_url);
+  ContentSettingsPattern primary_pattern = patterns.primary_pattern;
+  ContentSettingsPattern secondary_pattern = patterns.secondary_pattern;
+  if (!primary_pattern.IsValid() || !secondary_pattern.IsValid())
+    return;
+
+  SetContentSettingCustomScope(primary_pattern, secondary_pattern, content_type,
+                               resource_identifier, setting);
+}
+
+void HostContentSettingsMap::SetContentSettingCustomScope(

[raymes, 2016/03/01 06:17:32]

Maybe we shouldn't add this yet - instead we could just wait until we've changed
everything to SetContentSettingDefaultScope and then we can rename it to
"CustomScope"?

[lshang, 2016/03/02 04:02:28]

Done.

+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier,
+    ContentSetting setting) {
+  DCHECK(content_settings::ContentSettingsRegistry::GetInstance()->Get(
+      content_type));
+  if (setting == CONTENT_SETTING_ALLOW &&
+      (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION ||
+       content_type == CONTENT_SETTINGS_TYPE_NOTIFICATIONS)) {
+    UpdateLastUsageByPattern(primary_pattern, secondary_pattern, content_type);
+  }
+
+  scoped_ptr<base::Value> value;
+  // A value of CONTENT_SETTING_DEFAULT implies deleting the content setting.
+  if (setting != CONTENT_SETTING_DEFAULT) {
+    DCHECK(content_settings::ContentSettingsRegistry::GetInstance()
+               ->Get(content_type)
+               ->IsSettingValid(setting));
+    value.reset(new base::FundamentalValue(setting));
+  }
+  SetWebsiteSettingCustomScope(primary_pattern, secondary_pattern, content_type,
+                               resource_identifier, std::move(value));
+}
+
+void HostContentSettingsMap::MigrateOldSettings() {
+  for (const ContentSettingsType& type : kMigrateContentSettingTypes) {
+    ContentSettingsForOneType settings;
+    GetSettingsForOneType(type, std::string(), &settings);
+    for (const ContentSettingPatternSource& setting_entry : settings) {
+      // 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.
+        if (content_setting) {
+          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>();
 }