Move shared files in net/quic/ into net/quic/core/

net/quic/quic_session.h

-// 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_