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 335 matching lines @@
 
 TEST_F(UDPSocketTest, ConnectFail) {
   IPEndPoint peer_address;
   CreateUDPAddress("0.0.0.0", 53, &peer_address);
 
   scoped_ptr<UDPSocket> socket(
       new UDPSocket(DatagramSocket::RANDOM_BIND,
                     base::Bind(&PrivilegedRand),
                     NULL,
                     NetLog::Source()));
-  int rv = socket->Connect(peer_address);
+  int rv = socket->Open(peer_address.GetFamily());
+  EXPECT_EQ(OK, rv);
+  rv = socket->Connect(peer_address);
   // Connect should have failed since we couldn't bind to that port,
   EXPECT_NE(OK, rv);
   // Make sure that UDPSocket actually closed the socket.
   EXPECT_FALSE(socket->is_connected());
 }
 
 // In this test, we verify that connect() on a socket will have the effect
 // of filtering reads on this socket only to data read from the destination
 // we connected to.
 //
@@ skipping 176 matching lines @@
 
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
   IPAddressNumber group_ip;
   EXPECT_TRUE(ParseIPLiteralToNumber(kGroup, &group_ip));
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
+  EXPECT_EQ(OK, socket.Open(bind_address.GetFamily()));
   EXPECT_EQ(OK, socket.Bind(bind_address));
   EXPECT_EQ(OK, socket.JoinGroup(group_ip));
   // Joining group multiple times.
   EXPECT_NE(OK, socket.JoinGroup(group_ip));
   EXPECT_EQ(OK, socket.LeaveGroup(group_ip));
   // Leaving group multiple times.
   EXPECT_NE(OK, socket.LeaveGroup(group_ip));
 
   socket.Close();
 }
 
 TEST_F(UDPSocketTest, MulticastOptions) {
   const uint16 kPort = 9999;
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   // Before binding.
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(true));
   EXPECT_EQ(OK, socket.SetMulticastTimeToLive(0));
   EXPECT_EQ(OK, socket.SetMulticastTimeToLive(3));
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(-1));
   EXPECT_EQ(OK, socket.SetMulticastInterface(0));
 
+  EXPECT_EQ(OK, socket.Open(bind_address.GetFamily()));
   EXPECT_EQ(OK, socket.Bind(bind_address));
 
   EXPECT_NE(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_NE(OK, socket.SetMulticastTimeToLive(0));
   EXPECT_NE(OK, socket.SetMulticastInterface(0));
 
   socket.Close();
 }
 
 // Checking that DSCP bits are set correctly is difficult,
 // but let's check that the code doesn't crash at least.
 TEST_F(UDPSocketTest, SetDSCP) {
   // Setup the server to listen.
   IPEndPoint bind_address;
   UDPSocket client(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   // We need a real IP, but we won't actually send anything to it.
   CreateUDPAddress("8.8.8.8", 9999, &bind_address);
-  int rv = client.Connect(bind_address);
+  int rv = client.Open(bind_address.GetFamily());
+  EXPECT_EQ(OK, rv);
+
+  rv = client.Connect(bind_address);
   if (rv != OK) {
     // Let's try localhost then..
     CreateUDPAddress("127.0.0.1", 9999, &bind_address);
     rv = client.Connect(bind_address);
   }
   EXPECT_EQ(OK, rv);
 
   client.SetDiffServCodePoint(DSCP_NO_CHANGE);
   client.SetDiffServCodePoint(DSCP_AF41);
   client.SetDiffServCodePoint(DSCP_DEFAULT);
@@ skipping 86 matching lines @@
   // Setup the server to listen.
   IPEndPoint bind_address;
   // We need a real IP, but we won't actually send anything to it.
   CreateUDPAddress("8.8.8.8", 9999, &bind_address);
   UDPSocket client(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   int rv = client.SetDiffServCodePoint(DSCP_AF41);
   EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, rv);
+
+  rv = client.Open(bind_address.GetFamily());
+  EXPECT_EQ(OK, rv);
+
   rv = client.Connect(bind_address);
   EXPECT_EQ(OK, rv);
 
   QwaveAPI& qos(QwaveAPI::Get());
   qos.create_handle_func_ = FakeQOSCreateHandleFAIL;
   qos.close_handle_func_ = FakeQOSCloseHandle;
   qos.add_socket_to_flow_func_ = FakeQOSAddSocketToFlow;
   qos.remove_socket_from_flow_func_ = FakeQOSRemoveSocketFromFlow;
   qos.set_flow_func_ = FakeQOSSetFlow;
   qos.qwave_supported_ = true;
@@ skipping 14 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