workaround for mac kernel bug

ipc/ipc_channel_posix.h

 // 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.
 
 #ifndef IPC_IPC_CHANNEL_POSIX_H_
 #define IPC_IPC_CHANNEL_POSIX_H_
 
 #include "ipc/ipc_channel.h"
 
 #include <sys/socket.h>  // for CMSG macros
 
 #include <queue>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "ipc/file_descriptor_set_posix.h"
 #include "ipc/ipc_channel_reader.h"
 
 #if !defined(OS_MACOSX)
 // On Linux, the seccomp sandbox makes it very expensive to call
@@ skipping 50 matching lines @@
 
  private:
   bool CreatePipe(const IPC::ChannelHandle& channel_handle);
 
   bool ProcessOutgoingMessages();
 
   bool AcceptConnection();
   void ClosePipeOnError();
   int GetHelloMessageProcId();
   void QueueHelloMessage();
+  void CloseFileDescriptors(Message* msg);
+  void QueueCloseFDMessage(int fd, int hops);
 
   // ChannelReader implementation.
   virtual ReadState ReadData(char* buffer,
                              int buffer_len,
                              int* bytes_read) OVERRIDE;
   virtual bool WillDispatchInputMessage(Message* msg) OVERRIDE;
   virtual bool DidEmptyInputBuffers() OVERRIDE;
-  virtual void HandleHelloMessage(const Message& msg) OVERRIDE;
+  virtual void HandleInternalMessage(const Message& msg) OVERRIDE;
 
 #if defined(IPC_USES_READWRITE)
   // Reads the next message from the fd_pipe_ and appends them to the
   // input_fds_ queue. Returns false if there was a message receiving error.
   // True means there was a message and it was processed properly, or there was
   // no messages.
   bool ReadFileDescriptorsFromFDPipe();
 #endif
 
   // Finds the set of file descriptors in the given message.  On success,
@@ skipping 76 matching lines @@
   char input_cmsg_buf_[kMaxReadFDBuffer];
 
   // File descriptors extracted from messages coming off of the channel. The
   // handles may span messages and come off different channels from the message
   // data (in the case of READWRITE), and are processed in FIFO here.
   // NOTE: The implementation assumes underlying storage here is contiguous, so
   // don't change to something like std::deque<> without changing the
   // implementation!
   std::vector<int> input_fds_;
 
+#if defined(OS_MACOSX)
+  // On OSX, sent FDs must not be closed until we get an ack.
+  // Keep track of sent FDs here to make sure the remote is not
+  // trying to bamboozle us.
+  std::set<int> fds_to_close_;
+#endif
+
   // True if we are responsible for unlinking the unix domain socket file.
   bool must_unlink_;
 
 #if defined(OS_LINUX)
   // If non-zero, overrides the process ID sent in the hello message.
   static int global_pid_;
 #endif  // OS_LINUX
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelImpl);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_POSIX_H_