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   // |host_resolution_callback| will be invoked after the the hostname is
  33   // resolved.  If |host_resolution_callback| does not return OK, then the
  34   // connection will be aborted with that value.
  35   TransportSocketParams(
  36       const HostPortPair& host_port_pair,
  37       bool disable_resolver_cache,
  38       bool ignore_limits,
  39       const OnHostResolutionCallback& host_resolution_callback);
  40
  41   const HostResolver::RequestInfo& destination() const { return destination_; }
  42   bool ignore_limits() const { return ignore_limits_; }
  43   const OnHostResolutionCallback& host_resolution_callback() const {
  44     return host_resolution_callback_;
  45   }
  46
  47  private:
  48   friend class base::RefCounted<TransportSocketParams>;
  49   ~TransportSocketParams();
  50
  51   HostResolver::RequestInfo destination_;
  52   bool ignore_limits_;
  53   const OnHostResolutionCallback host_resolution_callback_;
  54
  55   DISALLOW_COPY_AND_ASSIGN(TransportSocketParams);
  56 };
  57
  58 // TransportConnectJob handles the host resolution necessary for socket creation
  59 // and the transport (likely TCP) connect. TransportConnectJob also has fallback
  60 // logic for IPv6 connect() timeouts (which may happen due to networks / routers
  61 // with broken IPv6 support). Those timeouts take 20s, so rather than make the
  62 // user wait 20s for the timeout to fire, we use a fallback timer
  63 // (kIPv6FallbackTimerInMs) and start a connect() to a IPv4 address if the timer
  64 // fires. Then we race the IPv4 connect() against the IPv6 connect() (which has
  65 // a headstart) and return the one that completes first to the socket pool.
  66 class NET_EXPORT_PRIVATE TransportConnectJob : public ConnectJob {
  67  public:
  68   TransportConnectJob(const std::string& group_name,
  69                       RequestPriority priority,
  70                       const scoped_refptr<TransportSocketParams>& params,
  71                       base::TimeDelta timeout_duration,
  72                       ClientSocketFactory* client_socket_factory,
  73                       HostResolver* host_resolver,
  74                       Delegate* delegate,
  75                       NetLog* net_log);
  76   virtual ~TransportConnectJob();
  77
  78   // ConnectJob methods.
  79   virtual LoadState GetLoadState() const OVERRIDE;
  80
  81   // Rolls |addrlist| forward until the first IPv4 address, if any.
  82   // WARNING: this method should only be used to implement the prefer-IPv4 hack.
  83   static void MakeAddressListStartWithIPv4(AddressList* addrlist);
  84
  85   static const int kIPv6FallbackTimerInMs;
  86
  87  private:
  88   enum State {
  89     STATE_RESOLVE_HOST,
  90     STATE_RESOLVE_HOST_COMPLETE,
  91     STATE_TRANSPORT_CONNECT,
  92     STATE_TRANSPORT_CONNECT_COMPLETE,
  93     STATE_NONE,
  94   };
  95
  96   enum ConnectInterval {
  97     CONNECT_INTERVAL_LE_10MS,
  98     CONNECT_INTERVAL_LE_20MS,
  99     CONNECT_INTERVAL_GT_20MS,
 100   };
 101
 102   void OnIOComplete(int result);
 103
 104   // Runs the state transition loop.
 105   int DoLoop(int result);
 106
 107   int DoResolveHost();
 108   int DoResolveHostComplete(int result);
 109   int DoTransportConnect();
 110   int DoTransportConnectComplete(int result);
 111
 112   // Not part of the state machine.
 113   void DoIPv6FallbackTransportConnect();
 114   void DoIPv6FallbackTransportConnectComplete(int result);
 115
 116   // Begins the host resolution and the TCP connect.  Returns OK on success
 117   // and ERR_IO_PENDING if it cannot immediately service the request.
 118   // Otherwise, it returns a net error code.
 119   virtual int ConnectInternal() OVERRIDE;
 120
 121   scoped_refptr<TransportSocketParams> params_;
 122   ClientSocketFactory* const client_socket_factory_;
 123   SingleRequestHostResolver resolver_;
 124   AddressList addresses_;
 125   State next_state_;
 126
 127   scoped_ptr<StreamSocket> transport_socket_;
 128
 129   scoped_ptr<StreamSocket> fallback_transport_socket_;
 130   scoped_ptr<AddressList> fallback_addresses_;
 131   base::TimeTicks fallback_connect_start_time_;
 132   base::OneShotTimer<TransportConnectJob> fallback_timer_;
 133
 134   // Track the interval between this connect and previous connect.
 135   ConnectInterval interval_between_connects_;
 136
 137   DISALLOW_COPY_AND_ASSIGN(TransportConnectJob);
 138 };
 139
 140 class NET_EXPORT_PRIVATE TransportClientSocketPool : public ClientSocketPool {
 141  public:
 142   typedef TransportSocketParams SocketParams;
 143
 144   TransportClientSocketPool(
 145       int max_sockets,
 146       int max_sockets_per_group,
 147       ClientSocketPoolHistograms* histograms,
 148       HostResolver* host_resolver,
 149       ClientSocketFactory* client_socket_factory,
 150       NetLog* net_log);
 151
 152   virtual ~TransportClientSocketPool();
 153
 154   // ClientSocketPool implementation.
 155   virtual int RequestSocket(const std::string& group_name,
 156                             const void* resolve_info,
 157                             RequestPriority priority,
 158                             ClientSocketHandle* handle,
 159                             const CompletionCallback& callback,
 160                             const BoundNetLog& net_log) OVERRIDE;
 161   virtual void RequestSockets(const std::string& group_name,
 162                               const void* params,
 163                               int num_sockets,
 164                               const BoundNetLog& net_log) OVERRIDE;
 165   virtual void CancelRequest(const std::string& group_name,
 166                              ClientSocketHandle* handle) OVERRIDE;
 167   virtual void ReleaseSocket(const std::string& group_name,
 168                              scoped_ptr<StreamSocket> socket,
 169                              int id) OVERRIDE;
 170   virtual void FlushWithError(int error) OVERRIDE;
 171   virtual void CloseIdleSockets() OVERRIDE;
 172   virtual int IdleSocketCount() const OVERRIDE;
 173   virtual int IdleSocketCountInGroup(
 174       const std::string& group_name) const OVERRIDE;
 175   virtual LoadState GetLoadState(
 176       const std::string& group_name,
 177       const ClientSocketHandle* handle) const OVERRIDE;
 178   virtual base::DictionaryValue* GetInfoAsValue(
 179       const std::string& name,
 180       const std::string& type,
 181       bool include_nested_pools) const OVERRIDE;
 182   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 183   virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
 184
 185   // HigherLayeredPool implementation.
 186   virtual bool IsStalled() const OVERRIDE;
 187   virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 188   virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 189
 190  private:
 191   typedef ClientSocketPoolBase<TransportSocketParams> PoolBase;
 192
 193   class TransportConnectJobFactory
 194       : public PoolBase::ConnectJobFactory {
 195    public:
 196     TransportConnectJobFactory(ClientSocketFactory* client_socket_factory,
 197                          HostResolver* host_resolver,
 198                          NetLog* net_log)
 199         : client_socket_factory_(client_socket_factory),
 200           host_resolver_(host_resolver),
 201           net_log_(net_log) {}
 202
 203     virtual ~TransportConnectJobFactory() {}
 204
 205     // ClientSocketPoolBase::ConnectJobFactory methods.
 206
 207     virtual scoped_ptr<ConnectJob> NewConnectJob(
 208         const std::string& group_name,
 209         const PoolBase::Request& request,
 210         ConnectJob::Delegate* delegate) const OVERRIDE;
 211
 212     virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 213
 214    private:
 215     ClientSocketFactory* const client_socket_factory_;
 216     HostResolver* const host_resolver_;
 217     NetLog* net_log_;
 218
 219     DISALLOW_COPY_AND_ASSIGN(TransportConnectJobFactory);
 220   };
 221
 222   PoolBase base_;
 223
 224   DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPool);
 225 };
 226
 227 }  // namespace net
 228
 229 #endif  // NET_SOCKET_TRANSPORT_CLIENT_SOCKET_POOL_H_