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/browser/renderer_host/p2p/socket_host_throttler.h"
 #include "content/common/p2p_messages.h"
@@ skipping 33 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,
                                    P2PMessageThrottler* throttler)
     : P2PSocketHost(message_sender, id),
       socket_(new net::UDPServerSocket(NULL, net::NetLog::Source())),
       send_pending_(false),
       send_packet_count_(0),
-      throttler_(throttler) {
+      throttler_(throttler),
+      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 (throttler_->DropNextPacket(data.size())) {
       LOG(INFO) << "STUN message is dropped due to high volume.";
       // Do not reset socket.
       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_->SetDiffServCodePoint(packet.dscp);
+    if (result == net::OK) {
+      last_dscp_ = packet.dscp;
+    } else if (!IsTransientError(result) && last_dscp_ != net::DSCP_CS0) {
+      // 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