Add migration code to change existing domain scoped content settings to be origin scoped

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 14 matching lines @@
 #include "components/content_settings/core/browser/content_settings_pref_provider.h"
 #include "components/content_settings/core/browser/content_settings_provider.h"
 #include "components/content_settings/core/browser/content_settings_registry.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #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 "components/syncable_prefs/pref_model_associator.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;
 
@@ skipping 66 matching lines @@
 }
 
 content_settings::PatternPair GetPatternsFromScopingType(
     WebsiteSettingsInfo::ScopingType scoping_type,
     const GURL& primary_url,
     const GURL& secondary_url) {
   DCHECK(!primary_url.is_empty());
   content_settings::PatternPair patterns;
 
   switch (scoping_type) {
-    case WebsiteSettingsInfo::TOP_LEVEL_DOMAIN_ONLY_SCOPE:
-    case WebsiteSettingsInfo::REQUESTING_DOMAIN_ONLY_SCOPE:
-      patterns.first = ContentSettingsPattern::FromURL(primary_url);
-      patterns.second = ContentSettingsPattern::Wildcard();
-      break;
+    case WebsiteSettingsInfo::TOP_LEVEL_ORIGIN_ONLY_SCOPE:
     case WebsiteSettingsInfo::REQUESTING_ORIGIN_ONLY_SCOPE:
       patterns.first = ContentSettingsPattern::FromURLNoWildcard(primary_url);
       patterns.second = ContentSettingsPattern::Wildcard();
       break;
     case WebsiteSettingsInfo::REQUESTING_ORIGIN_AND_TOP_LEVEL_ORIGIN_SCOPE:
       DCHECK(!secondary_url.is_empty());
       patterns.first = ContentSettingsPattern::FromURLNoWildcard(primary_url);
       patterns.second =
           ContentSettingsPattern::FromURLNoWildcard(secondary_url);
       break;
@@ skipping 29 matching lines @@
   // 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;
 
   MigrateKeygenSettings();
+  MigrateDomainScopedSettings();
+  RecordNumberOfExceptions();
 
-  RecordNumberOfExceptions();
+  syncable_prefs::PrefModelAssociator::SetMergeDataFinishedCallback(
+      base::Bind(&HostContentSettingsMap::MigrateDomainScopedSettings,
+                 base::Unretained(this)));
 }
 
 // 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 303 matching lines @@
                                      CONTENT_SETTINGS_TYPE_KEYGEN,
                                      std::string(), CONTENT_SETTING_DEFAULT);
         // Set the new pattern.
         SetContentSettingDefaultScope(url, GURL(), CONTENT_SETTINGS_TYPE_KEYGEN,
                                       std::string(), content_setting);
       }
     }
   }
 }
 
+void HostContentSettingsMap::MigrateDomainScopedSettings() {
+  const ContentSettingsType kDomainScopedTypes[] = {
+    CONTENT_SETTINGS_TYPE_COOKIES,
+#if !defined(OS_ANDROID) && !defined(OS_IOS)

[raymes, 2016/06/16 03:23:51]

Rather than the ifdefs, can we just check to see if
content_settings::ContentSettingsRegistry::GetInstance()->Get returns true?

[lshang, 2016/06/20 01:34:22]

Done.

+    CONTENT_SETTINGS_TYPE_IMAGES,
+    CONTENT_SETTINGS_TYPE_PLUGINS,
+#endif
+#if !defined(OS_IOS)
+    CONTENT_SETTINGS_TYPE_JAVASCRIPT,
+    CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
+#endif
+    CONTENT_SETTINGS_TYPE_POPUPS
+  };
+  for (const ContentSettingsType& type : kDomainScopedTypes) {
+    DCHECK(content_settings::ContentSettingsRegistry::GetInstance()->Get(type));
+    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 ALLOW settings only.
+      if (setting_entry.setting != CONTENT_SETTING_ALLOW)
+        continue;
+      // Skip default settings.
+      if (setting_entry.primary_pattern == ContentSettingsPattern::Wildcard() &&
+          setting_entry.secondary_pattern == ContentSettingsPattern::Wildcard())

[raymes, 2016/06/16 03:23:51]

nit: add {}

[lshang, 2016/06/20 01:34:22]

Done.

+        continue;

[raymes, 2016/06/16 03:23:50]

Should we also DCHECK that the secondary_pattern is a wildcard pattern? 

[lshang, 2016/06/20 01:34:22]

Done.

+      if (setting_entry.primary_pattern.IsGeneratedFromURLDomainScoped()) {

[raymes, 2016/06/16 03:23:50]

What about using "continue" here (if this evaluates to false) to avoid the
indenting below

[lshang, 2016/06/20 01:34:22]

Done.

+        ContentSettingsPattern origin_pattern =
+            ContentSettingsPattern::FromDomainToOrigin(
+                setting_entry.primary_pattern);
+        GURL origin(origin_pattern.ToString());
+        if (origin.is_valid()) {

[raymes, 2016/06/16 03:23:51]

Same here

[lshang, 2016/06/20 01:34:22]

Done.

+          ContentSetting origin_setting =

[raymes, 2016/06/16 03:23:51]

Maybe say:
// Ensure that the current resolved content setting for this origin is allowed.
Otherwise we may be overriding some narrower setting which is set to block.

[lshang, 2016/06/20 01:34:22]

Done.

+              GetContentSetting(origin, origin, type, std::string());
+
+          // Remove the domiain scoped pattern.

[raymes, 2016/06/16 03:23:50]

// Remove the domain scoped pattern. If |origin_setting| is not
CONTENT_SETTING_ALLOW it implies there is some narrower pattern in effect, so
it's still safe to remove the domain-scoped pattern.

[lshang, 2016/06/20 01:34:22]

Done.

+          SetContentSettingCustomScope(setting_entry.primary_pattern,
+                                       setting_entry.secondary_pattern, type,
+                                       std::string(), CONTENT_SETTING_DEFAULT);
+
+          // If the current setting of narrow-down origin is ALLOW, then add a
+          // new setting entry of this origin.

[raymes, 2016/06/16 03:23:51]

// If the current resolved content setting is allowed it's safe to set the
origin-scoped pattern.

[lshang, 2016/06/20 01:34:22]

Done.

+          if (origin_setting == CONTENT_SETTING_ALLOW)
+            SetContentSettingDefaultScope(origin, GURL(), type, std::string(),
+                                          CONTENT_SETTING_ALLOW);
+        }
+      }
+    }
+  }
+}
+
 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();
 
     ContentSettingsForOneType settings;
     GetSettingsForOneType(content_type, std::string(), &settings);
     size_t num_exceptions = 0;
     for (const ContentSettingPatternSource& setting_entry : settings) {
@@ skipping 137 matching lines @@
                     observers_,
                     OnContentSettingChanged(primary_pattern,
                                             secondary_pattern,
                                             content_type,
                                             resource_identifier));
 }
 
 HostContentSettingsMap::~HostContentSettingsMap() {
   DCHECK(!prefs_);
   STLDeleteValues(&content_settings_providers_);
+  syncable_prefs::PrefModelAssociator::ResetMergeDataFinishedCallback();
 }
 
 void HostContentSettingsMap::ShutdownOnUIThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs_);
   prefs_ = NULL;
   for (ProviderIterator it = content_settings_providers_.begin();
        it != content_settings_providers_.end();
        ++it) {
     it->second->ShutdownOnUIThread();
@@ skipping 179 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>();
 }