public Ngtcp2Source,

public DataQueue::BackpressureListener {

public:

using Header = NgHeaderBase<BindingData>;

static Stream* From(void* stream_user_data);

static bool HasInstance(Environment* env, v8::Local<v8::Value> value);

static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(

Environment* env);

static void Initialize(Environment* env, v8::Local<v8::Object> target);

static void RegisterExternalReferences(ExternalReferenceRegistry* registry);

static BaseObjectPtr<Stream> Create(

Session* session,

int64_t id,

std::shared_ptr<DataQueue> source = nullptr);

// The constructor is only public to be visible by MakeDetachedBaseObject.

// Call Create to create new instances of Stream.

Stream(BaseObjectWeakPtr<Session> session,

v8::Local<v8::Object> obj,

int64_t id,

std::shared_ptr<DataQueue> source);

~Stream() override;

int64_t id() const;

Side origin() const;

Direction direction() const;

Session& session() const;

bool is_destroyed() const;

// True if we've completely sent all outbound data for this stream.

bool is_eos() const;

bool is_readable() const;

bool is_writable() const;

// Called by the session/application to indicate that the specified number

// of bytes have been acknowledged by the peer.

void Acknowledge(size_t datalen);

void Commit(size_t datalen);

void EndWritable();

void EndReadable(std::optional<uint64_t> maybe_final_size = std::nullopt);

void EntryRead(size_t amount) override;

// Pulls data from the internal outbound DataQueue configured for this stream.

int DoPull(bob::Next<ngtcp2_vec> next,

int options,

ngtcp2_vec* data,

size_t count,

size_t max_count_hint) override;

// Forcefully close the stream immediately. All queued data and pending

// writes are abandoned, and the stream is immediately closed at the ngtcp2

// level without waiting for any outstanding acknowledgements.

void Destroy(QuicError error = QuicError());

struct ReceiveDataFlags final {

// Identifies the final chunk of data that the peer will send for the

// stream.

bool fin = false;

// Indicates that this chunk of data was received in a 0RTT packet before

// the TLS handshake completed, suggesting that is is not as secure and

// could be replayed by an attacker.

bool early = false;

};

void ReceiveData(const uint8_t* data, size_t len, ReceiveDataFlags flags);

void ReceiveStopSending(QuicError error);

void ReceiveStreamReset(uint64_t final_size, QuicError error);

void BeginHeaders(HeadersKind kind);

// Returns false if the header cannot be added. This will typically happen

// if the application does not support headers, a maximimum number of headers

// have already been added, or the maximum total header length is reached.

bool AddHeader(const Header& header);

SET_NO_MEMORY_INFO()

SET_MEMORY_INFO_NAME(Stream)

SET_SELF_SIZE(Stream)

struct State;

struct Stats;

// Notifies the JavaScript side that sending data on the stream has been

// blocked because of flow control restriction.

void EmitBlocked();

private:

struct Impl;

class Outbound;

// Gets a reader for the data received for this stream from the peer,

BaseObjectPtr<Blob::Reader> get_reader();

void set_final_size(uint64_t amount);

void set_outbound(std::shared_ptr<DataQueue> source);

// JavaScript callouts

// Notifies the JavaScript side that the stream has been destroyed.

void EmitClose(const QuicError& error);

// Delivers the set of inbound headers that have been collected.

void EmitHeaders();

// Notifies the JavaScript side that the stream has been reset.

void EmitReset(const QuicError& error);

// Notifies the JavaScript side that the application is ready to receive

// trailing headers.

void EmitWantTrailers();

AliasedStruct<Stats> stats_;

AliasedStruct<State> state_;

BaseObjectWeakPtr<Session> session_;

const Side origin_;

const Direction direction_;

std::unique_ptr<Outbound> outbound_;

std::shared_ptr<DataQueue> inbound_;

std::vector<v8::Local<v8::Value>> headers_;

HeadersKind headers_kind_ = HeadersKind::INITIAL;

size_t headers_length_ = 0;

friend struct Impl;

public:

// The Queue/Schedule/Unschedule here are part of the mechanism used to

// determine which streams have data to send on the session. When a stream

// potentially has data available, it will be scheduled in the Queue. Then,

// when the Session::Application starts sending pending data, it will check

// the queue to see if there are streams waiting. If there are, it will grab

// one and check to see if there is data to send. When a stream does not have

// data to send (such as when it is initially created or is using an async

// source that is still waiting for data to be pushed) it will not appear in

// the queue.

ListNode<Stream> stream_queue_;

using Queue = ListHead<Stream, &Stream::stream_queue_>;

void Schedule(Queue* queue);

void Unschedule();