[extension SW]: Support event listener registration and event dispatching.

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 56 matching lines @@
   BrowserContext* context = static_cast<BrowserContext*>(browser_context_id);
   activity_monitor::OnApiEventDispatched(context, extension_id, event_name,
                                          args);
 }
 
 // A global identifier used to distinguish extension events.
 base::StaticAtomicSequenceNumber g_extension_event_id;
 
 }  // namespace
 
-const char EventRouter::kRegisteredEvents[] = "events";
+const char EventRouter::kRegisteredLazyEvents[] = "events";
+const char EventRouter::kRegisteredServiceWorkerEvents[] =
+    "serviceworkerevents";
 
 // static
 void EventRouter::DispatchExtensionMessage(IPC::Sender* ipc_sender,
+                                           int worker_thread_id,
                                            void* browser_context_id,
                                            const std::string& extension_id,
                                            int event_id,
                                            const std::string& event_name,
                                            ListValue* event_args,
                                            UserGestureState user_gesture,
                                            const EventFilteringInfo& info) {
   NotifyEventDispatched(browser_context_id, extension_id, event_name,
                         *event_args);
 
   ExtensionMsg_DispatchEvent_Params params;
+  params.worker_thread_id = worker_thread_id;
   params.extension_id = extension_id;
   params.event_name = event_name;
   params.event_id = event_id;
   params.is_user_gesture = user_gesture == USER_GESTURE_ENABLED;
   params.filtering_info.Swap(info.AsValue().get());
 
   ipc_sender->Send(new ExtensionMsg_DispatchEvent(params, *event_args));
 }
 
 // static
@@ skipping 25 matching lines @@
   } else {
     // This is called from WebRequest API.
     // TODO(lazyboy): Skip this entirely: http://crbug.com/488747.
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&EventRouter::DoDispatchEventToSenderBookkeepingOnUI,
                    browser_context_id, extension_id, event_id, histogram_value,
                    event_name));
   }
 
-  DispatchExtensionMessage(ipc_sender, browser_context_id, extension_id,
+  DispatchExtensionMessage(ipc_sender,
+                           // TODO(lazyboy): |kNonWorkerThreadId| means these
+                           // will not work for extension SW.
+                           kNonWorkerThreadId, browser_context_id, extension_id,
                            event_id, event_name, event_args.get(), user_gesture,
                            info);
 }
 
 EventRouter::EventRouter(BrowserContext* browser_context,
                          ExtensionPrefs* extension_prefs)
     : browser_context_(browser_context),
       extension_prefs_(extension_prefs),
       extension_registry_observer_(this),
       listeners_(this) {
   registrar_.Add(this,
                  extensions::NOTIFICATION_EXTENSION_ENABLED,
                  content::Source<BrowserContext>(browser_context_));
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context_));
 }
 
 EventRouter::~EventRouter() {
   for (auto* process : observed_process_set_)
     process->RemoveObserver(this);
 }
 
 void EventRouter::AddEventListener(const std::string& event_name,
                                    content::RenderProcessHost* process,
                                    const std::string& extension_id) {
   listeners_.AddListener(EventListener::ForExtension(
       event_name, extension_id, process, std::unique_ptr<DictionaryValue>()));
 }
 
+void EventRouter::AddServiceWorkerEventListener(
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    const ExtensionId& extension_id,
+    int worker_thread_id) {
+  listeners_.AddListener(EventListener::ForExtensionServiceWorker(
+      event_name, extension_id, process, worker_thread_id,
+      std::unique_ptr<DictionaryValue>()));

[Devlin, 2017/05/24 17:58:25]

nit: could just pass nullptr

[lazyboy, 2017/05/25 01:33:43]

Done.

+}
+
 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, std::unique_ptr<DictionaryValue>());
   listeners_.RemoveListener(listener.get());
 }
 
+void EventRouter::RemoveServiceWorkerEventListener(
+    const std::string& event_name,
+    content::RenderProcessHost* process,
+    const ExtensionId& extension_id,
+    int worker_thread_id) {
+  std::unique_ptr<EventListener> listener =
+      EventListener::ForExtensionServiceWorker(
+          event_name, extension_id, process, worker_thread_id,
+          std::unique_ptr<DictionaryValue>());
+  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, std::unique_ptr<DictionaryValue>()));
 }
 
 void EventRouter::RemoveEventListenerForURL(const std::string& event_name,
                                             content::RenderProcessHost* process,
                                             const GURL& listener_url) {
@@ skipping 56 matching lines @@
   observed_process_set_.erase(host);
   host->RemoveObserver(this);
 }
 
 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 std::string& extension_id) {
-  bool is_new = listeners_.AddListener(EventListener::ForExtension(
-      event_name, extension_id, NULL, std::unique_ptr<DictionaryValue>()));
+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,
+                std::unique_ptr<DictionaryValue>())
+          : EventListener::ForExtension(event_name, extension_id, nullptr,
+                                        std::unique_ptr<DictionaryValue>()));
 
   if (is_new) {
-    std::set<std::string> events = GetRegisteredEvents(extension_id);
+    std::set<std::string> events = GetRegisteredEvents(
+        extension_id, is_for_service_worker ? kRegisteredServiceWorkerEvents
+                                            : kRegisteredLazyEvents);
     bool prefs_is_new = events.insert(event_name).second;
-    if (prefs_is_new)
-      SetRegisteredEvents(extension_id, events);
+    if (prefs_is_new) {
+      SetRegisteredEvents(extension_id, events,
+                          is_for_service_worker ? kRegisteredServiceWorkerEvents
+                                                : kRegisteredLazyEvents);
+    }
   }
 }
 
