Use public handle API to transfer handle attachments.

ipc/mojo/ipc_channel_mojo.cc

 // Copyright 2014 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 "ipc/mojo/ipc_channel_mojo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_attachment_set.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/mojo/ipc_mojo_bootstrap.h"
 #include "ipc/mojo/ipc_mojo_handle_attachment.h"
-#include "mojo/edk/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 
 #if defined(OS_POSIX)
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include "ipc/mach_port_attachment_mac.h"
 #endif
 
 #if defined(OS_WIN)
@@ skipping 24 matching lines @@
 
 mojom::SerializedHandlePtr CreateSerializedHandle(
     mojo::ScopedHandle handle,
     mojom::SerializedHandle::Type type) {
   mojom::SerializedHandlePtr serialized_handle = mojom::SerializedHandle::New();
   serialized_handle->the_handle = std::move(handle);
   serialized_handle->type = type;
   return serialized_handle;
 }
 
-MojoResult WrapPlatformHandle(mojo::edk::ScopedPlatformHandle handle,
+MojoResult WrapPlatformHandle(base::PlatformFile handle,
                               mojom::SerializedHandle::Type type,
                               mojom::SerializedHandlePtr* serialized) {
+  mojo::ScopedHandle wrapped_handle = mojo::WrapPlatformFile(handle);
+  if (!wrapped_handle.is_valid())
+    return MOJO_RESULT_UNKNOWN;
+
+  *serialized = CreateSerializedHandle(std::move(wrapped_handle), type);
+  return MOJO_RESULT_OK;
+}
+
+#if defined(OS_MACOSX)
+
+MojoResult WrapMachPort(mach_port_t mach_port,
+                        mojom::SerializedHandlePtr* serialized) {
+  MojoPlatformHandle platform_handle = {
+    sizeof(MojoPlatformHandle), MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT,
+    static_cast<uint64_t>(mach_port)
+  };
+
   MojoHandle wrapped_handle;
-  MojoResult wrap_result = mojo::edk::CreatePlatformHandleWrapper(
-      std::move(handle), &wrapped_handle);
-  if (wrap_result != MOJO_RESULT_OK)
-    return wrap_result;
+  MojoResult result = MojoWrapPlatformHandle(&platform_handle, &wrapped_handle);
+  if (result != MOJO_RESULT_OK)
+    return result;
 
   *serialized = CreateSerializedHandle(
-      mojo::MakeScopedHandle(mojo::Handle(wrapped_handle)), type);
+      mojo::MakeScopedHandle(mojo::Handle(wrapped_handle)),
+      mojom::SerializedHandle::Type::MACH_PORT);
   return MOJO_RESULT_OK;
 }
 
