Support requesting subsets of host permissions using the permissions API.

extensions/common/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 "extensions/common/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 75 matching lines @@
       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);
 }
 
+// Returns |path| with the trailing wildcard stripped if one existed.
+//
+// The functions that rely on this (OverlapsWith and Contains) are only
+// called 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.
+std::string StripTrailingWildcard(const std::string& path) {
+  size_t wildcard_index = path.find('*');
+  size_t path_last = path.size() - 1;
+  DCHECK(wildcard_index == std::string::npos || wildcard_index == path_last);
+  return wildcard_index == path_last ? path.substr(0, path_last) : path;
+}
+
 }  // namespace
 
 URLPattern::URLPattern()
     : valid_schemes_(SCHEME_NONE),
       match_all_urls_(false),
       match_subdomains_(false),
       port_("*") {}
 
 URLPattern::URLPattern(int valid_schemes)
     : valid_schemes_(valid_schemes),
@@ skipping 278 matching lines @@
   return test.host()[test.host().length() - host_.length() - 1] == '.';
 }
 
 bool URLPattern::MatchesPath(const std::string& test) const {
   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_);
@@ skipping 18 matching lines @@
   }
 
   if (!path_.empty())
     spec += path_;
 
   spec_ = spec;
   return spec_;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
-  if (!MatchesAnyScheme(other.GetExplicitSchemes()) &&
-      !other.MatchesAnyScheme(GetExplicitSchemes())) {
-    return false;
-  }
+  if (match_all_urls() || other.match_all_urls())
+    return true;
+  return (MatchesAnyScheme(other.GetExplicitSchemes()) ||
+          other.MatchesAnyScheme(GetExplicitSchemes()))
+      && (MatchesHost(other.host()) || other.MatchesHost(host()))
+      && (MatchesPortPattern(other.port()) || other.MatchesPortPattern(port()))
+      && (MatchesPath(StripTrailingWildcard(other.path())) ||
+          other.MatchesPath(StripTrailingWildcard(path())));
+}
 
-  if (!MatchesHost(other.host()) && !other.MatchesHost(host_))
-    return false;
-
-  if (port_ != "*" && other.port() != "*" && port_ != other.port())
-    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)))
-    return false;
-
-  return true;
+bool URLPattern::Contains(const URLPattern& other) const {
+  if (match_all_urls())
+    return true;
+  return MatchesAllSchemes(other.GetExplicitSchemes())
+      && MatchesHost(other.host())
+      && MatchesPortPattern(other.port())
+      && MatchesPath(StripTrailingWildcard(other.path()));
 }
 
 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))
       return true;
   }
 
   return false;
 }
 
+bool URLPattern::MatchesAllSchemes(
+    const std::vector<std::string>& schemes) const {
+  for (std::vector<std::string>::const_iterator i = schemes.begin();
+       i != schemes.end(); ++i) {
+    if (!MatchesScheme(*i))
+      return false;
+  }
+
+  return true;
+}
+
 bool URLPattern::MatchesSecurityOriginHelper(const GURL& test) const {
   // Ignore hostname if scheme is file://.
   if (scheme_ != chrome::kFileScheme && !MatchesHost(test))
     return false;
 
-  if (!MatchesPort(test.EffectiveIntPort()))
+  if (!MatchesPortPattern(base::IntToString(test.EffectiveIntPort())))
     return false;
 
   return true;
 }
 
+bool URLPattern::MatchesPortPattern(const std::string& port) const {
+  return port_ == "*" || port_ == port;
+}
+
 std::vector<std::string> URLPattern::GetExplicitSchemes() const {
   std::vector<std::string> result;
 
   if (scheme_ != "*" && !match_all_urls_ && IsValidScheme(scheme_)) {
     result.push_back(scheme_);
     return result;
   }
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (MatchesScheme(kValidSchemes[i])) {
@@ skipping 17 matching lines @@
   }
 
   return result;
 }
 
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }