POSIX: Rename DescriptorSet to FileDescriptorSet

This is just following up on a code review promise.


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@9676 0039d316-1c4b-4281-b951-d872f2087c98

11 files changed, 54 insertions, 282 deletions

diff --git a/chrome/common/common.scons b/chrome/common/common.scons
index 5824335..e5c709f 100644
--- a/chrome/common/common.scons
+++ b/chrome/common/common.scons
@@ -221,7 +221,7 @@ if not env.Bit('windows'):
   # TODO(port): This is temporary so we can link.
   input_files.Append(
       'temp_scaffolding_stubs.cc',
-      'descriptor_set_posix.cc',
+      'file_descriptor_set_posix.cc',
   )
 
   # TODO(port): Port these.
diff --git a/chrome/common/descriptor_set_posix.cc b/chrome/common/descriptor_set_posix.cc
deleted file mode 100644
index 9b19ef2..0000000
--- a/chrome/common/descriptor_set_posix.cc
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright (c) 2006-2008 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 "chrome/common/descriptor_set_posix.h"
-
-#include "base/logging.h"
-
-DescriptorSet::DescriptorSet()
-    : consumed_descriptor_highwater_(0) {
-}
-
-DescriptorSet::~DescriptorSet() {
-  if (consumed_descriptor_highwater_ == descriptors_.size())
-    return;
-
-  LOG(WARNING) << "DescriptorSet destroyed with unconsumed descriptors";
-  // We close all the descriptors where the close flag is set. If this
-  // message should have been transmitted, then closing those with close
-  // flags set mirrors the expected behaviour.
-  //
-  // If this message was received with more descriptors than expected
-  // (which could a DOS against the browser by a rogue renderer) then all
-  // the descriptors have their close flag set and we free all the extra
-  // kernel resources.
-  for (unsigned i = consumed_descriptor_highwater_;
-       i < descriptors_.size(); ++i) {
-    if (descriptors_[i].auto_close)
-      close(descriptors_[i].fd);
-  }
-}
-
-bool DescriptorSet::Add(int fd) {
-  if (descriptors_.size() == MAX_DESCRIPTORS_PER_MESSAGE)
-    return false;
-
-  struct base::FileDescriptor sd;
-  sd.fd = fd;
-  sd.auto_close = false;
-  descriptors_.push_back(sd);
-  return true;
-}
-
-bool DescriptorSet::AddAndAutoClose(int fd) {
-  if (descriptors_.size() == MAX_DESCRIPTORS_PER_MESSAGE)
-    return false;
-
-  struct base::FileDescriptor sd;
-  sd.fd = fd;
-  sd.auto_close = true;
-  descriptors_.push_back(sd);
-  DCHECK(descriptors_.size() <= MAX_DESCRIPTORS_PER_MESSAGE);
-  return true;
-}
-
-int DescriptorSet::GetDescriptorAt(unsigned index) const {
-  if (index >= descriptors_.size())
-    return -1;
-
-  // We should always walk the descriptors in order, so it's reasonable to
-  // enforce this. Consider the case where a compromised renderer sends us
-  // the following message:
-  //
-  //   ExampleMsg:
-  //     num_fds:2 msg:FD(index = 1) control:SCM_RIGHTS {n, m}
-  //
-  // Here the renderer sent us a message which should have a descriptor, but
-  // actually sent two in an attempt to fill our fd table and kill us. By
-  // setting the index of the descriptor in the message to 1 (it should be
-  // 0), we would record a highwater of 1 and then consider all the
-  // descriptors to have been used.
-  //
-  // So we can either track of the use of each descriptor in a bitset, or we
-  // can enforce that we walk the indexes strictly in order.
-  //
-  // There's one more wrinkle: When logging messages, we may reparse them. So
-  // we have an exception: When the consumed_descriptor_highwater_ is at the
-  // end of the array and index 0 is requested, we reset the highwater value.
-  if (index == 0 && consumed_descriptor_highwater_ == descriptors_.size())
-    consumed_descriptor_highwater_ = 0;
-
-  if (index != consumed_descriptor_highwater_)
-    return -1;
-
-  consumed_descriptor_highwater_ = index + 1;
-  return descriptors_[index].fd;
-}
-
-void DescriptorSet::GetDescriptors(int* buffer) const {
-  for (std::vector<base::FileDescriptor>::const_iterator
-       i = descriptors_.begin(); i != descriptors_.end(); ++i) {
-    *(buffer++) = i->fd;
-  }
-}
-
-void DescriptorSet::CommitAll() {
-  for (std::vector<base::FileDescriptor>::iterator
-       i = descriptors_.begin(); i != descriptors_.end(); ++i) {
-    if (i->auto_close)
-      close(i->fd);
-  }
-  descriptors_.clear();
-  consumed_descriptor_highwater_ = 0;
-}
-
-void DescriptorSet::SetDescriptors(const int* buffer, unsigned count) {
-  DCHECK_LE(count, MAX_DESCRIPTORS_PER_MESSAGE);
-  DCHECK_EQ(descriptors_.size(), 0u);
-  DCHECK_EQ(consumed_descriptor_highwater_, 0u);
-
-  descriptors_.reserve(count);
-  for (unsigned i = 0; i < count; ++i) {
-    struct base::FileDescriptor sd;
-    sd.fd = buffer[i];
-    sd.auto_close = true;
-    descriptors_.push_back(sd);
-  }
-}
diff --git a/chrome/common/descriptor_set_posix.h b/chrome/common/descriptor_set_posix.h
deleted file mode 100644
index 1757648..0000000
--- a/chrome/common/descriptor_set_posix.h
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright (c) 2006-2009 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.
-
-#ifndef CHROME_COMMON_DESCRIPTOR_SET_POSIX_H_
-#define CHROME_COMMON_DESCRIPTOR_SET_POSIX_H_
-
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/file_descriptor_posix.h"
-#include "base/ref_counted.h"
-
-// -----------------------------------------------------------------------------
-// A DescriptorSet is an ordered set of POSIX file descriptors. These are
-// associated with IPC messages so that descriptors can be transmitted over a
-// UNIX domain socket.
-// -----------------------------------------------------------------------------
-class DescriptorSet : public base::RefCountedThreadSafe<DescriptorSet> {
- public:
-  DescriptorSet();
-  ~DescriptorSet();
-
-  // This is the maximum number of descriptors per message. We need to know this
-  // because the control message kernel interface has to be given a buffer which
-  // is large enough to store all the descriptor numbers. Otherwise the kernel
-  // tells us that it truncated the control data and the extra descriptors are
-  // lost.
-  //
-  // In debugging mode, it's a fatal error to try and add more than this number
-  // of descriptors to a DescriptorSet.
-  enum {
-    MAX_DESCRIPTORS_PER_MESSAGE = 4,
-  };
-
-  // ---------------------------------------------------------------------------
-  // Interfaces for building during message serialisation...
-
-  // Add a descriptor to the end of the set. Returns false iff the set is full.
-  bool Add(int fd);
-  // Add a descriptor to the end of the set and automatically close it after
-  // transmission. Returns false iff the set is full.
-  bool AddAndAutoClose(int fd);
-
-  // ---------------------------------------------------------------------------
-
-
-  // ---------------------------------------------------------------------------
-  // Interfaces for accessing during message deserialisation...
-
-  // Return the number of descriptors
-  unsigned size() const { return descriptors_.size(); }
-  // Return true if no unconsumed descriptors remain
-  bool empty() const { return descriptors_.empty(); }
-  // Fetch the nth descriptor from the beginning of the set. Code using this
-  // /must/ access the descriptors in order, except that it may wrap from the
-  // end to index 0 again.
-  //
-  // This interface is designed for the deserialising code as it doesn't
-  // support close flags.
-  //   returns: file descriptor, or -1 on error
-  int GetDescriptorAt(unsigned n) const;
-
-  // ---------------------------------------------------------------------------
-
-
-  // ---------------------------------------------------------------------------
-  // Interfaces for transmission...
-
-  // Fill an array with file descriptors without 'consuming' them. CommitAll
-  // must be called after these descriptors have been transmitted.
-  //   buffer: (output) a buffer of, at least, size() integers.
-  void GetDescriptors(int* buffer) const;
-  // This must be called after transmitting the descriptors returned by
-  // GetDescriptors. It marks all the descriptors as consumed and closes those
-  // which are auto-close.
-  void CommitAll();
-
-  // ---------------------------------------------------------------------------
-
-
-  // ---------------------------------------------------------------------------
-  // Interfaces for receiving...
-
-  // Set the contents of the set from the given buffer. This set must be empty
-  // before calling. The auto-close flag is set on all the descriptors so that
-  // unconsumed descriptors are closed on destruction.
-  void SetDescriptors(const int* buffer, unsigned count);
-
-  // ---------------------------------------------------------------------------
-
- private:
-  // A vector of descriptors and close flags. If this message is sent, then
-  // these descriptors are sent as control data. After sending, any descriptors
-  // with a true flag are closed. If this message has been received, then these
-  // are the descriptors which were received and all close flags are true.
-  std::vector<base::FileDescriptor> descriptors_;
-
-  // This contains the index of the next descriptor which should be consumed.
-  // It's used in a couple of ways. Firstly, at destruction we can check that
-  // all the descriptors have been read (with GetNthDescriptor). Secondly, we
-  // can check that they are read in order.
-  mutable unsigned consumed_descriptor_highwater_;
-
-  DISALLOW_COPY_AND_ASSIGN(DescriptorSet);
-};
-
-#endif  // CHROME_COMMON_FILE_DESCRIPTOR_POSIX_H_
diff --git a/chrome/common/file_descriptor_set_posix.cc b/chrome/common/file_descriptor_set_posix.cc
index 9b19ef2..b57c007 100644
--- a/chrome/common/file_descriptor_set_posix.cc
+++ b/chrome/common/file_descriptor_set_posix.cc
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/common/descriptor_set_posix.h"
+#include "chrome/common/file_descriptor_set_posix.h"
 
 #include "base/logging.h"
 
-DescriptorSet::DescriptorSet()
+FileDescriptorSet::FileDescriptorSet()
     : consumed_descriptor_highwater_(0) {
 }
 
-DescriptorSet::~DescriptorSet() {
+FileDescriptorSet::~FileDescriptorSet() {
   if (consumed_descriptor_highwater_ == descriptors_.size())
     return;
 
-  LOG(WARNING) << "DescriptorSet destroyed with unconsumed descriptors";
+  LOG(WARNING) << "FileDescriptorSet destroyed with unconsumed descriptors";
   // We close all the descriptors where the close flag is set. If this
   // message should have been transmitted, then closing those with close
   // flags set mirrors the expected behaviour.
@@ -30,7 +30,7 @@ DescriptorSet::~DescriptorSet() {
   }
 }
 
-bool DescriptorSet::Add(int fd) {
+bool FileDescriptorSet::Add(int fd) {
   if (descriptors_.size() == MAX_DESCRIPTORS_PER_MESSAGE)
     return false;
 
@@ -41,7 +41,7 @@ bool DescriptorSet::Add(int fd) {
   return true;
 }
 
-bool DescriptorSet::AddAndAutoClose(int fd) {
+bool FileDescriptorSet::AddAndAutoClose(int fd) {
   if (descriptors_.size() == MAX_DESCRIPTORS_PER_MESSAGE)
     return false;
 
@@ -53,7 +53,7 @@ bool DescriptorSet::AddAndAutoClose(int fd) {
   return true;
 }
 
-int DescriptorSet::GetDescriptorAt(unsigned index) const {
+int FileDescriptorSet::GetDescriptorAt(unsigned index) const {
   if (index >= descriptors_.size())
     return -1;
 
@@ -86,14 +86,14 @@ int DescriptorSet::GetDescriptorAt(unsigned index) const {
   return descriptors_[index].fd;
 }
 
-void DescriptorSet::GetDescriptors(int* buffer) const {
+void FileDescriptorSet::GetDescriptors(int* buffer) const {
   for (std::vector<base::FileDescriptor>::const_iterator
        i = descriptors_.begin(); i != descriptors_.end(); ++i) {
     *(buffer++) = i->fd;
   }
 }
 
-void DescriptorSet::CommitAll() {
+void FileDescriptorSet::CommitAll() {
   for (std::vector<base::FileDescriptor>::iterator
        i = descriptors_.begin(); i != descriptors_.end(); ++i) {
     if (i->auto_close)
@@ -103,7 +103,7 @@ void DescriptorSet::CommitAll() {
   consumed_descriptor_highwater_ = 0;
 }
 
-void DescriptorSet::SetDescriptors(const int* buffer, unsigned count) {
+void FileDescriptorSet::SetDescriptors(const int* buffer, unsigned count) {
   DCHECK_LE(count, MAX_DESCRIPTORS_PER_MESSAGE);
   DCHECK_EQ(descriptors_.size(), 0u);
   DCHECK_EQ(consumed_descriptor_highwater_, 0u);
diff --git a/chrome/common/file_descriptor_set_posix.h b/chrome/common/file_descriptor_set_posix.h
index 1757648..342e6d9 100644
--- a/chrome/common/file_descriptor_set_posix.h
+++ b/chrome/common/file_descriptor_set_posix.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CHROME_COMMON_DESCRIPTOR_SET_POSIX_H_
-#define CHROME_COMMON_DESCRIPTOR_SET_POSIX_H_
+#ifndef CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
+#define CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
 
 #include <vector>
 
@@ -12,14 +12,14 @@
 #include "base/ref_counted.h"
 
 // -----------------------------------------------------------------------------
-// A DescriptorSet is an ordered set of POSIX file descriptors. These are
+// A FileDescriptorSet is an ordered set of POSIX file descriptors. These are
 // associated with IPC messages so that descriptors can be transmitted over a
 // UNIX domain socket.
 // -----------------------------------------------------------------------------
-class DescriptorSet : public base::RefCountedThreadSafe<DescriptorSet> {
+class FileDescriptorSet : public base::RefCountedThreadSafe<FileDescriptorSet> {
  public:
-  DescriptorSet();
-  ~DescriptorSet();
+  FileDescriptorSet();
+  ~FileDescriptorSet();
 
   // This is the maximum number of descriptors per message. We need to know this
   // because the control message kernel interface has to be given a buffer which
@@ -28,7 +28,7 @@ class DescriptorSet : public base::RefCountedThreadSafe<DescriptorSet> {
   // lost.
   //
   // In debugging mode, it's a fatal error to try and add more than this number
-  // of descriptors to a DescriptorSet.
+  // of descriptors to a FileDescriptorSet.
   enum {
     MAX_DESCRIPTORS_PER_MESSAGE = 4,
   };
@@ -102,7 +102,7 @@ class DescriptorSet : public base::RefCountedThreadSafe<DescriptorSet> {
   // can check that they are read in order.
   mutable unsigned consumed_descriptor_highwater_;
 
-  DISALLOW_COPY_AND_ASSIGN(DescriptorSet);
+  DISALLOW_COPY_AND_ASSIGN(FileDescriptorSet);
 };
 
-#endif  // CHROME_COMMON_FILE_DESCRIPTOR_POSIX_H_
+#endif  // CHROME_COMMON_FILE_DESCRIPTOR_SET_POSIX_H_
diff --git a/chrome/common/ipc_channel_posix.cc b/chrome/common/ipc_channel_posix.cc
index 72d1554..e29596c 100644
--- a/chrome/common/ipc_channel_posix.cc
+++ b/chrome/common/ipc_channel_posix.cc
@@ -28,7 +28,7 @@
 #include "base/singleton.h"
 #include "chrome/common/chrome_counters.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/descriptor_set_posix.h"
+#include "chrome/common/file_descriptor_set_posix.h"
 #include "chrome/common/ipc_message_utils.h"
 
 namespace IPC {
@@ -494,7 +494,7 @@ bool Channel::ChannelImpl::ProcessIncomingMessages() {
           }
 
           if (m.header()->num_fds >
-              DescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE) {
+              FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE) {
             // There are too many descriptors in this message
             error = "Message requires an excessive number of descriptors";
           }
@@ -514,7 +514,8 @@ bool Channel::ChannelImpl::ProcessIncomingMessages() {
             return false;
           }
 
-          m.descriptor_set()->SetDescriptors(&fds[fds_i], m.header()->num_fds);
+          m.file_descriptor_set()->SetDescriptors(
+              &fds[fds_i], m.header()->num_fds);
           fds_i += m.header()->num_fds;
         }
 #ifdef IPC_MESSAGE_DEBUG_EXTRA
@@ -578,15 +579,15 @@ bool Channel::ChannelImpl::ProcessOutgoingMessages() {
       msgh.msg_iov = &iov;
       msgh.msg_iovlen = 1;
       char buf[CMSG_SPACE(
-          sizeof(int[DescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE]))];
+          sizeof(int[FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE]))];
 
       if (message_send_bytes_written_ == 0 &&
-          !msg->descriptor_set()->empty()) {
+          !msg->file_descriptor_set()->empty()) {
         // This is the first chunk of a message which has descriptors to send
         struct cmsghdr *cmsg;
-        const unsigned num_fds = msg->descriptor_set()->size();
+        const unsigned num_fds = msg->file_descriptor_set()->size();
 
-        DCHECK_LE(num_fds, DescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE);
+        DCHECK_LE(num_fds, FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE);
 
         msgh.msg_control = buf;
         msgh.msg_controllen = CMSG_SPACE(sizeof(int) * num_fds);
@@ -594,7 +595,7 @@ bool Channel::ChannelImpl::ProcessOutgoingMessages() {
         cmsg->cmsg_level = SOL_SOCKET;
         cmsg->cmsg_type = SCM_RIGHTS;
         cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds);
-        msg->descriptor_set()->GetDescriptors(
+        msg->file_descriptor_set()->GetDescriptors(
             reinterpret_cast<int*>(CMSG_DATA(cmsg)));
         msgh.msg_controllen = cmsg->cmsg_len;
 
@@ -603,7 +604,7 @@ bool Channel::ChannelImpl::ProcessOutgoingMessages() {
 
       bytes_written = sendmsg(pipe_, &msgh, MSG_DONTWAIT);
       if (bytes_written > 0)
-        msg->descriptor_set()->CommitAll();
+        msg->file_descriptor_set()->CommitAll();
     } while (bytes_written == -1 && errno == EINTR);
 
     if (bytes_written < 0 && errno != EAGAIN) {
diff --git a/chrome/common/ipc_channel_posix.h b/chrome/common/ipc_channel_posix.h
index d6ed17d..fbdd59b 100644
--- a/chrome/common/ipc_channel_posix.h
+++ b/chrome/common/ipc_channel_posix.h
@@ -14,7 +14,7 @@
 #include <vector>
 
 #include "base/message_loop.h"
-#include "chrome/common/descriptor_set_posix.h"
+#include "chrome/common/file_descriptor_set_posix.h"
 
 namespace IPC {
 
@@ -76,7 +76,7 @@ class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
     // We assume a worst case: kReadBufferSize bytes of messages, where each
     // message has no payload and a full complement of descriptors.
     MAX_READ_FDS = (Channel::kReadBufferSize / sizeof(IPC::Message::Header)) *
-                   DescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE,
+                   FileDescriptorSet::MAX_DESCRIPTORS_PER_MESSAGE,
   };
 
   // This is a control message buffer large enough to hold kMaxReadFDs
diff --git a/chrome/common/ipc_message.cc b/chrome/common/ipc_message.cc
index 9a15f1c..593b763 100644
--- a/chrome/common/ipc_message.cc
+++ b/chrome/common/ipc_message.cc
@@ -8,7 +8,7 @@
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
-#include "chrome/common/descriptor_set_posix.h"
+#include "chrome/common/file_descriptor_set_posix.h"
 #endif
 
 namespace IPC {
@@ -45,7 +45,7 @@ Message::Message(const char* data, int data_len) : Pickle(data, data_len) {
 Message::Message(const Message& other) : Pickle(other) {
   InitLoggingVariables();
 #if defined(OS_POSIX)
-  descriptor_set_ = other.descriptor_set_;
+  file_descriptor_set_ = other.file_descriptor_set_;
 #endif
 }
 
@@ -60,7 +60,7 @@ void Message::InitLoggingVariables() {
 Message& Message::operator=(const Message& other) {
   *static_cast<Pickle*>(this) = other;
 #if defined(OS_POSIX)
-  descriptor_set_ = other.descriptor_set_;
+  file_descriptor_set_ = other.file_descriptor_set_;
 #endif
   return *this;
 }
@@ -90,11 +90,11 @@ void Message::set_received_time(int64 time) const {
 bool Message::WriteFileDescriptor(const base::FileDescriptor& 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(descriptor_set()->size());
+  WriteInt(file_descriptor_set()->size());
   if (descriptor.auto_close) {
-    return descriptor_set()->AddAndAutoClose(descriptor.fd);
+    return file_descriptor_set()->AddAndAutoClose(descriptor.fd);
   } else {
-    return descriptor_set()->Add(descriptor.fd);
+    return file_descriptor_set()->Add(descriptor.fd);
   }
 }
 
@@ -104,19 +104,19 @@ bool Message::ReadFileDescriptor(void** iter,
   if (!ReadInt(iter, &descriptor_index))
     return false;
 
-  DescriptorSet* descriptor_set = descriptor_set_.get();
-  if (!descriptor_set)
+  FileDescriptorSet* file_descriptor_set = file_descriptor_set_.get();
+  if (!file_descriptor_set)
     return false;
 
-  descriptor->fd = descriptor_set->GetDescriptorAt(descriptor_index);
+  descriptor->fd = file_descriptor_set->GetDescriptorAt(descriptor_index);
   descriptor->auto_close = false;
 
   return descriptor->fd >= 0;
 }
 
-void Message::EnsureDescriptorSet() {
-  if (descriptor_set_.get() == NULL)
-    descriptor_set_ = new DescriptorSet;
+void Message::EnsureFileDescriptorSet() {
+  if (file_descriptor_set_.get() == NULL)
+    file_descriptor_set_ = new FileDescriptorSet;
 }
 
 #endif
diff --git a/chrome/common/ipc_message.h b/chrome/common/ipc_message.h
index b670bf1..d0aa1c7 100644
--- a/chrome/common/ipc_message.h
+++ b/chrome/common/ipc_message.h
@@ -23,7 +23,7 @@ namespace base {
 class FileDescriptor;
 }
 
-class DescriptorSet;
+class FileDescriptorSet;
 
 namespace IPC {
 
@@ -239,17 +239,17 @@ class Message : public Pickle {
 
 #if defined(OS_POSIX)
   // The set of file descriptors associated with this message.
-  scoped_refptr<DescriptorSet> descriptor_set_;
+  scoped_refptr<FileDescriptorSet> file_descriptor_set_;
 
-  // Ensure that a DescriptorSet is allocated
-  void EnsureDescriptorSet();
+  // Ensure that a FileDescriptorSet is allocated
+  void EnsureFileDescriptorSet();
 
-  DescriptorSet* descriptor_set() {
-    EnsureDescriptorSet();
-    return descriptor_set_.get();
+  FileDescriptorSet* file_descriptor_set() {
+    EnsureFileDescriptorSet();
+    return file_descriptor_set_.get();
   }
-  const DescriptorSet* descriptor_set() const {
-    return descriptor_set_.get();
+  const FileDescriptorSet* file_descriptor_set() const {
+    return file_descriptor_set_.get();
   }
 #endif
 
diff --git a/chrome/common/ipc_message_utils.h b/chrome/common/ipc_message_utils.h
index fa65288..ae42bb0 100644
--- a/chrome/common/ipc_message_utils.h
+++ b/chrome/common/ipc_message_utils.h
@@ -13,7 +13,7 @@
 #include "base/string_util.h"
 #include "base/tuple.h"
 #if defined(OS_POSIX)
-#include "chrome/common/descriptor_set_posix.h"
+#include "chrome/common/file_descriptor_set_posix.h"
 #endif
 #include "chrome/common/ipc_sync_message.h"
 #include "chrome/common/thumbnail_score.h"
diff --git a/chrome/common/ipc_tests.cc b/chrome/common/ipc_tests.cc
index 4b24406..ae88659 100644
--- a/chrome/common/ipc_tests.cc
+++ b/chrome/common/ipc_tests.cc
@@ -26,9 +26,6 @@
 #include "base/test_suite.h"
 #include "base/thread.h"
 #include "chrome/common/chrome_switches.h"
-#if defined(OS_POSIX)
-#include "chrome/common/descriptor_set_posix.h"
-#endif
 #include "chrome/common/ipc_channel.h"
 #include "chrome/common/ipc_channel_proxy.h"
 #include "chrome/common/ipc_message_utils.h"