Always use NonBlocking IO for UDP sockets on Windows.

net/socket/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/socket/udp_socket.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 128 matching lines @@
   void CreateUDPAddress(const std::string& ip_str,
                         uint16_t port,
                         IPEndPoint* address) {
     IPAddress ip_address;
     if (!ip_address.AssignFromIPLiteral(ip_str))
       return;
     *address = IPEndPoint(ip_address, 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);
+  void ConnectTest();
 
  protected:
   static const int kMaxRead = 1024;
   scoped_refptr<IOBufferWithSize> buffer_;
   IPEndPoint recv_from_address_;
 };
 
 void ReadCompleteCallback(int* result_out, base::Closure callback, int result) {
   *result_out = result;
   callback.Run();
 }
 
-void UDPSocketTest::ConnectTest(bool use_nonblocking_io) {
+TEST_F(UDPSocketTest, Connect) {
   const uint16_t kPort = 9999;
   std::string simple_message("hello world!");
 
   // Setup the server to listen.
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", kPort, &bind_address);
   TestNetLog server_log;
   std::unique_ptr<UDPServerSocket> server(
       new UDPServerSocket(&server_log, NetLogSource()));
-  if (use_nonblocking_io)
-    server->UseNonBlockingIO();
   server->AllowAddressReuse();
   int rv = server->Listen(bind_address);
   ASSERT_THAT(rv, IsOk());
 
   // Setup the client.
   IPEndPoint server_address;
   CreateUDPAddress("127.0.0.1", kPort, &server_address);
   TestNetLog client_log;
   std::unique_ptr<UDPClientSocket> client(
       new UDPClientSocket(DatagramSocket::DEFAULT_BIND, RandIntCallback(),
                           &client_log, NetLogSource()));
-  if (use_nonblocking_io)
-    client->UseNonBlockingIO();
 
   rv = client->Connect(server_address);
   EXPECT_THAT(rv, IsOk());
 
   // 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());
@@ skipping 62 matching lines @@
   EXPECT_TRUE(LogContainsEvent(client_entries, 4,
                                NetLogEventType::UDP_BYTES_RECEIVED,
                                NetLogEventPhase::NONE));
   EXPECT_TRUE(LogContainsEvent(client_entries, 5,
                                NetLogEventType::UDP_BYTES_SENT,
                                NetLogEventPhase::NONE));
   EXPECT_TRUE(
       LogContainsEndEvent(client_entries, 6, NetLogEventType::SOCKET_ALIVE));
 }
 
-TEST_F(UDPSocketTest, Connect) {
-  // The variable |use_nonblocking_io| has no effect in non-Windows ports.
-  ConnectTest(false);
-}
-
-#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)
 // Disabled for Android because devices attached to testbots don't have default
 // network, so broadcasting to 255.255.255.255 returns error -109 (Address not
 // reachable). crbug.com/139144.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
 #else
@@ skipping 598 matching lines @@
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
   EXPECT_THAT(client.SetDiffServCodePoint(DSCP_NO_CHANGE), IsOk());
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
   EXPECT_THAT(client.SetDiffServCodePoint(DSCP_DEFAULT), IsOk());
   client.Close();
 }
 #endif
 
 }  // namespace net