Remove IPC::BrokerableAttachment.

ipc/ipc_channel_nacl.cc

 // Copyright (c) 2012 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/ipc_channel_nacl.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
 #include "ipc/ipc_message_attachment_set.h"
+#include "ipc/ipc_platform_file_attachment_posix.h"
 #include "native_client/src/public/imc_syscalls.h"
 #include "native_client/src/public/imc_types.h"
 
 namespace IPC {
 
 struct MessageContents {
   std::vector<char> data;
   std::vector<int> fds;
 };
 
@@ skipping 180 matching lines @@
 void ChannelNacl::DidRecvMsg(std::unique_ptr<MessageContents> contents) {
   // Close sets the pipe to -1. It's possible we'll get a buffer sent to us from
   // the reader thread after Close is called. If so, we ignore it.
   if (pipe_ == -1)
     return;
 
   linked_ptr<std::vector<char> > data(new std::vector<char>);
   data->swap(contents->data);
   read_queue_.push_back(data);
 
-  input_fds_.insert(input_fds_.end(),
-                    contents->fds.begin(), contents->fds.end());
+  input_attachments_.reserve(contents->fds.size());
+  for (int fd : contents->fds) {
+    input_attachments_.push_back(
+        new internal::PlatformFileAttachment(base::ScopedFD(fd)));
+  }
   contents->fds.clear();
 
   // In POSIX, we would be told when there are bytes to read by implementing
   // OnFileCanReadWithoutBlocking in MessageLoopForIO::Watcher. In NaCl, we
   // instead know at this point because the reader thread posted some data to
   // us.
   ProcessIncomingMessages();
 }
 
 void ChannelNacl::ReadDidFail() {
@@ skipping 27 matching lines @@
 
   if (pipe_ == -1)
     return false;
 
   // Write out all the messages. The trusted implementation is guaranteed to not
   // block. See NaClIPCAdapter::Send for the implementation of imc_sendmsg.
   while (!output_queue_.empty()) {
     linked_ptr<Message> msg = output_queue_.front();
     output_queue_.pop_front();
 
-    int fds[MessageAttachmentSet::kMaxDescriptorsPerMessage];
-    const size_t num_fds =
-        msg->attachment_set()->num_non_brokerable_attachments();
+    const size_t num_fds = msg->attachment_set()->size();
     DCHECK(num_fds <= MessageAttachmentSet::kMaxDescriptorsPerMessage);
-    msg->attachment_set()->PeekDescriptors(fds);
+    std::vector<int> fds;
+    fds.reserve(num_fds);
+    for (size_t i = 0; i < num_fds; i++) {
+      scoped_refptr<MessageAttachment> attachment =
+          msg->attachment_set()->GetAttachmentAt(i);
+      DCHECK_EQ(MessageAttachment::Type::PLATFORM_FILE, attachment->GetType());
+      fds.push_back(static_cast<internal::PlatformFileAttachment&>(*attachment)
+                        .TakePlatformFile());
+    }
 
     NaClAbiNaClImcMsgIoVec iov = {
       const_cast<void*>(msg->data()), msg->size()
     };
-    NaClAbiNaClImcMsgHdr msgh = { &iov, 1, fds, num_fds };
+    NaClAbiNaClImcMsgHdr msgh = {&iov, 1, fds.data(), num_fds};
     ssize_t bytes_written = imc_sendmsg(pipe_, &msgh, 0);
 
     DCHECK(bytes_written);  // The trusted side shouldn't return 0.
     if (bytes_written < 0) {
       // The trusted side should only ever give us an error of EPIPE. We
       // should never be interrupted, nor should we get EAGAIN.
       DCHECK(errno == EPIPE);
       Close();
       PLOG(ERROR) << "pipe_ error on "
                   << pipe_
@@ skipping 43 matching lines @@
       *bytes_read += bytes_to_read;
     }
   }
   return READ_SUCCEEDED;
 }
 
 bool ChannelNacl::ShouldDispatchInputMessage(Message* msg) {
   return true;
 }
 
-bool ChannelNacl::GetNonBrokeredAttachments(Message* msg) {
+bool ChannelNacl::GetAttachments(Message* msg) {
   uint16_t header_fds = msg->header()->num_fds;
-  CHECK(header_fds == input_fds_.size());
+  CHECK(header_fds == input_attachments_.size());
   if (header_fds == 0)
     return true;  // Nothing to do.
 
-  // The shenaniganery below with &foo.front() requires input_fds_ to have
-  // contiguous underlying storage (such as a simple array or a std::vector).
-  // This is why the header warns not to make input_fds_ a deque<>.
-  msg->attachment_set()->AddDescriptorsToOwn(&input_fds_.front(), header_fds);
-  input_fds_.clear();
+  for (auto& attachment : input_attachments_) {
+    msg->attachment_set()->AddAttachment(std::move(attachment));
+  }
+  input_attachments_.clear();
   return true;
 }
 
 bool ChannelNacl::DidEmptyInputBuffers() {
-  // When the input data buffer is empty, the fds should be too.
-  return input_fds_.empty();
+  // When the input data buffer is empty, the attachments should be too.
+  return input_attachments_.empty();
 }
 
 void ChannelNacl::HandleInternalMessage(const Message& msg) {
   // The trusted side IPC::Channel should handle the "hello" handshake; we
   // should not receive the "Hello" message.
   NOTREACHED();
 }
 
 // Channel's methods
 
 // static
 std::unique_ptr<Channel> Channel::Create(
     const IPC::ChannelHandle& channel_handle,
     Mode mode,
     Listener* listener) {
   return base::WrapUnique(new ChannelNacl(channel_handle, mode, listener));
 }
 
 }  // namespace IPC