Add support for matching query parameters in URLMatcher

components/url_matcher/url_matcher.cc

 // Copyright 2013 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 "components/url_matcher/url_matcher.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 178 matching lines @@
   return false;
 }
 
 bool URLMatcherCondition::IsFullURLCondition() const {
   // For these criteria the SubstringMatcher needs to be executed on the
   // 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;
     default:
       break;
   }
   return false;
 }
 
 bool URLMatcherCondition::IsRegexCondition() const {
   return IsRegexCriterion(criterion_);
 }
 
 bool URLMatcherCondition::IsOriginAndPathRegexCondition() const {
   return IsOriginAndPathRegexCriterion(criterion_);
 }
 
 bool URLMatcherCondition::IsMatch(
     const std::set<StringPattern::ID>& matching_patterns,
     const GURL& url) const {
   DCHECK(string_pattern_);
   if (!ContainsKey(matching_patterns, string_pattern_->id()))
     return false;
-  // The criteria HOST_CONTAINS, PATH_CONTAINS, QUERY_CONTAINS are based on
-  // a substring match on the raw URL. In case of a match, we need to verify
-  // that the match was found in the correct component of the URL.
+  // The criteria HOST_CONTAINS, PATH_CONTAINS are based on a substring match on
+  // the raw URL. In case of a match, we need to verify that the match was found
+  // in the correct component of the URL.
   switch (criterion_) {
     case HOST_CONTAINS:
       return url.host().find(string_pattern_->pattern()) !=
           std::string::npos;
     case PATH_CONTAINS:
       return url.path().find(string_pattern_->pattern()) !=
           std::string::npos;
-    case QUERY_CONTAINS:
-      return url.query().find(string_pattern_->pattern()) !=
-          std::string::npos;
     default:
       break;
   }
   return true;
 }
 
 //
 // URLMatcherConditionFactory
 //
 
 namespace {
 // These are symbols that are not contained in 7-bit ASCII used in GURLs.
 const char kBeginningOfURL[] = {static_cast<char>(-1), 0};
 const char kEndOfDomain[] = {static_cast<char>(-2), 0};
 const char kEndOfPath[] = {static_cast<char>(-3), 0};
-const char kEndOfURL[] = {static_cast<char>(-4), 0};
+const char kBeginningOfQueryComponent[] = {static_cast<char>(-4), 0};
+const char kEndOfURL[] = {static_cast<char>(-5), 0};
+const char kQuerySeperator = '&';
+
+// This function prepares the query string by replacing query separator with a
+// magic value (|kBeginningOfQueryComponent|). When the boolean
+// |prepend_beginning_of_query_component| is true the function prepends the
+// query with the same magic. This is done to locate the start of a key value
+// pair in the query string. The parameter |query| is passed by value
+// intentionally, since it is locally modified.
+std::string PrepareQuery(std::string query,
+                         bool prepend_beginning_of_query_component) {
+  for (std::string::iterator it = query.begin(); it != query.end(); ++it) {
+    if (*it == kQuerySeperator)
+      *it = kBeginningOfQueryComponent[0];
+  }
+  return prepend_beginning_of_query_component
+             ? kBeginningOfQueryComponent + query
+             : query;
+}
 }  // namespace
 
 URLMatcherConditionFactory::URLMatcherConditionFactory() : id_counter_(0) {}
 
 URLMatcherConditionFactory::~URLMatcherConditionFactory() {
   STLDeleteElements(&substring_pattern_singletons_);
   STLDeleteElements(&regex_pattern_singletons_);
   STLDeleteElements(&origin_and_path_regex_pattern_singletons_);
 }
 
 std::string URLMatcherConditionFactory::CanonicalizeURLForComponentSearches(
     const GURL& url) const {
   return kBeginningOfURL + CanonicalizeHostname(url.host()) + kEndOfDomain +
          url.path() + kEndOfPath +
-         (url.has_query() ? "?" + url.query() : std::string()) + kEndOfURL;
+         (url.has_query() ? PrepareQuery(url.query(), true) : std::string()) +
+         kEndOfURL;
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateHostPrefixCondition(
     const std::string& prefix) {
   return CreateCondition(URLMatcherCondition::HOST_PREFIX,
       kBeginningOfURL + CanonicalizeHostname(prefix));
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateHostSuffixCondition(
     const std::string& suffix) {
@@ skipping 31 matching lines @@
 URLMatcherCondition URLMatcherConditionFactory::CreatePathEqualsCondition(
     const std::string& str) {
   return CreateCondition(URLMatcherCondition::PATH_EQUALS,
       kEndOfDomain + str + kEndOfPath);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateQueryPrefixCondition(
     const std::string& prefix) {
   std::string pattern;
   if (!prefix.empty() && prefix[0] == '?')
-    pattern = kEndOfPath + prefix;
+    pattern = kEndOfPath + PrepareQuery(prefix.substr(1), true);
   else
-    pattern = kEndOfPath + ('?' + prefix);
+    pattern = kEndOfPath + PrepareQuery(prefix, true);
 
   return CreateCondition(URLMatcherCondition::QUERY_PREFIX, pattern);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateQuerySuffixCondition(
     const std::string& suffix) {
   if (!suffix.empty() && suffix[0] == '?') {
     return CreateQueryEqualsCondition(suffix);
   } else {
     return CreateCondition(URLMatcherCondition::QUERY_SUFFIX,
-                           suffix + kEndOfURL);
+                           PrepareQuery(suffix, false) + kEndOfURL);
   }
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateQueryContainsCondition(
     const std::string& str) {
+  std::string pattern;
   if (!str.empty() && str[0] == '?')
-    return CreateQueryPrefixCondition(str);
+    pattern = str.substr(1);
   else
-    return CreateCondition(URLMatcherCondition::QUERY_CONTAINS, str);
+    pattern = str;
+  return CreateCondition(URLMatcherCondition::QUERY_CONTAINS,
+                         PrepareQuery(pattern, true));
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateQueryEqualsCondition(
     const std::string& str) {
   std::string pattern;
   if (!str.empty() && str[0] == '?')
-    pattern = kEndOfPath + str + kEndOfURL;
+    pattern = kEndOfPath + PrepareQuery(str.substr(1), true) + kEndOfURL;
   else
-    pattern = kEndOfPath + ('?' + str) + kEndOfURL;
+    pattern = kEndOfPath + PrepareQuery(str, true) + kEndOfURL;
 
   return CreateCondition(URLMatcherCondition::QUERY_EQUALS, pattern);
 }
 
 URLMatcherCondition
     URLMatcherConditionFactory::CreateHostSuffixPathPrefixCondition(
     const std::string& host_suffix,
     const std::string& path_prefix) {
   return CreateCondition(URLMatcherCondition::HOST_SUFFIX_PATH_PREFIX,
       host_suffix + kEndOfDomain + path_prefix);
@@ skipping 509 matching lines @@
 
 void URLMatcher::UpdateInternalDatastructures() {
   UpdateSubstringSetMatcher(false);
   UpdateSubstringSetMatcher(true);
   UpdateRegexSetMatcher();
   UpdateTriggers();
   UpdateConditionFactory();
 }
 
 }  // namespace url_matcher