Implement UMA and internal data structure for tracking EWOULDBLOCK.

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 57 matching lines @@
 P2PSocketHostUdp::P2PSocketHostUdp(IPC::Sender* message_sender,
                                    int socket_id,
                                    P2PMessageThrottler* throttler)
     : P2PSocketHost(message_sender, socket_id),
       socket_(
           new net::UDPServerSocket(GetContentClient()->browser()->GetNetLog(),
                                    net::NetLog::Source())),
       send_pending_(false),
       last_dscp_(net::DSCP_CS0),
       throttler_(throttler) {
+  protocol_type_ = P2PSocketHost::UDP;
 }
 
 P2PSocketHostUdp::~P2PSocketHostUdp() {
   if (state_ == STATE_OPEN) {
     DCHECK(socket_.get());
     socket_.reset();
   }
 }
 
 bool P2PSocketHostUdp::Init(const net::IPEndPoint& local_address,
@@ skipping 116 matching lines @@
       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) {
   TRACE_EVENT_ASYNC_STEP_INTO1("p2p", "Send", packet.id, "UdpAsyncSendTo",
                                "size", packet.size);
@@ skipping 48 matching lines @@
 void P2PSocketHostUdp::OnSend(uint64 packet_id, int result) {
   DCHECK(send_pending_);
   DCHECK_NE(result, net::ERR_IO_PENDING);
 
   send_pending_ = false;
 
   HandleSendResult(packet_id, result);
 
   // Send next packets if we have them waiting in the buffer.
   while (state_ == STATE_OPEN && !send_queue_.empty() && !send_pending_) {
-    DoSend(send_queue_.front());
+    PendingPacket packet = send_queue_.front();
+    DoSend(packet);
     send_queue_.pop_front();
+    DecrementDelayedBytes(packet.size);
   }
 }
 
 void P2PSocketHostUdp::HandleSendResult(uint64 packet_id, int result) {
   TRACE_EVENT_ASYNC_END1("p2p", "Send", packet_id,
                          "result", result);
   if (result < 0) {
     if (!IsTransientError(result)) {
       LOG(ERROR) << "Error when sending data in UDP socket: " << result;
       OnError();
@@ skipping 22 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