Initial implementation of stashed message ports, content side

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 "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 36 matching lines @@
     int message_port_id,
     const base::string16& message,
     scoped_ptr<blink::WebMessagePortChannelArray> channels) {
   sender->Send(new MessagePortHostMsg_PostMessage(
       message_port_id,
       MessagePortMessage(message),
                          WebMessagePortChannelImpl::ExtractMessagePortIDs(
                              channels.release())));
 }
 
+void StashMessagePortOnMainThread(ThreadSafeSender* sender,
+                                  int routing_id,
+                                  WebMessagePortChannelImpl* channel,
+                                  const base::string16& name) {
+  DCHECK(channel->message_port_id() >= 0);

[Avi (use Gerrit), 2015/05/20 03:02:10]

DCHECK_GE

+  channel->set_is_stashed();
+  sender->Send(new ServiceWorkerHostMsg_StashMessagePort(
+      routing_id, channel->message_port_id(), name));
+}
+
 blink::WebURLRequest::FetchRequestMode GetBlinkFetchRequestMode(
     FetchRequestMode mode) {
   return static_cast<blink::WebURLRequest::FetchRequestMode>(mode);
 }
 
 blink::WebURLRequest::FetchCredentialsMode GetBlinkFetchCredentialsMode(
     FetchCredentialsMode credentials_mode) {
   return static_cast<blink::WebURLRequest::FetchCredentialsMode>(
       credentials_mode);
 }
@@ skipping 46 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SyncEvent, OnSyncEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_NotificationClickEvent,
                         OnNotificationClickEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_PushEvent, OnPushEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_GeofencingEvent, OnGeofencingEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginConnectEvent,
                         OnCrossOriginConnectEvent)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_MessageToWorker, OnPostMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_CrossOriginMessageToWorker,
                         OnCrossOriginMessageToWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerMsg_SendStashedMessagePorts,
+                        OnSendStashedMessagePorts)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidGetClients,
                         OnDidGetClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowResponse,
                         OnOpenWindowResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_OpenWindowError,
                         OnOpenWindowError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_FocusClientResponse,
                         OnFocusClientResponse)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidSkipWaiting, OnDidSkipWaiting)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidClaimClients, OnDidClaimClients)
@@ skipping 163 matching lines @@
   Send(new ServiceWorkerHostMsg_ClaimClients(GetRoutingID(), request_id));
 }
 
 void ServiceWorkerScriptContext::SkipWaiting(
     blink::WebServiceWorkerSkipWaitingCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = pending_skip_waiting_callbacks_.Add(callbacks);
   Send(new ServiceWorkerHostMsg_SkipWaiting(GetRoutingID(), request_id));
 }
 
+void ServiceWorkerScriptContext::StashMessagePort(
+    blink::WebMessagePortChannel* channel,
+    const base::string16& name) {
+  // All internal book-keeping messages for MessagePort are sent from main
+  // thread (with thread hopping), so we need to do the same thread hopping here
+  // not to overtake those messages.
+  WebMessagePortChannelImpl* channel_impl =
+      static_cast<WebMessagePortChannelImpl*>(channel);
+  embedded_context_->main_thread_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&StashMessagePortOnMainThread,
+                 make_scoped_refptr(embedded_context_->thread_safe_sender()),
+                 GetRoutingID(), base::Unretained(channel_impl), name));
+}
+
 void ServiceWorkerScriptContext::Send(IPC::Message* message) {
   embedded_context_->Send(message);
 }
 
 int ServiceWorkerScriptContext::GetRoutingID() const {
   return embedded_context_->embedded_worker_id();
 }
 
 void ServiceWorkerScriptContext::OnActivateEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
@@ skipping 125 matching lines @@
           sent_message_ports, new_routing_ids,
           embedded_context_->main_thread_task_runner());
 
   blink::WebCrossOriginServiceWorkerClient web_client;
   web_client.origin = client.origin;
   web_client.targetURL = client.target_url;
   web_client.clientID = client.message_port_id;
   proxy_->dispatchCrossOriginMessageEvent(web_client, message, ports);
 }
 
+void ServiceWorkerScriptContext::OnSendStashedMessagePorts(
+    const std::vector<TransferredMessagePort>& stashed_message_ports,
+    const std::vector<int>& new_routing_ids,
+    const std::vector<base::string16>& port_names) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerScriptContext::OnSendStashedMessagePorts");
+  blink::WebMessagePortChannelArray ports =
+      WebMessagePortChannelImpl::CreatePorts(
+          stashed_message_ports, new_routing_ids,
+          embedded_context_->main_thread_task_runner());
+  for (blink::WebMessagePortChannel* port : ports)
+    static_cast<WebMessagePortChannelImpl*>(port)->set_is_stashed();
+  proxy_->addStashedMessagePorts(ports, port_names);
+}
+
 void ServiceWorkerScriptContext::OnDidGetClients(
     int request_id, const std::vector<ServiceWorkerClientInfo>& clients) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnDidGetClients");
   blink::WebServiceWorkerClientsCallbacks* callbacks =
       pending_clients_callbacks_.Lookup(request_id);
   if (!callbacks) {
     NOTREACHED() << "Got stray response: " << request_id;
     return;
   }
@@ skipping 117 matching lines @@
       new blink::WebServiceWorkerError(error_type, message));
   callbacks->onError(error.release());
   pending_claim_clients_callbacks_.Remove(request_id);
 }
 
 void ServiceWorkerScriptContext::OnPing() {
   Send(new ServiceWorkerHostMsg_Pong(GetRoutingID()));
 }
 
 }  // namespace content