Use extension match pattern syntax in content settings extension API

chrome/common/extensions/url_pattern.cc

 // Copyright (c) 2011 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 "chrome/common/extensions/url_pattern.h"
 
+#include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "googleurl/src/url_util.h"
 
 const char URLPattern::kAllUrlsPattern[] = "<all_urls>";
 
 namespace {
@@ skipping 24 matching lines @@
 
 const char* kParseSuccess = "Success.";
 const char* kParseErrorMissingSchemeSeparator = "Missing scheme separator.";
 const char* kParseErrorInvalidScheme = "Invalid scheme.";
 const char* kParseErrorWrongSchemeType = "Wrong scheme type.";
 const char* kParseErrorEmptyHost = "Host can not be empty.";
 const char* kParseErrorInvalidHostWildcard = "Invalid host wildcard.";
 const char* kParseErrorEmptyPath = "Empty path.";
 const char* kParseErrorHasColon =
     "Ports are not supported in URL patterns. ':' may not be used in a host.";
+const char* kParseErrorInvalidPort =
+    "Invalid port.";
 
 // Message explaining each URLPattern::ParseResult.
 const char* kParseResultMessages[] = {
   kParseSuccess,
   kParseErrorMissingSchemeSeparator,
   kParseErrorInvalidScheme,
   kParseErrorWrongSchemeType,
   kParseErrorEmptyHost,
   kParseErrorInvalidHostWildcard,
   kParseErrorEmptyPath,
-  kParseErrorHasColon
+  kParseErrorHasColon,
+  kParseErrorInvalidPort,
 };
 
 COMPILE_ASSERT(URLPattern::NUM_PARSE_RESULTS == arraysize(kParseResultMessages),
                must_add_message_for_each_parse_result);
 
 const char kPathSeparator[] = "/";
 
 bool IsStandardScheme(const std::string& scheme) {
   // "*" gets the same treatment as a standard scheme.
   if (scheme == "*")
     return true;
 
   return url_util::IsStandard(scheme.c_str(),
       url_parse::Component(0, static_cast<int>(scheme.length())));
 }
 
+bool IsValidPort(const std::string& port) {
+  if (port.empty() || port == "*")
+    return true;
+  int parsed_port;
+  if (!base::StringToInt(port, &parsed_port))
+    return false;
+  return (parsed_port >= 0) && (parsed_port < 65536);
+}
+
 }  // namespace
 
 URLPattern::URLPattern()
     : valid_schemes_(SCHEME_NONE),
       match_all_urls_(false),
-      match_subdomains_(false) {}
+      match_subdomains_(false),
+      ignore_ports_(true) {}
 
 URLPattern::URLPattern(int valid_schemes)
-    : valid_schemes_(valid_schemes), match_all_urls_(false),
-      match_subdomains_(false) {}
+    : valid_schemes_(valid_schemes),
+      match_all_urls_(false),
+      match_subdomains_(false),
+      ignore_ports_(true) {}
 
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
-    : valid_schemes_(valid_schemes), match_all_urls_(false),
-      match_subdomains_(false) {
+    : valid_schemes_(valid_schemes),
+      match_all_urls_(false),
+      match_subdomains_(false),
+      ignore_ports_(true) {
 
   // Strict error checking is used, because this constructor is only
   // appropriate when we know |pattern| is valid.
   if (PARSE_SUCCESS != Parse(pattern, PARSE_STRICT))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
@@ skipping 82 matching lines @@
     // done as a convenience to developers who might otherwise be confused and
     // think '*' works as a glob in the host.
     if (host_.find('*') != std::string::npos)
       return PARSE_ERROR_INVALID_HOST_WILDCARD;
 
     path_start_pos = host_end_pos;
   }
 
   SetPath(pattern.substr(path_start_pos));
 
-  if (strictness == PARSE_STRICT && host_.find(':') != std::string::npos)
-    return PARSE_ERROR_HAS_COLON;
+  std::string port = "*";
+  size_t port_pos = host_.find(':');
+  if (port_pos != std::string::npos) {
+    if (strictness == PARSE_STRICT)
+      return PARSE_ERROR_HAS_COLON;
+
+    if (!ignore_ports_)
+      port = host_.substr(port_pos + 1);
+
+    host_ = host_.substr(0, port_pos);
+  }
+  if (!SetPort(port))
+    return PARSE_ERROR_INVALID_PORT;
 
   return PARSE_SUCCESS;
 }
 
 bool URLPattern::SetScheme(const std::string& scheme) {
   scheme_ = scheme;
   if (scheme_ == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
   } else if (!IsValidScheme(scheme_)) {
     return false;
@@ skipping 13 matching lines @@
   return false;
 }
 
 void URLPattern::SetPath(const std::string& path) {
   path_ = path;
   path_escaped_ = path_;
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "\\", "\\\\");
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "?", "\\?");
 }
 
+bool URLPattern::SetPort(const std::string& port) {
+  if (IsValidPort(port)) {
+    port_ = port;
+    return true;
+  }
+  return false;
+}
+
 bool URLPattern::MatchesURL(const GURL &test) const {
   if (!MatchesScheme(test.scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
   // Ignore hostname if scheme is file://.
   if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
     return false;
 
   if (!MatchesPath(test.PathForRequest()))
     return false;
 
+  if (!MatchesPort(test.port()))
+    return false;
+
   return true;
 }
 
 bool URLPattern::MatchesScheme(const std::string& test) const {
   if (!IsValidScheme(test))
     return false;
 
   return scheme_ == "*" || test == scheme_;
 }
 
@@ skipping 36 matching lines @@
   return test.host()[test.host().length() - host_.length() - 1] == '.';
 }
 
 bool URLPattern::MatchesPath(const std::string& test) const {
   if (!MatchPattern(test, path_escaped_))
     return false;
 
   return true;
 }
 
+bool URLPattern::MatchesPort(const std::string& test) const {
+  if (!IsValidPort(test))
+    return false;
+
+  return port_ == "*" || port_ == test;
+}
+
 std::string URLPattern::GetAsString() const {
   if (match_all_urls_)
     return kAllUrlsPattern;
 
   bool standard_scheme = IsStandardScheme(scheme_);
 
   std::string spec = scheme_ +
       (standard_scheme ? chrome::kStandardSchemeSeparator : ":");
 
   if (scheme_ != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
+
+    if (!ignore_ports_ && !port_.empty()) {
+      spec += ":";
+      spec += port_;
+    }
   }
 
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
   if (!MatchesAnyScheme(other.GetExplicitSchemes()) &&
       !other.MatchesAnyScheme(GetExplicitSchemes())) {
     return false;
   }
 
   if (!MatchesHost(other.host()) && !other.MatchesHost(host_))
     return false;
 
+  if (port_ != "*" && other.port() != "*" && port_ != other.port())
+    return false;
+
   // We currently only use OverlapsWith() 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.
   DCHECK(path_.find('*') == path_.size() - 1);
   DCHECK(other.path().find('*') == other.path().size() - 1);
 
   if (!MatchesPath(other.path().substr(0, other.path().size() - 1)) &&
       !other.MatchesPath(path_.substr(0, path_.size() - 1)))
@@ skipping 43 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }