| OLD | NEW |
|---|
| (Empty) |
| 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 STATUS_CODE_INADEQUATE_SECURITY = 35, | |
| 109 STATUS_CODE_HTTP_1_1_REQUIRED = 36, | |
| 110 | |
| 111 // SpdySession errors | |
| 112 PROTOCOL_ERROR_UNEXPECTED_PING = 22, | |
| 113 PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM = 23, | |
| 114 PROTOCOL_ERROR_SPDY_COMPRESSION_FAILURE = 24, | |
| 115 PROTOCOL_ERROR_REQUEST_FOR_SECURE_CONTENT_OVER_INSECURE_SESSION = 25, | |
| 116 PROTOCOL_ERROR_SYN_REPLY_NOT_RECEIVED = 26, | |
| 117 PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE = 27, | |
| 118 PROTOCOL_ERROR_RECEIVE_WINDOW_VIOLATION = 28, | |
| 119 | |
| 120 // Next free value. | |
| 121 NUM_SPDY_PROTOCOL_ERROR_DETAILS = 37, | |
| 122 }; | |
| 123 SpdyProtocolErrorDetails NET_EXPORT_PRIVATE | |
| 124 MapFramerErrorToProtocolError(SpdyFramer::SpdyError error); | |
| 125 Error NET_EXPORT_PRIVATE MapFramerErrorToNetError(SpdyFramer::SpdyError error); | |
| 126 SpdyProtocolErrorDetails NET_EXPORT_PRIVATE | |
| 127 MapRstStreamStatusToProtocolError(SpdyRstStreamStatus status); | |
| 128 SpdyGoAwayStatus NET_EXPORT_PRIVATE MapNetErrorToGoAwayStatus(Error err); | |
| 129 | |
| 130 // If these compile asserts fail then SpdyProtocolErrorDetails needs | |
| 131 // to be updated with new values, as do the mapping functions above. | |
| 132 static_assert(12 == SpdyFramer::LAST_ERROR, | |
| 133 "SpdyProtocolErrorDetails / Spdy Errors mismatch"); | |
| 134 static_assert(17 == RST_STREAM_NUM_STATUS_CODES, | |
| 135 "SpdyProtocolErrorDetails / RstStreamStatus mismatch"); | |
| 136 | |
| 137 // Splits pushed |headers| into request and response parts. Request headers are | |
| 138 // the headers specifying resource URL. | |
| 139 void NET_EXPORT_PRIVATE | |
| 140 SplitPushedHeadersToRequestAndResponse(const SpdyHeaderBlock& headers, | |
| 141 SpdyMajorVersion protocol_version, | |
| 142 SpdyHeaderBlock* request_headers, | |
| 143 SpdyHeaderBlock* response_headers); | |
| 144 | |
| 145 // A helper class used to manage a request to create a stream. | |
| 146 class NET_EXPORT_PRIVATE SpdyStreamRequest { | |
| 147 public: | |
| 148 SpdyStreamRequest(); | |
| 149 // Calls CancelRequest(). | |
| 150 ~SpdyStreamRequest(); | |
| 151 | |
| 152 // Starts the request to create a stream. If OK is returned, then | |
| 153 // ReleaseStream() may be called. If ERR_IO_PENDING is returned, | |
| 154 // then when the stream is created, |callback| will be called, at | |
| 155 // which point ReleaseStream() may be called. Otherwise, the stream | |
| 156 // is not created, an error is returned, and ReleaseStream() may not | |
| 157 // be called. | |
| 158 // | |
| 159 // If OK is returned, must not be called again without | |
| 160 // ReleaseStream() being called first. If ERR_IO_PENDING is | |
| 161 // returned, must not be called again without CancelRequest() or | |
| 162 // ReleaseStream() being called first. Otherwise, in case of an | |
| 163 // immediate error, this may be called again. | |
| 164 int StartRequest(SpdyStreamType type, | |
| 165 const base::WeakPtr<SpdySession>& session, | |
| 166 const GURL& url, | |
| 167 RequestPriority priority, | |
| 168 const BoundNetLog& net_log, | |
| 169 const CompletionCallback& callback); | |
| 170 | |
| 171 // Cancels any pending stream creation request. May be called | |
| 172 // repeatedly. | |
| 173 void CancelRequest(); | |
| 174 | |
| 175 // Transfers the created stream (guaranteed to not be NULL) to the | |
| 176 // caller. Must be called at most once after StartRequest() returns | |
| 177 // OK or |callback| is called with OK. The caller must immediately | |
| 178 // set a delegate for the returned stream (except for test code). | |
| 179 base::WeakPtr<SpdyStream> ReleaseStream(); | |
| 180 | |
| 181 private: | |
| 182 friend class SpdySession; | |
| 183 | |
| 184 // Called by |session_| when the stream attempt has finished | |
| 185 // successfully. | |
| 186 void OnRequestCompleteSuccess(const base::WeakPtr<SpdyStream>& stream); | |
| 187 | |
| 188 // Called by |session_| when the stream attempt has finished with an | |
| 189 // error. Also called with ERR_ABORTED if |session_| is destroyed | |
| 190 // while the stream attempt is still pending. | |
| 191 void OnRequestCompleteFailure(int rv); | |
| 192 | |
| 193 // Accessors called by |session_|. | |
| 194 SpdyStreamType type() const { return type_; } | |
| 195 const GURL& url() const { return url_; } | |
| 196 RequestPriority priority() const { return priority_; } | |
| 197 const BoundNetLog& net_log() const { return net_log_; } | |
| 198 | |
| 199 void Reset(); | |
| 200 | |
| 201 SpdyStreamType type_; | |
| 202 base::WeakPtr<SpdySession> session_; | |
| 203 base::WeakPtr<SpdyStream> stream_; | |
| 204 GURL url_; | |
| 205 RequestPriority priority_; | |
| 206 BoundNetLog net_log_; | |
| 207 CompletionCallback callback_; | |
| 208 | |
| 209 base::WeakPtrFactory<SpdyStreamRequest> weak_ptr_factory_; | |
| 210 | |
| 211 DISALLOW_COPY_AND_ASSIGN(SpdyStreamRequest); | |
| 212 }; | |
| 213 | |
| 214 class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface, | |
| 215 public SpdyFramerDebugVisitorInterface, | |
| 216 public HigherLayeredPool { | |
| 217 public: | |
| 218 // TODO(akalin): Use base::TickClock when it becomes available. | |
| 219 typedef base::TimeTicks (*TimeFunc)(void); | |
| 220 | |
| 221 // How we handle flow control (version-dependent). | |
| 222 enum FlowControlState { | |
| 223 FLOW_CONTROL_NONE, | |
| 224 FLOW_CONTROL_STREAM, | |
| 225 FLOW_CONTROL_STREAM_AND_SESSION | |
| 226 }; | |
| 227 | |
| 228 // Returns true if |hostname| can be pooled into an existing connection | |
| 229 // associated with |ssl_info|. | |
| 230 static bool CanPool(TransportSecurityState* transport_security_state, | |
| 231 const SSLInfo& ssl_info, | |
| 232 const std::string& old_hostname, | |
| 233 const std::string& new_hostname); | |
| 234 | |
| 235 // Create a new SpdySession. | |
| 236 // |spdy_session_key| is the host/port that this session connects to, privacy | |
| 237 // and proxy configuration settings that it's using. | |
| 238 // |session| is the HttpNetworkSession. |net_log| is the NetLog that we log | |
| 239 // network events to. | |
| 240 SpdySession(const SpdySessionKey& spdy_session_key, | |
| 241 const base::WeakPtr<HttpServerProperties>& http_server_properties, | |
| 242 TransportSecurityState* transport_security_state, | |
| 243 bool verify_domain_authentication, | |
| 244 bool enable_sending_initial_data, | |
| 245 bool enable_compression, | |
| 246 bool enable_ping_based_connection_checking, | |
| 247 NextProto default_protocol, | |
| 248 size_t stream_initial_recv_window_size, | |
| 249 size_t initial_max_concurrent_streams, | |
| 250 size_t max_concurrent_streams_limit, | |
| 251 TimeFunc time_func, | |
| 252 const HostPortPair& trusted_spdy_proxy, | |
| 253 NetLog* net_log); | |
| 254 | |
| 255 ~SpdySession() override; | |
| 256 | |
| 257 const HostPortPair& host_port_pair() const { | |
| 258 return spdy_session_key_.host_port_proxy_pair().first; | |
| 259 } | |
| 260 const HostPortProxyPair& host_port_proxy_pair() const { | |
| 261 return spdy_session_key_.host_port_proxy_pair(); | |
| 262 } | |
| 263 const SpdySessionKey& spdy_session_key() const { | |
| 264 return spdy_session_key_; | |
| 265 } | |
| 266 // Get a pushed stream for a given |url|. If the server initiates a | |
| 267 // stream, it might already exist for a given path. The server | |
| 268 // might also not have initiated the stream yet, but indicated it | |
| 269 // will via X-Associated-Content. Returns OK if a stream was found | |
| 270 // and put into |spdy_stream|, or if one was not found but it is | |
| 271 // okay to create a new stream (in which case |spdy_stream| is | |
| 272 // reset). Returns an error (not ERR_IO_PENDING) otherwise, and | |
| 273 // resets |spdy_stream|. | |
| 274 int GetPushStream( | |
| 275 const GURL& url, | |
| 276 base::WeakPtr<SpdyStream>* spdy_stream, | |
| 277 const BoundNetLog& stream_net_log); | |
| 278 | |
| 279 // Initialize the session with the given connection. |is_secure| | |
| 280 // must indicate whether |connection| uses an SSL socket or not; it | |
| 281 // is usually true, but it can be false for testing or when SPDY is | |
| 282 // configured to work with non-secure sockets. | |
| 283 // | |
| 284 // |pool| is the SpdySessionPool that owns us. Its lifetime must | |
| 285 // strictly be greater than |this|. | |
| 286 // | |
| 287 // |certificate_error_code| must either be OK or less than | |
| 288 // ERR_IO_PENDING. | |
| 289 // | |
| 290 // The session begins reading from |connection| on a subsequent event loop | |
| 291 // iteration, so the SpdySession may close immediately afterwards if the first | |
| 292 // read of |connection| fails. | |
| 293 void InitializeWithSocket(scoped_ptr<ClientSocketHandle> connection, | |
| 294 SpdySessionPool* pool, | |
| 295 bool is_secure, | |
| 296 int certificate_error_code); | |
| 297 | |
| 298 // Returns the protocol used by this session. Always between | |
| 299 // kProtoSPDYMinimumVersion and kProtoSPDYMaximumVersion. | |
| 300 NextProto protocol() const { return protocol_; } | |
| 301 | |
| 302 // Check to see if this SPDY session can support an additional domain. | |
| 303 // If the session is un-authenticated, then this call always returns true. | |
| 304 // For SSL-based sessions, verifies that the server certificate in use by | |
| 305 // this session provides authentication for the domain and no client | |
| 306 // certificate or channel ID was sent to the original server during the SSL | |
| 307 // handshake. NOTE: This function can have false negatives on some | |
| 308 // platforms. | |
| 309 // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch | |
| 310 // histogram because this function does more than verifying domain | |
| 311 // authentication now. | |
| 312 bool VerifyDomainAuthentication(const std::string& domain); | |
| 313 | |
| 314 // Pushes the given producer into the write queue for | |
| 315 // |stream|. |stream| is guaranteed to be activated before the | |
| 316 // producer is used to produce its frame. | |
| 317 void EnqueueStreamWrite(const base::WeakPtr<SpdyStream>& stream, | |
| 318 SpdyFrameType frame_type, | |
| 319 scoped_ptr<SpdyBufferProducer> producer); | |
| 320 | |
| 321 // Creates and returns a SYN frame for |stream_id|. | |
| 322 scoped_ptr<SpdyFrame> CreateSynStream( | |
| 323 SpdyStreamId stream_id, | |
| 324 RequestPriority priority, | |
| 325 SpdyControlFlags flags, | |
| 326 const SpdyHeaderBlock& headers); | |
| 327 | |
| 328 // Creates and returns a SpdyBuffer holding a data frame with the | |
| 329 // given data. May return NULL if stalled by flow control. | |
| 330 scoped_ptr<SpdyBuffer> CreateDataBuffer(SpdyStreamId stream_id, | |
| 331 IOBuffer* data, | |
| 332 int len, | |
| 333 SpdyDataFlags flags); | |
| 334 | |
| 335 // Close the stream with the given ID, which must exist and be | |
| 336 // active. Note that that stream may hold the last reference to the | |
| 337 // session. | |
| 338 void CloseActiveStream(SpdyStreamId stream_id, int status); | |
| 339 | |
| 340 // Close the given created stream, which must exist but not yet be | |
| 341 // active. Note that |stream| may hold the last reference to the | |
| 342 // session. | |
| 343 void CloseCreatedStream(const base::WeakPtr<SpdyStream>& stream, int status); | |
| 344 | |
| 345 // Send a RST_STREAM frame with the given status code and close the | |
| 346 // stream with the given ID, which must exist and be active. Note | |
| 347 // that that stream may hold the last reference to the session. | |
| 348 void ResetStream(SpdyStreamId stream_id, | |
| 349 SpdyRstStreamStatus status, | |
| 350 const std::string& description); | |
| 351 | |
| 352 // Check if a stream is active. | |
| 353 bool IsStreamActive(SpdyStreamId stream_id) const; | |
| 354 | |
| 355 // The LoadState is used for informing the user of the current network | |
| 356 // status, such as "resolving host", "connecting", etc. | |
| 357 LoadState GetLoadState() const; | |
| 358 | |
| 359 // Fills SSL info in |ssl_info| and returns true when SSL is in use. | |
| 360 bool GetSSLInfo(SSLInfo* ssl_info, | |
| 361 bool* was_npn_negotiated, | |
| 362 NextProto* protocol_negotiated); | |
| 363 | |
| 364 // Fills SSL Certificate Request info |cert_request_info| and returns | |
| 365 // true when SSL is in use. | |
| 366 bool GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info); | |
| 367 | |
| 368 // Send a WINDOW_UPDATE frame for a stream. Called by a stream | |
| 369 // whenever receive window size is increased. | |
| 370 void SendStreamWindowUpdate(SpdyStreamId stream_id, | |
| 371 uint32 delta_window_size); | |
| 372 | |
| 373 // Accessors for the session's availability state. | |
| 374 bool IsAvailable() const { return availability_state_ == STATE_AVAILABLE; } | |
| 375 bool IsGoingAway() const { return availability_state_ == STATE_GOING_AWAY; } | |
| 376 bool IsDraining() const { return availability_state_ == STATE_DRAINING; } | |
| 377 | |
| 378 // Closes this session. This will close all active streams and mark | |
| 379 // the session as permanently closed. Callers must assume that the | |
| 380 // session is destroyed after this is called. (However, it may not | |
| 381 // be destroyed right away, e.g. when a SpdySession function is | |
| 382 // present in the call stack.) | |
| 383 // | |
| 384 // |err| should be < ERR_IO_PENDING; this function is intended to be | |
| 385 // called on error. | |
| 386 // |description| indicates the reason for the error. | |
| 387 void CloseSessionOnError(Error err, const std::string& description); | |
| 388 | |
| 389 // Mark this session as unavailable, meaning that it will not be used to | |
| 390 // service new streams. Unlike when a GOAWAY frame is received, this function | |
| 391 // will not close any streams. | |
| 392 void MakeUnavailable(); | |
| 393 | |
| 394 // Closes all active streams with stream id's greater than | |
| 395 // |last_good_stream_id|, as well as any created or pending | |
| 396 // streams. Must be called only when |availability_state_| >= | |
| 397 // STATE_GOING_AWAY. After this function, DcheckGoingAway() will | |
| 398 // pass. May be called multiple times. | |
| 399 void StartGoingAway(SpdyStreamId last_good_stream_id, Error status); | |
| 400 | |
| 401 // Must be called only when going away (i.e., DcheckGoingAway() | |
| 402 // passes). If there are no more active streams and the session | |
| 403 // isn't closed yet, close it. | |
| 404 void MaybeFinishGoingAway(); | |
| 405 | |
| 406 // Retrieves information on the current state of the SPDY session as a | |
| 407 // Value. Caller takes possession of the returned value. | |
| 408 base::Value* GetInfoAsValue() const; | |
| 409 | |
| 410 // Indicates whether the session is being reused after having successfully | |
| 411 // used to send/receive data in the past or if the underlying socket was idle | |
| 412 // before being used for a SPDY session. | |
| 413 bool IsReused() const; | |
| 414 | |
| 415 // Returns true if the underlying transport socket ever had any reads or | |
| 416 // writes. | |
| 417 bool WasEverUsed() const { | |
| 418 return connection_->socket()->WasEverUsed(); | |
| 419 } | |
| 420 | |
| 421 // Returns the load timing information from the perspective of the given | |
| 422 // stream. If it's not the first stream, the connection is considered reused | |
| 423 // for that stream. | |
| 424 // | |
| 425 // This uses a different notion of reuse than IsReused(). This function | |
| 426 // sets |socket_reused| to false only if |stream_id| is the ID of the first | |
| 427 // stream using the session. IsReused(), on the other hand, indicates if the | |
| 428 // session has been used to send/receive data at all. | |
| 429 bool GetLoadTimingInfo(SpdyStreamId stream_id, | |
| 430 LoadTimingInfo* load_timing_info) const; | |
| 431 | |
| 432 // Returns true if session is not currently active | |
| 433 bool is_active() const { | |
| 434 return !active_streams_.empty() || !created_streams_.empty(); | |
| 435 } | |
| 436 | |
| 437 // Access to the number of active and pending streams. These are primarily | |
| 438 // available for testing and diagnostics. | |
| 439 size_t num_active_streams() const { return active_streams_.size(); } | |
| 440 size_t num_unclaimed_pushed_streams() const { | |
| 441 return unclaimed_pushed_streams_.size(); | |
| 442 } | |
| 443 size_t num_created_streams() const { return created_streams_.size(); } | |
| 444 | |
| 445 size_t num_pushed_streams() const { return num_pushed_streams_; } | |
| 446 size_t num_active_pushed_streams() const { | |
| 447 return num_active_pushed_streams_; | |
| 448 } | |
| 449 | |
| 450 size_t pending_create_stream_queue_size(RequestPriority priority) const { | |
| 451 DCHECK_GE(priority, MINIMUM_PRIORITY); | |
| 452 DCHECK_LE(priority, MAXIMUM_PRIORITY); | |
| 453 return pending_create_stream_queues_[priority].size(); | |
| 454 } | |
| 455 | |
| 456 // Returns the (version-dependent) flow control state. | |
| 457 FlowControlState flow_control_state() const { | |
| 458 return flow_control_state_; | |
| 459 } | |
| 460 | |
| 461 // Returns the current |stream_initial_send_window_size_|. | |
| 462 int32 stream_initial_send_window_size() const { | |
| 463 return stream_initial_send_window_size_; | |
| 464 } | |
| 465 | |
| 466 // Returns the current |stream_initial_recv_window_size_|. | |
| 467 int32 stream_initial_recv_window_size() const { | |
| 468 return stream_initial_recv_window_size_; | |
| 469 } | |
| 470 | |
| 471 // Returns true if no stream in the session can send data due to | |
| 472 // session flow control. | |
| 473 bool IsSendStalled() const { | |
| 474 return | |
| 475 flow_control_state_ == FLOW_CONTROL_STREAM_AND_SESSION && | |
| 476 session_send_window_size_ == 0; | |
| 477 } | |
| 478 | |
| 479 const BoundNetLog& net_log() const { return net_log_; } | |
| 480 | |
| 481 int GetPeerAddress(IPEndPoint* address) const; | |
| 482 int GetLocalAddress(IPEndPoint* address) const; | |
| 483 | |
| 484 // Adds |alias| to set of aliases associated with this session. | |
| 485 void AddPooledAlias(const SpdySessionKey& alias_key); | |
| 486 | |
| 487 // Returns the set of aliases associated with this session. | |
| 488 const std::set<SpdySessionKey>& pooled_aliases() const { | |
| 489 return pooled_aliases_; | |
| 490 } | |
| 491 | |
| 492 SpdyMajorVersion GetProtocolVersion() const; | |
| 493 | |
| 494 size_t GetDataFrameMinimumSize() const { | |
| 495 return buffered_spdy_framer_->GetDataFrameMinimumSize(); | |
| 496 } | |
| 497 | |
| 498 size_t GetControlFrameHeaderSize() const { | |
| 499 return buffered_spdy_framer_->GetControlFrameHeaderSize(); | |
| 500 } | |
| 501 | |
| 502 size_t GetFrameMinimumSize() const { | |
| 503 return buffered_spdy_framer_->GetFrameMinimumSize(); | |
| 504 } | |
| 505 | |
| 506 size_t GetFrameMaximumSize() const { | |
| 507 return buffered_spdy_framer_->GetFrameMaximumSize(); | |
| 508 } | |
| 509 | |
| 510 size_t GetDataFrameMaximumPayload() const { | |
| 511 return buffered_spdy_framer_->GetDataFrameMaximumPayload(); | |
| 512 } | |
| 513 | |
| 514 static int32 GetInitialWindowSize(NextProto protocol) { | |
| 515 return protocol < kProtoSPDY4MinimumVersion ? 65536 : 65535; | |
| 516 } | |
| 517 | |
| 518 // https://http2.github.io/http2-spec/#TLSUsage mandates minimum security | |
| 519 // standards for TLS. | |
| 520 bool HasAcceptableTransportSecurity() const; | |
| 521 | |
| 522 // Must be used only by |pool_|. | |
| 523 base::WeakPtr<SpdySession> GetWeakPtr(); | |
| 524 | |
| 525 // HigherLayeredPool implementation: | |
| 526 bool CloseOneIdleConnection() override; | |
| 527 | |
| 528 private: | |
| 529 friend class base::RefCounted<SpdySession>; | |
| 530 friend class SpdyStreamRequest; | |
| 531 friend class SpdySessionTest; | |
| 532 | |
| 533 // Allow tests to access our innards for testing purposes. | |
| 534 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ClientPing); | |
| 535 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, FailedPing); | |
| 536 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, GetActivePushStream); | |
| 537 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, DeleteExpiredPushStreams); | |
| 538 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ProtocolNegotiation); | |
| 539 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, ClearSettings); | |
| 540 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, AdjustRecvWindowSize); | |
| 541 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, AdjustSendWindowSize); | |
| 542 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlInactiveStream); | |
| 543 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlNoReceiveLeaks); | |
| 544 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlNoSendLeaks); | |
| 545 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, SessionFlowControlEndToEnd); | |
| 546 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, StreamIdSpaceExhausted); | |
| 547 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, UnstallRacesWithStreamCreation); | |
| 548 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, GoAwayOnSessionFlowControlError); | |
| 549 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, | |
| 550 RejectPushedStreamExceedingConcurrencyLimit); | |
| 551 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, IgnoreReservedRemoteStreamsCount); | |
| 552 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, | |
| 553 CancelReservedStreamOnHeadersReceived); | |
| 554 FRIEND_TEST_ALL_PREFIXES(SpdySessionTest, RejectInvalidUnknownFrames); | |
| 555 | |
| 556 typedef std::deque<base::WeakPtr<SpdyStreamRequest> > | |
| 557 PendingStreamRequestQueue; | |
| 558 | |
| 559 struct ActiveStreamInfo { | |
| 560 ActiveStreamInfo(); | |
| 561 explicit ActiveStreamInfo(SpdyStream* stream); | |
| 562 ~ActiveStreamInfo(); | |
| 563 | |
| 564 SpdyStream* stream; | |
| 565 bool waiting_for_syn_reply; | |
| 566 }; | |
| 567 typedef std::map<SpdyStreamId, ActiveStreamInfo> ActiveStreamMap; | |
| 568 | |
| 569 struct PushedStreamInfo { | |
| 570 PushedStreamInfo(); | |
| 571 PushedStreamInfo(SpdyStreamId stream_id, base::TimeTicks creation_time); | |
| 572 ~PushedStreamInfo(); | |
| 573 | |
| 574 SpdyStreamId stream_id; | |
| 575 base::TimeTicks creation_time; | |
| 576 }; | |
| 577 typedef std::map<GURL, PushedStreamInfo> PushedStreamMap; | |
| 578 | |
| 579 typedef std::set<SpdyStream*> CreatedStreamSet; | |
| 580 | |
| 581 enum AvailabilityState { | |
| 582 // The session is available in its socket pool and can be used | |
| 583 // freely. | |
| 584 STATE_AVAILABLE, | |
| 585 // The session can process data on existing streams but will | |
| 586 // refuse to create new ones. | |
| 587 STATE_GOING_AWAY, | |
| 588 // The session is draining its write queue in preparation of closing. | |
| 589 // Further writes will not be queued, and further reads will not be issued | |
| 590 // (though the remainder of a current read may be processed). The session | |
| 591 // will be destroyed by its write loop once the write queue is drained. | |
| 592 STATE_DRAINING, | |
| 593 }; | |
| 594 | |
| 595 enum ReadState { | |
| 596 READ_STATE_DO_READ, | |
| 597 READ_STATE_DO_READ_COMPLETE, | |
| 598 }; | |
| 599 | |
| 600 enum WriteState { | |
| 601 // There is no in-flight write and the write queue is empty. | |
| 602 WRITE_STATE_IDLE, | |
| 603 WRITE_STATE_DO_WRITE, | |
| 604 WRITE_STATE_DO_WRITE_COMPLETE, | |
| 605 }; | |
| 606 | |
| 607 // Checks whether a stream for the given |url| can be created or | |
| 608 // retrieved from the set of unclaimed push streams. Returns OK if | |
| 609 // so. Otherwise, the session is closed and an error < | |
| 610 // ERR_IO_PENDING is returned. | |
| 611 Error TryAccessStream(const GURL& url); | |
| 612 | |
| 613 // Called by SpdyStreamRequest to start a request to create a | |
| 614 // stream. If OK is returned, then |stream| will be filled in with a | |
| 615 // valid stream. If ERR_IO_PENDING is returned, then | |
| 616 // |request->OnRequestComplete{Success,Failure}()| will be called | |
| 617 // when the stream is created (unless it is cancelled). Otherwise, | |
| 618 // no stream is created and the error is returned. | |
| 619 int TryCreateStream(const base::WeakPtr<SpdyStreamRequest>& request, | |
| 620 base::WeakPtr<SpdyStream>* stream); | |
| 621 | |
| 622 // Actually create a stream into |stream|. Returns OK if successful; | |
| 623 // otherwise, returns an error and |stream| is not filled. | |
| 624 int CreateStream(const SpdyStreamRequest& request, | |
| 625 base::WeakPtr<SpdyStream>* stream); | |
| 626 | |
| 627 // Called by SpdyStreamRequest to remove |request| from the stream | |
| 628 // creation queue. | |
| 629 void CancelStreamRequest(const base::WeakPtr<SpdyStreamRequest>& request); | |
| 630 | |
| 631 // Returns the next pending stream request to process, or NULL if | |
| 632 // there is none. | |
| 633 base::WeakPtr<SpdyStreamRequest> GetNextPendingStreamRequest(); | |
| 634 | |
| 635 // Called when there is room to create more streams (e.g., a stream | |
| 636 // was closed). Processes as many pending stream requests as | |
| 637 // possible. | |
| 638 void ProcessPendingStreamRequests(); | |
| 639 | |
| 640 bool TryCreatePushStream(SpdyStreamId stream_id, | |
| 641 SpdyStreamId associated_stream_id, | |
| 642 SpdyPriority priority, | |
| 643 const SpdyHeaderBlock& headers); | |
| 644 | |
| 645 // Close the stream pointed to by the given iterator. Note that that | |
| 646 // stream may hold the last reference to the session. | |
| 647 void CloseActiveStreamIterator(ActiveStreamMap::iterator it, int status); | |
| 648 | |
| 649 // Close the stream pointed to by the given iterator. Note that that | |
| 650 // stream may hold the last reference to the session. | |
| 651 void CloseCreatedStreamIterator(CreatedStreamSet::iterator it, int status); | |
| 652 | |
| 653 // Calls EnqueueResetStreamFrame() and then | |
| 654 // CloseActiveStreamIterator(). | |
| 655 void ResetStreamIterator(ActiveStreamMap::iterator it, | |
| 656 SpdyRstStreamStatus status, | |
| 657 const std::string& description); | |
| 658 | |
| 659 // Send a RST_STREAM frame with the given parameters. There should | |
| 660 // either be no active stream with the given ID, or that active | |
| 661 // stream should be closed shortly after this function is called. | |
| 662 // | |
| 663 // TODO(akalin): Rename this to EnqueueResetStreamFrame(). | |
| 664 void EnqueueResetStreamFrame(SpdyStreamId stream_id, | |
| 665 RequestPriority priority, | |
| 666 SpdyRstStreamStatus status, | |
| 667 const std::string& description); | |
| 668 | |
| 669 // Calls DoReadLoop. Use this function instead of DoReadLoop when | |
| 670 // posting a task to pump the read loop. | |
| 671 void PumpReadLoop(ReadState expected_read_state, int result); | |
| 672 | |
| 673 // Advance the ReadState state machine. |expected_read_state| is the | |
| 674 // expected starting read state. | |
| 675 // | |
| 676 // This function must always be called via PumpReadLoop(). | |
| 677 int DoReadLoop(ReadState expected_read_state, int result); | |
| 678 // The implementations of the states of the ReadState state machine. | |
| 679 int DoRead(); | |
| 680 int DoReadComplete(int result); | |
| 681 | |
| 682 // Calls DoWriteLoop. If |availability_state_| is STATE_DRAINING and no | |
| 683 // writes remain, the session is removed from the session pool and | |
| 684 // destroyed. | |
| 685 // | |
| 686 // Use this function instead of DoWriteLoop when posting a task to | |
| 687 // pump the write loop. | |
| 688 void PumpWriteLoop(WriteState expected_write_state, int result); | |
| 689 | |
| 690 // Iff the write loop is not currently active, posts a callback into | |
| 691 // PumpWriteLoop(). | |
| 692 void MaybePostWriteLoop(); | |
| 693 | |
| 694 // Advance the WriteState state machine. |expected_write_state| is | |
| 695 // the expected starting write state. | |
| 696 // | |
| 697 // This function must always be called via PumpWriteLoop(). | |
| 698 int DoWriteLoop(WriteState expected_write_state, int result); | |
| 699 // The implementations of the states of the WriteState state machine. | |
| 700 int DoWrite(); | |
| 701 int DoWriteComplete(int result); | |
| 702 | |
| 703 // TODO(akalin): Rename the Send* and Write* functions below to | |
| 704 // Enqueue*. | |
| 705 | |
| 706 // Send initial data. Called when a connection is successfully | |
| 707 // established in InitializeWithSocket() and | |
| 708 // |enable_sending_initial_data_| is true. | |
| 709 void SendInitialData(); | |
| 710 | |
| 711 // Helper method to send a SETTINGS frame. | |
| 712 void SendSettings(const SettingsMap& settings); | |
| 713 | |
| 714 // Handle SETTING. Either when we send settings, or when we receive a | |
| 715 // SETTINGS control frame, update our SpdySession accordingly. | |
| 716 void HandleSetting(uint32 id, uint32 value); | |
| 717 | |
| 718 // Adjust the send window size of all ActiveStreams and PendingStreamRequests. | |
| 719 void UpdateStreamsSendWindowSize(int32 delta_window_size); | |
| 720 | |
| 721 // Send the PING (preface-PING) frame. | |
| 722 void SendPrefacePingIfNoneInFlight(); | |
| 723 | |
| 724 // Send PING if there are no PINGs in flight and we haven't heard from server. | |
| 725 void SendPrefacePing(); | |
| 726 | |
| 727 // Send a single WINDOW_UPDATE frame. | |
| 728 void SendWindowUpdateFrame(SpdyStreamId stream_id, uint32 delta_window_size, | |
| 729 RequestPriority priority); | |
| 730 | |
| 731 // Send the PING frame. | |
| 732 void WritePingFrame(SpdyPingId unique_id, bool is_ack); | |
| 733 | |
| 734 // Post a CheckPingStatus call after delay. Don't post if there is already | |
| 735 // CheckPingStatus running. | |
| 736 void PlanToCheckPingStatus(); | |
| 737 | |
| 738 // Check the status of the connection. It calls |CloseSessionOnError| if we | |
| 739 // haven't received any data in |kHungInterval| time period. | |
| 740 void CheckPingStatus(base::TimeTicks last_check_time); | |
| 741 | |
| 742 // Get a new stream id. | |
| 743 SpdyStreamId GetNewStreamId(); | |
| 744 | |
| 745 // Pushes the given frame with the given priority into the write | |
| 746 // queue for the session. | |
| 747 void EnqueueSessionWrite(RequestPriority priority, | |
| 748 SpdyFrameType frame_type, | |
| 749 scoped_ptr<SpdyFrame> frame); | |
| 750 | |
| 751 // Puts |producer| associated with |stream| onto the write queue | |
| 752 // with the given priority. | |
| 753 void EnqueueWrite(RequestPriority priority, | |
| 754 SpdyFrameType frame_type, | |
| 755 scoped_ptr<SpdyBufferProducer> producer, | |
| 756 const base::WeakPtr<SpdyStream>& stream); | |
| 757 | |
| 758 // Inserts a newly-created stream into |created_streams_|. | |
| 759 void InsertCreatedStream(scoped_ptr<SpdyStream> stream); | |
| 760 | |
| 761 // Activates |stream| (which must be in |created_streams_|) by | |
| 762 // assigning it an ID and returns it. | |
| 763 scoped_ptr<SpdyStream> ActivateCreatedStream(SpdyStream* stream); | |
| 764 | |
| 765 // Inserts a newly-activated stream into |active_streams_|. | |
| 766 void InsertActivatedStream(scoped_ptr<SpdyStream> stream); | |
| 767 | |
| 768 // Remove all internal references to |stream|, call OnClose() on it, | |
| 769 // and process any pending stream requests before deleting it. Note | |
| 770 // that |stream| may hold the last reference to the session. | |
| 771 void DeleteStream(scoped_ptr<SpdyStream> stream, int status); | |
| 772 | |
| 773 // Check if we have a pending pushed-stream for this url | |
| 774 // Returns the stream if found (and returns it from the pending | |
| 775 // list). Returns NULL otherwise. | |
| 776 base::WeakPtr<SpdyStream> GetActivePushStream(const GURL& url); | |
| 777 | |
| 778 // Delegates to |stream->OnInitialResponseHeadersReceived()|. If an | |
| 779 // error is returned, the last reference to |this| may have been | |
| 780 // released. | |
| 781 int OnInitialResponseHeadersReceived(const SpdyHeaderBlock& response_headers, | |
| 782 base::Time response_time, | |
| 783 base::TimeTicks recv_first_byte_time, | |
| 784 SpdyStream* stream); | |
| 785 | |
| 786 void RecordPingRTTHistogram(base::TimeDelta duration); | |
| 787 void RecordHistograms(); | |
| 788 void RecordProtocolErrorHistogram(SpdyProtocolErrorDetails details); | |
| 789 | |
| 790 // DCHECKs that |availability_state_| >= STATE_GOING_AWAY, that | |
| 791 // there are no pending stream creation requests, and that there are | |
| 792 // no created streams. | |
| 793 void DcheckGoingAway() const; | |
| 794 | |
| 795 // Calls DcheckGoingAway(), then DCHECKs that |availability_state_| | |
| 796 // == STATE_DRAINING, |error_on_close_| has a valid value, and that there | |
| 797 // are no active streams or unclaimed pushed streams. | |
| 798 void DcheckDraining() const; | |
| 799 | |
| 800 // If the session is already draining, does nothing. Otherwise, moves | |
| 801 // the session to the draining state. | |
| 802 void DoDrainSession(Error err, const std::string& description); | |
| 803 | |
| 804 // Called right before closing a (possibly-inactive) stream for a | |
| 805 // reason other than being requested to by the stream. | |
| 806 void LogAbandonedStream(SpdyStream* stream, Error status); | |
| 807 | |
| 808 // Called right before closing an active stream for a reason other | |
| 809 // than being requested to by the stream. | |
| 810 void LogAbandonedActiveStream(ActiveStreamMap::const_iterator it, | |
| 811 Error status); | |
| 812 | |
| 813 // Invokes a user callback for stream creation. We provide this method so it | |
| 814 // can be deferred to the MessageLoop, so we avoid re-entrancy problems. | |
| 815 void CompleteStreamRequest( | |
| 816 const base::WeakPtr<SpdyStreamRequest>& pending_request); | |
| 817 | |
| 818 // Remove old unclaimed pushed streams. | |
| 819 void DeleteExpiredPushedStreams(); | |
| 820 | |
| 821 // BufferedSpdyFramerVisitorInterface: | |
| 822 void OnError(SpdyFramer::SpdyError error_code) override; | |
| 823 void OnStreamError(SpdyStreamId stream_id, | |
| 824 const std::string& description) override; | |
| 825 void OnPing(SpdyPingId unique_id, bool is_ack) override; | |
| 826 void OnRstStream(SpdyStreamId stream_id, SpdyRstStreamStatus status) override; | |
| 827 void OnGoAway(SpdyStreamId last_accepted_stream_id, | |
| 828 SpdyGoAwayStatus status) override; | |
| 829 void OnDataFrameHeader(SpdyStreamId stream_id, | |
| 830 size_t length, | |
| 831 bool fin) override; | |
| 832 void OnStreamFrameData(SpdyStreamId stream_id, | |
| 833 const char* data, | |
| 834 size_t len, | |
| 835 bool fin) override; | |
| 836 void OnSettings(bool clear_persisted) override; | |
| 837 void OnSetting(SpdySettingsIds id, uint8 flags, uint32 value) override; | |
| 838 void OnWindowUpdate(SpdyStreamId stream_id, | |
| 839 uint32 delta_window_size) override; | |
| 840 void OnPushPromise(SpdyStreamId stream_id, | |
| 841 SpdyStreamId promised_stream_id, | |
| 842 const SpdyHeaderBlock& headers) override; | |
| 843 void OnSynStream(SpdyStreamId stream_id, | |
| 844 SpdyStreamId associated_stream_id, | |
| 845 SpdyPriority priority, | |
| 846 bool fin, | |
| 847 bool unidirectional, | |
| 848 const SpdyHeaderBlock& headers) override; | |
| 849 void OnSynReply(SpdyStreamId stream_id, | |
| 850 bool fin, | |
| 851 const SpdyHeaderBlock& headers) override; | |
| 852 void OnHeaders(SpdyStreamId stream_id, | |
| 853 bool has_priority, | |
| 854 SpdyPriority priority, | |
| 855 bool fin, | |
| 856 const SpdyHeaderBlock& headers) override; | |
| 857 bool OnUnknownFrame(SpdyStreamId stream_id, int frame_type) override; | |
| 858 | |
| 859 // SpdyFramerDebugVisitorInterface | |
| 860 void OnSendCompressedFrame(SpdyStreamId stream_id, | |
| 861 SpdyFrameType type, | |
| 862 size_t payload_len, | |
| 863 size_t frame_len) override; | |
| 864 void OnReceiveCompressedFrame(SpdyStreamId stream_id, | |
| 865 SpdyFrameType type, | |
| 866 size_t frame_len) override; | |
| 867 | |
| 868 // Called when bytes are consumed from a SpdyBuffer for a DATA frame | |
| 869 // that is to be written or is being written. Increases the send | |
| 870 // window size accordingly if some or all of the SpdyBuffer is being | |
| 871 // discarded. | |
| 872 // | |
| 873 // If session flow control is turned off, this must not be called. | |
| 874 void OnWriteBufferConsumed(size_t frame_payload_size, | |
| 875 size_t consume_size, | |
| 876 SpdyBuffer::ConsumeSource consume_source); | |
| 877 | |
| 878 // Called by OnWindowUpdate() (which is in turn called by the | |
| 879 // framer) to increase this session's send window size by | |
| 880 // |delta_window_size| from a WINDOW_UPDATE frome, which must be at | |
| 881 // least 1. If |delta_window_size| would cause this session's send | |
| 882 // window size to overflow, does nothing. | |
| 883 // | |
| 884 // If session flow control is turned off, this must not be called. | |
| 885 void IncreaseSendWindowSize(int32 delta_window_size); | |
| 886 | |
| 887 // If session flow control is turned on, called by CreateDataFrame() | |
| 888 // (which is in turn called by a stream) to decrease this session's | |
| 889 // send window size by |delta_window_size|, which must be at least 1 | |
| 890 // and at most kMaxSpdyFrameChunkSize. |delta_window_size| must not | |
| 891 // cause this session's send window size to go negative. | |
| 892 // | |
| 893 // If session flow control is turned off, this must not be called. | |
| 894 void DecreaseSendWindowSize(int32 delta_window_size); | |
| 895 | |
| 896 // Called when bytes are consumed by the delegate from a SpdyBuffer | |
| 897 // containing received data. Increases the receive window size | |
| 898 // accordingly. | |
| 899 // | |
| 900 // If session flow control is turned off, this must not be called. | |
| 901 void OnReadBufferConsumed(size_t consume_size, | |
| 902 SpdyBuffer::ConsumeSource consume_source); | |
| 903 | |
| 904 // Called by OnReadBufferConsume to increase this session's receive | |
| 905 // window size by |delta_window_size|, which must be at least 1 and | |
| 906 // must not cause this session's receive window size to overflow, | |
| 907 // possibly also sending a WINDOW_UPDATE frame. Also called during | |
| 908 // initialization to set the initial receive window size. | |
| 909 // | |
| 910 // If session flow control is turned off, this must not be called. | |
| 911 void IncreaseRecvWindowSize(int32 delta_window_size); | |
| 912 | |
| 913 // Called by OnStreamFrameData (which is in turn called by the | |
| 914 // framer) to decrease this session's receive window size by | |
| 915 // |delta_window_size|, which must be at least 1 and must not cause | |
| 916 // this session's receive window size to go negative. | |
| 917 // | |
| 918 // If session flow control is turned off, this must not be called. | |
| 919 void DecreaseRecvWindowSize(int32 delta_window_size); | |
| 920 | |
| 921 // Queue a send-stalled stream for possibly resuming once we're not | |
| 922 // send-stalled anymore. | |
| 923 void QueueSendStalledStream(const SpdyStream& stream); | |
| 924 | |
| 925 // Go through the queue of send-stalled streams and try to resume as | |
| 926 // many as possible. | |
| 927 void ResumeSendStalledStreams(); | |
| 928 | |
| 929 // Returns the next stream to possibly resume, or 0 if the queue is | |
| 930 // empty. | |
| 931 SpdyStreamId PopStreamToPossiblyResume(); | |
| 932 | |
| 933 // -------------------------- | |
| 934 // Helper methods for testing | |
| 935 // -------------------------- | |
| 936 | |
| 937 void set_connection_at_risk_of_loss_time(base::TimeDelta duration) { | |
| 938 connection_at_risk_of_loss_time_ = duration; | |
| 939 } | |
| 940 | |
| 941 void set_hung_interval(base::TimeDelta duration) { | |
| 942 hung_interval_ = duration; | |
| 943 } | |
| 944 | |
| 945 void set_max_concurrent_pushed_streams(size_t value) { | |
| 946 max_concurrent_pushed_streams_ = value; | |
| 947 } | |
| 948 | |
| 949 int64 pings_in_flight() const { return pings_in_flight_; } | |
| 950 | |
| 951 SpdyPingId next_ping_id() const { return next_ping_id_; } | |
| 952 | |
| 953 base::TimeTicks last_activity_time() const { return last_activity_time_; } | |
| 954 | |
| 955 bool check_ping_status_pending() const { return check_ping_status_pending_; } | |
| 956 | |
| 957 size_t max_concurrent_streams() const { return max_concurrent_streams_; } | |
| 958 | |
| 959 // Returns the SSLClientSocket that this SPDY session sits on top of, | |
| 960 // or NULL, if the transport is not SSL. | |
| 961 SSLClientSocket* GetSSLClientSocket() const; | |
| 962 | |
| 963 // Whether Do{Read,Write}Loop() is in the call stack. Useful for | |
| 964 // making sure we don't destroy ourselves prematurely in that case. | |
| 965 bool in_io_loop_; | |
| 966 | |
| 967 // The key used to identify this session. | |
| 968 const SpdySessionKey spdy_session_key_; | |
| 969 | |
| 970 // Set set of SpdySessionKeys for which this session has serviced | |
| 971 // requests. | |
| 972 std::set<SpdySessionKey> pooled_aliases_; | |
| 973 | |
| 974 // |pool_| owns us, therefore its lifetime must exceed ours. We set | |
| 975 // this to NULL after we are removed from the pool. | |
| 976 SpdySessionPool* pool_; | |
| 977 const base::WeakPtr<HttpServerProperties> http_server_properties_; | |
| 978 | |
| 979 TransportSecurityState* transport_security_state_; | |
| 980 | |
| 981 // The socket handle for this session. | |
| 982 scoped_ptr<ClientSocketHandle> connection_; | |
| 983 | |
| 984 // The read buffer used to read data from the socket. | |
| 985 scoped_refptr<IOBuffer> read_buffer_; | |
| 986 | |
| 987 SpdyStreamId stream_hi_water_mark_; // The next stream id to use. | |
| 988 | |
| 989 // Used to ensure the server increments push stream ids correctly. | |
| 990 SpdyStreamId last_accepted_push_stream_id_; | |
| 991 | |
| 992 // Queue, for each priority, of pending stream requests that have | |
| 993 // not yet been satisfied. | |
| 994 PendingStreamRequestQueue pending_create_stream_queues_[NUM_PRIORITIES]; | |
| 995 | |
| 996 // Map from stream id to all active streams. Streams are active in the sense | |
| 997 // that they have a consumer (typically SpdyNetworkTransaction and regardless | |
| 998 // of whether or not there is currently any ongoing IO [might be waiting for | |
| 999 // the server to start pushing the stream]) or there are still network events | |
| 1000 // incoming even though the consumer has already gone away (cancellation). | |
| 1001 // | |
| 1002 // |active_streams_| owns all its SpdyStream objects. | |
| 1003 // | |
| 1004 // TODO(willchan): Perhaps we should separate out cancelled streams and move | |
| 1005 // them into a separate ActiveStreamMap, and not deliver network events to | |
| 1006 // them? | |
| 1007 ActiveStreamMap active_streams_; | |
| 1008 | |
| 1009 // (Bijective) map from the URL to the ID of the streams that have | |
| 1010 // already started to be pushed by the server, but do not have | |
| 1011 // consumers yet. Contains a subset of |active_streams_|. | |
| 1012 PushedStreamMap unclaimed_pushed_streams_; | |
| 1013 | |
| 1014 // Set of all created streams but that have not yet sent any frames. | |
| 1015 // | |
| 1016 // |created_streams_| owns all its SpdyStream objects. | |
| 1017 CreatedStreamSet created_streams_; | |
| 1018 | |
| 1019 // Number of pushed streams. All active streams are stored in | |
| 1020 // |active_streams_|, but it's better to know the number of push streams | |
| 1021 // without traversing the whole collection. | |
| 1022 size_t num_pushed_streams_; | |
| 1023 | |
| 1024 // Number of active pushed streams in |active_streams_|, i.e. not in reserved | |
| 1025 // remote state. Streams in reserved state are not counted towards any | |
| 1026 // concurrency limits. | |
| 1027 size_t num_active_pushed_streams_; | |
| 1028 | |
| 1029 // The write queue. | |
| 1030 SpdyWriteQueue write_queue_; | |
| 1031 | |
| 1032 // Data for the frame we are currently sending. | |
| 1033 | |
| 1034 // The buffer we're currently writing. | |
| 1035 scoped_ptr<SpdyBuffer> in_flight_write_; | |
| 1036 // The type of the frame in |in_flight_write_|. | |
| 1037 SpdyFrameType in_flight_write_frame_type_; | |
| 1038 // The size of the frame in |in_flight_write_|. | |
| 1039 size_t in_flight_write_frame_size_; | |
| 1040 // The stream to notify when |in_flight_write_| has been written to | |
| 1041 // the socket completely. | |
| 1042 base::WeakPtr<SpdyStream> in_flight_write_stream_; | |
| 1043 | |
| 1044 // Flag if we're using an SSL connection for this SpdySession. | |
| 1045 bool is_secure_; | |
| 1046 | |
| 1047 // Certificate error code when using a secure connection. | |
| 1048 int certificate_error_code_; | |
| 1049 | |
| 1050 // Spdy Frame state. | |
| 1051 scoped_ptr<BufferedSpdyFramer> buffered_spdy_framer_; | |
| 1052 | |
| 1053 // The state variables. | |
| 1054 AvailabilityState availability_state_; | |
| 1055 ReadState read_state_; | |
| 1056 WriteState write_state_; | |
| 1057 | |
| 1058 // If the session is closing (i.e., |availability_state_| is STATE_DRAINING), | |
| 1059 // then |error_on_close_| holds the error with which it was closed, which | |
| 1060 // may be OK (upon a polite GOAWAY) or an error < ERR_IO_PENDING otherwise. | |
| 1061 // Initialized to OK. | |
| 1062 Error error_on_close_; | |
| 1063 | |
| 1064 // Limits | |
| 1065 size_t max_concurrent_streams_; // 0 if no limit | |
| 1066 size_t max_concurrent_streams_limit_; | |
| 1067 size_t max_concurrent_pushed_streams_; | |
| 1068 | |
| 1069 // Some statistics counters for the session. | |
| 1070 int streams_initiated_count_; | |
| 1071 int streams_pushed_count_; | |
| 1072 int streams_pushed_and_claimed_count_; | |
| 1073 int streams_abandoned_count_; | |
| 1074 | |
| 1075 // |total_bytes_received_| keeps track of all the bytes read by the | |
| 1076 // SpdySession. It is used by the |Net.SpdySettingsCwnd...| histograms. | |
| 1077 int total_bytes_received_; | |
| 1078 | |
| 1079 bool sent_settings_; // Did this session send settings when it started. | |
| 1080 bool received_settings_; // Did this session receive at least one settings | |
| 1081 // frame. | |
| 1082 int stalled_streams_; // Count of streams that were ever stalled. | |
| 1083 | |
| 1084 // Count of all pings on the wire, for which we have not gotten a response. | |
| 1085 int64 pings_in_flight_; | |
| 1086 | |
| 1087 // This is the next ping_id (unique_id) to be sent in PING frame. | |
| 1088 SpdyPingId next_ping_id_; | |
| 1089 | |
| 1090 // This is the last time we have sent a PING. | |
| 1091 base::TimeTicks last_ping_sent_time_; | |
| 1092 | |
| 1093 // This is the last time we had activity in the session. | |
| 1094 base::TimeTicks last_activity_time_; | |
| 1095 | |
| 1096 // This is the length of the last compressed frame. | |
| 1097 size_t last_compressed_frame_len_; | |
| 1098 | |
| 1099 // This is the next time that unclaimed push streams should be checked for | |
| 1100 // expirations. | |
| 1101 base::TimeTicks next_unclaimed_push_stream_sweep_time_; | |
| 1102 | |
| 1103 // Indicate if we have already scheduled a delayed task to check the ping | |
| 1104 // status. | |
| 1105 bool check_ping_status_pending_; | |
| 1106 | |
| 1107 // Whether to send the (HTTP/2) connection header prefix. | |
| 1108 bool send_connection_header_prefix_; | |
| 1109 | |
| 1110 // The (version-dependent) flow control state. | |
| 1111 FlowControlState flow_control_state_; | |
| 1112 | |
| 1113 // Initial send window size for this session's streams. Can be | |
| 1114 // changed by an arriving SETTINGS frame. Newly created streams use | |
| 1115 // this value for the initial send window size. | |
| 1116 int32 stream_initial_send_window_size_; | |
| 1117 | |
| 1118 // Initial receive window size for this session's streams. There are | |
| 1119 // plans to add a command line switch that would cause a SETTINGS | |
| 1120 // frame with window size announcement to be sent on startup. Newly | |
| 1121 // created streams will use this value for the initial receive | |
| 1122 // window size. | |
| 1123 int32 stream_initial_recv_window_size_; | |
| 1124 | |
| 1125 // Session flow control variables. All zero unless session flow | |
| 1126 // control is turned on. | |
| 1127 int32 session_send_window_size_; | |
| 1128 int32 session_recv_window_size_; | |
| 1129 int32 session_unacked_recv_window_bytes_; | |
| 1130 | |
| 1131 // A queue of stream IDs that have been send-stalled at some point | |
| 1132 // in the past. | |
| 1133 std::deque<SpdyStreamId> stream_send_unstall_queue_[NUM_PRIORITIES]; | |
| 1134 | |
| 1135 BoundNetLog net_log_; | |
| 1136 | |
| 1137 // Outside of tests, these should always be true. | |
| 1138 bool verify_domain_authentication_; | |
| 1139 bool enable_sending_initial_data_; | |
| 1140 bool enable_compression_; | |
| 1141 bool enable_ping_based_connection_checking_; | |
| 1142 | |
| 1143 // The SPDY protocol used. Always between kProtoSPDYMinimumVersion and | |
| 1144 // kProtoSPDYMaximumVersion. | |
| 1145 NextProto protocol_; | |
| 1146 | |
| 1147 // |connection_at_risk_of_loss_time_| is an optimization to avoid sending | |
| 1148 // wasteful preface pings (when we just got some data). | |
| 1149 // | |
| 1150 // If it is zero (the most conservative figure), then we always send the | |
| 1151 // preface ping (when none are in flight). | |
| 1152 // | |
| 1153 // It is common for TCP/IP sessions to time out in about 3-5 minutes. | |
| 1154 // Certainly if it has been more than 3 minutes, we do want to send a preface | |
| 1155 // ping. | |
| 1156 // | |
| 1157 // We don't think any connection will time out in under about 10 seconds. So | |
| 1158 // this might as well be set to something conservative like 10 seconds. Later, | |
| 1159 // we could adjust it to send fewer pings perhaps. | |
| 1160 base::TimeDelta connection_at_risk_of_loss_time_; | |
| 1161 | |
| 1162 // The amount of time that we are willing to tolerate with no activity (of any | |
| 1163 // form), while there is a ping in flight, before we declare the connection to | |
| 1164 // be hung. TODO(rtenneti): When hung, instead of resetting connection, race | |
| 1165 // to build a new connection, and see if that completes before we (finally) | |
| 1166 // get a PING response (http://crbug.com/127812). | |
| 1167 base::TimeDelta hung_interval_; | |
| 1168 | |
| 1169 // This SPDY proxy is allowed to push resources from origins that are | |
| 1170 // different from those of their associated streams. | |
| 1171 HostPortPair trusted_spdy_proxy_; | |
| 1172 | |
| 1173 TimeFunc time_func_; | |
| 1174 | |
| 1175 // Used for posting asynchronous IO tasks. We use this even though | |
| 1176 // SpdySession is refcounted because we don't need to keep the SpdySession | |
| 1177 // alive if the last reference is within a RunnableMethod. Just revoke the | |
| 1178 // method. | |
| 1179 base::WeakPtrFactory<SpdySession> weak_factory_; | |
| 1180 }; | |
| 1181 | |
| 1182 } // namespace net | |
| 1183 | |
| 1184 #endif // NET_SPDY_SPDY_SESSION_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master