Provide a mechanism to the decl. WebRequest API to match URLs without the query against a RegEx

extensions/common/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 "extensions/common/matcher/url_matcher.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
@@ skipping 128 matching lines @@
 //
 // This class also supports matching regular expressions (RE2 syntax)
 // against full URLs, which are transformed as in case 2.
 
 namespace {
 
 bool IsRegexCriterion(URLMatcherCondition::Criterion criterion) {
   return criterion == URLMatcherCondition::URL_MATCHES;
 }
 
+bool IsOriginAndPathRegexCriterion(URLMatcherCondition::Criterion criterion) {
+  return criterion == URLMatcherCondition::ORIGIN_AND_PATH_MATCHES;
+}
+
 }  // namespace
 
 //
 // URLMatcherCondition
 //
 
 URLMatcherCondition::URLMatcherCondition()
     : criterion_(HOST_PREFIX),
       string_pattern_(NULL) {}
 
@@ skipping 43 matching lines @@
     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.
   switch (criterion_) {
@@ skipping 22 matching lines @@
 const char kEndOfDomain[] = {static_cast<char>(-2), 0};
 const char kEndOfPath[] = {static_cast<char>(-3), 0};
 const char kEndOfURL[] = {static_cast<char>(-4), 0};
 }  // 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;
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateHostPrefixCondition(
@@ skipping 109 matching lines @@
     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;
 }
 
