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())
+    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) {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes), match_all_urls_(false),
       match_subdomains_(false) {}
@@ skipping 96 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;
+  size_t port_pos = host_.find(':');
+  if (port_pos != std::string::npos) {
+    if (strictness == PARSE_STRICT)
+      return PARSE_ERROR_HAS_COLON;
+
+    if (!SetPort(host_.substr(port_pos + 1)))

[Matt Perry, 2011/06/24 18:53:58]

This does change the behavior slightly. Previously PARSE_LENIENT would just drop
the port. Now it is preserved, and will affect GetAsString(). I'm not sure if
this will break anything. I'd feel safer if we added a separate
"set_allow_ports" switch that only the content settings used.

It's also strange that MatchesURL and OverlapsWith completely ignore the port.
If we're going to allow ports here, it seems like we should have them affect the
functionality (or maybe, they shouldn't affect anything, and remove the changes
to GetAsString).

[Bernhard Bauer, 2011/06/24 21:49:53]

I'd like to keep the changes to GetAsString, so we can return content settings
patterns to an extension later.

One thing we could do would be to use a wildcard for the port when
|set_allow_ports| is not set. This would make the current behavior correct w/r/t
the port, and also remove the port again when serializing the pattern to a
string.

+      return PARSE_ERROR_INVALID_PORT;
+
+    host_ = host_.substr(0, port_pos);
+  }
 
   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;
@@ skipping 68 matching lines @@
 
   if (scheme_ != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
+
+    if (!port_.empty()) {
+      spec += ":";
+      spec += port_;
+    }
   }
 
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
   if (!MatchesAnyScheme(other.GetExplicitSchemes()) &&
@@ skipping 60 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }