Remove timing limitation to set Broadcast, ReceiveBuffer, and SendBuffer options from UDPSocket.

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"
@@ skipping 199 matching lines @@
 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) {
 #else
 TEST_F(UDPSocketTest, Broadcast) {
 #endif
   const int kPort = 9999;
-  std::string first_message("first message"), second_message("second message");
+  std::string first_message("first message");
+  std::string second_message("second message");
+  std::string third_message("third message");
+  std::string fourth_message("fourth message");
 
   IPEndPoint broadcast_address;
   CreateUDPAddress("255.255.255.255", kPort, &broadcast_address);
   IPEndPoint listen_address;
   CreateUDPAddress("0.0.0.0", kPort, &listen_address);
 
   CapturingNetLog server1_log, server2_log;
   scoped_ptr<UDPServerSocket> server1(
       new UDPServerSocket(&server1_log, NetLog::Source()));
   scoped_ptr<UDPServerSocket> server2(
       new UDPServerSocket(&server2_log, NetLog::Source()));
   server1->AllowAddressReuse();
-  server1->AllowBroadcast();
+  int rv = server1->SetBroadcast(true);
+  ASSERT_EQ(OK, rv);
   server2->AllowAddressReuse();
-  server2->AllowBroadcast();
+  rv = server2->SetBroadcast(true);
+  ASSERT_EQ(OK, rv);
 
-  int rv = server1->Listen(listen_address);
+  rv = server1->Listen(listen_address);
   EXPECT_EQ(OK, rv);
   rv = server2->Listen(listen_address);
   EXPECT_EQ(OK, rv);
 
   rv = SendToSocket(server1.get(), first_message, broadcast_address);
   ASSERT_EQ(static_cast<int>(first_message.size()), rv);
   std::string str = RecvFromSocket(server1.get());
   ASSERT_EQ(first_message, str);
   str = RecvFromSocket(server2.get());
   ASSERT_EQ(first_message, str);
 
   rv = SendToSocket(server2.get(), second_message, broadcast_address);
   ASSERT_EQ(static_cast<int>(second_message.size()), rv);
   str = RecvFromSocket(server1.get());
   ASSERT_EQ(second_message, str);
   str = RecvFromSocket(server2.get());
   ASSERT_EQ(second_message, str);
+
+  rv = server1->SetBroadcast(false);
+  ASSERT_EQ(OK, rv);
+  rv = server2->SetBroadcast(false);
+  ASSERT_EQ(OK, rv);
+  rv = SendToSocket(server1.get(), third_message, broadcast_address);
+  ASSERT_LT(rv, 0);
+  rv = SendToSocket(server2.get(), fourth_message, broadcast_address);
+  ASSERT_LT(rv, 0);
 }
 
 // In this test, we verify that random binding logic works, which attempts
 // to bind to a random port and returns if succeeds, otherwise retries for
 // |kBindRetries| number of times.
 
 // To generate the scenario, we first create |kBindRetries| number of
 // UDPClientSockets with default binding policy and connect to the same
 // peer and save the used port numbers.  Then we get rid of the last
 // socket, making sure that the local port it was bound to is available.
@@ skipping 467 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