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

components/content_settings/core/common/content_settings_pattern.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/common/content_settings_pattern.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
@@ skipping 421 matching lines @@
 ContentSettingsPattern ContentSettingsPattern::FromString(
     const std::string& pattern_spec) {
   std::unique_ptr<ContentSettingsPattern::BuilderInterface> builder(
       ContentSettingsPattern::CreateBuilder(false));
   content_settings::PatternParser::Parse(pattern_spec,
                                          builder.get());
   return builder->Build();
 }
 
 // static
+ContentSettingsPattern ContentSettingsPattern::FromDomainToOrigin(
+    const ContentSettingsPattern domain_pattern) {
+  ContentSettingsPattern origin_pattern(domain_pattern);
+
+  if (domain_pattern.parts_.is_scheme_wildcard) {
+    origin_pattern.parts_.scheme = url::kHttpScheme;
+    origin_pattern.parts_.is_scheme_wildcard = false;
+  }
+  if (domain_pattern.parts_.has_domain_wildcard)
+    origin_pattern.parts_.has_domain_wildcard = false;
+  if (domain_pattern.parts_.is_port_wildcard) {
+    origin_pattern.parts_.port = GetDefaultPort(origin_pattern.parts_.scheme);
+    origin_pattern.parts_.is_port_wildcard = false;
+  }
+  return origin_pattern;
+}
+
+// static
 void ContentSettingsPattern::SetNonWildcardDomainNonPortScheme(
     const char* scheme) {
   DCHECK(scheme);
   DCHECK(!non_port_non_domain_wildcard_scheme ||
          non_port_non_domain_wildcard_scheme == scheme);
   non_port_non_domain_wildcard_scheme = scheme;
 }
 
 // static
 bool ContentSettingsPattern::IsNonWildcardDomainNonPortScheme(
@@ skipping 70 matching lines @@
     return false;
   }
 
   return true;
 }
 
 bool ContentSettingsPattern::MatchesAllHosts() const {
   return parts_.has_domain_wildcard && parts_.host.empty();
 }
 
+bool ContentSettingsPattern::IsGeneratedUsingFromURL() const {
+  // Generated patterns must either have a scheme wildcard or be https.
+  if (parts_.scheme != url::kHttpsScheme && !parts_.is_scheme_wildcard)
+    return false;
+
+  // Generated patterns will either have a port wildcard or be https (but not
+  // both).
+  if (parts_.is_port_wildcard && parts_.scheme == url::kHttpsScheme)
+    return false;
+
+  // Generated patterns will always have a domain wildcard.
+  if (!parts_.has_domain_wildcard)
+    return false;
+
+  // Generated patterns will always have a host.
+  if (parts_.host.empty())
+    return false;
+
+  return true;
+}
+
 std::string ContentSettingsPattern::ToString() const {
   if (IsValid())
     return content_settings::PatternParser::ToString(parts_);
   else
     return std::string();
 }
 
 ContentSettingsPattern::Relation ContentSettingsPattern::Compare(
     const ContentSettingsPattern& other) const {
   // Two invalid patterns are identical in the way they behave. They don't match
@@ skipping 195 matching lines @@
   if (!parts.is_path_wildcard && other_parts.is_path_wildcard)
     return ContentSettingsPattern::PREDECESSOR;
 
   int result = parts.path.compare(other_parts.path);
   if (result == 0)
     return ContentSettingsPattern::IDENTITY;
   if (result > 0)
     return ContentSettingsPattern::DISJOINT_ORDER_PRE;
   return ContentSettingsPattern::DISJOINT_ORDER_POST;
 }