SharedWorker: Remove message forwarding mechanism

content/browser/shared_worker/shared_worker_host.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/browser/shared_worker/shared_worker_host.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
@@ skipping 80 matching lines @@
   params.security_policy_type = instance_->security_policy_type();
   params.creation_address_space = instance_->creation_address_space();
   params.pause_on_start = pause_on_start;
   params.route_id = worker_route_id_;
   Send(new WorkerProcessMsg_CreateWorker(params));
 
   for (const FilterInfo& info : filters_)
     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()))
-    return false;
-
-  RelayMessage(message, filter);
-  return true;
+bool SharedWorkerHost::CanHandleMessage(int route_id,
+                                        SharedWorkerMessageFilter* filter) {
+  return IsAvailable() && HasFilter(filter, route_id);
 }
 
 void SharedWorkerHost::FilterShutdown(SharedWorkerMessageFilter* filter) {
   if (!instance_)
     return;
   RemoveFilters(filter);
   worker_document_set_->RemoveAll(filter);
   if (worker_document_set_->IsEmpty()) {
     // This worker has no more associated documents - shut it down.
     TerminateWorker();
   }
 }
 
+void SharedWorkerHost::Connect(int route_id,
+                               int sent_message_port_id,
+                               SharedWorkerMessageFilter* incoming_filter) {
+  if (!instance_)

[horo, 2017/01/05 03:54:13]

nit: DCHECK(instance_);

[nhiroki, 2017/01/05 04:11:40]

I'll make a separate CL to replace all such if-statements at once.

[dcheng, 2017/01/05 06:19:18]

Why is it OK to DCHECK instance_?

[nhiroki, 2017/01/05 07:54:33]

|instance_| is set at the ctor of SharedWorkerHost and unset in
SharedWorkerHost::WorkerContextDestroyed. The host is destroyed immediately
after WorkerContextDestroyed (see [1]), so |instance_| should not be null here.

[1]
https://chromium.googlesource.com/chromium/src/+/a2f777316c98a1bcc06f2d34120b...

+    return;
+
+  DCHECK(container_render_filter_);

[dcheng, 2017/01/05 06:19:18]

Ditto: why is this OK to DCHECK? These messages are coming from the renderer and
untrusted. So it could send them at an invalid time, I think.

[nhiroki, 2017/01/05 07:54:33]

Because this filter is set at the ctor and the host is destroyed when the filter
is closed (see [2])

[2]
https://chromium.googlesource.com/chromium/src/+/a2f777316c98a1bcc06f2d34120b...

+  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::DocumentDetached(SharedWorkerMessageFilter* filter,
                                         unsigned long long document_id) {
   if (!instance_)
     return;
   // Walk all instances and remove the document from their document set.
   worker_document_set_->Remove(filter, document_id);
   if (worker_document_set_->IsEmpty()) {
     // This worker has no more associated documents - shut it down.
     TerminateWorker();
   }
@@ skipping 84 matching lines @@
 
 void SharedWorkerHost::AllowIndexedDB(const GURL& url,
                                       const base::string16& name,
                                       bool* result) {
   if (!instance_)
     return;
   *result = GetContentClient()->browser()->AllowWorkerIndexedDB(
       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_)
     NotifyWorkerDestroyed(worker_process_id_, worker_route_id_);
   Send(new WorkerMsg_TerminateWorkerContext(worker_route_id_));
 }
 
 std::vector<std::pair<int, int> >
 SharedWorkerHost::GetRenderFrameIDsForWorker() {
   std::vector<std::pair<int, int> > result;
@@ skipping 45 matching lines @@
                                         int message_port_id) {
   for (FilterList::iterator i = filters_.begin(); i != filters_.end(); ++i) {
     if (i->filter() == filter && i->route_id() == route_id) {
       i->set_message_port_id(message_port_id);
       return;
     }
   }
 }
 
 }  // namespace content