Adds a method to TCPServerSocket to adopt a socket.

net/socket/tcp_socket_unittest.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_socket.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 208 matching lines @@
 
   EXPECT_THAT(connect_callback.WaitForResult(), IsOk());
 }
 
 // Test Accept() callback.
 TEST_F(TCPSocketTest, AcceptAsync) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
   TestAcceptAsync();
 }
 
-#if defined(OS_WIN)
-// Test Accept() for AdoptListenSocket.
-TEST_F(TCPSocketTest, AcceptForAdoptedListenSocket) {
-  // Create a socket to be used with AdoptListenSocket.
-  SOCKET existing_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  ASSERT_THAT(socket_.AdoptListenSocket(existing_socket), IsOk());
+// Test AdoptConnectedSocket()
+TEST_F(TCPSocketTest, AdoptConnectedSocket) {
+  TCPSocket accepting_socket(NULL, NULL, NetLogSource());
+  ASSERT_THAT(accepting_socket.Open(ADDRESS_FAMILY_IPV4), IsOk());
+  ASSERT_THAT(accepting_socket.Bind(IPEndPoint(IPAddress::IPv4Localhost(), 0)),
+              IsOk());
+  ASSERT_THAT(accepting_socket.GetLocalAddress(&local_address_), IsOk());
+  ASSERT_THAT(accepting_socket.Listen(kListenBacklog), IsOk());
+
+  TestCompletionCallback connect_callback;
+  // TODO(yzshen): Switch to use TCPSocket when it supports client socket
+  // operations.
+  TCPClientSocket connecting_socket(local_address_list(), NULL, NULL,
+                                    NetLogSource());
+  connecting_socket.Connect(connect_callback.callback());
+
+  TestCompletionCallback accept_callback;
+  std::unique_ptr<TCPSocket> accepted_socket;
+  IPEndPoint accepted_address;
+  int result = accepting_socket.Accept(&accepted_socket, &accepted_address,
+                                       accept_callback.callback());
+  if (result == ERR_IO_PENDING)
+    result = accept_callback.WaitForResult();
+  ASSERT_THAT(result, IsOk());
+
+  SocketDescriptor accepted_descriptor = accepted_socket->GetSocketDescriptor();
+
+  // Note that this takes owenership of the descriptor, which causes the socket
+  // to be closed twice at the os level, once for socket_ and once for
+  // accepted_socket, due to the unique_ptrs involved. The test passes, but this
+  // generates a run-time error message.
+  // The double close is difficult to avoid, as it the would require avoiding
+  // the unique_prts by using lower-level calls to set up the accepting socket
+  // and do the accept. Doing the above accept asynchronously involves a fair
+  // amount of platform-specific code. Doing the connect asynchronously and the
+  // accept synchronously deadlocks, presumably because it's racing the connect
+  // somehow. In the end keeping this code simpler and accepting a benign error
+  // message seems the best tradeoff.

[mmenke, 2017/05/01 18:44:19]

Can we do better?  Shouldn't be hard to make GetSocketDescriptor steal the
socket instead (And rename it to ReleaseSocketDescriptorForTesting or
ReleaseConnectedSocketForTesting()).

On POSIX, we can just use:

SocketDescriptor socket_descriptor = socket_->ReleaseConnectedSocket();
socket_.reset();
return socket_descriptor;

On Windows, it would be:

SocketDescriptor socket_descriptor = socket_;
socket_ = INVALID_SOCKET;
Close();
return socket_descriptor;


And then add a warning to both methods that read/write/accept operations must
not be pending when stealing the socket.

[Raul Vera, 2017/05/02 00:08:53]

Excellent. All done. Thank you.

+  ASSERT_THAT(
+      socket_.AdoptConnectedSocket(accepted_descriptor, accepted_address),
+      IsOk());
+
+  // socket_ should now have the local address.
+  IPEndPoint adopted_address;
+  ASSERT_THAT(socket_.GetLocalAddress(&adopted_address), IsOk());
+  EXPECT_EQ(local_address_.address(), adopted_address.address());
+
+  EXPECT_THAT(connect_callback.WaitForResult(), IsOk());
+}
+
+// Test Accept() for AdoptUnconnectedSocket.
+TEST_F(TCPSocketTest, AcceptForAdoptedUnconnectedSocket) {
+  SocketDescriptor existing_socket =
+      CreatePlatformSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  ASSERT_THAT(socket_.AdoptUnconnectedSocket(existing_socket), IsOk());
 
   IPEndPoint address(IPAddress::IPv4Localhost(), 0);
   SockaddrStorage storage;
   ASSERT_TRUE(address.ToSockAddr(storage.addr, &storage.addr_len));
   ASSERT_EQ(0, bind(existing_socket, storage.addr, storage.addr_len));
 
   ASSERT_THAT(socket_.Listen(kListenBacklog), IsOk());
   ASSERT_THAT(socket_.GetLocalAddress(&local_address_), IsOk());
 
   TestAcceptAsync();
 }
-#endif
 
 // Accept two connections simultaneously.
 TEST_F(TCPSocketTest, Accept2Connections) {
   ASSERT_NO_FATAL_FAILURE(SetUpListenIPv4());
 
   TestCompletionCallback accept_callback;
   std::unique_ptr<TCPSocket> accepted_socket;
   IPEndPoint accepted_address;
 
   ASSERT_EQ(ERR_IO_PENDING,
@@ skipping 133 matching lines @@
 
 // One notification should be received when the socket connects. One
 // additional notification should be received for each message read.
 TEST_F(TCPSocketTest, SPWNoAdvance) {
   TestSPWNotifications(true, 2u, 0u, 3u);
 }
 #endif  // defined(TCP_INFO) || defined(OS_LINUX)
 
 }  // namespace
 }  // namespace net