extensions/common/event_filter.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "extensions/common/event_filter.h"
   8
   9 #include "components/url_matcher/url_matcher_factory.h"
  10 #include "ipc/ipc_message.h"
  11
  12 using url_matcher::URLMatcher;
  13 using url_matcher::URLMatcherConditionSet;
  14 using url_matcher::URLMatcherFactory;
  15
  16 namespace extensions {
  17
  18 EventFilter::EventMatcherEntry::EventMatcherEntry(
  19     scoped_ptr<EventMatcher> event_matcher,
  20     URLMatcher* url_matcher,
  21     const URLMatcherConditionSet::Vector& condition_sets)
  22     : event_matcher_(event_matcher.Pass()),
  23       url_matcher_(url_matcher) {
  24   for (URLMatcherConditionSet::Vector::const_iterator it =
  25        condition_sets.begin(); it != condition_sets.end(); it++)
  26     condition_set_ids_.push_back((*it)->id());
  27   url_matcher_->AddConditionSets(condition_sets);
  28 }
  29
  30 EventFilter::EventMatcherEntry::~EventMatcherEntry() {
  31   url_matcher_->RemoveConditionSets(condition_set_ids_);
  32 }
  33
  34 void EventFilter::EventMatcherEntry::DontRemoveConditionSetsInDestructor() {
  35   condition_set_ids_.clear();
  36 }
  37
  38 EventFilter::EventFilter()
  39     : next_id_(0),
  40       next_condition_set_id_(0) {
  41 }
  42
  43 EventFilter::~EventFilter() {
  44   // Normally when an event matcher entry is removed from event_matchers_ it
  45   // will remove its condition sets from url_matcher_, but as url_matcher_ is
  46   // being destroyed anyway there is no need to do that step here.
  47   for (EventMatcherMultiMap::iterator it = event_matchers_.begin();
  48        it != event_matchers_.end(); it++) {
  49     for (EventMatcherMap::iterator it2 = it->second.begin();
  50          it2 != it->second.end(); it2++) {
  51       it2->second->DontRemoveConditionSetsInDestructor();
  52     }
  53   }
  54 }
  55
  56 EventFilter::MatcherID
  57 EventFilter::AddEventMatcher(const std::string& event_name,
  58                              scoped_ptr<EventMatcher> matcher) {
  59   MatcherID id = next_id_++;
  60   URLMatcherConditionSet::Vector condition_sets;
  61   if (!CreateConditionSets(id, matcher.get(), &condition_sets))
  62     return -1;
  63
  64   for (URLMatcherConditionSet::Vector::iterator it = condition_sets.begin();
  65        it != condition_sets.end(); it++) {
  66     condition_set_id_to_event_matcher_id_.insert(
  67         std::make_pair((*it)->id(), id));
  68   }
  69   id_to_event_name_[id] = event_name;
  70   event_matchers_[event_name][id] = linked_ptr<EventMatcherEntry>(
  71       new EventMatcherEntry(matcher.Pass(), &url_matcher_, condition_sets));
  72   return id;
  73 }
  74
  75 EventMatcher* EventFilter::GetEventMatcher(MatcherID id) {
  76   DCHECK(id_to_event_name_.find(id) != id_to_event_name_.end());
  77   const std::string& event_name = id_to_event_name_[id];
  78   return event_matchers_[event_name][id]->event_matcher();
  79 }
  80
  81 const std::string& EventFilter::GetEventName(MatcherID id) {
  82   DCHECK(id_to_event_name_.find(id) != id_to_event_name_.end());
  83   return id_to_event_name_[id];
  84 }
  85
  86 bool EventFilter::CreateConditionSets(
  87     MatcherID id,
  88     EventMatcher* matcher,
  89     URLMatcherConditionSet::Vector* condition_sets) {
  90   if (matcher->GetURLFilterCount() == 0) {
  91     // If there are no URL filters then we want to match all events, so create a
  92     // URLFilter from an empty dictionary.
  93     base::DictionaryValue empty_dict;
  94     return AddDictionaryAsConditionSet(&empty_dict, condition_sets);
  95   }
  96   for (int i = 0; i < matcher->GetURLFilterCount(); i++) {
  97     base::DictionaryValue* url_filter;
  98     if (!matcher->GetURLFilter(i, &url_filter))
  99       return false;
 100     if (!AddDictionaryAsConditionSet(url_filter, condition_sets))
 101       return false;
 102   }
 103   return true;
 104 }
 105
 106 bool EventFilter::AddDictionaryAsConditionSet(
 107     base::DictionaryValue* url_filter,
 108     URLMatcherConditionSet::Vector* condition_sets) {
 109   std::string error;
 110   URLMatcherConditionSet::ID condition_set_id = next_condition_set_id_++;
 111   condition_sets->push_back(URLMatcherFactory::CreateFromURLFilterDictionary(
 112       url_matcher_.condition_factory(),
 113       url_filter,
 114       condition_set_id,
 115       &error));
 116   if (!error.empty()) {
 117     LOG(ERROR) << "CreateFromURLFilterDictionary failed: " << error;
 118     url_matcher_.ClearUnusedConditionSets();
 119     condition_sets->clear();
 120     return false;
 121   }
 122   return true;
 123 }
 124
 125 std::string EventFilter::RemoveEventMatcher(MatcherID id) {
 126   std::map<MatcherID, std::string>::iterator it = id_to_event_name_.find(id);
 127   std::string event_name = it->second;
 128   // EventMatcherEntry's destructor causes the condition set ids to be removed
 129   // from url_matcher_.
 130   event_matchers_[event_name].erase(id);
 131   id_to_event_name_.erase(it);
 132   return event_name;
 133 }
 134
 135 std::set<EventFilter::MatcherID> EventFilter::MatchEvent(
 136     const std::string& event_name, const EventFilteringInfo& event_info,
 137     int routing_id) {
 138   std::set<MatcherID> matchers;
 139
 140   EventMatcherMultiMap::iterator it = event_matchers_.find(event_name);
 141   if (it == event_matchers_.end())
 142     return matchers;
 143
 144   EventMatcherMap& matcher_map = it->second;
 145   GURL url_to_match_against = event_info.has_url() ? event_info.url() : GURL();
 146   std::set<URLMatcherConditionSet::ID> matching_condition_set_ids =
 147       url_matcher_.MatchURL(url_to_match_against);
 148   for (std::set<URLMatcherConditionSet::ID>::iterator it =
 149        matching_condition_set_ids.begin();
 150        it != matching_condition_set_ids.end(); it++) {
 151     std::map<URLMatcherConditionSet::ID, MatcherID>::iterator matcher_id =
 152         condition_set_id_to_event_matcher_id_.find(*it);
 153     if (matcher_id == condition_set_id_to_event_matcher_id_.end()) {
 154       NOTREACHED() << "id not found in condition set map (" << (*it) << ")";
 155       continue;
 156     }
 157     MatcherID id = matcher_id->second;
 158     EventMatcherMap::iterator matcher_entry = matcher_map.find(id);
 159     if (matcher_entry == matcher_map.end()) {
 160       // Matcher must be for a different event.
 161       continue;
 162     }
 163     const EventMatcher* event_matcher = matcher_entry->second->event_matcher();
 164     // The context that installed the event listener should be the same context
 165     // as the one where the event listener is called.
 166     if ((routing_id != MSG_ROUTING_NONE) &&
 167         (event_matcher->GetRoutingID() != routing_id)) {
 168       continue;
 169     }
 170     if (event_matcher->MatchNonURLCriteria(event_info)) {
 171       CHECK(!event_matcher->HasURLFilters() || event_info.has_url());
 172       matchers.insert(id);
 173     }
 174   }
 175
 176   return matchers;
 177 }
 178
 179 int EventFilter::GetMatcherCountForEvent(const std::string& name) {
 180   EventMatcherMultiMap::const_iterator it = event_matchers_.find(name);
 181   if (it == event_matchers_.end())
 182     return 0;
 183
 184   return it->second.size();
 185 }
 186
 187 }  // namespace extensions