Notify NQE of TCP RTT values

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 <utility>
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
+#include "net/base/socket_performance_watcher_factory.h"
 #include "net/log/net_log.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/socket_net_log_params.h"
 #include "net/socket/tcp_client_socket.h"
 
 using base::TimeDelta;
 
 namespace net {
@@ skipping 159 matching lines @@
   return connect_duration;
 }
 
 TransportConnectJob::TransportConnectJob(
     const std::string& group_name,
     RequestPriority priority,
     ClientSocketPool::RespectLimits respect_limits,
     const scoped_refptr<TransportSocketParams>& params,
     base::TimeDelta timeout_duration,
     ClientSocketFactory* client_socket_factory,
+    SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
     : ConnectJob(group_name,
                  timeout_duration,
                  priority,
                  respect_limits,
                  delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       helper_(params, client_socket_factory, host_resolver, &connect_timing_),
+      socket_performance_watcher_factory_(socket_performance_watcher_factory),
       interval_between_connects_(CONNECT_INTERVAL_GT_20MS),
       resolve_result_(OK) {
   helper_.SetOnIOComplete(this);
 }
 
 TransportConnectJob::~TransportConnectJob() {
   // We don't worry about cancelling the host resolution and TCP connect, since
   // ~SingleRequestHostResolver and ~StreamSocket will take care of it.
 }
 
@@ skipping 68 matching lines @@
     else if (interval <= 20)
       interval_between_connects_ = CONNECT_INTERVAL_LE_20MS;
     else
       interval_between_connects_ = CONNECT_INTERVAL_GT_20MS;
   }
 
   helper_.set_next_state(
       TransportConnectJobHelper::STATE_TRANSPORT_CONNECT_COMPLETE);
   transport_socket_ =
       helper_.client_socket_factory()->CreateTransportClientSocket(
-          helper_.addresses(), net_log().net_log(), net_log().source());
+          helper_.addresses(), socket_performance_watcher_factory_,
+          net_log().net_log(), net_log().source());
 
   // If the list contains IPv6 and IPv4 addresses, the first address will
   // be IPv6, and the IPv4 addresses will be tried as fallback addresses,
   // per "Happy Eyeballs" (RFC 6555).
   bool try_ipv6_connect_with_ipv4_fallback =
       helper_.addresses().front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
       !AddressListOnlyContainsIPv6(helper_.addresses());
 
   // Enable TCP FastOpen if indicated by transport socket params.
   // Note: We currently do not turn on TCP FastOpen for destinations where
@@ skipping 98 matching lines @@
     return;
   }
 
   DCHECK(!fallback_transport_socket_.get());
   DCHECK(!fallback_addresses_.get());
 
   fallback_addresses_.reset(new AddressList(helper_.addresses()));
   MakeAddressListStartWithIPv4(fallback_addresses_.get());
   fallback_transport_socket_ =
       helper_.client_socket_factory()->CreateTransportClientSocket(
-          *fallback_addresses_, net_log().net_log(), net_log().source());
+          *fallback_addresses_, socket_performance_watcher_factory_,
+          net_log().net_log(), net_log().source());
   fallback_connect_start_time_ = base::TimeTicks::Now();
   int rv = fallback_transport_socket_->Connect(
       base::Bind(
           &TransportConnectJob::DoIPv6FallbackTransportConnectComplete,
           base::Unretained(this)));
   if (rv != ERR_IO_PENDING)
     DoIPv6FallbackTransportConnectComplete(rv);
 }
 
 void TransportConnectJob::DoIPv6FallbackTransportConnectComplete(int result) {
@@ skipping 54 matching lines @@
 }
 
 scoped_ptr<ConnectJob>
 TransportClientSocketPool::TransportConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
   return scoped_ptr<ConnectJob>(new TransportConnectJob(
       group_name, request.priority(), request.respect_limits(),
       request.params(), ConnectionTimeout(), client_socket_factory_,
-      host_resolver_, delegate, net_log_));
+      socket_performance_watcher_factory_, host_resolver_, delegate, net_log_));
+}
+
+void TransportClientSocketPool::TransportConnectJobFactory::
+    SetSocketPerformanceWatcherFactory(
+        SocketPerformanceWatcherFactory* socket_performance_watcher_factory) {
+  socket_performance_watcher_factory_ = socket_performance_watcher_factory;
 }
 
 base::TimeDelta
     TransportClientSocketPool::TransportConnectJobFactory::ConnectionTimeout()
     const {
   return base::TimeDelta::FromSeconds(kTransportConnectJobTimeoutInSeconds);
 }
 
 TransportClientSocketPool::TransportClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     NetLog* net_log)
     : base_(NULL,
             max_sockets,
             max_sockets_per_group,
             ClientSocketPool::unused_idle_socket_timeout(),
             ClientSocketPool::used_idle_socket_timeout(),
             new TransportConnectJobFactory(client_socket_factory,
                                            host_resolver,
                                            net_log)) {
   base_.EnableConnectBackupJobs();
 }
 
+void TransportClientSocketPool::SetSocketPerformanceWatcherFactory(
+    SocketPerformanceWatcherFactory* socket_performance_watcher_factory) {
+  base_.SetSocketPerformanceWatcherFactory(socket_performance_watcher_factory);
+}
+
 TransportClientSocketPool::~TransportClientSocketPool() {}
 
 int TransportClientSocketPool::RequestSocket(const std::string& group_name,
                                              const void* params,
                                              RequestPriority priority,
                                              RespectLimits respect_limits,
                                              ClientSocketHandle* handle,
                                              const CompletionCallback& callback,
                                              const BoundNetLog& net_log) {
   const scoped_refptr<TransportSocketParams>* casted_params =
@@ skipping 90 matching lines @@
     HigherLayeredPool* higher_pool) {
   base_.AddHigherLayeredPool(higher_pool);
 }
 
 void TransportClientSocketPool::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   base_.RemoveHigherLayeredPool(higher_pool);
 }
 
 }  // namespace net