[ServiceWorker] Mojofy extendable message event.

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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 "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 162 matching lines @@
   using ClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>>;
   using ClaimClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>>;
   using ClientCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientCallbacks>>;
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
+  using ExtendableMessageEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchExtendableMessageEventCallback>>;
   using NavigationPreloadRequestsMap = IDMap<
       std::unique_ptr<ServiceWorkerContextClient::NavigationPreloadRequest>>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : event_dispatcher_binding(owner),
         weak_factory(owner),
         proxy_weak_factory(owner->proxy_) {}
 
   ~WorkerContextData() {
     DCHECK(thread_checker.CalledOnValidThread());
@@ skipping 12 matching lines @@
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
   // Pending callbacks for Fetch Events.
   FetchEventCallbacksMap fetch_event_callbacks;
 
+  // Pending callbacks for Extendable Message Events.
+  ExtendableMessageEventCallbacksMap message_event_callbacks;
+
   // Pending navigation preload requests.
   NavigationPreloadRequestsMap preload_requests;
 
   base::ThreadChecker thread_checker;
   base::WeakPtrFactory<ServiceWorkerContextClient> weak_factory;
   base::WeakPtrFactory<blink::WebServiceWorkerContextProxy> proxy_weak_factory;
 };
 
 class ServiceWorkerContextClient::NavigationPreloadRequest final
     : public mojom::URLLoaderClient {
@@ skipping 164 matching lines @@
 ServiceWorkerContextClient::~ServiceWorkerContextClient() {}
 
 void ServiceWorkerContextClient::OnMessageReceived(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   CHECK_EQ(embedded_worker_id_, embedded_worker_id);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerContextClient, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ExtendableMessageEvent,
-                        OnExtendableMessageEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationCloseEvent,
                         OnNotificationCloseEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClient, OnDidGetClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients, OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
@@ skipping 159 matching lines @@
            &context_->sync_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
   // Aborts the all pending fetch event callbacks.
   for (WorkerContextData::FetchEventCallbacksMap::iterator it(
            &context_->fetch_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
+  // Aborts the all pending extendable message event callbacks.
+  for (WorkerContextData::ExtendableMessageEventCallbacksMap::iterator it(
+           &context_->message_event_callbacks);
+       !it.IsAtEnd(); it.Advance()) {
+    it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
+  }
 
   // We have to clear callbacks now, as they need to be freed on the
   // same thread.
   context_.reset();
 
   // This also lets the message filter stop dispatching messages to
   // this client.
   g_worker_client_tls.Pointer()->Set(NULL);
 
   GetContentClient()->renderer()->WillDestroyServiceWorkerContextOnWorkerThread(
@@ skipping 69 matching lines @@
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_ActivateEventFinished(
       GetRoutingID(), request_id, result,
       base::Time::FromDoubleT(event_dispatch_time)));
 }
 
 void ServiceWorkerContextClient::didHandleExtendableMessageEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  Send(new ServiceWorkerHostMsg_ExtendableMessageEventFinished(
-      GetRoutingID(), request_id, result,
-      base::Time::FromDoubleT(event_dispatch_time)));
+  const DispatchExtendableMessageEventCallback* callback =
+      context_->message_event_callbacks.Lookup(request_id);
+  if (!callback)

[shimazu, 2016/12/02 04:00:33]

DCHECK(callback) is better here because IIUC callback must not null here.

[leonhsl(Using Gerrit), 2016/12/02 08:36:44]

This is following didHandleSyncEvent(), |callback| would be null in case of no
instance corresponding with |request_id|.

[shimazu, 2016/12/05 03:40:21]

Oops, I didn't realize that. 
Hmm.. I don't want to use early return here because in this case null-callback
situation is likely to be a bug. 

horo@-san: WDYT?

[horo, 2016/12/05 04:13:16]

I prefer DCHECK(callback) too.

[leonhsl(Using Gerrit), 2016/12/06 08:54:39]

Done.

+    return;
+  if (result == blink::WebServiceWorkerEventResultCompleted) {
+    callback->Run(SERVICE_WORKER_OK,
+                  base::Time::FromDoubleT(event_dispatch_time));
+  } else {
+    callback->Run(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED,
+                  base::Time::FromDoubleT(event_dispatch_time));
+  }
+  context_->message_event_callbacks.Remove(request_id);
 }
 
 void ServiceWorkerContextClient::didHandleInstallEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_InstallEventFinished(
       GetRoutingID(), request_id, result, proxy_->hasFetchEventHandler(),
       base::Time::FromDoubleT(event_dispatch_time)));
 }
@@ skipping 250 matching lines @@
   proxy_->setRegistration(
       WebServiceWorkerRegistrationImpl::CreateHandle(registration));
 }
 
 void ServiceWorkerContextClient::OnActivateEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnActivateEvent");
   proxy_->dispatchActivateEvent(request_id);
 }
 
-void ServiceWorkerContextClient::OnExtendableMessageEvent(
-    int request_id,
-    const ServiceWorkerMsg_ExtendableMessageEvent_Params& params) {
+void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
+    mojom::ExtendableMessageEventPtr event,
+    const DispatchExtendableMessageEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::OnExtendableMessageEvent");
+               "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
+  int request_id = context_->message_event_callbacks.Add(
+      base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
+
   blink::WebMessagePortChannelArray ports =
-      WebMessagePortChannelImpl::CreatePorts(params.message_ports,
-                                             params.new_routing_ids,
+      WebMessagePortChannelImpl::CreatePorts(event->message_ports,
+                                             event->new_routing_ids,
                                              main_thread_task_runner_);
-  if (params.source.client_info.IsValid()) {
+  if (event->source.client_info.IsValid()) {
     blink::WebServiceWorkerClientInfo web_client =
-        ToWebServiceWorkerClientInfo(params.source.client_info);
+        ToWebServiceWorkerClientInfo(event->source.client_info);
     proxy_->dispatchExtendableMessageEvent(
-        request_id, params.message, params.source_origin, ports, web_client);
+        request_id, event->message, event->source_origin, ports, web_client);
     return;
   }
 
-  DCHECK(params.source.service_worker_info.IsValid());
+  DCHECK(event->source.service_worker_info.IsValid());
   std::unique_ptr<ServiceWorkerHandleReference> handle =
-      ServiceWorkerHandleReference::Adopt(params.source.service_worker_info,
+      ServiceWorkerHandleReference::Adopt(event->source.service_worker_info,
                                           sender_.get());
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(
           sender_.get(), main_thread_task_runner_.get());
   scoped_refptr<WebServiceWorkerImpl> worker =
       dispatcher->GetOrCreateServiceWorker(std::move(handle));
   proxy_->dispatchExtendableMessageEvent(
-      request_id, params.message, params.source_origin, ports,
+      request_id, event->message, event->source_origin, ports,
       WebServiceWorkerImpl::CreateHandle(worker));
 }
 
 void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnInstallEvent");
   proxy_->dispatchInstallEvent(request_id);
 }
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
@@ skipping 295 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content