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_H_
6 #define NET_SPDY_SPDY_SESSION_H_
13 #include "base/basictypes.h"
14 #include "base/gtest_prod_util.h"
15 #include "base/memory/ref_counted.h"
16 #include "base/memory/scoped_ptr.h"
17 #include "base/memory/weak_ptr.h"
18 #include "base/time/time.h"
19 #include "net/base/io_buffer.h"
20 #include "net/base/load_states.h"
21 #include "net/base/net_errors.h"
22 #include "net/base/net_export.h"
23 #include "net/base/request_priority.h"
24 #include "net/socket/client_socket_handle.h"
25 #include "net/socket/client_socket_pool.h"
26 #include "net/socket/next_proto.h"
27 #include "net/socket/ssl_client_socket.h"
28 #include "net/socket/stream_socket.h"
29 #include "net/spdy/buffered_spdy_framer.h"
30 #include "net/spdy/spdy_buffer.h"
31 #include "net/spdy/spdy_framer.h"
32 #include "net/spdy/spdy_header_block.h"
33 #include "net/spdy/spdy_protocol.h"
34 #include "net/spdy/spdy_session_pool.h"
35 #include "net/spdy/spdy_stream.h"
36 #include "net/spdy/spdy_write_queue.h"
37 #include "net/ssl/ssl_config_service.h"
42 // This is somewhat arbitrary and not really fixed, but it will always work
43 // reasonably with ethernet. Chop the world into 2-packet chunks. This is
44 // somewhat arbitrary, but is reasonably small and ensures that we elicit
45 // ACKs quickly from TCP (because TCP tries to only ACK every other packet).
46 const int kMss = 1430;
47 // The 8 is the size of the SPDY frame header.
48 const int kMaxSpdyFrameChunkSize = (2 * kMss) - 8;
50 // Maximum number of concurrent streams we will create, unless the server
51 // sends a SETTINGS frame with a different value.
52 const size_t kInitialMaxConcurrentStreams = 100;
54 // Specifies the maxiumum concurrent streams server could send (via push).
55 const int kMaxConcurrentPushedStreams = 1000;
57 // Specifies the maximum number of bytes to read synchronously before
59 const int kMaxReadBytesWithoutYielding = 32 * 1024;
61 // The initial receive window size for both streams and sessions.
62 const int32 kDefaultInitialRecvWindowSize = 10 * 1024 * 1024; // 10MB
64 // First and last valid stream IDs. As we always act as the client,
65 // start at 1 for the first stream id.
66 const SpdyStreamId kFirstStreamId = 1;
67 const SpdyStreamId kLastStreamId = 0x7fffffff;
70 struct LoadTimingInfo;
73 class TransportSecurityState;
75 // NOTE: There's an enum of the same name (also with numeric suffixes)
76 // in histograms.xml. Be sure to add new values there also.
77 enum SpdyProtocolErrorDetails {
78 // SpdyFramer::SpdyError mappings.
79 SPDY_ERROR_NO_ERROR = 0,
80 SPDY_ERROR_INVALID_CONTROL_FRAME = 1,
81 SPDY_ERROR_CONTROL_PAYLOAD_TOO_LARGE = 2,
82 SPDY_ERROR_ZLIB_INIT_FAILURE = 3,
83 SPDY_ERROR_UNSUPPORTED_VERSION = 4,
84 SPDY_ERROR_DECOMPRESS_FAILURE = 5,
85 SPDY_ERROR_COMPRESS_FAILURE = 6,
86 // SPDY_ERROR_CREDENTIAL_FRAME_CORRUPT = 7, (removed).
87 SPDY_ERROR_GOAWAY_FRAME_CORRUPT = 29,
88 SPDY_ERROR_RST_STREAM_FRAME_CORRUPT = 30,
89 SPDY_ERROR_INVALID_DATA_FRAME_FLAGS = 8,
90 SPDY_ERROR_INVALID_CONTROL_FRAME_FLAGS = 9,
91 SPDY_ERROR_UNEXPECTED_FRAME = 31,
92 // SpdyRstStreamStatus mappings.
93 // RST_STREAM_INVALID not mapped.
94 STATUS_CODE_PROTOCOL_ERROR = 11,
95 STATUS_CODE_INVALID_STREAM = 12,
96 STATUS_CODE_REFUSED_STREAM = 13,
97 STATUS_CODE_UNSUPPORTED_VERSION = 14,
98 STATUS_CODE_CANCEL = 15,
99 STATUS_CODE_INTERNAL_ERROR = 16,
100 STATUS_CODE_FLOW_CONTROL_ERROR = 17,
101 STATUS_CODE_STREAM_IN_USE = 18,
102 STATUS_CODE_STREAM_ALREADY_CLOSED = 19,
103 STATUS_CODE_INVALID_CREDENTIALS = 20,
104 STATUS_CODE_FRAME_SIZE_ERROR = 21,
105 STATUS_CODE_SETTINGS_TIMEOUT = 32,
106 STATUS_CODE_CONNECT_ERROR = 33,
107 STATUS_CODE_ENHANCE_YOUR_CALM = 34,
109 // SpdySession errors
110 PROTOCOL_ERROR_UNEXPECTED_PING = 22,
111 PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM = 23,
112 PROTOCOL_ERROR_SPDY_COMPRESSION_FAILURE = 24,
113 PROTOCOL_ERROR_REQUEST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION = 25,
114 PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED = 26,
115 PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE = 27,
116 PROTOCOL_ERROR_RECEIVE_WINDOW_VIOLATION = 28,
119 NUM_SPDY_PROTOCOL_ERROR_DETAILS = 35,
121 SpdyProtocolErrorDetails NET_EXPORT_PRIVATE
122 MapFramerErrorToProtocolError(SpdyFramer::SpdyError error);
123 Error NET_EXPORT_PRIVATE MapFramerErrorToNetError(SpdyFramer::SpdyError error);
124 SpdyProtocolErrorDetails NET_EXPORT_PRIVATE
125 MapRstStreamStatusToProtocolError(SpdyRstStreamStatus status);
126 SpdyGoAwayStatus NET_EXPORT_PRIVATE MapNetErrorToGoAwayStatus(Error err);
128 // If these compile asserts fail then SpdyProtocolErrorDetails needs
129 // to be updated with new values, as do the mapping functions above.
130 COMPILE_ASSERT(12 == SpdyFramer::LAST_ERROR,
131 SpdyProtocolErrorDetails_SpdyErrors_mismatch);
132 COMPILE_ASSERT(15 == RST_STREAM_NUM_STATUS_CODES,
133 SpdyProtocolErrorDetails_RstStreamStatus_mismatch);
135 // Splits pushed |headers| into request and response parts. Request headers are
136 // the headers specifying resource URL.
137 void NET_EXPORT_PRIVATE
138 SplitPushedHeadersToRequestAndResponse(const SpdyHeaderBlock& headers,
139 SpdyMajorVersion protocol_version,
140 SpdyHeaderBlock* request_headers,
141 SpdyHeaderBlock* response_headers);
143 // A helper class used to manage a request to create a stream.
144 class NET_EXPORT_PRIVATE SpdyStreamRequest {
147 // Calls CancelRequest().
148 ~SpdyStreamRequest();
150 // Starts the request to create a stream. If OK is returned, then
151 // ReleaseStream() may be called. If ERR_IO_PENDING is returned,
152 // then when the stream is created, |callback| will be called, at
153 // which point ReleaseStream() may be called. Otherwise, the stream
154 // is not created, an error is returned, and ReleaseStream() may not
157 // If OK is returned, must not be called again without
158 // ReleaseStream() being called first. If ERR_IO_PENDING is
159 // returned, must not be called again without CancelRequest() or
160 // ReleaseStream() being called first. Otherwise, in case of an
161 // immediate error, this may be called again.
162 int StartRequest(SpdyStreamType type,
163 const base::WeakPtr<SpdySession>& session,
165 RequestPriority priority,
166 const BoundNetLog& net_log,
167 const CompletionCallback& callback);
169 // Cancels any pending stream creation request. May be called
171 void CancelRequest();
173 // Transfers the created stream (guaranteed to not be NULL) to the
174 // caller. Must be called at most once after StartRequest() returns
175 // OK or |callback| is called with OK. The caller must immediately
176 // set a delegate for the returned stream (except for test code).
177 base::WeakPtr<SpdyStream> ReleaseStream();
180 friend class SpdySession;
182 // Called by |session_| when the stream attempt has finished
184 void OnRequestCompleteSuccess(const base::WeakPtr<SpdyStream>& stream);
186 // Called by |session_| when the stream attempt has finished with an
187 // error. Also called with ERR_ABORTED if |session_| is destroyed
188 // while the stream attempt is still pending.
189 void OnRequestCompleteFailure(int rv);
191 // Accessors called by |session_|.
192 SpdyStreamType type() const { return type_; }
193 const GURL& url() const { return url_; }
194 RequestPriority priority() const { return priority_; }
195 const BoundNetLog& net_log() const { return net_log_; }
199 SpdyStreamType type_;
200 base::WeakPtr<SpdySession> session_;
201 base::WeakPtr<SpdyStream> stream_;
203 RequestPriority priority_;
204 BoundNetLog net_log_;
205 CompletionCallback callback_;
207 base::WeakPtrFactory<SpdyStreamRequest> weak_ptr_factory_;
209 DISALLOW_COPY_AND_ASSIGN(SpdyStreamRequest);
212 class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
213 public SpdyFramerDebugVisitorInterface,
214 public HigherLayeredPool {
216 // TODO(akalin): Use base::TickClock when it becomes available.
217 typedef base::TimeTicks (*TimeFunc)(void);
219 // How we handle flow control (version-dependent).
220 enum FlowControlState {
223 FLOW_CONTROL_STREAM_AND_SESSION
226 // Returns true if |hostname| can be pooled into an existing connection
227 // associated with |ssl_info|.
228 static bool CanPool(TransportSecurityState* transport_security_state,
229 const SSLInfo& ssl_info,
230 const std::string& old_hostname,
231 const std::string& new_hostname);
233 // Create a new SpdySession.
234 // |spdy_session_key| is the host/port that this session connects to, privacy
235 // and proxy configuration settings that it's using.
236 // |session| is the HttpNetworkSession. |net_log| is the NetLog that we log
237 // network events to.
238 SpdySession(const SpdySessionKey& spdy_session_key,
239 const base::WeakPtr<HttpServerProperties>& http_server_properties,
240 TransportSecurityState* transport_security_state,
241 bool verify_domain_authentication,
242 bool enable_sending_initial_data,
243 bool enable_compression,
244 bool enable_ping_based_connection_checking,
245 NextProto default_protocol,
246 size_t stream_initial_recv_window_size,
247 size_t initial_max_concurrent_streams,
248 size_t max_concurrent_streams_limit,
250 const HostPortPair& trusted_spdy_proxy,
253 virtual ~SpdySession();
255 const HostPortPair& host_port_pair() const {
256 return spdy_session_key_.host_port_proxy_pair().first;
258 const HostPortProxyPair& host_port_proxy_pair() const {
259 return spdy_session_key_.host_port_proxy_pair();
261 const SpdySessionKey& spdy_session_key() const {
262 return spdy_session_key_;
264 // Get a pushed stream for a given |url|. If the server initiates a
265 // stream, it might already exist for a given path. The server
266 // might also not have initiated the stream yet, but indicated it
267 // will via X-Associated-Content. Returns OK if a stream was found
268 // and put into |spdy_stream|, or if one was not found but it is
269 // okay to create a new stream (in which case |spdy_stream| is
270 // reset). Returns an error (not ERR_IO_PENDING) otherwise, and
271 // resets |spdy_stream|.
274 base::WeakPtr<SpdyStream>* spdy_stream,
275 const BoundNetLog& stream_net_log);
277 // Initialize the session with the given connection. |is_secure|
278 // must indicate whether |connection| uses an SSL socket or not; it
279 // is usually true, but it can be false for testing or when SPDY is
280 // configured to work with non-secure sockets.
282 // |pool| is the SpdySessionPool that owns us. Its lifetime must
283 // strictly be greater than |this|.
285 // |certificate_error_code| must either be OK or less than
288 // The session begins reading from |connection| on a subsequent event loop
289 // iteration, so the SpdySession may close immediately afterwards if the first
290 // read of |connection| fails.
291 void InitializeWithSocket(scoped_ptr<ClientSocketHandle> connection,
292 SpdySessionPool* pool,
294 int certificate_error_code);
296 // Returns the protocol used by this session. Always between
297 // kProtoSPDYMinimumVersion and kProtoSPDYMaximumVersion.
298 NextProto protocol() const { return protocol_; }
300 // Check to see if this SPDY session can support an additional domain.
301 // If the session is un-authenticated, then this call always returns true.
302 // For SSL-based sessions, verifies that the server certificate in use by
303 // this session provides authentication for the domain and no client
304 // certificate or channel ID was sent to the original server during the SSL
305 // handshake. NOTE: This function can have false negatives on some
307 // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch
308 // histogram because this function does more than verifying domain
309 // authentication now.
310 bool VerifyDomainAuthentication(const std::string& domain);
312 // Pushes the given producer into the write queue for
313 // |stream|. |stream| is guaranteed to be activated before the
314 // producer is used to produce its frame.
315 void EnqueueStreamWrite(const base::WeakPtr<SpdyStream>& stream,
316 SpdyFrameType frame_type,
317 scoped_ptr<SpdyBufferProducer> producer);
319 // Creates and returns a SYN frame for |stream_id|.
320 scoped_ptr<SpdyFrame> CreateSynStream(
321 SpdyStreamId stream_id,
322 RequestPriority priority,
323 SpdyControlFlags flags,
324 const SpdyHeaderBlock& headers);
326 // Creates and returns a SpdyBuffer holding a data frame with the
327 // given data. May return NULL if stalled by flow control.
328 scoped_ptr<SpdyBuffer> CreateDataBuffer(SpdyStreamId stream_id,
331 SpdyDataFlags flags);
333 // Close the stream with the given ID, which must exist and be
334 // active. Note that that stream may hold the last reference to the
336 void CloseActiveStream(SpdyStreamId stream_id, int status);
338 // Close the given created stream, which must exist but not yet be
339 // active. Note that |stream| may hold the last reference to the
341 void CloseCreatedStream(const base::WeakPtr<SpdyStream>& stream, int status);
343 // Send a RST_STREAM frame with the given status code and close the
344 // stream with the given ID, which must exist and be active. Note
345 // that that stream may hold the last reference to the session.
346 void ResetStream(SpdyStreamId stream_id,
347 SpdyRstStreamStatus status,
348 const std::string& description);
350 // Check if a stream is active.
351 bool IsStreamActive(SpdyStreamId stream_id) const;
353 // The LoadState is used for informing the user of the current network
354 // status, such as "resolving host", "connecting", etc.
355 LoadState GetLoadState() const;
357 // Fills SSL info in |ssl_info| and returns true when SSL is in use.
358 bool GetSSLInfo(SSLInfo* ssl_info,
359 bool* was_npn_negotiated,
360 NextProto* protocol_negotiated);
362 // Fills SSL Certificate Request info |cert_request_info| and returns
363 // true when SSL is in use.
364 bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
366 // Send a WINDOW_UPDATE frame for a stream. Called by a stream
367 // whenever receive window size is increased.
368 void SendStreamWindowUpdate(SpdyStreamId stream_id,
369 uint32 delta_window_size);
371 // Accessors for the session's availability state.
372 bool IsAvailable() const { return availability_state_ == STATE_AVAILABLE; }
373 bool IsGoingAway() const { return availability_state_ == STATE_GOING_AWAY; }
374 bool IsDraining() const { return availability_state_ == STATE_DRAINING; }
376 // Closes this session. This will close all active streams and mark
377 // the session as permanently closed. Callers must assume that the
378 // session is destroyed after this is called. (However, it may not
379 // be destroyed right away, e.g. when a SpdySession function is
380 // present in the call stack.)
382 // |err| should be < ERR_IO_PENDING; this function is intended to be
384 // |description| indicates the reason for the error.
385 void CloseSessionOnError(Error err, const std::string& description);
387 // Mark this session as unavailable, meaning that it will not be used to
388 // service new streams. Unlike when a GOAWAY frame is received, this function
389 // will not close any streams.
390 void MakeUnavailable();
392 // Closes all active streams with stream id's greater than
393 // |last_good_stream_id|, as well as any created or pending
394 // streams. Must be called only when |availability_state_| >=
395 // STATE_GOING_AWAY. After this function, DcheckGoingAway() will
396 // pass. May be called multiple times.
397 void StartGoingAway(SpdyStreamId last_good_stream_id, Error status);
399 // Must be called only when going away (i.e., DcheckGoingAway()
400 // passes). If there are no more active streams and the session
401 // isn't closed yet, close it.
402 void MaybeFinishGoingAway();
404 // Retrieves information on the current state of the SPDY session as a
405 // Value. Caller takes possession of the returned value.
406 base::Value* GetInfoAsValue() const;
408 // Indicates whether the session is being reused after having successfully
409 // used to send/receive data in the past or if the underlying socket was idle
410 // before being used for a SPDY session.
411 bool IsReused() const;
413 // Returns true if the underlying transport socket ever had any reads or
415 bool WasEverUsed() const {
416 return connection_->socket()->WasEverUsed();
419 // Returns the load timing information from the perspective of the given
420 // stream. If it's not the first stream, the connection is considered reused
423 // This uses a different notion of reuse than IsReused(). This function
424 // sets |socket_reused| to false only if |stream_id| is the ID of the first
425 // stream using the session. IsReused(), on the other hand, indicates if the
426 // session has been used to send/receive data at all.
427 bool GetLoadTimingInfo(SpdyStreamId stream_id,
428 LoadTimingInfo* load_timing_info) const;
430 // Returns true if session is not currently active
431 bool is_active() const {
432 return !active_streams_.empty() || !created_streams_.empty();
435 // Access to the number of active and pending streams. These are primarily
436 // available for testing and diagnostics.
437 size_t num_active_streams() const { return active_streams_.size(); }
438 size_t num_unclaimed_pushed_streams() const {
439 return unclaimed_pushed_streams_.size();
441 size_t num_created_streams() const { return created_streams_.size(); }
443 size_t num_pushed_streams() const { return num_pushed_streams_; }
444 size_t num_active_pushed_streams() const {
445 return num_active_pushed_streams_;
448 size_t pending_create_stream_queue_size(RequestPriority priority) const {
449 DCHECK_GE(priority, MINIMUM_PRIORITY);
450 DCHECK_LE(priority, MAXIMUM_PRIORITY);
451 return pending_create_stream_queues_[priority].size();
454 // Returns the (version-dependent) flow control state.
455 FlowControlState flow_control_state() const {
456 return flow_control_state_;
459 // Returns the current |stream_initial_send_window_size_|.
460 int32 stream_initial_send_window_size() const {
461 return stream_initial_send_window_size_;
464 // Returns the current |stream_initial_recv_window_size_|.
465 int32 stream_initial_recv_window_size() const {
466 return stream_initial_recv_window_size_;
469 // Returns true if no stream in the session can send data due to
470 // session flow control.
471 bool IsSendStalled() const {
473 flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION &&
474 session_send_window_size_ == 0;
477 const BoundNetLog& net_log() const { return net_log_; }
479 int GetPeerAddress(IPEndPoint* address) const;
480 int GetLocalAddress(IPEndPoint* address) const;
482 // Adds |alias| to set of aliases associated with this session.
483 void AddPooledAlias(const SpdySessionKey& alias_key);
485 // Returns the set of aliases associated with this session.
486 const std::set<SpdySessionKey>& pooled_aliases() const {
487 return pooled_aliases_;
490 SpdyMajorVersion GetProtocolVersion() const;
492 size_t GetDataFrameMinimumSize() const {
493 return buffered_spdy_framer_->GetDataFrameMinimumSize();
496 size_t GetControlFrameHeaderSize() const {
497 return buffered_spdy_framer_->GetControlFrameHeaderSize();
500 size_t GetFrameMinimumSize() const {
501 return buffered_spdy_framer_->GetFrameMinimumSize();
504 size_t GetFrameMaximumSize() const {
505 return buffered_spdy_framer_->GetFrameMaximumSize();
508 size_t GetDataFrameMaximumPayload() const {
509 return buffered_spdy_framer_->GetDataFrameMaximumPayload();
512 // https://http2.github.io/http2-spec/#TLSUsage mandates minimum security
513 // standards for TLS.
514 bool HasAcceptableTransportSecurity() const;
516 // Must be used only by |pool_|.
517 base::WeakPtr<SpdySession> GetWeakPtr();
519 // HigherLayeredPool implementation:
520 virtual bool CloseOneIdleConnection() OVERRIDE;
523 friend class base::RefCounted<SpdySession>;
524 friend class SpdyStreamRequest;
525 friend class SpdySessionTest;
527 // Allow tests to access our innards for testing purposes.
528 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ClientPing);
529 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, FailedPing);
530 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, GetActivePushStream);
531 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, DeleteExpiredPushStreams);
532 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ProtocolNegotiation);
533 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ClearSettings);
534 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, AdjustRecvWindowSize);
535 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, AdjustSendWindowSize);
536 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlInactiveStream);
537 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlNoReceiveLeaks);
538 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlNoSendLeaks);
539 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlEndToEnd);
540 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, StreamIdSpaceExhausted);
541 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, UnstallRacesWithStreamCreation);
542 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, GoAwayOnSessionFlowControlError);
543 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest,
544 RejectPushedStreamExceedingConcurrencyLimit);
545 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, IgnoreReservedRemoteStreamsCount);
546 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest,
547 CancelReservedStreamOnHeadersReceived);
549 typedef std::deque<base::WeakPtr<SpdyStreamRequest> >
550 PendingStreamRequestQueue;
552 struct ActiveStreamInfo {
554 explicit ActiveStreamInfo(SpdyStream* stream);
558 bool waiting_for_syn_reply;
560 typedef std::map<SpdyStreamId, ActiveStreamInfo> ActiveStreamMap;
562 struct PushedStreamInfo {
564 PushedStreamInfo(SpdyStreamId stream_id, base::TimeTicks creation_time);
567 SpdyStreamId stream_id;
568 base::TimeTicks creation_time;
570 typedef std::map<GURL, PushedStreamInfo> PushedStreamMap;
572 typedef std::set<SpdyStream*> CreatedStreamSet;
574 enum AvailabilityState {
575 // The session is available in its socket pool and can be used
578 // The session can process data on existing streams but will
579 // refuse to create new ones.
581 // The session is draining its write queue in preparation of closing.
582 // Further writes will not be queued, and further reads will not be issued
583 // (though the remainder of a current read may be processed). The session
584 // will be destroyed by its write loop once the write queue is drained.
590 READ_STATE_DO_READ_COMPLETE,
594 // There is no in-flight write and the write queue is empty.
596 WRITE_STATE_DO_WRITE,
597 WRITE_STATE_DO_WRITE_COMPLETE,
600 // Checks whether a stream for the given |url| can be created or
601 // retrieved from the set of unclaimed push streams. Returns OK if
602 // so. Otherwise, the session is closed and an error <
603 // ERR_IO_PENDING is returned.
604 Error TryAccessStream(const GURL& url);
606 // Called by SpdyStreamRequest to start a request to create a
607 // stream. If OK is returned, then |stream| will be filled in with a
608 // valid stream. If ERR_IO_PENDING is returned, then
609 // |request->OnRequestComplete{Success,Failure}()| will be called
610 // when the stream is created (unless it is cancelled). Otherwise,
611 // no stream is created and the error is returned.
612 int TryCreateStream(const base::WeakPtr<SpdyStreamRequest>& request,
613 base::WeakPtr<SpdyStream>* stream);
615 // Actually create a stream into |stream|. Returns OK if successful;
616 // otherwise, returns an error and |stream| is not filled.
617 int CreateStream(const SpdyStreamRequest& request,
618 base::WeakPtr<SpdyStream>* stream);
620 // Called by SpdyStreamRequest to remove |request| from the stream
622 void CancelStreamRequest(const base::WeakPtr<SpdyStreamRequest>& request);
624 // Returns the next pending stream request to process, or NULL if
626 base::WeakPtr<SpdyStreamRequest> GetNextPendingStreamRequest();
628 // Called when there is room to create more streams (e.g., a stream
629 // was closed). Processes as many pending stream requests as
631 void ProcessPendingStreamRequests();
633 bool TryCreatePushStream(SpdyStreamId stream_id,
634 SpdyStreamId associated_stream_id,
635 SpdyPriority priority,
636 const SpdyHeaderBlock& headers);
638 // Close the stream pointed to by the given iterator. Note that that
639 // stream may hold the last reference to the session.
640 void CloseActiveStreamIterator(ActiveStreamMap::iterator it, int status);
642 // Close the stream pointed to by the given iterator. Note that that
643 // stream may hold the last reference to the session.
644 void CloseCreatedStreamIterator(CreatedStreamSet::iterator it, int status);
646 // Calls EnqueueResetStreamFrame() and then
647 // CloseActiveStreamIterator().
648 void ResetStreamIterator(ActiveStreamMap::iterator it,
649 SpdyRstStreamStatus status,
650 const std::string& description);
652 // Send a RST_STREAM frame with the given parameters. There should
653 // either be no active stream with the given ID, or that active
654 // stream should be closed shortly after this function is called.
656 // TODO(akalin): Rename this to EnqueueResetStreamFrame().
657 void EnqueueResetStreamFrame(SpdyStreamId stream_id,
658 RequestPriority priority,
659 SpdyRstStreamStatus status,
660 const std::string& description);
662 // Calls DoReadLoop. Use this function instead of DoReadLoop when
663 // posting a task to pump the read loop.
664 void PumpReadLoop(ReadState expected_read_state, int result);
666 // Advance the ReadState state machine. |expected_read_state| is the
667 // expected starting read state.
669 // This function must always be called via PumpReadLoop().
670 int DoReadLoop(ReadState expected_read_state, int result);
671 // The implementations of the states of the ReadState state machine.
673 int DoReadComplete(int result);
675 // Calls DoWriteLoop. If |availability_state_| is STATE_DRAINING and no
676 // writes remain, the session is removed from the session pool and
679 // Use this function instead of DoWriteLoop when posting a task to
680 // pump the write loop.
681 void PumpWriteLoop(WriteState expected_write_state, int result);
683 // Iff the write loop is not currently active, posts a callback into
685 void MaybePostWriteLoop();
687 // Advance the WriteState state machine. |expected_write_state| is
688 // the expected starting write state.
690 // This function must always be called via PumpWriteLoop().
691 int DoWriteLoop(WriteState expected_write_state, int result);
692 // The implementations of the states of the WriteState state machine.
694 int DoWriteComplete(int result);
696 // TODO(akalin): Rename the Send* and Write* functions below to
699 // Send initial data. Called when a connection is successfully
700 // established in InitializeWithSocket() and
701 // |enable_sending_initial_data_| is true.
702 void SendInitialData();
704 // Helper method to send a SETTINGS frame.
705 void SendSettings(const SettingsMap& settings);
707 // Handle SETTING. Either when we send settings, or when we receive a
708 // SETTINGS control frame, update our SpdySession accordingly.
709 void HandleSetting(uint32 id, uint32 value);
711 // Adjust the send window size of all ActiveStreams and PendingStreamRequests.
712 void UpdateStreamsSendWindowSize(int32 delta_window_size);
714 // Send the PING (preface-PING) frame.
715 void SendPrefacePingIfNoneInFlight();
717 // Send PING if there are no PINGs in flight and we haven't heard from server.
718 void SendPrefacePing();
720 // Send a single WINDOW_UPDATE frame.
721 void SendWindowUpdateFrame(SpdyStreamId stream_id, uint32 delta_window_size,
722 RequestPriority priority);
724 // Send the PING frame.
725 void WritePingFrame(uint32 unique_id, bool is_ack);
727 // Post a CheckPingStatus call after delay. Don't post if there is already
728 // CheckPingStatus running.
729 void PlanToCheckPingStatus();
731 // Check the status of the connection. It calls |CloseSessionOnError| if we
732 // haven't received any data in |kHungInterval| time period.
733 void CheckPingStatus(base::TimeTicks last_check_time);
735 // Get a new stream id.
736 SpdyStreamId GetNewStreamId();
738 // Pushes the given frame with the given priority into the write
739 // queue for the session.
740 void EnqueueSessionWrite(RequestPriority priority,
741 SpdyFrameType frame_type,
742 scoped_ptr<SpdyFrame> frame);
744 // Puts |producer| associated with |stream| onto the write queue
745 // with the given priority.
746 void EnqueueWrite(RequestPriority priority,
747 SpdyFrameType frame_type,
748 scoped_ptr<SpdyBufferProducer> producer,
749 const base::WeakPtr<SpdyStream>& stream);
751 // Inserts a newly-created stream into |created_streams_|.
752 void InsertCreatedStream(scoped_ptr<SpdyStream> stream);
754 // Activates |stream| (which must be in |created_streams_|) by
755 // assigning it an ID and returns it.
756 scoped_ptr<SpdyStream> ActivateCreatedStream(SpdyStream* stream);
758 // Inserts a newly-activated stream into |active_streams_|.
759 void InsertActivatedStream(scoped_ptr<SpdyStream> stream);
761 // Remove all internal references to |stream|, call OnClose() on it,
762 // and process any pending stream requests before deleting it. Note
763 // that |stream| may hold the last reference to the session.
764 void DeleteStream(scoped_ptr<SpdyStream> stream, int status);
766 // Check if we have a pending pushed-stream for this url
767 // Returns the stream if found (and returns it from the pending
768 // list). Returns NULL otherwise.
769 base::WeakPtr<SpdyStream> GetActivePushStream(const GURL& url);
771 // Delegates to |stream->OnInitialResponseHeadersReceived()|. If an
772 // error is returned, the last reference to |this| may have been
774 int OnInitialResponseHeadersReceived(const SpdyHeaderBlock& response_headers,
775 base::Time response_time,
776 base::TimeTicks recv_first_byte_time,
779 void RecordPingRTTHistogram(base::TimeDelta duration);
780 void RecordHistograms();
781 void RecordProtocolErrorHistogram(SpdyProtocolErrorDetails details);
783 // DCHECKs that |availability_state_| >= STATE_GOING_AWAY, that
784 // there are no pending stream creation requests, and that there are
785 // no created streams.
786 void DcheckGoingAway() const;
788 // Calls DcheckGoingAway(), then DCHECKs that |availability_state_|
789 // == STATE_DRAINING, |error_on_close_| has a valid value, and that there
790 // are no active streams or unclaimed pushed streams.
791 void DcheckDraining() const;
793 // If the session is already draining, does nothing. Otherwise, moves
794 // the session to the draining state.
795 void DoDrainSession(Error err, const std::string& description);
797 // Called right before closing a (possibly-inactive) stream for a
798 // reason other than being requested to by the stream.
799 void LogAbandonedStream(SpdyStream* stream, Error status);
801 // Called right before closing an active stream for a reason other
802 // than being requested to by the stream.
803 void LogAbandonedActiveStream(ActiveStreamMap::const_iterator it,
806 // Invokes a user callback for stream creation. We provide this method so it
807 // can be deferred to the MessageLoop, so we avoid re-entrancy problems.
808 void CompleteStreamRequest(
809 const base::WeakPtr<SpdyStreamRequest>& pending_request);
811 // Remove old unclaimed pushed streams.
812 void DeleteExpiredPushedStreams();
814 // BufferedSpdyFramerVisitorInterface:
815 virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE;
816 virtual void OnStreamError(SpdyStreamId stream_id,
817 const std::string& description) OVERRIDE;
818 virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE;
819 virtual void OnRstStream(SpdyStreamId stream_id,
820 SpdyRstStreamStatus status) OVERRIDE;
821 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id,
822 SpdyGoAwayStatus status) OVERRIDE;
823 virtual void OnDataFrameHeader(SpdyStreamId stream_id,
826 virtual void OnStreamFrameData(SpdyStreamId stream_id,
830 virtual void OnSettings(bool clear_persisted) OVERRIDE;
831 virtual void OnSetting(
832 SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE;
833 virtual void OnWindowUpdate(SpdyStreamId stream_id,
834 uint32 delta_window_size) OVERRIDE;
835 virtual void OnPushPromise(SpdyStreamId stream_id,
836 SpdyStreamId promised_stream_id,
837 const SpdyHeaderBlock& headers) OVERRIDE;
838 virtual void OnSynStream(SpdyStreamId stream_id,
839 SpdyStreamId associated_stream_id,
840 SpdyPriority priority,
843 const SpdyHeaderBlock& headers) OVERRIDE;
844 virtual void OnSynReply(
845 SpdyStreamId stream_id,
847 const SpdyHeaderBlock& headers) OVERRIDE;
848 virtual void OnHeaders(
849 SpdyStreamId stream_id,
851 const SpdyHeaderBlock& headers) OVERRIDE;
853 // SpdyFramerDebugVisitorInterface
854 virtual void OnSendCompressedFrame(
855 SpdyStreamId stream_id,
858 size_t frame_len) OVERRIDE;
859 virtual void OnReceiveCompressedFrame(
860 SpdyStreamId stream_id,
862 size_t frame_len) OVERRIDE;
864 // Called when bytes are consumed from a SpdyBuffer for a DATA frame
865 // that is to be written or is being written. Increases the send
866 // window size accordingly if some or all of the SpdyBuffer is being
869 // If session flow control is turned off, this must not be called.
870 void OnWriteBufferConsumed(size_t frame_payload_size,
872 SpdyBuffer::ConsumeSource consume_source);
874 // Called by OnWindowUpdate() (which is in turn called by the
875 // framer) to increase this session's send window size by
876 // |delta_window_size| from a WINDOW_UPDATE frome, which must be at
877 // least 1. If |delta_window_size| would cause this session's send
878 // window size to overflow, does nothing.
880 // If session flow control is turned off, this must not be called.
881 void IncreaseSendWindowSize(int32 delta_window_size);
883 // If session flow control is turned on, called by CreateDataFrame()
884 // (which is in turn called by a stream) to decrease this session's
885 // send window size by |delta_window_size|, which must be at least 1
886 // and at most kMaxSpdyFrameChunkSize. |delta_window_size| must not
887 // cause this session's send window size to go negative.
889 // If session flow control is turned off, this must not be called.
890 void DecreaseSendWindowSize(int32 delta_window_size);
892 // Called when bytes are consumed by the delegate from a SpdyBuffer
893 // containing received data. Increases the receive window size
896 // If session flow control is turned off, this must not be called.
897 void OnReadBufferConsumed(size_t consume_size,
898 SpdyBuffer::ConsumeSource consume_source);
900 // Called by OnReadBufferConsume to increase this session's receive
901 // window size by |delta_window_size|, which must be at least 1 and
902 // must not cause this session's receive window size to overflow,
903 // possibly also sending a WINDOW_UPDATE frame. Also called during
904 // initialization to set the initial receive window size.
906 // If session flow control is turned off, this must not be called.
907 void IncreaseRecvWindowSize(int32 delta_window_size);
909 // Called by OnStreamFrameData (which is in turn called by the
910 // framer) to decrease this session's receive window size by
911 // |delta_window_size|, which must be at least 1 and must not cause
912 // this session's receive window size to go negative.
914 // If session flow control is turned off, this must not be called.
915 void DecreaseRecvWindowSize(int32 delta_window_size);
917 // Queue a send-stalled stream for possibly resuming once we're not
918 // send-stalled anymore.
919 void QueueSendStalledStream(const SpdyStream& stream);
921 // Go through the queue of send-stalled streams and try to resume as
923 void ResumeSendStalledStreams();
925 // Returns the next stream to possibly resume, or 0 if the queue is
927 SpdyStreamId PopStreamToPossiblyResume();
929 // --------------------------
930 // Helper methods for testing
931 // --------------------------
933 void set_connection_at_risk_of_loss_time(base::TimeDelta duration) {
934 connection_at_risk_of_loss_time_ = duration;
937 void set_hung_interval(base::TimeDelta duration) {
938 hung_interval_ = duration;
941 void set_max_concurrent_pushed_streams(size_t value) {
942 max_concurrent_pushed_streams_ = value;
945 int64 pings_in_flight() const { return pings_in_flight_; }
947 uint32 next_ping_id() const { return next_ping_id_; }
949 base::TimeTicks last_activity_time() const { return last_activity_time_; }
951 bool check_ping_status_pending() const { return check_ping_status_pending_; }
953 size_t max_concurrent_streams() const { return max_concurrent_streams_; }
955 // Returns the SSLClientSocket that this SPDY session sits on top of,
956 // or NULL, if the transport is not SSL.
957 SSLClientSocket* GetSSLClientSocket() const;
959 // Whether Do{Read,Write}Loop() is in the call stack. Useful for
960 // making sure we don't destroy ourselves prematurely in that case.
963 // The key used to identify this session.
964 const SpdySessionKey spdy_session_key_;
966 // Set set of SpdySessionKeys for which this session has serviced
968 std::set<SpdySessionKey> pooled_aliases_;
970 // |pool_| owns us, therefore its lifetime must exceed ours. We set
971 // this to NULL after we are removed from the pool.
972 SpdySessionPool* pool_;
973 const base::WeakPtr<HttpServerProperties> http_server_properties_;
975 TransportSecurityState* transport_security_state_;
977 // The socket handle for this session.
978 scoped_ptr<ClientSocketHandle> connection_;
980 // The read buffer used to read data from the socket.
981 scoped_refptr<IOBuffer> read_buffer_;
983 SpdyStreamId stream_hi_water_mark_; // The next stream id to use.
985 // Queue, for each priority, of pending stream requests that have
986 // not yet been satisfied.
987 PendingStreamRequestQueue pending_create_stream_queues_[NUM_PRIORITIES];
989 // Map from stream id to all active streams. Streams are active in the sense
990 // that they have a consumer (typically SpdyNetworkTransaction and regardless
991 // of whether or not there is currently any ongoing IO [might be waiting for
992 // the server to start pushing the stream]) or there are still network events
993 // incoming even though the consumer has already gone away (cancellation).
995 // |active_streams_| owns all its SpdyStream objects.
997 // TODO(willchan): Perhaps we should separate out cancelled streams and move
998 // them into a separate ActiveStreamMap, and not deliver network events to
1000 ActiveStreamMap active_streams_;
1002 // (Bijective) map from the URL to the ID of the streams that have
1003 // already started to be pushed by the server, but do not have
1004 // consumers yet. Contains a subset of |active_streams_|.
1005 PushedStreamMap unclaimed_pushed_streams_;
1007 // Set of all created streams but that have not yet sent any frames.
1009 // |created_streams_| owns all its SpdyStream objects.
1010 CreatedStreamSet created_streams_;
1012 // Number of pushed streams. All active streams are stored in
1013 // |active_streams_|, but it's better to know the number of push streams
1014 // without traversing the whole collection.
1015 size_t num_pushed_streams_;
1017 // Number of active pushed streams in |active_streams_|, i.e. not in reserved
1018 // remote state. Streams in reserved state are not counted towards any
1019 // concurrency limits.
1020 size_t num_active_pushed_streams_;
1023 SpdyWriteQueue write_queue_;
1025 // Data for the frame we are currently sending.
1027 // The buffer we're currently writing.
1028 scoped_ptr<SpdyBuffer> in_flight_write_;
1029 // The type of the frame in |in_flight_write_|.
1030 SpdyFrameType in_flight_write_frame_type_;
1031 // The size of the frame in |in_flight_write_|.
1032 size_t in_flight_write_frame_size_;
1033 // The stream to notify when |in_flight_write_| has been written to
1034 // the socket completely.
1035 base::WeakPtr<SpdyStream> in_flight_write_stream_;
1037 // Flag if we're using an SSL connection for this SpdySession.
1040 // Certificate error code when using a secure connection.
1041 int certificate_error_code_;
1043 // Spdy Frame state.
1044 scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
1046 // The state variables.
1047 AvailabilityState availability_state_;
1048 ReadState read_state_;
1049 WriteState write_state_;
1051 // If the session is closing (i.e., |availability_state_| is STATE_DRAINING),
1052 // then |error_on_close_| holds the error with which it was closed, which
1053 // may be OK (upon a polite GOAWAY) or an error < ERR_IO_PENDING otherwise.
1054 // Initialized to OK.
1055 Error error_on_close_;
1058 size_t max_concurrent_streams_; // 0 if no limit
1059 size_t max_concurrent_streams_limit_;
1060 size_t max_concurrent_pushed_streams_;
1062 // Some statistics counters for the session.
1063 int streams_initiated_count_;
1064 int streams_pushed_count_;
1065 int streams_pushed_and_claimed_count_;
1066 int streams_abandoned_count_;
1068 // |total_bytes_received_| keeps track of all the bytes read by the
1069 // SpdySession. It is used by the |Net.SpdySettingsCwnd...| histograms.
1070 int total_bytes_received_;
1072 bool sent_settings_; // Did this session send settings when it started.
1073 bool received_settings_; // Did this session receive at least one settings
1075 int stalled_streams_; // Count of streams that were ever stalled.
1077 // Count of all pings on the wire, for which we have not gotten a response.
1078 int64 pings_in_flight_;
1080 // This is the next ping_id (unique_id) to be sent in PING frame.
1081 uint32 next_ping_id_;
1083 // This is the last time we have sent a PING.
1084 base::TimeTicks last_ping_sent_time_;
1086 // This is the last time we had activity in the session.
1087 base::TimeTicks last_activity_time_;
1089 // This is the length of the last compressed frame.
1090 size_t last_compressed_frame_len_;
1092 // This is the next time that unclaimed push streams should be checked for
1094 base::TimeTicks next_unclaimed_push_stream_sweep_time_;
1096 // Indicate if we have already scheduled a delayed task to check the ping
1098 bool check_ping_status_pending_;
1100 // Whether to send the (HTTP/2) connection header prefix.
1101 bool send_connection_header_prefix_;
1103 // The (version-dependent) flow control state.
1104 FlowControlState flow_control_state_;
1106 // Initial send window size for this session's streams. Can be
1107 // changed by an arriving SETTINGS frame. Newly created streams use
1108 // this value for the initial send window size.
1109 int32 stream_initial_send_window_size_;
1111 // Initial receive window size for this session's streams. There are
1112 // plans to add a command line switch that would cause a SETTINGS
1113 // frame with window size announcement to be sent on startup. Newly
1114 // created streams will use this value for the initial receive
1116 int32 stream_initial_recv_window_size_;
1118 // Session flow control variables. All zero unless session flow
1119 // control is turned on.
1120 int32 session_send_window_size_;
1121 int32 session_recv_window_size_;
1122 int32 session_unacked_recv_window_bytes_;
1124 // A queue of stream IDs that have been send-stalled at some point
1126 std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES];
1128 BoundNetLog net_log_;
1130 // Outside of tests, these should always be true.
1131 bool verify_domain_authentication_;
1132 bool enable_sending_initial_data_;
1133 bool enable_compression_;
1134 bool enable_ping_based_connection_checking_;
1136 // The SPDY protocol used. Always between kProtoSPDYMinimumVersion and
1137 // kProtoSPDYMaximumVersion.
1138 NextProto protocol_;
1140 // |connection_at_risk_of_loss_time_| is an optimization to avoid sending
1141 // wasteful preface pings (when we just got some data).
1143 // If it is zero (the most conservative figure), then we always send the
1144 // preface ping (when none are in flight).
1146 // It is common for TCP/IP sessions to time out in about 3-5 minutes.
1147 // Certainly if it has been more than 3 minutes, we do want to send a preface
1150 // We don't think any connection will time out in under about 10 seconds. So
1151 // this might as well be set to something conservative like 10 seconds. Later,
1152 // we could adjust it to send fewer pings perhaps.
1153 base::TimeDelta connection_at_risk_of_loss_time_;
1155 // The amount of time that we are willing to tolerate with no activity (of any
1156 // form), while there is a ping in flight, before we declare the connection to
1157 // be hung. TODO(rtenneti): When hung, instead of resetting connection, race
1158 // to build a new connection, and see if that completes before we (finally)
1159 // get a PING response (http://crbug.com/127812).
1160 base::TimeDelta hung_interval_;
1162 // This SPDY proxy is allowed to push resources from origins that are
1163 // different from those of their associated streams.
1164 HostPortPair trusted_spdy_proxy_;
1166 TimeFunc time_func_;
1168 // Used for posting asynchronous IO tasks. We use this even though
1169 // SpdySession is refcounted because we don't need to keep the SpdySession
1170 // alive if the last reference is within a RunnableMethod. Just revoke the
1172 base::WeakPtrFactory<SpdySession> weak_factory_;
1177 #endif // NET_SPDY_SPDY_SESSION_H_