Adds a method to TCPServerSocket to adopt a socket.

net/socket/tcp_server_socket.cc

 // Copyright 2013 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 "net/socket/tcp_server_socket.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "net/base/net_errors.h"
 #include "net/socket/tcp_client_socket.h"
 
 namespace net {
 
 TCPServerSocket::TCPServerSocket(NetLog* net_log, const NetLogSource& source)
     : socket_(nullptr, net_log, source), pending_accept_(false) {}
 
+#if defined(OS_POSIX)
+int TCPServerSocket::AdopListeningRawSocket(int socket_fd) {
+  // A TCPSocketPosix can adopt any socket, whether connected or not, so the
+  // following method is a slight misnomer.
+  return socket_.AdoptConnectedSocket(socket_fd, IPEndPoint());

[mmenke, 2017/04/17 17:42:18]

Using IPEndPoint() seems to violate the API promise, and
"AdoptConnectedSocket()" is rather inaccurate for this use case, since the
socket isn't connected.

TcpSocketWin has an AdoptListenSocket method, but it expects socket that isn't
yet listening.  I don't suppose we could make a POSIX equivalent, and just use
that, and start listening on it ourselves?

[Raul Vera, 2017/04/17 23:51:57]

The AdoptConnectedSocket method on TCPSocketPosix was already there, including
the misnomer, and used by other code. I have tried to keep my changes to the net
directory to a minimum.

Expecting that the socket is not yet listening would make this entire change
pointless, as the whole idea is to provide a mechanism that allows a parent
process to connect immediately, even though Chrome is still starting up and
won't reach this call point for some time. See the motivating bug:
crbug.com/624837, and the corresponding other CL:
https://codereview.chromium.org/2810353003

[mmenke, 2017/04/18 16:15:24]

I'm not seeing a consumer in the chrome repo that passes in a connection that's
not connected.  Regardless, mind renaming the method (Just AdoptSocket is fine. 
There aren't a lot of consumers), and documenting it?  (Important things:  Takes
ownership of a socket that may or may not be connected or bound.  The IPEndPoint
is optional, and is what will be returned by GetPeerAddress().

+}
+#endif
+
 TCPServerSocket::~TCPServerSocket() {
 }
 
 int TCPServerSocket::Listen(const IPEndPoint& address, int backlog) {
   int result = socket_.Open(address.GetFamily());
   if (result != OK)
     return result;
 
   result = socket_.SetDefaultOptionsForServer();
   if (result != OK) {
@@ skipping 70 matching lines @@
 void TCPServerSocket::OnAcceptCompleted(
     std::unique_ptr<StreamSocket>* output_accepted_socket,
     const CompletionCallback& forward_callback,
     int result) {
   result = ConvertAcceptedSocket(result, output_accepted_socket);
   pending_accept_ = false;
   forward_callback.Run(result);
 }
 
 }  // namespace net