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 78 matching lines @@
   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),
+      valid_inner_schemes_(SCHEME_NONE),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
+      valid_inner_schemes_(valid_schemes),
       match_all_urls_(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),
+      valid_inner_schemes_(valid_schemes),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {
   if (PARSE_SUCCESS != Parse(pattern))
     NOTREACHED() << "URLPattern is invalid: " << pattern;
 }
 
 URLPattern::~URLPattern() {
 }
 
@@ skipping 11 matching lines @@
   SetMatchSubdomains(false);
   SetPort("*");
 
   // Special case pattern to match every valid URL.
   if (pattern == kAllUrlsPattern) {
     SetMatchAllURLs(true);
     return PARSE_SUCCESS;
   }
 
   // Parse out the scheme.
-  size_t scheme_end_pos = pattern.find(chrome::kStandardSchemeSeparator);
-  bool has_standard_scheme_separator = true;
+  size_t standard_scheme_end_pos =
+      pattern.find(chrome::kStandardSchemeSeparator);
+  bool has_standard_scheme_separator =
+      (standard_scheme_end_pos != std::string::npos);
 
   // Some urls also use ':' alone as the scheme separator.
-  if (scheme_end_pos == std::string::npos) {
-    scheme_end_pos = pattern.find(':');
-    has_standard_scheme_separator = false;
-  }
+  size_t simple_scheme_end_pos = pattern.find(':');
+  bool has_simple_scheme_separator =
+      (simple_scheme_end_pos != std::string::npos) &&
+      (!has_standard_scheme_separator ||
+       simple_scheme_end_pos < standard_scheme_end_pos);
 
-  if (scheme_end_pos == std::string::npos)
+  size_t scheme_end_pos;

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

Please always initialize primitives. I wish we had a clang plugin for this.

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

So is it true at this point that has_simple_scheme_separator and
has_standard_scheme_separator are exclusive? If so, it would be nice to put a
CHECK to that effect to remind the reader.

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

Done.

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

No.  It used to be true, but now we have "filesystem:http://" which tests
positive for both.  As long as the ':' comes before a '://', it counts.

+
+  if (has_simple_scheme_separator)
+    scheme_end_pos = simple_scheme_end_pos;
+  else if (has_standard_scheme_separator)
+    scheme_end_pos = standard_scheme_end_pos;
+  else
     return PARSE_ERROR_MISSING_SCHEME_SEPARATOR;
 
   if (!SetScheme(pattern.substr(0, scheme_end_pos)))

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

Would it be simpler to restructure parsing the scheme bit like this (in
psuedo-code):

scheme_separator_start = input.find(':');
scheme_separator_end = scheme_separator_start + 1;
if (input.length > (scheme_separator_start + 2) &&
    input[scheme_separator_start + 1] == '/' &&
    input[scheme_separator_start + 2] == '/')) {
  scheme_separator_end = scheme_separator_start + 3;
}

scheme = input.substr(0, scheme_separator_start);
scheme_separator = input.substr(scheme_separator_start, scheme_separator_end);

< validate legit scheme/separator combinations >

< if outer scheme is filesystem, parse inner scheme >

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

Thanks for the suggestion; I think it's a lot clearer now.  Some of the
complexity got in there when I was trying to keep supporting CrOS's
"filesystem:*" wildcards here, instead of converting them off in extension-land
before calling in.

     return PARSE_ERROR_INVALID_SCHEME;
 
+  if (!has_simple_scheme_separator && has_standard_scheme_separator &&

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

This method is getting pretty hairy. Is it possible to break it up into parts?

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

Do you still think it's necessary after the rewrite?

+      scheme_ == chrome::kFileSystemScheme)
+    return PARSE_ERROR_WRONG_SCHEME_SEPARATOR;
+
+  if (has_simple_scheme_separator && has_standard_scheme_separator) {
+    if (scheme_ != chrome::kFileSystemScheme)
+      return PARSE_ERROR_WRONG_SCHEME_SEPARATOR;
+    if (!SetInnerScheme(
+        pattern.substr(simple_scheme_end_pos + 1,
+            standard_scheme_end_pos - simple_scheme_end_pos - 1)))
+      return PARSE_ERROR_INVALID_SCHEME;
+    scheme_end_pos = standard_scheme_end_pos;
+  }
+
   bool standard_scheme = IsStandardScheme(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);
