Add UMA for the kernel's TCP RTT estimate.

net/socket/tcp_client_socket.cc

 // Copyright (c) 2013 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/tcp_client_socket.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
+#include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 
 namespace net {
 
 TCPClientSocket::TCPClientSocket(const AddressList& addresses,
                                  net::NetLog* net_log,
                                  const net::NetLog::Source& source)
@@ skipping 11 matching lines @@
       current_address_index_(0),
       next_connect_state_(CONNECT_STATE_NONE),
       previously_disconnected_(false) {
   DCHECK(socket_);
 
   socket_->SetDefaultOptionsForClient();
   use_history_.set_was_ever_connected();
 }
 
 TCPClientSocket::~TCPClientSocket() {
+  Disconnect();
 }
 
 int TCPClientSocket::Bind(const IPEndPoint& address) {
   if (current_address_index_ >= 0 || bind_address_) {
     // Cannot bind the socket if we are already connected or connecting.
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   int result = OK;
@@ skipping 119 matching lines @@
   if (current_address_index_ + 1 < static_cast<int>(addresses_.size())) {
     next_connect_state_ = CONNECT_STATE_CONNECT;
     ++current_address_index_;
     return OK;
   }
 
   // Otherwise there is nothing to fall back to, so give up.
   return result;
 }
 
 void TCPClientSocket::Disconnect() {

[mmenke, 2015/07/07 21:27:29]

This is a valid concern.  While I suspect we'll see an estimated RTT of 0 in
that case, I'm not confident of it.  One option would be to pass a bool into
DoDisconnect indicating if we're calling it due to a connection failure or not.
The class really isn't meant to be subclassed - it's only done for tests.  Some
sticklers would doubtless disagree disagree with me on this, but I think it's
fine as-is.

[Bryan McQuade, 2015/07/08 00:35:37]

I'm ok leaving this as-is for the time being. To really improve things, I'll
likely need to plumb the RTT up to a higher layer in the stack to log at some
more sane interval like once per HTTP request.

   DoDisconnect();
   current_address_index_ = -1;
   bind_address_.reset();
 }
 
 void TCPClientSocket::DoDisconnect() {
+  EmitTCPMetricsHistogramsOnDisconnect();
   // If connecting or already connected, record that the socket has been
   // disconnected.
   previously_disconnected_ = socket_->IsValid() && current_address_index_ >= 0;
   socket_->Close();
 }
 
 bool TCPClientSocket::IsConnected() const {
   return socket_->IsConnected();
 }
 
@@ skipping 146 matching lines @@
 
   int result = socket_->Open(family);
   if (result != OK)
     return result;
 
   socket_->SetDefaultOptionsForClient();
 
   return OK;
 }
 
+void TCPClientSocket::EmitTCPMetricsHistogramsOnDisconnect() {
+  base::TimeDelta rtt;
+  if (socket_->GetEstimatedRoundTripTime(&rtt)) {
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.TcpRtt.AtDisconnect", rtt,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10), 100);
+  }
+}
+
 }  // namespace net