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.
5 #ifndef NET_SPDY_SPDY_SESSION_POOL_H_
6 #define NET_SPDY_SPDY_SESSION_POOL_H_
13 #include "base/basictypes.h"
14 #include "base/gtest_prod_util.h"
15 #include "base/memory/ref_counted.h"
16 #include "base/memory/weak_ptr.h"
17 #include "net/base/host_port_pair.h"
18 #include "net/base/ip_endpoint.h"
19 #include "net/base/net_errors.h"
20 #include "net/base/net_export.h"
21 #include "net/base/network_change_notifier.h"
22 #include "net/cert/cert_database.h"
23 #include "net/proxy/proxy_config.h"
24 #include "net/proxy/proxy_server.h"
25 #include "net/socket/next_proto.h"
26 #include "net/spdy/spdy_session_key.h"
27 #include "net/ssl/ssl_config_service.h"
33 class ClientSocketHandle;
35 class HttpServerProperties;
38 // This is a very simple pool for open SpdySessions.
39 class NET_EXPORT SpdySessionPool
40 : public NetworkChangeNotifier::IPAddressObserver,
41 public SSLConfigService::Observer,
42 public CertDatabase::Observer {
44 typedef base::TimeTicks (*TimeFunc)(void);
46 // |default_protocol| may be kProtoUnknown (e.g., if SPDY is
47 // disabled), in which case it's set to a default value. Otherwise,
48 // it must be a SPDY protocol.
50 HostResolver* host_resolver,
51 SSLConfigService* ssl_config_service,
52 const base::WeakPtr<HttpServerProperties>& http_server_properties,
53 bool force_single_domain,
54 bool enable_ip_pooling,
55 bool enable_compression,
56 bool enable_ping_based_connection_checking,
57 NextProto default_protocol,
58 size_t stream_initial_recv_window_size,
59 size_t initial_max_concurrent_streams,
60 size_t max_concurrent_streams_limit,
61 SpdySessionPool::TimeFunc time_func,
62 const std::string& trusted_spdy_proxy);
63 virtual ~SpdySessionPool();
65 // In the functions below, a session is "available" if this pool has
66 // a reference to it and there is some SpdySessionKey for which
67 // FindAvailableSession() will return it. A session is "unavailable"
68 // if this pool has a reference to it but it won't be returned by
69 // FindAvailableSession() for any SpdySessionKey; for example, this
70 // can happen when a session receives a GOAWAY frame and is still
71 // processing existing streams.
73 // Create a new SPDY session from an existing socket. There must
74 // not already be a session for the given key. This pool must have
75 // been constructed with a valid |default_protocol| value.
77 // |is_secure| can be false for testing or when SPDY is configured
78 // to work with non-secure sockets. If |is_secure| is true,
79 // |certificate_error_code| indicates that the certificate error
80 // encountered when connecting the SSL socket, with OK meaning there
83 // If successful, OK is returned and |available_session| will be
84 // non-NULL and available. Otherwise, an error is returned and
85 // |available_session| will be NULL.
86 net::Error CreateAvailableSessionFromSocket(
87 const SpdySessionKey& key,
88 scoped_ptr<ClientSocketHandle> connection,
89 const BoundNetLog& net_log,
90 int certificate_error_code,
91 base::WeakPtr<SpdySession>* available_session,
94 // Find an available session for the given key, or NULL if there isn't one.
95 base::WeakPtr<SpdySession> FindAvailableSession(const SpdySessionKey& key,
96 const BoundNetLog& net_log);
98 // Remove all mappings and aliases for the given session, which must
99 // still be available. Except for in tests, this must be called by
100 // the given session itself.
101 void MakeSessionUnavailable(
102 const base::WeakPtr<SpdySession>& available_session);
104 // Removes an unavailable session from the pool. Except for in
105 // tests, this must be called by the given session itself.
106 void RemoveUnavailableSession(
107 const base::WeakPtr<SpdySession>& unavailable_session);
109 // Close only the currently existing SpdySessions with |error|.
110 // Let any new ones created while this method is running continue to
112 void CloseCurrentSessions(net::Error error);
114 // Close only the currently existing SpdySessions that are idle.
115 // Let any new ones created while this method is running continue to
117 void CloseCurrentIdleSessions();
119 // Close all SpdySessions, including any new ones created in the process of
120 // closing the current ones.
121 void CloseAllSessions();
123 // Creates a Value summary of the state of the spdy session pool. The caller
124 // responsible for deleting the returned value.
125 base::Value* SpdySessionPoolInfoToValue() const;
127 base::WeakPtr<HttpServerProperties> http_server_properties() {
128 return http_server_properties_;
131 // NetworkChangeNotifier::IPAddressObserver methods:
133 // We flush all idle sessions and release references to the active ones so
134 // they won't get re-used. The active ones will either complete successfully
135 // or error out due to the IP address change.
136 virtual void OnIPAddressChanged() OVERRIDE;
138 // SSLConfigService::Observer methods:
140 // We perform the same flushing as described above when SSL settings change.
141 virtual void OnSSLConfigChanged() OVERRIDE;
143 // CertDatabase::Observer methods:
144 virtual void OnCertAdded(const X509Certificate* cert) OVERRIDE;
145 virtual void OnCACertChanged(const X509Certificate* cert) OVERRIDE;
148 friend class SpdySessionPoolPeer; // For testing.
150 typedef std::set<SpdySession*> SessionSet;
151 typedef std::vector<base::WeakPtr<SpdySession> > WeakSessionList;
152 typedef std::map<SpdySessionKey, base::WeakPtr<SpdySession> >
154 typedef std::map<IPEndPoint, SpdySessionKey> AliasMap;
156 // Returns true iff |session| is in |available_sessions_|.
157 bool IsSessionAvailable(const base::WeakPtr<SpdySession>& session) const;
159 // Returns a normalized version of the given key suitable for lookup
160 // into |available_sessions_|.
161 const SpdySessionKey& NormalizeListKey(const SpdySessionKey& key) const;
163 // Map the given key to the given session. There must not already be
164 // a mapping for |key|.
165 void MapKeyToAvailableSession(const SpdySessionKey& key,
166 const base::WeakPtr<SpdySession>& session);
168 // Returns an iterator into |available_sessions_| for the given key,
169 // which may be equal to |available_sessions_.end()|.
170 AvailableSessionMap::iterator LookupAvailableSessionByKey(
171 const SpdySessionKey& key);
173 // Remove the mapping of the given key, which must exist.
174 void UnmapKey(const SpdySessionKey& key);
176 // Remove all aliases for |key| from the aliases table.
177 void RemoveAliases(const SpdySessionKey& key);
179 // Get a copy of the current sessions as a list of WeakPtrs. Used by
180 // CloseCurrentSessionsHelper() below.
181 WeakSessionList GetCurrentSessions() const;
183 // Close only the currently existing SpdySessions with |error|. Let
184 // any new ones created while this method is running continue to
185 // live. If |idle_only| is true only idle sessions are closed.
186 void CloseCurrentSessionsHelper(
188 const std::string& description,
191 const base::WeakPtr<HttpServerProperties> http_server_properties_;
193 // The set of all sessions. This is a superset of the sessions in
194 // |available_sessions_|.
196 // |sessions_| owns all its SpdySession objects.
197 SessionSet sessions_;
199 // This is a map of available sessions by key. A session may appear
200 // more than once in this map if it has aliases.
201 AvailableSessionMap available_sessions_;
203 // A map of IPEndPoint aliases for sessions.
206 static bool g_force_single_domain;
208 const scoped_refptr<SSLConfigService> ssl_config_service_;
209 HostResolver* const resolver_;
211 // Defaults to true. May be controlled via SpdySessionPoolPeer for tests.
212 bool verify_domain_authentication_;
213 bool enable_sending_initial_data_;
214 bool force_single_domain_;
215 bool enable_ip_pooling_;
216 bool enable_compression_;
217 bool enable_ping_based_connection_checking_;
218 const NextProto default_protocol_;
219 size_t stream_initial_recv_window_size_;
220 size_t initial_max_concurrent_streams_;
221 size_t max_concurrent_streams_limit_;
224 // This SPDY proxy is allowed to push resources from origins that are
225 // different from those of their associated streams.
226 HostPortPair trusted_spdy_proxy_;
228 DISALLOW_COPY_AND_ASSIGN(SpdySessionPool);
233 #endif // NET_SPDY_SPDY_SESSION_POOL_H_