Add TCP socket mojo interfaces

mojo/services/public/interfaces/network/tcp_socket.mojom

Index: mojo/services/public/interfaces/network/tcp_socket.mojom
diff --git a/mojo/services/public/interfaces/network/tcp_socket.mojom b/mojo/services/public/interfaces/network/tcp_socket.mojom
new file mode 100644
index 0000000000000000000000000000000000000000..1c0cc1561ca4d861292d6c74087a2165631c54a9
--- /dev/null
+++ b/mojo/services/public/interfaces/network/tcp_socket.mojom
@@ -0,0 +1,80 @@
+// Copyright 2014 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.
+
+import "mojo/services/public/interfaces/network/net_address.mojom"
+import "mojo/services/public/interfaces/network/network_error.mojom"
+
+module mojo {
+
+struct TCPSocketInfo {
+  NetAddress local_address;
+  NetAddress remote_address;
+};
+
+// Represents a TCP socket. A socket can represent either a connection to a

[viettrungluu, 2014/09/30 19:22:15]

Why is it important to combine these two cases into one interface?

+// remote host, or a local server socket waiting for incoming connections.
+//
+// For client connections:
+//  - Connect(), providing a pair of streams to use for data transfer.
+//  - Read and write from the streams as desired.
+//  - Close().
+//
+// For server connections:
+//  - Bind() to allocate a port.
+//  - For as long as you want to accept incoming connections:
+//    1. Listen() to wait for an incoming connection.

[yzshen1, 2014/09/30 18:21:39]

This is different from what Pepper does. Is it intended?

In Pepper:
Listen() starts listening for incoming connections. And it needs to be called
only once.
Accept() waits for an incoming connection until one is available.

[brettw, 2014/09/30 19:17:48]

You're right, I misunderstood what Pepper/BSD did. Fixed.

+//    2. Accept() to initiate a connection once one is available.
+//  - Close().
+interface TCPSocket {
+  // Binds this connection to a local port. The TCPSocket must not be bound,
+  // listening, or connected.
+  //
+  // This function is required to initialize a server socket for using Listen(),
+  // but is optional when using Connect() to initiate a client connection.
+  Bind(NetAddress addr) => (NetworkError result);

[yzshen1, 2014/09/30 18:21:40]

For server socket, it seems we don't have a way to get its resulting bound
address, right?

[brettw, 2014/09/30 19:17:47]

Added info.

+
+  // Starts listening on this socket for incoming connection requests. The
+  // socket must be bound and not connected.
+  //
+  // When an incoming connection is detected, the callback will report success
+  // and you can call Accept() to accept the connection. If a program then
+  // wants to listen for more than one incoming connection, it would typically
+  // call Listen() again to wait for more connections.
+  //
+  // The backlog is a hint indicating the number of incoming connections that
+  // can be queued up at one time waiting for Accept(). This queuing will
+  // happen when connections are incoming faster than Accept() can be called.
+  Listen(int32 backlog) => (NetworkError result);
+
+  // Accepts a connection. The socket must be listening.
+  //
+  // This function is called to accept an incoming connection after Listen()
+  // indicates that one is available. The caller provides the streams that will
+  // be used to send and receive data on the connection.
+  //
+  // On success, the callback will be provided with the new socket that
+  // represents the connection. It will already be in a connected state and the
+  // data streams will be ready to use.
+  Accept(handle<data_pipe_consumer> send_stream,
+         handle<data_pipe_producer> receive_stream) =>
+      (NetworkError result, TCPSocket socket, TCPSocketInfo info);

[yzshen1, 2014/09/30 18:21:39]

You might want to append '?' to the type TCPSocket and TCPSocketInfo.
So that the service can return NULL (on failure).

[brettw, 2014/09/30 19:17:48]

Good idea, I added this everywhere.

+
+  // Connects the socket to the given address. The socket must not be listening
+  // or previously connected. Binding the socket beforehand is optional.
+  Connect(NetAddress addr,
+          handle<data_pipe_consumer> send_stream,
+          handle<data_pipe_producer> receive_stream) =>
+      (NetworkError result, TCPSocketInfo info);
+
+  // Closes the connection. If Close() is not called, the connection will be

[yzshen1, 2014/09/30 18:21:39]

Maybe we could revise the comment to also cover the server socket case.

[brettw, 2014/09/30 19:17:48]

Done

+  // implicitly closes when the TCPSocket has been deleted.
+  Close();
+
+  // Controls whether small writes are coalesced to make TCP segments, and
+  // instead delivers data immediately. The default value is true (coalescing
+  // enabled).
+  SetCoaleseWrites(bool coalesce);
+};
+
+}