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

This CL changes every place a MessagePort is transferred between process to
properly propagate the send_messages_as_values flag, as well as makes it
possible for NavigatorConnectContext to set this flag when setting up a
new connection.

This is part of a series of changes:
[1/5] Blink side changes in https://codereview.chromium.org/924983002/ that expose a needed v8 context
[2/5] https://codereview.chromium.org/921013002/ allow MessagePort to send messages as values
[3/5] This CL
[4/5] https://codereview.chromium.org/938403005/ which uses this for navigator.connect services and adds infrastructure for layout tests
[5/5] https://codereview.chromium.org/940423004/ adds layout tests to blink to test these new features

BUG=426458

Review URL: https://codereview.chromium.org/944443003

Cr-Commit-Position: refs/heads/master@{#318578}

41 files changed, 368 insertions, 347 deletions

diff --git a/android_webview/browser/aw_message_port_message_filter.cc b/android_webview/browser/aw_message_port_message_filter.cc
index b19b344..8c434b5 100644
--- a/android_webview/browser/aw_message_port_message_filter.cc
+++ b/android_webview/browser/aw_message_port_message_filter.cc
@@ -46,12 +46,15 @@ void AwMessagePortMessageFilter::OnConvertedAppToWebMessage(
     int msg_port_id,
     const base::string16& message,
     const std::vector<int>& sent_message_port_ids) {
-
+  std::vector<content::TransferredMessagePort>
+      sent_ports(sent_message_port_ids.size());
+  for (size_t i = 0; i < sent_message_port_ids.size(); ++i)
+    sent_ports[i].id = sent_message_port_ids[i];
   // TODO(mek): Bypass the extra roundtrip and just send the unconverted message
   // to the renderer directly.
   MessagePortProvider::PostMessageToPort(msg_port_id,
       content::MessagePortMessage(message),
-      sent_message_port_ids);
+      sent_ports);
 }
 
 void AwMessagePortMessageFilter::OnClosePortAck(int message_port_id) {
@@ -81,8 +84,13 @@ void AwMessagePortMessageFilter::SendClosePortMessage(int message_port_id) {
 void AwMessagePortMessageFilter::SendMessage(
     int msg_port_route_id,
     const content::MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<content::TransferredMessagePort>& sent_message_ports) {
   DCHECK(message.is_string());
+  std::vector<int> sent_message_port_ids(sent_message_ports.size());
+  for (size_t i = 0; i < sent_message_ports.size(); ++i) {
+    DCHECK(!sent_message_ports[i].send_messages_as_values);
+    sent_message_port_ids[i] = sent_message_ports[i].id;
+  }
   Send(new AwMessagePortMsg_WebToAppMessage(
       route_id_,
       msg_port_route_id, // same as the port id
diff --git a/android_webview/browser/aw_message_port_message_filter.h b/android_webview/browser/aw_message_port_message_filter.h
index 061dabb..4dfeed6 100644
--- a/android_webview/browser/aw_message_port_message_filter.h
+++ b/android_webview/browser/aw_message_port_message_filter.h
@@ -29,9 +29,11 @@ class AwMessagePortMessageFilter : public content::BrowserMessageFilter,
   void SendClosePortMessage(int message_port_id);
 
   // MessagePortDelegate implementation.
-  void SendMessage(int msg_port_route_id,
-                   const content::MessagePortMessage& message,
-                   const std::vector<int>& sent_message_port_ids) override;
+  void SendMessage(
+      int msg_port_route_id,
+      const content::MessagePortMessage& message,
+      const std::vector<content::TransferredMessagePort>& sent_message_ports)
+      override;
   void SendMessagesAreQueued(int route_id) override;
  private:
   friend class content::BrowserThread;
diff --git a/android_webview/native/aw_contents.cc b/android_webview/native/aw_contents.cc
index 8580478..e192656 100644
--- a/android_webview/native/aw_contents.cc
+++ b/android_webview/native/aw_contents.cc
@@ -60,6 +60,7 @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/common/message_port_types.h"
 #include "content/public/common/renderer_preferences.h"
 #include "content/public/common/ssl_status.h"
 #include "jni/AwContents_jni.h"
@@ -1113,11 +1114,14 @@ void AwContents::PostMessageToFrame(JNIEnv* env, jobject obj,
                    base::Unretained(AwMessagePortServiceImpl::GetInstance()),
                    j_ports));
   }
+  std::vector<content::TransferredMessagePort> ports(j_ports.size());
+  for (size_t i = 0; i < j_ports.size(); ++i)
+    ports[i].id = j_ports[i];
   content::MessagePortProvider::PostMessageToFrame(web_contents_.get(),
                                                    source_origin,
                                                    j_target_origin,
                                                    j_message,
-                                                   j_ports);
+                                                   ports);
 }
 
 scoped_refptr<AwMessagePortMessageFilter>
diff --git a/content/browser/message_port_message_filter.cc b/content/browser/message_port_message_filter.cc
index 9046ee7..6dc44b6 100644
--- a/content/browser/message_port_message_filter.cc
+++ b/content/browser/message_port_message_filter.cc
@@ -63,13 +63,13 @@ int MessagePortMessageFilter::GetNextRoutingID() {
 void MessagePortMessageFilter::SendMessage(
     int route_id,
     const MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   // Generate new routing ids for all ports that were sent around. This avoids
   // waiting for the created ports to send a sync message back to get routing
   // ids.
   std::vector<int> new_routing_ids;
-  UpdateMessagePortsWithNewRoutes(sent_message_port_ids, &new_routing_ids);
-  Send(new MessagePortMsg_Message(route_id, message, sent_message_port_ids,
+  UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
+  Send(new MessagePortMsg_Message(route_id, message, sent_message_ports,
                                   new_routing_ids));
 }
 
@@ -78,16 +78,16 @@ void MessagePortMessageFilter::SendMessagesAreQueued(int route_id) {
 }
 
 void MessagePortMessageFilter::UpdateMessagePortsWithNewRoutes(
-    const std::vector<int>& message_port_ids,
+    const std::vector<TransferredMessagePort>& message_ports,
     std::vector<int>* new_routing_ids) {
   DCHECK(new_routing_ids);
   new_routing_ids->clear();
-  new_routing_ids->resize(message_port_ids.size());
+  new_routing_ids->resize(message_ports.size());
 
-  for (size_t i = 0; i < message_port_ids.size(); ++i) {
+  for (size_t i = 0; i < message_ports.size(); ++i) {
     (*new_routing_ids)[i] = GetNextRoutingID();
     MessagePortService::GetInstance()->UpdateMessagePort(
-        message_port_ids[i],
+        message_ports[i].id,
         this,
         (*new_routing_ids)[i]);
   }
@@ -97,7 +97,7 @@ void MessagePortMessageFilter::RouteMessageEventWithMessagePorts(
     int routing_id,
     const ViewMsg_PostMessage_Params& params) {
   ViewMsg_PostMessage_Params new_params(params);
-  UpdateMessagePortsWithNewRoutes(params.message_port_ids,
+  UpdateMessagePortsWithNewRoutes(params.message_ports,
                                   &new_params.new_routing_ids);
   Send(new ViewMsg_PostMessageEvent(routing_id, new_params));
 }
diff --git a/content/browser/message_port_message_filter.h b/content/browser/message_port_message_filter.h
index 6242902..e71a235 100644
--- a/content/browser/message_port_message_filter.h
+++ b/content/browser/message_port_message_filter.h
@@ -18,6 +18,7 @@
 struct ViewMsg_PostMessage_Params;
 
 namespace content {
+struct TransferredMessagePort;
 
 // Filter for MessagePort related IPC messages (creating and destroying a
 // MessagePort, sending a message via a MessagePort etc).
@@ -39,15 +40,16 @@ class CONTENT_EXPORT MessagePortMessageFilter
   int GetNextRoutingID();
 
   // MessagePortDelegate implementation.
-  void SendMessage(int route_id,
-                   const MessagePortMessage& message,
-                   const std::vector<int>& sent_message_port_ids) override;
+  void SendMessage(
+      int route_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports) override;
   void SendMessagesAreQueued(int route_id) override;
 
-  // Updates message ports registered for |message_port_ids| and returns
+  // Updates message ports registered for |message_ports| and returns
   // new routing IDs for the updated ports via |new_routing_ids|.
   void UpdateMessagePortsWithNewRoutes(
-      const std::vector<int>& message_port_ids,
+      const std::vector<TransferredMessagePort>& message_ports,
       std::vector<int>* new_routing_ids);
 
   void RouteMessageEventWithMessagePorts(
diff --git a/content/browser/message_port_provider.cc b/content/browser/message_port_provider.cc
index 7abc7dc..63de381 100644
--- a/content/browser/message_port_provider.cc
+++ b/content/browser/message_port_provider.cc
@@ -16,49 +16,32 @@
 
 namespace content {
 
-namespace {
-
-void PostMessageOnIOThread(MessagePortMessageFilter* filter,
-                           int routing_id,
-                           ViewMsg_PostMessage_Params* params) {
-  if (!params->message_port_ids.empty()) {
-    filter->UpdateMessagePortsWithNewRoutes(params->message_port_ids,
-                                            &params->new_routing_ids);
-  }
-  filter->Send(new ViewMsg_PostMessageEvent(routing_id, *params));
-}
-
-}  // namespace
-
 // static
 void MessagePortProvider::PostMessageToFrame(
     WebContents* web_contents,
     const base::string16& source_origin,
     const base::string16& target_origin,
     const base::string16& data,
-    const std::vector<int>& ports) {
+    const std::vector<TransferredMessagePort>& ports) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  ViewMsg_PostMessage_Params* params = new ViewMsg_PostMessage_Params();
-  params->is_data_raw_string = true;
-  params->data = data;
+  ViewMsg_PostMessage_Params params;
+  params.is_data_raw_string = true;
+  params.data = data;
   // Blink requires a source frame to transfer ports. This is why a
   // source routing id is set here. See WebDOMMessageEvent::initMessageEvent()
-  params->source_routing_id = web_contents->GetRoutingID();
-  params->source_origin = source_origin;
-  params->target_origin = target_origin;
-  params->message_port_ids = ports;
+  params.source_routing_id = web_contents->GetRoutingID();
+  params.source_origin = source_origin;
+  params.target_origin = target_origin;
+  params.message_ports = ports;
 
   RenderProcessHostImpl* rph =
       static_cast<RenderProcessHostImpl*>(web_contents->GetRenderProcessHost());
-  MessagePortMessageFilter* mf = rph->message_port_message_filter();
   BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&PostMessageOnIOThread,
-                 make_scoped_refptr(mf),
-                 web_contents->GetRoutingID(),
-                 base::Owned(params)));
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&MessagePortMessageFilter::RouteMessageEventWithMessagePorts,
+                 rph->message_port_message_filter(),
+                 web_contents->GetRoutingID(), params));
 }
 
 // static
@@ -83,7 +66,7 @@ void MessagePortProvider::CreateMessageChannel(MessagePortDelegate* delegate,
 void MessagePortProvider::PostMessageToPort(
     int sender_port_id,
     const MessagePortMessage& message,
-    const std::vector<int>& sent_ports) {
+    const std::vector<TransferredMessagePort>& sent_ports) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   MessagePortService* msp = MessagePortService::GetInstance();
   msp->PostMessage(sender_port_id, message, sent_ports);
diff --git a/content/browser/message_port_provider_browsertest.cc b/content/browser/message_port_provider_browsertest.cc
index b7f7a63..425e08f 100644
--- a/content/browser/message_port_provider_browsertest.cc
+++ b/content/browser/message_port_provider_browsertest.cc
@@ -26,7 +26,7 @@ class MockMessagePortDelegate : public MessagePortDelegate {
   struct Message {
     int route_id;  // the routing id of the target port
     MessagePortMessage data;  // the message data
-    std::vector<int> sent_ports;  // any transferred ports
+    std::vector<TransferredMessagePort> sent_ports;  // any transferred ports
   };
 
   typedef std::vector<Message> Messages;
@@ -35,13 +35,14 @@ class MockMessagePortDelegate : public MessagePortDelegate {
   ~MockMessagePortDelegate() override { }
 
   // MessagePortDelegate implementation
-  void SendMessage(int route_id,
-                   const MessagePortMessage& message,
-                   const std::vector<int>& sent_message_port_ids) override {
+  void SendMessage(
+      int route_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports) override {
     Message m;
     m.route_id = route_id;
     m.data = message;
-    m.sent_ports = sent_message_port_ids;
+    m.sent_ports = sent_message_ports;
     messages_.push_back(m);
   }
 
@@ -75,7 +76,7 @@ IN_PROC_BROWSER_TEST_F(MessagePortProviderBrowserTest, PostMessage) {
   content::LoadDataWithBaseURL(shell(), history_url, data, base_url);
   const base::string16 source_origin(base::UTF8ToUTF16("source"));
   const base::string16 message(base::UTF8ToUTF16("success"));
-  const std::vector<int> ports;
+  const std::vector<TransferredMessagePort> ports;
   content::TitleWatcher title_watcher(shell()->web_contents(), message);
   MessagePortProvider::PostMessageToFrame(shell()->web_contents(),
                                           source_origin,
@@ -99,7 +100,7 @@ void VerifyCreateChannelOnIOThread(base::WaitableEvent* event) {
   MessagePortProvider::CreateMessageChannel(&delegate, &port1, &port2);
   MessagePortService* service = MessagePortService::GetInstance();
   // Send a message to port1 transferring no ports.
-  std::vector<int> sent_ports;
+  std::vector<TransferredMessagePort> sent_ports;
   service->PostMessage(port1, MessagePortMessage(base::string16(MESSAGE1)),
                        sent_ports);
   // Verify that message is received
@@ -114,9 +115,9 @@ void VerifyCreateChannelOnIOThread(base::WaitableEvent* event) {
 
   // Create a new channel, and transfer one of its ports to port2, making sure
   // the transferred port is received.
-  int port3;
-  int port4;
-  MessagePortProvider::CreateMessageChannel(&delegate, &port3, &port4);
+  TransferredMessagePort port3;
+  TransferredMessagePort port4;
+  MessagePortProvider::CreateMessageChannel(&delegate, &port3.id, &port4.id);
   sent_ports.push_back(port3);
   service->PostMessage(port1, MessagePortMessage(base::string16(MESSAGE2)),
                        sent_ports);
@@ -124,7 +125,7 @@ void VerifyCreateChannelOnIOThread(base::WaitableEvent* event) {
   EXPECT_EQ(received[1].route_id, port2);
   EXPECT_EQ(received[1].data.message_as_string, MESSAGE2);
   EXPECT_EQ(received[1].sent_ports.size(), 1u);
-  EXPECT_EQ(received[1].sent_ports[0], port3);
+  EXPECT_EQ(received[1].sent_ports[0].id, port3.id);
 
   event->Signal();
 }
diff --git a/content/browser/message_port_service.cc b/content/browser/message_port_service.cc
index 597b190..915ae48 100644
--- a/content/browser/message_port_service.cc
+++ b/content/browser/message_port_service.cc
@@ -134,7 +134,7 @@ void MessagePortService::Entangle(int 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();
@@ -151,40 +151,35 @@ void MessagePortService::PostMessage(
     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;
   }
 
@@ -195,7 +190,7 @@ void MessagePortService::PostMessageTo(
 
   // 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) {
@@ -231,8 +226,8 @@ void MessagePortService::SendQueuedMessages(
   // 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)
+        HoldMessages(sent_port.id);
   }
 
   port.queued_messages.insert(port.queued_messages.begin(),
@@ -272,8 +267,8 @@ void MessagePortService::HoldMessages(int message_port_id) {
 
   // 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)
+      HoldMessages(sent_port.id);
 
   message_ports_[message_port_id].hold_messages_for_destination = true;
 }
@@ -292,8 +287,8 @@ void MessagePortService::ClosePort(int message_port_id) {
 
   // 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)
+      ClosePort(sent_port.id);
 
   Erase(message_port_id);
 }
diff --git a/content/browser/message_port_service.h b/content/browser/message_port_service.h
index 1e561b2..d5e3379 100644
--- a/content/browser/message_port_service.h
+++ b/content/browser/message_port_service.h
@@ -21,7 +21,8 @@ class MessagePortDelegate;
 
 class CONTENT_EXPORT MessagePortService {
  public:
-  typedef std::vector<std::pair<content::MessagePortMessage, std::vector<int>>>
+  typedef std::vector<std::pair<content::MessagePortMessage,
+                                std::vector<TransferredMessagePort>>>
       QueuedMessages;
 
   // Returns the MessagePortService singleton.
@@ -33,9 +34,10 @@ class CONTENT_EXPORT MessagePortService {
               int* message_port_id);
   void Destroy(int message_port_id);
   void Entangle(int local_message_port_id, int remote_message_port_id);
-  void PostMessage(int sender_message_port_id,
-                   const MessagePortMessage& message,
-                   const std::vector<int>& sent_message_port_ids);
+  void PostMessage(
+      int sender_message_port_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports);
   void QueueMessages(int message_port_id);
   void SendQueuedMessages(int message_port_id,
                           const QueuedMessages& queued_messages);
@@ -72,9 +74,10 @@ class CONTENT_EXPORT MessagePortService {
   MessagePortService();
   ~MessagePortService();
 
-  void PostMessageTo(int message_port_id,
-                     const MessagePortMessage& message,
-                     const std::vector<int>& sent_message_port_ids);
+  void PostMessageTo(
+      int message_port_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports);
 
   // Handles the details of removing a message port id. Before calling this,
   // verify that the message port id exists.
diff --git a/content/browser/navigator_connect/navigator_connect_context_impl.cc b/content/browser/navigator_connect/navigator_connect_context_impl.cc
index 9911b3c..35a02d1 100644
--- a/content/browser/navigator_connect/navigator_connect_context_impl.cc
+++ b/content/browser/navigator_connect/navigator_connect_context_impl.cc
@@ -68,10 +68,8 @@ void NavigatorConnectContextImpl::Connect(
 
   if (!factory) {
     // No factories found.
-    // Destroy ports since connection failed.
-    message_port_service->Destroy(client_port);
-    message_port_service->Destroy(service_port);
-    callback.Run(MSG_ROUTING_NONE, MSG_ROUTING_NONE, false);
+    OnConnectResult(client, client_port, client_port_route_id,
+                    callback, nullptr);
     return;
   }
 
@@ -92,12 +90,15 @@ void NavigatorConnectContextImpl::OnConnectResult(
     // Update service side port with delegate.
     MessagePortService::GetInstance()->UpdateMessagePort(
         client.message_port_id, delegate, client.message_port_id);
-    callback.Run(client_message_port_id, client_port_route_id, true);
+    TransferredMessagePort port;
+    port.id = client_message_port_id;
+    // TODO(mek): Set port.send_value_as_messages depending on connect result.
+    callback.Run(port, client_port_route_id, true);
   } else {
     // Destroy ports since connection failed.
     MessagePortService::GetInstance()->Destroy(client.message_port_id);
     MessagePortService::GetInstance()->Destroy(client_message_port_id);
-    callback.Run(MSG_ROUTING_NONE, MSG_ROUTING_NONE, false);
+    callback.Run(TransferredMessagePort(), MSG_ROUTING_NONE, false);
   }
 }
 
diff --git a/content/browser/navigator_connect/navigator_connect_context_impl.h b/content/browser/navigator_connect/navigator_connect_context_impl.h
index ce18d9c..1f53c53 100644
--- a/content/browser/navigator_connect/navigator_connect_context_impl.h
+++ b/content/browser/navigator_connect/navigator_connect_context_impl.h
@@ -14,9 +14,10 @@
 namespace content {
 
 class MessagePortMessageFilter;
-struct NavigatorConnectClient;
 class NavigatorConnectService;
 class NavigatorConnectServiceFactory;
+struct NavigatorConnectClient;
+struct TransferredMessagePort;
 
 // Tracks all active navigator.connect connections, as well as available service
 // factories. Delegates connection requests to the correct factory and passes
@@ -25,8 +26,10 @@ class NavigatorConnectServiceFactory;
 // TODO(mek): Somehow clean up connections when the client side goes away.
 class NavigatorConnectContextImpl : public NavigatorConnectContext {
  public:
-  using ConnectCallback = base::Callback<
-      void(int message_port_id, int message_port_route_id, bool success)>;
+  using ConnectCallback =
+      base::Callback<void(const TransferredMessagePort& message_port,
+                          int message_port_route_id,
+                          bool success)>;
 
   explicit NavigatorConnectContextImpl();
 
diff --git a/content/browser/navigator_connect/navigator_connect_dispatcher_host.cc b/content/browser/navigator_connect/navigator_connect_dispatcher_host.cc
index d3e0a2d..daa46ba 100644
--- a/content/browser/navigator_connect/navigator_connect_dispatcher_host.cc
+++ b/content/browser/navigator_connect/navigator_connect_dispatcher_host.cc
@@ -48,14 +48,15 @@ void NavigatorConnectDispatcherHost::OnConnect(
                  thread_id, request_id));
 }
 
-void NavigatorConnectDispatcherHost::OnConnectResult(int thread_id,
-                                                     int request_id,
-                                                     int message_port_id,
-                                                     int message_port_route_id,
-                                                     bool accept_connection) {
+void NavigatorConnectDispatcherHost::OnConnectResult(
+    int thread_id,
+    int request_id,
+    const TransferredMessagePort& message_port,
+    int message_port_route_id,
+    bool accept_connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   Send(new NavigatorConnectMsg_ConnectResult(
-      thread_id, request_id, message_port_id, message_port_route_id,
+      thread_id, request_id, message_port, message_port_route_id,
       accept_connection));
 }
 
diff --git a/content/browser/navigator_connect/navigator_connect_dispatcher_host.h b/content/browser/navigator_connect/navigator_connect_dispatcher_host.h
index 6f22e61..614382e 100644
--- a/content/browser/navigator_connect/navigator_connect_dispatcher_host.h
+++ b/content/browser/navigator_connect/navigator_connect_dispatcher_host.h
@@ -12,8 +12,9 @@ class GURL;
 namespace content {
 
 class MessagePortMessageFilter;
-struct NavigatorConnectClient;
 class NavigatorConnectContextImpl;
+struct NavigatorConnectClient;
+struct TransferredMessagePort;
 
 // Receives navigator.connect connection attempts from a child process.
 // Attempts to find a service that serves the URL the connection is made to
@@ -45,7 +46,7 @@ class NavigatorConnectDispatcherHost : public BrowserMessageFilter {
   // connection event.
   void OnConnectResult(int thread_id,
                        int request_id,
-                       int message_port_id,
+                       const TransferredMessagePort& message_port,
                        int message_port_route_id,
                        bool accept_connection);
 
diff --git a/content/browser/navigator_connect/navigator_connect_service_worker_service_factory.cc b/content/browser/navigator_connect/navigator_connect_service_worker_service_factory.cc
index 149ba81..802ae72 100644
--- a/content/browser/navigator_connect/navigator_connect_service_worker_service_factory.cc
+++ b/content/browser/navigator_connect/navigator_connect_service_worker_service_factory.cc
@@ -30,19 +30,21 @@ class NavigatorConnectServiceWorkerService : public MessagePortDelegate {
   ~NavigatorConnectServiceWorkerService() override;
 
   // MessagePortDelegate implementation.
-  void SendMessage(int route_id,
-                   const MessagePortMessage& message,
-                   const std::vector<int>& sent_message_port_ids) override;
+  void SendMessage(
+      int route_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports) override;
   void SendMessagesAreQueued(int route_id) override;
 
  private:
   // Callback called by SendMessage when the ServiceWorkerRegistration for this
   // service has been located.
-  void DeliverMessage(const base::string16& message,
-                      const std::vector<int>& sent_message_port_ids,
-                      ServiceWorkerStatusCode service_worker_status,
-                      const scoped_refptr<ServiceWorkerRegistration>&
-                          service_worker_registration);
+  void DeliverMessage(
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
+      ServiceWorkerStatusCode service_worker_status,
+      const scoped_refptr<ServiceWorkerRegistration>&
+          service_worker_registration);
 
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
   NavigatorConnectClient client_;
@@ -70,7 +72,7 @@ NavigatorConnectServiceWorkerService::~NavigatorConnectServiceWorkerService() {
 void NavigatorConnectServiceWorkerService::SendMessage(
     int route_id,
     const MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   DCHECK(route_id == client_.message_port_id);
   DCHECK(message.message_as_value.empty());
 
@@ -78,14 +80,14 @@ void NavigatorConnectServiceWorkerService::SendMessage(
   // by the service can be asynchronous. When a message is delivered,
   // WebMessagePortChannelImpl instances will be constructed which send
   // MessagePortHostMsg_ReleaseMessages to release messages.
-  for (int sent_message_port_id : sent_message_port_ids)
-    MessagePortService::GetInstance()->HoldMessages(sent_message_port_id);
+  for (const auto& port : sent_message_ports)
+    MessagePortService::GetInstance()->HoldMessages(port.id);
 
   service_worker_context_->context()->storage()->FindRegistrationForId(
       service_worker_registration_id_, service_worker_registration_origin_,
       base::Bind(&NavigatorConnectServiceWorkerService::DeliverMessage,
                  weak_factory_.GetWeakPtr(), message.message_as_string,
-                 sent_message_port_ids));
+                 sent_message_ports));
 }
 
 void NavigatorConnectServiceWorkerService::SendMessagesAreQueued(int route_id) {
@@ -94,7 +96,7 @@ void NavigatorConnectServiceWorkerService::SendMessagesAreQueued(int route_id) {
 
 void NavigatorConnectServiceWorkerService::DeliverMessage(
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     ServiceWorkerStatusCode service_worker_status,
     const scoped_refptr<ServiceWorkerRegistration>&
         service_worker_registration) {
@@ -111,7 +113,7 @@ void NavigatorConnectServiceWorkerService::DeliverMessage(
   }
 
   active_version->DispatchCrossOriginMessageEvent(
-      client_, message, sent_message_port_ids,
+      client_, message, sent_message_ports,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
diff --git a/content/browser/service_worker/service_worker_dispatcher_host.cc b/content/browser/service_worker/service_worker_dispatcher_host.cc
index 6ffbfc5..6f1d95f 100644
--- a/content/browser/service_worker/service_worker_dispatcher_host.cc
+++ b/content/browser/service_worker/service_worker_dispatcher_host.cc
@@ -495,7 +495,7 @@ void ServiceWorkerDispatcherHost::OnGetRegistration(
 void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
     int handle_id,
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcherHost::OnPostMessageToWorker");
   if (!GetContext())
@@ -508,7 +508,7 @@ void ServiceWorkerDispatcherHost::OnPostMessageToWorker(
   }
 
   handle->version()->DispatchMessageEvent(
-      message, sent_message_port_ids,
+      message, sent_message_ports,
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
diff --git a/content/browser/service_worker/service_worker_dispatcher_host.h b/content/browser/service_worker/service_worker_dispatcher_host.h
index 7290592..e737a20 100644
--- a/content/browser/service_worker/service_worker_dispatcher_host.h
+++ b/content/browser/service_worker/service_worker_dispatcher_host.h
@@ -31,6 +31,7 @@ class ServiceWorkerVersion;
 struct ServiceWorkerObjectInfo;
 struct ServiceWorkerRegistrationObjectInfo;
 struct ServiceWorkerVersionAttributes;
+struct TransferredMessagePort;
 
 class CONTENT_EXPORT ServiceWorkerDispatcherHost : public BrowserMessageFilter {
  public:
@@ -113,16 +114,14 @@ class CONTENT_EXPORT ServiceWorkerDispatcherHost : public BrowserMessageFilter {
   void OnReportConsoleMessage(
       int embedded_worker_id,
       const EmbeddedWorkerHostMsg_ReportConsoleMessage_Params& params);
-  void OnPostMessage(int handle_id,
-                     const base::string16& message,
-                     const std::vector<int>& sent_message_port_ids);
   void OnIncrementServiceWorkerRefCount(int handle_id);
   void OnDecrementServiceWorkerRefCount(int handle_id);
   void OnIncrementRegistrationRefCount(int registration_handle_id);
   void OnDecrementRegistrationRefCount(int registration_handle_id);
-  void OnPostMessageToWorker(int handle_id,
-                             const base::string16& message,
-                             const std::vector<int>& sent_message_port_ids);
+  void OnPostMessageToWorker(
+      int handle_id,
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports);
   void OnServiceWorkerObjectDestroyed(int handle_id);
   void OnTerminateWorker(int handle_id);
 
diff --git a/content/browser/service_worker/service_worker_provider_host.cc b/content/browser/service_worker/service_worker_provider_host.cc
index 6ad3897..6dd627c 100644
--- a/content/browser/service_worker/service_worker_provider_host.cc
+++ b/content/browser/service_worker/service_worker_provider_host.cc
@@ -276,19 +276,19 @@ bool ServiceWorkerProviderHost::CanAssociateRegistration(
 
 void ServiceWorkerProviderHost::PostMessage(
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   if (!dispatcher_host_)
     return;  // Could be NULL in some tests.
 
   std::vector<int> new_routing_ids;
   dispatcher_host_->message_port_message_filter()->
-      UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
+      UpdateMessagePortsWithNewRoutes(sent_message_ports,
                                       &new_routing_ids);
 
   Send(new ServiceWorkerMsg_MessageToDocument(
       kDocumentMainThreadId, provider_id(),
       message,
-      sent_message_port_ids,
+      sent_message_ports,
       new_routing_ids));
 }
 
diff --git a/content/browser/service_worker/service_worker_provider_host.h b/content/browser/service_worker/service_worker_provider_host.h
index 798b7d4..a4f3704 100644
--- a/content/browser/service_worker/service_worker_provider_host.h
+++ b/content/browser/service_worker/service_worker_provider_host.h
@@ -143,8 +143,9 @@ class CONTENT_EXPORT ServiceWorkerProviderHost
   bool IsContextAlive();
 
   // Dispatches message event to the document.
-  void PostMessage(const base::string16& message,
-                   const std::vector<int>& sent_message_port_ids);
+  void PostMessage(
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports);
 
   // Activates the WebContents associated with
   // { render_process_id_, render_frame_id_ }.
diff --git a/content/browser/service_worker/service_worker_version.cc b/content/browser/service_worker/service_worker_version.cc
index 65189d1..747319e 100644
--- a/content/browser/service_worker/service_worker_version.cc
+++ b/content/browser/service_worker/service_worker_version.cc
@@ -153,12 +153,12 @@ void RunErrorFetchCallback(const ServiceWorkerVersion::FetchCallback& callback,
 }
 
 void RunErrorMessageCallback(
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const ServiceWorkerVersion::StatusCallback& callback,
     ServiceWorkerStatusCode status) {
   // Transfering the message ports failed, so destroy the ports.
-  for (int message_port_id : sent_message_port_ids) {
-    MessagePortService::GetInstance()->ClosePort(message_port_id);
+  for (const TransferredMessagePort& port : sent_message_ports) {
+    MessagePortService::GetInstance()->ClosePort(port.id);
   }
   callback.Run(status);
 }
@@ -444,26 +444,26 @@ void ServiceWorkerVersion::SendMessage(
 
 void ServiceWorkerVersion::DispatchMessageEvent(
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
-  for (int message_port_id : sent_message_port_ids) {
-    MessagePortService::GetInstance()->HoldMessages(message_port_id);
+  for (const TransferredMessagePort& port : sent_message_ports) {
+    MessagePortService::GetInstance()->HoldMessages(port.id);
   }
 
-  DispatchMessageEventInternal(message, sent_message_port_ids, callback);
+  DispatchMessageEventInternal(message, sent_message_ports, callback);
 }
 
 void ServiceWorkerVersion::DispatchMessageEventInternal(
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(
         &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
-        base::Bind(&RunErrorMessageCallback, sent_message_port_ids, callback),
+        base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
         base::Bind(&self::DispatchMessageEventInternal,
-                   weak_factory_.GetWeakPtr(), message, sent_message_port_ids,
+                   weak_factory_.GetWeakPtr(), message, sent_message_ports,
                    callback)));
     return;
   }
@@ -471,11 +471,10 @@ void ServiceWorkerVersion::DispatchMessageEventInternal(
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
-  filter->UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
-                                          &new_routing_ids);
+  filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_MessageToWorker(
-          message, sent_message_port_ids, new_routing_ids));
+          message, sent_message_ports, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 
@@ -698,7 +697,7 @@ void ServiceWorkerVersion::DispatchCrossOriginConnectEvent(
 void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
     const NavigatorConnectClient& client,
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const StatusCallback& callback) {
   // Unlike in the case of DispatchMessageEvent, here the caller is assumed to
   // have already put all the sent message ports on hold. So no need to do that
@@ -707,23 +706,24 @@ void ServiceWorkerVersion::DispatchCrossOriginMessageEvent(
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(
-        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+        base::Bind(&RunErrorMessageCallback, sent_message_ports, callback),
         base::Bind(&self::DispatchCrossOriginMessageEvent,
                    weak_factory_.GetWeakPtr(), client, message,
-                   sent_message_port_ids, callback)));
+                   sent_message_ports, callback)));
     return;
   }
 
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
-  filter->UpdateMessagePortsWithNewRoutes(sent_message_port_ids,
-                                          &new_routing_ids);
+  filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginMessageToWorker(
-          client, message, sent_message_port_ids, new_routing_ids));
+          client, message, sent_message_ports, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
+
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(controllee_map_, provider_host));
@@ -1285,7 +1285,7 @@ void ServiceWorkerVersion::OnClearCachedMetadataFinished(int64 callback_id,
 void ServiceWorkerVersion::OnPostMessageToDocument(
     int client_id,
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids) {
+    const std::vector<TransferredMessagePort>& sent_message_ports) {
   TRACE_EVENT1("ServiceWorker",
                "ServiceWorkerVersion::OnPostMessageToDocument",
                "Client id", client_id);
@@ -1295,7 +1295,7 @@ void ServiceWorkerVersion::OnPostMessageToDocument(
     // The client may already have been closed, just ignore.
     return;
   }
-  provider_host->PostMessage(message, sent_message_port_ids);
+  provider_host->PostMessage(message, sent_message_ports);
 }
 
 void ServiceWorkerVersion::OnFocusClient(int request_id, int client_id) {
diff --git a/content/browser/service_worker/service_worker_version.h b/content/browser/service_worker/service_worker_version.h
index 7308e96..2aeaabb 100644
--- a/content/browser/service_worker/service_worker_version.h
+++ b/content/browser/service_worker/service_worker_version.h
@@ -53,6 +53,7 @@ class ServiceWorkerVersionInfo;
 struct NavigatorConnectClient;
 struct PlatformNotificationData;
 struct ServiceWorkerClientInfo;
+struct TransferredMessagePort;
 
 // This class corresponds to a specific version of a ServiceWorker
 // script for a given pattern. When a script is upgraded, there may be
@@ -173,9 +174,10 @@ class CONTENT_EXPORT ServiceWorkerVersion
   void SendMessage(const IPC::Message& message, const StatusCallback& callback);
 
   // Sends a message event to the associated embedded worker.
-  void DispatchMessageEvent(const base::string16& message,
-                            const std::vector<int>& sent_message_port_ids,
-                            const StatusCallback& callback);
+  void DispatchMessageEvent(
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
+      const StatusCallback& callback);
 
   // Sends install event to the associated embedded worker and asynchronously
   // calls |callback| when it errors out or it gets a response from the worker
@@ -264,7 +266,7 @@ class CONTENT_EXPORT ServiceWorkerVersion
   void DispatchCrossOriginMessageEvent(
       const NavigatorConnectClient& client,
       const base::string16& message,
-      const std::vector<int>& sent_message_port_ids,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
       const StatusCallback& callback);
 
   // Adds and removes |provider_host| as a controllee of this ServiceWorker.
@@ -352,7 +354,7 @@ class CONTENT_EXPORT ServiceWorkerVersion
 
   void DispatchMessageEventInternal(
       const base::string16& message,
-      const std::vector<int>& sent_message_port_ids,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
       const StatusCallback& callback);
 
   // Message handlers.
@@ -384,9 +386,10 @@ class CONTENT_EXPORT ServiceWorkerVersion
   void OnClearCachedMetadata(const GURL& url);
   void OnClearCachedMetadataFinished(int64 callback_id, int result);
 
-  void OnPostMessageToDocument(int client_id,
-                               const base::string16& message,
-                               const std::vector<int>& sent_message_port_ids);
+  void OnPostMessageToDocument(
+      int client_id,
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports);
   void OnFocusClient(int request_id, int client_id);
   void OnSkipWaiting(int request_id);
   void OnClaimClients(int request_id);
diff --git a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
index 6407bbf..7ca585e 100644
--- a/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
+++ b/content/browser/shared_worker/shared_worker_service_impl_unittest.cc
@@ -285,11 +285,11 @@ class MockSharedWorkerConnector {
         new MessagePortHostMsg_QueueMessages(remote_port_id_)));
   }
   void SendPostMessage(std::string data) {
-    const std::vector<int> empty_ids;
+    const std::vector<TransferredMessagePort> empty_ports;
     EXPECT_TRUE(
         renderer_host_->OnMessageReceived(new MessagePortHostMsg_PostMessage(
             local_port_id_,
-            MessagePortMessage(base::ASCIIToUTF16(data)), empty_ids)));
+            MessagePortMessage(base::ASCIIToUTF16(data)), empty_ports)));
   }
   void SendConnect() {
     EXPECT_TRUE(
@@ -467,11 +467,11 @@ TEST_F(SharedWorkerServiceImplTest, BasicTest) {
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
-  const std::vector<int> empty_ids;
+  const std::vector<TransferredMessagePort> empty_ports;
   EXPECT_TRUE(
       renderer_host->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector->remote_port_id(),
-          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ids)));
+          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ports)));
   EXPECT_EQ(1U, renderer_host->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host.get(), connector->local_port_route_id(), "test2");
@@ -564,11 +564,11 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
 
   // When SharedWorker side sends MessagePortHostMsg_PostMessage,
   // SharedWorkerConnector side shuold receive MessagePortMsg_Message.
-  const std::vector<int> empty_ids;
+  const std::vector<TransferredMessagePort> empty_ports;
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector0->remote_port_id(),
-          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ids)));
+          MessagePortMessage(base::ASCIIToUTF16("test2")), empty_ports)));
   EXPECT_EQ(1U, renderer_host0->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host0.get(), connector0->local_port_route_id(), "test2");
@@ -647,7 +647,7 @@ TEST_F(SharedWorkerServiceImplTest, TwoRendererTest) {
   EXPECT_TRUE(
       renderer_host0->OnMessageReceived(new MessagePortHostMsg_PostMessage(
           connector1->remote_port_id(),
-          MessagePortMessage(base::ASCIIToUTF16("test4")), empty_ids)));
+          MessagePortMessage(base::ASCIIToUTF16("test4")), empty_ports)));
   EXPECT_EQ(1U, renderer_host1->QueuedMessageCount());
   CheckMessagePortMsgMessage(
       renderer_host1.get(), connector1->local_port_route_id(), "test4");
diff --git a/content/browser/web_contents/web_contents_impl.cc b/content/browser/web_contents/web_contents_impl.cc
index 49b5a5e..ede1642 100644
--- a/content/browser/web_contents/web_contents_impl.cc
+++ b/content/browser/web_contents/web_contents_impl.cc
@@ -4020,7 +4020,7 @@ void WebContentsImpl::RouteMessageEvent(
   // In most cases, we receive this from a swapped out RenderViewHost.
   // It is possible to receive it from one that has just been swapped in,
   // in which case we might as well deliver the message anyway.
-  if (!params.message_port_ids.empty()) {
+  if (!params.message_ports.empty()) {
     // Updating the message port information has to be done in the IO thread;
     // MessagePortMessageFilter::RouteMessageEventWithMessagePorts will send
     // ViewMsg_PostMessageEvent after it's done. Note that a trivial solution
diff --git a/content/child/navigator_connect/navigator_connect_provider.cc b/content/child/navigator_connect/navigator_connect_provider.cc
index 415b7a3..78c3fda 100644
--- a/content/child/navigator_connect/navigator_connect_provider.cc
+++ b/content/child/navigator_connect/navigator_connect_provider.cc
@@ -77,18 +77,19 @@ NavigatorConnectProvider* NavigatorConnectProvider::ThreadSpecificInstance(
   return provider;
 }
 
-void NavigatorConnectProvider::OnConnectResult(int thread_id,
-                                               int request_id,
-                                               int message_port_id,
-                                               int message_port_route_id,
-                                               bool allow_connect) {
+void NavigatorConnectProvider::OnConnectResult(
+    int thread_id,
+    int request_id,
+    const TransferredMessagePort& message_port,
+    int message_port_route_id,
+    bool allow_connect) {
   blink::WebNavigatorConnectPortCallbacks* callbacks =
       requests_.Lookup(request_id);
   DCHECK(callbacks);
 
   if (allow_connect) {
     WebMessagePortChannelImpl* channel = new WebMessagePortChannelImpl(
-        message_port_route_id, message_port_id, main_loop_);
+        message_port_route_id, message_port, main_loop_);
     callbacks->onSuccess(channel);
   } else {
     callbacks->onError();
diff --git a/content/child/navigator_connect/navigator_connect_provider.h b/content/child/navigator_connect/navigator_connect_provider.h
index 8ef6d17..f21b0c4 100644
--- a/content/child/navigator_connect/navigator_connect_provider.h
+++ b/content/child/navigator_connect/navigator_connect_provider.h
@@ -28,6 +28,7 @@ class Message;
 
 namespace content {
 class ThreadSafeSender;
+struct TransferredMessagePort;
 
 // Main entry point for the navigator.connect API in a child process. This
 // implements the blink API and passes connect calls on to the browser process.
@@ -60,7 +61,7 @@ class NavigatorConnectProvider : public blink::WebNavigatorConnectProvider,
  private:
   void OnConnectResult(int thread_id,
                        int request_id,
-                       int message_port_id,
+                       const TransferredMessagePort& message_port,
                        int message_port_route_id,
                        bool allow_connect);
 
diff --git a/content/child/service_worker/service_worker_dispatcher.cc b/content/child/service_worker/service_worker_dispatcher.cc
index 2a713bc..39c23da 100644
--- a/content/child/service_worker/service_worker_dispatcher.cc
+++ b/content/child/service_worker/service_worker_dispatcher.cc
@@ -632,7 +632,7 @@ void ServiceWorkerDispatcher::OnPostMessage(
     int thread_id,
     int provider_id,
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   // Make sure we're on the main document thread. (That must be the only
   // thread we get this message)
@@ -648,15 +648,10 @@ void ServiceWorkerDispatcher::OnPostMessage(
     return;
   }
 
-  std::vector<WebMessagePortChannelImpl*> ports;
-  if (!sent_message_port_ids.empty()) {
-    ports.resize(sent_message_port_ids.size());
-    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-      ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i],
-          base::MessageLoopProxy::current());
-    }
-  }
+  blink::WebMessagePortChannelArray ports =
+      WebMessagePortChannelImpl::CreatePorts(sent_message_ports,
+                                             new_routing_ids,
+                                             base::MessageLoopProxy::current());
 
   found->second->dispatchMessageEvent(message, ports);
 }
diff --git a/content/child/service_worker/service_worker_dispatcher.h b/content/child/service_worker/service_worker_dispatcher.h
index 9ef86cc..e7ef59b 100644
--- a/content/child/service_worker/service_worker_dispatcher.h
+++ b/content/child/service_worker/service_worker_dispatcher.h
@@ -36,6 +36,7 @@ class WebServiceWorkerRegistrationImpl;
 struct ServiceWorkerObjectInfo;
 struct ServiceWorkerRegistrationObjectInfo;
 struct ServiceWorkerVersionAttributes;
+struct TransferredMessagePort;
 
 // This class manages communication with the browser process about
 // registration of the service worker, exposed to renderer and worker
@@ -200,11 +201,12 @@ class ServiceWorkerDispatcher : public WorkerTaskRunner::Observer {
                                     int provider_id,
                                     const ServiceWorkerObjectInfo& info,
                                     bool should_notify_controllerchange);
-  void OnPostMessage(int thread_id,
-                     int provider_id,
-                     const base::string16& message,
-                     const std::vector<int>& sent_message_port_ids,
-                     const std::vector<int>& new_routing_ids);
+  void OnPostMessage(
+      int thread_id,
+      int provider_id,
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
+      const std::vector<int>& new_routing_ids);
 
   void SetReadyRegistration(
       int provider_id,
diff --git a/content/child/webmessageportchannel_impl.cc b/content/child/webmessageportchannel_impl.cc
index 9aff263..86764af 100644
--- a/content/child/webmessageportchannel_impl.cc
+++ b/content/child/webmessageportchannel_impl.cc
@@ -36,12 +36,12 @@ WebMessagePortChannelImpl::WebMessagePortChannelImpl(
 
 WebMessagePortChannelImpl::WebMessagePortChannelImpl(
     int route_id,
-    int message_port_id,
+    const TransferredMessagePort& port,
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner)
     : client_(NULL),
       route_id_(route_id),
-      message_port_id_(message_port_id),
-      send_messages_as_values_(false),
+      message_port_id_(port.id),
+      send_messages_as_values_(port.send_messages_as_values),
       main_thread_task_runner_(main_thread_task_runner) {
   AddRef();
   Init();
@@ -50,7 +50,7 @@ WebMessagePortChannelImpl::WebMessagePortChannelImpl(
 WebMessagePortChannelImpl::~WebMessagePortChannelImpl() {
   // If we have any queued messages with attached ports, manually destroy them.
   while (!message_queue_.empty()) {
-    const std::vector<WebMessagePortChannelImpl*>& channel_array =
+    const WebMessagePortChannelArray& channel_array =
         message_queue_.front().ports;
     for (size_t i = 0; i < channel_array.size(); i++) {
       channel_array[i]->destroy();
@@ -83,25 +83,53 @@ void WebMessagePortChannelImpl::CreatePair(
 }
 
 // static
-std::vector<int> WebMessagePortChannelImpl::ExtractMessagePortIDs(
+std::vector<TransferredMessagePort>
+WebMessagePortChannelImpl::ExtractMessagePortIDs(
     WebMessagePortChannelArray* channels) {
-  std::vector<int> message_port_ids;
+  std::vector<TransferredMessagePort> message_ports;
   if (channels) {
-    message_port_ids.resize(channels->size());
     // Extract the port IDs from the source array, then free it.
-    for (size_t i = 0; i < channels->size(); ++i) {
-      WebMessagePortChannelImpl* webchannel =
-          static_cast<WebMessagePortChannelImpl*>((*channels)[i]);
-      // The message port ids might not be set up yet if this channel
-      // wasn't created on the main thread.
-      DCHECK(webchannel->main_thread_task_runner_->BelongsToCurrentThread());
-      message_port_ids[i] = webchannel->message_port_id();
-      webchannel->QueueMessages();
-      DCHECK(message_port_ids[i] != MSG_ROUTING_NONE);
-    }
+    message_ports = ExtractMessagePortIDs(*channels);
     delete channels;
   }
-  return message_port_ids;
+  return message_ports;
+}
+
+// static
+std::vector<TransferredMessagePort>
+WebMessagePortChannelImpl::ExtractMessagePortIDs(
+    const WebMessagePortChannelArray& channels) {
+  std::vector<TransferredMessagePort> message_ports(channels.size());
+  for (size_t i = 0; i < channels.size(); ++i) {
+    WebMessagePortChannelImpl* webchannel =
+        static_cast<WebMessagePortChannelImpl*>(channels[i]);
+    // The message port ids might not be set up yet if this channel
+    // wasn't created on the main thread.
+    DCHECK(webchannel->main_thread_task_runner_->BelongsToCurrentThread());
+    message_ports[i].id = webchannel->message_port_id();
+    message_ports[i].send_messages_as_values =
+        webchannel->send_messages_as_values_;
+    webchannel->QueueMessages();
+    DCHECK(message_ports[i].id != MSG_ROUTING_NONE);
+  }
+  return message_ports;
+}
+
+// static
+WebMessagePortChannelArray WebMessagePortChannelImpl::CreatePorts(
+    const std::vector<TransferredMessagePort>& message_ports,
+    const std::vector<int>& new_routing_ids,
+    const scoped_refptr<base::SingleThreadTaskRunner>&
+        main_thread_task_runner) {
+  DCHECK_EQ(message_ports.size(), new_routing_ids.size());
+  WebMessagePortChannelArray channels(message_ports.size());
+  for (size_t i = 0; i < message_ports.size() && i < new_routing_ids.size();
+       ++i) {
+    channels[i] = new WebMessagePortChannelImpl(
+        new_routing_ids[i], message_ports[i],
+        main_thread_task_runner);
+  }
+  return channels;
 }
 
 void WebMessagePortChannelImpl::setClient(WebMessagePortChannelClient* client) {
@@ -174,14 +202,7 @@ bool WebMessagePortChannelImpl::tryGetMessage(
   } else {
     *message = message_queue_.front().message.message_as_string;
   }
-  const std::vector<WebMessagePortChannelImpl*>& channel_array =
-      message_queue_.front().ports;
-  WebMessagePortChannelArray result_ports(channel_array.size());
-  for (size_t i = 0; i < channel_array.size(); i++) {
-    result_ports[i] = channel_array[i];
-  }
-
-  channels.swap(result_ports);
+  channels = message_queue_.front().ports;
   message_queue_.pop();
   return true;
 }
@@ -263,19 +284,13 @@ bool WebMessagePortChannelImpl::OnMessageReceived(const IPC::Message& message) {
 
 void WebMessagePortChannelImpl::OnMessage(
     const MessagePortMessage& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   base::AutoLock auto_lock(lock_);
   Message msg;
   msg.message = message;
-  if (!sent_message_port_ids.empty()) {
-    msg.ports.resize(sent_message_port_ids.size());
-    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-      msg.ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i],
-          main_thread_task_runner_.get());
-    }
-  }
+  msg.ports = CreatePorts(sent_message_ports, new_routing_ids,
+                          main_thread_task_runner_.get());
 
   bool was_empty = message_queue_.empty();
   message_queue_.push(msg);
@@ -291,14 +306,9 @@ void WebMessagePortChannelImpl::OnMessagesQueued() {
     queued_messages.reserve(message_queue_.size());
     while (!message_queue_.empty()) {
       MessagePortMessage message = message_queue_.front().message;
-      const std::vector<WebMessagePortChannelImpl*>& channel_array =
-          message_queue_.front().ports;
-      std::vector<int> port_ids(channel_array.size());
-      for (size_t i = 0; i < channel_array.size(); ++i) {
-        port_ids[i] = channel_array[i]->message_port_id();
-        channel_array[i]->QueueMessages();
-      }
-      queued_messages.push_back(std::make_pair(message, port_ids));
+      std::vector<TransferredMessagePort> ports =
+          ExtractMessagePortIDs(message_queue_.front().ports);
+      queued_messages.push_back(std::make_pair(message, ports));
       message_queue_.pop();
     }
   }
diff --git a/content/child/webmessageportchannel_impl.h b/content/child/webmessageportchannel_impl.h
index cb87aff..4b9c273 100644
--- a/content/child/webmessageportchannel_impl.h
+++ b/content/child/webmessageportchannel_impl.h
@@ -36,7 +36,7 @@ class WebMessagePortChannelImpl
           main_thread_task_runner);
   WebMessagePortChannelImpl(
       int route_id,
-      int message_port_id,
+      const TransferredMessagePort& port,
       const scoped_refptr<base::SingleThreadTaskRunner>&
           main_thread_task_runner);
 
@@ -48,9 +48,22 @@ class WebMessagePortChannelImpl
 
   // Extracts port IDs for passing on to the browser process, and queues any
   // received messages. Takes ownership of the passed array (and deletes it).
-  static std::vector<int> ExtractMessagePortIDs(
+  static std::vector<TransferredMessagePort> ExtractMessagePortIDs(
       blink::WebMessagePortChannelArray* channels);
 
+  // Extracts port IDs for passing on to the browser process, and queues any
+  // received messages.
+  static std::vector<TransferredMessagePort> ExtractMessagePortIDs(
+      const blink::WebMessagePortChannelArray& channels);
+
+  // Creates WebMessagePortChannelImpl instances for port IDs passed in from the
+  // browser process.
+  static blink::WebMessagePortChannelArray CreatePorts(
+      const std::vector<TransferredMessagePort>& message_ports,
+      const std::vector<int>& new_routing_ids,
+      const scoped_refptr<base::SingleThreadTaskRunner>&
+          main_thread_task_runner);
+
   // Queues received and incoming messages until there are no more in-flight
   // messages, then sends all of them to the browser process.
   void QueueMessages();
@@ -78,7 +91,7 @@ class WebMessagePortChannelImpl
   bool OnMessageReceived(const IPC::Message& message) override;
 
   void OnMessage(const MessagePortMessage& message,
-                 const std::vector<int>& sent_message_port_ids,
+                 const std::vector<TransferredMessagePort>& sent_message_ports,
                  const std::vector<int>& new_routing_ids);
   void OnMessagesQueued();
 
@@ -87,7 +100,7 @@ class WebMessagePortChannelImpl
     ~Message();
 
     MessagePortMessage message;
-    std::vector<WebMessagePortChannelImpl*> ports;
+    blink::WebMessagePortChannelArray ports;
   };
 
   typedef std::queue<Message> MessageQueue;
diff --git a/content/common/message_port_messages.h b/content/common/message_port_messages.h
index be748a8..d2c6fb8 100644
--- a/content/common/message_port_messages.h
+++ b/content/common/message_port_messages.h
@@ -26,7 +26,8 @@
 #ifndef CONTENT_COMMON_MESSAGE_PORT_MESSAGES_H_
 #define CONTENT_COMMON_MESSAGE_PORT_MESSAGES_H_
 
-typedef std::pair<content::MessagePortMessage, std::vector<int>> QueuedMessage;
+typedef std::pair<content::MessagePortMessage,
+                  std::vector<content::TransferredMessagePort>> QueuedMessage;
 
 #endif  // CONTENT_COMMON_MESSAGE_PORT_MESSAGES_H_
 
@@ -35,15 +36,21 @@ IPC_STRUCT_TRAITS_BEGIN(content::MessagePortMessage)
   IPC_STRUCT_TRAITS_MEMBER(message_as_value)
 IPC_STRUCT_TRAITS_END()
 
+IPC_STRUCT_TRAITS_BEGIN(content::TransferredMessagePort)
+  IPC_STRUCT_TRAITS_MEMBER(id)
+  IPC_STRUCT_TRAITS_MEMBER(send_messages_as_values)
+IPC_STRUCT_TRAITS_END()
+
 //-----------------------------------------------------------------------------
 // MessagePort messages
 // These are messages sent from the browser to child processes.
 
 // Sends a message to a message port.
-IPC_MESSAGE_ROUTED3(MessagePortMsg_Message,
-                    content::MessagePortMessage /* message */,
-                    std::vector<int> /* sent_message_port_ids */,
-                    std::vector<int> /* new_routing_ids */)
+IPC_MESSAGE_ROUTED3(
+    MessagePortMsg_Message,
+    content::MessagePortMessage /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */,
+    std::vector<int> /* new_routing_ids */)
 
 // Tells the Message Port Channel object that there are no more in-flight
 // messages arriving.
@@ -66,10 +73,11 @@ IPC_MESSAGE_CONTROL1(MessagePortHostMsg_DestroyMessagePort,
 
 // Sends a message to a message port.  Optionally sends a message port as
 // as well if sent_message_port_id != MSG_ROUTING_NONE.
-IPC_MESSAGE_CONTROL3(MessagePortHostMsg_PostMessage,
-                     int /* sender_message_port_id */,
-                     content::MessagePortMessage /* message */,
-                     std::vector<int> /* sent_message_port_ids */)
+IPC_MESSAGE_CONTROL3(
+    MessagePortHostMsg_PostMessage,
+    int /* sender_message_port_id */,
+    content::MessagePortMessage /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */)
 
 // Causes messages sent to the remote port to be delivered to this local port.
 IPC_MESSAGE_CONTROL2(MessagePortHostMsg_Entangle,
diff --git a/content/common/navigator_connect_messages.h b/content/common/navigator_connect_messages.h
index af6dcb9..760a69a 100644
--- a/content/common/navigator_connect_messages.h
+++ b/content/common/navigator_connect_messages.h
@@ -4,6 +4,7 @@
 
 // IPC messages for navigator.connect
 
+#include "content/public/common/message_port_types.h"
 #include "content/public/common/navigator_connect_client.h"
 #include "ipc/ipc_message_macros.h"
 #include "url/gurl.h"
@@ -26,6 +27,6 @@ IPC_MESSAGE_CONTROL3(NavigatorConnectHostMsg_Connect,
 IPC_MESSAGE_CONTROL5(NavigatorConnectMsg_ConnectResult,
                      int /* thread_id */,
                      int /* request_id */,
-                     int /* message_port_id */,
+                     content::TransferredMessagePort /* message_port */,
                      int /* message_port_route_id */,
                      bool /* allow_connect */)
diff --git a/content/common/service_worker/service_worker_messages.h b/content/common/service_worker/service_worker_messages.h
index 0acdfe9..f883f37 100644
--- a/content/common/service_worker/service_worker_messages.h
+++ b/content/common/service_worker/service_worker_messages.h
@@ -11,6 +11,7 @@
 #include "content/common/service_worker/service_worker_client_info.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/public/common/message_port_types.h"
 #include "content/public/common/navigator_connect_client.h"
 #include "content/public/common/platform_notification_data.h"
 #include "ipc/ipc_message_macros.h"
@@ -145,10 +146,11 @@ IPC_MESSAGE_CONTROL4(ServiceWorkerHostMsg_GetRegistration,
                      GURL /* document_url */)
 
 // Sends a 'message' event to a service worker (renderer->browser).
-IPC_MESSAGE_CONTROL3(ServiceWorkerHostMsg_PostMessageToWorker,
-                     int /* handle_id */,
-                     base::string16 /* message */,
-                     std::vector<int> /* sent_message_port_ids */)
+IPC_MESSAGE_CONTROL3(
+    ServiceWorkerHostMsg_PostMessageToWorker,
+    int /* handle_id */,
+    base::string16 /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */)
 
 // Informs the browser of a new ServiceWorkerProvider in the child process,
 // |provider_id| is unique within its child process.
@@ -229,10 +231,11 @@ IPC_MESSAGE_ROUTED1(ServiceWorkerHostMsg_GetClientDocuments,
                     int /* request_id */)
 
 // Sends a 'message' event to a client document (renderer->browser).
-IPC_MESSAGE_ROUTED3(ServiceWorkerHostMsg_PostMessageToDocument,
-                    int /* client_id */,
-                    base::string16 /* message */,
-                    std::vector<int> /* sent_message_port_ids */)
+IPC_MESSAGE_ROUTED3(
+    ServiceWorkerHostMsg_PostMessageToDocument,
+    int /* client_id */,
+    base::string16 /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */)
 
 // ServiceWorker -> Browser message to request that the ServiceWorkerStorage
 // cache |data| associated with |url|.
@@ -414,12 +417,13 @@ IPC_MESSAGE_CONTROL4(ServiceWorkerMsg_SetControllerServiceWorker,
                      bool /* should_notify_controllerchange */)
 
 // Sends a 'message' event to a client document (browser->renderer).
-IPC_MESSAGE_CONTROL5(ServiceWorkerMsg_MessageToDocument,
-                     int /* thread_id */,
-                     int /* provider_id */,
-                     base::string16 /* message */,
-                     std::vector<int> /* sent_message_port_ids */,
-                     std::vector<int> /* new_routing_ids */)
+IPC_MESSAGE_CONTROL5(
+    ServiceWorkerMsg_MessageToDocument,
+    int /* thread_id */,
+    int /* provider_id */,
+    base::string16 /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */,
+    std::vector<int> /* new_routing_ids */)
 
 // Sent via EmbeddedWorker to dispatch events.
 IPC_MESSAGE_CONTROL2(ServiceWorkerMsg_InstallEvent,
@@ -447,15 +451,17 @@ IPC_MESSAGE_CONTROL4(ServiceWorkerMsg_GeofencingEvent,
 IPC_MESSAGE_CONTROL2(ServiceWorkerMsg_CrossOriginConnectEvent,
                      int /* request_id */,
                      content::NavigatorConnectClient /* client */)
-IPC_MESSAGE_CONTROL3(ServiceWorkerMsg_MessageToWorker,
-                     base::string16 /* message */,
-                     std::vector<int> /* sent_message_port_ids */,
-                     std::vector<int> /* new_routing_ids */)
-IPC_MESSAGE_CONTROL4(ServiceWorkerMsg_CrossOriginMessageToWorker,
-                     content::NavigatorConnectClient /* client */,
-                     base::string16 /* message */,
-                     std::vector<int> /* sent_message_port_ids */,
-                     std::vector<int> /* new_routing_ids */)
+IPC_MESSAGE_CONTROL3(
+    ServiceWorkerMsg_MessageToWorker,
+    base::string16 /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */,
+    std::vector<int> /* new_routing_ids */)
+IPC_MESSAGE_CONTROL4(
+    ServiceWorkerMsg_CrossOriginMessageToWorker,
+    content::NavigatorConnectClient /* client */,
+    base::string16 /* message */,
+    std::vector<content::TransferredMessagePort> /* sent_message_ports */,
+    std::vector<int> /* new_routing_ids */)
 IPC_MESSAGE_CONTROL1(ServiceWorkerMsg_DidSkipWaiting,
                      int /* request_id */)
 IPC_MESSAGE_CONTROL1(ServiceWorkerMsg_DidClaimClients,
diff --git a/content/common/view_messages.h b/content/common/view_messages.h
index 1cb5442..c24b176 100644
--- a/content/common/view_messages.h
+++ b/content/common/view_messages.h
@@ -24,6 +24,7 @@
 #include "content/public/common/file_chooser_file_info.h"
 #include "content/public/common/file_chooser_params.h"
 #include "content/public/common/menu_item.h"
+#include "content/public/common/message_port_types.h"
 #include "content/public/common/page_state.h"
 #include "content/public/common/page_zoom.h"
 #include "content/public/common/referrer.h"
@@ -535,7 +536,7 @@ IPC_STRUCT_BEGIN(ViewMsg_PostMessage_Params)
   IPC_STRUCT_MEMBER(base::string16, target_origin)
 
   // Information about the MessagePorts this message contains.
-  IPC_STRUCT_MEMBER(std::vector<int>, message_port_ids)
+  IPC_STRUCT_MEMBER(std::vector<content::TransferredMessagePort>, message_ports)
   IPC_STRUCT_MEMBER(std::vector<int>, new_routing_ids)
 IPC_STRUCT_END()
 
diff --git a/content/public/browser/message_port_delegate.h b/content/public/browser/message_port_delegate.h
index 7b89e4d..7c2de5b 100644
--- a/content/public/browser/message_port_delegate.h
+++ b/content/public/browser/message_port_delegate.h
@@ -17,6 +17,7 @@
 
 namespace content {
 struct MessagePortMessage;
+struct TransferredMessagePort;
 
 // Delegate used by MessagePortService to send messages to message ports to the
 // correct renderer. Delegates are responsible for managing their own lifetime,
@@ -26,9 +27,10 @@ class CONTENT_EXPORT MessagePortDelegate {
  public:
   // Sends a message to the given route. Implementations are responsible for
   // updating MessagePortService with new routes for the sent message ports.
-  virtual void SendMessage(int route_id,
-                           const MessagePortMessage& message,
-                           const std::vector<int>& sent_message_port_ids) = 0;
+  virtual void SendMessage(
+      int route_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports) = 0;
 
   // Requests messages to the given route to be queued.
   virtual void SendMessagesAreQueued(int route_id) = 0;
diff --git a/content/public/browser/message_port_provider.h b/content/public/browser/message_port_provider.h
index c9b6574..4fdeb84 100644
--- a/content/public/browser/message_port_provider.h
+++ b/content/public/browser/message_port_provider.h
@@ -15,8 +15,9 @@
 namespace content {
 
 class MessagePortDelegate;
-struct MessagePortMessage;
 class WebContents;
+struct MessagePortMessage;
+struct TransferredMessagePort;
 
 // An interface consisting of methods that can be called to use Message ports.
 class CONTENT_EXPORT MessagePortProvider {
@@ -27,11 +28,12 @@ class CONTENT_EXPORT MessagePortProvider {
   // See https://html.spec.whatwg.org/multipage/comms.html#messageevent for
   // further information on message events.
   // Should be called on UI thread.
-  static void PostMessageToFrame(WebContents* web_contents,
-                                 const base::string16& source_origin,
-                                 const base::string16& target_origin,
-                                 const base::string16& data,
-                                 const std::vector<int>& ports);
+  static void PostMessageToFrame(
+      WebContents* web_contents,
+      const base::string16& source_origin,
+      const base::string16& target_origin,
+      const base::string16& data,
+      const std::vector<TransferredMessagePort>& ports);
 
   // Creates a message channel and provide the ids of the message ports that are
   // associated with this message channel.
@@ -44,9 +46,10 @@ class CONTENT_EXPORT MessagePortProvider {
                                    int* port2);
 
   // Posts a MessageEvent to a message port associated with a message channel.
-  static void PostMessageToPort(int sender_port_id,
-                                const MessagePortMessage& message,
-                                const std::vector<int>& sent_ports);
+  static void PostMessageToPort(
+      int sender_port_id,
+      const MessagePortMessage& message,
+      const std::vector<TransferredMessagePort>& sent_ports);
 
   // Close the message port. Should be called on IO thread.
   static void ClosePort(int message_port_id);
diff --git a/content/public/common/message_port_types.h b/content/public/common/message_port_types.h
index 961afe2..cf53d08 100644
--- a/content/public/common/message_port_types.h
+++ b/content/public/common/message_port_types.h
@@ -11,6 +11,7 @@
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "content/common/content_export.h"
+#include "ipc/ipc_message.h"
 
 namespace content {
 
@@ -37,6 +38,11 @@ struct CONTENT_EXPORT MessagePortMessage {
   base::ListValue message_as_value;
 };
 
+struct TransferredMessagePort {
+  int id = MSG_ROUTING_NONE;
+  bool send_messages_as_values = false;
+};
+
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_COMMON_MESSAGE_PORT_TYPES_H_
diff --git a/content/renderer/render_frame_impl.cc b/content/renderer/render_frame_impl.cc
index 6273518..47e05b5 100644
--- a/content/renderer/render_frame_impl.cc
+++ b/content/renderer/render_frame_impl.cc
@@ -3425,19 +3425,8 @@ bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
   if (!target_origin.isNull())
     params.target_origin = target_origin.toString();
 
-  blink::WebMessagePortChannelArray channels = event.releaseChannels();
-  if (!channels.isEmpty()) {
-    std::vector<int> message_port_ids(channels.size());
-     // Extract the port IDs from the channel array.
-     for (size_t i = 0; i < channels.size(); ++i) {
-       WebMessagePortChannelImpl* webchannel =
-           static_cast<WebMessagePortChannelImpl*>(channels[i]);
-       message_port_ids[i] = webchannel->message_port_id();
-       webchannel->QueueMessages();
-       DCHECK_NE(message_port_ids[i], MSG_ROUTING_NONE);
-     }
-     params.message_port_ids = message_port_ids;
-  }
+  params.message_ports =
+      WebMessagePortChannelImpl::ExtractMessagePortIDs(event.releaseChannels());
 
   // Include the routing ID for the source frame (if one exists), which the
   // browser process will translate into the routing ID for the equivalent
diff --git a/content/renderer/render_frame_proxy.cc b/content/renderer/render_frame_proxy.cc
index 733a0bb..90e7cea 100644
--- a/content/renderer/render_frame_proxy.cc
+++ b/content/renderer/render_frame_proxy.cc
@@ -289,19 +289,8 @@ void RenderFrameProxy::postMessageEvent(
   if (!target_origin.isNull())
     params.target_origin = target_origin.toString();
 
-  blink::WebMessagePortChannelArray channels = event.releaseChannels();
-  if (!channels.isEmpty()) {
-    std::vector<int> message_port_ids(channels.size());
-     // Extract the port IDs from the channel array.
-     for (size_t i = 0; i < channels.size(); ++i) {
-       WebMessagePortChannelImpl* webchannel =
-           static_cast<WebMessagePortChannelImpl*>(channels[i]);
-       message_port_ids[i] = webchannel->message_port_id();
-       webchannel->QueueMessages();
-       DCHECK_NE(message_port_ids[i], MSG_ROUTING_NONE);
-     }
-     params.message_port_ids = message_port_ids;
-  }
+  params.message_ports =
+      WebMessagePortChannelImpl::ExtractMessagePortIDs(event.releaseChannels());
 
   // Include the routing ID for the source frame (if one exists), which the
   // browser process will translate into the routing ID for the equivalent
diff --git a/content/renderer/render_view_impl.cc b/content/renderer/render_view_impl.cc
index 19fb20a..6519f37 100644
--- a/content/renderer/render_view_impl.cc
+++ b/content/renderer/render_view_impl.cc
@@ -2785,16 +2785,10 @@ void RenderViewImpl::OnPostMessageEvent(
   }
 
   // If the message contained MessagePorts, create the corresponding endpoints.
-  DCHECK_EQ(params.message_port_ids.size(), params.new_routing_ids.size());
-  blink::WebMessagePortChannelArray channels(params.message_port_ids.size());
-  for (size_t i = 0;
-       i < params.message_port_ids.size() && i < params.new_routing_ids.size();
-       ++i) {
-    channels[i] =
-        new WebMessagePortChannelImpl(params.new_routing_ids[i],
-                                      params.message_port_ids[i],
-                                      base::MessageLoopProxy::current().get());
-  }
+  blink::WebMessagePortChannelArray channels =
+      WebMessagePortChannelImpl::CreatePorts(
+          params.message_ports, params.new_routing_ids,
+          base::MessageLoopProxy::current().get());
 
   WebSerializedScriptValue serialized_script_value;
   if (params.is_data_raw_string) {
diff --git a/content/renderer/service_worker/service_worker_script_context.cc b/content/renderer/service_worker/service_worker_script_context.cc
index 90d539e..1466184 100644
--- a/content/renderer/service_worker/service_worker_script_context.cc
+++ b/content/renderer/service_worker/service_worker_script_context.cc
@@ -408,20 +408,14 @@ void ServiceWorkerScriptContext::OnCrossOriginConnectEvent(
 
 void ServiceWorkerScriptContext::OnPostMessage(
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnPostEvent");
-  std::vector<WebMessagePortChannelImpl*> ports;
-  if (!sent_message_port_ids.empty()) {
-    base::SingleThreadTaskRunner* task_runner =
-        embedded_context_->main_thread_task_runner();
-    ports.resize(sent_message_port_ids.size());
-    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-      ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i], task_runner);
-    }
-  }
+  blink::WebMessagePortChannelArray ports =
+      WebMessagePortChannelImpl::CreatePorts(
+          sent_message_ports, new_routing_ids,
+          embedded_context_->main_thread_task_runner());
 
   // dispatchMessageEvent is expected to execute onmessage function
   // synchronously.
@@ -435,20 +429,14 @@ void ServiceWorkerScriptContext::OnPostMessage(
 void ServiceWorkerScriptContext::OnCrossOriginMessageToWorker(
     const NavigatorConnectClient& client,
     const base::string16& message,
-    const std::vector<int>& sent_message_port_ids,
+    const std::vector<TransferredMessagePort>& sent_message_ports,
     const std::vector<int>& new_routing_ids) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerScriptContext::OnCrossOriginMessageToWorker");
-  std::vector<WebMessagePortChannelImpl*> ports;
-  if (!sent_message_port_ids.empty()) {
-    base::SingleThreadTaskRunner* task_runner =
-        embedded_context_->main_thread_task_runner();
-    ports.resize(sent_message_port_ids.size());
-    for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
-      ports[i] = new WebMessagePortChannelImpl(
-          new_routing_ids[i], sent_message_port_ids[i], task_runner);
-    }
-  }
+  blink::WebMessagePortChannelArray ports =
+      WebMessagePortChannelImpl::CreatePorts(
+          sent_message_ports, new_routing_ids,
+          embedded_context_->main_thread_task_runner());
 
   blink::WebCrossOriginServiceWorkerClient web_client;
   web_client.origin = client.origin;
diff --git a/content/renderer/service_worker/service_worker_script_context.h b/content/renderer/service_worker/service_worker_script_context.h
index ea1f316..1517e0fd 100644
--- a/content/renderer/service_worker/service_worker_script_context.h
+++ b/content/renderer/service_worker/service_worker_script_context.h
@@ -127,13 +127,14 @@ class ServiceWorkerScriptContext {
                          const blink::WebCircularGeofencingRegion& region);
   void OnCrossOriginConnectEvent(int request_id,
                                  const NavigatorConnectClient& client);
-  void OnPostMessage(const base::string16& message,
-                     const std::vector<int>& sent_message_port_ids,
-                     const std::vector<int>& new_routing_ids);
+  void OnPostMessage(
+      const base::string16& message,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
+      const std::vector<int>& new_routing_ids);
   void OnCrossOriginMessageToWorker(
       const NavigatorConnectClient& client,
       const base::string16& message,
-      const std::vector<int>& sent_message_port_ids,
+      const std::vector<TransferredMessagePort>& sent_message_ports,
       const std::vector<int>& new_routing_ids);
   void OnDidGetClientDocuments(
       int request_id, const std::vector<ServiceWorkerClientInfo>& clients);
diff --git a/content/renderer/shared_worker/embedded_shared_worker_stub.cc b/content/renderer/shared_worker/embedded_shared_worker_stub.cc
index 4bcc639..8f9a809 100644
--- a/content/renderer/shared_worker/embedded_shared_worker_stub.cc
+++ b/content/renderer/shared_worker/embedded_shared_worker_stub.cc
@@ -274,9 +274,11 @@ void EmbeddedSharedWorkerStub::ConnectToChannel(
 
 void EmbeddedSharedWorkerStub::OnConnect(int sent_message_port_id,
                                          int routing_id) {
+  TransferredMessagePort port;
+  port.id = sent_message_port_id;
   WebMessagePortChannelImpl* channel =
       new WebMessagePortChannelImpl(routing_id,
-                                    sent_message_port_id,
+                                    port,
                                     base::MessageLoopProxy::current().get());
   if (runing_) {
     ConnectToChannel(channel);