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

These sockets allow one connection at a time, however clients can
connect and disconnect repeatedly.

These are going to be used by Cloud Print, Remoting and
Automation.

BUG=NONE
TEST=BUILD

Committed: http://src.chromium.org/viewvc/chrome?view=rev&revision=69660

Review URL: http://codereview.chromium.org/5749001

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

1 files changed, 23 insertions, 14 deletions

diff --git a/ipc/ipc_channel_posix.h b/ipc/ipc_channel_posix.h
index 4ff3de1..ecfd41a 100644
--- a/ipc/ipc_channel_posix.h
+++ b/ipc/ipc_channel_posix.h
@@ -40,12 +40,10 @@
 
 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();
@@ -53,13 +51,23 @@ class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
   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 listening_socket);
 
   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);
@@ -74,17 +82,14 @@ class Channel::ChannelImpl : public MessageLoopForIO::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.
@@ -132,16 +137,20 @@ class Channel::ChannelImpl : public MessageLoopForIO::Watcher {
   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);
 };
 
+// The maximum length of the name of a pipe for MODE_NAMED_SERVER or
+// MODE_NAMED_CLIENT if you want to pass in your own socket.
+// The standard size on linux is 108, mac is 104. To maintain consistency
+// across platforms we standardize on the smaller value.
+static const size_t kMaxPipeNameLength = 104;
+
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_POSIX_H_