Index: net/quic/quic_session.h |
diff --git a/net/quic/quic_session.h b/net/quic/quic_session.h |
deleted file mode 100644 |
index 81ab2d1beb3bcd21bff9d1522934c9df013f51c2..0000000000000000000000000000000000000000 |
--- a/net/quic/quic_session.h |
+++ /dev/null |
@@ -1,416 +0,0 @@ |
-// 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 NET_QUIC_QUIC_SESSION_H_ |
-#define NET_QUIC_QUIC_SESSION_H_ |
- |
-#include <stddef.h> |
- |
-#include <map> |
-#include <memory> |
-#include <string> |
-#include <unordered_map> |
-#include <unordered_set> |
-#include <vector> |
- |
-#include "base/compiler_specific.h" |
-#include "base/containers/small_map.h" |
-#include "base/macros.h" |
-#include "base/strings/string_piece.h" |
-#include "net/base/ip_endpoint.h" |
-#include "net/quic/quic_connection.h" |
-#include "net/quic/quic_crypto_stream.h" |
-#include "net/quic/quic_packet_creator.h" |
-#include "net/quic/quic_protocol.h" |
-#include "net/quic/quic_write_blocked_list.h" |
-#include "net/quic/reliable_quic_stream.h" |
- |
-namespace net { |
- |
-class QuicCryptoStream; |
-class QuicFlowController; |
-class ReliableQuicStream; |
- |
-namespace test { |
-class QuicSessionPeer; |
-} // namespace test |
- |
-class NET_EXPORT_PRIVATE QuicSession : public QuicConnectionVisitorInterface { |
- public: |
- // 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_INITIAL. (Client only.) |
- ENCRYPTION_REESTABLISHED, |
- // HANDSHAKE_CONFIRMED, in a client, indicates the 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, |
- }; |
- |
- // Takes ownership of |connection|. |
- QuicSession(QuicConnection* connection, const QuicConfig& config); |
- |
- ~QuicSession() override; |
- |
- virtual void Initialize(); |
- |
- // QuicConnectionVisitorInterface methods: |
- void OnStreamFrame(const QuicStreamFrame& frame) override; |
- void OnRstStream(const QuicRstStreamFrame& frame) override; |
- void OnGoAway(const QuicGoAwayFrame& frame) override; |
- void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override; |
- void OnBlockedFrame(const QuicBlockedFrame& frame) override; |
- void OnConnectionClosed(QuicErrorCode error, |
- const std::string& error_details, |
- ConnectionCloseSource source) override; |
- void OnWriteBlocked() override {} |
- void OnSuccessfulVersionNegotiation(const QuicVersion& version) override; |
- void OnCanWrite() override; |
- void OnCongestionWindowChange(QuicTime /*now*/) override {} |
- void OnConnectionMigration(PeerAddressChangeType type) override {} |
- // Deletes streams that are safe to be deleted now that it's safe to do so (no |
- // other operations are being done on the streams at this time). |
- void PostProcessAfterData() override; |
- bool WillingAndAbleToWrite() const override; |
- bool HasPendingHandshake() const override; |
- bool HasOpenDynamicStreams() const override; |
- void OnPathDegrading() override; |
- |
- // Called on every incoming packet. Passes |packet| through to |connection_|. |
- virtual void ProcessUdpPacket(const IPEndPoint& self_address, |
- const IPEndPoint& 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. |
- // If provided, |ack_notifier_delegate| will be registered to be notified when |
- // we have seen ACKs for all packets resulting from this call. |
- virtual QuicConsumedData WritevData( |
- ReliableQuicStream* stream, |
- QuicStreamId id, |
- QuicIOVector iov, |
- QuicStreamOffset offset, |
- bool fin, |
- QuicAckListenerInterface* ack_notifier_delegate); |
- |
- // 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. |
- void SendGoAway(QuicErrorCode error_code, const std::string& reason); |
- |
- // 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(); |
- |
- // 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(); |
- |
- // 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); |
- |
- // 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_.get(); } |
- const QuicConnection* connection() const { return connection_.get(); } |
- size_t num_active_requests() const { return dynamic_stream_map_.size(); } |
- const IPEndPoint& peer_address() const { return connection_->peer_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. |
- virtual size_t GetNumActiveStreams() const; |
- |
- // Returns the number of currently open peer initiated streams, excluding the |
- // reserved headers and crypto streams. |
- virtual size_t GetNumOpenIncomingStreams() const; |
- |
- // Returns the number of currently open self initiated streams, excluding the |
- // reserved headers and crypto streams. |
- virtual size_t GetNumOpenOutgoingStreams() const; |
- |
- // Returns the number of "available" streams, the stream ids less than |
- // largest_peer_created_stream_id_ that have not yet been opened. |
- virtual size_t GetNumAvailableStreams() 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); |
- |
- // Returns true if the session has data to be sent, either queued in the |
- // connection, or in a write-blocked stream. |
- bool HasDataToWrite() const; |
- |
- bool goaway_sent() const; |
- |
- bool goaway_received() const; |
- |
- 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_streams() const { |
- return max_open_incoming_streams_; |
- } |
- |
- size_t max_open_outgoing_streams() const { |
- return max_open_outgoing_streams_; |
- } |
- |
- size_t MaxAvailableStreams() 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. |
- ReliableQuicStream* 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); |
- |
- protected: |
- using StaticStreamMap = |
- base::SmallMap<std::unordered_map<QuicStreamId, ReliableQuicStream*>, 2>; |
- |
- using DynamicStreamMap = |
- base::SmallMap<std::unordered_map<QuicStreamId, ReliableQuicStream*>, 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 ReliableQuicStream* CreateIncomingDynamicStream(QuicStreamId id) = 0; |
- |
- // Create a new stream to handle a locally-initiated stream. |
- // Caller does not own the returned stream. |
- // Returns nullptr if max streams have already been opened. |
- virtual ReliableQuicStream* CreateOutgoingDynamicStream( |
- SpdyPriority priority) = 0; |
- |
- // Return the reserved crypto stream. |
- virtual QuicCryptoStream* GetCryptoStream() = 0; |
- |
- // Adds |stream| to the dynamic stream map. |
- // Takes ownership of |stream|. |
- virtual void ActivateStream(ReliableQuicStream* stream); |
- |
- // Returns the stream ID for a new outgoing stream, and increments the |
- // underlying counter. |
- QuicStreamId GetNextOutgoingStreamId(); |
- |
- // 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. |
- ReliableQuicStream* 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, or RST) this method |
- // is called, and correctly updates the connection level flow controller. |
- void UpdateFlowControlOnFinalReceivedByteOffset( |
- QuicStreamId id, |
- QuicStreamOffset final_byte_offset); |
- |
- // Return true if given stream is peer initiated. |
- bool IsIncomingStream(QuicStreamId id) const; |
- |
- StaticStreamMap& static_streams() { return static_stream_map_; } |
- 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_; |
- } |
- |
- std::vector<ReliableQuicStream*>* closed_streams() { |
- return &closed_streams_; |
- } |
- |
- void set_max_open_incoming_streams(size_t max_open_incoming_streams); |
- void set_max_open_outgoing_streams(size_t max_open_outgoing_streams); |
- |
- void set_largest_peer_created_stream_id( |
- QuicStreamId largest_peer_created_stream_id) { |
- largest_peer_created_stream_id_ = 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; |
- |
- size_t num_locally_closed_incoming_streams_highest_offset() const { |
- return num_locally_closed_incoming_streams_highest_offset_; |
- } |
- |
- size_t GetNumLocallyClosedOutgoingStreamsHighestOffset() const; |
- |
- // Returns true if the stream is still active. |
- bool IsOpenStream(QuicStreamId id); |
- |
- QuicStreamId next_outgoing_stream_id() const { |
- return next_outgoing_stream_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); |
- |
- 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); |
- |
- 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); |
- |
- // 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_; |
- |
- std::unique_ptr<QuicConnection> connection_; |
- |
- std::vector<ReliableQuicStream*> closed_streams_; |
- |
- QuicConfig config_; |
- |
- // The maximum number of outgoing streams this connection can open. |
- size_t max_open_outgoing_streams_; |
- |
- // The maximum number of incoming streams this connection will allow. |
- size_t max_open_incoming_streams_; |
- |
- // 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_; |
- |
- // The ID to use for the next outgoing stream. |
- QuicStreamId next_outgoing_stream_id_; |
- |
- // Set of stream ids that are less than the largest stream id that has been |
- // received, but are nonetheless available to be created. |
- std::unordered_set<QuicStreamId> available_streams_; |
- |
- // 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. |
- std::unordered_set<QuicStreamId> draining_streams_; |
- |
- // A list of streams which need to write more data. |
- QuicWriteBlockedList write_blocked_streams_; |
- |
- QuicStreamId largest_peer_created_stream_id_; |
- |
- // 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_; |
- |
- DISALLOW_COPY_AND_ASSIGN(QuicSession); |
-}; |
- |
-} // namespace net |
- |
-#endif // NET_QUIC_QUIC_SESSION_H_ |