[mojo-edk] Add support for transferring mach ports.

mojo/edk/system/channel_posix.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/channel.h"
 
 #include <errno.h>
 #include <sys/uio.h>
 
 #include <algorithm>
@@ skipping 18 matching lines @@
 const size_t kMaxBatchReadCapacity = 256 * 1024;
 
 // A view over a Channel::Message object. The write queue uses these since
 // large messages may need to be sent in chunks.
 class MessageView {
  public:
   // Owns |message|. |offset| indexes the first unsent byte in the message.
   MessageView(Channel::MessagePtr message, size_t offset)
       : message_(std::move(message)),
         offset_(offset),
-        handles_(message_->TakeHandles()) {
+        handles_(message_->TakeHandlesForTransport()) {
     DCHECK_GT(message_->data_num_bytes(), offset_);
   }
 
   MessageView(MessageView&& other) { *this = std::move(other); }
 
   MessageView& operator=(MessageView&& other) {
     message_ = std::move(other.message_);
     offset_ = other.offset_;
     handles_ = std::move(other.handles_);
     return *this;
@@ skipping 79 matching lines @@
       // the delegate and we don't want to re-enter it.
       io_task_runner_->PostTask(FROM_HERE,
                                 base::Bind(&ChannelPosix::OnError, this));
     }
   }
 
   ScopedPlatformHandleVectorPtr GetReadPlatformHandles(
       size_t num_handles,
       const void* extra_header,
       size_t extra_header_size) override {
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+    // On OSX, we can have mach ports which are located in the extra header
+    // section.
+    using MachPortsEntry = Channel::Message::MachPortsEntry;
+    CHECK(extra_header_size >= num_handles * sizeof(MachPortsEntry));
+    size_t num_mach_ports = 0;
+    const MachPortsEntry* mach_ports =
+        reinterpret_cast<const MachPortsEntry*>(extra_header);
+    for (size_t i = 0; i < num_handles; i++) {
+      if (mach_ports[i].mach_port != MACH_PORT_NULL)
+        num_mach_ports++;
+    }
+    CHECK(num_mach_ports <= num_handles);
+    if (incoming_platform_handles_.size() + num_mach_ports < num_handles)
+      return nullptr;
+
+    ScopedPlatformHandleVectorPtr handles(
+        new PlatformHandleVector(num_handles));
+    for (size_t i = 0, mach_port_index = 0; i < num_handles; ++i) {
+      if (mach_port_index < num_mach_ports &&
+          mach_ports[mach_port_index].index == i) {
+        (*handles)[i] = PlatformHandle(
+            static_cast<mach_port_t>(mach_ports[mach_port_index].mach_port));
+        CHECK((*handles)[i].type == PlatformHandle::Type::MACH);
+        // These are actually just Mach port names until they're resolved from
+        // the remote process.
+        (*handles)[i].type = PlatformHandle::Type::MACH_NAME;
+        mach_port_index++;
+      } else {
+        CHECK(!incoming_platform_handles_.empty());
+        (*handles)[i] = incoming_platform_handles_.front();
+        incoming_platform_handles_.pop_front();
+      }
+    }
+#else
     if (incoming_platform_handles_.size() < num_handles)
       return nullptr;
 
     ScopedPlatformHandleVectorPtr handles(
         new PlatformHandleVector(num_handles));
     for (size_t i = 0; i < num_handles; ++i) {
       (*handles)[i] = incoming_platform_handles_.front();
       incoming_platform_handles_.pop_front();
     }
+#endif
 
     return handles;
   }
 
  private:
   ~ChannelPosix() override {
     DCHECK(!read_watcher_);
     DCHECK(!write_watcher_);
     for (auto handle : incoming_platform_handles_)
       handle.CloseIfNecessary();
@@ skipping 292 matching lines @@
 // static
 scoped_refptr<Channel> Channel::Create(
     Delegate* delegate,
     ScopedPlatformHandle platform_handle,
     scoped_refptr<base::TaskRunner> io_task_runner) {
   return new ChannelPosix(delegate, std::move(platform_handle), io_task_runner);
 }
 
 }  // namespace edk
 }  // namespace mojo