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_SPDY_SPDY_SESSION_H_ 6 #define NET_SPDY_SPDY_SESSION_H_ 7 8 #include <deque> 9 #include <map> 10 #include <set> 11 #include <string> 12 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" 38 #include "url/gurl.h" 39 40 namespace net { 41 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; 49 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; 53 54 // Specifies the maxiumum concurrent streams server could send (via push). 55 const int kMaxConcurrentPushedStreams = 1000; 56 57 // Specifies the maximum number of bytes to read synchronously before 58 // yielding. 59 const int kMaxReadBytesWithoutYielding = 32 * 1024; 60 61 // The initial receive window size for both streams and sessions. 62 const int32 kDefaultInitialRecvWindowSize = 10 * 1024 * 1024; // 10MB 63 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; 68 69 class BoundNetLog; 70 struct LoadTimingInfo; 71 class SpdyStream; 72 class SSLInfo; 73 class TransportSecurityState; 74 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, 108 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, 117 118 // Next free value. 119 NUM_SPDY_PROTOCOL_ERROR_DETAILS = 35, 120 }; 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); 127 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); 134 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); 142 143 // A helper class used to manage a request to create a stream. 144 class NET_EXPORT_PRIVATE SpdyStreamRequest { 145 public: 146 SpdyStreamRequest(); 147 // Calls CancelRequest(). 148 ~SpdyStreamRequest(); 149 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 155 // be called. 156 // 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, 164 const GURL& url, 165 RequestPriority priority, 166 const BoundNetLog& net_log, 167 const CompletionCallback& callback); 168 169 // Cancels any pending stream creation request. May be called 170 // repeatedly. 171 void CancelRequest(); 172 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(); 178 179 private: 180 friend class SpdySession; 181 182 // Called by |session_| when the stream attempt has finished 183 // successfully. 184 void OnRequestCompleteSuccess(const base::WeakPtr<SpdyStream>& stream); 185 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); 190 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_; } 196 197 void Reset(); 198 199 SpdyStreamType type_; 200 base::WeakPtr<SpdySession> session_; 201 base::WeakPtr<SpdyStream> stream_; 202 GURL url_; 203 RequestPriority priority_; 204 BoundNetLog net_log_; 205 CompletionCallback callback_; 206 207 base::WeakPtrFactory<SpdyStreamRequest> weak_ptr_factory_; 208 209 DISALLOW_COPY_AND_ASSIGN(SpdyStreamRequest); 210 }; 211 212 class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface, 213 public SpdyFramerDebugVisitorInterface, 214 public HigherLayeredPool { 215 public: 216 // TODO(akalin): Use base::TickClock when it becomes available. 217 typedef base::TimeTicks (*TimeFunc)(void); 218 219 // How we handle flow control (version-dependent). 220 enum FlowControlState { 221 FLOW_CONTROL_NONE, 222 FLOW_CONTROL_STREAM, 223 FLOW_CONTROL_STREAM_AND_SESSION 224 }; 225 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); 232 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, 249 TimeFunc time_func, 250 const HostPortPair& trusted_spdy_proxy, 251 NetLog* net_log); 252 253 virtual ~SpdySession(); 254 255 const HostPortPair& host_port_pair() const { 256 return spdy_session_key_.host_port_proxy_pair().first; 257 } 258 const HostPortProxyPair& host_port_proxy_pair() const { 259 return spdy_session_key_.host_port_proxy_pair(); 260 } 261 const SpdySessionKey& spdy_session_key() const { 262 return spdy_session_key_; 263 } 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|. 272 int GetPushStream( 273 const GURL& url, 274 base::WeakPtr<SpdyStream>* spdy_stream, 275 const BoundNetLog& stream_net_log); 276 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. 281 // 282 // |pool| is the SpdySessionPool that owns us. Its lifetime must 283 // strictly be greater than |this|. 284 // 285 // |certificate_error_code| must either be OK or less than 286 // ERR_IO_PENDING. 287 // 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, 293 bool is_secure, 294 int certificate_error_code); 295 296 // Returns the protocol used by this session. Always between 297 // kProtoSPDYMinimumVersion and kProtoSPDYMaximumVersion. 298 NextProto protocol() const { return protocol_; } 299 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 306 // platforms. 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); 311 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); 318 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); 325 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, 329 IOBuffer* data, 330 int len, 331 SpdyDataFlags flags); 332 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 335 // session. 336 void CloseActiveStream(SpdyStreamId stream_id, int status); 337 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 340 // session. 341 void CloseCreatedStream(const base::WeakPtr<SpdyStream>& stream, int status); 342 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); 349 350 // Check if a stream is active. 351 bool IsStreamActive(SpdyStreamId stream_id) const; 352 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; 356 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); 361 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); 365 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); 370 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; } 375 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.) 381 // 382 // |err| should be < ERR_IO_PENDING; this function is intended to be 383 // called on error. 384 // |description| indicates the reason for the error. 385 void CloseSessionOnError(Error err, const std::string& description); 386 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(); 391 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); 398 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(); 403 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; 407 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; 412 413 // Returns true if the underlying transport socket ever had any reads or 414 // writes. 415 bool WasEverUsed() const { 416 return connection_->socket()->WasEverUsed(); 417 } 418 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 421 // for that stream. 422 // 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; 429 430 // Returns true if session is not currently active 431 bool is_active() const { 432 return !active_streams_.empty() || !created_streams_.empty(); 433 } 434 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(); 440 } 441 size_t num_created_streams() const { return created_streams_.size(); } 442 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_; 446 } 447 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(); 452 } 453 454 // Returns the (version-dependent) flow control state. 455 FlowControlState flow_control_state() const { 456 return flow_control_state_; 457 } 458 459 // Returns the current |stream_initial_send_window_size_|. 460 int32 stream_initial_send_window_size() const { 461 return stream_initial_send_window_size_; 462 } 463 464 // Returns the current |stream_initial_recv_window_size_|. 465 int32 stream_initial_recv_window_size() const { 466 return stream_initial_recv_window_size_; 467 } 468 469 // Returns true if no stream in the session can send data due to 470 // session flow control. 471 bool IsSendStalled() const { 472 return 473 flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION && 474 session_send_window_size_ == 0; 475 } 476 477 const BoundNetLog& net_log() const { return net_log_; } 478 479 int GetPeerAddress(IPEndPoint* address) const; 480 int GetLocalAddress(IPEndPoint* address) const; 481 482 // Adds |alias| to set of aliases associated with this session. 483 void AddPooledAlias(const SpdySessionKey& alias_key); 484 485 // Returns the set of aliases associated with this session. 486 const std::set<SpdySessionKey>& pooled_aliases() const { 487 return pooled_aliases_; 488 } 489 490 SpdyMajorVersion GetProtocolVersion() const; 491 492 size_t GetDataFrameMinimumSize() const { 493 return buffered_spdy_framer_->GetDataFrameMinimumSize(); 494 } 495 496 size_t GetControlFrameHeaderSize() const { 497 return buffered_spdy_framer_->GetControlFrameHeaderSize(); 498 } 499 500 size_t GetFrameMinimumSize() const { 501 return buffered_spdy_framer_->GetFrameMinimumSize(); 502 } 503 504 size_t GetFrameMaximumSize() const { 505 return buffered_spdy_framer_->GetFrameMaximumSize(); 506 } 507 508 size_t GetDataFrameMaximumPayload() const { 509 return buffered_spdy_framer_->GetDataFrameMaximumPayload(); 510 } 511 512 // https://http2.github.io/http2-spec/#TLSUsage mandates minimum security 513 // standards for TLS. 514 bool HasAcceptableTransportSecurity() const; 515 516 // Must be used only by |pool_|. 517 base::WeakPtr<SpdySession> GetWeakPtr(); 518 519 // HigherLayeredPool implementation: 520 virtual bool CloseOneIdleConnection() OVERRIDE; 521 522 private: 523 friend class base::RefCounted<SpdySession>; 524 friend class SpdyStreamRequest; 525 friend class SpdySessionTest; 526 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); 548 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, RejectInvalidUnknownFrames); 549 550 typedef std::deque<base::WeakPtr<SpdyStreamRequest> > 551 PendingStreamRequestQueue; 552 553 struct ActiveStreamInfo { 554 ActiveStreamInfo(); 555 explicit ActiveStreamInfo(SpdyStream* stream); 556 ~ActiveStreamInfo(); 557 558 SpdyStream* stream; 559 bool waiting_for_syn_reply; 560 }; 561 typedef std::map<SpdyStreamId, ActiveStreamInfo> ActiveStreamMap; 562 563 struct PushedStreamInfo { 564 PushedStreamInfo(); 565 PushedStreamInfo(SpdyStreamId stream_id, base::TimeTicks creation_time); 566 ~PushedStreamInfo(); 567 568 SpdyStreamId stream_id; 569 base::TimeTicks creation_time; 570 }; 571 typedef std::map<GURL, PushedStreamInfo> PushedStreamMap; 572 573 typedef std::set<SpdyStream*> CreatedStreamSet; 574 575 enum AvailabilityState { 576 // The session is available in its socket pool and can be used 577 // freely. 578 STATE_AVAILABLE, 579 // The session can process data on existing streams but will 580 // refuse to create new ones. 581 STATE_GOING_AWAY, 582 // The session is draining its write queue in preparation of closing. 583 // Further writes will not be queued, and further reads will not be issued 584 // (though the remainder of a current read may be processed). The session 585 // will be destroyed by its write loop once the write queue is drained. 586 STATE_DRAINING, 587 }; 588 589 enum ReadState { 590 READ_STATE_DO_READ, 591 READ_STATE_DO_READ_COMPLETE, 592 }; 593 594 enum WriteState { 595 // There is no in-flight write and the write queue is empty. 596 WRITE_STATE_IDLE, 597 WRITE_STATE_DO_WRITE, 598 WRITE_STATE_DO_WRITE_COMPLETE, 599 }; 600 601 // Checks whether a stream for the given |url| can be created or 602 // retrieved from the set of unclaimed push streams. Returns OK if 603 // so. Otherwise, the session is closed and an error < 604 // ERR_IO_PENDING is returned. 605 Error TryAccessStream(const GURL& url); 606 607 // Called by SpdyStreamRequest to start a request to create a 608 // stream. If OK is returned, then |stream| will be filled in with a 609 // valid stream. If ERR_IO_PENDING is returned, then 610 // |request->OnRequestComplete{Success,Failure}()| will be called 611 // when the stream is created (unless it is cancelled). Otherwise, 612 // no stream is created and the error is returned. 613 int TryCreateStream(const base::WeakPtr<SpdyStreamRequest>& request, 614 base::WeakPtr<SpdyStream>* stream); 615 616 // Actually create a stream into |stream|. Returns OK if successful; 617 // otherwise, returns an error and |stream| is not filled. 618 int CreateStream(const SpdyStreamRequest& request, 619 base::WeakPtr<SpdyStream>* stream); 620 621 // Called by SpdyStreamRequest to remove |request| from the stream 622 // creation queue. 623 void CancelStreamRequest(const base::WeakPtr<SpdyStreamRequest>& request); 624 625 // Returns the next pending stream request to process, or NULL if 626 // there is none. 627 base::WeakPtr<SpdyStreamRequest> GetNextPendingStreamRequest(); 628 629 // Called when there is room to create more streams (e.g., a stream 630 // was closed). Processes as many pending stream requests as 631 // possible. 632 void ProcessPendingStreamRequests(); 633 634 bool TryCreatePushStream(SpdyStreamId stream_id, 635 SpdyStreamId associated_stream_id, 636 SpdyPriority priority, 637 const SpdyHeaderBlock& headers); 638 639 // Close the stream pointed to by the given iterator. Note that that 640 // stream may hold the last reference to the session. 641 void CloseActiveStreamIterator(ActiveStreamMap::iterator it, int status); 642 643 // Close the stream pointed to by the given iterator. Note that that 644 // stream may hold the last reference to the session. 645 void CloseCreatedStreamIterator(CreatedStreamSet::iterator it, int status); 646 647 // Calls EnqueueResetStreamFrame() and then 648 // CloseActiveStreamIterator(). 649 void ResetStreamIterator(ActiveStreamMap::iterator it, 650 SpdyRstStreamStatus status, 651 const std::string& description); 652 653 // Send a RST_STREAM frame with the given parameters. There should 654 // either be no active stream with the given ID, or that active 655 // stream should be closed shortly after this function is called. 656 // 657 // TODO(akalin): Rename this to EnqueueResetStreamFrame(). 658 void EnqueueResetStreamFrame(SpdyStreamId stream_id, 659 RequestPriority priority, 660 SpdyRstStreamStatus status, 661 const std::string& description); 662 663 // Calls DoReadLoop. Use this function instead of DoReadLoop when 664 // posting a task to pump the read loop. 665 void PumpReadLoop(ReadState expected_read_state, int result); 666 667 // Advance the ReadState state machine. |expected_read_state| is the 668 // expected starting read state. 669 // 670 // This function must always be called via PumpReadLoop(). 671 int DoReadLoop(ReadState expected_read_state, int result); 672 // The implementations of the states of the ReadState state machine. 673 int DoRead(); 674 int DoReadComplete(int result); 675 676 // Calls DoWriteLoop. If |availability_state_| is STATE_DRAINING and no 677 // writes remain, the session is removed from the session pool and 678 // destroyed. 679 // 680 // Use this function instead of DoWriteLoop when posting a task to 681 // pump the write loop. 682 void PumpWriteLoop(WriteState expected_write_state, int result); 683 684 // Iff the write loop is not currently active, posts a callback into 685 // PumpWriteLoop(). 686 void MaybePostWriteLoop(); 687 688 // Advance the WriteState state machine. |expected_write_state| is 689 // the expected starting write state. 690 // 691 // This function must always be called via PumpWriteLoop(). 692 int DoWriteLoop(WriteState expected_write_state, int result); 693 // The implementations of the states of the WriteState state machine. 694 int DoWrite(); 695 int DoWriteComplete(int result); 696 697 // TODO(akalin): Rename the Send* and Write* functions below to 698 // Enqueue*. 699 700 // Send initial data. Called when a connection is successfully 701 // established in InitializeWithSocket() and 702 // |enable_sending_initial_data_| is true. 703 void SendInitialData(); 704 705 // Helper method to send a SETTINGS frame. 706 void SendSettings(const SettingsMap& settings); 707 708 // Handle SETTING. Either when we send settings, or when we receive a 709 // SETTINGS control frame, update our SpdySession accordingly. 710 void HandleSetting(uint32 id, uint32 value); 711 712 // Adjust the send window size of all ActiveStreams and PendingStreamRequests. 713 void UpdateStreamsSendWindowSize(int32 delta_window_size); 714 715 // Send the PING (preface-PING) frame. 716 void SendPrefacePingIfNoneInFlight(); 717 718 // Send PING if there are no PINGs in flight and we haven't heard from server. 719 void SendPrefacePing(); 720 721 // Send a single WINDOW_UPDATE frame. 722 void SendWindowUpdateFrame(SpdyStreamId stream_id, uint32 delta_window_size, 723 RequestPriority priority); 724 725 // Send the PING frame. 726 void WritePingFrame(uint32 unique_id, bool is_ack); 727 728 // Post a CheckPingStatus call after delay. Don't post if there is already 729 // CheckPingStatus running. 730 void PlanToCheckPingStatus(); 731 732 // Check the status of the connection. It calls |CloseSessionOnError| if we 733 // haven't received any data in |kHungInterval| time period. 734 void CheckPingStatus(base::TimeTicks last_check_time); 735 736 // Get a new stream id. 737 SpdyStreamId GetNewStreamId(); 738 739 // Pushes the given frame with the given priority into the write 740 // queue for the session. 741 void EnqueueSessionWrite(RequestPriority priority, 742 SpdyFrameType frame_type, 743 scoped_ptr<SpdyFrame> frame); 744 745 // Puts |producer| associated with |stream| onto the write queue 746 // with the given priority. 747 void EnqueueWrite(RequestPriority priority, 748 SpdyFrameType frame_type, 749 scoped_ptr<SpdyBufferProducer> producer, 750 const base::WeakPtr<SpdyStream>& stream); 751 752 // Inserts a newly-created stream into |created_streams_|. 753 void InsertCreatedStream(scoped_ptr<SpdyStream> stream); 754 755 // Activates |stream| (which must be in |created_streams_|) by 756 // assigning it an ID and returns it. 757 scoped_ptr<SpdyStream> ActivateCreatedStream(SpdyStream* stream); 758 759 // Inserts a newly-activated stream into |active_streams_|. 760 void InsertActivatedStream(scoped_ptr<SpdyStream> stream); 761 762 // Remove all internal references to |stream|, call OnClose() on it, 763 // and process any pending stream requests before deleting it. Note 764 // that |stream| may hold the last reference to the session. 765 void DeleteStream(scoped_ptr<SpdyStream> stream, int status); 766 767 // Check if we have a pending pushed-stream for this url 768 // Returns the stream if found (and returns it from the pending 769 // list). Returns NULL otherwise. 770 base::WeakPtr<SpdyStream> GetActivePushStream(const GURL& url); 771 772 // Delegates to |stream->OnInitialResponseHeadersReceived()|. If an 773 // error is returned, the last reference to |this| may have been 774 // released. 775 int OnInitialResponseHeadersReceived(const SpdyHeaderBlock& response_headers, 776 base::Time response_time, 777 base::TimeTicks recv_first_byte_time, 778 SpdyStream* stream); 779 780 void RecordPingRTTHistogram(base::TimeDelta duration); 781 void RecordHistograms(); 782 void RecordProtocolErrorHistogram(SpdyProtocolErrorDetails details); 783 784 // DCHECKs that |availability_state_| >= STATE_GOING_AWAY, that 785 // there are no pending stream creation requests, and that there are 786 // no created streams. 787 void DcheckGoingAway() const; 788 789 // Calls DcheckGoingAway(), then DCHECKs that |availability_state_| 790 // == STATE_DRAINING, |error_on_close_| has a valid value, and that there 791 // are no active streams or unclaimed pushed streams. 792 void DcheckDraining() const; 793 794 // If the session is already draining, does nothing. Otherwise, moves 795 // the session to the draining state. 796 void DoDrainSession(Error err, const std::string& description); 797 798 // Called right before closing a (possibly-inactive) stream for a 799 // reason other than being requested to by the stream. 800 void LogAbandonedStream(SpdyStream* stream, Error status); 801 802 // Called right before closing an active stream for a reason other 803 // than being requested to by the stream. 804 void LogAbandonedActiveStream(ActiveStreamMap::const_iterator it, 805 Error status); 806 807 // Invokes a user callback for stream creation. We provide this method so it 808 // can be deferred to the MessageLoop, so we avoid re-entrancy problems. 809 void CompleteStreamRequest( 810 const base::WeakPtr<SpdyStreamRequest>& pending_request); 811 812 // Remove old unclaimed pushed streams. 813 void DeleteExpiredPushedStreams(); 814 815 // BufferedSpdyFramerVisitorInterface: 816 virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE; 817 virtual void OnStreamError(SpdyStreamId stream_id, 818 const std::string& description) OVERRIDE; 819 virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE; 820 virtual void OnRstStream(SpdyStreamId stream_id, 821 SpdyRstStreamStatus status) OVERRIDE; 822 virtual void OnGoAway(SpdyStreamId last_accepted_stream_id, 823 SpdyGoAwayStatus status) OVERRIDE; 824 virtual void OnDataFrameHeader(SpdyStreamId stream_id, 825 size_t length, 826 bool fin) OVERRIDE; 827 virtual void OnStreamFrameData(SpdyStreamId stream_id, 828 const char* data, 829 size_t len, 830 bool fin) OVERRIDE; 831 virtual void OnSettings(bool clear_persisted) OVERRIDE; 832 virtual void OnSetting( 833 SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE; 834 virtual void OnWindowUpdate(SpdyStreamId stream_id, 835 uint32 delta_window_size) OVERRIDE; 836 virtual void OnPushPromise(SpdyStreamId stream_id, 837 SpdyStreamId promised_stream_id, 838 const SpdyHeaderBlock& headers) OVERRIDE; 839 virtual void OnSynStream(SpdyStreamId stream_id, 840 SpdyStreamId associated_stream_id, 841 SpdyPriority priority, 842 bool fin, 843 bool unidirectional, 844 const SpdyHeaderBlock& headers) OVERRIDE; 845 virtual void OnSynReply( 846 SpdyStreamId stream_id, 847 bool fin, 848 const SpdyHeaderBlock& headers) OVERRIDE; 849 virtual void OnHeaders( 850 SpdyStreamId stream_id, 851 bool fin, 852 const SpdyHeaderBlock& headers) OVERRIDE; 853 virtual bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) OVERRIDE; 854 855 // SpdyFramerDebugVisitorInterface 856 virtual void OnSendCompressedFrame( 857 SpdyStreamId stream_id, 858 SpdyFrameType type, 859 size_t payload_len, 860 size_t frame_len) OVERRIDE; 861 virtual void OnReceiveCompressedFrame( 862 SpdyStreamId stream_id, 863 SpdyFrameType type, 864 size_t frame_len) OVERRIDE; 865 866 // Called when bytes are consumed from a SpdyBuffer for a DATA frame 867 // that is to be written or is being written. Increases the send 868 // window size accordingly if some or all of the SpdyBuffer is being 869 // discarded. 870 // 871 // If session flow control is turned off, this must not be called. 872 void OnWriteBufferConsumed(size_t frame_payload_size, 873 size_t consume_size, 874 SpdyBuffer::ConsumeSource consume_source); 875 876 // Called by OnWindowUpdate() (which is in turn called by the 877 // framer) to increase this session's send window size by 878 // |delta_window_size| from a WINDOW_UPDATE frome, which must be at 879 // least 1. If |delta_window_size| would cause this session's send 880 // window size to overflow, does nothing. 881 // 882 // If session flow control is turned off, this must not be called. 883 void IncreaseSendWindowSize(int32 delta_window_size); 884 885 // If session flow control is turned on, called by CreateDataFrame() 886 // (which is in turn called by a stream) to decrease this session's 887 // send window size by |delta_window_size|, which must be at least 1 888 // and at most kMaxSpdyFrameChunkSize. |delta_window_size| must not 889 // cause this session's send window size to go negative. 890 // 891 // If session flow control is turned off, this must not be called. 892 void DecreaseSendWindowSize(int32 delta_window_size); 893 894 // Called when bytes are consumed by the delegate from a SpdyBuffer 895 // containing received data. Increases the receive window size 896 // accordingly. 897 // 898 // If session flow control is turned off, this must not be called. 899 void OnReadBufferConsumed(size_t consume_size, 900 SpdyBuffer::ConsumeSource consume_source); 901 902 // Called by OnReadBufferConsume to increase this session's receive 903 // window size by |delta_window_size|, which must be at least 1 and 904 // must not cause this session's receive window size to overflow, 905 // possibly also sending a WINDOW_UPDATE frame. Also called during 906 // initialization to set the initial receive window size. 907 // 908 // If session flow control is turned off, this must not be called. 909 void IncreaseRecvWindowSize(int32 delta_window_size); 910 911 // Called by OnStreamFrameData (which is in turn called by the 912 // framer) to decrease this session's receive window size by 913 // |delta_window_size|, which must be at least 1 and must not cause 914 // this session's receive window size to go negative. 915 // 916 // If session flow control is turned off, this must not be called. 917 void DecreaseRecvWindowSize(int32 delta_window_size); 918 919 // Queue a send-stalled stream for possibly resuming once we're not 920 // send-stalled anymore. 921 void QueueSendStalledStream(const SpdyStream& stream); 922 923 // Go through the queue of send-stalled streams and try to resume as 924 // many as possible. 925 void ResumeSendStalledStreams(); 926 927 // Returns the next stream to possibly resume, or 0 if the queue is 928 // empty. 929 SpdyStreamId PopStreamToPossiblyResume(); 930 931 // -------------------------- 932 // Helper methods for testing 933 // -------------------------- 934 935 void set_connection_at_risk_of_loss_time(base::TimeDelta duration) { 936 connection_at_risk_of_loss_time_ = duration; 937 } 938 939 void set_hung_interval(base::TimeDelta duration) { 940 hung_interval_ = duration; 941 } 942 943 void set_max_concurrent_pushed_streams(size_t value) { 944 max_concurrent_pushed_streams_ = value; 945 } 946 947 int64 pings_in_flight() const { return pings_in_flight_; } 948 949 uint32 next_ping_id() const { return next_ping_id_; } 950 951 base::TimeTicks last_activity_time() const { return last_activity_time_; } 952 953 bool check_ping_status_pending() const { return check_ping_status_pending_; } 954 955 size_t max_concurrent_streams() const { return max_concurrent_streams_; } 956 957 // Returns the SSLClientSocket that this SPDY session sits on top of, 958 // or NULL, if the transport is not SSL. 959 SSLClientSocket* GetSSLClientSocket() const; 960 961 // Whether Do{Read,Write}Loop() is in the call stack. Useful for 962 // making sure we don't destroy ourselves prematurely in that case. 963 bool in_io_loop_; 964 965 // The key used to identify this session. 966 const SpdySessionKey spdy_session_key_; 967 968 // Set set of SpdySessionKeys for which this session has serviced 969 // requests. 970 std::set<SpdySessionKey> pooled_aliases_; 971 972 // |pool_| owns us, therefore its lifetime must exceed ours. We set 973 // this to NULL after we are removed from the pool. 974 SpdySessionPool* pool_; 975 const base::WeakPtr<HttpServerProperties> http_server_properties_; 976 977 TransportSecurityState* transport_security_state_; 978 979 // The socket handle for this session. 980 scoped_ptr<ClientSocketHandle> connection_; 981 982 // The read buffer used to read data from the socket. 983 scoped_refptr<IOBuffer> read_buffer_; 984 985 SpdyStreamId stream_hi_water_mark_; // The next stream id to use. 986 987 // Used to ensure the server increments push stream ids correctly. 988 SpdyStreamId last_accepted_push_stream_id_; 989 990 // Queue, for each priority, of pending stream requests that have 991 // not yet been satisfied. 992 PendingStreamRequestQueue pending_create_stream_queues_[NUM_PRIORITIES]; 993 994 // Map from stream id to all active streams. Streams are active in the sense 995 // that they have a consumer (typically SpdyNetworkTransaction and regardless 996 // of whether or not there is currently any ongoing IO [might be waiting for 997 // the server to start pushing the stream]) or there are still network events 998 // incoming even though the consumer has already gone away (cancellation). 999 // 1000 // |active_streams_| owns all its SpdyStream objects. 1001 // 1002 // TODO(willchan): Perhaps we should separate out cancelled streams and move 1003 // them into a separate ActiveStreamMap, and not deliver network events to 1004 // them? 1005 ActiveStreamMap active_streams_; 1006 1007 // (Bijective) map from the URL to the ID of the streams that have 1008 // already started to be pushed by the server, but do not have 1009 // consumers yet. Contains a subset of |active_streams_|. 1010 PushedStreamMap unclaimed_pushed_streams_; 1011 1012 // Set of all created streams but that have not yet sent any frames. 1013 // 1014 // |created_streams_| owns all its SpdyStream objects. 1015 CreatedStreamSet created_streams_; 1016 1017 // Number of pushed streams. All active streams are stored in 1018 // |active_streams_|, but it's better to know the number of push streams 1019 // without traversing the whole collection. 1020 size_t num_pushed_streams_; 1021 1022 // Number of active pushed streams in |active_streams_|, i.e. not in reserved 1023 // remote state. Streams in reserved state are not counted towards any 1024 // concurrency limits. 1025 size_t num_active_pushed_streams_; 1026 1027 // The write queue. 1028 SpdyWriteQueue write_queue_; 1029 1030 // Data for the frame we are currently sending. 1031 1032 // The buffer we're currently writing. 1033 scoped_ptr<SpdyBuffer> in_flight_write_; 1034 // The type of the frame in |in_flight_write_|. 1035 SpdyFrameType in_flight_write_frame_type_; 1036 // The size of the frame in |in_flight_write_|. 1037 size_t in_flight_write_frame_size_; 1038 // The stream to notify when |in_flight_write_| has been written to 1039 // the socket completely. 1040 base::WeakPtr<SpdyStream> in_flight_write_stream_; 1041 1042 // Flag if we're using an SSL connection for this SpdySession. 1043 bool is_secure_; 1044 1045 // Certificate error code when using a secure connection. 1046 int certificate_error_code_; 1047 1048 // Spdy Frame state. 1049 scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_; 1050 1051 // The state variables. 1052 AvailabilityState availability_state_; 1053 ReadState read_state_; 1054 WriteState write_state_; 1055 1056 // If the session is closing (i.e., |availability_state_| is STATE_DRAINING), 1057 // then |error_on_close_| holds the error with which it was closed, which 1058 // may be OK (upon a polite GOAWAY) or an error < ERR_IO_PENDING otherwise. 1059 // Initialized to OK. 1060 Error error_on_close_; 1061 1062 // Limits 1063 size_t max_concurrent_streams_; // 0 if no limit 1064 size_t max_concurrent_streams_limit_; 1065 size_t max_concurrent_pushed_streams_; 1066 1067 // Some statistics counters for the session. 1068 int streams_initiated_count_; 1069 int streams_pushed_count_; 1070 int streams_pushed_and_claimed_count_; 1071 int streams_abandoned_count_; 1072 1073 // |total_bytes_received_| keeps track of all the bytes read by the 1074 // SpdySession. It is used by the |Net.SpdySettingsCwnd...| histograms. 1075 int total_bytes_received_; 1076 1077 bool sent_settings_; // Did this session send settings when it started. 1078 bool received_settings_; // Did this session receive at least one settings 1079 // frame. 1080 int stalled_streams_; // Count of streams that were ever stalled. 1081 1082 // Count of all pings on the wire, for which we have not gotten a response. 1083 int64 pings_in_flight_; 1084 1085 // This is the next ping_id (unique_id) to be sent in PING frame. 1086 uint32 next_ping_id_; 1087 1088 // This is the last time we have sent a PING. 1089 base::TimeTicks last_ping_sent_time_; 1090 1091 // This is the last time we had activity in the session. 1092 base::TimeTicks last_activity_time_; 1093 1094 // This is the length of the last compressed frame. 1095 size_t last_compressed_frame_len_; 1096 1097 // This is the next time that unclaimed push streams should be checked for 1098 // expirations. 1099 base::TimeTicks next_unclaimed_push_stream_sweep_time_; 1100 1101 // Indicate if we have already scheduled a delayed task to check the ping 1102 // status. 1103 bool check_ping_status_pending_; 1104 1105 // Whether to send the (HTTP/2) connection header prefix. 1106 bool send_connection_header_prefix_; 1107 1108 // The (version-dependent) flow control state. 1109 FlowControlState flow_control_state_; 1110 1111 // Initial send window size for this session's streams. Can be 1112 // changed by an arriving SETTINGS frame. Newly created streams use 1113 // this value for the initial send window size. 1114 int32 stream_initial_send_window_size_; 1115 1116 // Initial receive window size for this session's streams. There are 1117 // plans to add a command line switch that would cause a SETTINGS 1118 // frame with window size announcement to be sent on startup. Newly 1119 // created streams will use this value for the initial receive 1120 // window size. 1121 int32 stream_initial_recv_window_size_; 1122 1123 // Session flow control variables. All zero unless session flow 1124 // control is turned on. 1125 int32 session_send_window_size_; 1126 int32 session_recv_window_size_; 1127 int32 session_unacked_recv_window_bytes_; 1128 1129 // A queue of stream IDs that have been send-stalled at some point 1130 // in the past. 1131 std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES]; 1132 1133 BoundNetLog net_log_; 1134 1135 // Outside of tests, these should always be true. 1136 bool verify_domain_authentication_; 1137 bool enable_sending_initial_data_; 1138 bool enable_compression_; 1139 bool enable_ping_based_connection_checking_; 1140 1141 // The SPDY protocol used. Always between kProtoSPDYMinimumVersion and 1142 // kProtoSPDYMaximumVersion. 1143 NextProto protocol_; 1144 1145 // |connection_at_risk_of_loss_time_| is an optimization to avoid sending 1146 // wasteful preface pings (when we just got some data). 1147 // 1148 // If it is zero (the most conservative figure), then we always send the 1149 // preface ping (when none are in flight). 1150 // 1151 // It is common for TCP/IP sessions to time out in about 3-5 minutes. 1152 // Certainly if it has been more than 3 minutes, we do want to send a preface 1153 // ping. 1154 // 1155 // We don't think any connection will time out in under about 10 seconds. So 1156 // this might as well be set to something conservative like 10 seconds. Later, 1157 // we could adjust it to send fewer pings perhaps. 1158 base::TimeDelta connection_at_risk_of_loss_time_; 1159 1160 // The amount of time that we are willing to tolerate with no activity (of any 1161 // form), while there is a ping in flight, before we declare the connection to 1162 // be hung. TODO(rtenneti): When hung, instead of resetting connection, race 1163 // to build a new connection, and see if that completes before we (finally) 1164 // get a PING response (http://crbug.com/127812). 1165 base::TimeDelta hung_interval_; 1166 1167 // This SPDY proxy is allowed to push resources from origins that are 1168 // different from those of their associated streams. 1169 HostPortPair trusted_spdy_proxy_; 1170 1171 TimeFunc time_func_; 1172 1173 // Used for posting asynchronous IO tasks. We use this even though 1174 // SpdySession is refcounted because we don't need to keep the SpdySession 1175 // alive if the last reference is within a RunnableMethod. Just revoke the 1176 // method. 1177 base::WeakPtrFactory<SpdySession> weak_factory_; 1178 }; 1179 1180 } // namespace net 1181 1182 #endif // NET_SPDY_SPDY_SESSION_H_ 1183