+      (has_standard_scheme_separator ?
+          strlen(chrome::kStandardSchemeSeparator) : 1);
   if (scheme_end_pos >= pattern.size())
     return PARSE_ERROR_EMPTY_HOST;
 
   // Parse out the host and path.
   size_t host_start_pos = scheme_end_pos;
   size_t path_start_pos = 0;
 
   if (!standard_scheme) {
     path_start_pos = host_start_pos;
   } else if (scheme_ == chrome::kFileScheme) {
     size_t host_end_pos = pattern.find(kPathSeparator, host_start_pos);
     if (host_end_pos == std::string::npos) {
       // Allow hostname omission.
       // e.g. file://* is interpreted as file:///*,
       // file://foo* is interpreted as file:///foo*.
       path_start_pos = host_start_pos - 1;
     } else {
       // Ignore hostname if scheme is file://.
       // e.g. file://localhost/foo is equal to file:///foo.
       path_start_pos = host_end_pos;
     }
+  } else if (scheme_ == chrome::kFileSystemScheme &&
+      inner_scheme_ == chrome::kFileScheme) {
+    // We can't distinguish between a host and a storage type in a
+    // filesystem:file URL, so just let it be part of the path.
+    path_start_pos = host_start_pos;
   } else {
     size_t host_end_pos = pattern.find(kPathSeparator, host_start_pos);
 
     // Host is required.
     if (host_start_pos == host_end_pos)
       return PARSE_ERROR_EMPTY_HOST;
 
     if (host_end_pos == std::string::npos)
       return PARSE_ERROR_EMPTY_PATH;
 
@@ skipping 26 matching lines @@
   // think '*' works as a glob in the host.
   if (host_.find('*') != std::string::npos)
     return PARSE_ERROR_INVALID_HOST_WILDCARD;
 
   return PARSE_SUCCESS;
 }
 
 void URLPattern::SetValidSchemes(int valid_schemes) {
   spec_.clear();
   valid_schemes_ = valid_schemes;
+  valid_inner_schemes_ = valid_schemes;
+}
+
+void URLPattern::SetValidInnerSchemes(int valid_schemes) {
+  spec_.clear();
+  valid_inner_schemes_ = valid_schemes;
 }
 
 void URLPattern::SetHost(const std::string& host) {
   spec_.clear();
   host_ = host;
 }
 
 void URLPattern::SetMatchAllURLs(bool val) {
   spec_.clear();
   match_all_urls_ = val;
 
   if (val) {
     match_subdomains_ = true;
     scheme_ = "*";
     host_.clear();
     SetPath("/*");
   }
 }
 
 void URLPattern::SetMatchSubdomains(bool val) {
   spec_.clear();
   match_subdomains_ = val;
 }
 
 bool URLPattern::SetScheme(const std::string& scheme) {
   spec_.clear();
-  scheme_ = scheme;
-  if (scheme_ == "*") {
+  inner_scheme_.clear();
+  if (scheme == "*") {
     valid_schemes_ &= (SCHEME_HTTP | SCHEME_HTTPS);
-  } else if (!IsValidScheme(scheme_)) {
+  } else if (!IsValidScheme(scheme)) {
     return false;
   }
+  scheme_ = scheme;
   return true;
 }
 
+bool URLPattern::SetInnerScheme(const std::string& scheme) {

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

It would be more clear to name this param "inner_scheme".

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

Done.

+  spec_.clear();
+  DCHECK(scheme_ == chrome::kFileSystemScheme);
+  if (scheme == "*") {
+    valid_inner_schemes_ = SCHEME_HTTP | SCHEME_HTTPS | SCHEME_FTP |

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

This looks weird. In your travels, did you come to understand why SetScheme()
modifies valid_schemes_?

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

It only does so if you're putting in a wildcard.  The comment in the header says
"The '*' scheme pattern excludes file URLs.".  The code for SetScheme also rules
out ftp; I wasn't sure if that was a bug, but it disagrees with the comments.  I
left FTP in, but they should probably match.  Which way should we go?

+        SCHEME_EXTENSION;  // Exclude file: and chrome:.
+  } else if (!IsValidInnerScheme(scheme)) {
+    return false;
+  }
+  inner_scheme_ = scheme;
+  return true;
+}
+
 bool URLPattern::IsValidScheme(const std::string& scheme) const {
   if (valid_schemes_ == SCHEME_ALL)
     return true;
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (scheme == kValidSchemes[i] && (valid_schemes_ & kValidSchemeMasks[i]))
       return true;
   }
 
   return false;
 }
 
