Add implicit trailing dot domain matching support to URLPattern.

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>
 
 #include "base/macros.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
+#include "net/base/url_util.h"
 #include "url/gurl.h"
 #include "url/url_util.h"
 
 const char URLPattern::kAllUrlsPattern[] = "<all_urls>";
 
 namespace {
 
 // TODO(aa): What about more obscure schemes like data: and javascript: ?
 // Note: keep this array in sync with kValidSchemeMasks.
 const char* const kValidSchemes[] = {
@@ skipping 75 matching lines @@
 // called for the patterns inside URLPatternSet. In those cases, we know that
 // the path will have only a single wildcard at the end. This makes figuring
 // out overlap much easier. It seems like there is probably a computer-sciency
 // way to solve the general case, but we don't need that yet.
 std::string StripTrailingWildcard(const std::string& path) {
   size_t wildcard_index = path.find('*');
   size_t path_last = path.size() - 1;
   return wildcard_index == path_last ? path.substr(0, path_last) : path;
 }
 
+bool EndsWithDot(base::StringPiece str) {
+  return base::EndsWith(str, ".", base::CompareCase::SENSITIVE);
+}
+
 }  // namespace
 
 // static
 bool URLPattern::IsValidSchemeForExtensions(const std::string& scheme) {
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (scheme == kValidSchemes[i])
       return true;
   }
   return false;
 }
@@ skipping 271 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 std::string test_host(CanonicalizeHostForMatching(test));

[Devlin, 2016/10/28 19:17:27]

This code is called under some pretty performance-sensitive times (e.g. web
request matching, etc).  We need to do a pretty big overhaul to make it all
faster, but I wonder if we can at least avoid a string copy here.  Could we
instead use a StringPiece test_host and StringPiece pattern_host that both have
the trailing dot (if any) removed, and thus avoid the copies?

+
   // If the hosts are exactly equal, we have a match.
-  if (test.host() == host_)
+  if (test_host == 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_ && host_.empty())
     return true;
 
   // Otherwise, we can only match if our match pattern matches subdomains.
   if (!match_subdomains_)
     return false;
 
   // We don't do subdomain matching against IP addresses, so we can give up now
   // if the test host is an IP address.
   if (test.HostIsIPAddress())
     return false;
 
   // Check if the test host is a subdomain of our host.
-  if (test.host().length() <= (host_.length() + 1))
+  if (test_host.length() <= (host_.length() + 1))
     return false;
 
-  if (test.host().compare(test.host().length() - host_.length(),
-                          host_.length(), host_) != 0)
+  if (test_host.compare(test_host.length() - host_.length(), host_.length(),
+                        host_) != 0)
     return false;
 
-  return test.host()[test.host().length() - host_.length() - 1] == '.';
+  return test_host[test_host.length() - host_.length() - 1] == '.';
 }
 
 bool URLPattern::ImpliesAllHosts() const {
   // Check if it matches all urls or is a pattern like http://*/*.
   if (match_all_urls_ ||
       (match_subdomains_ && host_.empty() && port_ == "*" && path_ == "/*")) {
     return true;
   }
 
   // If this doesn't even match subdomains, it can't possibly imply all hosts.
@@ skipping 155 matching lines @@
        i != explicit_schemes.end(); ++i) {
     URLPattern temp = *this;
     temp.SetScheme(*i);
     temp.SetMatchAllURLs(false);
     result.push_back(temp);
   }
 
   return result;
 }
 
+std::string URLPattern::CanonicalizeHostForMatching(const GURL& url) const {
+  std::string url_host = url.host();
+  if (url_host.empty() || url.HostIsIPAddress())
+    return url_host;
+
+  const bool pattern_host_ends_with_dot = EndsWithDot(host_);
+  const bool url_host_ends_with_dot = EndsWithDot(url_host);
+  if (pattern_host_ends_with_dot != url_host_ends_with_dot) {
+    if (url_host_ends_with_dot)
+      url_host = net::TrimEndingDot(url_host);
+    else
+      url_host += ".";
+  }
+
+  return url_host;
+}
+
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }