Attributes

state of type QuicTransportState, readonly

The current state of the QUIC transport. On getting, it MUST return the value of the [[\QuicTransportState]] internal slot.

maxDatagramSize of type unsigned short, readonly

The maximum size data that may be passed to sendDatagram.

onstatechange of type EventHandler

This event handler, of event handler event type statechange, MUST be fired any time the [[\QuicTransportState]] slot changes, unless the state changes due to calling stop.

onerror of type EventHandler

This event handler, of event handler event type error, MUST be fired on reception of a QUIC error; an implementation SHOULD include QUIC error information in error.message (defined in [[!HTML51]] Section 7.1.3.8.2). This event MUST be fired before the onstatechange event.

onreceivestream of type EventHandler

This event handler, of event handler event type receivestream, MUST be fired on when data is received from a newly created remote QuicReceiveStream for the first time.

onbidirectionalstream of type EventHandler

This event handler, of event handler event type bidirectionalstream, MUST be fired when data is received from a newly created remote QuicBidirectionalStream for the first time.

Methods

stop

Stops and closes the QuicTransportBase object. This triggers an Immediate Close as described in [[QUIC-TRANSPORT]] section 10.3.

When stop is called, the user agent MUST run the following steps:

1. Let transport be the QuicTransportBase on which stop is invoked.
2. If transport's [[\QuicTransportState]] is "closed" then abort these steps.
3. Set transport's [[\QuicTransportState]] to "closed".
4. Let stopInfo be the first argument.
5. Start the Immediate Close procedure by sending an CONNECTION_CLOSE frame with its error code value set to the value of stopInfo.errorCode and its reason value set to the value of stopInfo.reason.

No parameters.

Return type: void

Parameter	Type	Nullable	Optional	Description
stopInfo	QuicTransportStopInfo	✘	✘

createBidirectionalStream

Creates an QuicBidirectionalStream object.

When createBidectionalStream is called, the user agent MUST run the following steps:

1. Let transport be the QuicTransportBase on which createBidectionalStream is invoked.

2. If transport's state is "closed" or "failed", immediately return a new rejected promise with a newly created InvalidStateError and abort these steps.

3. If transport's state is "connected", immediately return a new resolved promise with a newly created QuicBidirectionalStream object, add the QuicBidirectionalStream to the transport and abort these steps.

4. Let p be a new promise.

5. Return p and continue the following steps in the background.

1. Resolve p with a newly created QuicBidirectionalStream object, add the QuicBidirectionalStream to the transport when all of the following conditions are met:

   1. The transport's state has transitioned to "connected"
   2. Stream creation flow control is not being violated by exceeding the max stream limit set by the remote endpoint, as specified in [[QUIC-TRANSPORT]].
   3. p has not been settled

2. Reject p with a newly created InvalidStateError when all of the following conditions are met:

   1. The transport's state transitions to "closed" or "failed"
   2. p has not been settled

No parameters.

Return type: Promise<QuicBidirectionalStream>

createSendStream

Creates an QuicSendStream object.

When createSendStream is called, the user agent MUST run the following steps:

1. Let transport be the QuicTransportBase on which createSendStream is invoked.

2. If transport's state is "closed" or "failed", immediately return a new rejected promise with a newly created InvalidStateError and abort these steps.

3. If transport's state is "connected", immediately return a new resolved promise with a newly created QuicSendStream object, add the QuicSendStream to the transport and abort these steps.

4. Let p be a new promise.

5. Return p and continue the following steps in the background.

1. Resolve p with a newly created QuicSendStream object, add the QuicSendStream to the transport when all of the following conditions are met:

   1. The transport's state has transitioned to "connected"
   2. Stream creation flow control is not being violated by exceeding the max stream limit set by the remote endpoint, as specified in [[QUIC-TRANSPORT]].
   3. p has not been settled

2. Reject p with a newly created InvalidStateError when all of the following conditions are met:

   1. The transport's state transitions to "closed" or "failed"
   2. p has not been settled

No parameters.

Return type: Promise<QuicSendStream>

