Draft: Dispatching extension events to stopped extension SW.

extensions/browser/event_router.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 "extensions/browser/event_router.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 163 matching lines @@
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(
       EventListener::ForExtension(event_name, extension_id, process, nullptr));
 }
 
 void EventRouter::AddServiceWorkerEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const ExtensionId& extension_id,
+    const GURL& service_worker_scope,
     int worker_thread_id) {
   listeners_.AddListener(EventListener::ForExtensionServiceWorker(
-      event_name, extension_id, process, worker_thread_id, nullptr));
+      event_name, extension_id, process, service_worker_scope, worker_thread_id,
+      nullptr));
 }
 
 void EventRouter::RemoveEventListener(const std::string& event_name,
                                       content::RenderProcessHost* process,
                                       const std::string& extension_id) {
   std::unique_ptr<EventListener> listener =
       EventListener::ForExtension(event_name, extension_id, process, nullptr);
   listeners_.RemoveListener(listener.get());
 }
 
 void EventRouter::RemoveServiceWorkerEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const ExtensionId& extension_id,
+    const GURL& service_worker_scope,
     int worker_thread_id) {
   std::unique_ptr<EventListener> listener =
-      EventListener::ForExtensionServiceWorker(
-          event_name, extension_id, process, worker_thread_id, nullptr);
+      EventListener::ForExtensionServiceWorker(event_name, extension_id,
+                                               process, service_worker_scope,
+                                               worker_thread_id, nullptr);
   listeners_.RemoveListener(listener.get());
 }
 
 void EventRouter::AddEventListenerForURL(const std::string& event_name,
                                          content::RenderProcessHost* process,
                                          const GURL& listener_url) {
   listeners_.AddListener(
       EventListener::ForURL(event_name, listener_url, process, nullptr));
 }
 
