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 allowed when the pattern is parsed with the PARSE_LENIENT

[Sam Kerner (Chrome), 2011/06/27 17:58:25]

The idea of lenient vs. strict parsing made sense when ports were not part of
any valid pattern.  If ports are not an error for some users, a change in
terminology is needed.


Once upon a time, the parser did not throw an error when it saw a port. 
http://foo.com:123/* would be parsed so that the host was "foo.com:123".  People
put ports in patterns, and wondered why they didn't work.  We wanted the parser
to fail on ports, but this would break existing installs.  So we fail on ports
when loading an unpacked extension (strict mode), and tolerate ports when
loading an installed extension (lenient mode).

How about making ParseOption have a way to request that ports are ignored, and
another option to indicate that ports are an error?  Then PARSE_LENIENT,
PARSE_STRICT, and full support for ports could all be expressed.  Something
like:

enum ParseOption {
  FORBID_PORTS = 1<<0,
  ERROR_ON_PORTS = 1<<1;

  PARSE_MANIFEST_PATTERN_LENIENT = FORBID_PORTS,  // Formerly PARSE_LENIENT
  PARSE_MANIFEST_PATTERN_STRICT = FORBID_PORTS & ERROR_ON_PORTS  // Formerly
PARSE_STRICT
};

+//   option. If the |port_allowed| flag is not set, the port will be ignored
+//   regardless.
 // * 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 68 matching lines @@
   // 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_INVALID_PORT,
     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 27 matching lines @@
 
   // Gets the path the pattern matches with the leading slash. This can have
   // embedded asterisks which are interpreted using glob rules.
   const std::string& path() const { return path_; }
   void SetPath(const std::string& path);
 
   // Returns true if this pattern matches all urls.
   bool match_all_urls() const { return match_all_urls_; }
   void set_match_all_urls(bool val) { match_all_urls_ = val; }
 
+  bool ignore_ports() const { return ignore_ports_; }
+  void set_ignore_ports(bool val) { ignore_ports_ = val; }
+
   // Initializes this instance by parsing the provided string. Returns
   // URLPattern::PARSE_SUCCESS on success, or an error code otherwise. On
   // failure, this instance will have some intermediate values and is in an
   // invalid state.  Adding error checks to URLPattern::Parse() can cause
   // patterns in installed extensions to fail.  If an installed extension
   // uses a pattern that was valid but fails a new error check, the
   // extension will fail to load when chrome is auto-updated.  To avoid
   // this, new parse checks are enabled only when |strictness| is
   // OPTION_STRICT.  OPTION_STRICT should be used when loading in developer
   // mode, or when an extension's patterns are controlled by chrome (such
@@ skipping 19 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 |test| matches our port.
+  bool MatchesPort(const std::string& test) 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_;
 
+  // Whether we silently ignore ports when testing for matches or overlaps.
+  bool ignore_ports_;
+
+  // The port. URL patterns only support ports if they are parsed with the
+  // |PARSE_LENIENT| 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_