ServiceWorker: Introduce ExtendableMessageEvent to replace MessageEvent

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 "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 232 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FetchEvent, OnFetchEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_InstallEvent, OnInstallEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SyncEvent, OnSyncEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginConnectEvent,
                         OnCrossOriginConnectEvent)
-    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ClientMessageEvent,
+                        OnClientMessageEvent)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_WorkerMessageEvent,
+                        OnWorkerMessageEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
                         OnCrossOriginMessageToWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SendStashedMessagePorts,
                         OnSendStashedMessagePorts)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients, OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
                         OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
@@ skipping 261 matching lines @@
                                                   result));
 }
 
 void ServiceWorkerContextClient::didHandleCrossOriginConnectEvent(
     int request_id,
     bool accept_connection) {
   Send(new ServiceWorkerHostMsg_CrossOriginConnectEventFinished(
       GetRoutingID(), request_id, accept_connection));
 }
 
+void ServiceWorkerContextClient::didHandleMessageEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result) {
+  Send(new ServiceWorkerHostMsg_MessageEventFinished(GetRoutingID(),
+                                                     request_id));
+}
+
 blink::WebServiceWorkerNetworkProvider*
 ServiceWorkerContextClient::createServiceWorkerNetworkProvider(
     blink::WebDataSource* data_source) {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   scoped_ptr<ServiceWorkerNetworkProvider> provider(
       new ServiceWorkerNetworkProvider(
           MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER));
@@ skipping 121 matching lines @@
   if (!found)
     return;  // Cannot be associated with a registration in some tests.
 
   ServiceWorkerDispatcher* dispatcher =
       ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(sender_.get());
 
   // Register a registration and its version attributes with the dispatcher
   // living on the worker thread.
   scoped_ptr<WebServiceWorkerRegistrationImpl> registration(
       dispatcher->CreateServiceWorkerRegistration(info, false));
+  int provider_id = provider_context_->provider_id();
   registration->SetInstalling(
-      dispatcher->GetServiceWorker(attrs.installing, false));
+      dispatcher->GetServiceWorker(attrs.installing, provider_id, false));
   registration->SetWaiting(
-      dispatcher->GetServiceWorker(attrs.waiting, false));
+      dispatcher->GetServiceWorker(attrs.waiting, provider_id, false));
   registration->SetActive(
-      dispatcher->GetServiceWorker(attrs.active, false));
+      dispatcher->GetServiceWorker(attrs.active, provider_id, false));
 
   proxy_->setRegistration(registration.release());
 }
 
 void ServiceWorkerContextClient::OnActivateEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnActivateEvent");
   activate_start_timings_[request_id] = base::TimeTicks::Now();
   proxy_->dispatchActivateEvent(request_id);
 }
@@ skipping 82 matching lines @@
     const NavigatorConnectClient& client) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnCrossOriginConnectEvent");
   blink::WebCrossOriginServiceWorkerClient web_client;
   web_client.origin = client.origin;
   web_client.targetURL = client.target_url;
   web_client.clientID = client.message_port_id;
   proxy_->dispatchCrossOriginConnectEvent(request_id, web_client);
 }
 
-void ServiceWorkerContextClient::OnPostMessage(
+void ServiceWorkerContextClient::OnClientMessageEvent(
+    int request_id,
+    const ServiceWorkerClientInfo& client,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::OnPostEvent");
+               "ServiceWorkerContextClient::OnClientMessageEvent");
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreatePorts(
           sent_message_ports, new_routing_ids,
           main_thread_task_runner_);
 
   // dispatchMessageEvent is expected to execute onmessage function
   // synchronously.
   base::TimeTicks before = base::TimeTicks::Now();
-  proxy_->dispatchMessageEvent(message, ports);
-  UMA_HISTOGRAM_MEDIUM_TIMES(
-      "ServiceWorker.MessageEvent.Time",
-      base::TimeTicks::Now() - before);
+  blink::WebServiceWorkerClientInfo web_client =
+      ToWebServiceWorkerClientInfo(client);
+  proxy_->dispatchMessageEvent(request_id, web_client, message, ports);
+  UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.MessageEvent.Time",
+                             base::TimeTicks::Now() - before);
+}
+
+void ServiceWorkerContextClient::OnWorkerMessageEvent(
+    int request_id,
+    const ServiceWorkerObjectInfo& worker,
+    const base::string16& message,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
+    const std::vector<int>& new_routing_ids) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::OnWorkerMessageEvent");
+  blink::WebMessagePortChannelArray ports =
+      WebMessagePortChannelImpl::CreatePorts(
+          sent_message_ports, new_routing_ids, main_thread_task_runner_);
+
+  // dispatchMessageEvent is expected to execute onmessage function
+  // synchronously.
+  base::TimeTicks before = base::TimeTicks::Now();
+  ServiceWorkerDispatcher* dispatcher =
+      ServiceWorkerDispatcher::GetOrCreateThreadSpecificInstance(sender_.get());
+  blink::WebServiceWorker* service_worker = dispatcher->GetServiceWorker(
+      worker, provider_context_->provider_id(), false);
+  proxy_->dispatchMessageEvent(request_id, service_worker, message, ports);
+  UMA_HISTOGRAM_MEDIUM_TIMES("ServiceWorker.MessageEvent.Time",
+                             base::TimeTicks::Now() - before);
 }
 
 void ServiceWorkerContextClient::OnCrossOriginMessageToWorker(
     const NavigatorConnectClient& client,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnCrossOriginMessageToWorker");
   blink::WebMessagePortChannelArray ports =
@@ skipping 159 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content