ServiceWorker: Introduce ExtendableMessageEvent to replace MessageEvent

content/browser/service_worker/service_worker_version.cc

 // Copyright 2013 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/browser/service_worker/service_worker_version.h"
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 658 matching lines @@
       base::Bind(&ServiceWorkerVersion::FoundRegistrationForUpdate,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerVersion::DeferScheduledUpdate() {
   if (update_timer_.IsRunning())
     update_timer_.Reset();
 }
 
 void ServiceWorkerVersion::DispatchMessageEvent(
+    ServiceWorkerProviderHost* provider_host,
     const base::string16& message,
     const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   for (const TransferredMessagePort& port : sent_message_ports) {
     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;
   }
 
   // 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);
+  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(
     const StatusCallback& callback) {
   DCHECK_EQ(INSTALLING, status()) << status();
 
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(
         base::Bind(&RunTaskAfterStartWorker,
@@ skipping 455 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SyncEventFinished,
                         OnSyncEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_GeofencingEventFinished,
                         OnGeofencingEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_CrossOriginConnectEventFinished,
                         OnCrossOriginConnectEventFinished)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_MessageEventFinished,
+                        OnMessageEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_OpenWindow,
                         OnOpenWindow)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetCachedMetadata,
                         OnSetCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ClearCachedMetadata,
                         OnClearCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToClient,
                         OnPostMessageToClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FocusClient,
                         OnFocusClient)
@@ skipping 236 matching lines @@
     NOTREACHED() << "Got unexpected message: " << request_id;
     return;
   }
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   callback->Run(SERVICE_WORKER_OK, accept_connection);
   RemoveCallbackAndStopIfRedundant(&cross_origin_connect_callbacks_,
                                    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_)
     return;
 
   if (!url.is_valid()) {
     DVLOG(1) << "Received unexpected invalid URL from renderer process.";
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&KillEmbeddedWorkerProcess,
                                        embedded_worker_->process_id(),
@@ skipping 575 matching lines @@
     case REQUEST_PUSH:
       return RunIDMapCallback(&push_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_GEOFENCING:
       return RunIDMapCallback(&geofencing_callbacks_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_CROSS_ORIGIN_CONNECT:
       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;
 }
 
 void ServiceWorkerVersion::SetAllRequestTimes(const base::TimeTicks& ticks) {
   std::queue<RequestInfo> new_requests;
   while (!requests_.empty()) {
     RequestInfo info = requests_.front();
     info.time = ticks;
@@ skipping 106 matching lines @@
 
   streaming_url_request_jobs_.clear();
 
   FOR_EACH_OBSERVER(Listener, listeners_, OnRunningStateChanged(this));
 
   if (should_restart)
     StartWorkerInternal(false /* pause_after_download */);
 }
 
 }  // namespace content