SharedWorker: Remove message forwarding mechanism

SharedWorker service has a mechanism to forward a message sent from a document
to a worker. With this mechanism, a sender creates a nested IPC message and
sends it to the SharedWorker service in the browser process. The service
interprets the nested message and forwards it to an appropriate receiver.

This mechanism is available for any IPC messages but it has been used only for
worker connection message. If we use it only for one message type, we don't have
to manage such a complex mechanism. Therefore, this CL removes the mechanism and
uses a plain IPC message for connecting to a worker.

This simplification also makes it easier to mojofy SharedWorker.

BUG=612308

Review-Url: https://codereview.chromium.org/2601893002
Cr-Commit-Position: refs/heads/master@{#441785}

content/browser/shared_worker/shared_worker_host.cc

@@ -98,12 +98,14 @@ void SharedWorkerHost::Start(bool pause_on_start) {
     info.filter()->Send(new ViewMsg_WorkerCreated(info.route_id()));
 }
 
-bool SharedWorkerHost::FilterMessage(const IPC::Message& message,
-                                     SharedWorkerMessageFilter* filter) {
-  if (!IsAvailable() || !HasFilter(filter, message.routing_id()))
+bool SharedWorkerHost::FilterConnectionMessage(
+    int route_id,
+    int sent_message_port_id,
+    SharedWorkerMessageFilter* incoming_filter) {
+  if (!IsAvailable() || !HasFilter(incoming_filter, route_id))
     return false;
 
-  RelayMessage(message, filter);
+  Connect(route_id, sent_message_port_id, incoming_filter);
   return true;
 }
 
@@ -222,42 +224,6 @@ void SharedWorkerHost::AllowIndexedDB(const GURL& url,
       url, name, instance_->resource_context(), GetRenderFrameIDsForWorker());
 }
 
-void SharedWorkerHost::RelayMessage(
-    const IPC::Message& message,
-    SharedWorkerMessageFilter* incoming_filter) {
-  if (!instance_)
-    return;
-  if (message.type() == WorkerMsg_Connect::ID) {
-    // Crack the SharedWorker Connect message to setup routing for the port.
-    WorkerMsg_Connect::Param param;
-    if (!WorkerMsg_Connect::Read(&message, &param))
-      return;
-    int sent_message_port_id = std::get<0>(param);
-    int new_routing_id = std::get<1>(param);
-
-    DCHECK(container_render_filter_);
-    new_routing_id = container_render_filter_->GetNextRoutingID();
-    MessagePortService::GetInstance()->UpdateMessagePort(
-        sent_message_port_id,
-        container_render_filter_->message_port_message_filter(),
-        new_routing_id);
-    SetMessagePortID(
-        incoming_filter, message.routing_id(), sent_message_port_id);
-    // Resend the message with the new routing id.
-    Send(new WorkerMsg_Connect(
-        worker_route_id_, sent_message_port_id, new_routing_id));
-
-    // Send any queued messages for the sent port.
-    MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
-        sent_message_port_id);
-  } else {
-    IPC::Message* new_message = new IPC::Message(message);
-    new_message->set_routing_id(worker_route_id_);
-    Send(new_message);
-    return;
-  }
-}
-
 void SharedWorkerHost::TerminateWorker() {
   termination_message_sent_ = true;
   if (!closed_)
@@ -311,6 +277,26 @@ bool SharedWorkerHost::HasFilter(SharedWorkerMessageFilter* filter,
   return false;
 }
 
+void SharedWorkerHost::Connect(int route_id,
+                               int sent_message_port_id,
+                               SharedWorkerMessageFilter* incoming_filter) {
+  DCHECK(IsAvailable());
+  DCHECK(HasFilter(incoming_filter, route_id));
+  DCHECK(container_render_filter_);
+
+  int new_routing_id = container_render_filter_->GetNextRoutingID();
+  MessagePortService::GetInstance()->UpdateMessagePort(
+      sent_message_port_id,
+      container_render_filter_->message_port_message_filter(), new_routing_id);
+  SetMessagePortID(incoming_filter, route_id, sent_message_port_id);
+  Send(new WorkerMsg_Connect(worker_route_id_, sent_message_port_id,
+                             new_routing_id));
+
+  // Send any queued messages for the sent port.
+  MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
+      sent_message_port_id);
+}
+
 void SharedWorkerHost::SetMessagePortID(SharedWorkerMessageFilter* filter,
                                         int route_id,
                                         int message_port_id) {

content/browser/shared_worker/shared_worker_host.h

@@ -45,8 +45,9 @@ class SharedWorkerHost {
 
   // Returns true iff the given message from a renderer process was forwarded to
   // the worker.
-  bool FilterMessage(const IPC::Message& message,
-                     SharedWorkerMessageFilter* filter);
+  bool FilterConnectionMessage(int route_id,
+                               int sent_message_port_id,
+                               SharedWorkerMessageFilter* incoming_filter);
 
   // Handles the shutdown of the filter. If the worker has no other client,
   // sends TerminateWorkerContext message to shut it down.
@@ -109,21 +110,20 @@ class SharedWorkerHost {
 
   using FilterList = std::list<FilterInfo>;
 
-  // Relays |message| to the SharedWorker. Takes care of parsing the message if
-  // it contains a message port and sending it a valid route id.
-  void RelayMessage(const IPC::Message& message,
-                    SharedWorkerMessageFilter* incoming_filter);
-
   // Return a vector of all the render process/render frame IDs.
   std::vector<std::pair<int, int> > GetRenderFrameIDsForWorker();
 
   void RemoveFilters(SharedWorkerMessageFilter* filter);
   bool HasFilter(SharedWorkerMessageFilter* filter, int route_id) const;
+  void Connect(int route_id,
+               int sent_message_port_id,
+               SharedWorkerMessageFilter* incoming_filter);
   void SetMessagePortID(SharedWorkerMessageFilter* filter,
                         int route_id,
                         int message_port_id);
   void AllowFileSystemResponse(std::unique_ptr<IPC::Message> reply_msg,
                                bool allowed);
+
   std::unique_ptr<SharedWorkerInstance> instance_;
   scoped_refptr<WorkerDocumentSet> worker_document_set_;
   FilterList filters_;

content/browser/shared_worker/shared_worker_message_filter.cc

@@ -50,7 +50,7 @@ bool SharedWorkerMessageFilter::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(SharedWorkerMessageFilter, message)
     // Only sent from renderer for now, until we have nested workers.
     IPC_MESSAGE_HANDLER(ViewHostMsg_CreateWorker, OnCreateWorker)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToWorker, OnForwardToWorker)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_ConnectToWorker, OnConnectToWorker)
     // Only sent from renderer.
     IPC_MESSAGE_HANDLER(ViewHostMsg_DocumentDetached, OnDocumentDetached)
     // Only sent from SharedWorker in renderer.
@@ -88,8 +88,10 @@ void SharedWorkerMessageFilter::OnCreateWorker(
       WorkerStoragePartitionId(partition_));
 }
 
