Add UMA for the kernel's TCP RTT estimate.

net/socket/tcp_socket_libevent.cc

 // Copyright 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_socket.h"
 
 #include <errno.h>
 #include <netinet/tcp.h>
 #include <sys/socket.h>
 
@@ skipping 96 matching lines @@
   return true;
 }
 
 void RegisterTCPFastOpenIntentAndSupport(bool user_enabled,
                                          bool system_supported) {
   g_tcp_fastopen_supported = system_supported;
   g_tcp_fastopen_user_enabled = user_enabled;
 }
 #endif
 
+#if defined(TCP_INFO)
+bool GetTcpInfo(SocketDescriptor fd, tcp_info* info) {
+  socklen_t info_len = sizeof(tcp_info);
+  return getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &info_len) == 0 &&
+         info_len == sizeof(tcp_info);
+}
+#endif  // defined(TCP_INFO)
+
 }  // namespace
 
 //-----------------------------------------------------------------------------
 
 bool IsTCPFastOpenSupported() {
   return g_tcp_fastopen_supported;
 }
 
 bool IsTCPFastOpenUserEnabled() {
   return g_tcp_fastopen_user_enabled;
@@ skipping 586 matching lines @@
             TCP_FASTOPEN_FAST_CONNECT_READ_FAILED :
             TCP_FASTOPEN_SLOW_CONNECT_READ_FAILED);
     return;
   }
 
   bool getsockopt_success = false;
   bool server_acked_data = false;
 #if defined(TCP_INFO)
   // Probe to see the if the socket used TCP FastOpen.
   tcp_info info;
-  socklen_t info_len = sizeof(tcp_info);
-  getsockopt_success = getsockopt(socket_->socket_fd(), IPPROTO_TCP, TCP_INFO,
-                                  &info, &info_len) == 0 &&
-                       info_len == sizeof(tcp_info);
-  server_acked_data = getsockopt_success &&
-                      (info.tcpi_options & TCPI_OPT_SYN_DATA);
-#endif
+  getsockopt_success = GetTcpInfo(socket_->socket_fd(), &info);
+  server_acked_data =
+      getsockopt_success && (info.tcpi_options & TCPI_OPT_SYN_DATA);
+#endif  // defined(TCP_INFO)
 
   if (getsockopt_success) {
     if (tcp_fastopen_status_ == TCP_FASTOPEN_FAST_CONNECT_RETURN) {
       tcp_fastopen_status_ = (server_acked_data ?
                               TCP_FASTOPEN_SYN_DATA_ACK :
                               TCP_FASTOPEN_SYN_DATA_NACK);
     } else {
       tcp_fastopen_status_ = (server_acked_data ?
                               TCP_FASTOPEN_NO_SYN_DATA_ACK :
                               TCP_FASTOPEN_NO_SYN_DATA_NACK);
     }
   } else {
     tcp_fastopen_status_ =
         (tcp_fastopen_status_ == TCP_FASTOPEN_FAST_CONNECT_RETURN ?
          TCP_FASTOPEN_SYN_DATA_GETSOCKOPT_FAILED :
          TCP_FASTOPEN_NO_SYN_DATA_GETSOCKOPT_FAILED);
   }
 }
 
+bool TCPSocketLibevent::GetEstimatedRoundTripTime(
+    base::TimeDelta* out_rtt) const {
+  DCHECK(out_rtt);
+  if (!socket_)
+    return false;
+
+#if defined(TCP_INFO)
+  tcp_info info;
+  if (GetTcpInfo(socket_->socket_fd(), &info)) {
+    // tcpi_rtt is zero when the kernel doesn't have an RTT estimate,
+    // and possibly in other cases such as connections to localhost.
+    if (info.tcpi_rtt > 0) {
+      *out_rtt = base::TimeDelta::FromMicroseconds(info.tcpi_rtt);
+      return true;
+    }
+  }
+#endif  // defined(TCP_INFO)
+  return false;
+}
+
 }  // namespace net