readyToSendDatagram

Returns a promise that will be resolved when the QuicTransport can send a datagram as defined by [[QUIC-DATAGRAM]].

When readyToSendDatagram is called, the user agent MUST run the following steps:

1. Let p be a new promise.

2. Let transport be the QuicTransportBase on which readyToSendDatagram is invoked.

3. Return p and continue the following steps in the background.

1. If transport can send a datagram, imediately resolve p and abort these steps.

2. If transport's state is "failed" or "closed" immediately reject p with a newly created InvalidStateError and abort these steps.

3. If transport is blocked from sending a datagram due to congestion control, resolve p when transport is no longer blocked.

4. reject p with a newly created InvalidStateError if the transport's state transitions to "failed" or "closed".

No parameters.

Return type: Promise<void>

sendDatagram

Sends a datagram as defined by [[QUIC-DATAGRAM]].

When sendDatagram is called, the user agent MUST run the following steps:

1. Let data be the first argument.

2. Let transport be the QuicTransportBase on which sendDatagram is invoked.

3. If transport's state is not connected return a promise rejected with a newly created InvalidStateError and abort these steps.

4. If data is too large to fit into a datagram, return a promise rejected with a newly created InvalidArgumentError and abort these steps.

5. If transport is unable to send the datagram due to congestion control, return a promise rejected with a newly created InvalidStateError and abort these steps.

6. Let p be a new promise.

7. Return p and continue the following steps in the background.

1. Send data in a QUIC datagram.

2. When an ack is received for the sent datagram, resolve p with true.

3. When the datagram is detemined to be lost, resolve p with false.

Parameter	Type	Nullable	Optional	Description
data	Uint8Array	✘	✘

Return type: Promise<boolean>

receiveDatagrams

If datagrams have been received since the last call to receiveDatagrams(), return a new promise resolved with all of the received datagrams.

If not, return a new promise that will resolve when more datagrams are received, resolved with all datagrams received.

If too many datagrams are queued between calls to receiveDatagrams(), the implementation may drop datagrams and replace them with a null value in the sequence of datagrams returned in the next call to receiveDatagrams(). One null value may represent many dropped datagrams.

receiveDatagrams() may only be called once at a time. If a promised returned from a previous call is still unresolved, the user agent MUST return a new promise rejected with an InvalidStateError.

Return type: Promise<sequence<Uint8Array>>

Dictionary QuicStreamParameters Members

disableRetransmissions of type bool, defaulting to false

disableRetransmissions, with a default of false. If true, the stream will be sent without retransmissions. If false, the stream will be sent with retransmissions.

Constructors

ReceiveStreamEvent

Parameter	Type	Nullable	Optional	Description
type	DOMString	✘	✘
eventInitDict	ReceiveStreamEventInit	✘	✘

Attributes

stream of type QuicReceiveStream, readonly

The stream attribute represents the QuicReceiveStream object associated with the event.

Dictionary ReceiveStreamEventInit Members

stream of type QuicReceiveStream

The QuicReceiveStream object associated with the event.

Constructors

BidirectionalStreamEvent

Parameter	Type	Nullable	Optional	Description
type	DOMString	✘	✘
eventInitDict	BidirectionalStreamEventInit	✘	✘

Attributes

stream of type QuicBidirectionalStream, readonly

The stream attribute represents the QuicBidirectionalStream object associated with the event.

Dictionary BidirectionalStreamEventInit Members

stream of type QuicBidirectionalStream

The QuicBidirectionalStream object associated with the event.

Dictionary QuicTransportStopInfo Members

errorCode of type unsigned short, defaulting to 0.

The error code used in CONNECTION_CLOSE frame.

reason of type DOMString, defaulting to ""

The reason for stopping the QuicTransportBase

Constructors

1. If port is 0, throw an NotSupportedError and abort these steps.
2. Let quictransport be a newly constructed QuicTransport object.
3. Let quictransport have a [[\QuicTransportWritableStreams]] internal slot representing a sequence of QuicWritableStream objects, initialized to empty.
4. Let quictransport have a [[\QuicTransportReadableStreams]] internal slot representing a sequence of QuicReadableStream objects, initialized to empty.
5. Let quictransport have a [[\QuicTransportState]] internal slot, initialized to "connecting".
6. Let quictransport have a [[\QuicTransportReceivedDatagrams]] internal slot representing a queue of Uint8Array, initialized to empty.
7. Let quictransport have a [[\QuicTransportReceiveDatagramsPromise]] internal slot representing a Promise<sequence<Uint8Array>>?, initialized to null.
8. Run these steps in parallel:
   1. Establish a QUIC connection to the address identified by the given host and port. During connection establishment, use of this API must be indicated by selecting the ALPN [[!ALPN]] token "wq" in the crypto handshake and including a QUIC transport parameter with ID web_client(0x333C) and empty value.
   2. If the connection fails, set quictransport's [[\QuicTransportState]] internal slot to "failed" and abort these steps.
   3. Let joinedAcceptedOrigins be the QUIC transport parameter provided by the server with ID web_accepted_origins(0x333A). If the transport parameter is absent, set quictransport's [[\QuicTransportState]] internal slot to "failed" and abort these steps.
   4. Let serializedAcceptedOrigins be joinedAcceptedOrigins split by the separator ",".
   5. Let serializedOrigin be quictransport's relevant settings object's origin, serialized.
   6. If serializedOrigin is a member of serializedAcceptedOrigins or joinedAcceptedOrigins is equal to "*", set quictransport's [[\QuicTransportState]] internal slot to "connected" and abort these steps.
   7. Set quictransport's [[\QuicTransportState]] internal slot to "failed".
9. Return quictransport.

QuicTransport

Parameter	Type	Nullable	Optional	Description
host	DOMString	✘	✘	The host to connect to.
port	unsigned short	✘	✘	The port to connect to.

Overview

The QuicWritableStream will initialize with the following:

1. Let stream be the QuicWritableStream.
2. Let stream have a [[\Writable]] internal slot initialized to true.
3. Let stream have a [[\WriteBufferedAmount]] internal slot initialized to zero.

Attributes

writable of type boolean readonly

The writable attribute represents whether data can be written to the QuicWritableStream. On getting it MUST return the value of the [[\Writable]] slot.

writeBufferedAmount of type unsigned long, readonly

The writeBufferedAmount attribute represents the number of bytes of application data that have been queued using write but that, as of the last time the event loop started executing a task, had not yet been transmitted to the network. This includes any data sent during the execution of the current task, regardless of whether the user agent is able to transmit text asynchronously with script execution. This does not include framing overhead incurred by the protocol, or buffering done by the operating system or network hardware. On getting, it MUST return the value of the QuicWritableStream's [[\WriteBufferedAmount]] internal slot.

writingAborted of type QuicStreamAbortInfo readonly

The writingAborted attribute represents a promise that resolves when the STOP_SENDING frame is received from the QuicReadableStream. When the stream receives a STOP_SENDING frame from its corresponding QuicReadableStream, the user agent MUST run the following:

1. Let stream be the QuicWritableStream object.
2. Set stream's [[\Writable]] slot to false.
3. Clear the stream's write buffer.
4. Let transport be the QuicTransportBase, which the stream was created from.
5. Remove the stream from the transport's [[\QuicTransportWritableStreams]] internal slot.
6. resolve the promise with the resulting QuicStreamAbortInfo with the errorCode set to the value from the STOP_SENDING frame.

Methods

write

Writes data to the stream. When the remote QuicTransportBase receives the STREAM frame from this stream for the first time, it will trigger the creation of the corresponding remote stream. When the write method is called, the user agent MUST run the following steps:

