1 // Copyright 2013 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 QUICHE_QUIC_CORE_HTTP_QUIC_HEADERS_STREAM_H_ 6 #define QUICHE_QUIC_CORE_HTTP_QUIC_HEADERS_STREAM_H_ 7 8 #include <cstddef> 9 #include <memory> 10 11 #include "quiche/quic/core/http/quic_header_list.h" 12 #include "quiche/quic/core/quic_packets.h" 13 #include "quiche/quic/core/quic_stream.h" 14 #include "quiche/quic/platform/api/quic_export.h" 15 #include "quiche/spdy/core/spdy_framer.h" 16 17 namespace quic { 18 19 class QuicSpdySession; 20 21 namespace test { 22 class QuicHeadersStreamPeer; 23 } // namespace test 24 25 // Headers in QUIC are sent as HTTP/2 HEADERS frames over a reserved stream with 26 // the id 3. Each endpoint (client and server) will allocate an instance of 27 // QuicHeadersStream to send and receive headers. 28 class QUICHE_EXPORT QuicHeadersStream : public QuicStream { 29 public: 30 explicit QuicHeadersStream(QuicSpdySession* session); 31 QuicHeadersStream(const QuicHeadersStream&) = delete; 32 QuicHeadersStream& operator=(const QuicHeadersStream&) = delete; 33 ~QuicHeadersStream() override; 34 35 // QuicStream implementation 36 void OnDataAvailable() override; 37 38 // Release underlying buffer if allowed. 39 void MaybeReleaseSequencerBuffer(); 40 41 bool OnStreamFrameAcked(QuicStreamOffset offset, QuicByteCount data_length, 42 bool fin_acked, QuicTime::Delta ack_delay_time, 43 QuicTime receive_timestamp, 44 QuicByteCount* newly_acked_length) override; 45 46 void OnStreamFrameRetransmitted(QuicStreamOffset offset, 47 QuicByteCount data_length, 48 bool fin_retransmitted) override; 49 50 void OnStreamReset(const QuicRstStreamFrame& frame) override; 51 52 private: 53 friend class test::QuicHeadersStreamPeer; 54 55 // CompressedHeaderInfo includes simple information of a header, including 56 // offset in headers stream, unacked length and ack listener of this header. 57 struct QUICHE_EXPORT CompressedHeaderInfo { 58 CompressedHeaderInfo( 59 QuicStreamOffset headers_stream_offset, QuicStreamOffset full_length, 60 quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface> 61 ack_listener); 62 CompressedHeaderInfo(const CompressedHeaderInfo& other); 63 ~CompressedHeaderInfo(); 64 65 // Offset the header was sent on the headers stream. 66 QuicStreamOffset headers_stream_offset; 67 // The full length of the header. 68 QuicByteCount full_length; 69 // The remaining bytes to be acked. 70 QuicByteCount unacked_length; 71 // Ack listener of this header, and it is notified once any of the bytes has 72 // been acked or retransmitted. 73 quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface> 74 ack_listener; 75 }; 76 77 // Returns true if the session is still connected. 78 bool IsConnected(); 79 80 // Override to store mapping from offset, length to ack_listener. This 81 // ack_listener is notified once data within [offset, offset + length] is 82 // acked or retransmitted. 83 void OnDataBuffered( 84 QuicStreamOffset offset, QuicByteCount data_length, 85 const quiche::QuicheReferenceCountedPointer<QuicAckListenerInterface>& 86 ack_listener) override; 87 88 QuicSpdySession* spdy_session_; 89 90 // Headers that have not been fully acked. 91 quiche::QuicheCircularDeque<CompressedHeaderInfo> unacked_headers_; 92 }; 93 94 } // namespace quic 95 96 #endif // QUICHE_QUIC_CORE_HTTP_QUIC_HEADERS_STREAM_H_ 97