Step two of optionally sending messages to/from message ports as base::Value.

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/common/message_port_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/message_port_delegate.h"
 
@@ skipping 116 matching lines @@
 
   DCHECK(message_ports_[remote_message_port_id].entangled_message_port_id ==
       MSG_ROUTING_NONE);
   message_ports_[remote_message_port_id].entangled_message_port_id =
       local_message_port_id;
 }
 
 void MessagePortService::PostMessage(
     int sender_message_port_id,
     const MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!message_ports_.count(sender_message_port_id)) {
     NOTREACHED();
     return;
   }
 
   int entangled_message_port_id =
       message_ports_[sender_message_port_id].entangled_message_port_id;
   if (entangled_message_port_id == MSG_ROUTING_NONE)
     return;  // Process could have crashed.
 
   if (!message_ports_.count(entangled_message_port_id)) {
     NOTREACHED();
     return;
   }
 
-  PostMessageTo(entangled_message_port_id, message, sent_message_port_ids);
+  PostMessageTo(entangled_message_port_id, message, sent_message_ports);
 }
 
 void MessagePortService::PostMessageTo(
     int message_port_id,
     const MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
-  for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-    if (!message_ports_.count(sent_message_port_ids[i])) {
+  for (size_t i = 0; i < sent_message_ports.size(); ++i) {
+    if (!message_ports_.count(sent_message_ports[i].id)) {
       NOTREACHED();
       return;
     }
   }
 
   MessagePort& entangled_port = message_ports_[message_port_id];
-
-  std::vector<MessagePort*> sent_ports(sent_message_port_ids.size());
-  for (size_t i = 0; i < sent_message_port_ids.size(); ++i)
-    sent_ports[i] = &message_ports_[sent_message_port_ids[i]];
-
   if (entangled_port.queue_messages()) {
     // If the target port is currently holding messages because the destination
     // renderer isn't available yet, all message ports being sent should also be
     // 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);
+      for (const auto& port : sent_message_ports)
+        HoldMessages(port.id);
     }
     entangled_port.queued_messages.push_back(
-        std::make_pair(message, sent_message_port_ids));
+        std::make_pair(message, sent_message_ports));
     return;
   }
 
   if (!entangled_port.delegate) {
     NOTREACHED();
     return;
   }
 
   // Now send the message to the entangled port.
   entangled_port.delegate->SendMessage(entangled_port.route_id, message,
-                                       sent_message_port_ids);
+                                       sent_message_ports);
 }
 
 void MessagePortService::QueueMessages(int message_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   MessagePort& port = message_ports_[message_port_id];
@@ skipping 15 matching lines @@
 
   // Send the queued messages to the port again.  This time they'll reach the
   // new location.
   MessagePort& port = message_ports_[message_port_id];
   port.queue_for_inflight_messages = false;
 
   // If the port is currently holding messages waiting for the target renderer,
   // all ports in messages being sent to the port should also be put on hold.
   if (port.hold_messages_for_destination) {
     for (const auto& message : queued_messages)
-      for (int sent_message_port_id : message.second)
-        HoldMessages(sent_message_port_id);
+      for (const TransferredMessagePort& sent_port : message.second)

[Avi (use Gerrit), 2015/02/27 21:37:55]

const auto&? (you do that on line 178 above)

[Marijn Kruisselbrink, 2015/02/27 23:20:17]

I think my reasoning was that on line 178 it's fairly clear what auto refers to,
since it's iterating over a parameter to the method, while in these other three
cases it's pretty much impossible to figure out what "auto" means without
looking at message_port_service.h. Especially since it's already hard to figure
out what |message.second| actually is, I think that using auto here would make
it even harder to figure out what the code does.

+        HoldMessages(sent_port.id);
   }
 
   port.queued_messages.insert(port.queued_messages.begin(),
                               queued_messages.begin(),
                               queued_messages.end());
 
   if (port.should_be_destroyed)
     ClosePort(message_port_id);
   else
     SendQueuedMessagesIfPossible(message_port_id);
@@ skipping 19 matching lines @@
 
 void MessagePortService::HoldMessages(int message_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   // Any ports in messages currently in the queue should also be put on hold.
   for (const auto& message : message_ports_[message_port_id].queued_messages)
-    for (int sent_message_port_id : message.second)
-      HoldMessages(sent_message_port_id);
+    for (const TransferredMessagePort& sent_port : message.second)

[Avi (use Gerrit), 2015/02/27 21:37:55]

const auto&?

+      HoldMessages(sent_port.id);
 
   message_ports_[message_port_id].hold_messages_for_destination = true;
 }
 
 void MessagePortService::ClosePort(int message_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
 
   if (message_ports_[message_port_id].queue_for_inflight_messages) {
     message_ports_[message_port_id].should_be_destroyed = true;
     return;
   }
 
   // First close any message ports in the queue for this message port.
   for (const auto& message : message_ports_[message_port_id].queued_messages)
-    for (int sent_message_port_id : message.second)
-      ClosePort(sent_message_port_id);
+    for (const TransferredMessagePort& sent_port : message.second)

[Avi (use Gerrit), 2015/02/27 21:37:55]

ditto

+      ClosePort(sent_port.id);
 
   Erase(message_port_id);
 }
 
 void MessagePortService::ReleaseMessages(int message_port_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!message_ports_.count(message_port_id)) {
     NOTREACHED();
     return;
   }
@@ skipping 11 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