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

extensions/common/matcher/url_matcher.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_MATCHER_URL_MATCHER_H_
 #define EXTENSIONS_COMMON_MATCHER_URL_MATCHER_H_
 
 #include <set>
 #include <vector>
 
@@ skipping 35 matching lines @@
     QUERY_SUFFIX,
     QUERY_CONTAINS,
     QUERY_EQUALS,
     HOST_SUFFIX_PATH_PREFIX,
     HOST_EQUALS_PATH_PREFIX,
     URL_PREFIX,
     URL_SUFFIX,
     URL_CONTAINS,
     URL_EQUALS,
     URL_MATCHES,
+    ORIGIN_AND_PATH_MATCHES,  // Matches the URL minus its query string.
   };
 
   URLMatcherCondition();
   ~URLMatcherCondition();
   URLMatcherCondition(Criterion criterion,
                       const StringPattern* substring_pattern);
   URLMatcherCondition(const URLMatcherCondition& rhs);
   URLMatcherCondition& operator=(const URLMatcherCondition& rhs);
   bool operator<(const URLMatcherCondition& rhs) const;
 
   Criterion criterion() const { return criterion_; }
   const StringPattern* string_pattern() const {
     return string_pattern_;
   }
 
   // Returns whether this URLMatcherCondition needs to be executed on a
   // full URL rather than the individual components (see
   // URLMatcherConditionFactory).
   bool IsFullURLCondition() const;
 
   // Returns whether this URLMatcherCondition is a regular expression to be
   // handled by a regex matcher instead of a substring matcher.
   bool IsRegexCondition() const;
 
+  // Returns whether this URLMatcherCondition is a regular expression that shall
+  // be evaluated on the URL without the query parameter.
+  bool IsOriginAndPathRegexCondition() const;
+
   // Returns whether this condition is fulfilled according to
   // |matching_patterns| and |url|.
   bool IsMatch(const std::set<StringPattern::ID>& matching_patterns,
                const GURL& url) const;
 
  private:
   // |criterion_| and |string_pattern_| describe together what property a URL
   // needs to fulfill to be considered a match.
   Criterion criterion_;
 
@@ skipping 58 matching lines @@
       const std::string& path_prefix);
   URLMatcherCondition CreateHostEqualsPathPrefixCondition(
       const std::string& host,
       const std::string& path_prefix);
 
   // Canonicalizes a URL for "CreateURL*Condition" searches.
   std::string CanonicalizeURLForFullSearches(const GURL& url) const;
 
   // Canonicalizes a URL for "CreateURLMatchesCondition" searches.
   std::string CanonicalizeURLForRegexSearches(const GURL& url) const;
+  // Canonicalizes a URL for "CreateOriginAndPathMatchesCondition" searches.
+  std::string CanonicalizeURLForOriginAndPathRegexSearches(
+      const GURL& url) const;
 
   URLMatcherCondition CreateURLPrefixCondition(const std::string& prefix);
   URLMatcherCondition CreateURLSuffixCondition(const std::string& suffix);
   URLMatcherCondition CreateURLContainsCondition(const std::string& str);
   URLMatcherCondition CreateURLEqualsCondition(const std::string& str);
 
   URLMatcherCondition CreateURLMatchesCondition(const std::string& regex);
+  URLMatcherCondition CreateOriginAndPathMatchesCondition(
+      const std::string& regex);
 
   // Removes all patterns from |pattern_singletons_| that are not listed in
   // |used_patterns|. These patterns are not referenced any more and get
   // freed.
   void ForgetUnusedPatterns(
       const std::set<StringPattern::ID>& used_patterns);
 
   // Returns true if this object retains no allocated data. Only for debugging.
   bool IsEmpty() const;
 
@@ skipping 15 matching lines @@
   // StringPatterns.
   struct StringPatternPointerCompare {
     bool operator()(StringPattern* lhs, StringPattern* rhs) const;
   };
   // Set to ensure that we generate only one StringPattern for each content
   // of StringPattern::pattern().
   typedef std::set<StringPattern*, StringPatternPointerCompare>
       PatternSingletons;
   PatternSingletons substring_pattern_singletons_;
   PatternSingletons regex_pattern_singletons_;
+  PatternSingletons origin_and_path_regex_pattern_singletons_;
 
   DISALLOW_COPY_AND_ASSIGN(URLMatcherConditionFactory);
 };
 
 // This class represents a filter for the URL scheme to be hooked up into a
 // URLMatcherConditionSet.
 class URLMatcherSchemeFilter {
  public:
   explicit URLMatcherSchemeFilter(const std::string& filter);
   explicit URLMatcherSchemeFilter(const std::vector<std::string>& filters);
@@ skipping 115 matching lines @@
 
   // Maps a StringPattern ID to the URLMatcherConditions that need to
   // be triggered in case of a StringPattern match.
   typedef std::map<StringPattern::ID, std::set<URLMatcherConditionSet::ID> >
       StringPatternTriggers;
   StringPatternTriggers substring_match_triggers_;
 
   SubstringSetMatcher full_url_matcher_;
   SubstringSetMatcher url_component_matcher_;
   RegexSetMatcher regex_set_matcher_;
+  RegexSetMatcher origin_and_path_regex_set_matcher_;
   std::set<const StringPattern*> registered_full_url_patterns_;
   std::set<const StringPattern*> registered_url_component_patterns_;
 
   DISALLOW_COPY_AND_ASSIGN(URLMatcher);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_MATCHER_URL_MATCHER_H_