[mojo-edk] Pass process handle through the broker on all platforms.

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 40 matching lines @@
 };
 
 struct AcceptParentData {
   ports::NodeName token;
   ports::NodeName child_name;
 };
 
 // This message may include a process handle on plaforms that require it.
 struct AddBrokerClientData {
   ports::NodeName client_name;
+#if !defined(OS_WIN)
+  uint32_t process_handle;
+  uint32_t padding;
+#endif
 };
 
+#if !defined(OS_WIN)
+static_assert(sizeof(base::ProcessHandle) == sizeof(uint32_t),
+              "Unexpected pid size");
+static_assert(sizeof(AddBrokerClientData) % kChannelMessageAlignment == 0,
+              "Invalid AddBrokerClientData size.");
+#endif
+
 // This data is followed by a platform channel handle to the broker.
 struct BrokerClientAddedData {
   ports::NodeName client_name;
 };
 
 // This data may be followed by a platform channel handle to the broker. If not,
 // then the parent is the broker and its channel should be used as such.
 struct AcceptBrokerClientData {
   ports::NodeName broker_name;
 };
@@ skipping 75 matching lines @@
 
 void NodeChannel::ShutDown() {
   base::AutoLock lock(channel_lock_);
   if (channel_) {
     channel_->ShutDown();
     channel_ = nullptr;
   }
 }
 
 void NodeChannel::SetRemoteProcessHandle(base::ProcessHandle process_handle) {
-#if defined(OS_WIN)
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   base::AutoLock lock(remote_process_handle_lock_);
   remote_process_handle_ = process_handle;
-#endif
 }
 
 bool NodeChannel::HasRemoteProcessHandle() {
-#if defined(OS_WIN)
   base::AutoLock lock(remote_process_handle_lock_);
   return remote_process_handle_ != base::kNullProcessHandle;
-#else
-  return false;
-#endif
 }
 
-ScopedPlatformHandle NodeChannel::CopyRemoteProcessHandle() {
+base::ProcessHandle NodeChannel::CopyRemoteProcessHandle() {
+  base::AutoLock lock(remote_process_handle_lock_);
 #if defined(OS_WIN)
-  base::AutoLock lock(remote_process_handle_lock_);
   if (remote_process_handle_ != base::kNullProcessHandle) {
     // Privileged nodes use this to pass their childrens' process handles to the
     // broker on launch.
     HANDLE handle = remote_process_handle_;
     BOOL result = DuplicateHandle(
         base::GetCurrentProcessHandle(), remote_process_handle_,
         base::GetCurrentProcessHandle(), &handle, 0, FALSE,
         DUPLICATE_SAME_ACCESS);
     DCHECK(result);
-    return ScopedPlatformHandle(PlatformHandle(handle));
+    return handle;
   }
+  return base::kNullProcessHandle;
+#else
+  return remote_process_handle_;
 #endif
-  return ScopedPlatformHandle();
 }
 
 void NodeChannel::SetRemoteNodeName(const ports::NodeName& name) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   remote_node_name_ = name;
 }
 
 void NodeChannel::AcceptChild(const ports::NodeName& parent_name,
                               const ports::NodeName& token) {
   AcceptChildData* data;
   Channel::MessagePtr message = CreateMessage(
       MessageType::ACCEPT_CHILD, sizeof(AcceptChildData), 0, &data);
   data->parent_name = parent_name;
   data->token = token;
   WriteChannelMessage(std::move(message));
 }
 
 void NodeChannel::AcceptParent(const ports::NodeName& token,
                                const ports::NodeName& child_name) {
   AcceptParentData* data;
   Channel::MessagePtr message = CreateMessage(
       MessageType::ACCEPT_PARENT, sizeof(AcceptParentData), 0, &data);
   data->token = token;
   data->child_name = child_name;
   WriteChannelMessage(std::move(message));
 }
 
 void NodeChannel::AddBrokerClient(const ports::NodeName& client_name,
-                                  ScopedPlatformHandle process_handle) {
+                                  base::ProcessHandle process_handle) {
   AddBrokerClientData* data;
   ScopedPlatformHandleVectorPtr handles(new PlatformHandleVector());
 #if defined(OS_WIN)
-  handles->push_back(process_handle.release());
+  handles->push_back(PlatformHandle(process_handle));
 #endif
   Channel::MessagePtr message = CreateMessage(
       MessageType::ADD_BROKER_CLIENT, sizeof(AddBrokerClientData),
       handles->size(), &data);
   message->SetHandles(std::move(handles));
   data->client_name = client_name;
+#if !defined(OS_WIN)
+  data->process_handle = process_handle;
+#endif
   WriteChannelMessage(std::move(message));
 }
 
 void NodeChannel::BrokerClientAdded(const ports::NodeName& client_name,
                                     ScopedPlatformHandle broker_channel) {
   BrokerClientAddedData* data;
   ScopedPlatformHandleVectorPtr handles(new PlatformHandleVector());
   if (broker_channel.is_valid())
     handles->push_back(broker_channel.release());
   Channel::MessagePtr message = CreateMessage(
@@ skipping 136 matching lines @@
       const AddBrokerClientData* data;
       GetMessagePayload(payload, &data);
       ScopedPlatformHandle process_handle;
 #if defined(OS_WIN)
       if (!handles || handles->size() != 1) {
         DLOG(ERROR) << "Dropping invalid AddBrokerClient message.";
         break;
       }
       process_handle = ScopedPlatformHandle(handles->at(0));
       handles->clear();
+      delegate_->OnAddBrokerClient(remote_node_name_, data->client_name,
+                                   process_handle.release().handle);
 #else
       if (handles && handles->size() != 0) {
         DLOG(ERROR) << "Dropping invalid AddBrokerClient message.";
         break;
       }
+      delegate_->OnAddBrokerClient(remote_node_name_, data->client_name,
+                                   data->process_handle);
 #endif
-      delegate_->OnAddBrokerClient(remote_node_name_, data->client_name,
-                                   std::move(process_handle));
       break;
     }
 
     case MessageType::BROKER_CLIENT_ADDED: {
       const BrokerClientAddedData* data;
       GetMessagePayload(payload, &data);
       ScopedPlatformHandle broker_channel;
       if (!handles || handles->size() != 1) {
         DLOG(ERROR) << "Dropping invalid BrokerClientAdded message.";
         break;
@@ skipping 139 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