Notify NQE of TCP RTT values

net/socket/transport_client_socket_pool.h

 // 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.
 
 #ifndef NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/host_port_pair.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/single_request_host_resolver.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/connection_attempts.h"
 
 namespace net {
 
 class ClientSocketFactory;
+class SocketPerformanceWatcherFactory;
 
 typedef base::Callback<int(const AddressList&, const BoundNetLog& net_log)>
 OnHostResolutionCallback;
 
 class NET_EXPORT_PRIVATE TransportSocketParams
     : public base::RefCounted<TransportSocketParams> {
  public:
   // CombineConnectAndWrite currently translates to using TCP FastOpen.
   // TCP FastOpen should not be used if the first write to the socket may
   // be non-idempotent, as the underlying socket could retransmit the data
@@ skipping 111 matching lines @@
 // TransportConnectJob handles the host resolution necessary for socket creation
 // and the transport (likely TCP) connect. TransportConnectJob also has fallback
 // logic for IPv6 connect() timeouts (which may happen due to networks / routers
 // with broken IPv6 support). Those timeouts take 20s, so rather than make the
 // user wait 20s for the timeout to fire, we use a fallback timer
 // (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer
 // fires. Then we race the IPv4 connect() against the IPv6 connect() (which has
 // a headstart) and return the one that completes first to the socket pool.
 class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
  public:
-  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,
-                      HostResolver* host_resolver,
-                      Delegate* delegate,
-                      NetLog* net_log);
+  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);
   ~TransportConnectJob() override;
 
   // ConnectJob methods.
   LoadState GetLoadState() const override;
   void GetAdditionalErrorState(ClientSocketHandle* handle) override;
 
   // Rolls |addrlist| forward until the first IPv4 address, if any.
   // WARNING: this method should only be used to implement the prefer-IPv4 hack.
   static void MakeAddressListStartWithIPv4(AddressList* addrlist);
 
@@ skipping 23 matching lines @@
   void CopyConnectionAttemptsFromSockets();
 
   TransportConnectJobHelper helper_;
 
   scoped_ptr<StreamSocket> transport_socket_;
 
   scoped_ptr<StreamSocket> fallback_transport_socket_;
   scoped_ptr<AddressList> fallback_addresses_;
   base::TimeTicks fallback_connect_start_time_;
   base::OneShotTimer fallback_timer_;
+  SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
 
   // Track the interval between this connect and previous connect.
   ConnectInterval interval_between_connects_;
 
   int resolve_result_;
 
   // Used in the failure case to save connection attempts made on the main and
   // fallback sockets and pass them on in |GetAdditionalErrorState|. (In the
   // success case, connection attempts are passed through the returned socket;
   // attempts are copied from the other socket, if one exists, into it before
   // it is returned.)
   ConnectionAttempts connection_attempts_;
   ConnectionAttempts fallback_connection_attempts_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportConnectJob);
 };
 
 class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool {
  public:
   typedef TransportSocketParams SocketParams;
 
   TransportClientSocketPool(
       int max_sockets,
       int max_sockets_per_group,
       HostResolver* host_resolver,
       ClientSocketFactory* client_socket_factory,
       NetLog* net_log);
 
+  void SetSocketPerformanceWatcherFactory(
+      SocketPerformanceWatcherFactory* socket_performance_watcher_factory);
+
   ~TransportClientSocketPool() override;
 
   // ClientSocketPool implementation.
   int RequestSocket(const std::string& group_name,
                     const void* resolve_info,
                     RequestPriority priority,
                     RespectLimits respect_limits,
                     ClientSocketHandle* handle,
                     const CompletionCallback& callback,
                     const BoundNetLog& net_log) override;
@@ skipping 29 matching lines @@
       const BoundNetLog& net_log,
       const scoped_refptr<TransportSocketParams>* casted_params);
 
  private:
   typedef ClientSocketPoolBase<TransportSocketParams> PoolBase;
 
   class TransportConnectJobFactory
       : public PoolBase::ConnectJobFactory {
    public:
     TransportConnectJobFactory(ClientSocketFactory* client_socket_factory,
-                         HostResolver* host_resolver,
-                         NetLog* net_log)
+                               HostResolver* host_resolver,
+                               NetLog* net_log)
         : client_socket_factory_(client_socket_factory),
+          socket_performance_watcher_factory_(nullptr),
           host_resolver_(host_resolver),
           net_log_(net_log) {}
 
+    void SetSocketPerformanceWatcherFactory(
+        SocketPerformanceWatcherFactory* socket_performance_watcher_factory)
+        override;
+
     ~TransportConnectJobFactory() override {}
 
     // ClientSocketPoolBase::ConnectJobFactory methods.
 
     scoped_ptr<ConnectJob> NewConnectJob(
         const std::string& group_name,
         const PoolBase::Request& request,
         ConnectJob::Delegate* delegate) const override;
 
     base::TimeDelta ConnectionTimeout() const override;
 
    private:
     ClientSocketFactory* const client_socket_factory_;
+    SocketPerformanceWatcherFactory* socket_performance_watcher_factory_;
     HostResolver* const host_resolver_;
     NetLog* net_log_;
 
     DISALLOW_COPY_AND_ASSIGN(TransportConnectJobFactory);
   };
 
   PoolBase base_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool);
 };
@@ skipping 49 matching lines @@
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
 }  // namespace net
 
 #endif  // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_