Implement parts of the Mojo TCP interfaces.

mojo/services/network/tcp_server_socket_impl.cc

Index: mojo/services/network/tcp_server_socket_impl.cc
diff --git a/mojo/services/network/tcp_server_socket_impl.cc b/mojo/services/network/tcp_server_socket_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3fb88e0bc2590618d341a7753756d12e8417aa8d
--- /dev/null
+++ b/mojo/services/network/tcp_server_socket_impl.cc
@@ -0,0 +1,69 @@
+// 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.
+
+#include "mojo/services/network/tcp_server_socket_impl.h"
+
+#include "mojo/services/network/net_adapters.h"
+#include "mojo/services/network/net_address_type_converters.h"
+#include "mojo/services/network/tcp_connected_socket_impl.h"
+#include "net/base/net_errors.h"
+
+namespace mojo {
+
+TCPServerSocketImpl::TCPServerSocketImpl(scoped_ptr<net::TCPSocket> socket)
+    : socket_(socket.Pass()) {
+}
+
+TCPServerSocketImpl::~TCPServerSocketImpl() {
+}
+
+void TCPServerSocketImpl::Accept(
+    ScopedDataPipeConsumerHandle send_stream,
+    ScopedDataPipeProducerHandle receive_stream,
+    InterfaceRequest<TCPConnectedSocket> client_socket,
+    const AcceptCallback& callback) {
+  // One possible future enhancement would be to enqueue multiple Accept calls
+  // on this object. This would allow the client to accept some number of
+  // incoming connections rapidly without doing an IPC round-trip.
+  if (!pending_callback_.is_null()) {
+    // Already have a pending accept on this socket.
+    callback.Run(MakeNetworkError(net::ERR_UNEXPECTED), NetAddressPtr());
+    return;
+  }
+
+  int result = socket_->Accept(
+      &accepted_socket_, &accepted_address_,
+      base::Bind(&TCPServerSocketImpl::OnAcceptCompleted,
+                 base::Unretained(this)));
+  if (result == net::OK || result == net::ERR_IO_PENDING) {
+    pending_callback_ = callback;
+    pending_send_stream_ = send_stream.Pass();
+    pending_receive_stream_ = receive_stream.Pass();
+    pending_client_socket_ = client_socket.Pass();
+    if (result == net::OK)
+      OnAcceptCompleted(net::OK);
+  } else {
+    callback.Run(MakeNetworkError(result), NetAddressPtr());
+  }
+}
+
+void TCPServerSocketImpl::OnAcceptCompleted(int result) {
+  if (result != net::OK) {
+    pending_callback_.Run(MakeNetworkError(result), NetAddressPtr());
+    pending_send_stream_.reset();
+    pending_receive_stream_.reset();
+    pending_client_socket_ = InterfaceRequest<TCPConnectedSocket>();

[brettw, 2014/10/07 23:12:16]

Is this the right thing to do for an interface request? It's not clear to me if
this is sufficient to clean up all resources.

[yzshen1, 2014/10/07 23:51:36]

It is sufficient. InterfaceRequest is just a wrapper of a message pipe.

+  } else {
+    BindToRequest(new TCPConnectedSocketImpl(
+        accepted_socket_.Pass(),
+        pending_send_stream_.Pass(),
+        pending_receive_stream_.Pass()), &pending_client_socket_);
+    pending_callback_.Run(MakeNetworkError(net::OK),
+                          NetAddress::From(accepted_address_));
+  }
+
+  pending_callback_ = AcceptCallback();
+}
+
+}  // namespace mojo