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

media/cast/test/utility/udp_proxy.cc

 // Copyright 2014 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 <math.h>
 #include <stdlib.h>
 #include <vector>
 
 #include "media/cast/test/utility/udp_proxy.h"
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/default_tick_clock.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/udp/udp_socket.h"
+#include "net/udp/udp_server_socket.h"
 
 namespace media {
 namespace cast {
 namespace test {
 
 const size_t kMaxPacketSize = 65536;
 
 PacketPipe::PacketPipe() {}
 PacketPipe::~PacketPipe() {}
 void PacketPipe::InitOnIOThread(
@@ skipping 702 matching lines @@
     if (result == net::ERR_IO_PENDING) {
       blocked_ = true;
     } else if (result < 0) {
       LOG(ERROR) << "Failed to write packet.";
     }
   }
 
  private:
   void Start(base::WaitableEvent* start_event,
              net::NetLog* net_log) {
-    socket_.reset(new net::UDPSocket(net::DatagramSocket::DEFAULT_BIND,
-                                     net::RandIntCallback(),
-                                     net_log,
-                                     net::NetLog::Source()));
+    socket_.reset(new net::UDPServerSocket(net_log, net::NetLog::Source()));
     BuildPipe(&to_dest_pipe_, new PacketSender(this, &destination_));
     BuildPipe(&from_dest_pipe_, new PacketSender(this, &return_address_));
     to_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current(),
                                   &tick_clock_);
     from_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current(),
                                     &tick_clock_);
 
     VLOG(0) << "From:" << local_port_.ToString();
     if (!destination_is_mutable_)
       VLOG(0) << "To:" << destination_.ToString();
 
-    CHECK_GE(socket_->Bind(local_port_), 0);
+    CHECK_GE(socket_->Listen(local_port_), 0);
 
     start_event->Signal();
     PollRead();
   }
 
   void Stop(base::WaitableEvent* stop_event) {
     to_dest_pipe_.reset(NULL);
     from_dest_pipe_.reset(NULL);
     socket_.reset(NULL);
     stop_event->Signal();
@@ skipping 56 matching lines @@
   net::IPEndPoint local_port_;
 
   net::IPEndPoint destination_;
   bool destination_is_mutable_;
 
   net::IPEndPoint return_address_;
   bool set_destination_next_;
 
   base::DefaultTickClock tick_clock_;
   base::Thread proxy_thread_;
-  scoped_ptr<net::UDPSocket> socket_;
+  scoped_ptr<net::UDPServerSocket> socket_;
   scoped_ptr<PacketPipe> to_dest_pipe_;
   scoped_ptr<PacketPipe> from_dest_pipe_;
 
   // For receiving.
   net::IPEndPoint recv_address_;
   scoped_ptr<Packet> packet_;
 
   // For sending.
   bool blocked_;
 
@@ skipping 14 matching lines @@
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media