Fix P2PSocketHostUdp to handle dropped packets properly.

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/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
@@ skipping 252 matching lines @@
 void P2PSocketHostUdp::Send(const net::IPEndPoint& to,
                             const std::vector<char>& data,
                             const rtc::PacketOptions& options,
                             uint64_t 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 (!base::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;
-    }
-  }
-
   IncrementTotalSentPackets();
 
   if (send_pending_) {
     send_queue_.push_back(PendingPacket(to, data, options, packet_id));
     IncrementDelayedBytes(data.size());
     IncrementDelayedPackets();
   } else {
-    // TODO(mallinath: Remove unnecessary memcpy in this case.
     PendingPacket packet(to, data, options, packet_id);
     DoSend(packet);
   }
 }
 
 void P2PSocketHostUdp::DoSend(const PendingPacket& packet) {
+  base::TimeTicks send_time = base::TimeTicks::Now();
+
+  // The peer is considered not connected until the first incoming STUN
+  // request/response. In that state the renderer is allowed to send only STUN
+  // messages to that peer and they are throttled using the |throttler_|. This
+  // has to be done here instead of Send() to ensure P2PMsg_OnSendComplete
+  // messages are sent in correct order.
+  if (!base::ContainsKey(connected_peers_, packet.to)) {
+    P2PSocketHost::StunMessageType type = P2PSocketHost::StunMessageType();
+    bool stun = GetStunPacketType(packet.data->data(), packet.size, &type);
+    if (!stun || type == STUN_DATA_INDICATION) {
+      LOG(ERROR) << "Page tried to send a data packet to "
+                 << packet.to.ToString() << " before STUN binding is finished.";
+      OnError();
+      return;
+    }
+
+    if (throttler_->DropNextPacket(packet.size)) {
+      VLOG(0) << "Throttling outgoing STUN message.";
+      // The renderer expects P2PMsg_OnSendComplete for all packets it generates
+      // and in the same order it generates them, so we need to respond even
+      // when the packet is dropped.
+      message_sender_->Send(new P2PMsg_OnSendComplete(
+          id_, P2PSendPacketMetrics(packet.id, packet.packet_options.packet_id,
+                                    send_time)));
+      // Do not reset the socket.
+      return;
+    }
+  }
+
   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.
   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_ = 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;
     }
   }
 
-  base::TimeTicks send_time = base::TimeTicks::Now();
   cricket::ApplyPacketOptions(reinterpret_cast<uint8_t*>(packet.data->data()),
                               packet.size,
                               packet.packet_options.packet_time_params,
                               (send_time - base::TimeTicks()).InMicroseconds());
   auto callback_binding =
       base::Bind(&P2PSocketHostUdp::OnSend, base::Unretained(this), packet.id,
                  packet.packet_options.packet_id, send_time);
   int result = socket_->SendTo(packet.data.get(), packet.size, packet.to,
                                callback_binding);
 
@@ skipping 23 matching lines @@
   DCHECK(send_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
   HandleSendResult(packet_id, transport_sequence_number, send_time, result);
 
   // Send next packets if we have them waiting in the buffer.
   while (state_ == STATE_OPEN && !send_queue_.empty() && !send_pending_) {
     PendingPacket packet = send_queue_.front();
+    send_queue_.pop_front();
     DoSend(packet);
-    send_queue_.pop_front();
     DecrementDelayedBytes(packet.size);
   }
 }
 
 void P2PSocketHostUdp::HandleSendResult(uint64_t packet_id,
                                         int32_t transport_sequence_number,
                                         base::TimeTicks send_time,
                                         int result) {
   TRACE_EVENT_ASYNC_END1("p2p", "Send", packet_id,
                          "result", result);
@@ skipping 55 matching lines @@
   net::UDPServerSocket* socket = new net::UDPServerSocket(
       GetContentClient()->browser()->GetNetLog(), net::NetLog::Source());
 #if defined(OS_WIN)
   socket->UseNonBlockingIO();
 #endif
 
   return base::WrapUnique(socket);
 }
 
 }  // namespace content