Add support for sockets that can listen and accept a connection.

ipc/ipc_channel_posix.h

 // Copyright (c) 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 IPC_IPC_CHANNEL_POSIX_H_
 #define IPC_IPC_CHANNEL_POSIX_H_
 #pragma once
 
 #include "ipc/ipc_channel.h"
 
@@ skipping 22 matching lines @@
 // this switch 'on' on the Mac as well.
 
 // The HELLO message from the client to the server is always sent using
 // sendmsg because it will contain the file descriptor that the server
 // needs to send file descriptors in later messages.
 #define IPC_USES_READWRITE 1
 #endif
 
 namespace IPC {
 
-// An implementation of ChannelImpl for POSIX systems that works via
-// socketpairs.  See the .cc file for an overview of the implementation.
 class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
  public:
   // Mirror methods of Channel, see ipc_channel.h for description.
-  ChannelImpl(const IPC::ChannelHandle &channel_handle, Mode mode,
+  ChannelImpl(const IPC::ChannelHandle& channel_handle, Mode mode,
               Listener* listener);
   ~ChannelImpl();
   bool Connect();
   void Close();
   void set_listener(Listener* listener) { listener_ = listener; }
   bool Send(Message* message);
   int GetClientFileDescriptor() const;
+  bool AcceptsConnections() const;
+  bool HasAcceptedConnection() const;
+  void ResetToAcceptingConnectionState();
 
  private:
-  bool CreatePipe(const IPC::ChannelHandle &channel_handle, Mode mode);
+  bool CreatePipe(const IPC::ChannelHandle& channel_handle,
+                  bool uses_domain_sockets);
 
   bool ProcessIncomingMessages();
   bool ProcessOutgoingMessages();
 
+  bool AcceptConnection();
+  void ClosePipeOnError();
+  void QueueHelloMessage();
+  bool IsHelloMessage(const Message* m) const;
+
   // MessageLoopForIO::Watcher implementation.
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int fd);
 
   Mode mode_;
 
   // After accepting one client connection on our server socket we want to
   // stop listening.
   MessageLoopForIO::FileDescriptorWatcher server_listen_connection_watcher_;
   MessageLoopForIO::FileDescriptorWatcher read_watcher_;
   MessageLoopForIO::FileDescriptorWatcher write_watcher_;
 
   // Indicates whether we're currently blocked waiting for a write to complete.
   bool is_blocked_on_write_;
+  bool waiting_connect_;
 
   // If sending a message blocks then we use this variable
   // to keep track of where we are.
   size_t message_send_bytes_written_;
 
-  // If the kTestingChannelID flag is specified, we use a FIFO instead of
-  // a socketpair().
-  bool uses_fifo_;
-
-  // File descriptor we're listening on for new connections in the FIFO case;
-  // unused otherwise.
+  // File descriptor we're listening on for new connections if we listen
+  // for connections.
   int server_listen_pipe_;
 
   // The pipe used for communication.
   int pipe_;
 
   // For a server, the client end of our socketpair() -- the other end of our
   // pipe_ that is passed to the client.
   int client_pipe_;
 
 #if defined(IPC_USES_READWRITE)
@@ skipping 27 matching lines @@
   char input_cmsg_buf_[1024];
 #else
   char input_cmsg_buf_[CMSG_SPACE(sizeof(int) * MAX_READ_FDS)];
 #endif
 
   // Large messages that span multiple pipe buffers, get built-up using
   // this buffer.
   std::string input_overflow_buf_;
   std::vector<int> input_overflow_fds_;
 
-  // In server-mode, we have to wait for the client to connect before we
-  // can begin reading.  We make use of the input_state_ when performing
-  // the connect operation in overlapped mode.
-  bool waiting_connect_;
+  // True if we are responsible for unlinking the unix domain socket file.
+  bool must_unlink_;
 
   ScopedRunnableMethodFactory<ChannelImpl> factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChannelImpl);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_POSIX_H_