Changing SpawnChild to return a struct.

mojo/edk/system/node_controller.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_controller.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 147 matching lines @@
 void NodeController::SetIOTaskRunner(
     scoped_refptr<base::TaskRunner> task_runner) {
   io_task_runner_ = task_runner;
   ThreadDestructionObserver::Create(
       io_task_runner_,
       base::Bind(&NodeController::DropAllPeers, base::Unretained(this)));
 }
 
 void NodeController::ConnectToChild(
     base::ProcessHandle process_handle,
-    ScopedPlatformHandle platform_handle,
+    ConnectionParam connection_param,
     const std::string& child_token,
     const ProcessErrorCallback& process_error_callback) {
   // Generate the temporary remote node name here so that it can be associated
   // with the embedder's child_token. If an error occurs in the child process
   // after it is launched, but before any reserved ports are connected, this can
   // be used to clean up any dangling ports.
   ports::NodeName node_name;
   GenerateRandomName(&node_name);
 
   {
@@ skipping 10 matching lines @@
   HANDLE dup_handle = INVALID_HANDLE_VALUE;
   BOOL ok = ::DuplicateHandle(
       base::GetCurrentProcessHandle(), process_handle,
       base::GetCurrentProcessHandle(), &dup_handle,
       0, FALSE, DUPLICATE_SAME_ACCESS);
   DPCHECK(ok);
   process_handle = dup_handle;
 #endif
 
   io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&NodeController::ConnectToChildOnIOThread,
-                 base::Unretained(this),
-                 process_handle,
-                 base::Passed(&platform_handle),
-                 node_name,
-                 process_error_callback));
+      FROM_HERE, base::Bind(&NodeController::ConnectToChildOnIOThread,
+                            base::Unretained(this), process_handle,
+                            base::Passed(&connection_param), node_name,
+                            process_error_callback));
 }
 
 void NodeController::CloseChildPorts(const std::string& child_token) {
   std::vector<ports::PortRef> ports_to_close;
   {
     std::vector<std::string> port_tokens;
     base::AutoLock lock(reserved_ports_lock_);
     for (const auto& port : reserved_ports_) {
       if (port.second.child_token == child_token) {
         DVLOG(1) << "Closing reserved port " << port.second.port.name();
@@ skipping 12 matching lines @@
   // Ensure local port closure messages are processed.
   AcceptIncomingMessages();
 }
 
 void NodeController::ClosePeerConnection(const std::string& peer_token) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&NodeController::ClosePeerConnectionOnIOThread,
                             base::Unretained(this), peer_token));
 }
 
-void NodeController::ConnectToParent(ScopedPlatformHandle platform_handle) {
+void NodeController::ConnectToParent(ConnectionParam connection_param) {
 #if !defined(OS_MACOSX) && !defined(OS_NACL_SFI)
   // Use the bootstrap channel for the broker and receive the node's channel
   // synchronously as the first message from the broker.
   base::ElapsedTimer timer;
-  broker_.reset(new Broker(std::move(platform_handle)));
-  platform_handle = broker_->GetParentPlatformHandle();
+  broker_.reset(new Broker(connection_param.TakeChannelHandle()));
+  ScopedPlatformHandle platform_handle = broker_->GetParentPlatformHandle();
   UMA_HISTOGRAM_TIMES("Mojo.System.GetParentPlatformHandleSyncTime",
                       timer.Elapsed());
 
   if (!platform_handle.is_valid()) {
     // Most likely the browser side of the channel has already been closed and
     // the broker was unable to negotiate a NodeChannel pipe. In this case we
     // can cancel parent connection.
     DVLOG(1) << "Cannot connect to invalid parent channel.";
     CancelPendingPortMerges();
     return;
   }
+  connection_param =
+      ConnectionParam(std::move(platform_handle)
+#if defined(OS_ANDROID)
+                          ,
+                      std::move(connection_param.TakeParcelableChannelClient()),
+                      std::move(connection_param.TakeParcelableChannelServer())
+#endif
+                          );
 #endif
 
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&NodeController::ConnectToParentOnIOThread,
-                 base::Unretained(this),
-                 base::Passed(&platform_handle)));
+                 base::Unretained(this), base::Passed(&connection_param)));
 }
 
