IPC: Add MojoHandleAttachment

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.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/client_channel.mojom.h"
 #include "ipc/mojo/ipc_mojo_bootstrap.h"
+#include "ipc/mojo/ipc_mojo_handle_attachment.h"
 #include "third_party/mojo/src/mojo/edk/embedder/embedder.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 namespace IPC {
 
 namespace {
@@ skipping 308 matching lines @@
 }
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 int ChannelMojo::GetClientFileDescriptor() const {
   return bootstrap_->GetClientFileDescriptor();
 }
 
 base::ScopedFD ChannelMojo::TakeClientFileDescriptor() {
   return bootstrap_->TakeClientFileDescriptor();
 }
-
-// static
-MojoResult ChannelMojo::WriteToMessageAttachmentSet(
-    const std::vector<MojoHandle>& handle_buffer,
-    Message* message) {
-  for (size_t i = 0; i < handle_buffer.size(); ++i) {
-    mojo::embedder::ScopedPlatformHandle platform_handle;
-    MojoResult unwrap_result = mojo::embedder::PassWrappedPlatformHandle(
-        handle_buffer[i], &platform_handle);
-    if (unwrap_result != MOJO_RESULT_OK) {
-      DLOG(WARNING) << "Pipe failed to covert handles. Closing: "
-                    << unwrap_result;
-      return unwrap_result;
-    }
-
-    bool ok = message->attachment_set()->AddAttachment(
-        new internal::PlatformFileAttachment(
-            base::ScopedFD(platform_handle.release().fd)));
-    DCHECK(ok);
-  }
-
-  return MOJO_RESULT_OK;
-}
+#endif  // defined(OS_POSIX) && !defined(OS_NACL)
 
 // static
 MojoResult ChannelMojo::ReadFromMessageAttachmentSet(
     Message* message,
     std::vector<MojoHandle>* handles) {
   // 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.
   if (message->HasAttachments()) {
-    MessageAttachmentSet* fdset = message->attachment_set();
-    std::vector<base::PlatformFile> fds_to_send(fdset->size());
-    fdset->PeekDescriptors(&fds_to_send[0]);
-    for (size_t i = 0; i < fds_to_send.size(); ++i) {
-      int fd_to_send = dup(fds_to_send[i]);
-      if (-1 == fd_to_send) {
-        DPLOG(WARNING) << "Failed to dup FD to transmit.";
-        fdset->CommitAll();
-        return MOJO_RESULT_UNKNOWN;
+    MessageAttachmentSet* set = message->attachment_set();
+    for (unsigned i = 0; i < set->size(); ++i) {
+      scoped_refptr<MessageAttachment> attachment = set->GetAttachmentAt(i);
+      switch (attachment->GetType()) {
+        case MessageAttachment::TYPE_PLATFORM_FILE:
+#if defined(OS_POSIX) && !defined(OS_NACL)
+        {
+          base::PlatformFile file =
+              dup(static_cast<IPC::internal::PlatformFileAttachment*>(
+                      attachment.get())->file());
+          if (file == -1) {
+            DPLOG(WARNING) << "Failed to dup FD to transmit.";
+            set->CommitAll();
+            return MOJO_RESULT_UNKNOWN;
+          }
+
+          MojoHandle wrapped_handle;
+          MojoResult wrap_result = CreatePlatformHandleWrapper(
+              mojo::embedder::ScopedPlatformHandle(
+                  mojo::embedder::PlatformHandle(file)),
+              &wrapped_handle);
+          if (MOJO_RESULT_OK != wrap_result) {
+            DLOG(WARNING) << "Pipe failed to wrap handles. Closing: "
+                          << wrap_result;
+            set->CommitAll();
+            return wrap_result;
+          }
+
+          handles->push_back(wrapped_handle);
+        }
+#else
+          NOTREACHED();
+#endif  //  defined(OS_POSIX) && !defined(OS_NACL)
+        break;
+        case MessageAttachment::TYPE_MOJO_HANDLE: {
+          mojo::ScopedHandle handle =
+              static_cast<IPC::internal::MojoHandleAttachment*>(
+                  attachment.get())->TakeHandle();
+          handles->push_back(handle.release().value());
+        } break;
       }
-
-      MojoHandle wrapped_handle;
-      MojoResult wrap_result = CreatePlatformHandleWrapper(
-          mojo::embedder::ScopedPlatformHandle(
-              mojo::embedder::PlatformHandle(fd_to_send)),
-          &wrapped_handle);
-      if (MOJO_RESULT_OK != wrap_result) {
-        DLOG(WARNING) << "Pipe failed to wrap handles. Closing: "
-                      << wrap_result;
-        fdset->CommitAll();
-        return wrap_result;
-      }
-
-      handles->push_back(wrapped_handle);
     }
 
-    fdset->CommitAll();
+    set->CommitAll();
   }
 
   return MOJO_RESULT_OK;
 }
 
-#endif  // defined(OS_POSIX) && !defined(OS_NACL)
+// static
+MojoResult ChannelMojo::WriteToMessageAttachmentSet(
+    const std::vector<MojoHandle>& handle_buffer,
+    Message* message) {
+  for (size_t i = 0; i < handle_buffer.size(); ++i) {
+    bool ok = message->attachment_set()->AddAttachment(
+        new IPC::internal::MojoHandleAttachment(
+            mojo::MakeScopedHandle(mojo::Handle(handle_buffer[i]))));
+    DCHECK(ok);
+    if (!ok) {
+      DLOG(ERROR) << "Failed to add new Mojo handle.";
+      return MOJO_RESULT_UNKNOWN;
+    }
+  }
+
+  return MOJO_RESULT_OK;
+}
 
 }  // namespace IPC