Notify NQE of TCP RTT values

net/socket/client_socket_pool_manager_impl.cc

Index: net/socket/client_socket_pool_manager_impl.cc
diff --git a/net/socket/client_socket_pool_manager_impl.cc b/net/socket/client_socket_pool_manager_impl.cc
index 9dbb19e9c622579513b3a3eaff2f30b69a37b72a..54f06e4142202391d8dea1f7bb4175262fc361f8 100644
--- a/net/socket/client_socket_pool_manager_impl.cc
+++ b/net/socket/client_socket_pool_manager_impl.cc
@@ -16,6 +16,8 @@
 
 namespace net {
 
+class SocketPerformanceWatcherFactory;
+
 namespace {
 
 // Appends information about all |socket_pools| to the end of |list|.
@@ -37,6 +39,7 @@ void AddSocketPoolsToList(base::ListValue* list,
 ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
     NetLog* net_log,
     ClientSocketFactory* socket_factory,
+    const SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
     HostResolver* host_resolver,
     CertVerifier* cert_verifier,
     ChannelIDService* channel_id_service,
@@ -48,6 +51,7 @@ ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
     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),
@@ -57,19 +61,21 @@ ClientSocketPoolManagerImpl::ClientSocketPoolManagerImpl(
       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,
@@ -210,15 +216,12 @@ SOCKSClientSocketPool* ClientSocketPoolManagerImpl::GetSocketPoolForSOCKSProxy(
   DCHECK(!ContainsKey(transport_socket_pools_for_socks_proxies_, socks_proxy));
 
   std::pair<TransportSocketPoolMap::iterator, bool> tcp_ret =
-      transport_socket_pools_for_socks_proxies_.insert(
-          std::make_pair(
-              socks_proxy,
-              new TransportClientSocketPool(
-                  max_sockets_per_proxy_server(pool_type_),
-                  max_sockets_per_group(pool_type_),
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_socks_proxies_.insert(std::make_pair(
+          socks_proxy,
+          new TransportClientSocketPool(
+              max_sockets_per_proxy_server(pool_type_),
+              max_sockets_per_group(pool_type_), host_resolver_,
+              socket_factory_, socket_performance_watcher_factory_, net_log_)));

[Ryan Sleevi, 2015/10/20 00:10:36]

This does make me 'somewhat uneasy' about future privacy issues that might arise
from all of the pools sharing the same socket performance watcher factory.

I'm not sure if I can articulate a more reasoned argument for why, but if we
expose per-host information to origins, it might allow them to infer information
about proxies, which would be a privacy concern.

It may be that this is misguided; the onus is on you to justify why it's OK (and
it may be, but just write it up :P)

[tbansal1, 2016/02/05 19:44:15]

I agree that exposing the raw numerical estimates of RTT or bandwidth to remote
origins is a privacy risk. But, I predict that we will never expose those. In
future, a more likely scenario is that we expose a enum value (dog slow, slow,
not slow, fast etc.).

And that enum value would be computed from multiple factors: bandwidth, RTT,
signal strength, packet loss rate etc (not all are yet 
implemented).

In the unlikely case that a decision is made to expose the raw values,  we would
need to revisit this architecture.

   DCHECK(tcp_ret.second);
 
   std::pair<SOCKSSocketPoolMap::iterator, bool> ret =
@@ -250,27 +253,21 @@ ClientSocketPoolManagerImpl::GetSocketPoolForHTTPProxy(
   DCHECK(!ContainsKey(ssl_socket_pools_for_https_proxies_, http_proxy));
 
   std::pair<TransportSocketPoolMap::iterator, bool> tcp_http_ret =
-      transport_socket_pools_for_http_proxies_.insert(
-          std::make_pair(
-              http_proxy,
-              new TransportClientSocketPool(
-                  max_sockets_per_proxy_server(pool_type_),
-                  max_sockets_per_group(pool_type_),
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_http_proxies_.insert(std::make_pair(
+          http_proxy,
+          new TransportClientSocketPool(
+              max_sockets_per_proxy_server(pool_type_),
+              max_sockets_per_group(pool_type_), 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(
-                  max_sockets_per_proxy_server(pool_type_),
-                  max_sockets_per_group(pool_type_),
-                  host_resolver_,
-                  socket_factory_,
-                  net_log_)));
+      transport_socket_pools_for_https_proxies_.insert(std::make_pair(
+          http_proxy,
+          new TransportClientSocketPool(
+              max_sockets_per_proxy_server(pool_type_),
+              max_sockets_per_group(pool_type_), host_resolver_,
+              socket_factory_, socket_performance_watcher_factory_, net_log_)));
   DCHECK(tcp_https_ret.second);
 
   std::pair<SSLSocketPoolMap::iterator, bool> ssl_https_ret =