Cast: Use DSCP AF41 for all traffic if possible.

media/cast/transport/transport/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/transport/transport/udp_transport.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 36 matching lines @@
     : 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),
       status_callback_(status_callback),
       weak_factory_(this) {
   DCHECK(!IsEmpty(local_end_point) || !IsEmpty(remote_end_point));
 }
 
 UdpTransport::~UdpTransport() {}
 
 void UdpTransport::StartReceiving(
     const PacketReceiverCallback& packet_receiver) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
@@ skipping 14 matching lines @@
       return;
     }
     client_connected_ = true;
   } else {
     NOTREACHED() << "Either local or remote address has to be defined.";
   }
 
   ScheduleReceiveNextPacket();
 }
 
+void UdpTransport::SetDscp(net::DiffServCodePoint dscp) {
+  DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
+  next_dscp_value_ = dscp;
+}
+
 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 54 matching lines @@
 
 bool UdpTransport::SendPacket(PacketRef packet, const base::Closure& cb) {
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
 
   DCHECK(!send_pending_);
   if (send_pending_) {
     VLOG(1) << "Cannot send because of pending IO.";
     return true;
   }
 
+  if (next_dscp_value_ != net::DSCP_NO_CHANGE) {
+    int result = udp_socket_->SetDiffServCodePoint(next_dscp_value_);
+    if (result != net::OK) {
+      LOG(ERROR) << "Unable to set DSCP: " << next_dscp_value_
+                 << " to socket; Error: " << result;
+    }
+    // Don't change DSCP in next send.
+    next_dscp_value_ = net::DSCP_NO_CHANGE;
+  }
+
   scoped_refptr<net::IOBuffer> buf =
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&packet->data.front()));
 
   int result;
   base::Callback<void(int)> callback = base::Bind(&UdpTransport::OnSent,
                                                   weak_factory_.GetWeakPtr(),
                                                   buf,
                                                   packet,
                                                   cb);
   if (client_connected_) {
@@ skipping 42 matching lines @@
   }
 
   if (!cb.is_null()) {
     cb.Run();
   }
 }
 
 }  // namespace transport
 }  // namespace cast
 }  // namespace media