Make URLPattern::OverlapsWith handle wildcards better by expanding them to explicit schemes.

chrome/common/extensions/url_pattern.cc

 // Copyright (c) 2011 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_piece.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
@@ skipping 293 matching lines @@
       spec += host_;
   }
 
   if (!path_.empty())
     spec += path_;
 
   return spec;
 }
 
 bool URLPattern::OverlapsWith(const URLPattern& other) const {
-  if (!MatchesScheme(other.scheme_) && !other.MatchesScheme(scheme_))
+  if (!MatchesAnyScheme(other.GetExplicitSchemes()) &&
+      !other.MatchesAnyScheme(GetExplicitSchemes())) {
     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;
 }
 
-std::vector<URLPattern> URLPattern::ConvertToExplicitSchemes() const {
-  std::vector<URLPattern> result;
+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;
+}
+
+std::vector<std::string> URLPattern::GetExplicitSchemes() const {
+  std::vector<std::string> result;
 
   if (scheme_ != "*" && !match_all_urls_ && IsValidScheme(scheme_)) {
-    result.push_back(*this);
+    result.push_back(scheme_);
     return result;
   }
 
   for (size_t i = 0; i < arraysize(kValidSchemes); ++i) {
     if (MatchesScheme(kValidSchemes[i])) {
-      URLPattern temp = *this;
-      temp.SetScheme(kValidSchemes[i]);
-      temp.set_match_all_urls(false);
-      result.push_back(temp);
+      result.push_back(kValidSchemes[i]);
     }
   }
 
   return result;
 }
 
+std::vector<URLPattern> URLPattern::ConvertToExplicitSchemes() const {
+  std::vector<std::string> explicit_schemes = GetExplicitSchemes();
+  std::vector<URLPattern> result;
+
+  for (std::vector<std::string>::const_iterator i = explicit_schemes.begin();
+       i != explicit_schemes.end(); ++i) {
+    URLPattern temp = *this;
+    temp.SetScheme(*i);
+    temp.set_match_all_urls(false);
+    result.push_back(temp);
+  }
+
+  return result;
+}
+
 // static
 const char* URLPattern::GetParseResultString(
     URLPattern::ParseResult parse_result) {
   return kParseResultMessages[parse_result];
 }