Reland: Communicate ExtensionSettings policy to renderers

extensions/common/url_pattern.h

 // 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.
 #ifndef EXTENSIONS_COMMON_URL_PATTERN_H_
 #define EXTENSIONS_COMMON_URL_PATTERN_H_
 
 #include <functional>
 #include <iosfwd>
 #include <string>
 #include <vector>
@@ skipping 63 matching lines @@
     PARSE_ERROR_INVALID_SCHEME,
     PARSE_ERROR_WRONG_SCHEME_SEPARATOR,
     PARSE_ERROR_EMPTY_HOST,
     PARSE_ERROR_INVALID_HOST_WILDCARD,
     PARSE_ERROR_EMPTY_PATH,
     PARSE_ERROR_INVALID_PORT,
     PARSE_ERROR_INVALID_HOST,
     NUM_PARSE_RESULTS
   };
 
+  // Types of URLPattern that Parse() considers valid.
+  enum ParseOptions {
+    DENY_WILDCARD_FOR_EFFECTIVE_TLD,
+    ALLOW_WILDCARD_FOR_EFFECTIVE_TLD,
+  };
+
   // The <all_urls> string pattern.
   static const char kAllUrlsPattern[];
 
   // Returns true if the given |scheme| is considered valid for extensions.
   static bool IsValidSchemeForExtensions(base::StringPiece scheme);
 
   // Returns the mask for all schemes considered valid for extensions.
   static int GetValidSchemeMaskForExtensions();
 
   explicit URLPattern(int valid_schemes);
 
   // Convenience to construct a URLPattern from a string. If the string is not
   // known ahead of time, use Parse() instead, which returns success or failure.
   URLPattern(int valid_schemes, base::StringPiece pattern);
 
   URLPattern();
   URLPattern(const URLPattern& other);
   ~URLPattern();
 
   bool operator<(const URLPattern& other) const;
   bool operator>(const URLPattern& other) const;
   bool operator==(const URLPattern& other) const;
 
   // 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.
+  // invalid state. If you want to allow the match pattern to specify a wildcard
+  // for the effective TLD, specify in |parse_options|.
   ParseResult Parse(base::StringPiece pattern_str);
+  ParseResult Parse(base::StringPiece pattern_str, ParseOptions parse_options);
 
   // Gets the bitmask of valid schemes.
   int valid_schemes() const { return valid_schemes_; }
   void SetValidSchemes(int valid_schemes);
 
   // Gets the host the pattern matches. This can be an empty string if the
   // pattern matches all hosts (the input was <scheme>://*/<whatever>).
   const std::string& host() const { return host_; }
   void SetHost(base::StringPiece host);
 
   // Gets whether to match subdomains of host().
   bool match_subdomains() const { return match_subdomains_; }
   void SetMatchSubdomains(bool val);
 
+  // Gets whether host() contains an effective TLD. If false, during
+  // a match, the URL you're comparing must have its TLD removed
+  // prior to comparison.
+  // e.g. For the match pattern https://google.com/*
+  //      If this is true: host() would be google.com
+  //      If this is false: host() would be google
+  bool match_effective_tld() const { return match_effective_tld_; }
+  void SetMatchEffectiveTld(bool val);
+
   // 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(base::StringPiece path);
 
   // Returns true if this pattern matches all urls.
   bool match_all_urls() const { return match_all_urls_; }
   void SetMatchAllURLs(bool val);
 
   // Sets the scheme for pattern matches. This can be a single '*' if the
@@ skipping 104 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 should match the effective TLD of the host. This is true by
+  // default and only false if ParseOptions is ALLOW_WILDCARD_FOR_EFFECTIVE_TLD
+  // and is only applicable when the the pattern's host ends with ".*"
+  // (e.g. https://example.*/*).
+  bool match_effective_tld_;
+
   // The port.
   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_;
 
   // A string representing this URLPattern.
   mutable std::string spec_;
 };
 
 std::ostream& operator<<(std::ostream& out, const URLPattern& url_pattern);
 
 typedef std::vector<URLPattern> URLPatternList;
 
 #endif  // EXTENSIONS_COMMON_URL_PATTERN_H_