IPC: Generalize FileDescriptorSet to MessageAttachmentSet

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 <sys/types.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/task_runner_util.h"
 #include "base/threading/simple_thread.h"
-#include "ipc/file_descriptor_set_posix.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_logging.h"
+#include "ipc/ipc_message_attachment_set.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;
 };
 
 namespace {
 
 bool ReadDataOnReaderThread(int pipe, MessageContents* contents) {
   DCHECK(pipe >= 0);
   if (pipe < 0)
     return false;
 
   contents->data.resize(Channel::kReadBufferSize);
-  contents->fds.resize(FileDescriptorSet::kMaxDescriptorsPerMessage);
+  contents->fds.resize(MessageAttachmentSet::kMaxDescriptorsPerMessage);
 
   NaClAbiNaClImcMsgIoVec iov = { &contents->data[0], contents->data.size() };
   NaClAbiNaClImcMsgHdr msg = {
     &iov, 1, &contents->fds[0], contents->fds.size()
   };
 
   int bytes_read = imc_recvmsg(pipe, &msg, 0);
 
   if (bytes_read <= 0) {
     // NaClIPCAdapter::BlockingReceive returns -1 when the pipe closes (either
@@ skipping 217 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[FileDescriptorSet::kMaxDescriptorsPerMessage];
-    const size_t num_fds = msg->file_descriptor_set()->size();
-    DCHECK(num_fds <= FileDescriptorSet::kMaxDescriptorsPerMessage);
-    msg->file_descriptor_set()->PeekDescriptors(fds);
+    int fds[MessageAttachmentSet::kMaxDescriptorsPerMessage];
+    const size_t num_fds = msg->attachment_set()->size();
+    DCHECK(num_fds <= MessageAttachmentSet::kMaxDescriptorsPerMessage);
+    msg->attachment_set()->PeekDescriptors(fds);
 
     NaClAbiNaClImcMsgIoVec iov = {
       const_cast<void*>(msg->data()), msg->size()
     };
     NaClAbiNaClImcMsgHdr msgh = { &iov, 1, fds, 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_
                   << " Currently writing message of size: "
                   << msg->size();
       return false;
     } else {
-      msg->file_descriptor_set()->CommitAll();
+      msg->attachment_set()->CommitAll();
     }
 
     // Message sent OK!
     DVLOG(2) << "sent message @" << msg.get() << " with type " << msg->type()
              << " on fd " << pipe_;
   }
   return true;
 }
 
 void ChannelNacl::CallOnChannelConnected() {
@@ skipping 33 matching lines @@
 
 bool ChannelNacl::WillDispatchInputMessage(Message* msg) {
   uint16 header_fds = msg->header()->num_fds;
   CHECK(header_fds == input_fds_.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->file_descriptor_set()->AddDescriptorsToOwn(&input_fds_.front(),
-                                                  header_fds);
+  msg->attachment_set()->AddDescriptorsToOwn(&input_fds_.front(), header_fds);
   input_fds_.clear();
   return true;
 }
 
 bool ChannelNacl::DidEmptyInputBuffers() {
   // When the input data buffer is empty, the fds should be too.
   return input_fds_.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
 scoped_ptr<Channel> Channel::Create(
     const IPC::ChannelHandle &channel_handle, Mode mode, Listener* listener) {
   return scoped_ptr<Channel>(
       new ChannelNacl(channel_handle, mode, listener));
 }
 
 }  // namespace IPC