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

content/child/service_worker/service_worker_dispatcher.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/child/service_worker/service_worker_dispatcher.h"
 
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
+#include "content/child/child_thread.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/thread_safe_sender.h"
+#include "content/child/webmessageportchannel_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerProviderClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 
 using blink::WebServiceWorkerError;
 using blink::WebServiceWorkerProvider;
 using base::ThreadLocalPointer;
 
 namespace content {
 
@@ skipping 26 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerDispatcher, msg)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistered, OnRegistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerUnregistered,
                         OnUnregistered)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerRegistrationError,
                         OnRegistrationError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ServiceWorkerStateChanged,
                         OnServiceWorkerStateChanged)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SetCurrentServiceWorker,
                         OnSetCurrentServiceWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToDocument,
+                        OnPostMessage)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << "Unhandled message:" << msg.type();
 }
 
 bool ServiceWorkerDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
 void ServiceWorkerDispatcher::RegisterServiceWorker(
@@ skipping 154 matching lines @@
   ScriptClientMap::iterator found = script_clients_.find(provider_id);
   if (found != script_clients_.end()) {
     // Populate the .current field with the new worker object.
     scoped_ptr<ServiceWorkerHandleReference> handle_ref(
         ServiceWorkerHandleReference::Create(info, thread_safe_sender_));
     found->second->setCurrentServiceWorker(
         new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_));
   }
 }
 
+void ServiceWorkerDispatcher::OnPostMessage(
+    int thread_id,
+    int provider_id,
+    const base::string16& message,
+    const std::vector<int>& sent_message_port_ids,
+    const std::vector<int>& new_routing_ids) {
+  // Make sure we're on the main document thread. (That must be the only
+  // thread we get this message)
+  DCHECK(ChildThread::current());
+
+  ScriptClientMap::iterator found = script_clients_.find(provider_id);
+  if (found == script_clients_.end()) {
+    // For now we do no queueing for messages sent to nonexistent / unattached
+    // client.
+    return;
+  }
+
+  std::vector<WebMessagePortChannelImpl*> ports;
+  if (!sent_message_port_ids.empty()) {
+    ports.resize(sent_message_port_ids.size());
+    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
+      ports[i] = new WebMessagePortChannelImpl(
+          new_routing_ids[i], sent_message_port_ids[i],
+          base::MessageLoopProxy::current());
+    }
+  }
+
+  found->second->dispatchMessageEvent(message, ports);
+}
+
 void ServiceWorkerDispatcher::AddServiceWorker(
     int handle_id, WebServiceWorkerImpl* worker) {
   DCHECK(!ContainsKey(service_workers_, handle_id));
   service_workers_[handle_id] = worker;
 }
 
 void ServiceWorkerDispatcher::RemoveServiceWorker(int handle_id) {
   DCHECK(ContainsKey(service_workers_, handle_id));
   service_workers_.erase(handle_id);
 }
 
 }  // namespace content