-void NodeController::ConnectToPeer(ScopedPlatformHandle handle,
+void NodeController::ConnectToPeer(ConnectionParam connection_param,
                                    const ports::PortRef& port,
                                    const std::string& peer_token) {
   ports::NodeName node_name;
   GenerateRandomName(&node_name);
   io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&NodeController::ConnectToPeerOnIOThread,
-                            base::Unretained(this), base::Passed(&handle),
-                            node_name, port, peer_token));
+      FROM_HERE,
+      base::Bind(&NodeController::ConnectToPeerOnIOThread,
+                 base::Unretained(this), base::Passed(&connection_param),
+                 node_name, port, peer_token));
 }
 
 void NodeController::SetPortObserver(
     const ports::PortRef& port,
     const scoped_refptr<PortObserver>& observer) {
   node_->SetUserData(port, observer);
 }
 
 void NodeController::ClosePort(const ports::PortRef& port) {
   SetPortObserver(port, nullptr);
@@ skipping 104 matching lines @@
 
 void NodeController::NotifyBadMessageFrom(const ports::NodeName& source_node,
                                           const std::string& error) {
   scoped_refptr<NodeChannel> peer = GetPeerChannel(source_node);
   if (peer)
     peer->NotifyBadMessage(error);
 }
 
 void NodeController::ConnectToChildOnIOThread(
     base::ProcessHandle process_handle,
-    ScopedPlatformHandle platform_handle,
+    ConnectionParam connection_param,
     ports::NodeName token,
     const ProcessErrorCallback& process_error_callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
 #if !defined(OS_MACOSX) && !defined(OS_NACL)
   PlatformChannelPair node_channel;
   ScopedPlatformHandle server_handle = node_channel.PassServerHandle();
   // BrokerHost owns itself.
   BrokerHost* broker_host =
-      new BrokerHost(process_handle, std::move(platform_handle));
+      new BrokerHost(process_handle, connection_param.TakeChannelHandle());
   bool channel_ok = broker_host->SendChannel(node_channel.PassClientHandle());
 
 #if defined(OS_WIN)
   if (!channel_ok) {
     // On Windows the above operation may fail if the channel is crossing a
     // session boundary. In that case we fall back to a named pipe.
     NamedPlatformChannelPair named_channel;
     server_handle = named_channel.PassServerHandle();
     broker_host->SendNamedChannel(named_channel.handle().name);
   }
 #else
   CHECK(channel_ok);
 #endif  // defined(OS_WIN)
 
-  scoped_refptr<NodeChannel> channel = NodeChannel::Create(
-      this, std::move(server_handle), io_task_runner_, process_error_callback);
+#if defined(OS_ANDROID)
+  DCHECK(connection_param.is_valid_parcelable_channel_client());
+  DCHECK(connection_param.is_valid_parcelable_channel_server());
+
+  ConnectionParam new_connection_param(
+      std::move(server_handle), connection_param.TakeParcelableChannelClient(),
+      connection_param.TakeParcelableChannelServer());
+#else
+  ConnectionParam new_connection_param(std::move(server_handle));
+#endif
+
+  scoped_refptr<NodeChannel> channel =
+      NodeChannel::Create(this, std::move(new_connection_param),
+                          io_task_runner_, process_error_callback);
 
 #else  // !defined(OS_MACOSX) && !defined(OS_NACL)
   scoped_refptr<NodeChannel> channel =
-      NodeChannel::Create(this, std::move(platform_handle), io_task_runner_,
+      NodeChannel::Create(this, std::move(connection_param), io_task_runner_,
                           process_error_callback);
 #endif  // !defined(OS_MACOSX) && !defined(OS_NACL)
 
   // We set up the child channel with a temporary name so it can be identified
   // as a pending child if it writes any messages to the channel. We may start
   // receiving messages from it (though we shouldn't) as soon as Start() is
   // called below.
 
   pending_children_.insert(std::make_pair(token, channel));
   RecordPendingChildCount(pending_children_.size());
 
   channel->SetRemoteNodeName(token);
   channel->SetRemoteProcessHandle(process_handle);
   channel->Start();
 
   channel->AcceptChild(name_, token);
 }
 
 void NodeController::ConnectToParentOnIOThread(
-    ScopedPlatformHandle platform_handle) {
+    ConnectionParam connection_param) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   {
     base::AutoLock lock(parent_lock_);
     DCHECK(parent_name_ == ports::kInvalidNodeName);
 
     // At this point we don't know the parent's name, so we can't yet insert it
     // into our |peers_| map. That will happen as soon as we receive an
     // AcceptChild message from them.
     bootstrap_parent_channel_ =
-        NodeChannel::Create(this, std::move(platform_handle), io_task_runner_,
+        NodeChannel::Create(this, std::move(connection_param), io_task_runner_,
                             ProcessErrorCallback());
     // Prevent the parent pipe handle from being closed on shutdown. Pipe
     // closure is used by the parent to detect the child process has exited.
     // Relying on message pipes to be closed is not enough because the parent
     // may see the message pipe closure before the child is dead, causing the
     // child process to be unexpectedly SIGKILL'd.
     bootstrap_parent_channel_->LeakHandleOnShutdown();
   }
   bootstrap_parent_channel_->Start();
 }
 
-void NodeController::ConnectToPeerOnIOThread(ScopedPlatformHandle handle,
+void NodeController::ConnectToPeerOnIOThread(ConnectionParam connection_param,
                                              ports::NodeName token,
                                              ports::PortRef port,
                                              const std::string& peer_token) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
-  scoped_refptr<NodeChannel> channel =
-      NodeChannel::Create(this, std::move(handle), io_task_runner_, {});
+  scoped_refptr<NodeChannel> channel = NodeChannel::Create(
+      this, std::move(connection_param), io_task_runner_, {});
   peer_connections_.insert(
       {token, PeerConnection{channel, port, peer_token}});
   peers_by_token_.insert({peer_token, token});
 
   channel->SetRemoteNodeName(token);
   channel->Start();
 
   channel->AcceptPeer(name_, token, port.name());
 }
 
@@ skipping 499 matching lines @@
     return;
   }
 
   if (GetPeerChannel(client_name)) {
     DLOG(ERROR) << "Ignoring AddBrokerClient for known client.";
     DropPeer(from_node, nullptr);
     return;
   }
 
   PlatformChannelPair broker_channel;
-  scoped_refptr<NodeChannel> client = NodeChannel::Create(
-      this, broker_channel.PassServerHandle(), io_task_runner_,
-      ProcessErrorCallback());
+  ConnectionParam connection_param(broker_channel.PassServerHandle());
+  scoped_refptr<NodeChannel> client =
+      NodeChannel::Create(this, std::move(connection_param), io_task_runner_,
+                          ProcessErrorCallback());
 
 #if defined(OS_WIN)
   // The broker must have a working handle to the client process in order to
   // properly copy other handles to and from the client.
   if (!scoped_process_handle.is_valid()) {
     DLOG(ERROR) << "Broker rejecting client with invalid process handle.";
     return;
   }
   client->SetRemoteProcessHandle(scoped_process_handle.release().handle);
 #else
@@ skipping 55 matching lines @@
   DCHECK(broker_name != ports::kInvalidNodeName);
 
   // It's now possible to add both the broker and the parent as peers.
   // Note that the broker and parent may be the same node.
   scoped_refptr<NodeChannel> broker;
   if (broker_name == parent_name) {
     DCHECK(!broker_channel.is_valid());
     broker = parent;
   } else {
     DCHECK(broker_channel.is_valid());
-    broker = NodeChannel::Create(this, std::move(broker_channel),
+    ConnectionParam connection_param(std::move(broker_channel));
+    broker = NodeChannel::Create(this, std::move(connection_param),
                                  io_task_runner_, ProcessErrorCallback());
     AddPeer(broker_name, broker, true /* start_channel */);
   }
 
   AddPeer(parent_name, parent, false /* start_channel */);
 
   {
     // Complete any port merge requests we have waiting for the parent.
     base::AutoLock lock(pending_port_merges_lock_);
     for (const auto& request : pending_port_merges_)
@@ skipping 107 matching lines @@
 
   if (!channel_handle.is_valid()) {
     node_->LostConnectionToNode(name);
 
     DVLOG(1) << "Could not be introduced to peer " << name;
     base::AutoLock lock(peers_lock_);
     pending_peer_messages_.erase(name);
     return;
   }
 
+  ConnectionParam connection_param(std::move(channel_handle));
   scoped_refptr<NodeChannel> channel =
-      NodeChannel::Create(this, std::move(channel_handle), io_task_runner_,
+      NodeChannel::Create(this, std::move(connection_param), io_task_runner_,
                           ProcessErrorCallback());
 
   DVLOG(1) << "Adding new peer " << name << " via parent introduction.";
   AddPeer(name, channel, true /* start_channel */);
 }
 
 void NodeController::OnBroadcast(const ports::NodeName& from_node,
                                  Channel::MessagePtr message) {
   DCHECK(!message->has_handles());
 
@@ skipping 232 matching lines @@
 NodeController::PeerConnection::~PeerConnection() = default;
 
 NodeController::PeerConnection& NodeController::PeerConnection::
 operator=(const PeerConnection& other) = default;
 
 NodeController::PeerConnection& NodeController::PeerConnection::
 operator=(PeerConnection&& other) = default;
 
 }  // namespace edk
 }  // namespace mojo