+#endif
+
 #if defined(OS_POSIX)
 
 base::ScopedFD TakeOrDupFile(internal::PlatformFileAttachment* attachment) {
   return attachment->Owns() ? base::ScopedFD(attachment->TakePlatformFile())
                             : base::ScopedFD(dup(attachment->file()));
 }
 
 #endif
 
 MojoResult WrapAttachmentImpl(MessageAttachment* attachment,
                               mojom::SerializedHandlePtr* serialized) {
   if (attachment->GetType() == MessageAttachment::TYPE_MOJO_HANDLE) {
     *serialized = CreateSerializedHandle(
         static_cast<internal::MojoHandleAttachment&>(*attachment).TakeHandle(),
         mojom::SerializedHandle::Type::MOJO_HANDLE);
     return MOJO_RESULT_OK;
   }
 #if defined(OS_POSIX)
   if (attachment->GetType() == MessageAttachment::TYPE_PLATFORM_FILE) {
     // We dup() the handles in IPC::Message to transmit.
     // IPC::MessageAttachmentSet has intricate lifecycle semantics
     // of FDs, so just to dup()-and-own them is the safest option.
     base::ScopedFD file = TakeOrDupFile(
         static_cast<IPC::internal::PlatformFileAttachment*>(attachment));
     if (!file.is_valid()) {
       DPLOG(WARNING) << "Failed to dup FD to transmit.";
       return MOJO_RESULT_UNKNOWN;
     }
 
-    return WrapPlatformHandle(mojo::edk::ScopedPlatformHandle(
-                                  mojo::edk::PlatformHandle(file.release())),
+    return WrapPlatformHandle(file.release(),
                               mojom::SerializedHandle::Type::PLATFORM_FILE,
                               serialized);
   }
 #endif
 #if defined(OS_MACOSX)
   DCHECK_EQ(attachment->GetType(),
             MessageAttachment::TYPE_BROKERABLE_ATTACHMENT);
   DCHECK_EQ(static_cast<BrokerableAttachment&>(*attachment).GetBrokerableType(),
             BrokerableAttachment::MACH_PORT);
   internal::MachPortAttachmentMac& mach_port_attachment =
       static_cast<internal::MachPortAttachmentMac&>(*attachment);
-  MojoResult result = WrapPlatformHandle(
-      mojo::edk::ScopedPlatformHandle(
-          mojo::edk::PlatformHandle(mach_port_attachment.get_mach_port())),
-      mojom::SerializedHandle::Type::MACH_PORT, serialized);
+  MojoResult result = WrapMachPort(mach_port_attachment.get_mach_port(),
+                                   serialized);
   mach_port_attachment.reset_mach_port_ownership();
   return result;
 #elif defined(OS_WIN)
   DCHECK_EQ(attachment->GetType(),
             MessageAttachment::TYPE_BROKERABLE_ATTACHMENT);
   DCHECK_EQ(static_cast<BrokerableAttachment&>(*attachment).GetBrokerableType(),
             BrokerableAttachment::WIN_HANDLE);
   internal::HandleAttachmentWin& handle_attachment =
       static_cast<internal::HandleAttachmentWin&>(*attachment);
   MojoResult result = WrapPlatformHandle(
-      mojo::edk::ScopedPlatformHandle(
-          mojo::edk::PlatformHandle(handle_attachment.get_handle())),
+      handle_attachment.get_handle(),
       mojom::SerializedHandle::Type::WIN_HANDLE, serialized);
   handle_attachment.reset_handle_ownership();
   return result;
 #else
   NOTREACHED();
   return MOJO_RESULT_UNKNOWN;
 #endif  // defined(OS_MACOSX)
 }
 
 MojoResult WrapAttachment(MessageAttachment* attachment,
                           mojo::Array<mojom::SerializedHandlePtr>* handles) {
   mojom::SerializedHandlePtr serialized_handle;
   MojoResult wrap_result = WrapAttachmentImpl(attachment, &serialized_handle);
   if (wrap_result != MOJO_RESULT_OK) {
     LOG(WARNING) << "Pipe failed to wrap handles. Closing: " << wrap_result;
     return wrap_result;
   }
   handles->push_back(std::move(serialized_handle));
   return MOJO_RESULT_OK;
 }
 
 MojoResult UnwrapAttachment(mojom::SerializedHandlePtr handle,
                             scoped_refptr<MessageAttachment>* attachment) {
   if (handle->type == mojom::SerializedHandle::Type::MOJO_HANDLE) {
     *attachment =
         new IPC::internal::MojoHandleAttachment(std::move(handle->the_handle));
     return MOJO_RESULT_OK;
   }
-  mojo::edk::ScopedPlatformHandle platform_handle;
-  MojoResult unwrap_result = mojo::edk::PassWrappedPlatformHandle(
+  MojoPlatformHandle platform_handle = { sizeof(MojoPlatformHandle), 0, 0 };
+  MojoResult unwrap_result = MojoUnwrapPlatformHandle(
           handle->the_handle.release().value(), &platform_handle);
   if (unwrap_result != MOJO_RESULT_OK)
     return unwrap_result;
 #if defined(OS_POSIX)
-  if (handle->type == mojom::SerializedHandle::Type::PLATFORM_FILE &&
-      platform_handle.get().type == mojo::edk::PlatformHandle::Type::POSIX) {
-    *attachment = new internal::PlatformFileAttachment(
-        platform_handle.release().handle);
+  if (handle->type == mojom::SerializedHandle::Type::PLATFORM_FILE) {
+    base::PlatformFile file = base::kInvalidPlatformFile;
+    if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_FILE_DESCRIPTOR)
+      file = static_cast<base::PlatformFile>(platform_handle.value);
+    *attachment = new internal::PlatformFileAttachment(file);
     return MOJO_RESULT_OK;
   }
 #endif  // defined(OS_POSIX)
 #if defined(OS_MACOSX)
-  if (handle->type == mojom::SerializedHandle::Type::MACH_PORT &&
-      platform_handle.get().type == mojo::edk::PlatformHandle::Type::MACH) {
+  if (handle->type == mojom::SerializedHandle::Type::MACH_PORT) {
+    mach_port_t mach_port = MACH_PORT_NULL;
+    if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT)
+      mach_port = static_cast<mach_port_t>(platform_handle.value);
     *attachment = new internal::MachPortAttachmentMac(
-        platform_handle.release().port,
-        internal::MachPortAttachmentMac::FROM_WIRE);
+        mach_port, internal::MachPortAttachmentMac::FROM_WIRE);
     return MOJO_RESULT_OK;
   }
 #endif  // defined(OS_MACOSX)
 #if defined(OS_WIN)
   if (handle->type == mojom::SerializedHandle::Type::WIN_HANDLE) {
+    base::PlatformFile handle = base::kInvalidPlatformFile;
+    if (platform_handle.type == MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE)
+      handle = reinterpret_cast<base::PlatformFile>(platform_handle.value);
     *attachment = new internal::HandleAttachmentWin(
-        platform_handle.release().handle,
-        internal::HandleAttachmentWin::FROM_WIRE);
+        handle, internal::HandleAttachmentWin::FROM_WIRE);
     return MOJO_RESULT_OK;
   }
 #endif  // defined(OS_WIN)
   NOTREACHED();
   return MOJO_RESULT_UNKNOWN;
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
@@ skipping 234 matching lines @@
     DCHECK(ok);
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC