Chromium-side plumbing for ServiceWorker -> Document postMessage (2/3)

content/renderer/service_worker/service_worker_script_context.cc

 // Copyright 2014 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_script_context.h"
 
 #include "base/logging.h"
+#include "content/child/thread_safe_sender.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/renderer/service_worker/embedded_worker_context_client.h"
 #include "ipc/ipc_message.h"
 #include "third_party/WebKit/public/web/WebServiceWorkerContextClient.h"
 #include "third_party/WebKit/public/web/WebServiceWorkerContextProxy.h"
 
 namespace content {
 
+namespace {
+
+void SendPostMessageToDocumentOnMainThread(
+    ThreadSafeSender* sender,
+    int routing_id,
+    int client_id,
+    const base::string16& message,
+    const std::vector<int>& message_port_ids) {
+  sender->Send(new ServiceWorkerHostMsg_PostMessageToDocument(
+      routing_id, client_id, message, message_port_ids));
+}
+
+}  // namespace
+
 ServiceWorkerScriptContext::ServiceWorkerScriptContext(
     EmbeddedWorkerContextClient* embedded_context,
     blink::WebServiceWorkerContextProxy* proxy)
     : embedded_context_(embedded_context),
       proxy_(proxy) {
 }
 
 ServiceWorkerScriptContext::~ServiceWorkerScriptContext() {}
 
 void ServiceWorkerScriptContext::OnMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerScriptContext, message)
     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_Message, OnPostMessage)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClientDocuments,
                         OnDidGetClientDocuments)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
 }
 
 void ServiceWorkerScriptContext::DidHandleActivateEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result) {
@@ skipping 22 matching lines @@
 }
 
 void ServiceWorkerScriptContext::GetClientDocuments(
     blink::WebServiceWorkerClientsCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = pending_clients_callbacks_.Add(callbacks);
   Send(new ServiceWorkerHostMsg_GetClientDocuments(
       GetRoutingID(), request_id));
 }
 
+void ServiceWorkerScriptContext::PostMessageToDocument(
+    int client_id,
+    const base::string16& message,
+    const std::vector<int>& message_port_ids) {
+  // This may send IDs for MessagePorts, and all internal book-keeping
+  // messages for MessagePort (e.g. QueueMessages) are sent from main thread
+  // (with thread hopping), so we need to do the same thread hopping here not
+  // to overtake those messages.

[michaeln, 2014/05/08 00:00:27]

ouch, that's a subtle ordering dependency

+  embedded_context_->main_thread_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&SendPostMessageToDocumentOnMainThread,
+                 make_scoped_refptr(embedded_context_->thread_safe_sender()),
+                 GetRoutingID(), client_id, message, message_port_ids));
+}
+
 void ServiceWorkerScriptContext::Send(IPC::Message* message) {
   embedded_context_->Send(message);
 }
 
 void ServiceWorkerScriptContext::OnActivateEvent(int request_id) {
   proxy_->dispatchActivateEvent(request_id);
 }
 
 void ServiceWorkerScriptContext::OnInstallEvent(int request_id,
                                                 int active_version_id) {
@@ skipping 41 matching lines @@
   info->clientIDs = client_ids;
   callbacks->onSuccess(info.release());
   pending_clients_callbacks_.Remove(request_id);
 }
 
 int ServiceWorkerScriptContext::GetRoutingID() const {
   return embedded_context_->embedded_worker_id();
 }
 
 }  // namespace content