-void EventRouter::RemoveLazyEventListener(const std::string& event_name,
-                                          const std::string& extension_id) {
-  std::unique_ptr<EventListener> listener = EventListener::ForExtension(
-      event_name, extension_id, NULL, std::unique_ptr<DictionaryValue>());
+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,
+                std::unique_ptr<DictionaryValue>())
+          : EventListener::ForExtension(event_name, extension_id, nullptr,
+                                        std::unique_ptr<DictionaryValue>());
   bool did_exist = listeners_.RemoveListener(listener.get());
 
   if (did_exist) {
-    std::set<std::string> events = GetRegisteredEvents(extension_id);
+    std::set<std::string> events =
+        GetRegisteredEvents(extension_id, kRegisteredLazyEvents);

[Devlin, 2017/05/24 17:58:25]

Do we need to check is_for_service_worker here?

[lazyboy, 2017/05/25 01:33:43]

Done.

     bool prefs_did_exist = events.erase(event_name) > 0;
     DCHECK(prefs_did_exist);
-    SetRegisteredEvents(extension_id, events);
+    SetRegisteredEvents(extension_id, events, kRegisteredLazyEvents);
   }
 }
 
+void EventRouter::AddLazyEventListener(const std::string& event_name,
+                                       const ExtensionId& extension_id) {
+  AddLazyEventListenerImpl(event_name, extension_id, kNonWorkerThreadId);
+}
+
+void EventRouter::RemoveLazyEventListener(const std::string& event_name,
+                                          const ExtensionId& extension_id) {
+  RemoveLazyEventListenerImpl(event_name, extension_id, kNonWorkerThreadId);
+}
+
+void EventRouter::AddLazyServiceWorkerEventListener(
+    const std::string& event_name,
+    const ExtensionId& extension_id,
+    int worker_thread_id) {
+  AddLazyEventListenerImpl(event_name, extension_id, worker_thread_id);
+}
+
+void EventRouter::RemoveLazyServiceWorkerEventListener(
+    const std::string& event_name,
+    const ExtensionId& extension_id,
+    int worker_thread_id) {
+  RemoveLazyEventListenerImpl(event_name, extension_id, worker_thread_id);
+}
+
+// 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,
       std::unique_ptr<DictionaryValue>(filter.DeepCopy())));
 
   if (add_lazy_listener) {
     bool added = listeners_.AddListener(EventListener::ForExtension(
-        event_name, extension_id, NULL,
+        event_name, extension_id, nullptr,
         std::unique_ptr<DictionaryValue>(filter.DeepCopy())));
 
     if (added)
       AddFilterToEvent(event_name, extension_id, &filter);
   }
 }
 
