net/http/http_proxy_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_HTTP_HTTP_PROXY_CLIENT_SOCKET_POOL_H_
   6 #define NET_HTTP_HTTP_PROXY_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/memory/weak_ptr.h"
  14 #include "base/time/time.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/base/net_export.h"
  17 #include "net/http/http_auth.h"
  18 #include "net/http/http_response_info.h"
  19 #include "net/http/proxy_client_socket.h"
  20 #include "net/socket/client_socket_pool.h"
  21 #include "net/socket/client_socket_pool_base.h"
  22 #include "net/socket/client_socket_pool_histograms.h"
  23 #include "net/socket/ssl_client_socket.h"
  24 #include "net/spdy/spdy_session.h"
  25
  26 namespace net {
  27
  28 class HostResolver;
  29 class HttpAuthCache;
  30 class HttpAuthHandlerFactory;
  31 class ProxyDelegate;
  32 class SSLClientSocketPool;
  33 class SSLSocketParams;
  34 class SpdySessionPool;
  35 class SpdyStream;
  36 class TransportClientSocketPool;
  37 class TransportSocketParams;
  38
  39 // HttpProxySocketParams only needs the socket params for one of the proxy
  40 // types.  The other param must be NULL.  When using an HTTP Proxy,
  41 // |transport_params| must be set.  When using an HTTPS Proxy, |ssl_params|
  42 // must be set.
  43 class NET_EXPORT_PRIVATE HttpProxySocketParams
  44     : public base::RefCounted<HttpProxySocketParams> {
  45  public:
  46   HttpProxySocketParams(
  47       const scoped_refptr<TransportSocketParams>& transport_params,
  48       const scoped_refptr<SSLSocketParams>& ssl_params,
  49       const GURL& request_url,
  50       const std::string& user_agent,
  51       const HostPortPair& endpoint,
  52       HttpAuthCache* http_auth_cache,
  53       HttpAuthHandlerFactory* http_auth_handler_factory,
  54       SpdySessionPool* spdy_session_pool,
  55       bool tunnel,
  56       ProxyDelegate* proxy_delegate);
  57
  58   const scoped_refptr<TransportSocketParams>& transport_params() const {
  59     return transport_params_;
  60   }
  61   const scoped_refptr<SSLSocketParams>& ssl_params() const {
  62     return ssl_params_;
  63   }
  64   const GURL& request_url() const { return request_url_; }
  65   const std::string& user_agent() const { return user_agent_; }
  66   const HostPortPair& endpoint() const { return endpoint_; }
  67   HttpAuthCache* http_auth_cache() const { return http_auth_cache_; }
  68   HttpAuthHandlerFactory* http_auth_handler_factory() const {
  69     return http_auth_handler_factory_;
  70   }
  71   SpdySessionPool* spdy_session_pool() {
  72     return spdy_session_pool_;
  73   }
  74   const HostResolver::RequestInfo& destination() const;
  75   bool tunnel() const { return tunnel_; }
  76   bool ignore_limits() const { return ignore_limits_; }
  77
  78   ProxyDelegate* proxy_delegate() const {
  79     return proxy_delegate_;
  80   }
  81
  82  private:
  83   friend class base::RefCounted<HttpProxySocketParams>;
  84   ~HttpProxySocketParams();
  85
  86   const scoped_refptr<TransportSocketParams> transport_params_;
  87   const scoped_refptr<SSLSocketParams> ssl_params_;
  88   SpdySessionPool* spdy_session_pool_;
  89   const GURL request_url_;
  90   const std::string user_agent_;
  91   const HostPortPair endpoint_;
  92   HttpAuthCache* const http_auth_cache_;
  93   HttpAuthHandlerFactory* const http_auth_handler_factory_;
  94   const bool tunnel_;
  95   bool ignore_limits_;
  96   ProxyDelegate* proxy_delegate_;
  97
  98   DISALLOW_COPY_AND_ASSIGN(HttpProxySocketParams);
  99 };
 100
 101 // HttpProxyConnectJob optionally establishes a tunnel through the proxy
 102 // server after connecting the underlying transport socket.
 103 class HttpProxyConnectJob : public ConnectJob {
 104  public:
 105   HttpProxyConnectJob(const std::string& group_name,
 106                       RequestPriority priority,
 107                       const scoped_refptr<HttpProxySocketParams>& params,
 108                       const base::TimeDelta& timeout_duration,
 109                       TransportClientSocketPool* transport_pool,
 110                       SSLClientSocketPool* ssl_pool,
 111                       HostResolver* host_resolver,
 112                       Delegate* delegate,
 113                       NetLog* net_log);
 114   virtual ~HttpProxyConnectJob();
 115
 116   // ConnectJob methods.
 117   virtual LoadState GetLoadState() const OVERRIDE;
 118
 119   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE;
 120
 121  private:
 122   enum State {
 123     STATE_TCP_CONNECT,
 124     STATE_TCP_CONNECT_COMPLETE,
 125     STATE_SSL_CONNECT,
 126     STATE_SSL_CONNECT_COMPLETE,
 127     STATE_HTTP_PROXY_CONNECT,
 128     STATE_HTTP_PROXY_CONNECT_COMPLETE,
 129     STATE_SPDY_PROXY_CREATE_STREAM,
 130     STATE_SPDY_PROXY_CREATE_STREAM_COMPLETE,
 131     STATE_SPDY_PROXY_CONNECT_COMPLETE,
 132     STATE_NONE,
 133   };
 134
 135   void OnIOComplete(int result);
 136
 137   // Runs the state transition loop.
 138   int DoLoop(int result);
 139
 140   // Connecting to HTTP Proxy
 141   int DoTransportConnect();
 142   int DoTransportConnectComplete(int result);
 143   // Connecting to HTTPS Proxy
 144   int DoSSLConnect();
 145   int DoSSLConnectComplete(int result);
 146
 147   int DoHttpProxyConnect();
 148   int DoHttpProxyConnectComplete(int result);
 149
 150   int DoSpdyProxyCreateStream();
 151   int DoSpdyProxyCreateStreamComplete(int result);
 152
 153   // Begins the tcp connection and the optional Http proxy tunnel.  If the
 154   // request is not immediately servicable (likely), the request will return
 155   // ERR_IO_PENDING. An OK return from this function or the callback means
 156   // that the connection is established; ERR_PROXY_AUTH_REQUESTED means
 157   // that the tunnel needs authentication credentials, the socket will be
 158   // returned in this case, and must be release back to the pool; or
 159   // a standard net error code will be returned.
 160   virtual int ConnectInternal() OVERRIDE;
 161
 162   scoped_refptr<HttpProxySocketParams> params_;
 163   TransportClientSocketPool* const transport_pool_;
 164   SSLClientSocketPool* const ssl_pool_;
 165   HostResolver* const resolver_;
 166
 167   State next_state_;
 168   CompletionCallback callback_;
 169   scoped_ptr<ClientSocketHandle> transport_socket_handle_;
 170   scoped_ptr<ProxyClientSocket> transport_socket_;
 171   bool using_spdy_;
 172   // Protocol negotiated with the server.
 173   NextProto protocol_negotiated_;
 174
 175   HttpResponseInfo error_response_info_;
 176
 177   SpdyStreamRequest spdy_stream_request_;
 178
 179   base::WeakPtrFactory<HttpProxyConnectJob> weak_ptr_factory_;
 180
 181   DISALLOW_COPY_AND_ASSIGN(HttpProxyConnectJob);
 182 };
 183
 184 class NET_EXPORT_PRIVATE HttpProxyClientSocketPool
 185     : public ClientSocketPool,
 186       public HigherLayeredPool {
 187  public:
 188   typedef HttpProxySocketParams SocketParams;
 189
 190   HttpProxyClientSocketPool(
 191       int max_sockets,
 192       int max_sockets_per_group,
 193       ClientSocketPoolHistograms* histograms,
 194       HostResolver* host_resolver,
 195       TransportClientSocketPool* transport_pool,
 196       SSLClientSocketPool* ssl_pool,
 197       const ProxyDelegate* proxy_delegate,
 198       NetLog* net_log);
 199
 200   virtual ~HttpProxyClientSocketPool();
 201
 202   // ClientSocketPool implementation.
 203   virtual int RequestSocket(const std::string& group_name,
 204                             const void* connect_params,
 205                             RequestPriority priority,
 206                             ClientSocketHandle* handle,
 207                             const CompletionCallback& callback,
 208                             const BoundNetLog& net_log) OVERRIDE;
 209
 210   virtual void RequestSockets(const std::string& group_name,
 211                               const void* params,
 212                               int num_sockets,
 213                               const BoundNetLog& net_log) OVERRIDE;
 214
 215   virtual void CancelRequest(const std::string& group_name,
 216                              ClientSocketHandle* handle) OVERRIDE;
 217
 218   virtual void ReleaseSocket(const std::string& group_name,
 219                              scoped_ptr<StreamSocket> socket,
 220                              int id) OVERRIDE;
 221
 222   virtual void FlushWithError(int error) OVERRIDE;
 223
 224   virtual void CloseIdleSockets() OVERRIDE;
 225
 226   virtual int IdleSocketCount() const OVERRIDE;
 227
 228   virtual int IdleSocketCountInGroup(
 229       const std::string& group_name) const OVERRIDE;
 230
 231   virtual LoadState GetLoadState(
 232       const std::string& group_name,
 233       const ClientSocketHandle* handle) const OVERRIDE;
 234
 235   virtual base::DictionaryValue* GetInfoAsValue(
 236       const std::string& name,
 237       const std::string& type,
 238       bool include_nested_pools) const OVERRIDE;
 239
 240   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 241
 242   virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
 243
 244   // LowerLayeredPool implementation.
 245   virtual bool IsStalled() const OVERRIDE;
 246
 247   virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 248
 249   virtual void RemoveHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE;
 250
 251   // HigherLayeredPool implementation.
 252   virtual bool CloseOneIdleConnection() OVERRIDE;
 253
 254  private:
 255   typedef ClientSocketPoolBase<HttpProxySocketParams> PoolBase;
 256
 257   class HttpProxyConnectJobFactory : public PoolBase::ConnectJobFactory {
 258    public:
 259     HttpProxyConnectJobFactory(
 260         TransportClientSocketPool* transport_pool,
 261         SSLClientSocketPool* ssl_pool,
 262         HostResolver* host_resolver,
 263         const ProxyDelegate* proxy_delegate,
 264         NetLog* net_log);
 265
 266     // ClientSocketPoolBase::ConnectJobFactory methods.
 267     virtual scoped_ptr<ConnectJob> NewConnectJob(
 268         const std::string& group_name,
 269         const PoolBase::Request& request,
 270         ConnectJob::Delegate* delegate) const OVERRIDE;
 271
 272     virtual base::TimeDelta ConnectionTimeout() const OVERRIDE;
 273
 274    private:
 275     TransportClientSocketPool* const transport_pool_;
 276     SSLClientSocketPool* const ssl_pool_;
 277     HostResolver* const host_resolver_;
 278     const ProxyDelegate* proxy_delegate_;
 279     NetLog* net_log_;
 280     base::TimeDelta timeout_;
 281
 282     DISALLOW_COPY_AND_ASSIGN(HttpProxyConnectJobFactory);
 283   };
 284
 285   TransportClientSocketPool* const transport_pool_;
 286   SSLClientSocketPool* const ssl_pool_;
 287   PoolBase base_;
 288
 289   DISALLOW_COPY_AND_ASSIGN(HttpProxyClientSocketPool);
 290 };
 291
 292 }  // namespace net
 293
 294 #endif  // NET_HTTP_HTTP_PROXY_CLIENT_SOCKET_POOL_H_