Add full support for filesystem URLs.

chrome/common/extensions/url_pattern.cc

 // 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.
 
 #include "chrome/common/extensions/url_pattern.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 49 matching lines @@
   kParseErrorInvalidHostWildcard,
   kParseErrorEmptyPath,
   kParseErrorInvalidPort,
 };
 
 COMPILE_ASSERT(URLPattern::NUM_PARSE_RESULTS == arraysize(kParseResultMessages),
                must_add_message_for_each_parse_result);
 
 const char kPathSeparator[] = "/";
 
-bool IsStandardScheme(const std::string& scheme) {
+bool is_standard_scheme(const std::string& scheme) {

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

Why rename this? I think the current capitalization is correct given that this
is a nontrivial amount of work.

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

You requested this change in your comments on patch set 40 ;'>.

Reverted.

   // "*" gets the same treatment as a standard scheme.
   if (scheme == "*")
     return true;
 
   return url_util::IsStandard(scheme.c_str(),
       url_parse::Component(0, static_cast<int>(scheme.length())));
 }
 
 bool IsValidPortForScheme(const std::string scheme, const std::string& port) {
   if (port == "*")
     return true;
 
   // Only accept non-wildcard ports if the scheme uses ports.
   if (url_canon::DefaultPortForScheme(scheme.c_str(), scheme.length()) ==
       url_parse::PORT_UNSPECIFIED) {
     return false;
   }
 
   int parsed_port = url_parse::PORT_UNSPECIFIED;
   if (!base::StringToInt(port, &parsed_port))
     return false;
   return (parsed_port >= 0) && (parsed_port < 65536);
 }
 
 }  // namespace
 
 URLPattern::URLPattern()
     : valid_schemes_(SCHEME_NONE),
       match_all_urls_(false),
+      match_nested_url_path_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
       match_all_urls_(false),
+      match_nested_url_path_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes, const std::string& pattern)
     // Strict error checking is used, because this constructor is only
     // appropriate when we know |pattern| is valid.
     : valid_schemes_(valid_schemes),
       match_all_urls_(false),
+      match_nested_url_path_(false),
       match_subdomains_(false),
       port_("*") {
   if (PARSE_SUCCESS != Parse(pattern))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
 bool URLPattern::operator<(const URLPattern& other) const {
@@ skipping 25 matching lines @@
     scheme_end_pos = pattern.find(':');
     has_standard_scheme_separator = false;
   }
 
   if (scheme_end_pos == std::string::npos)
     return PARSE_ERROR_MISSING_SCHEME_SEPARATOR;
 
   if (!SetScheme(pattern.substr(0, scheme_end_pos)))
     return PARSE_ERROR_INVALID_SCHEME;
 
-  bool standard_scheme = IsStandardScheme(scheme_);
+  bool standard_scheme = is_standard_scheme(scheme_);
   if (standard_scheme != has_standard_scheme_separator)
     return PARSE_ERROR_WRONG_SCHEME_SEPARATOR;
 
   // Advance past the scheme separator.
   scheme_end_pos +=
       (standard_scheme ? strlen(chrome::kStandardSchemeSeparator) : 1);
   if (scheme_end_pos >= pattern.size())
     return PARSE_ERROR_EMPTY_HOST;
 
   // Parse out the host and path.
@@ skipping 72 matching lines @@
   match_all_urls_ = val;
 
   if (val) {
     match_subdomains_ = true;
     scheme_ = "*";
     host_.clear();
     SetPath("/*");
   }
 }
 
+void URLPattern::SetMatchNestedURLPath(bool val) {

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

This one on the other hand should be set_match_nested_url_path() :-).

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

Done.

+  match_nested_url_path_ = val;
+}
+
 void URLPattern::SetMatchSubdomains(bool val) {
   spec_.clear();
   match_subdomains_ = val;
 }
 
 bool URLPattern::SetScheme(const std::string& scheme) {
   spec_.clear();
   scheme_ = scheme;
   if (scheme_ == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
@@ skipping 26 matching lines @@
 bool URLPattern::SetPort(const std::string& port) {
   spec_.clear();
   if (IsValidPortForScheme(scheme_, port)) {
     port_ = port;
     return true;
   }
   return false;
 }
 
 bool URLPattern::MatchesURL(const GURL& test) const {
-  if (!MatchesScheme(test.scheme()))
+  const GURL* test_url = &test;
+  bool has_inner_url = false;
+  if (test.inner_url()) {
+    test_url = test.inner_url();
+    has_inner_url = true;
+  }
+
+  if (!MatchesScheme(test_url->scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
-  return MatchesSecurityOriginHelper(test) &&
-         MatchesPath(test.PathForRequest());
+  std::string path_for_request = test.PathForRequest();
+  if (has_inner_url) {
+    path_for_request = test_url->path() + path_for_request;
+  }
+  return MatchesSecurityOriginHelper(*test_url) &&
+         MatchesPath(path_for_request, has_inner_url);
 }
 
 bool URLPattern::MatchesSecurityOrigin(const GURL& test) const {
   if (!MatchesScheme(test.scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
   return MatchesSecurityOriginHelper(test);
@@ skipping 38 matching lines @@
   if (test.host().length() <= (host_.length() + 1))
     return false;
 
   if (test.host().compare(test.host().length() - host_.length(),
                           host_.length(), host_) != 0)
     return false;
 
   return test.host()[test.host().length() - host_.length() - 1] == '.';
 }
 
-bool URLPattern::MatchesPath(const std::string& test) const {
+bool URLPattern::MatchesPath(const std::string& test, bool nested_url)
+    const {
+  if (nested_url != match_nested_url_path_ && path_ != "/*")
+    return false;
   if (!MatchPattern(test, path_escaped_))
     return false;
 
   return true;
 }
 
 bool URLPattern::MatchesPort(int port) const {
   if (port == url_parse::PORT_INVALID)
     return false;
 
   return port_ == "*" || port_ == base::IntToString(port);
 }
 
 
 const std::string& URLPattern::GetAsString() const {
   if (!spec_.empty())
     return spec_;
 
   if (match_all_urls_) {
     spec_ = kAllUrlsPattern;
     return spec_;
   }
 
-  bool standard_scheme = IsStandardScheme(scheme_);
+  bool standard_scheme = is_standard_scheme(scheme_);
 
   std::string spec = scheme_ +
       (standard_scheme ? chrome::kStandardSchemeSeparator : ":");
 
   if (scheme_ != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
@@ skipping 27 matching lines @@
     return false;
 
   // We currently only use OverlapsWith() for the patterns inside
   // URLPatternSet. In those cases, we know that the path will have only a
   // single wildcard at the end. This makes figuring out overlap much easier. It
   // seems like there is probably a computer-sciency way to solve the general
   // case, but we don't need that yet.
   DCHECK(path_.find('*') == path_.size() - 1);
   DCHECK(other.path().find('*') == other.path().size() - 1);
 
-  if (!MatchesPath(other.path().substr(0, other.path().size() - 1)) &&
-      !other.MatchesPath(path_.substr(0, path_.size() - 1)))
+  if ((path_.size() > 2 || other.path().size() > 2) &&
+      match_nested_url_path_ != other.match_nested_url_path())
+    return false;
+
+  if (!MatchesPath(other.path().substr(0, other.path().size() - 1),
+          match_nested_url_path_) &&
+      !other.MatchesPath(path_.substr(0, path_.size() - 1),
+          match_nested_url_path_))
     return false;
 
   return true;
 }
 
 bool URLPattern::MatchesAnyScheme(
     const std::vector<std::string>& schemes) const {
   for (std::vector<std::string>::const_iterator i = schemes.begin();
        i != schemes.end(); ++i) {
     if (MatchesScheme(*i))
@@ skipping 44 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }