Simplify interface for media/cast: CastTransportSenderImpl

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"
 
 namespace media {
 namespace cast {
 
 namespace {
-const int kMaxPacketSize = 1500;
+
+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) {
   net::IPAddressNumber empty_addr(addr.address().size());
   return std::equal(empty_addr.begin(), empty_addr.end(),
                     addr.address().bytes().begin()) &&
          !addr.port();
 }
 
+int LookupOptionWithDefault(const base::DictionaryValue& options,
+                            const std::string& path,
+                            int default_value) {
+  int ret;
+  if (options.GetInteger(path, &ret)) {
+    return ret;
+  } else {
+    return default_value;
+  }
+}
+
+int32_t GetTransportSendBufferSize(const base::DictionaryValue& options) {
+  // Socket send buffer size needs to be at least greater than one burst
+  // size.
+  int32_t max_burst_size =
+      LookupOptionWithDefault(options, kOptionPacerMaxBurstSize,
+                              media::cast::kMaxBurstSize) *
+      media::cast::kMaxIpPacketSize;
+  int32_t min_send_buffer_size =
+      LookupOptionWithDefault(options, kOptionSendBufferMinSize, 0);
+  return std::max(max_burst_size, min_send_buffer_size);
+}
+
 }  // namespace
 
 UdpTransport::UdpTransport(
     net::NetLog* net_log,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_proxy,
     const net::IPEndPoint& local_end_point,
     const net::IPEndPoint& remote_end_point,
-    int32_t send_buffer_size,
     const CastTransportStatusCallback& status_callback)
     : io_thread_proxy_(io_thread_proxy),
       local_addr_(local_end_point),
       remote_addr_(remote_end_point),
       udp_socket_(new net::UDPSocket(net::DatagramSocket::DEFAULT_BIND,
                                      net::RandIntCallback(),
                                      net_log,
                                      net::NetLog::Source())),
       send_pending_(false),
       receive_pending_(false),
       client_connected_(false),
       next_dscp_value_(net::DSCP_NO_CHANGE),
-      send_buffer_size_(send_buffer_size),
+      send_buffer_size_(media::cast::kMaxBurstSize *
+                        media::cast::kMaxIpPacketSize),
       status_callback_(status_callback),
       bytes_sent_(0),
       weak_factory_(this) {
   DCHECK(!IsEmpty(local_end_point) || !IsEmpty(remote_end_point));
 }
 
 UdpTransport::~UdpTransport() {}
 
 void UdpTransport::StartReceiving(
     const PacketReceiverCallbackWithStatus& packet_receiver) {
@@ skipping 74 matching lines @@
   if (packet_receiver_.is_null())
     return;
   if (!udp_socket_)
     return;
 
   // Loop while UdpSocket is delivering data synchronously.  When it responds
   // with a "pending" status, break and expect this method to be called back in
   // the future when a packet is ready.
   while (true) {
     if (length_or_status == net::ERR_IO_PENDING) {
-      next_packet_.reset(new Packet(kMaxPacketSize));
+      next_packet_.reset(new Packet(media::cast::kMaxIpPacketSize));
       recv_buf_ = new net::WrappedIOBuffer(
           reinterpret_cast<char*>(&next_packet_->front()));
-      length_or_status =
-          udp_socket_->RecvFrom(recv_buf_.get(),
-                                kMaxPacketSize,
-                                &recv_addr_,
-                                base::Bind(&UdpTransport::ReceiveNextPacket,
-                                           weak_factory_.GetWeakPtr()));
+      length_or_status = udp_socket_->RecvFrom(
+          recv_buf_.get(), media::cast::kMaxIpPacketSize, &recv_addr_,
+          base::Bind(&UdpTransport::ReceiveNextPacket,
+                     weak_factory_.GetWeakPtr()));
       if (length_or_status == net::ERR_IO_PENDING) {
         receive_pending_ = true;
         return;
       }
     }
 
     // Note: At this point, either a packet is ready or an error has occurred.
     if (length_or_status < 0) {
       VLOG(1) << "Failed to receive packet: Status code is "
               << length_or_status;
@@ skipping 101 matching lines @@
   if (result < 0) {
     VLOG(1) << "Failed to send packet: " << result << ".";
   }
   ScheduleReceiveNextPacket();
 
   if (!cb.is_null()) {
     cb.Run();
   }
 }
 
+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