Add full support for filesystem URLs.

chrome/common/extensions/url_pattern.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #define CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #pragma once
 
 #include <functional>
 #include <string>
 #include <vector>
 
@@ skipping 100 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 SetMatchAllURLs(bool val);
 
+  // Returns true if this pattern matches nested URL paths.
+  // If false, a path match other than '*' will always fail on a nested URL.
+  // If true, a path match other than '*' will always fail on a non-nested URL.

[Aaron Boodman, 2012/03/21 23:51:57]

Can we do something even more specific, just for the one place we need
filesystem support?

How about something like:

set_enable_partial_filesystem_scheme_support()

This would allow <pattern> to match filesystem:<url-that-would-match-<pattern>>,
but only when <pattern> has * for the path component.

This way when we fix the one place that uses this feature, we can easily remove
the support from URLPattern.

[ericu, 2012/03/22 00:22:14]

My goal was actually to support filesystem URLs transparently where it would
make sense.  So if e.g. a userscript should have access to all pages at
www.google.com, the pattern would also just work for pages that that site
creates in the filesystem.  It's only when the pattern is supposed to match
specific files that I want you to have to set a flag, since a specific path on
the server is clearly different than the same path in the filesystem.  The flag
just forces you to tell me whether it's a local path or a server path.

+  bool match_nested_url_path() const { return match_nested_url_path_; }
+  void SetMatchNestedURLPath(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);
   // Note: You should use MatchesScheme() instead of this getter unless you
   // absolutely need the exact scheme. This is exposed for testing.
   const std::string& scheme() const { return 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 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 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;
+  // Set nested_url to true if the test URL had an inner_url().
+  // See SetMatchNestedURLPath for behavior.
+  bool MatchesPath(const std::string& test, bool nested_url) 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.
   const std::string& GetAsString() const;
@@ skipping 38 matching lines @@
 
   // 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_;
 
   // True if this is a special-case "<all_urls>" pattern.
   bool match_all_urls_;
 
+  // True if we match path_ against the full path of a nested URL, e.g.
+  // if given filesystem:http://a.com/temporary/foo.txt, use /temporary/foo.txt.
+  // Otherwise we match only against the path of a non-nested URL.
+  bool match_nested_url_path_;
+
   // 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.
   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_