Home | History | Annotate | Download | only in http 
      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_NETWORK_SESSION_H_
      6 #define NET_HTTP_HTTP_NETWORK_SESSION_H_
      7 
      8 #include <set>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/memory/weak_ptr.h"
     15 #include "base/threading/non_thread_safe.h"
     16 #include "net/base/host_port_pair.h"
     17 #include "net/base/net_export.h"
     18 #include "net/dns/host_resolver.h"
     19 #include "net/http/http_auth_cache.h"
     20 #include "net/http/http_stream_factory.h"
     21 #include "net/quic/quic_stream_factory.h"
     22 #include "net/socket/next_proto.h"
     23 #include "net/spdy/spdy_session_pool.h"
     24 #include "net/ssl/ssl_client_auth_cache.h"
     25 
     26 namespace base {
     27 class Value;
     28 }
     29 
     30 namespace net {
     31 
     32 class CertVerifier;
     33 class ClientSocketFactory;
     34 class ClientSocketPoolManager;
     35 class CTVerifier;
     36 class HostResolver;
     37 class HpackHuffmanAggregator;
     38 class HttpAuthHandlerFactory;
     39 class HttpNetworkSessionPeer;
     40 class HttpProxyClientSocketPool;
     41 class HttpResponseBodyDrainer;
     42 class HttpServerProperties;
     43 class NetLog;
     44 class NetworkDelegate;
     45 class ServerBoundCertService;
     46 class ProxyService;
     47 class QuicClock;
     48 class QuicCryptoClientStreamFactory;
     49 class QuicServerInfoFactory;
     50 class SOCKSClientSocketPool;
     51 class SSLClientSocketPool;
     52 class SSLConfigService;
     53 class TransportClientSocketPool;
     54 class TransportSecurityState;
     55 
     56 // This class holds session objects used by HttpNetworkTransaction objects.
     57 class NET_EXPORT HttpNetworkSession
     58     : public base::RefCounted<HttpNetworkSession>,
     59       NON_EXPORTED_BASE(public base::NonThreadSafe) {
     60  public:
     61   struct NET_EXPORT Params {
     62     Params();
     63     ~Params();
     64 
     65     ClientSocketFactory* client_socket_factory;
     66     HostResolver* host_resolver;
     67     CertVerifier* cert_verifier;
     68     ServerBoundCertService* server_bound_cert_service;
     69     TransportSecurityState* transport_security_state;
     70     CTVerifier* cert_transparency_verifier;
     71     ProxyService* proxy_service;
     72     std::string ssl_session_cache_shard;
     73     SSLConfigService* ssl_config_service;
     74     HttpAuthHandlerFactory* http_auth_handler_factory;
     75     NetworkDelegate* network_delegate;
     76     base::WeakPtr<HttpServerProperties> http_server_properties;
     77     NetLog* net_log;
     78     HostMappingRules* host_mapping_rules;
     79     bool ignore_certificate_errors;
     80     uint16 testing_fixed_http_port;
     81     uint16 testing_fixed_https_port;
     82 
     83     bool force_spdy_single_domain;
     84     bool enable_spdy_compression;
     85     bool enable_spdy_ping_based_connection_checking;
     86     NextProto spdy_default_protocol;
     87     // The protocols supported by NPN (next protocol negotiation) during the
     88     // SSL handshake as well as by HTTP Alternate-Protocol.
     89     // TODO(mmenke):  This is currently empty by default, and alternate
     90     //                protocols are disabled.  We should use some reasonable
     91     //                defaults.
     92     NextProtoVector next_protos;
     93     size_t spdy_stream_initial_recv_window_size;
     94     size_t spdy_initial_max_concurrent_streams;
     95     size_t spdy_max_concurrent_streams_limit;
     96     SpdySessionPool::TimeFunc time_func;
     97     std::string trusted_spdy_proxy;
     98     // Controls whether or not ssl is used when in SPDY mode.
     99     bool force_spdy_over_ssl;
    100     // Controls whether or not SPDY is used without NPN.
    101     bool force_spdy_always;
    102     // URLs to exclude from forced SPDY.
    103     std::set<HostPortPair> forced_spdy_exclusions;
    104     // Noe: Using this in the case of NPN for HTTP only results in the browser
    105     // trying SSL and then falling back to http.
    106     bool use_alternate_protocols;
    107     bool enable_websocket_over_spdy;
    108 
    109     bool enable_quic;
    110     bool enable_quic_https;
    111     bool enable_quic_port_selection;
    112     bool enable_quic_pacing;
    113     bool enable_quic_time_based_loss_detection;
    114     bool enable_quic_persist_server_info;
    115     HostPortPair origin_to_force_quic_on;
    116     QuicClock* quic_clock;  // Will be owned by QuicStreamFactory.
    117     QuicRandom* quic_random;
    118     size_t quic_max_packet_length;
    119     std::string quic_user_agent_id;
    120     bool enable_user_alternate_protocol_ports;
    121     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory;
    122     QuicVersionVector quic_supported_versions;
    123   };
    124 
    125   enum SocketPoolType {
    126     NORMAL_SOCKET_POOL,
    127     WEBSOCKET_SOCKET_POOL,
    128     NUM_SOCKET_POOL_TYPES
    129   };
    130 
    131   explicit HttpNetworkSession(const Params& params);
    132 
    133   HttpAuthCache* http_auth_cache() { return &http_auth_cache_; }
    134   SSLClientAuthCache* ssl_client_auth_cache() {
    135     return &ssl_client_auth_cache_;
    136   }
    137 
    138   void AddResponseDrainer(HttpResponseBodyDrainer* drainer);
    139 
    140   void RemoveResponseDrainer(HttpResponseBodyDrainer* drainer);
    141 
    142   TransportClientSocketPool* GetTransportSocketPool(SocketPoolType pool_type);
    143   SSLClientSocketPool* GetSSLSocketPool(SocketPoolType pool_type);
    144   SOCKSClientSocketPool* GetSocketPoolForSOCKSProxy(
    145       SocketPoolType pool_type,
    146       const HostPortPair& socks_proxy);
    147   HttpProxyClientSocketPool* GetSocketPoolForHTTPProxy(
    148       SocketPoolType pool_type,
    149       const HostPortPair& http_proxy);
    150   SSLClientSocketPool* GetSocketPoolForSSLWithProxy(
    151       SocketPoolType pool_type,
    152       const HostPortPair& proxy_server);
    153 
    154   CertVerifier* cert_verifier() { return cert_verifier_; }
    155   ProxyService* proxy_service() { return proxy_service_; }
    156   SSLConfigService* ssl_config_service() { return ssl_config_service_.get(); }
    157   SpdySessionPool* spdy_session_pool() { return &spdy_session_pool_; }
    158   QuicStreamFactory* quic_stream_factory() { return &quic_stream_factory_; }
    159   HttpAuthHandlerFactory* http_auth_handler_factory() {
    160     return http_auth_handler_factory_;
    161   }
    162   NetworkDelegate* network_delegate() {
    163     return network_delegate_;
    164   }
    165   base::WeakPtr<HttpServerProperties> http_server_properties() {
    166     return http_server_properties_;
    167   }
    168   HttpStreamFactory* http_stream_factory() {
    169     return http_stream_factory_.get();
    170   }
    171   HttpStreamFactory* http_stream_factory_for_websocket() {
    172     return http_stream_factory_for_websocket_.get();
    173   }
    174   NetLog* net_log() {
    175     return net_log_;
    176   }
    177   HpackHuffmanAggregator* huffman_aggregator() {
    178     return huffman_aggregator_.get();
    179   }
    180 
    181   // Creates a Value summary of the state of the socket pools. The caller is
    182   // responsible for deleting the returned value.
    183   base::Value* SocketPoolInfoToValue() const;
    184 
    185   // Creates a Value summary of the state of the SPDY sessions. The caller is
    186   // responsible for deleting the returned value.
    187   base::Value* SpdySessionPoolInfoToValue() const;
    188 
    189   // Creates a Value summary of the state of the QUIC sessions and
    190   // configuration. The caller is responsible for deleting the returned value.
    191   base::Value* QuicInfoToValue() const;
    192 
    193   void CloseAllConnections();
    194   void CloseIdleConnections();
    195 
    196   // Returns the original Params used to construct this session.
    197   const Params& params() const { return params_; }
    198 
    199   bool IsProtocolEnabled(AlternateProtocol protocol) const;
    200 
    201   void GetNextProtos(std::vector<std::string>* next_protos) const;
    202 
    203   // Convenience function for searching through |params_| for
    204   // |forced_spdy_exclusions|.
    205   bool HasSpdyExclusion(HostPortPair host_port_pair) const;
    206 
    207  private:
    208   friend class base::RefCounted<HttpNetworkSession>;
    209   friend class HttpNetworkSessionPeer;
    210 
    211   ~HttpNetworkSession();
    212 
    213   ClientSocketPoolManager* GetSocketPoolManager(SocketPoolType pool_type);
    214 
    215   NetLog* const net_log_;
    216   NetworkDelegate* const network_delegate_;
    217   const base::WeakPtr<HttpServerProperties> http_server_properties_;
    218   CertVerifier* const cert_verifier_;
    219   HttpAuthHandlerFactory* const http_auth_handler_factory_;
    220 
    221   // Not const since it's modified by HttpNetworkSessionPeer for testing.
    222   ProxyService* proxy_service_;
    223   const scoped_refptr<SSLConfigService> ssl_config_service_;
    224 
    225   HttpAuthCache http_auth_cache_;
    226   SSLClientAuthCache ssl_client_auth_cache_;
    227   scoped_ptr<ClientSocketPoolManager> normal_socket_pool_manager_;
    228   scoped_ptr<ClientSocketPoolManager> websocket_socket_pool_manager_;
    229   QuicStreamFactory quic_stream_factory_;
    230   SpdySessionPool spdy_session_pool_;
    231   scoped_ptr<HttpStreamFactory> http_stream_factory_;
    232   scoped_ptr<HttpStreamFactory> http_stream_factory_for_websocket_;
    233   std::set<HttpResponseBodyDrainer*> response_drainers_;
    234 
    235   // TODO(jgraettinger): Remove when Huffman collection is complete.
    236   scoped_ptr<HpackHuffmanAggregator> huffman_aggregator_;
    237 
    238   std::vector<std::string> next_protos_;
    239   bool enabled_protocols_[NUM_VALID_ALTERNATE_PROTOCOLS];
    240 
    241   Params params_;
    242 };
    243 
    244 }  // namespace net
    245 
    246 #endif  // NET_HTTP_HTTP_NETWORK_SESSION_H_
    247