Implement ServiceWorker::postMessage() [Chromium]

content/browser/service_worker/service_worker_dispatcher_host.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_dispatcher_host.h"
 
 #include "base/strings/utf_string_conversions.h"
+#include "content/browser/message_port_message_filter.h"
+#include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
-#include "content/browser/service_worker/service_worker_provider_host.h"
+#include "content/browser/service_worker/service_worker_registration.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerError.h"
 #include "url/gurl.h"
 
 using blink::WebServiceWorkerError;
 
 namespace {
 
 const char kDisabledErrorMessage[] =
     "ServiceWorker is disabled";
 const char kDomainMismatchErrorMessage[] =
     "Scope and scripts do not have the same origin";
 
 const uint32 kFilteredMessageClasses[] = {
   ServiceWorkerMsgStart,
   EmbeddedWorkerMsgStart,
 };
 
 }  // namespace
 
 namespace content {
 
 ServiceWorkerDispatcherHost::ServiceWorkerDispatcherHost(
-    int render_process_id)
-    : BrowserMessageFilter(
-          kFilteredMessageClasses, arraysize(kFilteredMessageClasses)),
-      render_process_id_(render_process_id) {
+    int render_process_id,
+    MessagePortMessageFilter* message_port_message_filter)
+    : BrowserMessageFilter(kFilteredMessageClasses,
+                           arraysize(kFilteredMessageClasses)),
+      render_process_id_(render_process_id),
+      message_port_message_filter_(message_port_message_filter) {
 }
 
 ServiceWorkerDispatcherHost::~ServiceWorkerDispatcherHost() {
   if (context_) {
     context_->RemoveAllProviderHostsForProcess(render_process_id_);
     context_->embedded_worker_registry()->RemoveChildProcessSender(
         render_process_id_);
   }
 }
 
@@ skipping 26 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_UnregisterServiceWorker,
                         OnUnregisterServiceWorker)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderCreated,
                         OnProviderCreated)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ProviderDestroyed,
                         OnProviderDestroyed)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_AddScriptClient,
                         OnAddScriptClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_RemoveScriptClient,
                         OnRemoveScriptClient)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessage,
+                        OnPostMessage)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerHostMsg_WorkerStarted,
                         OnWorkerStarted)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerHostMsg_WorkerStopped,
                         OnWorkerStopped)
     IPC_MESSAGE_HANDLER(EmbeddedWorkerHostMsg_SendMessageToBrowser,
                         OnSendMessageToBrowser)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
@@ skipping 53 matching lines @@
 
   context_->UnregisterServiceWorker(
       pattern,
       render_process_id_,
       base::Bind(&ServiceWorkerDispatcherHost::UnregistrationComplete,
                  this,
                  thread_id,
                  request_id));
 }
 
+void ServiceWorkerDispatcherHost::OnPostMessage(
+    int64 registration_id,
+    base::string16 message,

[michaeln, 2014/03/11 23:17:34]

const ref here

[jsbell, 2014/03/12 18:16:16]

Done.

+    std::vector<int> sent_message_port_ids) {

[michaeln, 2014/03/11 23:17:34]

ditto here and in the next method sig too

[jsbell, 2014/03/12 18:16:16]

Done.

+  if (!context_ || !context_->IsEnabled())
+    return;
+
+  context_->storage()->FindRegistrationForId(
+      registration_id,
+      base::Bind(&ServiceWorkerDispatcherHost::PostMessageFoundRegistration,
+                 this,
+                 message,
+                 sent_message_port_ids));
+}
+
+static void NoOpStatusCallback(ServiceWorkerStatusCode status) {}
+
+void ServiceWorkerDispatcherHost::PostMessageFoundRegistration(
+    base::string16 message,
+    std::vector<int> sent_message_port_ids,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& result) {
+  // TODO(jsbell): Can we assert anything here?
+  if (status == SERVICE_WORKER_ERROR_NOT_FOUND)
+    return;
+
+  std::vector<int> new_routing_ids(sent_message_port_ids.size());
+  for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
+    new_routing_ids[i] = message_port_message_filter_->GetNextRoutingID();
+    MessagePortService::GetInstance()->UpdateMessagePort(

[michaeln, 2014/03/11 23:17:34]

i have no clue about msgport voodoo, but tests pass so it must be right :)

+        sent_message_port_ids[i],
+        message_port_message_filter_,
+        new_routing_ids[i]);
+  }
+
+  // TODO(jsbell): Need version_id passed along to disambiguate?

[jsbell, 2014/03/11 22:01:50]

This is probably the biggest issue with this CL. The message ends up routed to
the "active" instance, regardless of which one is actually referenced. From
chatting w/ alec, it seems as if the version id needs to be passed through to
the renderer on registration so it can be passed back through here, but I'm not
positive.

(That could be a follow-up patch, if we acknowledge that the behavior here is
incorrect until then.)

[michaeln, 2014/03/11 23:17:34]

This was my main question too. I think there are two different cases, not sure
if the answer is any different depending?

1) Case where the page is invoking navigator.serviceWorker.active.postMessage()
to send it to the sw associated with the page.

2) Case where postMessage is called on the return value of a register call
(which may be different than ^^^). A page that has called this method may
outlive update cycles of the sw that return value refers to.

I think what you have coded here might be good for both those cases?

[kinuko, 2014/03/12 08:19:05]

In the current code it'd work for both cases, though when we flesh out
registration flow this (talking to active_version) could be talking to a
different version for case 2). So... I think at least we'll need to be able to
distinguish case 1) and 2), or will need version_id. (Leaving TODO for now and
iterate on it while spec evolves more sounds good to me too)

[jsbell, 2014/03/12 18:16:16]

Agreed, that's the failure case I was thinking of.
SGTM2.

I'll put in a tracking bug. crbug.com/351797

+  result->active_version()->SendMessage(
+      ServiceWorkerMsg_Message(message, sent_message_port_ids, new_routing_ids),
+      base::Bind(&NoOpStatusCallback));
+}
+
 void ServiceWorkerDispatcherHost::OnProviderCreated(int provider_id) {
   if (!context_)
     return;
   if (context_->GetProviderHost(render_process_id_, provider_id)) {
     BadMessageReceived();
     return;
   }
   scoped_ptr<ServiceWorkerProviderHost> provider_host(
        new ServiceWorkerProviderHost(render_process_id_, provider_id));
   context_->AddProviderHost(provider_host.Pass());
@@ skipping 88 matching lines @@
     ServiceWorkerStatusCode status) {
   base::string16 error_message;
   blink::WebServiceWorkerError::ErrorType error_type;
   GetServiceWorkerRegistrationStatusResponse(
       status, &error_type, &error_message);
   Send(new ServiceWorkerMsg_ServiceWorkerRegistrationError(
       thread_id, request_id, error_type, error_message));
 }
 
 }  // namespace content