Add full support for filesystem URLs.

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>
@@ skipping 81 matching lines @@
   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.
   ParseResult Parse(const std::string& pattern_str);
 
   // Gets the bitmask of valid schemes.
   int valid_schemes() const { return valid_schemes_; }
+  // Sets the bitmask of valid schemes and inner_schemes.

[Aaron Boodman, 2012/02/15 21:31:18]

Please put an empty line before each of these comments.

   void SetValidSchemes(int valid_schemes);
+  // Gets the bitmask of valid inner schemes.
+  int valid_inner_schemes() const { return valid_inner_schemes_; }
+  // Sets the bitmask of valid inner_schemes.
+  void SetValidInnerSchemes(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 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
   // pattern matches all valid schemes (as defined by the valid_schemes_
   // property). Returns false on failure (if the scheme is not valid).
   bool SetScheme(const std::string& scheme);
+  // Sets the inner scheme for pattern matches; this can only be used for
+  // patterns whose scheme has already been set to "filesystem". This can be a

[Aaron Boodman, 2012/02/15 21:31:18]

Why make this restriction? It seems easier to just ignore it if the outer scheme
doesn't support nested schemes.

[ericu, 2012/02/16 01:42:56]

If you're doing something that's obviously wrong, I'd much rather be able to
DCHECK so that you find out about it.

+  // single '*' if the pattern matches all valid schemes (as defined by the
+  // valid_inner_schemes_ property). Returns false on failure (if the scheme is
+  // not valid).
+  bool SetInnerScheme(const std::string& scheme);
   // Note: You should use MatchesScheme() instead of this getter unless you

[Aaron Boodman, 2012/02/15 21:31:18]

In retrospect, these warnings are overly scary. Maybe something like:

Returns the scheme component of the pattern. Note that it is usually better to
call MatchesScheme(), since that will also handle the case where the scheme
component is a wildcard.

[ericu, 2012/02/22 00:00:51]

Done.

   // absolutely need the exact scheme. This is exposed for testing.
   const std::string& scheme() const { return scheme_; }
+  // Note: You should use MatchesInnerScheme() instead of this getter unless you
+  // absolutely need the exact scheme. This is exposed for testing.
+  const std::string& inner_scheme() const { return inner_scheme_; }
 
   // Returns true if the specified scheme can be used in this URL pattern, and
   // false otherwise. Uses valid_schemes_ to determine validity.
   bool IsValidScheme(const std::string& scheme) const;
 
+  // Returns true if the specified scheme can be used in this URL pattern, and

[Aaron Boodman, 2012/02/15 21:31:18]

.replace("specified scheme", "specified inner scheme");

[ericu, 2012/02/22 00:00:51]

Done.

+  // false otherwise. Uses valid_inner_schemes_ to determine validity.
+  bool IsValidInnerScheme(const std::string& scheme) const;
+
   // Returns true if this instance matches the specified URL.
   bool MatchesURL(const GURL& test) const;
 
   // Returns true if this instance matches the specified security origin.
   bool MatchesSecurityOrigin(const GURL& test) const;
 
   // Returns true if |test| matches our scheme.
   bool MatchesScheme(const std::string& test) const;
 
+  // Returns true if |test| matches our inner scheme.
+  // Only use this if scheme is "filesystem".
+  bool MatchesInnerScheme(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;
 
@@ skipping 40 matching lines @@
 
   // If the URLPattern contains a wildcard scheme, returns a list of
   // equivalent literal schemes, otherwise returns the current scheme.
   std::vector<std::string> GetExplicitSchemes() const;
 
   // A bitmask containing the schemes which are considered valid for this
   // pattern. Parse() uses this to decide whether a pattern contains a valid
   // scheme. MatchesScheme uses this to decide whether a wildcard scheme_
   // matches a given test scheme.
   int valid_schemes_;
+  // A bitmask containing the inner schemes which are considered valid for this

[Aaron Boodman, 2012/02/15 21:31:18]

.insertBefore("\n");

[ericu, 2012/02/22 00:00:51]

Done.

+  // pattern. Parse() uses this to decide whether a pattern contains a valid
+  // scheme. MatchesInnerScheme uses this to decide whether a wildcard
+  // inner_scheme_ matches a given test scheme.
+  int valid_inner_schemes_;
 
   // True if this is a special-case "<all_urls>" pattern.
   bool match_all_urls_;
 
   // The scheme for the pattern.
   std::string scheme_;
 
+  // The inner scheme for the pattern, used only when scheme_ is "filesystem".
+  std::string inner_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.
   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_;
 };
 
 typedef std::vector<URLPattern> URLPatternList;
 
 #endif  // CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_