Enable messaging over a navigator.connect initiated channel.

content/browser/message_port_service.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/message_port_service.h"
 
-#include "content/browser/message_port_message_filter.h"
+#include "content/browser/message_port_delegate.h"
 #include "content/common/message_port_messages.h"
+#include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 struct MessagePortService::MessagePort {
-  // |filter| and |route_id| are what we need to send messages to the port.
-  // |filter| is just a weak pointer since we get notified when its process has
-  // gone away and remove it.
-  MessagePortMessageFilter* filter;
+  // |delegate| and |route_id| are what we need to send messages to the port.
+  // |delegate| is just a weak pointer since we get notified when its process

[scheib, 2014/12/18 00:24:10]

Old comment out of date, I suggest:
"|delegate| is a raw pointer, it calls OnMessagePortDelegateClosing before it is
destroyed."

[Marijn Kruisselbrink, 2014/12/19 00:09:21]

Done.

+  // has gone away and remove it.
+  MessagePortDelegate* delegate;
   int route_id;
   // A globally unique id for this message port.
   int message_port_id;
   // The globally unique id of the entangled message port.
   int entangled_message_port_id;
   // If true, all messages to this message port are queued and not delivered.
   // This is needed so that when a message port is sent between processes all
   // pending message get transferred. There are two possibilities for pending
   // messages: either they are already received by the child process, or they're
   // in-flight. This flag ensures that the latter type get flushed through the
   // system.
   // This flag should only be set to true in response to
   // MessagePortHostMsg_QueueMessages.
   bool queue_for_inflight_messages;
   // If true, all messages to this message port are queued and not delivered.
   // This is needed so that when a message port is sent to a new process all
   // messages are held in the browser process until the destination process is
   // ready to receive messages. This flag is set true when a message port is
   // transferred to a different process but there isn't immediately a
-  // MessagePortMessageFilter available for that new process. Once the
+  // MessagePortDelegate available for that new process. Once the
   // destination process is ready to receive messages it sends
   // MessagePortHostMsg_ReleaseMessages to set this flag to false.
   bool hold_messages_for_destination;
   // Returns true if messages should be queued for either reason.
   bool queue_messages() const {
     return queue_for_inflight_messages || hold_messages_for_destination;
   }
   // If true, the message port should be destroyed but was currently still
   // waiting for a SendQueuedMessages message from a renderer. As soon as that
   // message is received the port will actually be destroyed.
   bool should_be_destroyed;
   QueuedMessages queued_messages;
 };
 
 MessagePortService* MessagePortService::GetInstance() {
   return Singleton<MessagePortService>::get();
 }
 
 MessagePortService::MessagePortService()
     : next_message_port_id_(0) {
 }
 
 MessagePortService::~MessagePortService() {
 }
 
-void MessagePortService::UpdateMessagePort(
-    int message_port_id,
-    MessagePortMessageFilter* filter,
-    int routing_id) {
+void MessagePortService::UpdateMessagePort(int message_port_id,
+                                           MessagePortDelegate* delegate,
+                                           int routing_id) {
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   MessagePort& port = message_ports_[message_port_id];
-  port.filter = filter;
+  port.delegate = delegate;
   port.route_id = routing_id;
 }
 
-void MessagePortService::OnMessagePortMessageFilterClosing(
-    MessagePortMessageFilter* filter) {
+void MessagePortService::OnMessagePortDelegateClosing(
+    MessagePortDelegate* delegate) {
   // Check if the (possibly) crashed process had any message ports.
   for (MessagePorts::iterator iter = message_ports_.begin();
        iter != message_ports_.end();) {
     MessagePorts::iterator cur_item = iter++;
-    if (cur_item->second.filter == filter) {
+    if (cur_item->second.delegate == delegate) {
       Erase(cur_item->first);
     }
   }
 }
 
 void MessagePortService::Create(int route_id,
-                                MessagePortMessageFilter* filter,
+                                MessagePortDelegate* delegate,
                                 int* message_port_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   *message_port_id = ++next_message_port_id_;
 
   MessagePort port;
-  port.filter = filter;
+  port.delegate = delegate;
   port.route_id = route_id;
   port.message_port_id = *message_port_id;
   port.entangled_message_port_id = MSG_ROUTING_NONE;
   port.queue_for_inflight_messages = false;
   port.hold_messages_for_destination = false;
   port.should_be_destroyed = false;
   message_ports_[*message_port_id] = port;
 }
 
 void MessagePortService::Destroy(int message_port_id) {
@@ skipping 70 matching lines @@
     // put in this state.
     if (entangled_port.hold_messages_for_destination) {
       for (int sent_message_port_id : sent_message_port_ids)
         HoldMessages(sent_message_port_id);
     }
     entangled_port.queued_messages.push_back(
         std::make_pair(message, sent_message_port_ids));
     return;
   }
 
-  if (!entangled_port.filter) {
+  if (!entangled_port.delegate) {
     NOTREACHED();
     return;
   }
 
-  // If a message port was sent around, the new location will need a routing
-  // id.  Instead of having the created port send us a sync message to get it,
-  // send along with the message.
-  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] = entangled_port.filter->GetNextRoutingID();
-    sent_ports[i]->filter = entangled_port.filter;
-
-    // Update the entry for the sent port as it can be in a different process.
-    sent_ports[i]->route_id = new_routing_ids[i];
-  }
-
   // Now send the message to the entangled port.
-  entangled_port.filter->Send(new MessagePortMsg_Message(
-      entangled_port.route_id, message, sent_message_port_ids,
-      new_routing_ids));
+  entangled_port.delegate->SendMessage(entangled_port.route_id, message,
+                                       sent_message_port_ids);
 }
 
 void MessagePortService::QueueMessages(int message_port_id) {
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   MessagePort& port = message_ports_[message_port_id];
-  if (port.filter) {
-    port.filter->Send(new MessagePortMsg_MessagesQueued(port.route_id));
+  if (port.delegate) {
+    port.delegate->SendMessagesAreQueued(port.route_id);
     port.queue_for_inflight_messages = true;
-    port.filter = NULL;
+    port.delegate = NULL;
   }
 }
 
 void MessagePortService::SendQueuedMessages(
     int message_port_id,
     const QueuedMessages& queued_messages) {
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
@@ skipping 21 matching lines @@
     SendQueuedMessagesIfPossible(message_port_id);
 }
 
 void MessagePortService::SendQueuedMessagesIfPossible(int message_port_id) {
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   MessagePort& port = message_ports_[message_port_id];
-  if (port.queue_messages() || !port.filter)
+  if (port.queue_messages() || !port.delegate)
     return;
 
   for (QueuedMessages::iterator iter = port.queued_messages.begin();
        iter != port.queued_messages.end(); ++iter) {
     PostMessageTo(message_port_id, iter->first, iter->second);
   }
   port.queued_messages.clear();
 }
 
 void MessagePortService::HoldMessages(int message_port_id) {
@@ skipping 48 matching lines @@
     // Do the disentanglement (and be paranoid about the other side existing
     // just in case something unusual happened during entanglement).
     if (message_ports_.count(entangled_id)) {
       message_ports_[entangled_id].entangled_message_port_id = MSG_ROUTING_NONE;
     }
   }
   message_ports_.erase(erase_item);
 }
 
 }  // namespace content