Method asyncWriteWritable

Libraries/AsyncStreams/AsyncStreams.cpp:1368–1397

    return Result(true);
}

void AsyncPipeline::asyncWriteWritable(AsyncBufferView::ID bufferID, AsyncReadableStream& readable,
                                       AsyncWritableStream& writable)
{
    source->getBuffersPool().refBuffer(bufferID);
    if (not writable.canAcceptWrite())
    {
        PendingWrite* pendingWrite = findPendingWrite(readable, writable);
        SC_ASYNC_STREAMS_ASSERT_RELEASE(pendingWrite != nullptr);
        SC_ASYNC_STREAMS_ASSERT_RELEASE(not pendingWrite->bufferID.isValid());
        const bool wasAlreadyBackpressured = hasPendingWritesForReadable(readable);
        pendingWrite->readable             = &readable;
        pendingWrite->writable             = &writable;
        pendingWrite->bufferID             = bufferID;
        if (not wasAlreadyBackpressured)
        {
            readable.pause();
        }
        return;
    }

    Function<void(AsyncBufferView::ID)> func;
    func.template bind<AsyncPipeline, &AsyncPipeline::afterWrite>(*this);
    // TODO: We should probably block when closing for in-flight writes
    Result res = writable.write(bufferID, func);
    if (not res)
    {
        source->getBuffersPool().unrefBuffer(bufferID);
        eventError.emit(res);
    }
}

bool AsyncPipeline::retryPendingWrites()