src/net/socket/transport_client_socket_pool.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
   6 #define NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/time/time.h"
  14 #include "base/timer/timer.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/dns/host_resolver.h"
  17 #include "net/dns/single_request_host_resolver.h"
  18 #include "net/socket/client_socket_pool.h"
  19 #include "net/socket/client_socket_pool_base.h"
  20 #include "net/socket/client_socket_pool_histograms.h"
  21
  22 namespace net {
  23
  24 class ClientSocketFactory;
  25
  26 typedef base::Callback<int(const AddressList&, const BoundNetLog& net_log)>
  27 OnHostResolutionCallback;
  28
  29 class NET_EXPORT_PRIVATE TransportSocketParams
  30     : public base::RefCounted<TransportSocketParams> {
  31  public:
  32   // CombineConnectAndWrite currently translates to using TCP FastOpen.
  33   // TCP FastOpen should not be used if the first write to the socket may
  34   // be non-idempotent, as the underlying socket could retransmit the data
  35   // on failure of the first transmission.
  36   // NOTE: Currently, COMBINE_CONNECT_AND_WRITE_DESIRED is used if the data in
  37   // the write is known to be idempotent, and COMBINE_CONNECT_AND_WRITE_DEFAULT
  38   // is used as a default for other cases (including non-idempotent writes).
  39   enum CombineConnectAndWritePolicy {
  40     COMBINE_CONNECT_AND_WRITE_DEFAULT,    // Default policy, implemented in
  41                                           // TransportSocketParams constructor.
  42     COMBINE_CONNECT_AND_WRITE_DESIRED,    // Combine if supported by socket.
  43     COMBINE_CONNECT_AND_WRITE_PROHIBITED  // Do not combine.
  44   };
  45
  46   // |host_resolution_callback| will be invoked after the the hostname is
  47   // resolved.  If |host_resolution_callback| does not return OK, then the
  48   // connection will be aborted with that value. |combine_connect_and_write|
  49   // defines the policy for use of TCP FastOpen on this socket.
  50   TransportSocketParams(
  51       const HostPortPair& host_port_pair,
  52       bool disable_resolver_cache,
  53       bool ignore_limits,
  54       const OnHostResolutionCallback& host_resolution_callback,
  55       CombineConnectAndWritePolicy combine_connect_and_write);
  56
  57   const HostResolver::RequestInfo& destination() const { return destination_; }
  58   bool ignore_limits() const { return ignore_limits_; }
  59   const OnHostResolutionCallback& host_resolution_callback() const {
  60     return host_resolution_callback_;
  61   }
  62
  63   CombineConnectAndWritePolicy combine_connect_and_write() const {
  64     return combine_connect_and_write_;
  65   }
  66
  67  private:
  68   friend class base::RefCounted<TransportSocketParams>;
  69   ~TransportSocketParams();
  70
  71   HostResolver::RequestInfo destination_;
  72   bool ignore_limits_;
  73   const OnHostResolutionCallback host_resolution_callback_;
  74   CombineConnectAndWritePolicy combine_connect_and_write_;
  75
  76   DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
  77 };
  78
  79 // Common data and logic shared between TransportConnectJob and
  80 // WebSocketTransportConnectJob.
  81 class NET_EXPORT_PRIVATE TransportConnectJobHelper {
  82  public:
  83   enum State {
  84     STATE_RESOLVE_HOST,
  85     STATE_RESOLVE_HOST_COMPLETE,
  86     STATE_TRANSPORT_CONNECT,
  87     STATE_TRANSPORT_CONNECT_COMPLETE,
  88     STATE_NONE,
  89   };
  90
  91   // For recording the connection time in the appropriate bucket.
  92   enum ConnectionLatencyHistogram {
  93     CONNECTION_LATENCY_UNKNOWN,
  94     CONNECTION_LATENCY_IPV4_WINS_RACE,
  95     CONNECTION_LATENCY_IPV4_NO_RACE,
  96     CONNECTION_LATENCY_IPV6_RACEABLE,
  97     CONNECTION_LATENCY_IPV6_SOLO,
  98   };
  99
 100   TransportConnectJobHelper(const scoped_refptr<TransportSocketParams>& params,
 101                             ClientSocketFactory* client_socket_factory,
 102                             HostResolver* host_resolver,
 103                             LoadTimingInfo::ConnectTiming* connect_timing);
 104   ~TransportConnectJobHelper();
 105
 106   ClientSocketFactory* client_socket_factory() {
 107     return client_socket_factory_;
 108   }
 109
 110   const AddressList& addresses() const { return addresses_; }
 111   State next_state() const { return next_state_; }
 112   void set_next_state(State next_state) { next_state_ = next_state; }
 113   CompletionCallback on_io_complete() const { return on_io_complete_; }
 114   const TransportSocketParams* params() { return params_.get(); }
 115
 116   int DoResolveHost(RequestPriority priority, const BoundNetLog& net_log);
 117   int DoResolveHostComplete(int result, const BoundNetLog& net_log);
 118
 119   template <class T>
 120   int DoConnectInternal(T* job);
 121
 122   template <class T>
 123   void SetOnIOComplete(T* job);
 124
 125   template <class T>
 126   void OnIOComplete(T* job, int result);
 127
 128   // Record the histograms Net.DNS_Resolution_And_TCP_Connection_Latency2 and
 129   // Net.TCP_Connection_Latency and return the connect duration.
 130   base::TimeDelta HistogramDuration(ConnectionLatencyHistogram race_result);
 131
 132   static const int kIPv6FallbackTimerInMs;
 133
 134  private:
 135   template <class T>
 136   int DoLoop(T* job, int result);
 137
 138   scoped_refptr<TransportSocketParams> params_;
 139   ClientSocketFactory* const client_socket_factory_;
 140   SingleRequestHostResolver resolver_;
 141   AddressList addresses_;
 142   State next_state_;
 143   CompletionCallback on_io_complete_;
 144   LoadTimingInfo::ConnectTiming* connect_timing_;
 145
 146   DISALLOW_COPY_AND_ASSIGN(TransportConnectJobHelper);
 147 };
 148
 149 // TransportConnectJob handles the host resolution necessary for socket creation
 150 // and the transport (likely TCP) connect. TransportConnectJob also has fallback
 151 // logic for IPv6 connect() timeouts (which may happen due to networks / routers
 152 // with broken IPv6 support). Those timeouts take 20s, so rather than make the
 153 // user wait 20s for the timeout to fire, we use a fallback timer
 154 // (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer
 155 // fires. Then we race the IPv4 connect() against the IPv6 connect() (which has
 156 // a headstart) and return the one that completes first to the socket pool.
 157 class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
 158  public:
 159   TransportConnectJob(const std::string& group_name,
 160                       RequestPriority priority,
 161                       const scoped_refptr<TransportSocketParams>& params,
 162                       base::TimeDelta timeout_duration,
 163                       ClientSocketFactory* client_socket_factory,
 164                       HostResolver* host_resolver,
 165                       Delegate* delegate,
 166                       NetLog* net_log);
 167   virtual ~TransportConnectJob();
 168
 169   // ConnectJob methods.
 170   virtual LoadState GetLoadState() const OVERRIDE;
 171
 172   // Rolls |addrlist| forward until the first IPv4 address, if any.
 173   // WARNING: this method should only be used to implement the prefer-IPv4 hack.
 174   static void MakeAddressListStartWithIPv4(AddressList* addrlist);
 175
 176  private:
 177   enum ConnectInterval {
 178     CONNECT_INTERVAL_LE_10MS,
 179     CONNECT_INTERVAL_LE_20MS,
 180     CONNECT_INTERVAL_GT_20MS,
 181   };
 182
 183   friend class TransportConnectJobHelper;
 184
 185   int DoResolveHost();
 186   int DoResolveHostComplete(int result);
 187   int DoTransportConnect();
 188   int DoTransportConnectComplete(int result);
 189
 190   // Not part of the state machine.
 191   void DoIPv6FallbackTransportConnect();
 192   void DoIPv6FallbackTransportConnectComplete(int result);
 193
 194   // Begins the host resolution and the TCP connect.  Returns OK on success
 195   // and ERR_IO_PENDING if it cannot immediately service the request.
 196   // Otherwise, it returns a net error code.
 197   virtual int ConnectInternal() OVERRIDE;
 198
 199   TransportConnectJobHelper helper_;
 200
 201   scoped_ptr<StreamSocket> transport_socket_;
 202
 203   scoped_ptr<StreamSocket> fallback_transport_socket_;
 204   scoped_ptr<AddressList> fallback_addresses_;
 205   base::TimeTicks fallback_connect_start_time_;
 206   base::OneShotTimer<TransportConnectJob> fallback_timer_;
 207
 208   // Track the interval between this connect and previous connect.
 209   ConnectInterval interval_between_connects_;
 210
 211   DISALLOW_COPY_AND_ASSIGN(TransportConnectJob);
 212 };
 213
 214 class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool {
 215  public:
 216   typedef TransportSocketParams SocketParams;
 217
 218   TransportClientSocketPool(
 219       int max_sockets,
 220       int max_sockets_per_group,
 221       ClientSocketPoolHistograms* histograms,
 222       HostResolver* host_resolver,
 223       ClientSocketFactory* client_socket_factory,
 224       NetLog* net_log);
 225
 226   virtual ~TransportClientSocketPool();
 227
 228   // ClientSocketPool implementation.
 229   virtual int RequestSocket(const std::string& group_name,
 230                             const void* resolve_info,
 231                             RequestPriority priority,
 232                             ClientSocketHandle* handle,
 233                             const CompletionCallback& callback,
 234                             const BoundNetLog& net_log) OVERRIDE;
 235   virtual void RequestSockets(const std::string& group_name,
 236                               const void* params,
 237                               int num_sockets,
 238                               const BoundNetLog& net_log) OVERRIDE;
 239   virtual void CancelRequest(const std::string& group_name,
 240                              ClientSocketHandle* handle) OVERRIDE;
 241   virtual void ReleaseSocket(const std::string& group_name,
 242                              scoped_ptr<StreamSocket> socket,
 243                              int id) OVERRIDE;
 244   virtual void FlushWithError(int error) OVERRIDE;
 245   virtual void CloseIdleSockets() OVERRIDE;
 246   virtual int IdleSocketCount() const OVERRIDE;
 247   virtual int IdleSocketCountInGroup(
 248       const std::string& group_name) const OVERRIDE;
 249   virtual LoadState GetLoadState(
 250       const std::string& group_name,
 251       const ClientSocketHandle* handle) const OVERRIDE;
 252   virtual base::DictionaryValue* GetInfoAsValue(
 253       const std::string& name,
 254       const std::string& type,
 255       bool include_nested_pools) const OVERRIDE;
 256   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 257   virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
 258
 259   // HigherLayeredPool implementation.
 260   virtual bool IsStalled() const OVERRIDE;
 261   virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 262   virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 263
 264  protected:
 265   // Methods shared with WebSocketTransportClientSocketPool
 266   void NetLogTcpClientSocketPoolRequestedSocket(
 267       const BoundNetLog& net_log,
 268       const scoped_refptr<TransportSocketParams>* casted_params);
 269
 270  private:
 271   typedef ClientSocketPoolBase<TransportSocketParams> PoolBase;
 272
 273   class TransportConnectJobFactory
 274       : public PoolBase::ConnectJobFactory {
 275    public:
 276     TransportConnectJobFactory(ClientSocketFactory* client_socket_factory,
 277                          HostResolver* host_resolver,
 278                          NetLog* net_log)
 279         : client_socket_factory_(client_socket_factory),
 280           host_resolver_(host_resolver),
 281           net_log_(net_log) {}
 282
 283     virtual ~TransportConnectJobFactory() {}
 284
 285     // ClientSocketPoolBase::ConnectJobFactory methods.
 286
 287     virtual scoped_ptr<ConnectJob> NewConnectJob(
 288         const std::string& group_name,
 289         const PoolBase::Request& request,
 290         ConnectJob::Delegate* delegate) const OVERRIDE;
 291
 292     virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 293
 294    private:
 295     ClientSocketFactory* const client_socket_factory_;
 296     HostResolver* const host_resolver_;
 297     NetLog* net_log_;
 298
 299     DISALLOW_COPY_AND_ASSIGN(TransportConnectJobFactory);
 300   };
 301
 302   PoolBase base_;
 303
 304   DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool);
 305 };
 306
 307 template <class T>
 308 int TransportConnectJobHelper::DoConnectInternal(T* job) {
 309   next_state_ = STATE_RESOLVE_HOST;
 310   return this->DoLoop(job, OK);
 311 }
 312
 313 template <class T>
 314 void TransportConnectJobHelper::SetOnIOComplete(T* job) {
 315   // These usages of base::Unretained() are safe because IO callbacks are
 316   // guaranteed not to be called after the object is destroyed.
 317   on_io_complete_ = base::Bind(&TransportConnectJobHelper::OnIOComplete<T>,
 318                                base::Unretained(this),
 319                                base::Unretained(job));
 320 }
 321
 322 template <class T>
 323 void TransportConnectJobHelper::OnIOComplete(T* job, int result) {
 324   result = this->DoLoop(job, result);
 325   if (result != ERR_IO_PENDING)
 326     job->NotifyDelegateOfCompletion(result);  // Deletes |job| and |this|
 327 }
 328
 329 template <class T>
 330 int TransportConnectJobHelper::DoLoop(T* job, int result) {
 331   DCHECK_NE(next_state_, STATE_NONE);
 332
 333   int rv = result;
 334   do {
 335     State state = next_state_;
 336     next_state_ = STATE_NONE;
 337     switch (state) {
 338       case STATE_RESOLVE_HOST:
 339         DCHECK_EQ(OK, rv);
 340         rv = job->DoResolveHost();
 341         break;
 342       case STATE_RESOLVE_HOST_COMPLETE:
 343         rv = job->DoResolveHostComplete(rv);
 344         break;
 345       case STATE_TRANSPORT_CONNECT:
 346         DCHECK_EQ(OK, rv);
 347         rv = job->DoTransportConnect();
 348         break;
 349       case STATE_TRANSPORT_CONNECT_COMPLETE:
 350         rv = job->DoTransportConnectComplete(rv);
 351         break;
 352       default:
 353         NOTREACHED();
 354         rv = ERR_FAILED;
 355         break;
 356     }
 357   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 358
 359   return rv;
 360 }
 361
 362 }  // namespace net
 363
 364 #endif  // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_