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 85 matching lines @@
   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, make |allow_wildcard_effective_tld| true.
   ParseResult Parse(const std::string& pattern_str);
+  ParseResult Parse(const std::string& pattern_str,
+                    const bool allow_wildcard_effective_tld);

[dcheng, 2017/02/06 07:05:29]

Nit: it's preferable to have explicitly named enum values instead of a bool when
the meaning isn't clear from the method name

[nrpeter, 2017/02/06 22:53:15]

Done.

 
   // 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(const std::string& 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, durring
+  // 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(const std::string& 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 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_