Struct PipeTo

struct PipeTo {
    reader: Dom<ReadableStreamDefaultReader>,
    writer: Dom<WritableStreamDefaultWriter>,
    pending_writes: Rc<RefCell<VecDeque<Rc<Promise>>>>,
    state: Rc<RefCell<PipeToState>>,
    prevent_abort: bool,
    prevent_cancel: bool,
    prevent_close: bool,
    shutting_down: Rc<Cell<bool>>,
    shutdown_error: Rc<Heap<JSVal>>,
    shutdown_action_promise: Rc<RefCell<Option<Rc<Promise>>>>,
    result_promise: Rc<Promise>,
}

The “in parallel, but not really” part of https://streams.spec.whatwg.org/#readable-stream-pipe-to

Note: the spec is flexible about how this is done, but requires the following constraints to apply:

• Public API must not be used: we’ll only use Rust.
• Backpressure must be enforced: we’ll only read from source when dest is ready.
• Shutdown must stop activity: we’ll do this together with the below.
• Error and close states must be propagated: we’ll do this by checking these states at every step.

Fields

reader: Dom<ReadableStreamDefaultReader>

https://streams.spec.whatwg.org/#ref-for-readablestream%E2%91%A7%E2%91%A0

writer: Dom<WritableStreamDefaultWriter>

https://streams.spec.whatwg.org/#ref-for-acquire-writable-stream-default-writer

pending_writes: Rc<RefCell<VecDeque<Rc<Promise>>>>

Pending writes are needed when shutting down(with an action), because we can only finalize when all writes are finished.

state: Rc<RefCell<PipeToState>>

The state machine.

prevent_abort: bool

https://streams.spec.whatwg.org/#readablestream-pipe-to-preventabort

prevent_cancel: bool

https://streams.spec.whatwg.org/#readablestream-pipe-to-preventcancel

prevent_close: bool

https://streams.spec.whatwg.org/#readablestream-pipe-to-preventclose

shutting_down: Rc<Cell<bool>>

The shuttingDown variable of https://streams.spec.whatwg.org/#readable-stream-pipe-to

shutdown_error: Rc<Heap<JSVal>>

The error potentially passed to shutdown, stored here because we must keep it across a microtask.

shutdown_action_promise: Rc<RefCell<Option<Rc<Promise>>>>

The promise returned by a shutdown action. We keep it to only continue when it is not pending anymore.

result_promise: Rc<Promise>

The promise resolved or rejected at https://streams.spec.whatwg.org/#rs-pipeTo-finalize

Implementations

impl PipeTo

fn wait_for_writer_ready( &self, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc, )

Wait for the writer to be ready, which implements the constraint that backpressure must be enforced.

fn read_chunk(&self, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc)

Read a chunk

fn write_chunk( &self, cx: SafeJSContext, global: &GlobalScope, chunk: SafeHandleValue<'_>, can_gc: CanGc, ) -> bool

Try to write a chunk using the jsval, and returns wether it succeeded

fn wait_on_pending_write( &self, global: &GlobalScope, promise: Rc<Promise>, realm: InRealm<'_>, can_gc: CanGc, )

Only as part of shutting-down do we wait on pending writes (backpressure is communicated not through pending writes but through the readiness of the writer).

fn check_and_propagate_errors_forward( &self, cx: SafeJSContext, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc, )

Errors must be propagated forward part of https://streams.spec.whatwg.org/#readable-stream-pipe-to

fn check_and_propagate_errors_backward( &self, cx: SafeJSContext, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc, )

Errors must be propagated backward part of https://streams.spec.whatwg.org/#readable-stream-pipe-to

fn check_and_propagate_closing_forward( &self, cx: SafeJSContext, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc, )

Closing must be propagated forward part of https://streams.spec.whatwg.org/#readable-stream-pipe-to

fn check_and_propagate_closing_backward( &self, cx: SafeJSContext, global: &GlobalScope, realm: InRealm<'_>, can_gc: CanGc, )

Closing must be propagated backward part of https://streams.spec.whatwg.org/#readable-stream-pipe-to

fn shutdown( &self, cx: SafeJSContext, global: &GlobalScope, action: Option<ShutdownAction>, realm: InRealm<'_>, can_gc: CanGc, )

https://streams.spec.whatwg.org/#rs-pipeTo-shutdown-with-action https://streams.spec.whatwg.org/#rs-pipeTo-shutdown Combined into one method with an optional action.

fn perform_action( &self, cx: SafeJSContext, global: &GlobalScope, action: ShutdownAction, realm: InRealm<'_>, can_gc: CanGc, )

The perform action part of https://streams.spec.whatwg.org/#rs-pipeTo-shutdown-with-action

fn finalize(&self, cx: SafeJSContext, global: &GlobalScope, can_gc: CanGc)

https://streams.spec.whatwg.org/#rs-pipeTo-finalize

Trait Implementations

impl Callback for PipeTo

fn callback( &self, cx: SafeJSContext, result: SafeHandleValue<'_>, realm: InRealm<'_>, can_gc: CanGc, )

The pipe makes progress one microtask at a time. Note: we use one struct as the callback for all promises, and for both of their reactions.

The context of the callback is determined from:

• the current state.
• the type of result.
• the state of a stored promise(in some cases).

impl Clone for PipeTo

fn clone(&self) -> PipeTo

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl MallocSizeOf for PipeTo

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl Rootable for PipeTo

const VTABLE: RootedVFTable = _

unsafe extern "C" fn trace( this: *mut c_void, trc: *mut JSTracer, _name: *const i8, )

impl Traceable for PipeTo

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.