@@ skipping 59 matching lines @@
 }
 
 void EventRouter::RenderProcessHostDestroyed(content::RenderProcessHost* host) {
   listeners_.RemoveListenersForProcess(host);
   observed_process_set_.erase(host);
   host->RemoveObserver(this);
 }
 
 void EventRouter::AddLazyEventListener(const std::string& event_name,
                                        const ExtensionId& extension_id) {
-  AddLazyEventListenerImpl(event_name, extension_id, kNonWorkerThreadId);
+  AddLazyEventListenerImpl(
+      EventListener::ForExtension(event_name, extension_id, nullptr, nullptr),
+      RegisteredEventType::kLazy);
 }
 
 void EventRouter::RemoveLazyEventListener(const std::string& event_name,
                                           const ExtensionId& extension_id) {
-  RemoveLazyEventListenerImpl(event_name, extension_id, kNonWorkerThreadId);
+  RemoveLazyEventListenerImpl(
+      EventListener::ForExtension(event_name, extension_id, nullptr, nullptr),
+      RegisteredEventType::kLazy);
 }
 
 void EventRouter::AddLazyServiceWorkerEventListener(
     const std::string& event_name,
     const ExtensionId& extension_id,
-    int worker_thread_id) {
-  AddLazyEventListenerImpl(event_name, extension_id, worker_thread_id);
+    const GURL& service_worker_scope) {
+  std::unique_ptr<EventListener> listener =
+      EventListener::ForExtensionServiceWorker(
+          event_name, extension_id, nullptr, service_worker_scope,
+          kNonWorkerThreadId,  // Lazy, without worker thread id.
+          nullptr);
+  AddLazyEventListenerImpl(std::move(listener),
+                           RegisteredEventType::kServiceWorker);
 }
 
 void EventRouter::RemoveLazyServiceWorkerEventListener(
     const std::string& event_name,
     const ExtensionId& extension_id,
-    int worker_thread_id) {
-  RemoveLazyEventListenerImpl(event_name, extension_id, worker_thread_id);
+    const GURL& service_worker_scope) {
+  std::unique_ptr<EventListener> listener =
+      EventListener::ForExtensionServiceWorker(
+          event_name, extension_id, nullptr, service_worker_scope,
+          kNonWorkerThreadId,  // Lazy, without worker thread id.
+          nullptr);
+  RemoveLazyEventListenerImpl(std::move(listener),
+                              RegisteredEventType::kServiceWorker);
 }
 
 // TODO(lazyboy): Support filters for extension SW events.
 void EventRouter::AddFilteredEventListener(const std::string& event_name,
                                            content::RenderProcessHost* process,
                                            const std::string& extension_id,
                                            const base::DictionaryValue& filter,
                                            bool add_lazy_listener) {
   listeners_.AddListener(EventListener::ForExtension(
       event_name, extension_id, process,
@@ skipping 122 matching lines @@
   if (!has_listener)
     RemoveLazyEventListener(event_name, extension_id);
 }
 
 void EventRouter::DispatchEventImpl(const std::string& restrict_to_extension_id,
                                     const linked_ptr<Event>& event) {
   // We don't expect to get events from a completely different browser context.
   DCHECK(!event->restrict_to_browser_context ||
          ExtensionsBrowserClient::Get()->IsSameContext(
              browser_context_, event->restrict_to_browser_context));
+  LOG(ERROR) << "ER::DispatchEventImpl, event_name: " << event->event_name
+             << ", restrict_to_extension_id: " << restrict_to_extension_id;
+  bool is_tabs_on_updated_event = event->event_name == "tabs.onUpdated";
   std::set<const EventListener*> listeners(
       listeners_.GetEventListeners(*event));
 
   LazyEventDispatcher lazy_event_dispatcher(
       browser_context_, event,
       base::Bind(&EventRouter::DispatchPendingEvent,
                  weak_factory_.GetWeakPtr()));
 
   // We dispatch events for lazy background pages first because attempting to do
   // so will cause those that are being suspended to cancel that suspension.
   // As canceling a suspension entails sending an event to the affected
   // background page, and as that event needs to be delivered before we dispatch
   // the event we are dispatching here, we dispatch to the lazy listeners here
   // first.
   for (const EventListener* listener : listeners) {
+    if (is_tabs_on_updated_event) {
+      LOG(ERROR) << "tabs.onUpdated: listener->process = "
+                 << listener->process() << ", listener->worker_thread_id() = "
+                 << listener->worker_thread_id() << ", is_for_service_worker: "
+                 << listener->is_for_service_worker()
+                 << ", IsLazy: " << listener->IsLazy();
+    }
     if (!restrict_to_extension_id.empty() &&
         restrict_to_extension_id != listener->extension_id()) {
       continue;
     }
-    // TODO(lazyboy): Support lazy listeners for extension SW events.
-    if (listener->IsLazy() && !listener->IsForServiceWorker()) {
-      lazy_event_dispatcher.DispatchToEventPage(listener->extension_id(),
-                                                listener->filter());
+    if (listener->IsLazy()) {
+      if (listener->is_for_service_worker()) {
+        if (is_tabs_on_updated_event)
+          LOG(ERROR) << "---> DISPATCH branch 2";
+        lazy_event_dispatcher.DispatchToServiceWorker(
+            listener->extension_id(), listener->listener_url(), nullptr);
+      } else {
+        lazy_event_dispatcher.DispatchToEventPage(listener->extension_id(),
+                                                  listener->filter());
+      }
     }
   }
 
   for (const EventListener* listener : listeners) {
     if (!restrict_to_extension_id.empty() &&
         restrict_to_extension_id != listener->extension_id()) {
       continue;
     }
     if (!listener->process())
       continue;
+    if (is_tabs_on_updated_event)
+      LOG(ERROR) << "---> DISPATCH branch 2";
     if (lazy_event_dispatcher.HasAlreadyDispatched(
             listener->process()->GetBrowserContext(), listener)) {
+      if (is_tabs_on_updated_event)
+        LOG(ERROR) << "SKIP^^^";
       continue;
     }
+
     DispatchEventToProcess(listener->extension_id(), listener->listener_url(),
                            listener->process(), listener->worker_thread_id(),
                            event, listener->filter(), false /* did_enqueue */);
   }
 }
 
 void EventRouter::DispatchEventToProcess(
     const std::string& extension_id,
     const GURL& listener_url,
     content::RenderProcessHost* process,
@@ skipping 64 matching lines @@
                                          event.get(), listener_filter)) {
     return;
   }
 
   int event_id = g_extension_event_id.GetNext();
   DispatchExtensionMessage(process, worker_thread_id, listener_context,
                            extension_id, event_id, event->event_name,
                            event->event_args.get(), event->user_gesture,
                            event->filter_info);
 
+  // TODO(lazyboy): This is wrong for extensions SW events. We need to:
+  // 1. Increment worker ref count
+  // 2. Add EventAck IPC to decrement that ref count.
   if (extension) {
     ReportEvent(event->histogram_value, extension, did_enqueue);
     IncrementInFlightEvents(listener_context, extension, event_id,
                             event->event_name);
   }
 }
 
 // static
 void EventRouter::DoDispatchEventToSenderBookkeepingOnUI(
     void* browser_context_id,
@@ skipping 95 matching lines @@
             histogram_value, events::ENUM_BOUNDARY);
       }
     } else {
       UMA_HISTOGRAM_ENUMERATION(
           "Extensions.Events.DispatchWithRunningEventPage", histogram_value,
           events::ENUM_BOUNDARY);
     }
   }
 }
 