+// TODO(lazyboy): Support filters for extension SW events.
 void EventRouter::RemoveFilteredEventListener(
     const std::string& event_name,
     content::RenderProcessHost* process,
     const std::string& extension_id,
     const base::DictionaryValue& filter,
     bool remove_lazy_listener) {
   std::unique_ptr<EventListener> listener = EventListener::ForExtension(
       event_name, extension_id, process,
       std::unique_ptr<DictionaryValue>(filter.DeepCopy()));
 
@@ skipping 11 matching lines @@
 bool EventRouter::HasEventListener(const std::string& event_name) {
   return listeners_.HasListenerForEvent(event_name);
 }
 
 bool EventRouter::ExtensionHasEventListener(const std::string& extension_id,
                                             const std::string& event_name) {
   return listeners_.HasListenerForExtension(extension_id, event_name);
 }
 
 std::set<std::string> EventRouter::GetRegisteredEvents(
-    const std::string& extension_id) const {
+    const std::string& extension_id,
+    const char* pref_key) const {
   std::set<std::string> events;
   const ListValue* events_value = NULL;
 
-  if (!extension_prefs_ ||
-      !extension_prefs_->ReadPrefAsList(
-           extension_id, kRegisteredEvents, &events_value)) {
+  if (!extension_prefs_ || !extension_prefs_->ReadPrefAsList(
+                               extension_id, pref_key, &events_value)) {
     return events;
   }
 
   for (size_t i = 0; i < events_value->GetSize(); ++i) {
     std::string event;
     if (events_value->GetString(i, &event))
       events.insert(event);
   }
   return events;
 }
 
+void EventRouter::ClearRegisteredEventsForTest(
+    const ExtensionId& extension_id) {
+  SetRegisteredEvents(extension_id, std::set<std::string>(),
+                      kRegisteredLazyEvents);
+  SetRegisteredEvents(extension_id, std::set<std::string>(),
+                      kRegisteredServiceWorkerEvents);
+}
+
 void EventRouter::RemoveFilterFromEvent(const std::string& event_name,
                                         const std::string& extension_id,
                                         const DictionaryValue* filter) {
   ExtensionPrefs::ScopedDictionaryUpdate update(
       extension_prefs_, extension_id, kFilteredEvents);
   DictionaryValue* filtered_events = update.Get();
   ListValue* filter_list = NULL;
   if (!filtered_events ||
       !filtered_events->GetListWithoutPathExpansion(event_name, &filter_list)) {
     return;
   }
 
   for (size_t i = 0; i < filter_list->GetSize(); i++) {
     DictionaryValue* filter_value = nullptr;
     CHECK(filter_list->GetDictionary(i, &filter_value));
     if (filter_value->Equals(filter)) {
       filter_list->Remove(i, nullptr);
       break;
     }
   }
 }
 
 const DictionaryValue* EventRouter::GetFilteredEvents(
-    const std::string& extension_id) {
-  const DictionaryValue* events = NULL;
-  extension_prefs_->ReadPrefAsDictionary(
-      extension_id, kFilteredEvents, &events);
+    const std::string& extension_id,
+    const char* pref_key) {
+  const DictionaryValue* events = nullptr;
+  extension_prefs_->ReadPrefAsDictionary(extension_id, pref_key, &events);
   return events;
 }
 
 void EventRouter::BroadcastEvent(std::unique_ptr<Event> event) {
   DispatchEventImpl(std::string(), linked_ptr<Event>(event.release()));
 }
 
 void EventRouter::DispatchEventToExtension(const std::string& extension_id,
                                            std::unique_ptr<Event> event) {
   DCHECK(!extension_id.empty());
@@ skipping 11 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));
-
   std::set<const EventListener*> listeners(
       listeners_.GetEventListeners(*event));
 
   std::set<EventDispatchIdentifier> already_dispatched;
 
   // 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 (restrict_to_extension_id.empty() ||
         restrict_to_extension_id == listener->extension_id()) {
-      if (listener->IsLazy()) {
+      // TODO(lazyboy): Support lazy listeners for extension SW events.
+      if (listener->IsLazy() && !listener->IsForServiceWorker()) {
         DispatchLazyEvent(listener->extension_id(), event, &already_dispatched,
                           listener->filter());
       }
     }
   }
 
   for (const EventListener* listener : listeners) {
     if (restrict_to_extension_id.empty() ||
         restrict_to_extension_id == listener->extension_id()) {
       if (listener->process()) {
         EventDispatchIdentifier dispatch_id(listener->GetBrowserContext(),
-                                            listener->extension_id());
+                                            listener->extension_id(),
+                                            listener->worker_thread_id());
         if (!base::ContainsKey(already_dispatched, dispatch_id)) {
           DispatchEventToProcess(listener->extension_id(),
                                  listener->listener_url(), listener->process(),
-                                 event, listener->filter(),
-                                 false /* did_enqueue */);
+                                 listener->worker_thread_id(), event,
+                                 listener->filter(), false /* did_enqueue */);
         }
       }
     }
   }
 }
 
 void EventRouter::DispatchLazyEvent(
     const std::string& extension_id,
     const linked_ptr<Event>& event,
     std::set<EventDispatchIdentifier>* already_dispatched,
     const base::DictionaryValue* listener_filter) {
   // Check both the original and the incognito browser context to see if we
   // should load a lazy bg page to handle the event. The latter case
   // occurs in the case of split-mode extensions.
   const Extension* extension =
       ExtensionRegistry::Get(browser_context_)->enabled_extensions().GetByID(
           extension_id);
   if (!extension)
     return;
 
   if (MaybeLoadLazyBackgroundPageToDispatchEvent(browser_context_, extension,
                                                  event, listener_filter)) {
-    already_dispatched->insert(std::make_pair(browser_context_, extension_id));
+    already_dispatched->insert(
+        std::make_tuple(browser_context_, extension_id, kNonWorkerThreadId));

[Devlin, 2017/05/24 17:58:25]

It's arguable we wouldn't need this.  We could also just dispatch the event to
the extension process and let the renderer figure it out.  Not sure if one is
preferable, so I'll leave it up to you.

[lazyboy, 2017/05/25 01:33:43]

Right now there isn't a way to send events to *all* the workers in an extension
process. Unfortunately this means we will send multiple IPCs in this case.

   }
 
   ExtensionsBrowserClient* browser_client = ExtensionsBrowserClient::Get();
   if (browser_client->HasOffTheRecordContext(browser_context_) &&
       IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* incognito_context =
         browser_client->GetOffTheRecordContext(browser_context_);
     if (MaybeLoadLazyBackgroundPageToDispatchEvent(incognito_context, extension,
                                                    event, listener_filter)) {
       already_dispatched->insert(
-          std::make_pair(incognito_context, extension_id));
+          std::make_tuple(incognito_context, extension_id, kNonWorkerThreadId));
     }
   }
 }
 
 void EventRouter::DispatchEventToProcess(
     const std::string& extension_id,
     const GURL& listener_url,
     content::RenderProcessHost* process,
+    int worker_thread_id,
     const linked_ptr<Event>& event,
     const base::DictionaryValue* listener_filter,
     bool did_enqueue) {
   BrowserContext* listener_context = process->GetBrowserContext();
   ProcessMap* process_map = ProcessMap::Get(listener_context);
 
   // NOTE: |extension| being NULL does not necessarily imply that this event
   // shouldn't be dispatched. Events can be dispatched to WebUI and webviews as
   // well.  It all depends on what GetMostLikelyContextType returns.
   const Extension* extension =
@@ skipping 47 matching lines @@
     return;
   }
 
   if (!event->will_dispatch_callback.is_null() &&
       !event->will_dispatch_callback.Run(listener_context, extension,
                                          event.get(), listener_filter)) {
     return;
   }
 
   int event_id = g_extension_event_id.GetNext();
