Implement UMA and internal data structure for tracking EWOULDBLOCK.

content/browser/renderer_host/p2p/socket_host.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.h"
 
+#include "base/metrics/histogram.h"
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
 #include "content/browser/renderer_host/p2p/socket_host_udp.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/hmac.h"
 #include "third_party/libjingle/source/talk/p2p/base/stun.h"
 #include "third_party/webrtc/base/asyncpacketsocket.h"
 #include "third_party/webrtc/base/byteorder.h"
@@ skipping 430 matching lines @@
       while ((rtp < extension_end) && (*rtp == 0)) {
         ++rtp;
       }
     }
   }
   return found;
 }
 
 }  // packet_processing_helpers
 
-P2PSocketHost::P2PSocketHost(IPC::Sender* message_sender, int socket_id)
+P2PSocketHost::P2PSocketHost(IPC::Sender* message_sender,
+                             int socket_id,
+                             ProtocolType protocol_type)
     : message_sender_(message_sender),
       id_(socket_id),
       state_(STATE_UNINITIALIZED),
       dump_incoming_rtp_packet_(false),
       dump_outgoing_rtp_packet_(false),
-      weak_ptr_factory_(this) {
+      weak_ptr_factory_(this),
+      protocol_type_(protocol_type),
+      send_packets_delayed_total_(0),
+      send_packets_total_(0),
+      send_bytes_delayed_max_(0),
+      send_bytes_delayed_cur_(0) {
 }
 
-P2PSocketHost::~P2PSocketHost() { }
+P2PSocketHost::~P2PSocketHost() {
+  if (protocol_type_ == P2PSocketHost::UDP) {
+    UMA_HISTOGRAM_COUNTS_10000("WebRTC.SystemMaxConsecutiveBytesDelayed_UDP",
+                               send_bytes_delayed_max_);
+  } else {
+    UMA_HISTOGRAM_COUNTS_10000("WebRTC.SystemMaxConsecutiveBytesDelayed_TCP",
+                               send_bytes_delayed_max_);
+  }
+
+  if (send_packets_total_ > 0) {
+    int delay_rate = (send_packets_delayed_total_ * 100) / send_packets_total_;
+    if (protocol_type_ == P2PSocketHost::UDP) {
+      UMA_HISTOGRAM_PERCENTAGE("WebRTC.SystemPercentPacketsDelayed_UDP",
+                               delay_rate);
+    } else {
+      UMA_HISTOGRAM_PERCENTAGE("WebRTC.SystemPercentPacketsDelayed_TCP",
+                               delay_rate);
+    }
+  }
+}
 
 // Verifies that the packet |data| has a valid STUN header.
 // static
 bool P2PSocketHost::GetStunPacketType(
     const char* data, int data_size, StunMessageType* type) {
 
   if (data_size < kStunHeaderSize) {
     return false;
   }
 
@@ skipping 160 matching lines @@
   // |packet_dump_callback_| must be called on the UI thread.
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(packet_dump_callback_,
                                      Passed(&packet_header),
                                      header_length,
                                      packet_length,
                                      incoming));
 }
 
+void P2PSocketHost::IncrementDelayedPackets() {
+  send_packets_delayed_total_++;
+}
+
+void P2PSocketHost::IncrementTotalSentPackets() {
+  send_packets_total_++;
+}
+
+void P2PSocketHost::IncrementDelayedBytes(uint32 size) {
+  send_bytes_delayed_cur_ += size;
+  if (send_bytes_delayed_cur_ > send_bytes_delayed_max_) {
+    send_bytes_delayed_max_ = send_bytes_delayed_cur_;
+  }
+}
+
+void P2PSocketHost::DecrementDelayedBytes(uint32 size) {
+  send_bytes_delayed_cur_ -= size;
+  DCHECK_GE(send_bytes_delayed_cur_, 0);
+}
+
 }  // namespace content