Relanding PacketOptions CL after revert

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 "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host_throttler.h"
@@ skipping 32 matching lines @@
          error == net::ERR_OUT_OF_MEMORY;
 }
 
 }  // namespace
 
 namespace content {
 
 P2PSocketHostUdp::PendingPacket::PendingPacket(
     const net::IPEndPoint& to,
     const std::vector<char>& content,
-    net::DiffServCodePoint dscp_,
+    const talk_base::PacketOptions& options,
     uint64 id)
     : to(to),
       data(new net::IOBuffer(content.size())),
       size(content.size()),
-      dscp(dscp_),
+      packet_options(options),
       id(id) {
   memcpy(data->data(), &content[0], size);
 }
 
 P2PSocketHostUdp::PendingPacket::~PendingPacket() {
 }
 
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender,
                                    int id,
                                    P2PMessageThrottler* throttler)
@@ skipping 103 matching lines @@
     message_sender_->Send(new P2PMsg_OnDataReceived(
         id_, recv_address_, data, base::TimeTicks::Now()));
   } 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,
-                            net::DiffServCodePoint dscp,
+                            const talk_base::PacketOptions& options,
                             uint64 packet_id) {
   if (!socket_) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
   if (!ContainsKey(connected_peers_, to)) {
     P2PSocketHost::StunMessageType type = P2PSocketHost::StunMessageType();
     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())) {
       VLOG(0) << "STUN message is dropped due to high volume.";
       // Do not reset socket.
       return;
     }
   }
 
   if (send_pending_) {
-    send_queue_.push_back(PendingPacket(to, data, dscp, packet_id));
+    send_queue_.push_back(PendingPacket(to, data, options, packet_id));
   } else {
-    PendingPacket packet(to, data, dscp, packet_id);
+    // TODO(mallinath: Remove unnecessary memcpy in this case.
+    PendingPacket packet(to, data, options, packet_id);
     DoSend(packet);
   }
 }
 
 void P2PSocketHostUdp::DoSend(const PendingPacket& packet) {
   TRACE_EVENT_ASYNC_STEP_INTO1("p2p", "Send", packet.id, "UdpAsyncSendTo",
                                "size", packet.size);
   // Don't try to set DSCP in following conditions,
   // 1. If the outgoing packet is set to DSCP_NO_CHANGE
   // 2. If no change in DSCP value from last packet
   // 3. If there is any error in setting DSCP on socket.
-  if (packet.dscp != net::DSCP_NO_CHANGE &&
-      last_dscp_ != packet.dscp && last_dscp_ != net::DSCP_NO_CHANGE) {
-    int result = socket_->SetDiffServCodePoint(packet.dscp);
+  net::DiffServCodePoint dscp =
+      static_cast<net::DiffServCodePoint>(packet.packet_options.dscp);
+  if (dscp != net::DSCP_NO_CHANGE && last_dscp_ != dscp &&
+      last_dscp_ != net::DSCP_NO_CHANGE) {
+    int result = socket_->SetDiffServCodePoint(dscp);
     if (result == net::OK) {
-      last_dscp_ = packet.dscp;
+      last_dscp_ = 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,
@@ skipping 65 matching lines @@
     case P2P_SOCKET_OPT_DSCP:
       return (net::OK == socket_->SetDiffServCodePoint(
           static_cast<net::DiffServCodePoint>(value))) ? true : false;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 }  // namespace content