Register a pref to control migration status

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 40 matching lines @@
 
 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},
 };
 
+// Enum describing the status of domain to origin migration of content settings.
+// Migration will be done twice: once upon construction of the
+// HostContentSettingsMap (before syncing any content settings) and once after
+// sync has finished. We always migrate before sync to ensure that settings will
+// get migrated even if a user doesn't have sync enabled. We migrate after sync
+// to ensure that any sync'd settings will be migrated. Once these events have
+// occurred, we won't perform migration again.
+enum DomainToOriginMigrationStatus {
+  // Haven't been migrated at all.
+  NOT_MIGRATED,
+  // Have done migration in the constructor of HostContentSettingsMap.
+  MIGRATED_BEFORE_SYNC,
+  // Have done migration both in HostContentSettingsMap construction and sync

[raymes, 2016/07/25 03:56:38]

nit: and after sync is finished. No migration will happen after this point.

[lshang, 2016/07/25 04:51:09]

Done.

+  // process(this is a clean up after sync). Migration is all finished at this
+  // stage.
+  MIGRATED_AFTER_SYNC,
+};
+
 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 105 matching lines @@
   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);
+  registry->RegisterIntegerPref(prefs::kDomainToOriginMigrationStatus,
+                                DomainToOriginMigrationStatus::NOT_MIGRATED);
 
   // Register the prefs for the content settings providers.
   content_settings::DefaultProvider::RegisterProfilePrefs(registry);
   content_settings::PrefProvider::RegisterProfilePrefs(registry);
   content_settings::PolicyProvider::RegisterProfilePrefs(registry);
 }
 
 void HostContentSettingsMap::RegisterProvider(
     ProviderType type,
     std::unique_ptr<content_settings::ObservableProvider> provider) {
@@ skipping 294 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() {
+void HostContentSettingsMap::MigrateDomainScopedSettings(bool after_sync) {
+  int status = prefs_->GetInteger(prefs::kDomainToOriginMigrationStatus);
+  if (status == MIGRATED_AFTER_SYNC)
+    return;
+  if (status == MIGRATED_BEFORE_SYNC && !after_sync)
+    return;
+  DCHECK(status != NOT_MIGRATED || !after_sync);
+
   const ContentSettingsType kDomainScopedTypes[] = {
       CONTENT_SETTINGS_TYPE_COOKIES,
       CONTENT_SETTINGS_TYPE_IMAGES,
       CONTENT_SETTINGS_TYPE_PLUGINS,
       CONTENT_SETTINGS_TYPE_JAVASCRIPT,
       CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
       CONTENT_SETTINGS_TYPE_POPUPS};
   for (const ContentSettingsType& type : kDomainScopedTypes) {
     if (!content_settings::ContentSettingsRegistry::GetInstance()->Get(type))
       continue;
@@ skipping 44 matching lines @@
 
       // If the current resolved content setting is allowed it's safe to set the
       // origin-scoped pattern.
       if (origin_setting == CONTENT_SETTING_ALLOW)
         SetContentSettingCustomScope(
             ContentSettingsPattern::FromURLNoWildcard(origin),
             ContentSettingsPattern::Wildcard(), type, std::string(),
             CONTENT_SETTING_ALLOW);
     }
   }
+
+  if (status == NOT_MIGRATED) {
+    prefs_->SetInteger(prefs::kDomainToOriginMigrationStatus,
+                       DomainToOriginMigrationStatus::MIGRATED_BEFORE_SYNC);

[raymes, 2016/07/25 03:56:38]

nit: no need for the DomainToOriginMigrationStatus prefix

[lshang, 2016/07/25 04:51:09]

Done.

+  } else if (status == MIGRATED_BEFORE_SYNC) {
+    prefs_->SetInteger(prefs::kDomainToOriginMigrationStatus,
+                       DomainToOriginMigrationStatus::MIGRATED_AFTER_SYNC);
+  }
 }
 
 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);
@@ skipping 338 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>();
 }