UDP: Windows implementation using non-blocking IO

net/udp/udp_socket_unittest.cc

 // Copyright (c) 2012 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/udp/udp_socket.h"
 
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
+#include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/net_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/test/net_test_suite.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 namespace {
 
 class UDPSocketTest : public PlatformTest {
  public:
   UDPSocketTest()
-      : buffer_(new IOBufferWithSize(kMaxRead)) {
-  }
+      : buffer_(new IOBufferWithSize(kMaxRead)), weak_factory_(this) {}

[rvargas (doing something else), 2015/01/23 03:05:34]

nit: I'd say this is not allowed by the style guide. Bug in the tool?

[Alpha Left Google, 2015/01/23 03:52:22]

I used git cl format and it didn't correct this line. Not sure.

 
   // Blocks until data is read from the socket.
   std::string RecvFromSocket(UDPServerSocket* socket) {
     TestCompletionCallback callback;
 
     int rv = socket->RecvFrom(
         buffer_.get(), kMaxRead, &recv_from_address_, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
@@ skipping 62 matching lines @@
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
+  // Creates and address from an ip/port and returns it in |address|.
+  void CreateUDPAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
+    IPAddressNumber ip_number;
+    bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
+    if (!rv)
+      return;
+    *address = IPEndPoint(ip_number, port);
+  }
+
+  // Run unit test for a connection test.
+  // |use_nonblocking_io| is used to switch between overlapped and non-blocking
+  // IO on Windows. It has no effect in other ports.
+  void ConnectTest(bool use_nonblocking_io) {

[rvargas (doing something else), 2015/01/23 03:05:34]

This method is way too long to be defined at the declaration point. I'd actually
say that the class is now to long to do that for the other methods.

[Alpha Left Google, 2015/01/23 03:52:22]

Defined it out of the class.

+    const uint16 kPort = 9999;
+    std::string simple_message("hello world!");
+
+    // Setup the server to listen.
+    IPEndPoint bind_address;
+    CreateUDPAddress("127.0.0.1", kPort, &bind_address);
+    CapturingNetLog server_log;
+    scoped_ptr<UDPServerSocket> server(
+        new UDPServerSocket(&server_log, NetLog::Source()));
+#if defined(OS_WIN)
+    if (use_nonblocking_io)
+      server->UseNonBlockingIO();
+#endif
+    server->AllowAddressReuse();
+    int rv = server->Listen(bind_address);
+    ASSERT_EQ(OK, rv);
+
+    // Setup the client.
+    IPEndPoint server_address;
+    CreateUDPAddress("127.0.0.1", kPort, &server_address);
+    CapturingNetLog client_log;
+    scoped_ptr<UDPClientSocket> client(
+        new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
+                            &client_log, NetLog::Source()));
+#if defined(OS_WIN)
+    if (use_nonblocking_io)
+      client->UseNonBlockingIO();
+#endif
+
+    rv = client->Connect(server_address);
+    EXPECT_EQ(OK, rv);
+
+    // Client sends to the server.
+    rv = WriteSocket(client.get(), simple_message);
+    EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
+
+    // Server waits for message.
+    std::string str = RecvFromSocket(server.get());
+    DCHECK(simple_message == str);
+
+    // Server echoes reply.
+    rv = SendToSocket(server.get(), simple_message);
+    EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
+
+    // Client waits for response.
+    str = ReadSocket(client.get());
+    DCHECK(simple_message == str);
+
+    // Delete sockets so they log their final events.
+    server.reset();
+    client.reset();
+
+    // Check the server's log.
+    CapturingNetLog::CapturedEntryList server_entries;
+    server_log.GetEntries(&server_entries);
+    EXPECT_EQ(4u, server_entries.size());
+    EXPECT_TRUE(
+        LogContainsBeginEvent(server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+    EXPECT_TRUE(LogContainsEvent(server_entries, 1,
+                                 NetLog::TYPE_UDP_BYTES_RECEIVED,
+                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(server_entries, 2, NetLog::TYPE_UDP_BYTES_SENT,
+                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(
+        LogContainsEndEvent(server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
+
+    // Check the client's log.
+    CapturingNetLog::CapturedEntryList client_entries;
+    client_log.GetEntries(&client_entries);
+    EXPECT_EQ(6u, client_entries.size());
+    EXPECT_TRUE(
+        LogContainsBeginEvent(client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
+    EXPECT_TRUE(
+        LogContainsBeginEvent(client_entries, 1, NetLog::TYPE_UDP_CONNECT));
+    EXPECT_TRUE(
+        LogContainsEndEvent(client_entries, 2, NetLog::TYPE_UDP_CONNECT));
+    EXPECT_TRUE(LogContainsEvent(client_entries, 3, NetLog::TYPE_UDP_BYTES_SENT,
+                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(LogContainsEvent(client_entries, 4,
+                                 NetLog::TYPE_UDP_BYTES_RECEIVED,
+                                 NetLog::PHASE_NONE));
+    EXPECT_TRUE(
+        LogContainsEndEvent(client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
+  }
+
  protected:
   static const int kMaxRead = 1024;
   scoped_refptr<IOBufferWithSize> buffer_;
   IPEndPoint recv_from_address_;
+  base::WeakPtrFactory<UDPSocketTest> weak_factory_;
 };
 
-// Creates and address from an ip/port and returns it in |address|.
-void CreateUDPAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
-  IPAddressNumber ip_number;
-  bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
-  if (!rv)
-    return;
-  *address = IPEndPoint(ip_number, port);
+TEST_F(UDPSocketTest, Connect) {
+  // The variable |use_nonblocking_io| has no effect in non-Windows ports.
+  ConnectTest(false);
 }
 
-TEST_F(UDPSocketTest, Connect) {
-  const uint16 kPort = 9999;
-  std::string simple_message("hello world!");
-
-  // Setup the server to listen.
-  IPEndPoint bind_address;
-  CreateUDPAddress("127.0.0.1", kPort, &bind_address);
-  CapturingNetLog server_log;
-  scoped_ptr<UDPServerSocket> server(
-      new UDPServerSocket(&server_log, NetLog::Source()));
-  server->AllowAddressReuse();
-  int rv = server->Listen(bind_address);
-  ASSERT_EQ(OK, rv);
-
-  // Setup the client.
-  IPEndPoint server_address;
-  CreateUDPAddress("127.0.0.1", kPort, &server_address);
-  CapturingNetLog client_log;
-  scoped_ptr<UDPClientSocket> client(
-      new UDPClientSocket(DatagramSocket::DEFAULT_BIND,
-                          RandIntCallback(),
-                          &client_log,
-                          NetLog::Source()));
-  rv = client->Connect(server_address);
-  EXPECT_EQ(OK, rv);
-
-  // Client sends to the server.
-  rv = WriteSocket(client.get(), simple_message);
-  EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
-
-  // Server waits for message.
-  std::string str = RecvFromSocket(server.get());
-  DCHECK(simple_message == str);
-
-  // Server echoes reply.
-  rv = SendToSocket(server.get(), simple_message);
-  EXPECT_EQ(simple_message.length(), static_cast<size_t>(rv));
-
-  // Client waits for response.
-  str = ReadSocket(client.get());
-  DCHECK(simple_message == str);
-
-  // Delete sockets so they log their final events.
-  server.reset();
-  client.reset();
-
-  // Check the server's log.
-  CapturingNetLog::CapturedEntryList server_entries;
-  server_log.GetEntries(&server_entries);
-  EXPECT_EQ(4u, server_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      server_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
-  EXPECT_TRUE(LogContainsEvent(
-      server_entries, 1, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEvent(
-      server_entries, 2, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      server_entries, 3, NetLog::TYPE_SOCKET_ALIVE));
-
-  // Check the client's log.
-  CapturingNetLog::CapturedEntryList client_entries;
-  client_log.GetEntries(&client_entries);
-  EXPECT_EQ(6u, client_entries.size());
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 0, NetLog::TYPE_SOCKET_ALIVE));
-  EXPECT_TRUE(LogContainsBeginEvent(
-      client_entries, 1, NetLog::TYPE_UDP_CONNECT));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 2, NetLog::TYPE_UDP_CONNECT));
-  EXPECT_TRUE(LogContainsEvent(
-      client_entries, 3, NetLog::TYPE_UDP_BYTES_SENT, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEvent(
-      client_entries, 4, NetLog::TYPE_UDP_BYTES_RECEIVED, NetLog::PHASE_NONE));
-  EXPECT_TRUE(LogContainsEndEvent(
-      client_entries, 5, NetLog::TYPE_SOCKET_ALIVE));
+#if defined(OS_WIN)
+TEST_F(UDPSocketTest, ConnectNonBlocking) {
+  ConnectTest(true);
 }
+#endif
 
 #if defined(OS_MACOSX)
 // UDPSocketPrivate_Broadcast is disabled for OSX because it requires
 // root permissions on OSX 10.7+.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
 #elif defined(OS_ANDROID)
 // It is also disabled for Android because it is extremely flaky.
 // The first call to SendToSocket returns -109 (Address not reachable)
 // in some unpredictable cases. crbug.com/139144.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
@@ skipping 527 matching lines @@
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
   client.Close();
 }
 #endif
 
 }  // namespace net