-void SharedWorkerMessageFilter::OnForwardToWorker(const IPC::Message& message) {
-  SharedWorkerServiceImpl::GetInstance()->ForwardToWorker(message, this);
+void SharedWorkerMessageFilter::OnConnectToWorker(int route_id,
+                                                  int sent_message_port_id) {
+  SharedWorkerServiceImpl::GetInstance()->ConnectToWorker(
+      route_id, sent_message_port_id, this);
 }
 
 void SharedWorkerMessageFilter::OnDocumentDetached(

content/browser/shared_worker/shared_worker_message_filter.h

@@ -46,7 +46,7 @@ class CONTENT_EXPORT SharedWorkerMessageFilter : public BrowserMessageFilter {
   // Message handlers.
   void OnCreateWorker(const ViewHostMsg_CreateWorker_Params& params,
                       ViewHostMsg_CreateWorker_Reply* reply);
-  void OnForwardToWorker(const IPC::Message& message);
+  void OnConnectToWorker(int route_id, int sent_message_port_id);
   void OnDocumentDetached(unsigned long long document_id);
   void OnWorkerContextClosed(int worker_route_id);
   void OnWorkerContextDestroyed(int worker_route_id);

content/browser/shared_worker/shared_worker_service_impl.cc

@@ -324,13 +324,15 @@ blink::WebWorkerCreationError SharedWorkerServiceImpl::CreateWorker(
   return ReserveRenderProcessToCreateWorker(std::move(pending_instance));
 }
 
-void SharedWorkerServiceImpl::ForwardToWorker(
-    const IPC::Message& message,
+void SharedWorkerServiceImpl::ConnectToWorker(
+    int route_id,
+    int sent_message_port_id,
     SharedWorkerMessageFilter* filter) {
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
-    if (iter->second->FilterMessage(message, filter))
+    if (iter->second->FilterConnectionMessage(route_id, sent_message_port_id,
+                                              filter))
       return;
   }
 }

content/browser/shared_worker/shared_worker_service_impl.h

@@ -56,7 +56,8 @@ class CONTENT_EXPORT SharedWorkerServiceImpl
       SharedWorkerMessageFilter* filter,
       ResourceContext* resource_context,
       const WorkerStoragePartitionId& partition_id);
-  void ForwardToWorker(const IPC::Message& message,
+  void ConnectToWorker(int route_id,
+                       int sent_message_port_id,
                        SharedWorkerMessageFilter* filter);
   void DocumentDetached(unsigned long long document_id,
                         SharedWorkerMessageFilter* filter);

content/browser/shared_worker/shared_worker_service_impl_unittest.cc

@@ -298,9 +298,8 @@ class MockSharedWorkerConnector {
   }
   void SendConnect() {
     EXPECT_TRUE(
-        renderer_host_->OnMessageReceived(new ViewHostMsg_ForwardToWorker(
-            WorkerMsg_Connect(create_worker_reply_.route_id, remote_port_id_,
-                              MSG_ROUTING_NONE))));
+        renderer_host_->OnMessageReceived(new ViewHostMsg_ConnectToWorker(
+            create_worker_reply_.route_id, remote_port_id_)));
   }
   void SendSendQueuedMessages(
       const std::vector<QueuedMessage>& queued_messages) {

content/common/view_messages.h

@@ -699,10 +699,11 @@ IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_CreateWorker,
 // is detached).
 IPC_MESSAGE_CONTROL1(ViewHostMsg_DocumentDetached, uint64_t /* document_id */)
 
-// Wraps an IPC message that's destined to the worker on the renderer->browser
-// hop.
-IPC_MESSAGE_CONTROL1(ViewHostMsg_ForwardToWorker,
-                     IPC::Message /* message */)
+// A renderer sends this to the browser process when it wants to connect to a
+// worker.
+IPC_MESSAGE_CONTROL2(ViewHostMsg_ConnectToWorker,
+                     int /* route_id */,
+                     int /* sent_message_port_id */)
 
 // Tells the browser that a specific Appcache manifest in the current page
 // was accessed.

content/renderer/websharedworker_proxy.cc

@@ -40,7 +40,7 @@ bool WebSharedWorkerProxy::Send(std::unique_ptr<IPC::Message> message) {
   // For now we proxy all messages to the worker process through the browser.
   // Revisit if we find this slow.
   // TODO(jabdelmalek): handle sync messages if we need them.
-  return router_->Send(new ViewHostMsg_ForwardToWorker(*message));
+  return router_->Send(message.release());
 }
 
 void WebSharedWorkerProxy::SendQueuedMessages() {
@@ -63,8 +63,8 @@ void WebSharedWorkerProxy::connect(blink::WebMessagePortChannel* channel,
   DCHECK_NE(MSG_ROUTING_NONE, message_port_id);
   webchannel->QueueMessages();
 
-  Send(base::MakeUnique<WorkerMsg_Connect>(route_id_, message_port_id,
-                                           MSG_ROUTING_NONE));
+  Send(base::MakeUnique<ViewHostMsg_ConnectToWorker>(route_id_,
+                                                     message_port_id));
   connect_listener_ = listener;
 }