Notify NQE of TCP RTT values

net/socket/client_socket_pool_manager_impl.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/client_socket_pool_manager_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/values.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/socket/transport_client_socket_pool.h"
 #include "net/socket/websocket_transport_client_socket_pool.h"
 #include "net/ssl/ssl_config_service.h"
 
 namespace net {
 
+class SocketPerformanceWatcherFactory;
+
 namespace {
 
 // Appends information about all |socket_pools| to the end of |list|.
 template <class MapType>
 void AddSocketPoolsToList(base::ListValue* list,
                           const MapType& socket_pools,
                           const std::string& type,
                           bool include_nested_pools) {
   for (typename MapType::const_iterator it = socket_pools.begin();
        it != socket_pools.end(); it++) {
     list->Append(it->second->GetInfoAsValue(it->first.ToString(),
                                             type,
                                             include_nested_pools));
   }
 }
 
 }  // namespace
 
 ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
     NetLog* net_log,
     ClientSocketFactory* socket_factory,
+    SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
     HostResolver* host_resolver,
     CertVerifier* cert_verifier,
     ChannelIDService* channel_id_service,
     TransportSecurityState* transport_security_state,
     CTVerifier* cert_transparency_verifier,
     CTPolicyEnforcer* ct_policy_enforcer,
     const std::string& ssl_session_cache_shard,
     SSLConfigService* ssl_config_service,
     HttpNetworkSession::SocketPoolType pool_type)
     : net_log_(net_log),
       socket_factory_(socket_factory),
+      socket_performance_watcher_factory_(socket_performance_watcher_factory),
       host_resolver_(host_resolver),
       cert_verifier_(cert_verifier),
       channel_id_service_(channel_id_service),
       transport_security_state_(transport_security_state),
       cert_transparency_verifier_(cert_transparency_verifier),
       ct_policy_enforcer_(ct_policy_enforcer),
       ssl_session_cache_shard_(ssl_session_cache_shard),
       ssl_config_service_(ssl_config_service),
       pool_type_(pool_type),
