Extend EventFilter to handle the case where EventMatchers from event X get

chrome/common/extensions/event_filter.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/event_filter.h"
 
 #include "chrome/common/extensions/matcher/url_matcher_factory.h"
 
 namespace extensions {
 
@@ skipping 33 matching lines @@
       it2->second->DontRemoveConditionSetsInDestructor();
     }
   }
 }
 
 EventFilter::MatcherID
 EventFilter::AddEventMatcher(const std::string& event_name,
                              scoped_ptr<EventMatcher> matcher) {
   MatcherID id = next_id_++;
   URLMatcherConditionSet::Vector condition_sets;
-  if (!CreateConditionSets(id, matcher->url_filters(), &condition_sets))
+  if (!CreateConditionSets(id, matcher.get(), &condition_sets))
     return -1;
 
   for (URLMatcherConditionSet::Vector::iterator it = condition_sets.begin();
        it != condition_sets.end(); it++) {
     condition_set_id_to_event_matcher_id_.insert(
         std::make_pair((*it)->id(), id));
   }
   id_to_event_name_[id] = event_name;
   event_matchers_[event_name][id] = linked_ptr<EventMatcherEntry>(
       new EventMatcherEntry(matcher.Pass(), &url_matcher_, condition_sets));
   return id;
 }
 
+EventMatcher* EventFilter::GetEventMatcher(MatcherID id) {
+  DCHECK(id_to_event_name_.find(id) != id_to_event_name_.end());
+  const std::string& event_name = id_to_event_name_[id];
+  return event_matchers_[event_name][id]->event_matcher();
+}
+
+const std::string& EventFilter::GetEventName(MatcherID id) {
+  DCHECK(id_to_event_name_.find(id) != id_to_event_name_.end());
+  return id_to_event_name_[id];
+}
+
 bool EventFilter::CreateConditionSets(
     MatcherID id,
-    base::ListValue* url_filters,
+    EventMatcher* matcher,
     URLMatcherConditionSet::Vector* condition_sets) {
-  if (!url_filters || url_filters->GetSize() == 0) {
-    // If there are no url_filters then we want to match all events, so create a
+  if (matcher->GetURLFilterCount() == 0) {
+    // If there are no URL filters then we want to match all events, so create a
     // URLFilter from an empty dictionary.
     base::DictionaryValue empty_dict;
     return AddDictionaryAsConditionSet(&empty_dict, condition_sets);
   }
-  for (size_t i = 0; i < url_filters->GetSize(); i++) {
+  for (int i = 0; i < matcher->GetURLFilterCount(); i++) {
     base::DictionaryValue* url_filter;
-    if (!url_filters->GetDictionary(i, &url_filter))
+    if (!matcher->GetURLFilter(i, &url_filter))
       return false;
     if (!AddDictionaryAsConditionSet(url_filter, condition_sets))
       return false;
   }
   return true;
 }
 
 bool EventFilter::AddDictionaryAsConditionSet(
     base::DictionaryValue* url_filter,
     URLMatcherConditionSet::Vector* condition_sets) {
   std::string error;
   URLMatcherConditionSet::ID condition_set_id = next_condition_set_id_++;
   condition_sets->push_back(URLMatcherFactory::CreateFromURLFilterDictionary(
       url_matcher_.condition_factory(),
       url_filter,
       condition_set_id,
       &error));
   if (!error.empty()) {
     LOG(ERROR) << "CreateFromURLFilterDictionary failed: " << error;
     url_matcher_.ClearUnusedConditionSets();
     condition_sets->clear();
     return false;
   }
   return true;
 }
 
 std::string EventFilter::RemoveEventMatcher(MatcherID id) {
   std::map<MatcherID, std::string>::iterator it = id_to_event_name_.find(id);
-  event_matchers_[it->second].erase(id);
   std::string event_name = it->second;
+  // EventMatcherEntry's destructor causes the condition set ids to be removed
+  // from url_matcher_.
+  event_matchers_[event_name].erase(id);
   id_to_event_name_.erase(it);
   return event_name;
 }
 
 std::set<EventFilter::MatcherID> EventFilter::MatchEvent(
     const std::string& event_name, const EventFilteringInfo& event_info) {
   std::set<MatcherID> matchers;
   EventMatcherMultiMap::iterator it = event_matchers_.find(event_name);
   if (it == event_matchers_.end())
     return matchers;
 
   EventMatcherMap& matcher_map = it->second;
   GURL url_to_match_against = event_info.has_url() ? event_info.url() : GURL();
   std::set<URLMatcherConditionSet::ID> matching_condition_set_ids =
       url_matcher_.MatchURL(url_to_match_against);
   for (std::set<URLMatcherConditionSet::ID>::iterator it =
        matching_condition_set_ids.begin();
        it != matching_condition_set_ids.end(); it++) {
-    MatcherID id = condition_set_id_to_event_matcher_id_[*it];
-    const EventMatcher& event_matcher = matcher_map[id]->event_matcher();
-    if (event_matcher.MatchNonURLCriteria(event_info)) {
-      CHECK(!event_matcher.url_filters() || event_info.has_url());
+    std::map<URLMatcherConditionSet::ID, MatcherID>::iterator matcher_id =
+        condition_set_id_to_event_matcher_id_.find(*it);
+    if (matcher_id == condition_set_id_to_event_matcher_id_.end()) {
+      NOTREACHED() << "id not found in condition set map (" << (*it) << ")";
+      continue;
+    }
+    MatcherID id = matcher_id->second;
+    EventMatcherMap::iterator matcher_entry = matcher_map.find(id);
+    if (matcher_entry == matcher_map.end()) {
+      // Matcher must be for a different event.
+      continue;
+    }
+    const EventMatcher* event_matcher = matcher_entry->second->event_matcher();
+    if (event_matcher->MatchNonURLCriteria(event_info)) {
+      CHECK(!event_matcher->HasURLFilters() || event_info.has_url());
       matchers.insert(id);
     }
   }
 
   return matchers;
 }
 
 int EventFilter::GetMatcherCountForEvent(const std::string& name) {
   EventMatcherMultiMap::const_iterator it = event_matchers_.find(name);
   if (it == event_matchers_.end())
     return 0;
 
   return it->second.size();
 }
 
 }  // namespace extensions