Added three histograms to track the following TCP connection latency

net/socket/transport_client_socket_pool.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 "net/socket/transport_client_socket_pool.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
@@ skipping 78 matching lines @@
     ClientSocketFactory* client_socket_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name, timeout_duration, priority, delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       params_(params),
       client_socket_factory_(client_socket_factory),
       resolver_(host_resolver),
       next_state_(STATE_NONE),
-      less_than_20ms_since_connect_(true) {
+      interval_between_connects_(CONNECT_INTERVAL_GT_20MS) {
 }
 
 TransportConnectJob::~TransportConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
   // ~SingleRequestHostResolver and ~StreamSocket will take care of it.
 }
 
 LoadState TransportConnectJob::GetLoadState() const {
   switch (next_state_) {
     case STATE_RESOLVE_HOST:
@@ skipping 87 matching lines @@
 }
 
 int TransportConnectJob::DoTransportConnect() {
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks last_connect_time;
   {
     base::AutoLock lock(g_last_connect_time_lock.Get());
     last_connect_time = g_last_connect_time.Get();
     *g_last_connect_time.Pointer() = now;
   }
-  if (last_connect_time.is_null() ||
-      (now - last_connect_time).InMilliseconds() < 20) {
-    less_than_20ms_since_connect_ = true;
+  if (last_connect_time.is_null()) {
+    interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
   } else {
-    less_than_20ms_since_connect_ = false;
+    int64 interval = (now - last_connect_time).InMilliseconds();
+    if (interval <= 10)
+      interval_between_connects_ = CONNECT_INTERVAL_LE_10MS;
+    else if (interval <= 20)
+      interval_between_connects_ = CONNECT_INTERVAL_LE_20MS;
+    else
+      interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
   }
 
   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
   transport_socket_ = client_socket_factory_->CreateTransportClientSocket(
         addresses_, net_log().net_log(), net_log().source());
   int rv = transport_socket_->Connect(
       base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)));
   if (rv == ERR_IO_PENDING &&
       addresses_.front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
       !AddressListOnlyContainsIPv6(addresses_)) {
@@ skipping 18 matching lines @@
         base::TimeDelta::FromMinutes(10),
         100);
 
     base::TimeDelta connect_duration = now - connect_timing_.connect_start;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
         connect_duration,
         base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10),
         100);
 
-    if (less_than_20ms_since_connect_) {
-      UMA_HISTOGRAM_CUSTOM_TIMES(
-          "Net.TCP_Connection_Latency_Interval_20ms_Minus",
-          connect_duration,
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMinutes(10),
-          100);
-    } else {
-      UMA_HISTOGRAM_CUSTOM_TIMES(
-          "Net.TCP_Connection_Latency_Interval_20ms_Plus",
-          connect_duration,
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMinutes(10),
-          100);
+    switch (interval_between_connects_) {
+      case CONNECT_INTERVAL_LE_10MS:
+        UMA_HISTOGRAM_CUSTOM_TIMES(
+            "Net.TCP_Connection_Latency_Interval_LessThanOrEqual_10ms",
+            connect_duration,
+            base::TimeDelta::FromMilliseconds(1),
+            base::TimeDelta::FromMinutes(10),
+            100);
+        break;
+      case CONNECT_INTERVAL_LE_20MS:
+        UMA_HISTOGRAM_CUSTOM_TIMES(
+            "Net.TCP_Connection_Latency_Interval_LessThanOrEqual_20ms",
+            connect_duration,
+            base::TimeDelta::FromMilliseconds(1),
+            base::TimeDelta::FromMinutes(10),
+            100);
+        break;
+      case CONNECT_INTERVAL_GT_20MS:
+        UMA_HISTOGRAM_CUSTOM_TIMES(
+            "Net.TCP_Connection_Latency_Interval_GreaterThan_20ms",
+            connect_duration,
+            base::TimeDelta::FromMilliseconds(1),
+            base::TimeDelta::FromMinutes(10),
+            100);
+        break;
+      default:
+        NOTREACHED();
+        break;
     }
 
     if (is_ipv4) {
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_No_Race",
                                  connect_duration,
                                  base::TimeDelta::FromMilliseconds(1),
                                  base::TimeDelta::FromMinutes(10),
                                  100);
     } else {
       if (AddressListOnlyContainsIPv6(addresses_)) {
@@ skipping 235 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net