Re-implement app overlap detection with new extent syntax.

chrome/common/extensions/url_pattern.h

 // 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.
 #ifndef CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 #define CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_
 
 #include <string>
 
 #include "googleurl/src/gurl.h"
 
@@ skipping 60 matching lines @@
  public:
   // Returns true if the specified scheme can be used in URL patterns, and false
   // otherwise.
   static bool IsValidScheme(const std::string& scheme);
 
   // Convenience to create a pattern from a string.
   static URLPattern* CreateFromString(const std::string& pattern);
 
   URLPattern() : match_subdomains_(false) {}
 
-  // Initializes this instance by parsing the provided string. On failure, the
-  // instance will have some intermediate values and is in an invalid state.
-  bool Parse(const std::string& pattern_str);
-
-  // Returns true if this instance matches the specified URL.
-  bool MatchesUrl(const GURL& url) const;
-
-  std::string GetAsString() const;
-
   // Get the scheme the pattern matches. This will always return a valid scheme
   // if is_valid() returns true.
   std::string scheme() const { return scheme_; }
   void set_scheme(const std::string& scheme) { scheme_ = scheme; }
 
   // Gets the host the pattern matches. This can be an empty string if the
   // pattern matches all hosts (the input was <scheme>://*/<whatever>).
   std::string host() const { return host_; }
   void set_host(const std::string& host) { host_ = host; }
 
   // Gets whether to match subdomains of host().
   bool match_subdomains() const { return match_subdomains_; }
   void set_match_subdomains(bool val) { match_subdomains_ = val; }
 
   // Gets the path the pattern matches with the leading slash. This can have
   // embedded asterisks which are interpreted using glob rules.
   std::string path() const { return path_; }
   void set_path(const std::string& path) {
     path_ = path;
     path_escaped_ = "";
   }
 
+  // Initializes this instance by parsing the provided string. On failure, the
+  // instance will have some intermediate values and is in an invalid state.
+  bool Parse(const std::string& pattern_str);
+
+  // Returns true if this instance matches the specified URL.
+  bool MatchesUrl(const GURL& url) const;
+
+  // Returns a string representing this instance.
+  std::string GetAsString() const;
+
+  // Determine whether there is a URL that would match this instance and another
+  // instance. This method is symmetrical: Calling other.OverlapsWith(this)
+  // would result in the same answer.
+  bool OverlapsWith(const URLPattern& other) const;
+
  private:
   // Returns true if |test| matches our host.
+  bool MatchesHost(const std::string& host) const;
   bool MatchesHost(const GURL& test) const;
 
   // Returns true if |test| matches our path.
-  bool MatchesPath(const GURL& test) const;
+  bool MatchesPath(const std::string& test) const;
 
   // The scheme for the pattern.
   std::string scheme_;
 
   // The host without any leading "*" components.
   std::string host_;
 
   // Whether we should match subdomains of the host. This is true if the first
   // component of the pattern's host was "*".
   bool match_subdomains_;
 
   // The path to match. This is everything after the host of the URL, or
   // everything after the scheme in the case of file:// URLs.
   std::string path_;
 
   // The path with "?" and "\" characters escaped for use with the
   // MatchPatternASCII() function. This is populated lazily, the first time it
   // is needed.
   mutable std::string path_escaped_;
 };
 
 #endif  // CHROME_COMMON_EXTENSIONS_URL_PATTERN_H_