1. Let data be the first argument.
2. Let stream be the QuicWritableStream object on which data is to be sent.
3. if length of data.data is 0 and data.finished is false, throw a NotSupportedError and abort these steps.
4. If stream's [[\Writable]] slot is false, throw an InvalidStateError and abort these steps.
5. Increase the value of stream's [[\WriteBufferedAmount]] slot by the length of data.data in bytes.
6. Queue data.data for transmission on stream's underlying data transport.
7. if data.finish is set to true, run the following:
1. Queue a STREAM frame with the FIN bit set.
2. Set stream's [[\Writable]] slot to false.
3. Let transport be the QuicTransportBase, which the stream was created from.
4. Remove the stream from the transport's [[\QuicTransportWritableStreams]] internal slot.
The actual transmission of data occurs in parallel. If sending data leads to a QUIC-level error, the application will be notified asynchronously through the QuicTransportBase's onerror EventHandler.

Parameter	Type	Nullable	Optional	Description
data	QuicStreamWriteParameters	✘	✘

Return type: void

abortWriting

A hard shutdown of the QuicWritableStream. It may be called regardless of whether the QuicWritableStream was created by the local or remote peer. When the abortWriting() method is called, the user agent MUST run the following steps:

1. Let stream be the QuicWritableStream object which is about to abort writing.
2. If stream's [[\Writable]] slot is false, throw an InvalidStateError and abort these steps.
3. Set stream's [[\Writable]] slot to false.
4. Clear the stream's write buffer.
5. Let transport be the QuicTransportBase, which the stream was created from.
6. Remove the stream from the transport's [[\QuicTransportWritableStreams]] internal slot.
7. Let abortInfo be the first argument.
8. Start the closing procedure by sending a RST_STREAM frame with its error code set to the value of abortInfo.errorCode.

Parameter	Type	Nullable	Optional	Description
abortInfo	QuicStreamAbortInfo	✘	✘

Return type: void

waitForWriteBufferedAmountBelow

waitForWriteBufferedAmountBelow resolves the promise when the data queued in the write buffer falls below the given threshold. If waitForWriteBufferedAmountBelow is called multiple times, multiple promises could be resolved when the write buffer falls below the threshold for each promise. The Promise will be rejected with a newly created InvalidStateError if the stream's [[\Writable]] slot transitions from true to false and the promise isn't settled. When the waitForWriteBufferedAmountBelow method is called, the user agent MUST run the following steps:

1. Let stream be the QuicWritableStream object on which waitForWriteBufferedAmountBelow was invoked.
2. Let p be a new promise.
3. If stream's [[\Writable]] slot is false, reject p with a newly created InvalidStateError and abort these steps.
4. Let threshold be the first argument.
5. When stream's [[\WriteBufferedAmount]]] slot decreases from above threshold to less than or equal to it, resolve p with undefined.

Parameter	Type	Nullable	Optional	Description
threshold	unsigned long	✘	✘

Return type: Promise<void>

Overview

The QuicReadableStream will initialize with the following:

1. Let stream be the QuicReadableStream.
2. Let stream have a [[\Readable]] internal slot initialized to true.
3. Let stream have a [[\ReadableAmount]] internal slot initialized to zero.

Attributes

readable of type boolean, readonly

The readable attribute represents whether data can be read from the QuicReadableStream. On getting, it MUST return the value of the QuicReadableStream's [[\Readable]] slot.

readableAmount of type unsigned long, readonly

The readableAmount attribute represents the number of bytes buffered for access by readInto but that, as of the last time the event loop started executing a task, had not yet been read. This does not include framing overhead incurred by the protocol, or buffers associated with the network hardware. On getting, it MUST return the value of the QuicReadableStream's [[\ReadableAmount]] internal slot.

readingAborted of type QuicStreamAbortInfo readonly

The readingAborted attribute represents a promise that resolves when the RST_STREAM frame is received from the QuicWritableStream. When the stream receives a RST_STREAM frame from its corresponding QuicWritableStream, the user agent MUST run the following:

1. Let stream be the QuicReadableStream object
2. Set stream's [[\Readable]] slot to false.
3. Clear the stream's read buffer.
4. Let transport be the QuicTransportBase, which the stream was created from.
5. Remove the stream from the transport's [[\QuicTransportReadableStreams]] internal slot.
6. resolve the promise with the resulting QuicStreamAbortInfo with errorCode set to the value of the errror code from the RST_STREAM frame.

