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>
 #include <string>
 #include <vector>
 
+#include "base/files/file_util.h"

[mmenke, 2017/04/21 19:20:38]

I don't think this is used?

[Raul Vera, 2017/05/01 05:35:25]

It was, but isn't now, so I've removed it.

 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/sockaddr_storage.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log_source.h"
 #include "net/socket/socket_performance_watcher.h"
+#if defined(OS_POSIX)
+#include "net/socket/socket_posix.h"
+#endif

[mmenke, 2017/04/21 19:20:38]

No longer needed, I believe.

[Raul Vera, 2017/05/01 05:35:25]

Good catch. I missed that. Thanks.

 #include "net/socket/tcp_client_socket.h"
 #include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using net::test::IsOk;
 
 namespace net {
 
@@ skipping 185 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) {
+  SocketDescriptor socket_fd =
+      CreatePlatformSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  ASSERT_GE(socket_fd, 0);
+  ASSERT_TRUE(base::SetNonBlocking(socket_fd));
+  IPEndPoint address(IPAddress::IPv4Localhost(), 0);
+  SockaddrStorage storage;
+  ASSERT_TRUE(address.ToSockAddr(storage.addr, &storage.addr_len));
+  ASSERT_GE(bind(socket_fd, storage.addr, storage.addr_len), 0);
+  ASSERT_GE(listen(socket_fd, kListenBacklog), 0);

[mmenke, 2017/04/21 19:20:38]

This isn't a connected socket, it's a listening socket.  Seems like we should
use a connected socket for this test.

[Raul Vera, 2017/05/01 05:35:25]

Indeed. This turned out to require exposing GetSocketDescriptor on TCPSocketWin
and TCPSocketPosix, so that I could build the test in a platform-independent
way. See the new comments in the code about the resulting error, too. If you can
think of a cleaner way to do this, let me know. In particular if you can think
of a way to use a nonblocking TCPSocket::Connect(...) and a blocking low-level
accept(...) on the single thread without the deadlock I saw, please let me know.
My sockets foo just isn't strong enough.

+
+  ASSERT_THAT(socket_.AdoptConnectedSocket(socket_fd, IPEndPoint()), IsOk());
+  ASSERT_THAT(socket_.GetLocalAddress(&local_address_), IsOk());
+
+  TestAcceptAsync();
+}
+
+// Test Accept() for AdoptUnconnectedSocket.
+TEST_F(TCPSocketTest, AcceptForAdoptedUnconnectedSocket) {
+  // Create a socket to be used with AdoptUnconnectedSocket.
+  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_EQ(bind(existing_socket, storage.addr, storage.addr_len), 0);

[mmenke, 2017/04/21 19:20:38]

Expected should go before actual, for ASSERT_EQ (Yes, it's weird that
ASSERT_THAT uses the opposite order)

[Raul Vera, 2017/05/01 05:35:25]

That code is gone now, but thanks.

 
   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