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

extensions/renderer/dispatcher.cc

 // Copyright 2014 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/renderer/dispatcher.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 199 matching lines @@
 // last removed listener, rather than for each subsequent listener; the browser
 // only cares if an event has >0 associated listeners.
 // TODO(devlin): Use this in EventBindings, too, and add logic for lazy
 // background pages.
 void SendEventListenersIPC(binding::EventListenersChanged changed,
                            ScriptContext* context,
                            const std::string& event_name,
                            const base::DictionaryValue* filter,
                            bool was_manual) {
   bool lazy = ExtensionFrameHelper::IsContextForEventPage(context);
+  const int worker_thread_id = content::WorkerThread::GetCurrentId();
   std::string extension_id = context->GetExtensionID();
   content::RenderThread* render_thread = content::RenderThread::Get();
 
   if (filter) {
     if (changed == binding::EventListenersChanged::HAS_LISTENERS) {
       render_thread->Send(new ExtensionHostMsg_AddFilteredListener(
           extension_id, event_name, *filter, lazy));
     } else {
       DCHECK_EQ(binding::EventListenersChanged::NO_LISTENERS, changed);
       render_thread->Send(new ExtensionHostMsg_RemoveFilteredListener(
           extension_id, event_name, *filter, lazy));
     }
   } else {
     if (changed == binding::EventListenersChanged::HAS_LISTENERS) {
       render_thread->Send(new ExtensionHostMsg_AddListener(
-          extension_id, context->url(), event_name));
+          extension_id, context->url(), event_name, worker_thread_id));
       if (lazy) {
-        render_thread->Send(
-            new ExtensionHostMsg_AddLazyListener(extension_id, event_name));
+        render_thread->Send(new ExtensionHostMsg_AddLazyListener(
+            extension_id, event_name, worker_thread_id));
       }
     } else {
       DCHECK_EQ(binding::EventListenersChanged::NO_LISTENERS, changed);
       render_thread->Send(new ExtensionHostMsg_RemoveListener(
-          extension_id, context->url(), event_name));
+          extension_id, context->url(), event_name, worker_thread_id));
       if (lazy && was_manual) {
-        render_thread->Send(
-            new ExtensionHostMsg_RemoveLazyListener(extension_id, event_name));
+        render_thread->Send(new ExtensionHostMsg_RemoveLazyListener(
+            extension_id, event_name, worker_thread_id));
       }
     }
   }
 }
 
+bool WorkerMightHandleMessage(const IPC::Message& message) {

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

Do we need this when the WorkerThreadDispatcher also checks message type?

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

Removed.

+  return message.type() == ExtensionMsg_DispatchEvent::ID;
+}
+
 base::LazyInstance<WorkerScriptContextSet>::DestructorAtExit
     g_worker_script_context_set = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Note that we can't use Blink public APIs in the constructor becase Blink
 // is not initialized at the point we create Dispatcher.
 Dispatcher::Dispatcher(DispatcherDelegate* delegate)
     : delegate_(delegate),
       content_watcher_(new ContentWatcher()),
@@ skipping 201 matching lines @@
     return;
   }
 
   ScriptContext* context = new ScriptContext(
       v8_context, nullptr, extension, Feature::SERVICE_WORKER_CONTEXT,
       extension, Feature::SERVICE_WORKER_CONTEXT);
   context->set_url(url);
 
   if (ExtensionsClient::Get()->ExtensionAPIEnabledInExtensionServiceWorkers()) {
     WorkerThreadDispatcher::Get()->AddWorkerData(service_worker_version_id,
-                                                 &source_map_);
+                                                 context, &source_map_);
 
     // TODO(lazyboy): Make sure accessing |source_map_| in worker thread is
     // safe.
     context->set_module_system(
         base::MakeUnique<ModuleSystem>(context, &source_map_));
 
     ModuleSystem* module_system = context->module_system();
     // Enable natives in startup.
     ModuleSystem::NativesEnabledScope natives_enabled_scope(module_system);
     ExtensionBindingsSystem* worker_bindings_system =
@@ skipping 396 matching lines @@
       std::unique_ptr<NativeHandler>(new IdGeneratorCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "runtime",
       std::unique_ptr<NativeHandler>(new RuntimeCustomBindings(context)));
   module_system->RegisterNativeHandler(
       "display_source",
       base::MakeUnique<DisplaySourceCustomBindings>(context, bindings_system));
 }
 
 bool Dispatcher::OnControlMessageReceived(const IPC::Message& message) {
+  if (WorkerMightHandleMessage(message) &&
+      WorkerThreadDispatcher::Get()->OnControlMessageReceived(message)) {
+    return true;
+  }
+
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(Dispatcher, message)
   IPC_MESSAGE_HANDLER(ExtensionMsg_ActivateExtension, OnActivateExtension)
   IPC_MESSAGE_HANDLER(ExtensionMsg_CancelSuspend, OnCancelSuspend)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DeliverMessage, OnDeliverMessage)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnConnect, OnDispatchOnConnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchOnDisconnect, OnDispatchOnDisconnect)
   IPC_MESSAGE_HANDLER(ExtensionMsg_Loaded, OnLoaded)
   IPC_MESSAGE_HANDLER(ExtensionMsg_MessageInvoke, OnMessageInvoke)
   IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchEvent, OnDispatchEvent)
@@ skipping 573 matching lines @@
   // The "guestViewDeny" module must always be loaded last. It registers
   // error-providing custom elements for the GuestView types that are not
   // available, and thus all of those types must have been checked and loaded
   // (or not loaded) beforehand.
   if (context_type == Feature::BLESSED_EXTENSION_CONTEXT) {
     module_system->Require("guestViewDeny");
   }
 }
 
 }  // namespace extensions