Methods

readInto

Reads from the QuicReadableStream into the buffer specified by the first argument and returns QuicStreamReadResult. When the readInto method is called, the user agent MUST run the following steps:

1. Let stream be the QuicReadableStream object on which readInto is invoked.
2. If stream's [[\Readable]] slot is false, throw an InvalidStateError, then abort these steps.
3. Let data be the first argument.
4. Let result be the QuicStreamReadResult to be returned.
5. If stream has finished reading, return result with amount set to 0 and finished set to true and abort these steps.
6. Transfer data from the read buffer into data.
7. Decrease the value of stream's [[\ReadableAmount]] slot by the length of data in bytes.
8. Set result's amount to the size of data in bytes.
9. If the data includes up to the FIN bit being read, then run the following steps:
1. Set result's finished to true.
2. Set the stream's [[\Readable]] slot to false.
3. Let transport be the QuicTransportBase, which the stream was created from.
4. Remove the stream from the transport's [[\QuicTransportReadableStreams]] internal slot.
10. Else, set result's finished to false.
11. Return result.

Parameter	Type	Nullable	Optional	Description
data	Uint8Array	✘	✘

Return type: QuicStreamReadResult

abortReading

A hard shutdown of the QuicReadableStream. It may be called regardless of whether the QuicReadableStream object was created by the local or remote peer. When the abortReading() method is called, the user agent MUST run the following steps:

1. Let stream be the QuicReadableStream object which is about to abort reading.
2. If stream's [[\Readable]] slot is false, throw an InvalidStateError and abort these steps.
3. Set stream's [[\Readable]] slot to false.
4. Clear the stream's read buffer.
5. Let transport be the QuicTransportBase, which the stream was created from.
6. Remove the stream from the transport's [[\QuicTransportReadableStreams]] internal slot.
7. Let abortInfo be the first argument.
8. Start the closing procedure by sending a STOP_SENDING frame with its error code set to the value of abortInfo.errorCode.

Parameter	Type	Nullable	Optional	Description
abortInfo	QuicStreamAbortInfo	✘	✘

Return type: void

waitForReadable

waitForReadable waits for data to become available, or for the QuicReadableStream to be finished reading. It resolves the promise when the data queued in the read buffer increases above the amount provided as an argument or when a STREAM frame with the FIN bit set has been received. If waitForReadable is called multiple times, multiple promises could be resolved. The Promise will be rejected with a newly created InvalidStateError if the stream's [[\Readable]] slot transitions from true to false and the promise isn't settled. When the waitForReadable method is called, the user agent MUST run the following steps:

1. Let stream be the QuicReadableStream on which waitForReadable is invoked.
2. Let p be a new promise.
3. If stream's [[\Readable]] slot is false, reject p with a newly created InvalidStateError and abort these steps.
4. Let amount be the first argument.
5. Resolve p with undefined when any of the following conditions are met:
   1. The [[\ReadableAmount]] increases from below the value of amount to greater than or equal to it.
   2. stream receives a STREAM frame with the FIN bit set and [[\ReadableAmount]] is less than amount.

Parameter	Type	Nullable	Optional	Description
amount	unsigned long	✘	✘

Return type: Promise<void>

Attributes

streamId of type unsigned long long, readonly

The readonly attribute referring to the ID of the QuicStream object.

transport of type QuicTransportBase, readonly

The readonly attribute referring to the related QuicTransportBase object.

Dictionary QuicStreamWriteParameters Members

data of type Uint8Array.

The data to be written.

finished of type boolean.

Set to true if this is the last data to be written. This will result in a STREAM frame with the FIN bit set.

Dictionary QuicStreamReadResult Members

amount of type unsigned long.

The amount of data read in bytes.

finished of type boolean.

Set to true if the QuicReadableStream has finished reading.

Dictionary QuicStreamAbortInfo Members

errorCode of type unsigned short.

The error code used in the RST_STREAM or STOP_SENDING frame. The default value of 0 means "STOPPING."