-      transport_socket_pool_(
-          pool_type == HttpNetworkSession::WEBSOCKET_SOCKET_POOL
-              ? new WebSocketTransportClientSocketPool(
-                    max_sockets_per_pool(pool_type),
-                    max_sockets_per_group(pool_type),
-                    host_resolver,
-                    socket_factory_,
-                    net_log)
-              : new TransportClientSocketPool(max_sockets_per_pool(pool_type),
-                                              max_sockets_per_group(pool_type),
-                                              host_resolver,
-                                              socket_factory_,
-                                              net_log)),
+      transport_socket_pool_(pool_type ==
+                                     HttpNetworkSession::WEBSOCKET_SOCKET_POOL
+                                 ? new WebSocketTransportClientSocketPool(
+                                       max_sockets_per_pool(pool_type),
+                                       max_sockets_per_group(pool_type),
+                                       host_resolver,
+                                       socket_factory_,
+                                       net_log)
+                                 : new TransportClientSocketPool(
+                                       max_sockets_per_pool(pool_type),
+                                       max_sockets_per_group(pool_type),
+                                       host_resolver,
+                                       socket_factory_,
+                                       socket_performance_watcher_factory_,
+                                       net_log)),
       ssl_socket_pool_(new SSLClientSocketPool(max_sockets_per_pool(pool_type),
                                                max_sockets_per_group(pool_type),
                                                cert_verifier,
                                                channel_id_service,
                                                transport_security_state,
                                                cert_transparency_verifier,
                                                ct_policy_enforcer,
                                                ssl_session_cache_shard,
                                                socket_factory,
                                                transport_socket_pool_.get(),
@@ skipping 123 matching lines @@
     DCHECK(ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
     return it->second;
   }
 
   DCHECK(!ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
   int sockets_per_proxy_server = max_sockets_per_proxy_server(pool_type_);
   int sockets_per_group = std::min(sockets_per_proxy_server,
                                    max_sockets_per_group(pool_type_));
 
   std::pair<TransportSocketPoolMap::iterator, bool> tcp_ret =
-      transport_socket_pools_for_socks_proxies_.insert(
-          std::make_pair(
-              socks_proxy,
-              new TransportClientSocketPool(
-                  sockets_per_proxy_server,
-                  sockets_per_group,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_socks_proxies_.insert(std::make_pair(
+          socks_proxy,
+          new TransportClientSocketPool(sockets_per_proxy_server,
+                                        sockets_per_group, host_resolver_,
+                                        socket_factory_, nullptr, net_log_)));
   DCHECK(tcp_ret.second);
 
   std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
-      socks_socket_pools_.insert(
-          std::make_pair(socks_proxy, new SOCKSClientSocketPool(
-              sockets_per_proxy_server,
-              sockets_per_group,
-              host_resolver_,
-              tcp_ret.first->second,
-              net_log_)));
+      socks_socket_pools_.insert(std::make_pair(
+          socks_proxy,
+          new SOCKSClientSocketPool(sockets_per_proxy_server, sockets_per_group,
+                                    host_resolver_, tcp_ret.first->second,
+                                    nullptr, net_log_)));
 
   return ret.first->second;
 }
 
 HttpProxyClientSocketPool*
 ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
     const HostPortPair& http_proxy) {
   HTTPProxySocketPoolMap::const_iterator it =
       http_proxy_socket_pools_.find(http_proxy);
   if (it != http_proxy_socket_pools_.end()) {
     DCHECK(ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
     DCHECK(ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
     DCHECK(ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
     return it->second;
   }
 
   DCHECK(!ContainsKey(transport_socket_pools_for_http_proxies_, http_proxy));
   DCHECK(!ContainsKey(transport_socket_pools_for_https_proxies_, http_proxy));
   DCHECK(!ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
 
   int sockets_per_proxy_server = max_sockets_per_proxy_server(pool_type_);
   int sockets_per_group = std::min(sockets_per_proxy_server,
                                    max_sockets_per_group(pool_type_));
 
   std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
-      transport_socket_pools_for_http_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new TransportClientSocketPool(
-                  sockets_per_proxy_server,
-                  sockets_per_group,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_http_proxies_.insert(std::make_pair(
+          http_proxy,
+          new TransportClientSocketPool(
+              sockets_per_proxy_server, sockets_per_group, host_resolver_,
+              socket_factory_, socket_performance_watcher_factory_, net_log_)));
   DCHECK(tcp_http_ret.second);
 
   std::pair<TransportSocketPoolMap::iterator, bool> tcp_https_ret =
-      transport_socket_pools_for_https_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new TransportClientSocketPool(
-                  sockets_per_proxy_server,
-                  sockets_per_group,
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_https_proxies_.insert(std::make_pair(
+          http_proxy,
+          new TransportClientSocketPool(
+              sockets_per_proxy_server, sockets_per_group, host_resolver_,
+              socket_factory_, socket_performance_watcher_factory_, net_log_)));
   DCHECK(tcp_https_ret.second);
 
   std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =
       ssl_socket_pools_for_https_proxies_.insert(std::make_pair(
           http_proxy,
           new SSLClientSocketPool(
               sockets_per_proxy_server, sockets_per_group, cert_verifier_,
               channel_id_service_, transport_security_state_,
               cert_transparency_verifier_, ct_policy_enforcer_,
               ssl_session_cache_shard_, socket_factory_,
@@ skipping 81 matching lines @@
   // We should not flush the socket pools if we added trust to a
   // cert.
   //
   // Since the OnCACertChanged method doesn't tell us what
   // kind of change it is, we have to flush the socket
   // pools to be safe.
   FlushSocketPoolsWithError(ERR_NETWORK_CHANGED);
 }
 
 }  // namespace net