[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 54 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>()));
+  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,
+    int worker_thread_id) {
+  listeners_.AddListener(EventListener::ForExtensionServiceWorker(
+      event_name, extension_id, process, 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, std::unique_ptr<DictionaryValue>());
+  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,
+    int worker_thread_id) {
+  std::unique_ptr<EventListener> listener =
+      EventListener::ForExtensionServiceWorker(
+          event_name, extension_id, process, 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, std::unique_ptr<DictionaryValue>()));
+  listeners_.AddListener(
+      EventListener::ForURL(event_name, listener_url, process, nullptr));
 }
 
 void EventRouter::RemoveEventListenerForURL(const std::string& event_name,
                                             content::RenderProcessHost* process,
                                             const GURL& listener_url) {
-  std::unique_ptr<EventListener> listener = EventListener::ForURL(
-      event_name, listener_url, process, std::unique_ptr<DictionaryValue>());
+  std::unique_ptr<EventListener> listener =
+      EventListener::ForURL(event_name, listener_url, process, nullptr);
   listeners_.RemoveListener(listener.get());
 }
 
 void EventRouter::RegisterObserver(Observer* observer,
                                    const std::string& event_name) {
   // Observing sub-event names like "foo.onBar/123" is not allowed.
   DCHECK(event_name.find('/') == std::string::npos);
   observers_[event_name] = observer;
 }
 
@@ skipping 42 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,

[Devlin, 2017/06/01 04:54:49]

Where possible, definition order should match declaration order

[lazyboy, 2017/06/01 23:33:29]

I've intentionally kept it this way, otherwise the diff becomes harder to
review. I'll wait to do that pass later.

[lazyboy, 2017/06/02 17:58:59]

Moved this after OnExtensionUnloaded to match .h in patch set #11

+                                           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));
 
   if (is_new) {
-    std::set<std::string> events = GetRegisteredEvents(extension_id);
+    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);
+      SetRegisteredEvents(extension_id, events, type);
   }
 }
 
-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, nullptr)
+          : EventListener::ForExtension(event_name, extension_id, nullptr,
+                                        nullptr);
   bool did_exist = listeners_.RemoveListener(listener.get());
 
   if (did_exist) {
-    std::set<std::string> events = GetRegisteredEvents(extension_id);
+    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);
+    SetRegisteredEvents(extension_id, events, type);
   }
 }
 
+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)
     return;
 
   bool added = listeners_.AddListener(EventListener::ForExtension(
       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 12 matching lines @@
   return listeners_.HasListenerForEvent(event_name);
 }
 
 bool EventRouter::ExtensionHasEventListener(
     const std::string& extension_id,
     const std::string& event_name) const {
   return listeners_.HasListenerForExtension(extension_id, event_name);
 }
 
 std::set<std::string> EventRouter::GetRegisteredEvents(
-    const std::string& extension_id) const {
+    const std::string& extension_id,
+    RegisteredEventType type) const {
   std::set<std::string> events;
   const ListValue* events_value = NULL;
 
-  if (!extension_prefs_ ||
-      !extension_prefs_->ReadPrefAsList(
-           extension_id, kRegisteredEvents, &events_value)) {
+  const char* pref_key = type == RegisteredEventType::kLazy
+                             ? kRegisteredLazyEvents
+                             : kRegisteredServiceWorkerEvents;
+  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>(),
+                      RegisteredEventType::kLazy);
+  SetRegisteredEvents(extension_id, std::set<std::string>(),
+                      RegisteredEventType::kServiceWorker);
+}
+
 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;
@@ skipping 38 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));
   }
 
   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 150 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,
+                                      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);
   }
-  extension_prefs_->UpdateExtensionPref(extension_id, kRegisteredEvents,
+  const char* pref_key = type == RegisteredEventType::kLazy
+                             ? kRegisteredLazyEvents
+                             : kRegisteredServiceWorkerEvents;
+  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 20 matching lines @@
     LazyBackgroundTaskQueue* queue =
         LazyBackgroundTaskQueue::Get(browser_context_);
     queue->AddPendingTask(browser_context_, extension->id(),
                           base::Bind(&DoNothing));
   }
 }
 
 void EventRouter::OnExtensionLoaded(content::BrowserContext* browser_context,
                                     const Extension* extension) {
   // Add all registered lazy listeners to our cache.
+  // TODO(lazyboy): Load extension SW lazy events.
   std::set<std::string> registered_events =
-      GetRegisteredEvents(extension->id());
+      GetRegisteredEvents(extension->id(), RegisteredEventType::kLazy);
   listeners_.LoadUnfilteredLazyListeners(extension->id(), registered_events);
+  // TODO(lazyboy): Load extension SW filtered events when they are available.
   const DictionaryValue* filtered_events = GetFilteredEvents(extension->id());
   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 54 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