-void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
-                                       ExtensionHost* host) {
-  if (!host)
+void EventRouter::DispatchPendingEvent(
+    const linked_ptr<Event>& event,
+    std::unique_ptr<LazyContextTaskQueue::ContextInfo> params) {
+  if (!params)
     return;
 
-  if (listeners_.HasProcessListener(host->render_process_host(),
-                                    kNonWorkerThreadId,
-                                    host->extension()->id())) {
-    DispatchEventToProcess(host->extension()->id(), host->GetURL(),
-                           host->render_process_host(), kNonWorkerThreadId,
-                           event, nullptr, true /* did_enqueue */);
+  if (event->event_name == "tabs.onUpdated")
+    LOG(ERROR) << "DispatchPendingEvent";
+
+  if (listeners_.HasProcessListener(params->render_process_host,
+                                    params->worker_thread_id,
+                                    params->extension_id)) {
+    DispatchEventToProcess(
+        params->extension_id, params->url, params->render_process_host,
+        params->worker_thread_id, event, nullptr, true /* did_enqueue */);
   }
 }
 
 void EventRouter::SetRegisteredEvents(const std::string& extension_id,
                                       const std::set<std::string>& events,
                                       RegisteredEventType type) {
   auto events_value = base::MakeUnique<base::ListValue>();
   for (std::set<std::string>::const_iterator iter = events.begin();
        iter != events.end(); ++iter) {
     events_value->AppendString(*iter);
@@ skipping 35 matching lines @@
     listeners_.LoadFilteredLazyListeners(extension->id(), *filtered_events);
 }
 
 void EventRouter::OnExtensionUnloaded(content::BrowserContext* browser_context,
                                       const Extension* extension,
                                       UnloadedExtensionReason reason) {
   // Remove all registered listeners from our cache.
   listeners_.RemoveListenersForExtension(extension->id());
 }
 
-void EventRouter::AddLazyEventListenerImpl(const std::string& event_name,
-                                           const ExtensionId& extension_id,
-                                           int worker_thread_id) {
-  bool is_for_service_worker = worker_thread_id != kNonWorkerThreadId;
-  bool is_new = listeners_.AddListener(
-      is_for_service_worker
-          ? EventListener::ForExtensionServiceWorker(
-                event_name, extension_id, nullptr, worker_thread_id, nullptr)
-          : EventListener::ForExtension(event_name, extension_id, nullptr,
-                                        nullptr));
-
+void EventRouter::AddLazyEventListenerImpl(
+    std::unique_ptr<EventListener> listener,
+    RegisteredEventType type) {
+  const ExtensionId& extension_id = listener->extension_id();
+  const std::string& event_name = listener->event_name();
+  bool is_new = listeners_.AddListener(std::move(listener));
   if (is_new) {
-    RegisteredEventType type = is_for_service_worker
-                                   ? RegisteredEventType::kServiceWorker
-                                   : RegisteredEventType::kLazy;
     std::set<std::string> events = GetRegisteredEvents(extension_id, type);
     bool prefs_is_new = events.insert(event_name).second;
     if (prefs_is_new)
       SetRegisteredEvents(extension_id, events, type);
   }
 }
 
-void EventRouter::RemoveLazyEventListenerImpl(const std::string& event_name,
-                                              const ExtensionId& extension_id,
-                                              int worker_thread_id) {
-  bool is_for_service_worker = worker_thread_id != kNonWorkerThreadId;
-  std::unique_ptr<EventListener> listener =
-      is_for_service_worker
-          ? EventListener::ForExtensionServiceWorker(
-                event_name, extension_id, nullptr, worker_thread_id, nullptr)
-          : EventListener::ForExtension(event_name, extension_id, nullptr,
-                                        nullptr);
+void EventRouter::RemoveLazyEventListenerImpl(
+    std::unique_ptr<EventListener> listener,
+    RegisteredEventType type) {
+  const ExtensionId& extension_id = listener->extension_id();
+  const std::string& event_name = listener->event_name();
   bool did_exist = listeners_.RemoveListener(listener.get());
-
   if (did_exist) {
-    RegisteredEventType type = is_for_service_worker
-                                   ? RegisteredEventType::kServiceWorker
-                                   : RegisteredEventType::kLazy;
     std::set<std::string> events = GetRegisteredEvents(extension_id, type);
     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
     SetRegisteredEvents(extension_id, events, type);
   }
 }
 
 Event::Event(events::HistogramValue histogram_value,
              const std::string& event_name,
              std::unique_ptr<base::ListValue> event_args)
@@ skipping 49 matching lines @@
                                      const std::string& extension_id,
                                      const GURL& listener_url,
                                      content::BrowserContext* browser_context)
     : event_name(event_name),
       extension_id(extension_id),
       listener_url(listener_url),
       browser_context(browser_context) {
 }
 
 }  // namespace extensions