Re-implement app overlap detection with new extent syntax.

chrome/common/extensions/url_pattern.cc

 // Copyright (c) 2006-2009 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/scoped_ptr.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
@@ skipping 81 matching lines @@
   return true;
 }
 
 bool URLPattern::MatchesUrl(const GURL &test) const {
   if (test.scheme() != scheme_)
     return false;
 
   if (!MatchesHost(test))
     return false;
 
-  if (!MatchesPath(test))
+  if (!MatchesPath(test.PathForRequest()))
     return false;
 
   return true;
 }
 
+bool URLPattern::MatchesHost(const std::string& host) const {
+  std::string url(chrome::kHttpScheme);
+  url += chrome::kStandardSchemeSeparator;
+  url += host;
+  url += "/";
+
+  return MatchesHost(GURL(url));
+}
+
 bool URLPattern::MatchesHost(const GURL& test) const {
   // If the hosts are exactly equal, we have a match.
   if (test.host() == host_)
     return true;
 
   // If we're matching subdomains, and we have no host in the match pattern,
   // that means that we're matching all hosts, which means we have a match no
   // matter what the test host is.
   if (match_subdomains_ && host_.empty())
     return true;
@@ skipping 11 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 GURL& test) const {
+bool URLPattern::MatchesPath(const std::string& test) const {
   if (path_escaped_.empty()) {
     path_escaped_ = path_;
     ReplaceSubstringsAfterOffset(&path_escaped_, 0, "\\", "\\\\");
     ReplaceSubstringsAfterOffset(&path_escaped_, 0, "?", "\\?");
   }
 
-  if (!MatchPatternASCII(test.PathForRequest(), path_escaped_))
+  if (!MatchPatternASCII(test, path_escaped_))
     return false;
 
   return true;
 }
 
 std::string URLPattern::GetAsString() const {
   std::string spec = scheme_ + chrome::kStandardSchemeSeparator;
 
   if (match_subdomains_) {
     spec += "*";
     if (!host_.empty())
       spec += ".";
   }
 
   if (!host_.empty())
     spec += host_;
 
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }
+
+bool URLPattern::OverlapsWith(const URLPattern& other) const {
+  if (scheme_ != other.scheme())
+    return false;
+
+  if (!MatchesHost(other.host()) && !other.MatchesHost(host_))
+    return false;
+
+  // We currently only use OverlapsWith() for the patterns inside
+  // ExtensionExtent. 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;
+}