IPC: Generalize FileDescriptorSet to MessageAttachmentSet

ipc/ipc_message.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_message.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/logging.h"
 #include "build/build_config.h"
+#include "ipc/ipc_message_attachment_set.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
-#include "ipc/file_descriptor_set_posix.h"
 #endif
 
 namespace {
 
 base::StaticAtomicSequenceNumber g_ref_num;
 
 // Create a reference number for identifying IPC messages in traces. The return
 // values has the reference number stored in the upper 24 bits, leaving the low
 // 8 bits set to 0 for use as flags.
 inline uint32 GetRefNumUpper24() {
@@ skipping 40 matching lines @@
   Init();
 }
 
 Message::Message(const char* data, int data_len) : Pickle(data, data_len) {
   Init();
 }
 
 Message::Message(const Message& other) : Pickle(other) {
   Init();
 #if defined(OS_POSIX)
-  file_descriptor_set_ = other.file_descriptor_set_;
+  attachment_set_ = other.attachment_set_;
 #endif
 }
 
 void Message::Init() {
   dispatch_error_ = false;
 #ifdef IPC_MESSAGE_LOG_ENABLED
   received_time_ = 0;
   dont_log_ = false;
   log_data_ = NULL;
 #endif
 }
 
 Message& Message::operator=(const Message& other) {
   *static_cast<Pickle*>(this) = other;
 #if defined(OS_POSIX)
-  file_descriptor_set_ = other.file_descriptor_set_;
+  attachment_set_ = other.attachment_set_;
 #endif
   return *this;
 }
 
 void Message::SetHeaderValues(int32 routing, uint32 type, uint32 flags) {
   // This should only be called when the message is already empty.
   DCHECK(payload_size() == 0);
 
   header()->routing = routing;
   header()->type = type;
   header()->flags = flags;
 }
 
+void Message::EnsureMessageAttachmentSet() {
+  if (attachment_set_.get() == NULL)
+    attachment_set_ = new MessageAttachmentSet;
+}
+
 #ifdef IPC_MESSAGE_LOG_ENABLED
 void Message::set_sent_time(int64 time) {
   DCHECK((header()->flags & HAS_SENT_TIME_BIT) == 0);
   header()->flags |= HAS_SENT_TIME_BIT;
   WriteInt64(time);
 }
 
 int64 Message::sent_time() const {
   if ((header()->flags & HAS_SENT_TIME_BIT) == 0)
     return 0;
 
   const char* data = end_of_payload();
   data -= sizeof(int64);
   return *(reinterpret_cast<const int64*>(data));
 }
 
 void Message::set_received_time(int64 time) const {
   received_time_ = time;
 }
 #endif
 
 #if defined(OS_POSIX)
 bool Message::WriteFile(base::ScopedFD descriptor) {
   // We write the index of the descriptor so that we don't have to
   // keep the current descriptor as extra decoding state when deserialising.
-  WriteInt(file_descriptor_set()->size());
-  return file_descriptor_set()->AddToOwn(descriptor.Pass());
+  WriteInt(attachment_set()->size());
+  return attachment_set()->AddToOwn(descriptor.Pass());
 }
 
 bool Message::WriteBorrowingFile(const base::PlatformFile& descriptor) {
   // We write the index of the descriptor so that we don't have to
   // keep the current descriptor as extra decoding state when deserialising.
-  WriteInt(file_descriptor_set()->size());
-  return file_descriptor_set()->AddToBorrow(descriptor);
+  WriteInt(attachment_set()->size());
+  return attachment_set()->AddToBorrow(descriptor);
 }
 
 bool Message::ReadFile(PickleIterator* iter, base::ScopedFD* descriptor) const {
   int descriptor_index;
   if (!iter->ReadInt(&descriptor_index))
     return false;
 
-  FileDescriptorSet* file_descriptor_set = file_descriptor_set_.get();
-  if (!file_descriptor_set)
+  MessageAttachmentSet* attachment_set = attachment_set_.get();
+  if (!attachment_set)
     return false;
 
-  base::PlatformFile file =
-      file_descriptor_set->TakeDescriptorAt(descriptor_index);
+  base::PlatformFile file = attachment_set->TakeDescriptorAt(descriptor_index);
   if (file < 0)
     return false;
 
   descriptor->reset(file);
   return true;
 }
 
 bool Message::HasFileDescriptors() const {
-  return file_descriptor_set_.get() && !file_descriptor_set_->empty();
-}
-
-void Message::EnsureFileDescriptorSet() {
-  if (file_descriptor_set_.get() == NULL)
-    file_descriptor_set_ = new FileDescriptorSet;
+  return attachment_set_.get() && !attachment_set_->empty();
 }
 
 #endif
 
 }  // namespace IPC