Project import generated by Copybara.
PiperOrigin-RevId: 237361882
Change-Id: I109a68f44db867b20f8c6a7732b0ce657133e52a
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
new file mode 100644
index 0000000..8976842
--- /dev/null
+++ b/quic/core/quic_session.h
@@ -0,0 +1,692 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// A QuicSession, which demuxes a single connection to individual streams.
+
+#ifndef QUICHE_QUIC_CORE_QUIC_SESSION_H_
+#define QUICHE_QUIC_CORE_QUIC_SESSION_H_
+
+#include <cstddef>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "base/macros.h"
+#include "net/third_party/quiche/src/quic/core/legacy_quic_stream_id_manager.h"
+#include "net/third_party/quiche/src/quic/core/quic_connection.h"
+#include "net/third_party/quiche/src/quic/core/quic_control_frame_manager.h"
+#include "net/third_party/quiche/src/quic/core/quic_crypto_stream.h"
+#include "net/third_party/quiche/src/quic/core/quic_packet_creator.h"
+#include "net/third_party/quiche/src/quic/core/quic_packets.h"
+#include "net/third_party/quiche/src/quic/core/quic_stream.h"
+#include "net/third_party/quiche/src/quic/core/quic_stream_frame_data_producer.h"
+#include "net/third_party/quiche/src/quic/core/quic_write_blocked_list.h"
+#include "net/third_party/quiche/src/quic/core/session_notifier_interface.h"
+#include "net/third_party/quiche/src/quic/core/uber_quic_stream_id_manager.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_containers.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_socket_address.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string.h"
+
+namespace quic {
+
+class QuicCryptoStream;
+class QuicFlowController;
+class QuicStream;
+class QuicStreamIdManager;
+
+namespace test {
+class QuicSessionPeer;
+} // namespace test
+
+class QUIC_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface,
+ public SessionNotifierInterface,
+ public QuicStreamFrameDataProducer {
+ public:
+ // An interface from the session to the entity owning the session.
+ // This lets the session notify its owner (the Dispatcher) when the connection
+ // is closed, blocked, or added/removed from the time-wait list.
+ class Visitor {
+ public:
+ virtual ~Visitor() {}
+
+ // Called when the connection is closed after the streams have been closed.
+ virtual void OnConnectionClosed(QuicConnectionId connection_id,
+ QuicErrorCode error,
+ const QuicString& error_details,
+ ConnectionCloseSource source) = 0;
+
+ // Called when the session has become write blocked.
+ virtual void OnWriteBlocked(QuicBlockedWriterInterface* blocked_writer) = 0;
+
+ // Called when the session receives reset on a stream from the peer.
+ virtual void OnRstStreamReceived(const QuicRstStreamFrame& frame) = 0;
+
+ // Called when the session receives a STOP_SENDING for a stream from the
+ // peer.
+ virtual void OnStopSendingReceived(const QuicStopSendingFrame& frame) = 0;
+ };
+
+ // CryptoHandshakeEvent enumerates the events generated by a QuicCryptoStream.
+ enum CryptoHandshakeEvent {
+ // ENCRYPTION_FIRST_ESTABLISHED indicates that a full client hello has been
+ // sent by a client and that subsequent packets will be encrypted. (Client
+ // only.)
+ ENCRYPTION_FIRST_ESTABLISHED,
+ // ENCRYPTION_REESTABLISHED indicates that a client hello was rejected by
+ // the server and thus the encryption key has been updated. Therefore the
+ // connection should resend any packets that were sent under
+ // ENCRYPTION_ZERO_RTT. (Client only.)
+ ENCRYPTION_REESTABLISHED,
+ // HANDSHAKE_CONFIRMED, in a client, indicates the server has accepted
+ // our handshake. In a server it indicates that a full, valid client hello
+ // has been received. (Client and server.)
+ HANDSHAKE_CONFIRMED,
+ };
+
+ // Does not take ownership of |connection| or |visitor|.
+ QuicSession(QuicConnection* connection,
+ Visitor* owner,
+ const QuicConfig& config,
+ const ParsedQuicVersionVector& supported_versions);
+ QuicSession(const QuicSession&) = delete;
+ QuicSession& operator=(const QuicSession&) = delete;
+
+ ~QuicSession() override;
+
+ virtual void Initialize();
+
+ // QuicConnectionVisitorInterface methods:
+ void OnStreamFrame(const QuicStreamFrame& frame) override;
+ void OnCryptoFrame(const QuicCryptoFrame& frame) override;
+ void OnRstStream(const QuicRstStreamFrame& frame) override;
+ void OnGoAway(const QuicGoAwayFrame& frame) override;
+ void OnMessageReceived(QuicStringPiece message) override;
+ void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
+ void OnBlockedFrame(const QuicBlockedFrame& frame) override;
+ void OnConnectionClosed(QuicErrorCode error,
+ const QuicString& error_details,
+ ConnectionCloseSource source) override;
+ void OnWriteBlocked() override;
+ void OnSuccessfulVersionNegotiation(
+ const ParsedQuicVersion& version) override;
+ void OnConnectivityProbeReceived(
+ const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address) override;
+ void OnCanWrite() override;
+ void OnCongestionWindowChange(QuicTime /*now*/) override {}
+ void OnConnectionMigration(AddressChangeType type) override {}
+ // Adds a connection level WINDOW_UPDATE frame.
+ void OnAckNeedsRetransmittableFrame() override;
+ void SendPing() override;
+ bool WillingAndAbleToWrite() const override;
+ bool HasPendingHandshake() const override;
+ void OnPathDegrading() override;
+ bool AllowSelfAddressChange() const override;
+ void OnForwardProgressConfirmed() override;
+ bool OnMaxStreamIdFrame(const QuicMaxStreamIdFrame& frame) override;
+ bool OnStreamIdBlockedFrame(const QuicStreamIdBlockedFrame& frame) override;
+ bool OnStopSendingFrame(const QuicStopSendingFrame& frame) override;
+
+ // QuicStreamFrameDataProducer
+ WriteStreamDataResult WriteStreamData(QuicStreamId id,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+ bool WriteCryptoData(EncryptionLevel level,
+ QuicStreamOffset offset,
+ QuicByteCount data_length,
+ QuicDataWriter* writer) override;
+
+ // SessionNotifierInterface methods:
+ bool OnFrameAcked(const QuicFrame& frame,
+ QuicTime::Delta ack_delay_time) override;
+ void OnStreamFrameRetransmitted(const QuicStreamFrame& frame) override;
+ void OnFrameLost(const QuicFrame& frame) override;
+ void RetransmitFrames(const QuicFrames& frames,
+ TransmissionType type) override;
+ bool IsFrameOutstanding(const QuicFrame& frame) const override;
+ bool HasUnackedCryptoData() const override;
+
+ // Called on every incoming packet. Passes |packet| through to |connection_|.
+ virtual void ProcessUdpPacket(const QuicSocketAddress& self_address,
+ const QuicSocketAddress& peer_address,
+ const QuicReceivedPacket& packet);
+
+ // Called by streams when they want to write data to the peer.
+ // Returns a pair with the number of bytes consumed from data, and a boolean
+ // indicating if the fin bit was consumed. This does not indicate the data
+ // has been sent on the wire: it may have been turned into a packet and queued
+ // if the socket was unexpectedly blocked.
+ virtual QuicConsumedData WritevData(QuicStream* stream,
+ QuicStreamId id,
+ size_t write_length,
+ QuicStreamOffset offset,
+ StreamSendingState state);
+
+ // Called by application to send |message|. Data copy can be avoided if
+ // |message| is provided in reference counted memory.
+ // Please note, |message| provided in reference counted memory would be moved
+ // internally when message is successfully sent. Thereafter, it would be
+ // undefined behavior if callers try to access the slices through their own
+ // copy of the span object.
+ // Returns the message result which includes the message status and message ID
+ // (valid if the write succeeds). SendMessage flushes a message packet even it
+ // is not full. If the application wants to bundle other data in the same
+ // packet, please consider adding a packet flusher around the SendMessage
+ // and/or WritevData calls.
+ //
+ // OnMessageAcked and OnMessageLost are called when a particular message gets
+ // acked or lost.
+ //
+ // Note that SendMessage will fail with status = MESSAGE_STATUS_BLOCKED
+ // if connection is congestion control blocked or underlying socket is write
+ // blocked. In this case the caller can retry sending message again when
+ // connection becomes available, for example after getting OnCanWrite()
+ // callback.
+ MessageResult SendMessage(QuicMemSliceSpan message);
+
+ // Called when message with |message_id| gets acked.
+ virtual void OnMessageAcked(QuicMessageId message_id);
+
+ // Called when message with |message_id| is considered as lost.
+ virtual void OnMessageLost(QuicMessageId message_id);
+
+ // Called by control frame manager when it wants to write control frames to
+ // the peer. Returns true if |frame| is consumed, false otherwise.
+ virtual bool WriteControlFrame(const QuicFrame& frame);
+
+ // Called by streams when they want to close the stream in both directions.
+ virtual void SendRstStream(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written);
+
+ // Called when the session wants to go away and not accept any new streams.
+ virtual void SendGoAway(QuicErrorCode error_code, const QuicString& reason);
+
+ // Sends a BLOCKED frame.
+ virtual void SendBlocked(QuicStreamId id);
+
+ // Sends a WINDOW_UPDATE frame.
+ virtual void SendWindowUpdate(QuicStreamId id, QuicStreamOffset byte_offset);
+
+ // Send a MAX_STREAM_ID frame.
+ void SendMaxStreamId(QuicStreamId max_allowed_incoming_id);
+
+ // Send a STREAM_ID_BLOCKED frame.
+ void SendStreamIdBlocked(QuicStreamId max_allowed_outgoing_id);
+
+ // Create and transmit a STOP_SENDING frame
+ virtual void SendStopSending(uint16_t code, QuicStreamId stream_id);
+
+ // Removes the stream associated with 'stream_id' from the active stream map.
+ virtual void CloseStream(QuicStreamId stream_id);
+
+ // Returns true if outgoing packets will be encrypted, even if the server
+ // hasn't confirmed the handshake yet.
+ virtual bool IsEncryptionEstablished() const;
+
+ // For a client, returns true if the server has confirmed our handshake. For
+ // a server, returns true if a full, valid client hello has been received.
+ virtual bool IsCryptoHandshakeConfirmed() const;
+
+ // Called by the QuicCryptoStream when a new QuicConfig has been negotiated.
+ virtual void OnConfigNegotiated();
+
+ // Called by the QuicCryptoStream when the handshake enters a new state.
+ //
+ // Clients will call this function in the order:
+ // ENCRYPTION_FIRST_ESTABLISHED
+ // zero or more ENCRYPTION_REESTABLISHED
+ // HANDSHAKE_CONFIRMED
+ //
+ // Servers will simply call it once with HANDSHAKE_CONFIRMED.
+ virtual void OnCryptoHandshakeEvent(CryptoHandshakeEvent event);
+
+ // Called by the QuicCryptoStream when a handshake message is sent.
+ virtual void OnCryptoHandshakeMessageSent(
+ const CryptoHandshakeMessage& message);
+
+ // Called by the QuicCryptoStream when a handshake message is received.
+ virtual void OnCryptoHandshakeMessageReceived(
+ const CryptoHandshakeMessage& message);
+
+ // Called by the stream on creation to set priority in the write blocked list.
+ virtual void RegisterStreamPriority(QuicStreamId id,
+ bool is_static,
+ spdy::SpdyPriority priority);
+ // Called by the stream on deletion to clear priority from the write blocked
+ // list.
+ virtual void UnregisterStreamPriority(QuicStreamId id, bool is_static);
+ // Called by the stream on SetPriority to update priority on the write blocked
+ // list.
+ virtual void UpdateStreamPriority(QuicStreamId id,
+ spdy::SpdyPriority new_priority);
+
+ // Returns mutable config for this session. Returned config is owned
+ // by QuicSession.
+ QuicConfig* config();
+
+ // Returns true if the stream existed previously and has been closed.
+ // Returns false if the stream is still active or if the stream has
+ // not yet been created.
+ bool IsClosedStream(QuicStreamId id);
+
+ QuicConnection* connection() { return connection_; }
+ const QuicConnection* connection() const { return connection_; }
+ size_t num_active_requests() const { return dynamic_stream_map_.size(); }
+ const QuicSocketAddress& peer_address() const {
+ return connection_->peer_address();
+ }
+ const QuicSocketAddress& self_address() const {
+ return connection_->self_address();
+ }
+ QuicConnectionId connection_id() const {
+ return connection_->connection_id();
+ }
+
+ // Returns the number of currently open streams, excluding the reserved
+ // headers and crypto streams, and never counting unfinished streams.
+ size_t GetNumActiveStreams() const;
+
+ // Returns the number of currently draining streams.
+ size_t GetNumDrainingStreams() const;
+
+ // Returns the number of currently open peer initiated streams, excluding the
+ // reserved headers and crypto streams.
+ size_t GetNumOpenIncomingStreams() const;
+
+ // Returns the number of currently open self initiated streams, excluding the
+ // reserved headers and crypto streams.
+ size_t GetNumOpenOutgoingStreams() const;
+
+ // Add the stream to the session's write-blocked list because it is blocked by
+ // connection-level flow control but not by its own stream-level flow control.
+ // The stream will be given a chance to write when a connection-level
+ // WINDOW_UPDATE arrives.
+ void MarkConnectionLevelWriteBlocked(QuicStreamId id);
+
+ // Called when stream |id| is done waiting for acks either because all data
+ // gets acked or is not interested in data being acked (which happens when
+ // a stream is reset because of an error).
+ void OnStreamDoneWaitingForAcks(QuicStreamId id);
+
+ // Called to cancel retransmission of unencypted crypto stream data.
+ void NeuterUnencryptedData();
+
+ // Returns true if the session has data to be sent, either queued in the
+ // connection, or in a write-blocked stream.
+ bool HasDataToWrite() const;
+
+ // Returns the largest payload that will fit into a single MESSAGE frame.
+ // Because overhead can vary during a connection, this method should be
+ // checked for every message.
+ QuicPacketLength GetLargestMessagePayload() const;
+
+ bool goaway_sent() const { return goaway_sent_; }
+
+ bool goaway_received() const { return goaway_received_; }
+
+ QuicErrorCode error() const { return error_; }
+
+ Perspective perspective() const { return connection_->perspective(); }
+
+ QuicFlowController* flow_controller() { return &flow_controller_; }
+
+ // Returns true if connection is flow controller blocked.
+ bool IsConnectionFlowControlBlocked() const;
+
+ // Returns true if any stream is flow controller blocked.
+ bool IsStreamFlowControlBlocked();
+
+ size_t max_open_incoming_bidirectional_streams() const;
+ size_t max_open_incoming_unidirectional_streams() const;
+
+ size_t MaxAvailableBidirectionalStreams() const;
+ size_t MaxAvailableUnidirectionalStreams() const;
+
+ // Returns existing static or dynamic stream with id = |stream_id|. If no
+ // such stream exists, and |stream_id| is a peer-created dynamic stream id,
+ // then a new stream is created and returned. In all other cases, nullptr is
+ // returned.
+ QuicStream* GetOrCreateStream(const QuicStreamId stream_id);
+
+ // Mark a stream as draining.
+ virtual void StreamDraining(QuicStreamId id);
+
+ // Returns true if this stream should yield writes to another blocked stream.
+ bool ShouldYield(QuicStreamId stream_id);
+
+ // Set transmission type of next sending packets.
+ void SetTransmissionType(TransmissionType type);
+
+ // Clean up closed_streams_.
+ void CleanUpClosedStreams();
+
+ bool session_decides_what_to_write() const;
+
+ const ParsedQuicVersionVector& supported_versions() const {
+ return supported_versions_;
+ }
+
+ // Called when new outgoing streams are available to be opened. This occurs
+ // when an extant, open, stream is moved to draining or closed. The default
+ // implementation does nothing.
+ virtual void OnCanCreateNewOutgoingStream();
+
+ QuicStreamId next_outgoing_bidirectional_stream_id() const;
+ QuicStreamId next_outgoing_unidirectional_stream_id() const;
+
+ // Return true if given stream is peer initiated.
+ bool IsIncomingStream(QuicStreamId id) const;
+
+ size_t GetNumLocallyClosedOutgoingStreamsHighestOffset() const;
+
+ size_t num_locally_closed_incoming_streams_highest_offset() const {
+ return num_locally_closed_incoming_streams_highest_offset_;
+ }
+
+ // Does actual work of sending reset-stream or reset-stream&stop-sending
+ // If the connection is not version 99/IETF QUIC, will always send a
+ // RESET_STREAM and close_write_side_only is ignored. If the connection is
+ // IETF QUIC/Version 99 then will send a RESET_STREAM and STOP_SENDING if
+ // close_write_side_only is false, just a RESET_STREAM if
+ // close_write_side_only is true.
+ virtual void SendRstStreamInner(QuicStreamId id,
+ QuicRstStreamErrorCode error,
+ QuicStreamOffset bytes_written,
+ bool close_write_side_only);
+
+ protected:
+ using StaticStreamMap = QuicSmallMap<QuicStreamId, QuicStream*, 2>;
+
+ using DynamicStreamMap =
+ QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
+
+ using PendingStreamMap =
+ QuicSmallMap<QuicStreamId, std::unique_ptr<PendingStream>, 10>;
+
+ using ClosedStreams = std::vector<std::unique_ptr<QuicStream>>;
+
+ using ZombieStreamMap =
+ QuicSmallMap<QuicStreamId, std::unique_ptr<QuicStream>, 10>;
+
+ // Creates a new stream to handle a peer-initiated stream.
+ // Caller does not own the returned stream.
+ // Returns nullptr and does error handling if the stream can not be created.
+ virtual QuicStream* CreateIncomingStream(QuicStreamId id) = 0;
+ virtual QuicStream* CreateIncomingStream(PendingStream pending) = 0;
+
+ // Return the reserved crypto stream.
+ virtual QuicCryptoStream* GetMutableCryptoStream() = 0;
+
+ // Return the reserved crypto stream as a constant pointer.
+ virtual const QuicCryptoStream* GetCryptoStream() const = 0;
+
+ // Adds |stream| to the dynamic stream map.
+ virtual void ActivateStream(std::unique_ptr<QuicStream> stream);
+
+ // Returns the stream ID for a new outgoing bidirectional/unidirectional
+ // stream, and increments the underlying counter.
+ QuicStreamId GetNextOutgoingBidirectionalStreamId();
+ QuicStreamId GetNextOutgoingUnidirectionalStreamId();
+
+ // Indicates whether the next outgoing bidirectional/unidirectional stream ID
+ // can be allocated or not. The test for version-99/IETF QUIC is whether it
+ // will exceed the maximum-stream-id or not. For non-version-99 (Google) QUIC
+ // it checks whether the next stream would exceed the limit on the number of
+ // open streams.
+ bool CanOpenNextOutgoingBidirectionalStream();
+ bool CanOpenNextOutgoingUnidirectionalStream();
+
+ // Returns the number of open dynamic streams.
+ uint64_t GetNumOpenDynamicStreams() const;
+
+ // Returns existing stream with id = |stream_id|. If no such stream exists,
+ // and |stream_id| is a peer-created id, then a new stream is created and
+ // returned. However if |stream_id| is a locally-created id and no such stream
+ // exists, the connection is closed.
+ // Caller does not own the returned stream.
+ QuicStream* GetOrCreateDynamicStream(QuicStreamId stream_id);
+
+ // Performs the work required to close |stream_id|. If |locally_reset|
+ // then the stream has been reset by this endpoint, not by the peer.
+ virtual void CloseStreamInner(QuicStreamId stream_id, bool locally_reset);
+
+ // When a stream is closed locally, it may not yet know how many bytes the
+ // peer sent on that stream.
+ // When this data arrives (via stream frame w. FIN, trailing headers, or RST)
+ // this method is called, and correctly updates the connection level flow
+ // controller.
+ virtual void OnFinalByteOffsetReceived(QuicStreamId id,
+ QuicStreamOffset final_byte_offset);
+
+ // Returns true if incoming streams should be buffered until the first
+ // byte of the stream arrives.
+ virtual bool ShouldBufferIncomingStream(QuicStreamId id) const {
+ return false;
+ }
+
+ // Register (|id|, |stream|) with the static stream map. Override previous
+ // registrations with the same id.
+ void RegisterStaticStream(QuicStreamId id, QuicStream* stream);
+ const StaticStreamMap& static_streams() const { return static_stream_map_; }
+
+ DynamicStreamMap& dynamic_streams() { return dynamic_stream_map_; }
+ const DynamicStreamMap& dynamic_streams() const {
+ return dynamic_stream_map_;
+ }
+
+ ClosedStreams* closed_streams() { return &closed_streams_; }
+
+ const ZombieStreamMap& zombie_streams() const { return zombie_streams_; }
+
+ void set_largest_peer_created_stream_id(
+ QuicStreamId largest_peer_created_stream_id);
+
+ void set_error(QuicErrorCode error) { error_ = error; }
+ QuicWriteBlockedList* write_blocked_streams() {
+ return &write_blocked_streams_;
+ }
+
+ size_t GetNumDynamicOutgoingStreams() const;
+
+ size_t GetNumDrainingOutgoingStreams() const;
+
+ // Returns true if the stream is still active.
+ bool IsOpenStream(QuicStreamId id);
+
+ // Close connection when receive a frame for a locally-created nonexistant
+ // stream.
+ // Prerequisite: IsClosedStream(stream_id) == false
+ // Server session might need to override this method to allow server push
+ // stream to be promised before creating an active stream.
+ virtual void HandleFrameOnNonexistentOutgoingStream(QuicStreamId stream_id);
+
+ virtual bool MaybeIncreaseLargestPeerStreamId(const QuicStreamId stream_id);
+
+ void InsertLocallyClosedStreamsHighestOffset(const QuicStreamId id,
+ QuicStreamOffset offset);
+ // If stream is a locally closed stream, this RST will update FIN offset.
+ // Otherwise stream is a preserved stream and the behavior of it depends on
+ // derived class's own implementation.
+ virtual void HandleRstOnValidNonexistentStream(
+ const QuicRstStreamFrame& frame);
+
+ // Returns a stateless reset token which will be included in the public reset
+ // packet.
+ virtual QuicUint128 GetStatelessResetToken() const;
+
+ QuicControlFrameManager& control_frame_manager() {
+ return control_frame_manager_;
+ }
+
+ const LegacyQuicStreamIdManager& stream_id_manager() const {
+ return stream_id_manager_;
+ }
+
+ // A StreamHandler represents an object which can receive a STREAM or
+ // or RST_STREAM frame.
+ struct StreamHandler {
+ StreamHandler() : is_pending(false), stream(nullptr) {}
+
+ // Creates a StreamHandler wrapping a QuicStream.
+ explicit StreamHandler(QuicStream* stream)
+ : is_pending(false), stream(stream) {}
+
+ // Creates a StreamHandler wrapping a PendingStream.
+ explicit StreamHandler(PendingStream* pending)
+ : is_pending(true), pending(pending) {
+ DCHECK(pending != nullptr);
+ }
+
+ // True if this handler contains a non-null PendingStream, false otherwise.
+ bool is_pending;
+ union {
+ QuicStream* stream;
+ PendingStream* pending;
+ };
+ };
+
+ StreamHandler GetOrCreateStreamImpl(QuicStreamId stream_id, bool may_buffer);
+
+ private:
+ friend class test::QuicSessionPeer;
+
+ // Called in OnConfigNegotiated when we receive a new stream level flow
+ // control window in a negotiated config. Closes the connection if invalid.
+ void OnNewStreamFlowControlWindow(QuicStreamOffset new_window);
+
+ // Called in OnConfigNegotiated when we receive a new connection level flow
+ // control window in a negotiated config. Closes the connection if invalid.
+ void OnNewSessionFlowControlWindow(QuicStreamOffset new_window);
+
+ // Debug helper for |OnCanWrite()|, check that OnStreamWrite() makes
+ // forward progress. Returns false if busy loop detected.
+ bool CheckStreamNotBusyLooping(QuicStream* stream,
+ uint64_t previous_bytes_written,
+ bool previous_fin_sent);
+
+ // Debug helper for OnCanWrite. Check that after QuicStream::OnCanWrite(),
+ // if stream has buffered data and is not stream level flow control blocked,
+ // it has to be in the write blocked list.
+ bool CheckStreamWriteBlocked(QuicStream* stream) const;
+
+ // Called in OnConfigNegotiated for Finch trials to measure performance of
+ // starting with larger flow control receive windows.
+ void AdjustInitialFlowControlWindows(size_t stream_window);
+
+ // Find stream with |id|, returns nullptr if the stream does not exist or
+ // closed.
+ QuicStream* GetStream(QuicStreamId id) const;
+
+ StreamHandler GetOrCreateDynamicStreamImpl(QuicStreamId stream_id,
+ bool may_buffer);
+
+ // Let streams and control frame managers retransmit lost data, returns true
+ // if all lost data is retransmitted. Returns false otherwise.
+ bool RetransmitLostData();
+
+ // Closes the pending stream |stream_id| before it has been created.
+ void ClosePendingStream(QuicStreamId stream_id);
+
+ // Keep track of highest received byte offset of locally closed streams, while
+ // waiting for a definitive final highest offset from the peer.
+ std::map<QuicStreamId, QuicStreamOffset>
+ locally_closed_streams_highest_offset_;
+
+ QuicConnection* connection_;
+
+ // May be null.
+ Visitor* visitor_;
+
+ // A list of streams which need to write more data. Stream register
+ // themselves in their constructor, and unregisterm themselves in their
+ // destructors, so the write blocked list must outlive all streams.
+ QuicWriteBlockedList write_blocked_streams_;
+
+ ClosedStreams closed_streams_;
+ // Streams which are closed, but need to be kept alive. Currently, the only
+ // reason is the stream's sent data (including FIN) does not get fully acked.
+ ZombieStreamMap zombie_streams_;
+
+ QuicConfig config_;
+
+ // Static streams, such as crypto and header streams. Owned by child classes
+ // that create these streams.
+ StaticStreamMap static_stream_map_;
+
+ // Map from StreamId to pointers to streams. Owns the streams.
+ DynamicStreamMap dynamic_stream_map_;
+
+ // Map from StreamId to PendingStreams for peer-created unidirectional streams
+ // which are waiting for the first byte of payload to arrive.
+ PendingStreamMap pending_stream_map_;
+
+ // Set of stream ids that are "draining" -- a FIN has been sent and received,
+ // but the stream object still exists because not all the received data has
+ // been consumed.
+ QuicUnorderedSet<QuicStreamId> draining_streams_;
+
+ // TODO(fayang): Consider moving LegacyQuicStreamIdManager into
+ // UberQuicStreamIdManager.
+ // Manages stream IDs for Google QUIC.
+ LegacyQuicStreamIdManager stream_id_manager_;
+
+ // Manages stream IDs for version99/IETF QUIC
+ UberQuicStreamIdManager v99_streamid_manager_;
+
+ // A counter for peer initiated streams which are in the dynamic_stream_map_.
+ size_t num_dynamic_incoming_streams_;
+
+ // A counter for peer initiated streams which are in the draining_streams_.
+ size_t num_draining_incoming_streams_;
+
+ // A counter for peer initiated streams which are in the
+ // locally_closed_streams_highest_offset_.
+ size_t num_locally_closed_incoming_streams_highest_offset_;
+
+ // The latched error with which the connection was closed.
+ QuicErrorCode error_;
+
+ // Used for connection-level flow control.
+ QuicFlowController flow_controller_;
+
+ // The stream id which was last popped in OnCanWrite, or 0, if not under the
+ // call stack of OnCanWrite.
+ QuicStreamId currently_writing_stream_id_;
+
+ // The largest stream id in |static_stream_map_|.
+ QuicStreamId largest_static_stream_id_;
+
+ // Cached value of whether the crypto handshake has been confirmed.
+ bool is_handshake_confirmed_;
+
+ // Whether a GoAway has been sent.
+ bool goaway_sent_;
+
+ // Whether a GoAway has been received.
+ bool goaway_received_;
+
+ QuicControlFrameManager control_frame_manager_;
+
+ // Id of latest successfully sent message.
+ QuicMessageId last_message_id_;
+
+ // TODO(fayang): switch to linked_hash_set when chromium supports it. The bool
+ // is not used here.
+ // List of streams with pending retransmissions.
+ QuicLinkedHashMap<QuicStreamId, bool> streams_with_pending_retransmission_;
+
+ // Clean up closed_streams_ when this alarm fires.
+ std::unique_ptr<QuicAlarm> closed_streams_clean_up_alarm_;
+
+ // Supported version list used by the crypto handshake only. Please note, this
+ // list may be a superset of the connection framer's supported versions.
+ ParsedQuicVersionVector supported_versions_;
+};
+
+} // namespace quic
+
+#endif // QUICHE_QUIC_CORE_QUIC_SESSION_H_
