Event matching by regular expression matching on URLs.

chrome/common/extensions/matcher/substring_set_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/substring_set_matcher.h"
 
 #include <queue>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 
 namespace extensions {
 
 //
-// SubstringPattern
-//
-
-SubstringPattern::SubstringPattern(const std::string& pattern,
-                                   SubstringPattern::ID id)
-    : pattern_(pattern), id_(id) {}
-
-SubstringPattern::~SubstringPattern() {}
-
-bool SubstringPattern::operator<(const SubstringPattern& rhs) const {
-  if (id_ < rhs.id_) return true;
-  if (id_ > rhs.id_) return false;
-  return pattern_ < rhs.pattern_;
-}
-
-//
 // SubstringSetMatcher
 //
 
 SubstringSetMatcher::SubstringSetMatcher() {
   RebuildAhoCorasickTree();
 }
 
 SubstringSetMatcher::~SubstringSetMatcher() {}
 
 void SubstringSetMatcher::RegisterPatterns(
-    const std::vector<const SubstringPattern*>& patterns) {
+    const std::vector<const StringPattern*>& patterns) {
   RegisterAndUnregisterPatterns(patterns,
-                                std::vector<const SubstringPattern*>());
+                                std::vector<const StringPattern*>());
 }
 
 void SubstringSetMatcher::UnregisterPatterns(
-    const std::vector<const SubstringPattern*>& patterns) {
-  RegisterAndUnregisterPatterns(std::vector<const SubstringPattern*>(),
+    const std::vector<const StringPattern*>& patterns) {
+  RegisterAndUnregisterPatterns(std::vector<const StringPattern*>(),
                                 patterns);
 }
 
 void SubstringSetMatcher::RegisterAndUnregisterPatterns(
-      const std::vector<const SubstringPattern*>& to_register,
-      const std::vector<const SubstringPattern*>& to_unregister) {
+      const std::vector<const StringPattern*>& to_register,
+      const std::vector<const StringPattern*>& to_unregister) {
   // Register patterns.
-  for (std::vector<const SubstringPattern*>::const_iterator i =
+  for (std::vector<const StringPattern*>::const_iterator i =
       to_register.begin(); i != to_register.end(); ++i) {
     DCHECK(patterns_.find((*i)->id()) == patterns_.end());
     patterns_[(*i)->id()] = *i;
   }
 
   // Unregister patterns
-  for (std::vector<const SubstringPattern*>::const_iterator i =
+  for (std::vector<const StringPattern*>::const_iterator i =
       to_unregister.begin(); i != to_unregister.end(); ++i) {
     patterns_.erase((*i)->id());
   }
 
   RebuildAhoCorasickTree();
 }
 
 bool SubstringSetMatcher::Match(const std::string& text,
-                                std::set<SubstringPattern::ID>* matches) const {
+                                std::set<StringPattern::ID>* matches) const {
   size_t old_number_of_matches = matches->size();
 
   // Handle patterns matching the empty string.
   matches->insert(tree_[0].matches().begin(), tree_[0].matches().end());
 
   int current_node = 0;
   size_t text_length = text.length();
   for (size_t i = 0; i < text_length; ++i) {
     while (!tree_[current_node].HasEdge(text[i]) && current_node != 0)
       current_node = tree_[current_node].failure();
@@ skipping 25 matching lines @@
   // Insert all patterns.
   for (SubstringPatternSet::const_iterator i = patterns_.begin();
        i != patterns_.end(); ++i) {
     InsertPatternIntoAhoCorasickTree(i->second);
   }
 
   CreateFailureEdges();
 }
 
 void SubstringSetMatcher::InsertPatternIntoAhoCorasickTree(
-    const SubstringPattern* pattern) {
+    const StringPattern* pattern) {
   const std::string& text = pattern->pattern();
   size_t text_length = text.length();
 
   // Iterators on the tree and the text.
   int current_node = 0;
   size_t text_pos = 0;
 
   // Follow existing paths for as long as possible.
   while (text_pos < text_length &&
          tree_[current_node].HasEdge(text[text_pos])) {
@@ skipping 76 matching lines @@
 
 int SubstringSetMatcher::AhoCorasickNode::GetEdge(char c) const {
   std::map<char, int>::const_iterator i = edges_.find(c);
   return i == edges_.end() ? -1 : i->second;
 }
 
 void SubstringSetMatcher::AhoCorasickNode::SetEdge(char c, int node) {
   edges_[c] = node;
 }
 
-void SubstringSetMatcher::AhoCorasickNode::AddMatch(SubstringPattern::ID id) {
+void SubstringSetMatcher::AhoCorasickNode::AddMatch(StringPattern::ID id) {
   matches_.insert(id);
 }
 
 void SubstringSetMatcher::AhoCorasickNode::AddMatches(
     const SubstringSetMatcher::AhoCorasickNode::Matches& matches) {
   matches_.insert(matches.begin(), matches.end());
 }
 
 }  // namespace extensions