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