+bool URLPattern::IsValidInnerScheme(const std::string& scheme) const {
+  // kFileSystemScheme is never a valid inner scheme, even if using SCHEME_ALL.
+  if (scheme == chrome::kFileSystemScheme)
+    return false;
+
+  if (valid_inner_schemes_ == SCHEME_ALL)
+    return true;
+
+  for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
+    if (scheme == kValidSchemes[i] &&
+        (valid_inner_schemes_ & kValidSchemeMasks[i]))
+      return true;
+  }
+
+  return false;
+}
+
 void URLPattern::SetPath(const std::string& path) {
   spec_.clear();
   path_ = path;
   path_escaped_ = path_;
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "\\", "\\\\");
   ReplaceSubstringsAfterOffset(&path_escaped_, 0, "?", "\\?");
 }
 
 bool URLPattern::SetPort(const std::string& port) {
   spec_.clear();
-  if (IsValidPortForScheme(scheme_, port)) {
+  std::string scheme = scheme_;

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

More clear to use a ternary operator here?

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

Done.

+  if (scheme == chrome::kFileSystemScheme)
+    scheme = inner_scheme_;
+  if (IsValidPortForScheme(scheme, port)) {
     port_ = port;
     return true;
   }
   return false;
 }
 
 bool URLPattern::MatchesURL(const GURL& test) const {
   if (!MatchesScheme(test.scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
-  return MatchesSecurityOriginHelper(test) &&
-         MatchesPath(test.PathForRequest());
+  DCHECK(!test.SchemeIsFileSystem() || test.inner_url());
+  if (scheme_ == chrome::kFileSystemScheme &&
+      (!test.SchemeIsFileSystem() ||
+       !MatchesInnerScheme(test.inner_url()->scheme())))
+    return false;
+
+  std::string path = test.PathForRequest();
+
+  // Filesystem URLs have the first path segment on the inner_url.
+  if (test.SchemeIsFileSystem())
+    path = test.inner_url()->path() + path;
+
+  return MatchesSecurityOriginHelper(test) && MatchesPath(path);
 }
 
 bool URLPattern::MatchesSecurityOrigin(const GURL& test) const {
   if (!MatchesScheme(test.scheme()))
     return false;
 
   if (match_all_urls_)
     return true;
 
   return MatchesSecurityOriginHelper(test);
 }
 
 bool URLPattern::MatchesScheme(const std::string& test) const {
   if (!IsValidScheme(test))
     return false;
 
   return scheme_ == "*" || test == scheme_;
 }
 
+bool URLPattern::MatchesInnerScheme(const std::string& test) const {
+  DCHECK(scheme_ == chrome::kFileSystemScheme);
+  if (!IsValidInnerScheme(test))
+    return false;
+
+  return inner_scheme_ == "*" || test == inner_scheme_;
+}
+
 bool URLPattern::MatchesHost(const std::string& host) const {
   std::string test(chrome::kHttpScheme);
   test += chrome::kStandardSchemeSeparator;
   test += host;
   test += "/";
   return MatchesHost(GURL(test));
 }
 
 bool URLPattern::MatchesHost(const GURL& test) const {
   // If the hosts are exactly equal, we have a match.
@@ skipping 45 matching lines @@
   if (!spec_.empty())
     return spec_;
 
   if (match_all_urls_) {
     spec_ = kAllUrlsPattern;
     return spec_;
   }
 
   bool standard_scheme = IsStandardScheme(scheme_);
 
-  std::string spec = scheme_ +
-      (standard_scheme ? chrome::kStandardSchemeSeparator : ":");
+  std::string spec = scheme_;
+  std::string scheme = scheme_;
+  bool add_standard_separator = standard_scheme;
+  if (scheme_ == chrome::kFileSystemScheme) {
+    spec += ":" + inner_scheme_;
+    add_standard_separator = true;
+    standard_scheme = IsStandardScheme(inner_scheme_);
+    scheme = inner_scheme_;
+  }
+  spec += (add_standard_separator ? chrome::kStandardSchemeSeparator : ":");
 
-  if (scheme_ != chrome::kFileScheme && standard_scheme) {
+  if (scheme != chrome::kFileScheme && standard_scheme) {
     if (match_subdomains_) {
       spec += "*";
       if (!host_.empty())
         spec += ".";
     }
 
     if (!host_.empty())
       spec += host_;
 
     if (port_ != "*") {
@@ skipping 41 matching lines @@
   for (std::vector<std::string>::const_iterator i = schemes.begin();
        i != schemes.end(); ++i) {
     if (MatchesScheme(*i))
       return true;
   }
 
   return false;
 }
 
 bool URLPattern::MatchesSecurityOriginHelper(const GURL& test) const {
-  // Ignore hostname if scheme is file://.
-  if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
+  // Ignore hostname if scheme is file:// or filesystem:file://.
+  std::string scheme = scheme_;
+  const GURL* test_url = &test;
+  if (scheme == chrome::kFileSystemScheme) {
+    scheme = inner_scheme_;
+    test_url = test.inner_url();
+    DCHECK(test_url);
+  }
+  if (scheme != chrome::kFileScheme && !MatchesHost(*test_url))
     return false;
 
-  if (!MatchesPort(test.EffectiveIntPort()))
+  if (!MatchesPort(test_url->EffectiveIntPort()))
     return false;
 
   return true;
 }
 
 std::vector<std::string> URLPattern::GetExplicitSchemes() const {
   std::vector<std::string> result;
 
   if (scheme_ != "*" && !match_all_urls_ && IsValidScheme(scheme_)) {
     result.push_back(scheme_);
@@ skipping 22 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }