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 79 matching lines @@
   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),
+      partial_filesystem_support_hack_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
       match_all_urls_(false),
+      partial_filesystem_support_hack_(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),
+      partial_filesystem_support_hack_(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 118 matching lines @@
   match_all_urls_ = val;
 
   if (val) {
     match_subdomains_ = true;
     scheme_ = "*";
     host_.clear();
     SetPath("/*");
   }
 }
 
+void URLPattern::set_partial_filesystem_support_hack(bool val) {

[Aaron Boodman, 2012/03/23 21:48:32]

Pure setters like this are typically in the .h file in Chrome.

[ericu, 2012/03/23 22:47:15]

Done.

+  partial_filesystem_support_hack_ = 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 = test.inner_url() != NULL;
+
+  if (partial_filesystem_support_hack_ != has_inner_url)
+    return false;
+
+  if (has_inner_url)
+    test_url = test.inner_url();
+
+  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)

[Aaron Boodman, 2012/03/23 21:48:32]

I don't understand why the nested_url param is necessary. Callers will
presumably ensure that they have the entire path before calling this, even in
the case of nested URLs.

[ericu, 2012/03/23 22:47:15]

The caller is telling us where he got the path.  If that wasn't from a
filesystem URL and !partial_filesystem_support_hack_, we need to reject it.  I'm
assuming the calling code wouldn't necessarily be the code that created the
pattern, and wouldn't want to deal with these details itself.  Of course, as it
happens, nobody calls this function outside this file at the moment, so we're
free to decide what we please, but this is the best I could come up with short
of making the function private.

[ericu, 2012/03/23 23:48:46]

Param removed.

+    const {
+  if (nested_url != partial_filesystem_support_hack_)
+    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;
 
@@ skipping 51 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 (partial_filesystem_support_hack_ !=
+      other.partial_filesystem_support_hack())
+    return false;
+
+  if (!MatchesPath(other.path().substr(0, other.path().size() - 1),
+          partial_filesystem_support_hack_) &&
+      !other.MatchesPath(path_.substr(0, path_.size() - 1),
+          partial_filesystem_support_hack_))
     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];
 }