Adds a method to TCPServerSocket to adopt a socket.

net/socket/tcp_server_socket.h

 // Copyright (c) 2011 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 NET_SOCKET_TCP_SERVER_SOCKET_H_
 #define NET_SOCKET_TCP_SERVER_SOCKET_H_
 
 #include <memory>
 
 #include "base/macros.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_export.h"
 #include "net/socket/server_socket.h"
 #include "net/socket/tcp_socket.h"
 
 namespace net {
 
 class NetLog;
 struct NetLogSource;
 
 // A server socket that uses TCP as the transport layer.
 class NET_EXPORT TCPServerSocket : public ServerSocket {
  public:
   TCPServerSocket(NetLog* net_log, const NetLogSource& source);
   ~TCPServerSocket() override;
 
+#if defined(OS_POSIX)
+  // Takes ownership of |socket_fd|, which is assumed to be already open, bound
+  // and listening, potentially with a connection already waiting to be
+  // accepted. This is used by headless chrome to allow a parent process to open
+  // a port and listen on it, pass it to Chrome on launch to use as the devtools
+  // remote debugging port, then connect to it immediately and block on the
+  // first read rather than having to poll for the connection. See
+  // crbug.com/624837.
+  int AdopListeningRawSocket(int socket_fd);

[Jana, 2017/04/17 17:27:57]

Use "Adopt" instead of "Adop".

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

Oops. Thanks. Done.

+#endif

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

Why do we need a POSIX-only method?  net/ is supposed to be platform
independent.

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

Because Windows does not inherit sockets the same way as POSIX systems do, as
far as I can tell. It appears that open sockets are passed on Windows only by
active communication between processes, in which case it would be difficult to
solve my actual use case, as described in crbug.com/624837.

TCPSocketPosix and TCPSocketWin are already different, offering
platform-specific methods used by other code. This change effectively elevates
one such method to TCPServerSocket, because I need access to that functionality
at that level (see https://codereview.chromium.org/2810353003). Regularizing all
the socket-adoption methods to make all of this platform independent would be a
much larger task, and it may not be possible to guarantee the same semantics
across all systems.

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

I don't think this is relevant to code in net/, which doesn't even know what a
process is.
There's only one extra method in the Windows method (Which should be on the
POSIX version, too, in my opinion).  I assume the classes aren't virtual to
avoid a vtable lookup, which is kinda silly, since we don't do that anywhere
else.  Ancient code does tend not to follow established norms, though.

You're promoting the interface from what is nominally a private POSIX-only class
(SocketPosix has no windows equivalent) to a cross-platform class.

Why would adding a comparable method to TcpSocketWin be so difficult?

+
   // net::ServerSocket implementation.
   int Listen(const IPEndPoint& address, int backlog) override;
   int GetLocalAddress(IPEndPoint* address) const override;
   int Accept(std::unique_ptr<StreamSocket>* socket,
              const CompletionCallback& callback) override;
 
   // Detachs from the current thread, to allow the socket to be transferred to
   // a new thread. Should only be called when the object is no longer used by
   // the old thread.
   void DetachFromThread();
@@ skipping 16 matching lines @@
   std::unique_ptr<TCPSocket> accepted_socket_;
   IPEndPoint accepted_address_;
   bool pending_accept_;
 
   DISALLOW_COPY_AND_ASSIGN(TCPServerSocket);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_TCP_SERVER_SOCKET_H_