First cut at POSIX Implementation of IPC Channel using FIFOs.

chrome/common/ipc_channel.h

 // 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.
 
 #ifndef CHROME_COMMON_IPC_CHANNEL_H_
 #define CHROME_COMMON_IPC_CHANNEL_H_
 
 #include <queue>
 
 #include "base/message_loop.h"
 #include "chrome/common/ipc_message.h"
 
 namespace IPC {
 
 //------------------------------------------------------------------------------
 
-class Channel : public Message::Sender
+class Channel : public Message::Sender,
 #if defined(OS_WIN)
-    , public MessageLoopForIO::IOHandler
+    public MessageLoopForIO::IOHandler
+#elif defined(OS_POSIX)
+    public MessageLoopForIO::FileWatcher
 #endif
     {
   // Security tests need access to the pipe handle.
   friend class ChannelTest;
 
  public:
   // Implemented by consumers of a Channel to receive messages.
   class Listener {
    public:
     virtual ~Listener() {}
@@ skipping 53 matching lines @@
   // |message| must be allocated using operator new.  This object will be
   // deleted once the contents of the Message have been sent.
   //
   //  FIXME bug 551500: the channel does not notice failures, so if the
   //    renderer crashes, it will silently succeed, leaking the parameter.
   //    At least the leak will be fixed by...
   //
   virtual bool Send(Message* message);
 
  private:
-#if defined(OS_WIN)
   const std::wstring PipeName(const std::wstring& channel_id) const;
   bool CreatePipe(const std::wstring& channel_id, Mode mode);
+#if defined(OS_WIN)
   bool ProcessConnection();
   bool ProcessIncomingMessages(MessageLoopForIO::IOContext* context,
                                DWORD bytes_read);
   bool ProcessOutgoingMessages(MessageLoopForIO::IOContext* context,
                                DWORD bytes_written);
 
   // MessageLoop::IOHandler implementation.
   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered, DWORD error);
-#endif
-
  private:
   enum {
     BUF_SIZE = 4096
   };
 
-#if defined(OS_WIN)
   struct State {
     explicit State(Channel* channel);
     ~State();
     MessageLoopForIO::IOContext context;
     bool is_pending;
   };
 
   State input_state_;
   State output_state_;
 
   HANDLE pipe_;
-#endif
+#elif defined(OS_POSIX)
+  bool ProcessIncomingMessages();
+  bool ProcessOutgoingMessages();
+
+  void OnFileReadReady(int fd);
+  void OnFileWriteReady(int fd);
+
+
+  Mode mode_;
+
+  // TODO(playmobil): do we need to change BUF_SIZE ?
+ private:
+  enum {
+    BUF_SIZE = 4096
+  };
+
+  // PIMPL to encapsulate libevent structures.
+  struct EventHolder;
+  EventHolder *server_listen_connection_event_;
+  EventHolder *read_event_;
+  EventHolder *write_event_;
+
+  // If sending a message blocks then we use this variable
+  // to keep track of where we are.
+  size_t message_send_bytes_written_;
+
+  int server_listen_pipe_;
+  int pipe_;
+  std::string pipe_name_;
+#endif  // defined(OS_POSIX)
   Listener* listener_;
 
   // Messages to be sent are queued here.
   std::queue<Message*> output_queue_;
 
   // We read from the pipe into this buffer
   char input_buf_[BUF_SIZE];
 
   // Large messages that span multiple pipe buffers, get built-up using
   // this buffer.
@@ skipping 20 matching lines @@
                                      // to avoid conflicting with normal
                                      // message types, which are enumeration
                                      // constants starting from 0.
   };
 };
 
 }
 
 #endif  // CHROME_COMMON_IPC_CHANNEL_H_