Always use NonBlocking IO for UDP sockets on Windows.

media/cast/net/udp_transport.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 "media/cast/net/udp_transport.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "build/build_config.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/rand_callback.h"
 #include "net/log/net_log_source.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 const char kOptionDscp[] = "DSCP";
-#if defined(OS_WIN)
-const char kOptionDisableNonBlockingIO[] = "disable_non_blocking_io";
-#endif
 const char kOptionSendBufferMinSize[] = "send_buffer_min_size";
 const char kOptionPacerMaxBurstSize[] = "pacer_max_burst_size";
 
 bool IsEmpty(const net::IPEndPoint& addr) {
   return (addr.address().empty() || addr.address().IsZero()) && !addr.port();
 }
 
 int LookupOptionWithDefault(const base::DictionaryValue& options,
                             const std::string& path,
                             int default_value) {
@@ skipping 92 matching lines @@
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
   packet_receiver_ = PacketReceiverCallbackWithStatus();
 }
 
 
 void UdpTransport::SetDscp(net::DiffServCodePoint dscp) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
   next_dscp_value_ = dscp;
 }
 
-#if defined(OS_WIN)
-void UdpTransport::UseNonBlockingIO() {
-  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
-  if (!udp_socket_)
-    return;
-  udp_socket_->UseNonBlockingIO();
-}
-#endif
-
 void UdpTransport::ScheduleReceiveNextPacket() {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
   if (!packet_receiver_.is_null() && !receive_pending_) {
     receive_pending_ = true;
     io_thread_proxy_->PostTask(FROM_HERE,
                                base::Bind(&UdpTransport::ReceiveNextPacket,
                                           weak_factory_.GetWeakPtr(),
                                           net::ERR_IO_PENDING));
   }
 }
@@ skipping 139 matching lines @@
   }
 }
 
 void UdpTransport::SetUdpOptions(const base::DictionaryValue& options) {
   SetSendBufferSize(GetTransportSendBufferSize(options));
   if (options.HasKey(kOptionDscp)) {
     // The default DSCP value for cast is AF41. Which gives it a higher
     // priority over other traffic.
     SetDscp(net::DSCP_AF41);
   }
-#if defined(OS_WIN)
-  if (!options.HasKey(kOptionDisableNonBlockingIO)) {
-    UseNonBlockingIO();
-  }
-#endif
 }
 
 void UdpTransport::SetSendBufferSize(int32_t send_buffer_size) {
   send_buffer_size_ = send_buffer_size;
 }
 
 }  // namespace cast
 }  // namespace media