Add a histogram to record the dns resolution + tcp connection times.

net/http/http_network_transaction.cc

 // Copyright (c) 2006-2008 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/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/string_util.h"
@@ skipping 563 matching lines @@
   if (using_proxy_ || using_tunnel_) {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     host = proxy_server.host();
     port = proxy_server.port();
   } else {
     // Direct connection
     host = request_->url.host();
     port = request_->url.EffectiveIntPort();
   }
 
+  host_resolution_start_time_ = base::Time::Now();
+
   DidStartDnsResolution(host, this);
   return resolver_.Resolve(host, port, &addresses_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoResolveHostComplete(int result) {
   bool ok = (result == OK);
   DidFinishDnsResolutionWithStatus(ok, request_->referrer, this);
   if (ok) {
     next_state_ = STATE_TCP_CONNECT;
   } else {
@@ skipping 11 matching lines @@
 
   ClientSocket* s = socket_factory_->CreateTCPClientSocket(addresses_);
   connection_.set_socket(s);
   return connection_.socket()->Connect(&io_callback_);
 }
 
 int HttpNetworkTransaction::DoTCPConnectComplete(int result) {
   // If we are using a direct SSL connection, then go ahead and establish the
   // SSL connection, now.  Otherwise, we need to first issue a CONNECT request.
   if (result == OK) {
-    LogTCPConnectionMetrics();
+    LogTCPConnectedMetrics();
     if (using_ssl_ && !using_tunnel_) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_WRITE_HEADERS;
       if (using_tunnel_)
         establishing_tunnel_ = true;
     }
   } else {
     result = ReconsiderProxyAfterError(result);
   }
@@ skipping 336 matching lines @@
   if (done) {
     DidDrainBodyForAuthRestart(keep_alive);
   } else {
     // Keep draining.
     next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
   }
 
   return OK;
 }
 
-void HttpNetworkTransaction::LogTCPConnectionMetrics() const {
+void HttpNetworkTransaction::LogTCPConnectedMetrics() const {
   DCHECK(connect_start_time_ != base::Time());
   base::TimeDelta connect_duration =
       base::Time::Now() - connect_start_time_;
 
   UMA_HISTOGRAM_CLIPPED_TIMES(FieldTrial::MakeName(
       "Net.TCP_Connection_Latency", "DnsImpact").data(), connect_duration,
       base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
       100);
+
+  base::TimeDelta host_resolution_and_tcp_connection_latency =
+      base::Time::Now() - host_resolution_start_time_;
+
+  UMA_HISTOGRAM_CLIPPED_TIMES(
+      FieldTrial::MakeName(
+          "Net.Dns_Resolution_And_TCP_Connection_Latency", "DnsImpact").data(),
+      host_resolution_and_tcp_connection_latency,
+      base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
+      100);
 }
 
 void HttpNetworkTransaction::LogTransactionConnectedMetrics() const {
   base::TimeDelta total_duration = response_.response_time - start_time_;
 
   UMA_HISTOGRAM_CLIPPED_TIMES(
       FieldTrial::MakeName(
           "Net.Transaction_Connected_Under_10",
           "DnsImpact").data(),
       total_duration,
@@ skipping 630 matching lines @@
   if (target == HttpAuth::AUTH_PROXY) {
     auth_info->host = ASCIIToWide(proxy_info_.proxy_server().host_and_port());
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     auth_info->host = ASCIIToWide(request_->url.host());
   }
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net