extensions/browser/event_router.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 "extensions/browser/event_router.h"
   6
   7 #include <utility>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/stl_util.h"
  13 #include "base/values.h"
  14 #include "chrome/browser/chrome_notification_types.h"
  15 #include "content/public/browser/notification_service.h"
  16 #include "content/public/browser/render_process_host.h"
  17 #include "extensions/browser/api_activity_monitor.h"
  18 #include "extensions/browser/extension_host.h"
  19 #include "extensions/browser/extension_prefs.h"
  20 #include "extensions/browser/extension_registry.h"
  21 #include "extensions/browser/extension_system.h"
  22 #include "extensions/browser/extensions_browser_client.h"
  23 #include "extensions/browser/lazy_background_task_queue.h"
  24 #include "extensions/browser/process_manager.h"
  25 #include "extensions/browser/process_map.h"
  26 #include "extensions/common/extension.h"
  27 #include "extensions/common/extension_api.h"
  28 #include "extensions/common/extension_messages.h"
  29 #include "extensions/common/extension_urls.h"
  30 #include "extensions/common/manifest_handlers/background_info.h"
  31 #include "extensions/common/manifest_handlers/incognito_info.h"
  32
  33 using base::DictionaryValue;
  34 using base::ListValue;
  35 using content::BrowserContext;
  36 using content::BrowserThread;
  37
  38 namespace extensions {
  39
  40 namespace {
  41
  42 void DoNothing(ExtensionHost* host) {}
  43
  44 // A dictionary of event names to lists of filters that this extension has
  45 // registered from its lazy background page.
  46 const char kFilteredEvents[] = "filtered_events";
  47
  48 // Sends a notification about an event to the API activity monitor on the
  49 // UI thread. Can be called from any thread.
  50 void NotifyApiEventDispatched(void* browser_context_id,
  51                               const std::string& extension_id,
  52                               const std::string& event_name,
  53                               scoped_ptr<ListValue> args) {
  54   // The ApiActivityMonitor can only be accessed from the UI thread.
  55   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  56     BrowserThread::PostTask(
  57         BrowserThread::UI,
  58         FROM_HERE,
  59         base::Bind(&NotifyApiEventDispatched,
  60                    browser_context_id,
  61                    extension_id,
  62                    event_name,
  63                    base::Passed(&args)));
  64     return;
  65   }
  66
  67   // Notify the ApiActivityMonitor about the event dispatch.
  68   BrowserContext* context = static_cast<BrowserContext*>(browser_context_id);
  69   if (!ExtensionsBrowserClient::Get()->IsValidContext(context))
  70     return;
  71   ApiActivityMonitor* monitor =
  72       ExtensionsBrowserClient::Get()->GetApiActivityMonitor(context);
  73   if (monitor)
  74     monitor->OnApiEventDispatched(extension_id, event_name, args.Pass());
  75 }
  76
  77 }  // namespace
  78
  79 const char EventRouter::kRegisteredEvents[] = "events";
  80
  81 struct EventRouter::ListenerProcess {
  82   content::RenderProcessHost* process;
  83   std::string extension_id;
  84
  85   ListenerProcess(content::RenderProcessHost* process,
  86                   const std::string& extension_id)
  87       : process(process), extension_id(extension_id) {}
  88
  89   bool operator<(const ListenerProcess& that) const {
  90     if (process < that.process)
  91       return true;
  92     if (process == that.process && extension_id < that.extension_id)
  93       return true;
  94     return false;
  95   }
  96 };
  97
  98 // static
  99 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
 100                                            void* browser_context_id,
 101                                            const std::string& extension_id,
 102                                            const std::string& event_name,
 103                                            ListValue* event_args,
 104                                            UserGestureState user_gesture,
 105                                            const EventFilteringInfo& info) {
 106   NotifyApiEventDispatched(browser_context_id,
 107                            extension_id,
 108                            event_name,
 109                            make_scoped_ptr(event_args->DeepCopy()));
 110
 111   ListValue args;
 112   args.Set(0, new base::StringValue(event_name));
 113   args.Set(1, event_args);
 114   args.Set(2, info.AsValue().release());
 115   ipc_sender->Send(new ExtensionMsg_MessageInvoke(
 116       MSG_ROUTING_CONTROL,
 117       extension_id,
 118       kEventBindings,
 119       "dispatchEvent",
 120       args,
 121       user_gesture == USER_GESTURE_ENABLED));
 122
 123   // DispatchExtensionMessage does _not_ take ownership of event_args, so we
 124   // must ensure that the destruction of args does not attempt to free it.
 125   scoped_ptr<base::Value> removed_event_args;
 126   args.Remove(1, &removed_event_args);
 127   ignore_result(removed_event_args.release());
 128 }
 129
 130 // static
 131 EventRouter* EventRouter::Get(content::BrowserContext* browser_context) {
 132   return ExtensionSystem::Get(browser_context)->event_router();
 133 }
 134
 135 // static
 136 std::string EventRouter::GetBaseEventName(const std::string& full_event_name) {
 137   size_t slash_sep = full_event_name.find('/');
 138   return full_event_name.substr(0, slash_sep);
 139 }
 140
 141 // static
 142 void EventRouter::DispatchEvent(IPC::Sender* ipc_sender,
 143                                 void* browser_context_id,
 144                                 const std::string& extension_id,
 145                                 const std::string& event_name,
 146                                 scoped_ptr<ListValue> event_args,
 147                                 UserGestureState user_gesture,
 148                                 const EventFilteringInfo& info) {
 149   DispatchExtensionMessage(ipc_sender,
 150                            browser_context_id,
 151                            extension_id,
 152                            event_name,
 153                            event_args.get(),
 154                            user_gesture,
 155                            info);
 156
 157   BrowserThread::PostTask(
 158       BrowserThread::UI,
 159       FROM_HERE,
 160       base::Bind(&EventRouter::IncrementInFlightEventsOnUI,
 161                   browser_context_id,
 162                   extension_id));
 163 }
 164
 165 EventRouter::EventRouter(BrowserContext* browser_context,
 166                          ExtensionPrefs* extension_prefs)
 167     : browser_context_(browser_context),
 168       extension_prefs_(extension_prefs),
 169       listeners_(this) {
 170   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
 171                  content::NotificationService::AllSources());
 172   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
 173                  content::NotificationService::AllSources());
 174   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
 175                  content::Source<BrowserContext>(browser_context_));
 176   registrar_.Add(this,
 177                  chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
 178                  content::Source<BrowserContext>(browser_context_));
 179   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 180                  content::Source<BrowserContext>(browser_context_));
 181 }
 182
 183 EventRouter::~EventRouter() {}
 184
 185 void EventRouter::AddEventListener(const std::string& event_name,
 186                                    content::RenderProcessHost* process,
 187                                    const std::string& extension_id) {
 188   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
 189       event_name, extension_id, process, scoped_ptr<DictionaryValue>())));
 190 }
 191
 192 void EventRouter::RemoveEventListener(const std::string& event_name,
 193                                       content::RenderProcessHost* process,
 194                                       const std::string& extension_id) {
 195   EventListener listener(event_name, extension_id, process,
 196                          scoped_ptr<DictionaryValue>());
 197   listeners_.RemoveListener(&listener);
 198 }
 199
 200 void EventRouter::RegisterObserver(Observer* observer,
 201                                    const std::string& event_name) {
 202   // Observing sub-event names like "foo.onBar/123" is not allowed.
 203   DCHECK(event_name.find('/') == std::string::npos);
 204   observers_[event_name] = observer;
 205 }
 206
 207 void EventRouter::UnregisterObserver(Observer* observer) {
 208   std::vector<ObserverMap::iterator> iters_to_remove;
 209   for (ObserverMap::iterator iter = observers_.begin();
 210        iter != observers_.end(); ++iter) {
 211     if (iter->second == observer)
 212       iters_to_remove.push_back(iter);
 213   }
 214   for (size_t i = 0; i < iters_to_remove.size(); ++i)
 215     observers_.erase(iters_to_remove[i]);
 216 }
 217
 218 void EventRouter::OnListenerAdded(const EventListener* listener) {
 219   const EventListenerInfo details(listener->event_name(),
 220                                   listener->extension_id(),
 221                                   listener->GetBrowserContext());
 222   std::string base_event_name = GetBaseEventName(listener->event_name());
 223   ObserverMap::iterator observer = observers_.find(base_event_name);
 224   if (observer != observers_.end())
 225     observer->second->OnListenerAdded(details);
 226 }
 227
 228 void EventRouter::OnListenerRemoved(const EventListener* listener) {
 229   const EventListenerInfo details(listener->event_name(),
 230                                   listener->extension_id(),
 231                                   listener->GetBrowserContext());
 232   std::string base_event_name = GetBaseEventName(listener->event_name());
 233   ObserverMap::iterator observer = observers_.find(base_event_name);
 234   if (observer != observers_.end())
 235     observer->second->OnListenerRemoved(details);
 236 }
 237
 238 void EventRouter::AddLazyEventListener(const std::string& event_name,
 239                                        const std::string& extension_id) {
 240   scoped_ptr<EventListener> listener(new EventListener(
 241       event_name, extension_id, NULL, scoped_ptr<DictionaryValue>()));
 242   bool is_new = listeners_.AddListener(listener.Pass());
 243
 244   if (is_new) {
 245     std::set<std::string> events = GetRegisteredEvents(extension_id);
 246     bool prefs_is_new = events.insert(event_name).second;
 247     if (prefs_is_new)
 248       SetRegisteredEvents(extension_id, events);
 249   }
 250 }
 251
 252 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
 253                                           const std::string& extension_id) {
 254   EventListener listener(event_name, extension_id, NULL,
 255                          scoped_ptr<DictionaryValue>());
 256   bool did_exist = listeners_.RemoveListener(&listener);
 257
 258   if (did_exist) {
 259     std::set<std::string> events = GetRegisteredEvents(extension_id);
 260     bool prefs_did_exist = events.erase(event_name) > 0;
 261     DCHECK(prefs_did_exist);
 262     SetRegisteredEvents(extension_id, events);
 263   }
 264 }
 265
 266 void EventRouter::AddFilteredEventListener(const std::string& event_name,
 267                                            content::RenderProcessHost* process,
 268                                            const std::string& extension_id,
 269                                            const base::DictionaryValue& filter,
 270                                            bool add_lazy_listener) {
 271   listeners_.AddListener(scoped_ptr<EventListener>(new EventListener(
 272       event_name, extension_id, process,
 273       scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 274
 275   if (add_lazy_listener) {
 276     bool added = listeners_.AddListener(scoped_ptr<EventListener>(
 277         new EventListener(event_name, extension_id, NULL,
 278         scoped_ptr<DictionaryValue>(filter.DeepCopy()))));
 279
 280     if (added)
 281       AddFilterToEvent(event_name, extension_id, &filter);
 282   }
 283 }
 284
 285 void EventRouter::RemoveFilteredEventListener(
 286     const std::string& event_name,
 287     content::RenderProcessHost* process,
 288     const std::string& extension_id,
 289     const base::DictionaryValue& filter,
 290     bool remove_lazy_listener) {
 291   EventListener listener(event_name, extension_id, process,
 292                          scoped_ptr<DictionaryValue>(filter.DeepCopy()));
 293
 294   listeners_.RemoveListener(&listener);
 295
 296   if (remove_lazy_listener) {
 297     listener.MakeLazy();
 298     bool removed = listeners_.RemoveListener(&listener);
 299
 300     if (removed)
 301       RemoveFilterFromEvent(event_name, extension_id, &filter);
 302   }
 303 }
 304
 305 bool EventRouter::HasEventListener(const std::string& event_name) {
 306   return listeners_.HasListenerForEvent(event_name);
 307 }
 308
 309 bool EventRouter::ExtensionHasEventListener(const std::string& extension_id,
 310                                             const std::string& event_name) {
 311   return listeners_.HasListenerForExtension(extension_id, event_name);
 312 }
 313
 314 bool EventRouter::HasEventListenerImpl(const ListenerMap& listener_map,
 315                                        const std::string& extension_id,
 316                                        const std::string& event_name) {
 317   ListenerMap::const_iterator it = listener_map.find(event_name);
 318   if (it == listener_map.end())
 319     return false;
 320
 321   const std::set<ListenerProcess>& listeners = it->second;
 322   if (extension_id.empty())
 323     return !listeners.empty();
 324
 325   for (std::set<ListenerProcess>::const_iterator listener = listeners.begin();
 326        listener != listeners.end(); ++listener) {
 327     if (listener->extension_id == extension_id)
 328       return true;
 329   }
 330   return false;
 331 }
 332
 333 std::set<std::string> EventRouter::GetRegisteredEvents(
 334     const std::string& extension_id) {
 335   std::set<std::string> events;
 336   const ListValue* events_value = NULL;
 337
 338   if (!extension_prefs_ ||
 339       !extension_prefs_->ReadPrefAsList(
 340            extension_id, kRegisteredEvents, &events_value)) {
 341     return events;
 342   }
 343
 344   for (size_t i = 0; i < events_value->GetSize(); ++i) {
 345     std::string event;
 346     if (events_value->GetString(i, &event))
 347       events.insert(event);
 348   }
 349   return events;
 350 }
 351
 352 void EventRouter::SetRegisteredEvents(const std::string& extension_id,
 353                                       const std::set<std::string>& events) {
 354   ListValue* events_value = new ListValue;
 355   for (std::set<std::string>::const_iterator iter = events.begin();
 356        iter != events.end(); ++iter) {
 357     events_value->Append(new base::StringValue(*iter));
 358   }
 359   extension_prefs_->UpdateExtensionPref(
 360       extension_id, kRegisteredEvents, events_value);
 361 }
 362
 363 void EventRouter::AddFilterToEvent(const std::string& event_name,
 364                                    const std::string& extension_id,
 365                                    const DictionaryValue* filter) {
 366   ExtensionPrefs::ScopedDictionaryUpdate update(
 367       extension_prefs_, extension_id, kFilteredEvents);
 368   DictionaryValue* filtered_events = update.Get();
 369   if (!filtered_events)
 370     filtered_events = update.Create();
 371
 372   ListValue* filter_list = NULL;
 373   if (!filtered_events->GetList(event_name, &filter_list)) {
 374     filter_list = new ListValue;
 375     filtered_events->SetWithoutPathExpansion(event_name, filter_list);
 376   }
 377
 378   filter_list->Append(filter->DeepCopy());
 379 }
 380
 381 void EventRouter::RemoveFilterFromEvent(const std::string& event_name,
 382                                         const std::string& extension_id,
 383                                         const DictionaryValue* filter) {
 384   ExtensionPrefs::ScopedDictionaryUpdate update(
 385       extension_prefs_, extension_id, kFilteredEvents);
 386   DictionaryValue* filtered_events = update.Get();
 387   ListValue* filter_list = NULL;
 388   if (!filtered_events ||
 389       !filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
 390     return;
 391   }
 392
 393   for (size_t i = 0; i < filter_list->GetSize(); i++) {
 394     DictionaryValue* filter = NULL;
 395     CHECK(filter_list->GetDictionary(i, &filter));
 396     if (filter->Equals(filter)) {
 397       filter_list->Remove(i, NULL);
 398       break;
 399     }
 400   }
 401 }
 402
 403 const DictionaryValue* EventRouter::GetFilteredEvents(
 404     const std::string& extension_id) {
 405   const DictionaryValue* events = NULL;
 406   extension_prefs_->ReadPrefAsDictionary(
 407       extension_id, kFilteredEvents, &events);
 408   return events;
 409 }
 410
 411 void EventRouter::BroadcastEvent(scoped_ptr<Event> event) {
 412   DispatchEventImpl(std::string(), linked_ptr<Event>(event.release()));
 413 }
 414
 415 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
 416                                            scoped_ptr<Event> event) {
 417   DCHECK(!extension_id.empty());
 418   DispatchEventImpl(extension_id, linked_ptr<Event>(event.release()));
 419 }
 420
 421 void EventRouter::DispatchEventWithLazyListener(const std::string& extension_id,
 422                                                 scoped_ptr<Event> event) {
 423   DCHECK(!extension_id.empty());
 424   std::string event_name = event->event_name;
 425   bool has_listener = ExtensionHasEventListener(extension_id, event_name);
 426   if (!has_listener)
 427     AddLazyEventListener(event_name, extension_id);
 428   DispatchEventToExtension(extension_id, event.Pass());
 429   if (!has_listener)
 430     RemoveLazyEventListener(event_name, extension_id);
 431 }
 432
 433 void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
 434                                     const linked_ptr<Event>& event) {
 435   // We don't expect to get events from a completely different browser context.
 436   DCHECK(!event->restrict_to_browser_context ||
 437          ExtensionsBrowserClient::Get()->IsSameContext(
 438              browser_context_, event->restrict_to_browser_context));
 439
 440   std::set<const EventListener*> listeners(
 441       listeners_.GetEventListeners(*event));
 442
 443   std::set<EventDispatchIdentifier> already_dispatched;
 444
 445   // We dispatch events for lazy background pages first because attempting to do
 446   // so will cause those that are being suspended to cancel that suspension.
 447   // As canceling a suspension entails sending an event to the affected
 448   // background page, and as that event needs to be delivered before we dispatch
 449   // the event we are dispatching here, we dispatch to the lazy listeners here
 450   // first.
 451   for (std::set<const EventListener*>::iterator it = listeners.begin();
 452        it != listeners.end(); it++) {
 453     const EventListener* listener = *it;
 454     if (restrict_to_extension_id.empty() ||
 455         restrict_to_extension_id == listener->extension_id()) {
 456       if (listener->IsLazy()) {
 457         DispatchLazyEvent(listener->extension_id(), event, &already_dispatched);
 458       }
 459     }
 460   }
 461
 462   for (std::set<const EventListener*>::iterator it = listeners.begin();
 463        it != listeners.end(); it++) {
 464     const EventListener* listener = *it;
 465     if (restrict_to_extension_id.empty() ||
 466         restrict_to_extension_id == listener->extension_id()) {
 467       if (listener->process()) {
 468         EventDispatchIdentifier dispatch_id(listener->GetBrowserContext(),
 469                                             listener->extension_id());
 470         if (!ContainsKey(already_dispatched, dispatch_id)) {
 471           DispatchEventToProcess(
 472               listener->extension_id(), listener->process(), event);
 473         }
 474       }
 475     }
 476   }
 477 }
 478
 479 void EventRouter::DispatchLazyEvent(
 480     const std::string& extension_id,
 481     const linked_ptr<Event>& event,
 482     std::set<EventDispatchIdentifier>* already_dispatched) {
 483   // Check both the original and the incognito browser context to see if we
 484   // should load a lazy bg page to handle the event. The latter case
 485   // occurs in the case of split-mode extensions.
 486   const Extension* extension =
 487       ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
 488           extension_id);
 489   if (!extension)
 490     return;
 491
 492   if (MaybeLoadLazyBackgroundPageToDispatchEvent(
 493           browser_context_, extension, event)) {
 494     already_dispatched->insert(std::make_pair(browser_context_, extension_id));
 495   }
 496
 497   ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
 498   if (browser_client->HasOffTheRecordContext(browser_context_) &&
 499       IncognitoInfo::IsSplitMode(extension)) {
 500     BrowserContext* incognito_context =
 501         browser_client->GetOffTheRecordContext(browser_context_);
 502     if (MaybeLoadLazyBackgroundPageToDispatchEvent(
 503             incognito_context, extension, event)) {
 504       already_dispatched->insert(
 505           std::make_pair(incognito_context, extension_id));
 506     }
 507   }
 508 }
 509
 510 void EventRouter::DispatchEventToProcess(const std::string& extension_id,
 511                                          content::RenderProcessHost* process,
 512                                          const linked_ptr<Event>& event) {
 513   const Extension* extension =
 514       ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
 515           extension_id);
 516
 517   // The extension could have been removed, but we do not unregister it until
 518   // the extension process is unloaded.
 519   if (!extension)
 520     return;
 521
 522   BrowserContext* listener_context = process->GetBrowserContext();
 523   ProcessMap* process_map = ProcessMap::Get(listener_context);
 524   // If the event is privileged, only send to extension processes. Otherwise,
 525   // it's OK to send to normal renderers (e.g., for content scripts).
 526   if (ExtensionAPI::GetSharedInstance()->IsPrivileged(event->event_name) &&
 527       !process_map->Contains(extension->id(), process->GetID())) {
 528     return;
 529   }
 530
 531   // If the event is restricted to a URL, only dispatch if the extension has
 532   // permission for it (or if the event originated from itself).
 533   if (!event->event_url.is_empty() &&
 534       event->event_url.host() != extension->id() &&
 535       !extension->GetActivePermissions()->HasEffectiveAccessToURL(
 536           event->event_url)) {
 537     return;
 538   }
 539
 540   if (!CanDispatchEventToBrowserContext(listener_context, extension, event))
 541     return;
 542
 543   if (!event->will_dispatch_callback.is_null()) {
 544     event->will_dispatch_callback.Run(listener_context, extension,
 545                                       event->event_args.get());
 546   }
 547
 548   DispatchExtensionMessage(process, listener_context, extension->id(),
 549                            event->event_name, event->event_args.get(),
 550                            event->user_gesture, event->filter_info);
 551   IncrementInFlightEvents(listener_context, extension);
 552 }
 553
 554 bool EventRouter::CanDispatchEventToBrowserContext(
 555     BrowserContext* context,
 556     const Extension* extension,
 557     const linked_ptr<Event>& event) {
 558   // Is this event from a different browser context than the renderer (ie, an
 559   // incognito tab event sent to a normal process, or vice versa).
 560   bool cross_incognito = event->restrict_to_browser_context &&
 561                          context != event->restrict_to_browser_context;
 562   if (!cross_incognito)
 563     return true;
 564   return ExtensionsBrowserClient::Get()->CanExtensionCrossIncognito(
 565       extension, context);
 566 }
 567
 568 bool EventRouter::MaybeLoadLazyBackgroundPageToDispatchEvent(
 569     BrowserContext* context,
 570     const Extension* extension,
 571     const linked_ptr<Event>& event) {
 572   if (extension->is_ephemeral() && !event->can_load_ephemeral_apps) {
 573     // Most events can only be dispatched to ephemeral apps that are already
 574     // running.
 575     ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
 576     if (!pm->GetBackgroundHostForExtension(extension->id()))
 577       return false;
 578   }
 579
 580   if (!CanDispatchEventToBrowserContext(context, extension, event))
 581     return false;
 582
 583   LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
 584       context)->lazy_background_task_queue();
 585   if (queue->ShouldEnqueueTask(context, extension)) {
 586     linked_ptr<Event> dispatched_event(event);
 587
 588     // If there's a dispatch callback, call it now (rather than dispatch time)
 589     // to avoid lifetime issues. Use a separate copy of the event args, so they
 590     // last until the event is dispatched.
 591     if (!event->will_dispatch_callback.is_null()) {
 592       dispatched_event.reset(event->DeepCopy());
 593       dispatched_event->will_dispatch_callback.Run(
 594           context, extension, dispatched_event->event_args.get());
 595       // Ensure we don't call it again at dispatch time.
 596       dispatched_event->will_dispatch_callback.Reset();
 597     }
 598
 599     queue->AddPendingTask(context, extension->id(),
 600                           base::Bind(&EventRouter::DispatchPendingEvent,
 601                                      base::Unretained(this), dispatched_event));
 602     return true;
 603   }
 604
 605   return false;
 606 }
 607
 608 // static
 609 void EventRouter::IncrementInFlightEventsOnUI(
 610     void* browser_context_id,
 611     const std::string& extension_id) {
 612   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 613   BrowserContext* browser_context =
 614       reinterpret_cast<BrowserContext*>(browser_context_id);
 615   if (!ExtensionsBrowserClient::Get()->IsValidContext(browser_context))
 616     return;
 617   EventRouter* event_router = EventRouter::Get(browser_context);
 618   if (!event_router)
 619     return;
 620   const Extension* extension =
 621       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
 622           extension_id);
 623   if (!extension)
 624     return;
 625   event_router->IncrementInFlightEvents(browser_context, extension);
 626 }
 627
 628 void EventRouter::IncrementInFlightEvents(BrowserContext* context,
 629                                           const Extension* extension) {
 630   // Only increment in-flight events if the lazy background page is active,
 631   // because that's the only time we'll get an ACK.
 632   if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
 633     ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
 634     ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
 635     if (host)
 636       pm->IncrementLazyKeepaliveCount(extension);
 637   }
 638 }
 639
 640 void EventRouter::OnEventAck(BrowserContext* context,
 641                              const std::string& extension_id) {
 642   ProcessManager* pm = ExtensionSystem::Get(context)->process_manager();
 643   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
 644   // The event ACK is routed to the background host, so this should never be
 645   // NULL.
 646   CHECK(host);
 647   // TODO(mpcomplete): We should never get this message unless
 648   // HasLazyBackgroundPage is true. Find out why we're getting it anyway.
 649   if (host->extension() &&
 650       BackgroundInfo::HasLazyBackgroundPage(host->extension()))
 651     pm->DecrementLazyKeepaliveCount(host->extension());
 652 }
 653
 654 void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
 655                                        ExtensionHost* host) {
 656   if (!host)
 657     return;
 658
 659   if (listeners_.HasProcessListener(host->render_process_host(),
 660                                     host->extension()->id())) {
 661     DispatchEventToProcess(host->extension()->id(),
 662                            host->render_process_host(), event);
 663   }
 664 }
 665
 666 void EventRouter::Observe(int type,
 667                           const content::NotificationSource& source,
 668                           const content::NotificationDetails& details) {
 669   switch (type) {
 670     case content::NOTIFICATION_RENDERER_PROCESS_TERMINATED:
 671     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
 672       content::RenderProcessHost* renderer =
 673           content::Source<content::RenderProcessHost>(source).ptr();
 674       // Remove all event listeners associated with this renderer.
 675       listeners_.RemoveListenersForProcess(renderer);
 676       break;
 677     }
 678     case chrome::NOTIFICATION_EXTENSION_ENABLED: {
 679       // If the extension has a lazy background page, make sure it gets loaded
 680       // to register the events the extension is interested in.
 681       const Extension* extension =
 682           content::Details<const Extension>(details).ptr();
 683       if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
 684         LazyBackgroundTaskQueue* queue = ExtensionSystem::Get(
 685             browser_context_)->lazy_background_task_queue();
 686         queue->AddPendingTask(browser_context_, extension->id(),
 687                               base::Bind(&DoNothing));
 688       }
 689       break;
 690     }
 691     case chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED: {
 692       // Add all registered lazy listeners to our cache.
 693       const Extension* extension =
 694           content::Details<const Extension>(details).ptr();
 695       std::set<std::string> registered_events =
 696           GetRegisteredEvents(extension->id());
 697       listeners_.LoadUnfilteredLazyListeners(extension->id(),
 698                                              registered_events);
 699       const DictionaryValue* filtered_events =
 700           GetFilteredEvents(extension->id());
 701       if (filtered_events)
 702         listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
 703       break;
 704     }
 705     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
 706       // Remove all registered lazy listeners from our cache.
 707       UnloadedExtensionInfo* unloaded =
 708           content::Details<UnloadedExtensionInfo>(details).ptr();
 709       listeners_.RemoveLazyListenersForExtension(unloaded->extension->id());
 710       break;
 711     }
 712     default:
 713       NOTREACHED();
 714       return;
 715   }
 716 }
 717
 718 Event::Event(const std::string& event_name,
 719              scoped_ptr<base::ListValue> event_args)
 720     : event_name(event_name),
 721       event_args(event_args.Pass()),
 722       restrict_to_browser_context(NULL),
 723       user_gesture(EventRouter::USER_GESTURE_UNKNOWN),
 724       can_load_ephemeral_apps(false) {
 725   DCHECK(this->event_args.get());
 726 }
 727
 728 Event::Event(const std::string& event_name,
 729              scoped_ptr<base::ListValue> event_args,
 730              BrowserContext* restrict_to_browser_context)
 731     : event_name(event_name),
 732       event_args(event_args.Pass()),
 733       restrict_to_browser_context(restrict_to_browser_context),
 734       user_gesture(EventRouter::USER_GESTURE_UNKNOWN),
 735       can_load_ephemeral_apps(false) {
 736   DCHECK(this->event_args.get());
 737 }
 738
 739 Event::Event(const std::string& event_name,
 740              scoped_ptr<ListValue> event_args,
 741              BrowserContext* restrict_to_browser_context,
 742              const GURL& event_url,
 743              EventRouter::UserGestureState user_gesture,
 744              const EventFilteringInfo& filter_info)
 745     : event_name(event_name),
 746       event_args(event_args.Pass()),
 747       restrict_to_browser_context(restrict_to_browser_context),
 748       event_url(event_url),
 749       user_gesture(user_gesture),
 750       filter_info(filter_info),
 751       can_load_ephemeral_apps(false) {
 752   DCHECK(this->event_args.get());
 753 }
 754
 755 Event::~Event() {}
 756
 757 Event* Event::DeepCopy() {
 758   Event* copy = new Event(event_name,
 759                           scoped_ptr<base::ListValue>(event_args->DeepCopy()),
 760                           restrict_to_browser_context,
 761                           event_url,
 762                           user_gesture,
 763                           filter_info);
 764   copy->will_dispatch_callback = will_dispatch_callback;
 765   return copy;
 766 }
 767
 768 EventListenerInfo::EventListenerInfo(const std::string& event_name,
 769                                      const std::string& extension_id,
 770                                      content::BrowserContext* browser_context)
 771     : event_name(event_name),
 772       extension_id(extension_id),
 773       browser_context(browser_context) {}
 774
 775 }  // namespace extensions