ServiceWorker: Introduce ExtendableMessageEvent to replace MessageEvent

content/browser/service_worker/service_worker_version.cc

Index: content/browser/service_worker/service_worker_version.cc
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index 802ed2e7311ad813ac91b579c6338dcc31bbdf32..c748b3dc712c4ee81d3df7bad7080e55070d795d 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -676,6 +676,7 @@ void ServiceWorkerVersion::DeferScheduledUpdate() {
 }
 
 void ServiceWorkerVersion::DispatchMessageEvent(
+    ServiceWorkerProviderHost* provider_host,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
@@ -683,21 +684,44 @@ void ServiceWorkerVersion::DispatchMessageEvent(
     MessagePortService::GetInstance()->HoldMessages(port.id);
   }
 
-  DispatchMessageEventInternal(message, sent_message_ports, callback);
+  if (provider_host->provider_type() ==
+      SERVICE_WORKER_PROVIDER_FOR_CONTROLLER) {
+    ServiceWorkerObjectInfo worker_info =
+        provider_host->GetOrCreateServiceWorkerHandle(
+            provider_host->running_hosted_version());
+    DispatchWorkerMessageEventInternal(message, sent_message_ports, worker_info,
+                                       callback);
+  } else if (provider_host->provider_type() ==
+             SERVICE_WORKER_PROVIDER_FOR_WINDOW) {
+    provider_host->GetWindowClientInfo(
+        base::Bind(&ServiceWorkerVersion::DispatchClientMessageEventInternal,
+                   weak_factory_.GetWeakPtr(), message, sent_message_ports,
+                   provider_host->client_uuid(), callback));
+  } else {
+    ServiceWorkerClientInfo client_info(blink::WebPageVisibilityStateHidden,
+                                        false,  // is_focused
+                                        provider_host->document_url(),
+                                        REQUEST_CONTEXT_FRAME_TYPE_NONE,
+                                        provider_host->client_type());
+    DispatchClientMessageEventInternal(message, sent_message_ports,
+                                       provider_host->client_uuid(), callback,
+                                       client_info);
+  }
 }
 
-void ServiceWorkerVersion::DispatchMessageEventInternal(
+void ServiceWorkerVersion::DispatchWorkerMessageEventInternal(
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
+    const ServiceWorkerObjectInfo& worker_info,
     const StatusCallback& callback) {
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(
         &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
         base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
-        base::Bind(&self::DispatchMessageEventInternal,
+        base::Bind(&self::DispatchWorkerMessageEventInternal,
                    weak_factory_.GetWeakPtr(), message, sent_message_ports,
-                   callback)));
+                   worker_info, callback)));
     return;
   }
 
@@ -705,14 +729,55 @@ void ServiceWorkerVersion::DispatchMessageEventInternal(
   // event becomes extendable, round-trip event. (crbug.com/498596)
   RestartTick(&idle_time_);
 
+  int request_id = AddRequest(callback, &message_callbacks_, REQUEST_MESSAGE);
+  MessagePortMessageFilter* filter =
+      embedded_worker_->message_port_message_filter();
+  std::vector<int> new_routing_ids;
+  filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
+  ServiceWorkerStatusCode status = embedded_worker_->SendMessage(
+      ServiceWorkerMsg_WorkerMessageEvent(request_id, worker_info, message,
+                                          sent_message_ports, new_routing_ids));
+  if (status != SERVICE_WORKER_OK) {
+    message_callbacks_.Remove(request_id);
+    RunSoon(base::Bind(callback, status));
+  }
+}
+
+void ServiceWorkerVersion::DispatchClientMessageEventInternal(
+    const base::string16& message,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
+    const std::string& client_uuid,
+    const StatusCallback& callback,
+    const ServiceWorkerClientInfo& client_info) {
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+        base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
+        base::Bind(&self::DispatchClientMessageEventInternal,
+                   weak_factory_.GetWeakPtr(), message, sent_message_ports,
+                   client_uuid, callback, client_info)));
+    return;
+  }
+
+  // TODO(kinuko): Cleanup this (and corresponding unit test) when message
+  // event becomes extendable, round-trip event. (crbug.com/498596)
+  RestartTick(&idle_time_);
+
+  int request_id = AddRequest(callback, &message_callbacks_, REQUEST_MESSAGE);
+  ServiceWorkerClientInfo client(client_info);
+  client.client_uuid = client_uuid;
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
-      embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
-          message, sent_message_ports, new_routing_ids));
-  RunSoon(base::Bind(callback, status));
+      embedded_worker_->SendMessage(ServiceWorkerMsg_ClientMessageEvent(
+          request_id, client, message, sent_message_ports, new_routing_ids));
+  if (status != SERVICE_WORKER_OK) {
+    message_callbacks_.Remove(request_id);
+    RunSoon(base::Bind(callback, status));
+  }
 }
 
 void ServiceWorkerVersion::DispatchInstallEvent(
@@ -1188,6 +1253,8 @@ bool ServiceWorkerVersion::OnMessageReceived(const IPC::Message& message) {
                         OnGeofencingEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CrossOriginConnectEventFinished,
                         OnCrossOriginConnectEventFinished)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_MessageEventFinished,
+                        OnMessageEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_OpenWindow,
                         OnOpenWindow)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetCachedMetadata,
@@ -1444,6 +1511,20 @@ void ServiceWorkerVersion::OnCrossOriginConnectEventFinished(
                                    request_id);
 }
 
+void ServiceWorkerVersion::OnMessageEventFinished(int request_id) {
+  TRACE_EVENT1("ServiceWorker", "ServiceWorkerVersion::OnMessageEventFinished",
+               "Request id", request_id);
+  StatusCallback* callback = message_callbacks_.Lookup(request_id);
+  if (!callback) {
+    NOTREACHED() << "Got unexpected message: " << request_id;
+    return;
+  }
+
+  scoped_refptr<ServiceWorkerVersion> protect(this);
+  callback->Run(SERVICE_WORKER_OK);
+  RemoveCallbackAndStopIfRedundant(&message_callbacks_, request_id);
+}
+
 void ServiceWorkerVersion::OnOpenWindow(int request_id, GURL url) {
   // Just abort if we are shutting down.
   if (!context_)
@@ -2039,6 +2120,9 @@ bool ServiceWorkerVersion::OnRequestTimeout(const RequestInfo& info) {
       return RunIDMapCallback(&cross_origin_connect_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT,
                               false /* accept_connection */);
+    case REQUEST_MESSAGE:
+      return RunIDMapCallback(&message_callbacks_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
   }
   NOTREACHED() << "Got unexpected request type: " << info.type;
   return false;