Connections now take a ConnectionParams instead of a pipe handle.

mojo/edk/system/node_channel.cc

 // Copyright 2016 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 "mojo/edk/system/node_channel.h"
 
 #include <cstring>
 #include <limits>
 #include <sstream>
 
@@ skipping 142 matching lines @@
   *out_data = reinterpret_cast<const DataType*>(
       static_cast<const char*>(bytes) + sizeof(Header));
   return true;
 }
 
 }  // namespace
 
 // static
 scoped_refptr<NodeChannel> NodeChannel::Create(
     Delegate* delegate,
-    ScopedPlatformHandle platform_handle,
+    ConnectionParam connection_param,
     scoped_refptr<base::TaskRunner> io_task_runner,
     const ProcessErrorCallback& process_error_callback) {
 #if defined(OS_NACL_SFI)
   LOG(FATAL) << "Multi-process not yet supported on NaCl-SFI";
   return nullptr;
 #else
-  return new NodeChannel(delegate, std::move(platform_handle), io_task_runner,
+  return new NodeChannel(delegate, std::move(connection_param), io_task_runner,
                          process_error_callback);
 #endif
 }
 
 // static
 Channel::MessagePtr NodeChannel::CreatePortsMessage(size_t payload_size,
                                                     void** payload,
                                                     size_t num_handles) {
   return CreateMessage(MessageType::PORTS_MESSAGE, payload_size, num_handles,
                        payload);
@@ skipping 266 matching lines @@
       &data);
   data->source = source;
   if (message->payload_size())
     memcpy(data + 1, message->payload(), message->payload_size());
   relayed_message->SetHandles(message->TakeHandles());
   WriteChannelMessage(std::move(relayed_message));
 }
 #endif  // defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
 
 NodeChannel::NodeChannel(Delegate* delegate,
-                         ScopedPlatformHandle platform_handle,
+                         ConnectionParam connection_param,
                          scoped_refptr<base::TaskRunner> io_task_runner,
                          const ProcessErrorCallback& process_error_callback)
     : delegate_(delegate),
       io_task_runner_(io_task_runner),
       process_error_callback_(process_error_callback)
 #if !defined(OS_NACL_SFI)
-      , channel_(
-          Channel::Create(this, std::move(platform_handle), io_task_runner_))
+      ,
+      channel_(
+          Channel::Create(this, std::move(connection_param), io_task_runner_))
 #endif
-      {
+{
 }
 
 NodeChannel::~NodeChannel() {
   ShutDown();
 }
 
 void NodeChannel::OnChannelMessage(const void* payload,
                                    size_t payload_size,
                                    ScopedPlatformHandleVectorPtr handles) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 417 matching lines @@
 
   base::AutoLock lock(channel_lock_);
   if (!channel_)
     DLOG(ERROR) << "Dropping message on closed channel.";
   else
     channel_->Write(std::move(message));
 }
 
 }  // namespace edk
 }  // namespace mojo