Let url filter test the scheme in urlContains/Equals/Prefix/Suffix criteria

chrome/common/extensions/matcher/url_matcher.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/matcher/url_matcher.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
+#include "content/public/common/url_constants.h"
 #include "googleurl/src/gurl.h"
+#include "googleurl/src/url_canon.h"
 
 namespace extensions {
 
 // This set of classes implement a mapping of URL Component Patterns, such as
 // host_prefix, host_suffix, host_equals, ..., etc., to SubstringPatterns.
 //
 // The idea of this mapping is to reduce the problem of comparing many
 // URL Component Patterns against one URL to the problem of searching many
 // substrings in one string:
 //
@@ skipping 59 matching lines @@
 // -> host_equals("www.example.com") = BU .www.example.com ED
 //
 // Similarly for path query parameters ({path, query}_{prefix, suffix, equals}).
 //
 // With this, we can search the SubstringPatterns in the normalized URL.
 //
 //
 // Case 2: url_{prefix,suffix,equals,contains} searches.
 // =====================================================
 //
-// Step 1: as above
+// Step 1: as above, except that
+// - the scheme is not removed
+// - the port is not removed if it is specified and does not match the default
+//   port for the given scheme.
 //
 // Step 2:
 // Translate URL to String and add the following position markers:
 // - BU = Beginning of URL
 // - EU = End of URL
-// Furthermore, the hostname is canonicalized to start with a ".".
 //
-// -> www.example.com/index.html?search=foo becomes
-// BU .www.example.com/index.html?search=foo EU
+// -> http://www.example.com:8080/index.html?search=foo#first_match becomes
+// BU http://www.example.com:8080/index.html?search=foo EU
+// -> http://www.example.com:80/index.html?search=foo#first_match becomes
+// BU http://www.example.com/index.html?search=foo EU
 //
-// url_prefix(prefix) = BU add_missing_dot_prefix(prefix)
-// -> url_prefix("www.example") = BU .www.example
+// url_prefix(prefix) = BU prefix
+// -> url_prefix("http://www.example") = BU http://www.example
 //
 // url_contains(substring) = substring
 // -> url_contains("index") = index
 //
 //
 // Case 3: {host,path,query}_contains searches.
 // ============================================
 //
 // These kinds of searches are not supported directly but can be derived
 // by a combination of a url_contains() query followed by an explicit test:
 //
 // host_contains(str) = url_contains(str) followed by test whether str occurs
-//   in host comonent of original URL.
+//   in host component of original URL.
 // -> host_contains("example.co") = example.co
 //    followed by gurl.host().find("example.co");
 //
 // [similarly for path_contains and query_contains].
 
 
 //
 // URLMatcherCondition
 //
 
@@ skipping 26 matching lines @@
   if (substring_pattern_ != NULL && rhs.substring_pattern_ != NULL)
     return *substring_pattern_ < *rhs.substring_pattern_;
   if (substring_pattern_ == NULL && rhs.substring_pattern_ != NULL) return true;
   // Either substring_pattern_ != NULL && rhs.substring_pattern_ == NULL,
   // or both are NULL.
   return false;
 }
 
 bool URLMatcherCondition::IsFullURLCondition() const {
   // For these criteria the SubstringMatcher needs to be executed on the
-  // GURL that is canonlizaliced with
+  // GURL that is canonicalized with
   // URLMatcherConditionFactory::CanonicalizeURLForFullSearches.
   switch (criterion_) {
     case HOST_CONTAINS:
     case PATH_CONTAINS:
     case QUERY_CONTAINS:
     case URL_PREFIX:
     case URL_SUFFIX:
     case URL_CONTAINS:
     case URL_EQUALS:
       return true;
@@ skipping 133 matching lines @@
 URLMatcherConditionFactory::CreateHostEqualsPathPrefixCondition(
     const std::string& host,
     const std::string& path_prefix) {
   return CreateCondition(URLMatcherCondition::HOST_EQUALS_PATH_PREFIX,
       kBeginningOfURL + CanonicalizeHostname(host) + kEndOfDomain +
       path_prefix);
 }
 
 std::string URLMatcherConditionFactory::CanonicalizeURLForFullSearches(
     const GURL& url) {
-  return kBeginningOfURL + CanonicalizeHostname(url.host()) + url.path() +
-      (url.has_query() ? "?" + url.query() : "") + kEndOfURL;
+  GURL::Replacements replacements;
+  replacements.ClearPassword();
+  replacements.ClearUsername();
+  replacements.ClearRef();
+  // Clear port if it is implicit from scheme.
+  if (url.has_port()) {
+    const std::string& port = url.scheme();
+    if (url_canon::DefaultPortForScheme(port.c_str(), port.size()) ==
+            url.EffectiveIntPort()) {
+      replacements.ClearPort();
+    }
+  }
+  return kBeginningOfURL + url.ReplaceComponents(replacements).spec() +
+      kEndOfURL;
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateURLPrefixCondition(
     const std::string& prefix) {
   return CreateCondition(URLMatcherCondition::URL_PREFIX,
-      kBeginningOfURL + CanonicalizeHostname(prefix));
+      kBeginningOfURL + prefix);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateURLSuffixCondition(
     const std::string& suffix) {
   return CreateCondition(URLMatcherCondition::URL_SUFFIX, suffix + kEndOfURL);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateURLContainsCondition(
     const std::string& str) {
   return CreateCondition(URLMatcherCondition::URL_CONTAINS, str);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateURLEqualsCondition(
     const std::string& str) {
   return CreateCondition(URLMatcherCondition::URL_EQUALS,
-      kBeginningOfURL + CanonicalizeHostname(str) + kEndOfURL);
+      kBeginningOfURL + str + kEndOfURL);
 }
 
 void URLMatcherConditionFactory::ForgetUnusedPatterns(
       const std::set<SubstringPattern::ID>& used_patterns) {
   PatternSingletons::iterator i = pattern_singletons_.begin();
   while (i != pattern_singletons_.end()) {
     if (used_patterns.find((*i)->id()) != used_patterns.end()) {
       ++i;
     } else {
       delete *i;
@@ skipping 328 matching lines @@
 }
 
 void URLMatcher::UpdateInternalDatastructures() {
   UpdateSubstringSetMatcher(false);
   UpdateSubstringSetMatcher(true);
   UpdateTriggers();
   UpdateConditionFactory();
 }
 
 }  // namespace extensions