Communicate ExtensionSettings policy to renderers

extensions/common/url_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 "extensions/common/url_pattern.h"
 
 #include <stddef.h>
 
 #include <ostream>
 
@@ skipping 125 matching lines @@
   int result = 0;
   for (size_t i = 0; i < arraysize(kValidSchemeMasks); ++i)
     result |= kValidSchemeMasks[i];
   return result;
 }
 
 URLPattern::URLPattern()
     : valid_schemes_(SCHEME_NONE),
       match_all_urls_(false),
       match_subdomains_(false),
+      match_effective_tld_(true),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
+      match_effective_tld_(true),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
     // Strict error checking is used, because this constructor is only
     // appropriate when we know |pattern| is valid.
     : valid_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
+      match_effective_tld_(true),
       port_("*") {
   ParseResult result = Parse(pattern);
   if (PARSE_SUCCESS != result)
     NOTREACHED() << "URLPattern invalid: " << pattern << " result " << result;
 }
 
 URLPattern::URLPattern(const URLPattern& other) = default;
 
 URLPattern::~URLPattern() {
 }
 
 bool URLPattern::operator<(const URLPattern& other) const {
   return GetAsString() < other.GetAsString();
 }
 
 bool URLPattern::operator>(const URLPattern& other) const {
   return GetAsString() > other.GetAsString();
 }
 
 bool URLPattern::operator==(const URLPattern& other) const {
   return GetAsString() == other.GetAsString();
 }
 
 std::ostream& operator<<(std::ostream& out, const URLPattern& url_pattern) {
   return out << '"' << url_pattern.GetAsString() << '"';
 }
 
-URLPattern::ParseResult URLPattern::Parse(const std::string& pattern) {
+URLPattern::ParseResult URLPattern::Parse(
+    const std::string& pattern,
+    const bool allow_wildcard_effective_tld) {
   spec_.clear();
   SetMatchAllURLs(false);
   SetMatchSubdomains(false);
+  SetMatchEffectiveTld(true);
   SetPort("*");
 
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     SetMatchAllURLs(true);
     return PARSE_SUCCESS;
   }
 
   // Parse out the scheme.
   size_t scheme_end_pos = pattern.find(url::kStandardSchemeSeparator);
@@ skipping 58 matching lines @@
     // Could be empty if the host only consists of whitespace characters.
     if (host_components.empty() ||
         (host_components.size() == 1 && host_components[0].empty()))
       return PARSE_ERROR_EMPTY_HOST;
 
     if (host_components[0] == "*") {
       match_subdomains_ = true;
       host_components.erase(host_components.begin(),
                             host_components.begin() + 1);
     }
+
+    // If explicitly allowed, the last component can optionally be '*' to
+    // match all effective TLDs.
+    if (allow_wildcard_effective_tld && host_components.size() > 1 &&
+        host_components[1] == "*") {
+      match_effective_tld_ = false;
+      host_components.pop_back();
+    }
     host_ = base::JoinString(host_components, ".");
 
     path_start_pos = host_end_pos;
   }
 
   SetPath(pattern.substr(path_start_pos));
 
   size_t port_pos = host_.find(':');
   if (port_pos != std::string::npos) {
     if (!SetPort(host_.substr(port_pos + 1)))
@@ skipping 34 matching lines @@
     host_.clear();
     SetPath("/*");
   }
 }
 
 void URLPattern::SetMatchSubdomains(bool val) {
   spec_.clear();
   match_subdomains_ = val;
 }
 
+void URLPattern::SetMatchEffectiveTld(bool val) {
+  spec_.clear();
+  match_effective_tld_ = val;
+}
+
 bool URLPattern::SetScheme(const std::string& scheme) {
   spec_.clear();
   scheme_ = scheme;
   if (scheme_ == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
   } else if (!IsValidScheme(scheme_)) {
     return false;
   }
   return true;
 }
@@ skipping 79 matching lines @@
 
 bool URLPattern::MatchesHost(const std::string& host) const {
   std::string test(url::kHttpScheme);
   test += url::kStandardSchemeSeparator;
   test += host;
   test += "/";
   return MatchesHost(GURL(test));
 }
 
 bool URLPattern::MatchesHost(const GURL& test) const {
-  const base::StringPiece test_host(
-      CanonicalizeHostForMatching(test.host_piece()));
+  base::StringPiece test_host(CanonicalizeHostForMatching(test.host_piece()));
   const base::StringPiece pattern_host(CanonicalizeHostForMatching(host_));
 
+  // If we don't care about matching the effective TLD, remove it.
+  if (!match_effective_tld_) {
+    int reg_length = net::registry_controlled_domains::GetRegistryLength(
+        test, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
+        net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
+    if (reg_length > 0) {
+      test_host = test_host.substr(0, test_host.size() - reg_length - 1);
+    }
+  }
+
   // If the hosts are exactly equal, we have a match.
   if (test_host == pattern_host)
     return true;
 
   // If we're matching subdomains, and we have no host in the match pattern,
   // that means that we're matching all hosts, which means we have a match no
   // matter what the test host is.
   if (match_subdomains_ && pattern_host.empty())
     return true;
 
@@ skipping 79 matching lines @@
   if (scheme_ != url::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
 
+    if (!match_effective_tld_) {
+      if (!host_.empty())
+        spec += ".";
+      spec += "*";
+    }
+
     if (port_ != "*") {
       spec += ":";
       spec += port_;
     }
   }
 
   if (!path_.empty())
     spec += path_;
 
   spec_ = spec;
@@ skipping 88 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }