Add transparent support for filesystem URLs in URLPatterns.

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 167 matching lines @@
     port_ = port;
     return true;
   }
   return false;
 }
 
 bool URLPattern::MatchesURL(const GURL& test) const {
   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()))

[Aaron Boodman, 2012/05/02 04:04:05]

Perhaps this only makes sense for the filesystem scheme. We don't know what the
security expectations will be about future nested URLs.

Put a check somewhere to disallow other types of nested URLs?

[ericu, 2012/05/02 16:51:16]

That makes sense.  Done.

     return false;
 
   if (match_all_urls_)
     return true;
 
   std::string path_for_request = test.PathForRequest();
   if (has_inner_url)
     path_for_request = test_url->path() + path_for_request;
 
   return MatchesSecurityOriginHelper(*test_url) &&
@@ skipping 121 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 (partial_filesystem_support_hack_ !=
-      other.partial_filesystem_support_hack())
-    return false;
-
   if (!MatchesPath(other.path().substr(0, other.path().size() - 1)) &&
       !other.MatchesPath(path_.substr(0, path_.size() - 1)))
     return false;
 
   return true;
 }
 
 bool URLPattern::MatchesAnyScheme(
     const std::vector<std::string>& schemes) const {
   for (std::vector<std::string>::const_iterator i = schemes.begin();
@@ skipping 46 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }