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

extensions/renderer/worker_thread_dispatcher.cc

 // Copyright 2016 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/worker_thread_dispatcher.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/values.h"
 #include "content/public/child/worker_thread.h"
 #include "content/public/renderer/render_thread.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/feature_switch.h"
+#include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/extension_bindings_system.h"
 #include "extensions/renderer/js_extension_bindings_system.h"
 #include "extensions/renderer/native_extension_bindings_system.h"
 #include "extensions/renderer/service_worker_data.h"
 
 namespace extensions {
 
 namespace {
 
 base::LazyInstance<WorkerThreadDispatcher>::DestructorAtExit g_instance =
@@ skipping 54 matching lines @@
 }
 
 // static
 V8SchemaRegistry* WorkerThreadDispatcher::GetV8SchemaRegistry() {
   return GetServiceWorkerData()->v8_schema_registry();
 }
 
 // static
 bool WorkerThreadDispatcher::HandlesMessageOnWorkerThread(
     const IPC::Message& message) {
-  return message.type() == ExtensionMsg_ResponseWorker::ID;
+  return message.type() == ExtensionMsg_ResponseWorker::ID ||
+         message.type() == ExtensionMsg_DispatchEvent::ID;
 }
 
 // static
 void WorkerThreadDispatcher::ForwardIPC(int worker_thread_id,
                                         const IPC::Message& message) {
   WorkerThreadDispatcher::Get()->OnMessageReceivedOnWorkerThread(
       worker_thread_id, message);
 }
 
 bool WorkerThreadDispatcher::OnControlMessageReceived(
     const IPC::Message& message) {
   if (HandlesMessageOnWorkerThread(message)) {
     int worker_thread_id = base::kInvalidThreadId;
     bool found = base::PickleIterator(message).ReadInt(&worker_thread_id);

[dcheng, 2017/06/06 04:55:07]

Btw this seems pretty hard to understand. We should be able to assume this field
always exists right? This was previously a CHECK. Maybe this should be a routed
IPC...?

(A followup is OK for trying to make this routed, but in the short-term, it
seems like DCHECK(found)/CHECK(found) should be a reasonable thing to do still)

[lazyboy, 2017/06/06 19:12:00]

Yes, restored CHECK.
This was previously a CHECK. Maybe this should be a routed
Can we send a routed message to a child thread directly? This pattern is
borrowed from content/'s service worker code, e.g.
https://cs.chromium.org/chromium/src/content/child/worker_thread_message_filt...
We need to be able to pick the thread id to be able to dispatch the IPC to that
thread.

[dcheng, 2017/06/06 20:59:55]

Something something mojo I think. But in principle, there's no reason it
shouldn't be possible--fundamentally routable messages are just about unpickling
a known routing ID and then dispatching based off that.

-    CHECK(found && worker_thread_id > 0);
+    if (!found || worker_thread_id <= 0)

[dcheng, 2017/06/05 20:23:15]

Why would the worker_thread_id be < 0? Maybe just explicitly check for
worker_thread_id == kNonWorkerThreadId?

[lazyboy, 2017/06/05 21:12:06]

Done.

+      return false;
     base::TaskRunner* runner = GetTaskRunnerFor(worker_thread_id);
     bool task_posted = runner->PostTask(
         FROM_HERE, base::Bind(&WorkerThreadDispatcher::ForwardIPC,
                               worker_thread_id, message));
     DCHECK(task_posted) << "Could not PostTask IPC to worker thread.";
     return true;
   }
   return false;
 }
 
 void WorkerThreadDispatcher::OnMessageReceivedOnWorkerThread(
     int worker_thread_id,
     const IPC::Message& message) {
   CHECK_EQ(content::WorkerThread::GetCurrentId(), worker_thread_id);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WorkerThreadDispatcher, message)
     IPC_MESSAGE_HANDLER(ExtensionMsg_ResponseWorker, OnResponseWorker)
+    IPC_MESSAGE_HANDLER(ExtensionMsg_DispatchEvent, OnDispatchEvent)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   CHECK(handled);
 }
 
 base::TaskRunner* WorkerThreadDispatcher::GetTaskRunnerFor(
     int worker_thread_id) {
   base::AutoLock lock(task_runner_map_lock_);
   return task_runner_map_[worker_thread_id];
 }
@@ skipping 10 matching lines @@
   // TODO(devlin): Using the RequestSender directly here won't work with
   // NativeExtensionBindingsSystem (since there is no associated RequestSender
   // in that case). We should instead be going
   // ExtensionBindingsSystem::HandleResponse().
   ServiceWorkerData* data = g_data_tls.Pointer()->Get();
   WorkerThreadDispatcher::GetRequestSender()->HandleWorkerResponse(
       request_id, data->service_worker_version_id(), succeeded, response,
       error);
 }
 
+void WorkerThreadDispatcher::OnDispatchEvent(
+    const ExtensionMsg_DispatchEvent_Params& params,
+    const base::ListValue& event_args) {
+  ServiceWorkerData* data = g_data_tls.Pointer()->Get();
+  DCHECK(data);
+  data->bindings_system()->DispatchEventInContext(
+      params.event_name, &event_args, &params.filtering_info, data->context());
+}
+
 void WorkerThreadDispatcher::AddWorkerData(
     int64_t service_worker_version_id,
+    ScriptContext* context,
     ResourceBundleSourceMap* source_map) {
   ServiceWorkerData* data = g_data_tls.Pointer()->Get();
   if (!data) {
     std::unique_ptr<ExtensionBindingsSystem> bindings_system;
     if (FeatureSwitch::native_crx_bindings()->IsEnabled()) {
       bindings_system = base::MakeUnique<NativeExtensionBindingsSystem>(
           base::Bind(&SendRequestIPC), base::Bind(&SendEventListenersIPC));
     } else {
       bindings_system = base::MakeUnique<JsExtensionBindingsSystem>(
           source_map, base::MakeUnique<ServiceWorkerRequestSender>(
                           this, service_worker_version_id));
     }
     ServiceWorkerData* new_data = new ServiceWorkerData(
-        service_worker_version_id, std::move(bindings_system));
+        service_worker_version_id, context, std::move(bindings_system));
     g_data_tls.Pointer()->Set(new_data);
   }
 
   int worker_thread_id = base::PlatformThread::CurrentId();
   DCHECK_EQ(content::WorkerThread::GetCurrentId(), worker_thread_id);
   {
     base::AutoLock lock(task_runner_map_lock_);
     auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
     CHECK(task_runner);
     task_runner_map_[worker_thread_id] = task_runner;
@@ skipping 11 matching lines @@
 
   int worker_thread_id = base::PlatformThread::CurrentId();
   DCHECK_EQ(content::WorkerThread::GetCurrentId(), worker_thread_id);
   {
     base::AutoLock lock(task_runner_map_lock_);
     task_runner_map_.erase(worker_thread_id);
   }
 }
 
 }  // namespace extensions