Allow p2p UDP packages to set DSCP

content/browser/renderer_host/p2p/socket_host_udp.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 "content/browser/renderer_host/p2p/socket_host_udp.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "content/common/p2p_messages.h"
 #include "ipc/ipc_sender.h"
@@ skipping 32 matching lines @@
   uid <<= 32;
   uid |= packet_id;
   return uid;
 }
 
 }  // namespace
 
 namespace content {
 
 P2PSocketHostUdp::PendingPacket::PendingPacket(
-    const net::IPEndPoint& to, const std::vector<char>& content, uint64 id)
+    const net::IPEndPoint& to,
+    const std::vector<char>& content,
+    uint64 id,
+    net::DiffServCodePoint dscp_)
     : to(to),
       data(new net::IOBuffer(content.size())),
       size(content.size()),
-      id(id) {
+      id(id),
+      dscp(dscp_) {
   memcpy(data->data(), &content[0], size);
 }
 
 P2PSocketHostUdp::PendingPacket::~PendingPacket() {
 }
 
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender, int id)
     : P2PSocketHost(message_sender, id),
       socket_(new net::UDPServerSocket(NULL, net::NetLog::Source())),
       send_pending_(false),
-      send_packet_count_(0) {
+      send_packet_count_(0),
+      last_dscp_(net::DSCP_CS0) {
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 bool P2PSocketHostUdp::Init(const net::IPEndPoint& local_address,
@@ skipping 78 matching lines @@
     }
 
     message_sender_->Send(new P2PMsg_OnDataReceived(id_, recv_address_, data));
   } else if (result < 0 && !IsTransientError(result)) {
     LOG(ERROR) << "Error when reading from UDP socket: " << result;
     OnError();
   }
 }
 
 void P2PSocketHostUdp::Send(const net::IPEndPoint& to,
-                            const std::vector<char>& data) {
+                            const std::vector<char>& data,
+                            net::DiffServCodePoint dscp) {
   if (!socket_) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
   if (connected_peers_.find(to) == connected_peers_.end()) {
     P2PSocketHost::StunMessageType type;
     bool stun = GetStunPacketType(&*data.begin(), data.size(), &type);
     if (!stun || type == STUN_DATA_INDICATION) {
       LOG(ERROR) << "Page tried to send a data packet to " << to.ToString()
                  << " before STUN binding is finished.";
       OnError();
       return;
     }
   }
 
   if (send_pending_) {
-    send_queue_.push_back(PendingPacket(to, data, send_packet_count_));
+    send_queue_.push_back(PendingPacket(to, data, send_packet_count_, dscp));
   } else {
-    PendingPacket packet(to, data, send_packet_count_);
+    PendingPacket packet(to, data, send_packet_count_, dscp);
     DoSend(packet);
   }
   ++send_packet_count_;
 }
 
 void P2PSocketHostUdp::DoSend(const PendingPacket& packet) {
   TRACE_EVENT_ASYNC_BEGIN1("p2p", "Udp::DoSend",
                            GetUniqueEventId(this, packet.id),
                            "size", packet.size);
+  if (last_dscp_ != packet.dscp && last_dscp_ != net::DSCP_NO_CHANGE) {
+    int result = socket_->SetToS(packet.dscp);
+    if (result == net::OK) {
+      last_dscp_ = packet.dscp;
+    } else if (!IsTransientError(result) && last_dscp_ != net::DSCP_CS0) {

[Sergey Ulanov, 2013/08/17 05:50:04]

IsTransientError() is used for errors returned from SendTo(). Why do we need it
here?

[hubbe, 2013/08/21 18:51:36]

On some platforms setsockopt() IP_TOS is a privileged operation. The idea is
that if setsockopt() fails permanently, we want to stop calling it. Since SetToS
returns errors of the same type as SendTo(), it seems reasonable to use the same
function.

+      // We receieved a non-transient error, and it seems we have
+      // not changed the DSCP in the past, disable DSCP as it unlikely
+      // to work in the future.
+      last_dscp_ = net::DSCP_NO_CHANGE;
+    }
+  }
   int result = socket_->SendTo(
       packet.data.get(),
       packet.size,
       packet.to,
       base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this), packet.id));
 
   // sendto() may return an error, e.g. if we've received an ICMP Destination
   // Unreachable message. When this happens try sending the same packet again,
   // and just drop it if it fails again.
   if (IsTransientError(result)) {
@@ skipping 43 matching lines @@
 }
 
 P2PSocketHost* P2PSocketHostUdp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 }  // namespace content