-  DispatchExtensionMessage(process, listener_context, extension_id, event_id,
-                           event->event_name, event->event_args.get(),
-                           event->user_gesture, event->filter_info);
+  DispatchExtensionMessage(process, worker_thread_id, listener_context,
+                           extension_id, event_id, event->event_name,
+                           event->event_args.get(), event->user_gesture,
+                           event->filter_info);
 
   if (extension) {
     ReportEvent(event->histogram_value, extension, did_enqueue);
     IncrementInFlightEvents(listener_context, extension, event_id,
                             event->event_name);
   }
 }
 
 bool EventRouter::CanDispatchEventToBrowserContext(
     BrowserContext* context,
@@ skipping 151 matching lines @@
     }
   }
 }
 
 void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
                                        ExtensionHost* host) {
   if (!host)
     return;
 
   if (listeners_.HasProcessListener(host->render_process_host(),
+                                    kNonWorkerThreadId,
                                     host->extension()->id())) {
     DispatchEventToProcess(host->extension()->id(), host->GetURL(),
-                           host->render_process_host(), event, nullptr,
-                           true /* did_enqueue */);
+                           host->render_process_host(), kNonWorkerThreadId,
+                           event, nullptr, true /* did_enqueue */);
   }
 }
 
 void EventRouter::SetRegisteredEvents(const std::string& extension_id,
-                                      const std::set<std::string>& events) {
+                                      const std::set<std::string>& events,
+                                      const char* pref_key) {
   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);
   }
-  extension_prefs_->UpdateExtensionPref(extension_id, kRegisteredEvents,
+  extension_prefs_->UpdateExtensionPref(extension_id, pref_key,
                                         std::move(events_value));
 }
 
 void EventRouter::AddFilterToEvent(const std::string& event_name,
                                    const std::string& extension_id,
                                    const DictionaryValue* filter) {
   ExtensionPrefs::ScopedDictionaryUpdate update(extension_prefs_, extension_id,
                                                 kFilteredEvents);
   DictionaryValue* filtered_events = update.Get();
   if (!filtered_events)
@@ skipping 28 matching lines @@
     }
     default:
       NOTREACHED();
   }
 }
 
 void EventRouter::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   // Add all registered lazy listeners to our cache.
   std::set<std::string> registered_events =
-      GetRegisteredEvents(extension->id());
+      GetRegisteredEvents(extension->id(), kRegisteredLazyEvents);
   listeners_.LoadUnfilteredLazyListeners(extension->id(), registered_events);
-  const DictionaryValue* filtered_events = GetFilteredEvents(extension->id());
+  // TODO(lazyboy): Load extension SW lazy events.
+  const DictionaryValue* filtered_events =
+      GetFilteredEvents(extension->id(), kRegisteredLazyEvents);
   if (filtered_events)
     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());
 }
@@ skipping 53 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