-std::string URLMatcherConditionFactory::CanonicalizeURLForRegexSearches(
-    const GURL& url) const {
+static std::string CanonicalizeURLForRegexSearchesHelper(
+    const GURL& url,
+    bool clear_query) {
   GURL::Replacements replacements;
   replacements.ClearPassword();
   replacements.ClearUsername();
   replacements.ClearRef();
+  if (clear_query)
+    replacements.ClearQuery();
   // 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 url.ReplaceComponents(replacements).spec();
 }
 
+std::string URLMatcherConditionFactory::CanonicalizeURLForRegexSearches(
+    const GURL& url) const {
+  return CanonicalizeURLForRegexSearchesHelper(url, false);
+}
+
+std::string
+URLMatcherConditionFactory::CanonicalizeURLForOriginAndPathRegexSearches(
+    const GURL& url) const {
+  return CanonicalizeURLForRegexSearchesHelper(url, true);
+}
+
 URLMatcherCondition URLMatcherConditionFactory::CreateURLPrefixCondition(
     const std::string& prefix) {
   return CreateCondition(URLMatcherCondition::URL_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 + str + kEndOfURL);
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateURLMatchesCondition(
     const std::string& regex) {
   return CreateCondition(URLMatcherCondition::URL_MATCHES, regex);
 }
 
+URLMatcherCondition
+URLMatcherConditionFactory::CreateOriginAndPathMatchesCondition(
+    const std::string& regex) {
+  return CreateCondition(URLMatcherCondition::ORIGIN_AND_PATH_MATCHES, regex);
+}
+
 void URLMatcherConditionFactory::ForgetUnusedPatterns(
       const std::set<StringPattern::ID>& used_patterns) {
   PatternSingletons::iterator i = substring_pattern_singletons_.begin();
   while (i != substring_pattern_singletons_.end()) {
-    if (used_patterns.find((*i)->id()) != used_patterns.end()) {
+    if (ContainsKey(used_patterns, (*i)->id())) {
       ++i;
     } else {
       delete *i;
       substring_pattern_singletons_.erase(i++);
     }
   }
   i = regex_pattern_singletons_.begin();
   while (i != regex_pattern_singletons_.end()) {
-    if (used_patterns.find((*i)->id()) != used_patterns.end()) {
+    if (ContainsKey(used_patterns, (*i)->id())) {
       ++i;
     } else {
       delete *i;
       regex_pattern_singletons_.erase(i++);
     }
   }
+  i = origin_and_path_regex_pattern_singletons_.begin();
+  while (i != origin_and_path_regex_pattern_singletons_.end()) {
+    if (ContainsKey(used_patterns, (*i)->id())) {
+      ++i;
+    } else {
+      delete *i;
+      origin_and_path_regex_pattern_singletons_.erase(i++);
+    }
+  }
 }
 
 bool URLMatcherConditionFactory::IsEmpty() const {
   return substring_pattern_singletons_.empty() &&
-      regex_pattern_singletons_.empty();
+      regex_pattern_singletons_.empty() &&
+      origin_and_path_regex_pattern_singletons_.empty();
 }
 
 URLMatcherCondition URLMatcherConditionFactory::CreateCondition(
     URLMatcherCondition::Criterion criterion,
     const std::string& pattern) {
   StringPattern search_pattern(pattern, 0);
-  PatternSingletons* pattern_singletons =
-      IsRegexCriterion(criterion) ? &regex_pattern_singletons_
-                                  : &substring_pattern_singletons_;
+  PatternSingletons* pattern_singletons = NULL;
+  if (IsRegexCriterion(criterion))
+    pattern_singletons = &regex_pattern_singletons_;
+  else if (IsOriginAndPathRegexCriterion(criterion))
+    pattern_singletons = &origin_and_path_regex_pattern_singletons_;
+  else
+    pattern_singletons = &substring_pattern_singletons_;
 
   PatternSingletons::const_iterator iter =
       pattern_singletons->find(&search_pattern);
 
   if (iter != pattern_singletons->end()) {
     return URLMatcherCondition(criterion, *iter);
   } else {
     StringPattern* new_pattern =
         new StringPattern(pattern, id_counter_++);
     pattern_singletons->insert(new_pattern);
@@ skipping 140 matching lines @@
 void URLMatcher::ClearUnusedConditionSets() {
   UpdateConditionFactory();
 }
 
 std::set<URLMatcherConditionSet::ID> URLMatcher::MatchURL(
     const GURL& url) const {
   // Find all IDs of StringPatterns that match |url|.
   // See URLMatcherConditionFactory for the canonicalization of URLs and the
   // distinction between full url searches and url component searches.
   std::set<StringPattern::ID> matches;
-  full_url_matcher_.Match(
-      condition_factory_.CanonicalizeURLForFullSearches(url), &matches);
-  url_component_matcher_.Match(
-      condition_factory_.CanonicalizeURLForComponentSearches(url), &matches);
-  regex_set_matcher_.Match(
-      condition_factory_.CanonicalizeURLForRegexSearches(url), &matches);
+  if (!full_url_matcher_.IsEmpty()) {
+    full_url_matcher_.Match(
+        condition_factory_.CanonicalizeURLForFullSearches(url), &matches);
+  }
+  if (!url_component_matcher_.IsEmpty()) {
+    url_component_matcher_.Match(
+        condition_factory_.CanonicalizeURLForComponentSearches(url), &matches);
+  }
+  if (!regex_set_matcher_.IsEmpty()) {
+    regex_set_matcher_.Match(
+        condition_factory_.CanonicalizeURLForRegexSearches(url), &matches);
+  }
+  if (!origin_and_path_regex_set_matcher_.IsEmpty()) {
+    origin_and_path_regex_set_matcher_.Match(
+        condition_factory_.CanonicalizeURLForOriginAndPathRegexSearches(url),
+        &matches);
+  }
 
   // Calculate all URLMatcherConditionSets for which all URLMatcherConditions
   // were fulfilled.
   std::set<URLMatcherConditionSet::ID> result;
   for (std::set<StringPattern::ID>::const_iterator i = matches.begin();
        i != matches.end(); ++i) {
     // For each URLMatcherConditionSet there is exactly one condition
     // registered in substring_match_triggers_. This means that the following
     // logic tests each URLMatcherConditionSet exactly once if it can be
     // completely fulfilled.
@@ skipping 15 matching lines @@
 
   return result;
 }
 
 bool URLMatcher::IsEmpty() const {
   return condition_factory_.IsEmpty() &&
       url_matcher_condition_sets_.empty() &&
       substring_match_triggers_.empty() &&
       full_url_matcher_.IsEmpty() &&
       url_component_matcher_.IsEmpty() &&
+      regex_set_matcher_.IsEmpty() &&
+      origin_and_path_regex_set_matcher_.IsEmpty() &&
       registered_full_url_patterns_.empty() &&
       registered_url_component_patterns_.empty();
 }
 
 void URLMatcher::UpdateSubstringSetMatcher(bool full_url_conditions) {
   // The purpose of |full_url_conditions| is just that we need to execute
   // the same logic once for Full URL searches and once for URL Component
   // searches (see URLMatcherConditionFactory).
 
   // Determine which patterns need to be registered when this function
   // terminates.
   std::set<const StringPattern*> new_patterns;
   for (URLMatcherConditionSets::const_iterator condition_set_iter =
       url_matcher_condition_sets_.begin();
       condition_set_iter != url_matcher_condition_sets_.end();
       ++condition_set_iter) {
     const URLMatcherConditionSet::Conditions& conditions =
         condition_set_iter->second->conditions();
     for (URLMatcherConditionSet::Conditions::const_iterator condition_iter =
          conditions.begin(); condition_iter != conditions.end();
          ++condition_iter) {
       // If we are called to process Full URL searches, ignore others, and
       // vice versa. (Regex conditions are updated in UpdateRegexSetMatcher.)
       if (!condition_iter->IsRegexCondition() &&
+          !condition_iter->IsOriginAndPathRegexCondition() &&
           full_url_conditions == condition_iter->IsFullURLCondition())
         new_patterns.insert(condition_iter->string_pattern());
     }
   }
 
   // This is the set of patterns that were registered before this function
   // is called.
   std::set<const StringPattern*>& registered_patterns =
       full_url_conditions ? registered_full_url_patterns_
                           : registered_url_component_patterns_;
@@ skipping 19 matching lines @@
   url_matcher.RegisterAndUnregisterPatterns(patterns_to_register,
                                             patterns_to_unregister);
 
   // Update the set of registered_patterns for the next time this function
   // is being called.
   registered_patterns.swap(new_patterns);
 }
 
 void URLMatcher::UpdateRegexSetMatcher() {
   std::vector<const StringPattern*> new_patterns;
+  std::vector<const StringPattern*> new_origin_and_path_patterns;
 
   for (URLMatcherConditionSets::const_iterator condition_set_iter =
       url_matcher_condition_sets_.begin();
       condition_set_iter != url_matcher_condition_sets_.end();
       ++condition_set_iter) {
     const URLMatcherConditionSet::Conditions& conditions =
         condition_set_iter->second->conditions();
     for (URLMatcherConditionSet::Conditions::const_iterator condition_iter =
          conditions.begin(); condition_iter != conditions.end();
          ++condition_iter) {
-      if (condition_iter->IsRegexCondition())
+      if (condition_iter->IsRegexCondition()) {
         new_patterns.push_back(condition_iter->string_pattern());
+      } else if (condition_iter->IsOriginAndPathRegexCondition()) {
+        new_origin_and_path_patterns.push_back(
+            condition_iter->string_pattern());
+      }
     }
   }
 
   // Start over from scratch. We can't really do better than this, since the
   // FilteredRE2 backend doesn't support incremental updates.
   regex_set_matcher_.ClearPatterns();
   regex_set_matcher_.AddPatterns(new_patterns);
+  origin_and_path_regex_set_matcher_.ClearPatterns();
+  origin_and_path_regex_set_matcher_.AddPatterns(new_origin_and_path_patterns);
 }
 
 void URLMatcher::UpdateTriggers() {
   // Count substring pattern frequencies.
   std::map<StringPattern::ID, size_t> substring_pattern_frequencies;
   for (URLMatcherConditionSets::const_iterator condition_set_iter =
       url_matcher_condition_sets_.begin();
       condition_set_iter != url_matcher_condition_sets_.end();
       ++condition_set_iter) {
     const URLMatcherConditionSet::Conditions& conditions =
@@ skipping 58 matching lines @@
 
 void URLMatcher::UpdateInternalDatastructures() {
   UpdateSubstringSetMatcher(false);
   UpdateSubstringSetMatcher(true);
   UpdateRegexSetMatcher();
   UpdateTriggers();
   UpdateConditionFactory();
 }
 
 }  // namespace extensions