Added broadcasting feature to UDP server sockets.

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_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
@@ skipping 183 matching lines @@
   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));
 }
 
+TEST_F(UDPSocketTest, Broadcast) {
+  const int kPort = 9999;
+  std::string first_message("first message"), second_message("second 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();
+  server2->AllowAddressReuse();
+  server2->AllowBroadcast();
+
+  int 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);
+  EXPECT_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);
+  EXPECT_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);
+}
+
 // 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.
 // Finally, we create a socket with random binding policy, passing it a
 // test PRNG that would serve used port numbers in the array, one after
@@ skipping 225 matching lines @@
   EXPECT_EQ(rv, ERR_IO_PENDING);
 
   server.Close();
 
   EXPECT_FALSE(callback.have_result());
 }
 
 }  // namespace
 
 }  // namespace net