Use extension match pattern syntax in content settings extension API

chrome/common/extensions/url_pattern.h

 // 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.
 #ifndef CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #define CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #pragma once
 
 #include <functional>
 #include <string>
 #include <vector>
 
 class GURL;
 
 // A pattern that can be used to match URLs. A URLPattern is a very restricted
 // subset of URL syntax:
 //
-// <url-pattern> := <scheme>://<host><path> | '<all_urls>'
+// <url-pattern> := <scheme>://<host><port><path> | '<all_urls>'
 // <scheme> := '*' | 'http' | 'https' | 'file' | 'ftp' | 'chrome'
 // <host> := '*' | '*.' <anychar except '/' and '*'>+
+// <port> := [':' ('*' | <port number between 0 and 65535>)]
 // <path> := '/' <any chars>
 //
 // * Host is not used when the scheme is 'file'.
+// * The port is only used if the pattern is parsed with the USE_PORTS option.
+//   If the patterns is parsed with the ERROR_ON_PORTS option, the port is not
+//   allowed, and the resulting pattern matches any port. If it is parsed with
+//   the IGNORE_PORTS option, the port (including colon) is kept as part of the
+//   host, which makes the pattern effectively never match any URL.

[Sam Kerner (Chrome), 2011/06/30 02:36:52]

Please point out that this seemingly silly behavior is needed because some users
have to maintain backward compatibility with the behavior patters used to have
before ports were parsed.

 // * The path can have embedded '*' characters which act as glob wildcards.
 // * '<all_urls>' is a special pattern that matches any URL that contains a
 //   valid scheme (as specified by valid_schemes_).
 // * The '*' scheme pattern excludes file URLs.
 //
 // Examples of valid patterns:
 // - http://*/*
 // - http://*/foo*
 // - https://*.google.com/foo*bar
 // - file://monkey*
@@ skipping 54 matching lines @@
     // SCHEME_ALL will match every scheme, including chrome://, chrome-
     // extension://, about:, etc. Because this has lots of security
     // implications, third-party extensions should never be able to get access
     // to URL patterns initialized this way. It should only be used for internal
     // Chrome code.
     SCHEME_ALL      = -1,
   };
 
   // Options for URLPattern::Parse().
   enum ParseOption {
-    PARSE_LENIENT,
-    PARSE_STRICT
+    ERROR_ON_PORTS,
+    IGNORE_PORTS,
+    USE_PORTS,
   };
 
   // Error codes returned from Parse().
   enum ParseResult {
     PARSE_SUCCESS = 0,
     PARSE_ERROR_MISSING_SCHEME_SEPARATOR,
     PARSE_ERROR_INVALID_SCHEME,
     PARSE_ERROR_WRONG_SCHEME_SEPARATOR,
     PARSE_ERROR_EMPTY_HOST,
     PARSE_ERROR_INVALID_HOST_WILDCARD,
     PARSE_ERROR_EMPTY_PATH,
-    PARSE_ERROR_HAS_COLON,  // Only checked when strict checks are enabled.
+    PARSE_ERROR_HAS_COLON,     // Only checked when parsing with ERROR_ON_PORTS.
+    PARSE_ERROR_INVALID_PORT,  // Only checked when parsing with USE_PORTS.
     NUM_PARSE_RESULTS
   };
 
   // The <all_urls> string pattern.
   static const char kAllUrlsPattern[];
 
   // Construct an URLPattern with the given set of allowable schemes. See
   // valid_schemes_ for more info.
   explicit URLPattern(int valid_schemes);
 
@@ skipping 66 matching lines @@
   // Returns true if |test| matches our scheme.
   bool MatchesScheme(const std::string& test) const;
 
   // Returns true if |test| matches our host.
   bool MatchesHost(const std::string& test) const;
   bool MatchesHost(const GURL& test) const;
 
   // Returns true if |test| matches our path.
   bool MatchesPath(const std::string& test) const;
 
+  // Returns true if |port| matches our port.
+  bool MatchesPort(int port) const;
+
+  // Sets the port. Returns false if the port is invalid.
+  bool SetPort(const std::string& port);
+  const std::string& port() const { return port_; }
+
   // Returns a string representing this instance.
   std::string GetAsString() const;
 
   // Determine whether there is a URL that would match this instance and another
   // instance. This method is symmetrical: Calling other.OverlapsWith(this)
   // would result in the same answer.
   bool OverlapsWith(const URLPattern& other) const;
 
   // Convert this URLPattern into an equivalent set of URLPatterns that don't
   // use a wildcard in the scheme component. If this URLPattern doesn't use a
@@ skipping 46 matching lines @@
   // The scheme for the pattern.
   std::string scheme_;
 
   // The host without any leading "*" components.
   std::string host_;
 
   // Whether we should match subdomains of the host. This is true if the first
   // component of the pattern's host was "*".
   bool match_subdomains_;
 
+  // The port. URL patterns only support specific ports if they are parsed with
+  // the |USE_PORTS| option.
+  std::string port_;
+
   // The path to match. This is everything after the host of the URL, or
   // everything after the scheme in the case of file:// URLs.
   std::string path_;
 
   // The path with "?" and "\" characters escaped for use with the
   // MatchPattern() function.
   std::string path_escaped_;
 };
 
 typedef std::vector<URLPattern> URLPatternList;
 
 #endif  // CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_