Raw SocketDescriptor variant of UnixDomainServerSocket::Accept

net/socket/unix_domain_client_socket_posix_unittest.cc

 // 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 "net/socket/unix_domain_client_socket_posix.h"
 
 #include <unistd.h>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/posix/eintr_wrapper.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/unix_domain_server_socket_posix.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 const char kSocketFilename[] = "socket_for_testing";
@@ skipping 118 matching lines @@
   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
   EXPECT_TRUE(client_socket.IsConnected());
   // Server has not yet been notified of the connection.
   EXPECT_FALSE(accepted_socket);
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
   EXPECT_TRUE(accepted_socket);
   EXPECT_TRUE(accepted_socket->IsConnected());
 }
 
+TEST_F(UnixDomainClientSocketTest, ConnectWithSocketDescriptor) {
+  const bool kUseAbstractNamespace = false;
+
+  UnixDomainServerSocket server_socket(CreateAuthCallback(true),
+                                       kUseAbstractNamespace);
+  EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
+
+  SocketDescriptor accepted_socket_fd = kInvalidSocket;
+  TestCompletionCallback accept_callback;
+  EXPECT_EQ(ERR_IO_PENDING,
+            server_socket.AcceptSocketDescriptor(&accepted_socket_fd,
+                                                 accept_callback.callback()));
+  EXPECT_EQ(kInvalidSocket, accepted_socket_fd);
+
+  UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
+  EXPECT_FALSE(client_socket.IsConnected());
+
+  EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
+  EXPECT_TRUE(client_socket.IsConnected());
+  // Server has not yet been notified of the connection.
+  EXPECT_EQ(kInvalidSocket, accepted_socket_fd);
+
+  EXPECT_EQ(OK, accept_callback.WaitForResult());
+  EXPECT_NE(kInvalidSocket, accepted_socket_fd);
+
+  SocketDescriptor client_socket_fd = client_socket.ReleaseSocketDescriptor();

[mmenke, 2014/09/03 14:56:46]

Can we wrap this in a UnixDomainClientSocket (And a TcpClientSocketLibEvent) and
try reading something from it?  Closing should return an error if it's already
closed, but I'm very paranoid about regressions here.

[Chris Masone, 2014/09/03 15:03:40]

TclClientSocketLibEvent? This is the wrong kind of FD to be injected into that
class, no?

[Chris Masone, 2014/09/03 15:57:12]

Ok, I've done a read() and made sure I got ERR_IO_PENDING and not EOF, which i
think verifies what you're looking for.

I had to add NET_EXPORT_PRIVATE to SocketLibevent to use it here, though.

+  EXPECT_NE(kInvalidSocket, client_socket_fd);
+
+  EXPECT_EQ(0, IGNORE_EINTR(close(accepted_socket_fd)));
+  EXPECT_EQ(0, IGNORE_EINTR(close(client_socket_fd)));
+}
+
 TEST_F(UnixDomainClientSocketTest, ConnectWithAbstractNamespace) {
   const bool kUseAbstractNamespace = true;
 
   UnixDomainClientSocket client_socket(socket_path_, kUseAbstractNamespace);
   EXPECT_FALSE(client_socket.IsConnected());
 
 #if defined(OS_ANDROID) || defined(OS_LINUX)
   UnixDomainServerSocket server_socket(CreateAuthCallback(true),
                                        kUseAbstractNamespace);
   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
@@ skipping 226 matching lines @@
                 accepted_socket.get(), read_buffer.get(), kReadBufferSize, 0));
 
   // Disconnect from server side after read-write.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 }
 
 }  // namespace
 }  // namespace net