diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/streams/ReadableByteStreamController.cpp | 2108 |
1 files changed, 2108 insertions, 0 deletions
diff --git a/dom/streams/ReadableByteStreamController.cpp b/dom/streams/ReadableByteStreamController.cpp new file mode 100644 index 0000000000..6a38e0aebe --- /dev/null +++ b/dom/streams/ReadableByteStreamController.cpp @@ -0,0 +1,2108 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set ts=2 sw=2 sts=2 et cindent: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/dom/ReadableByteStreamController.h" + +#include "ReadIntoRequest.h" +#include "js/ArrayBuffer.h" +#include "js/ErrorReport.h" +#include "js/Exception.h" +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "js/ValueArray.h" +#include "js/experimental/TypedData.h" +#include "js/friend/ErrorMessages.h" +#include "mozilla/AlreadyAddRefed.h" +#include "mozilla/Attributes.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/HoldDropJSObjects.h" +#include "mozilla/dom/ByteStreamHelpers.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Promise-inl.h" +#include "mozilla/dom/ReadableByteStreamControllerBinding.h" +#include "mozilla/dom/ReadableStream.h" +#include "mozilla/dom/ReadableStreamBYOBReader.h" +#include "mozilla/dom/ReadableStreamBYOBRequest.h" +#include "mozilla/dom/ReadableStreamController.h" +#include "mozilla/dom/ReadableStreamDefaultController.h" +#include "mozilla/dom/ReadableStreamDefaultReader.h" +#include "mozilla/dom/ReadableStreamGenericReader.h" +#include "mozilla/dom/ToJSValue.h" +#include "mozilla/dom/ScriptSettings.h" +#include "mozilla/dom/UnderlyingSourceCallbackHelpers.h" +#include "nsCycleCollectionParticipant.h" +#include "nsIGlobalObject.h" +#include "nsISupports.h" + +#include <algorithm> // std::min + +namespace mozilla::dom { + +using namespace streams_abstract; + +// https://streams.spec.whatwg.org/#readable-byte-stream-queue-entry +struct ReadableByteStreamQueueEntry + : LinkedListElement<RefPtr<ReadableByteStreamQueueEntry>> { + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING( + ReadableByteStreamQueueEntry) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS( + ReadableByteStreamQueueEntry) + + ReadableByteStreamQueueEntry(JS::Handle<JSObject*> aBuffer, + size_t aByteOffset, size_t aByteLength) + : mBuffer(aBuffer), mByteOffset(aByteOffset), mByteLength(aByteLength) { + mozilla::HoldJSObjects(this); + } + + JSObject* Buffer() const { return mBuffer; } + void SetBuffer(JS::Handle<JSObject*> aBuffer) { mBuffer = aBuffer; } + + size_t ByteOffset() const { return mByteOffset; } + void SetByteOffset(size_t aByteOffset) { mByteOffset = aByteOffset; } + + size_t ByteLength() const { return mByteLength; } + void SetByteLength(size_t aByteLength) { mByteLength = aByteLength; } + + void ClearBuffer() { mBuffer = nullptr; } + + private: + // An ArrayBuffer, which will be a transferred version of the one originally + // supplied by the underlying byte source. + JS::Heap<JSObject*> mBuffer; + + // A nonnegative integer number giving the byte offset derived from the view + // originally supplied by the underlying byte source + size_t mByteOffset = 0; + + // A nonnegative integer number giving the byte length derived from the view + // originally supplied by the underlying byte source + size_t mByteLength = 0; + + ~ReadableByteStreamQueueEntry() { mozilla::DropJSObjects(this); } +}; + +NS_IMPL_CYCLE_COLLECTION_WITH_JS_MEMBERS(ReadableByteStreamQueueEntry, (), + (mBuffer)); + +struct PullIntoDescriptor final + : LinkedListElement<RefPtr<PullIntoDescriptor>> { + NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(PullIntoDescriptor) + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(PullIntoDescriptor) + + enum Constructor { + DataView, +#define DEFINE_TYPED_CONSTRUCTOR_ENUM_NAMES(ExternalT, NativeT, Name) Name, + JS_FOR_EACH_TYPED_ARRAY(DEFINE_TYPED_CONSTRUCTOR_ENUM_NAMES) +#undef DEFINE_TYPED_CONSTRUCTOR_ENUM_NAMES + }; + + static Constructor constructorFromScalar(JS::Scalar::Type type) { + switch (type) { +#define REMAP_PULL_INTO_DESCRIPTOR_TYPE(ExternalT, NativeT, Name) \ + case JS::Scalar::Name: \ + return Constructor::Name; + JS_FOR_EACH_TYPED_ARRAY(REMAP_PULL_INTO_DESCRIPTOR_TYPE) +#undef REMAP + + case JS::Scalar::Int64: + case JS::Scalar::Simd128: + case JS::Scalar::MaxTypedArrayViewType: + break; + } + MOZ_CRASH("Unexpected Scalar::Type"); + } + + PullIntoDescriptor(JS::Handle<JSObject*> aBuffer, uint64_t aBufferByteLength, + uint64_t aByteOffset, uint64_t aByteLength, + uint64_t aBytesFilled, uint64_t aElementSize, + Constructor aViewConstructor, ReaderType aReaderType) + : mBuffer(aBuffer), + mBufferByteLength(aBufferByteLength), + mByteOffset(aByteOffset), + mByteLength(aByteLength), + mBytesFilled(aBytesFilled), + mElementSize(aElementSize), + mViewConstructor(aViewConstructor), + mReaderType(aReaderType) { + mozilla::HoldJSObjects(this); + } + + JSObject* Buffer() const { return mBuffer; } + void SetBuffer(JS::Handle<JSObject*> aBuffer) { mBuffer = aBuffer; } + + uint64_t BufferByteLength() const { return mBufferByteLength; } + void SetBufferByteLength(const uint64_t aBufferByteLength) { + mBufferByteLength = aBufferByteLength; + } + + uint64_t ByteOffset() const { return mByteOffset; } + void SetByteOffset(const uint64_t aByteOffset) { mByteOffset = aByteOffset; } + + uint64_t ByteLength() const { return mByteLength; } + void SetByteLength(const uint64_t aByteLength) { mByteLength = aByteLength; } + + uint64_t BytesFilled() const { return mBytesFilled; } + void SetBytesFilled(const uint64_t aBytesFilled) { + mBytesFilled = aBytesFilled; + } + + uint64_t ElementSize() const { return mElementSize; } + void SetElementSize(const uint64_t aElementSize) { + mElementSize = aElementSize; + } + + Constructor ViewConstructor() const { return mViewConstructor; } + + // Note: Named GetReaderType to avoid name conflict with type. + ReaderType GetReaderType() const { return mReaderType; } + void SetReaderType(const ReaderType aReaderType) { + mReaderType = aReaderType; + } + + void ClearBuffer() { mBuffer = nullptr; } + + private: + JS::Heap<JSObject*> mBuffer; + uint64_t mBufferByteLength = 0; + uint64_t mByteOffset = 0; + uint64_t mByteLength = 0; + uint64_t mBytesFilled = 0; + uint64_t mElementSize = 0; + Constructor mViewConstructor; + ReaderType mReaderType; + + ~PullIntoDescriptor() { mozilla::DropJSObjects(this); } +}; + +NS_IMPL_CYCLE_COLLECTION_WITH_JS_MEMBERS(PullIntoDescriptor, (), (mBuffer)); + +NS_IMPL_CYCLE_COLLECTION_CLASS(ReadableByteStreamController) +NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(ReadableByteStreamController, + ReadableStreamController) + NS_IMPL_CYCLE_COLLECTION_UNLINK(mByobRequest, mQueue, mPendingPullIntos) + NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_UNLINK_END + +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(ReadableByteStreamController, + ReadableStreamController) + NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mByobRequest, mQueue, mPendingPullIntos) +NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END + +NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(ReadableByteStreamController, + ReadableStreamController) + NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER +NS_IMPL_CYCLE_COLLECTION_TRACE_END + +NS_IMPL_ADDREF_INHERITED(ReadableByteStreamController, ReadableStreamController) +NS_IMPL_RELEASE_INHERITED(ReadableByteStreamController, + ReadableStreamController) +NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ReadableByteStreamController) + NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY +NS_INTERFACE_MAP_END_INHERITING(ReadableStreamController) + +ReadableByteStreamController::ReadableByteStreamController( + nsIGlobalObject* aGlobal) + : ReadableStreamController(aGlobal) {} + +ReadableByteStreamController::~ReadableByteStreamController() { + ClearPendingPullIntos(); + ClearQueue(); +} + +void ReadableByteStreamController::ClearQueue() { + // Since the pull intos are traced only by the owning + // ReadableByteStreamController, when clearning the list we also clear JS + // references to avoid dangling JS references. + for (auto* queueEntry : mQueue) { + queueEntry->ClearBuffer(); + } + mQueue.clear(); +} + +void ReadableByteStreamController::ClearPendingPullIntos() { + // Since the pull intos are traced only by the owning + // ReadableByteStreamController, when clearning the list we also clear JS + // references to avoid dangling JS references. + for (auto* pullInto : mPendingPullIntos) { + pullInto->ClearBuffer(); + } + mPendingPullIntos.clear(); +} + +namespace streams_abstract { +// https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollergetbyobrequest +already_AddRefed<ReadableStreamBYOBRequest> +ReadableByteStreamControllerGetBYOBRequest( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. + if (!aController->GetByobRequest() && + !aController->PendingPullIntos().isEmpty()) { + // Step 1.1: + PullIntoDescriptor* firstDescriptor = + aController->PendingPullIntos().getFirst(); + + // Step 1.2: + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> buffer(aCx, firstDescriptor->Buffer()); + JS::Rooted<JSObject*> view( + aCx, JS_NewUint8ArrayWithBuffer( + aCx, buffer, + firstDescriptor->ByteOffset() + firstDescriptor->BytesFilled(), + int64_t(firstDescriptor->ByteLength() - + firstDescriptor->BytesFilled()))); + if (!view) { + aRv.StealExceptionFromJSContext(aCx); + return nullptr; + } + + // Step 1.3: + RefPtr<ReadableStreamBYOBRequest> byobRequest = + new ReadableStreamBYOBRequest(aController->GetParentObject()); + + // Step 1.4: + byobRequest->SetController(aController); + + // Step 1.5: + byobRequest->SetView(view); + + // Step 1.6: + aController->SetByobRequest(byobRequest); + } + + // Step 2. + RefPtr<ReadableStreamBYOBRequest> request(aController->GetByobRequest()); + return request.forget(); +} +} // namespace streams_abstract + +already_AddRefed<ReadableStreamBYOBRequest> +ReadableByteStreamController::GetByobRequest(JSContext* aCx, ErrorResult& aRv) { + return ReadableByteStreamControllerGetBYOBRequest(aCx, this, aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-get-desired-size +Nullable<double> ReadableByteStreamControllerGetDesiredSize( + const ReadableByteStreamController* aController) { + // Step 1. + ReadableStream::ReaderState state = aController->Stream()->State(); + + // Step 2. + if (state == ReadableStream::ReaderState::Errored) { + return nullptr; + } + + // Step 3. + if (state == ReadableStream::ReaderState::Closed) { + return 0.0; + } + + // Step 4. + return aController->StrategyHWM() - aController->QueueTotalSize(); +} + +Nullable<double> ReadableByteStreamController::GetDesiredSize() const { + // Step 1. + return ReadableByteStreamControllerGetDesiredSize(this); +} + +JSObject* ReadableByteStreamController::WrapObject( + JSContext* aCx, JS::Handle<JSObject*> aGivenProto) { + return ReadableByteStreamController_Binding::Wrap(aCx, this, aGivenProto); +} + +namespace streams_abstract { + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-invalidate-byob-request +static void ReadableByteStreamControllerInvalidateBYOBRequest( + ReadableByteStreamController* aController) { + // Step 1. + if (!aController->GetByobRequest()) { + return; + } + + // Step 2. + aController->GetByobRequest()->SetController(nullptr); + + // Step 3. + aController->GetByobRequest()->SetView(nullptr); + + // Step 4. + aController->SetByobRequest(nullptr); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-clear-pending-pull-intos +void ReadableByteStreamControllerClearPendingPullIntos( + ReadableByteStreamController* aController) { + // Step 1. + ReadableByteStreamControllerInvalidateBYOBRequest(aController); + + // Step 2. + aController->ClearPendingPullIntos(); +} + +// https://streams.spec.whatwg.org/#reset-queue +void ResetQueue(ReadableByteStreamController* aContainer) { + // Step 1. Implied by type. + // Step 2. + aContainer->ClearQueue(); + + // Step 3. + aContainer->SetQueueTotalSize(0); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-clear-algorithms +void ReadableByteStreamControllerClearAlgorithms( + ReadableByteStreamController* aController) { + // Step 1. Set controller.[[pullAlgorithm]] to undefined. + // Step 2. Set controller.[[cancelAlgorithm]] to undefined. + aController->ClearAlgorithms(); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-error +void ReadableByteStreamControllerError( + ReadableByteStreamController* aController, JS::Handle<JS::Value> aValue, + ErrorResult& aRv) { + // Step 1. Let stream be controller.[[stream]]. + ReadableStream* stream = aController->Stream(); + + // Step 2. If stream.[[state]] is not "readable", return. + if (stream->State() != ReadableStream::ReaderState::Readable) { + return; + } + + // Step 3. Perform + // !ReadableByteStreamControllerClearPendingPullIntos(controller). + ReadableByteStreamControllerClearPendingPullIntos(aController); + + // Step 4. Perform !ResetQueue(controller). + ResetQueue(aController); + + // Step 5. Perform !ReadableByteStreamControllerClearAlgorithms(controller). + ReadableByteStreamControllerClearAlgorithms(aController); + + // Step 6. Perform !ReadableStreamError(stream, e). + AutoJSAPI jsapi; + if (!jsapi.Init(aController->GetParentObject())) { + return; + } + ReadableStreamError(jsapi.cx(), stream, aValue, aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-close +void ReadableByteStreamControllerClose( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. + RefPtr<ReadableStream> stream = aController->Stream(); + + // Step 2. + if (aController->CloseRequested() || + stream->State() != ReadableStream::ReaderState::Readable) { + return; + } + + // Step 3. + if (aController->QueueTotalSize() > 0) { + // Step 3.1 + aController->SetCloseRequested(true); + // Step 3.2 + return; + } + + // Step 4. + if (!aController->PendingPullIntos().isEmpty()) { + // Step 4.1 + PullIntoDescriptor* firstPendingPullInto = + aController->PendingPullIntos().getFirst(); + // Step 4.2 + if (firstPendingPullInto->BytesFilled() > 0) { + // Step 4.2.1 + ErrorResult rv; + rv.ThrowTypeError("Leftover Bytes"); + + JS::Rooted<JS::Value> exception(aCx); + MOZ_ALWAYS_TRUE(ToJSValue(aCx, std::move(rv), &exception)); + + // Step 4.2.2 + ReadableByteStreamControllerError(aController, exception, aRv); + if (aRv.Failed()) { + return; + } + + aRv.MightThrowJSException(); + aRv.ThrowJSException(aCx, exception); + return; + } + } + + // Step 5. + ReadableByteStreamControllerClearAlgorithms(aController); + + // Step 6. + ReadableStreamClose(aCx, stream, aRv); +} + +} // namespace streams_abstract + +// https://streams.spec.whatwg.org/#rbs-controller-close +void ReadableByteStreamController::Close(JSContext* aCx, ErrorResult& aRv) { + // Step 1. + if (mCloseRequested) { + aRv.ThrowTypeError("Close already requested"); + return; + } + + // Step 2. + if (Stream()->State() != ReadableStream::ReaderState::Readable) { + aRv.ThrowTypeError("Closing un-readable stream controller"); + return; + } + + // Step 3. + ReadableByteStreamControllerClose(aCx, this, aRv); +} + +namespace streams_abstract { + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-enqueue-chunk-to-queue +void ReadableByteStreamControllerEnqueueChunkToQueue( + ReadableByteStreamController* aController, + JS::Handle<JSObject*> aTransferredBuffer, size_t aByteOffset, + size_t aByteLength) { + // Step 1. + RefPtr<ReadableByteStreamQueueEntry> queueEntry = + new ReadableByteStreamQueueEntry(aTransferredBuffer, aByteOffset, + aByteLength); + aController->Queue().insertBack(queueEntry); + + // Step 2. + aController->AddToQueueTotalSize(double(aByteLength)); +} + +// https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollerenqueueclonedchunktoqueue +void ReadableByteStreamControllerEnqueueClonedChunkToQueue( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aBuffer, size_t aByteOffset, size_t aByteLength, + ErrorResult& aRv) { + // Step 1. Let cloneResult be CloneArrayBuffer(buffer, byteOffset, byteLength, + // %ArrayBuffer%). + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> cloneResult( + aCx, JS::ArrayBufferClone(aCx, aBuffer, aByteOffset, aByteLength)); + + // Step 2. If cloneResult is an abrupt completion, + if (!cloneResult) { + JS::Rooted<JS::Value> exception(aCx); + if (!JS_GetPendingException(aCx, &exception)) { + // Uncatchable exception; we should mark aRv and return. + aRv.StealExceptionFromJSContext(aCx); + return; + } + JS_ClearPendingException(aCx); + + // Step 2.1. Perform ! ReadableByteStreamControllerError(controller, + // cloneResult.[[Value]]). + ReadableByteStreamControllerError(aController, exception, aRv); + if (aRv.Failed()) { + return; + } + + // Step 2.2. Return cloneResult. + aRv.ThrowJSException(aCx, exception); + return; + } + + // Step 3. Perform ! + // ReadableByteStreamControllerEnqueueChunkToQueue(controller, + // cloneResult.[[Value]], 0, byteLength). + ReadableByteStreamControllerEnqueueChunkToQueue(aController, cloneResult, 0, + aByteLength); +} + +already_AddRefed<PullIntoDescriptor> +ReadableByteStreamControllerShiftPendingPullInto( + ReadableByteStreamController* aController); + +// https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollerenqueuedetachedpullintotoqueue +void ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue( + JSContext* aCx, ReadableByteStreamController* aController, + PullIntoDescriptor* aPullIntoDescriptor, ErrorResult& aRv) { + // Step 1. Assert: pullIntoDescriptor’s reader type is "none". + MOZ_ASSERT(aPullIntoDescriptor->GetReaderType() == ReaderType::None); + + // Step 2. If pullIntoDescriptor’s bytes filled > 0, + // perform ? ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, + // pullIntoDescriptor’s buffer, pullIntoDescriptor’s byte offset, + // pullIntoDescriptor’s bytes filled). + if (aPullIntoDescriptor->BytesFilled() > 0) { + JS::Rooted<JSObject*> buffer(aCx, aPullIntoDescriptor->Buffer()); + ReadableByteStreamControllerEnqueueClonedChunkToQueue( + aCx, aController, buffer, aPullIntoDescriptor->ByteOffset(), + aPullIntoDescriptor->BytesFilled(), aRv); + if (aRv.Failed()) { + return; + } + } + + // Step 3. Perform ! + // ReadableByteStreamControllerShiftPendingPullInto(controller). + RefPtr<PullIntoDescriptor> discarded = + ReadableByteStreamControllerShiftPendingPullInto(aController); + (void)discarded; +} + +// https://streams.spec.whatwg.org/#readable-stream-get-num-read-into-requests +static size_t ReadableStreamGetNumReadIntoRequests(ReadableStream* aStream) { + // Step 1. + MOZ_ASSERT(ReadableStreamHasBYOBReader(aStream)); + + // Step 2. + return aStream->GetReader()->AsBYOB()->ReadIntoRequests().length(); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-should-call-pull +bool ReadableByteStreamControllerShouldCallPull( + ReadableByteStreamController* aController) { + // Step 1. Let stream be controller.[[stream]]. + ReadableStream* stream = aController->Stream(); + + // Step 2. If stream.[[state]] is not "readable", return false. + if (stream->State() != ReadableStream::ReaderState::Readable) { + return false; + } + + // Step 3. If controller.[[closeRequested]] is true, return false. + if (aController->CloseRequested()) { + return false; + } + + // Step 4. If controller.[[started]] is false, return false. + if (!aController->Started()) { + return false; + } + + // Step 5. If ! ReadableStreamHasDefaultReader(stream) is true + // and ! ReadableStreamGetNumReadRequests(stream) > 0, return true. + if (ReadableStreamHasDefaultReader(stream) && + ReadableStreamGetNumReadRequests(stream) > 0) { + return true; + } + + // Step 6. If ! ReadableStreamHasBYOBReader(stream) is true + // and ! ReadableStreamGetNumReadIntoRequests(stream) > 0, return true. + if (ReadableStreamHasBYOBReader(stream) && + ReadableStreamGetNumReadIntoRequests(stream) > 0) { + return true; + } + + // Step 7. Let desiredSize be + // ! ReadableByteStreamControllerGetDesiredSize(controller). + Nullable<double> desiredSize = + ReadableByteStreamControllerGetDesiredSize(aController); + + // Step 8. Assert: desiredSize is not null. + MOZ_ASSERT(!desiredSize.IsNull()); + + // Step 9. If desiredSize > 0, return true. + // Step 10. Return false. + return desiredSize.Value() > 0; +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-call-pull-if-needed +void ReadableByteStreamControllerCallPullIfNeeded( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. + bool shouldPull = ReadableByteStreamControllerShouldCallPull(aController); + + // Step 2. + if (!shouldPull) { + return; + } + + // Step 3. + if (aController->Pulling()) { + aController->SetPullAgain(true); + return; + } + + // Step 4. + MOZ_ASSERT(!aController->PullAgain()); + + // Step 5. + aController->SetPulling(true); + + // Step 6. + RefPtr<ReadableStreamController> controller(aController); + RefPtr<UnderlyingSourceAlgorithmsBase> algorithms = + aController->GetAlgorithms(); + RefPtr<Promise> pullPromise = algorithms->PullCallback(aCx, *controller, aRv); + if (aRv.Failed()) { + return; + } + + // Steps 7+8 + pullPromise->AddCallbacksWithCycleCollectedArgs( + [](JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv, + ReadableByteStreamController* aController) + MOZ_CAN_RUN_SCRIPT_BOUNDARY { + // Step 7.1 + aController->SetPulling(false); + // Step 7.2 + if (aController->PullAgain()) { + // Step 7.2.1 + aController->SetPullAgain(false); + + // Step 7.2.2 + ReadableByteStreamControllerCallPullIfNeeded( + aCx, MOZ_KnownLive(aController), aRv); + } + }, + [](JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv, + ReadableByteStreamController* aController) { + // Step 8.1 + ReadableByteStreamControllerError(aController, aValue, aRv); + }, + RefPtr(aController)); +} + +bool ReadableByteStreamControllerFillPullIntoDescriptorFromQueue( + JSContext* aCx, ReadableByteStreamController* aController, + PullIntoDescriptor* aPullIntoDescriptor, ErrorResult& aRv); + +JSObject* ReadableByteStreamControllerConvertPullIntoDescriptor( + JSContext* aCx, PullIntoDescriptor* pullIntoDescriptor, ErrorResult& aRv); + +// https://streams.spec.whatwg.org/#readable-stream-fulfill-read-into-request +MOZ_CAN_RUN_SCRIPT +void ReadableStreamFulfillReadIntoRequest(JSContext* aCx, + ReadableStream* aStream, + JS::Handle<JS::Value> aChunk, + bool done, ErrorResult& aRv) { + // Step 1. Assert: !ReadableStreamHasBYOBReader(stream) is true. + MOZ_ASSERT(ReadableStreamHasBYOBReader(aStream)); + + // Step 2. Let reader be stream.[[reader]]. + ReadableStreamBYOBReader* reader = aStream->GetReader()->AsBYOB(); + + // Step 3. Assert: reader.[[readIntoRequests]] is not empty. + MOZ_ASSERT(!reader->ReadIntoRequests().isEmpty()); + + // Step 4. Let readIntoRequest be reader.[[readIntoRequests]][0]. + // Step 5. Remove readIntoRequest from reader.[[readIntoRequests]]. + RefPtr<ReadIntoRequest> readIntoRequest = + reader->ReadIntoRequests().popFirst(); + + // Step 6. If done is true, perform readIntoRequest’s close steps, given + // chunk. + if (done) { + readIntoRequest->CloseSteps(aCx, aChunk, aRv); + return; + } + + // Step 7. Otherwise, perform readIntoRequest’s chunk steps, given chunk. + readIntoRequest->ChunkSteps(aCx, aChunk, aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-commit-pull-into-descriptor +MOZ_CAN_RUN_SCRIPT +void ReadableByteStreamControllerCommitPullIntoDescriptor( + JSContext* aCx, ReadableStream* aStream, + PullIntoDescriptor* pullIntoDescriptor, ErrorResult& aRv) { + // Step 1. Assert: stream.[[state]] is not "errored". + MOZ_ASSERT(aStream->State() != ReadableStream::ReaderState::Errored); + + // Step 2. Assert: pullIntoDescriptor.reader type is not "none". + MOZ_ASSERT(pullIntoDescriptor->GetReaderType() != ReaderType::None); + + // Step 3. Let done be false. + bool done = false; + + // Step 4. If stream.[[state]] is "closed", + if (aStream->State() == ReadableStream::ReaderState::Closed) { + // Step 4.1. Assert: pullIntoDescriptor’s bytes filled is 0. + MOZ_ASSERT(pullIntoDescriptor->BytesFilled() == 0); + + // Step 4.2. Set done to true. + done = true; + } + + // Step 5. Let filledView be ! + // ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor). + JS::Rooted<JSObject*> filledView( + aCx, ReadableByteStreamControllerConvertPullIntoDescriptor( + aCx, pullIntoDescriptor, aRv)); + if (aRv.Failed()) { + return; + } + JS::Rooted<JS::Value> filledViewValue(aCx, JS::ObjectValue(*filledView)); + + // Step 6. If pullIntoDescriptor’s reader type is "default", + if (pullIntoDescriptor->GetReaderType() == ReaderType::Default) { + // Step 6.1. Perform !ReadableStreamFulfillReadRequest(stream, filledView, + // done). + ReadableStreamFulfillReadRequest(aCx, aStream, filledViewValue, done, aRv); + return; + } + + // Step 7.1. Assert: pullIntoDescriptor’s reader type is "byob". + MOZ_ASSERT(pullIntoDescriptor->GetReaderType() == ReaderType::BYOB); + + // Step 7.2 Perform !ReadableStreamFulfillReadIntoRequest(stream, filledView, + // done). + ReadableStreamFulfillReadIntoRequest(aCx, aStream, filledViewValue, done, + aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-process-pull-into-descriptors-using-queue +MOZ_CAN_RUN_SCRIPT +void ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. Assert: controller.[[closeRequested]] is false. + MOZ_ASSERT(!aController->CloseRequested()); + + // Step 2. While controller.[[pendingPullIntos]] is not empty, + while (!aController->PendingPullIntos().isEmpty()) { + // Step 2.1 If controller.[[queueTotalSize]] is 0, return. + if (aController->QueueTotalSize() == 0) { + return; + } + + // Step 2.2. Let pullIntoDescriptor be controller.[[pendingPullIntos]][0]. + RefPtr<PullIntoDescriptor> pullIntoDescriptor = + aController->PendingPullIntos().getFirst(); + + // Step 2.3. If + // !ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, + // pullIntoDescriptor) is true, + bool ready = ReadableByteStreamControllerFillPullIntoDescriptorFromQueue( + aCx, aController, pullIntoDescriptor, aRv); + if (aRv.Failed()) { + return; + } + + if (ready) { + // Step 2.3.1. Perform + // !ReadableByteStreamControllerShiftPendingPullInto(controller). + RefPtr<PullIntoDescriptor> discardedPullIntoDescriptor = + ReadableByteStreamControllerShiftPendingPullInto(aController); + + // Step 2.3.2. Perform + // !ReadableByteStreamControllerCommitPullIntoDescriptor(controller.[[stream]], + // pullIntoDescriptor). + RefPtr<ReadableStream> stream(aController->Stream()); + ReadableByteStreamControllerCommitPullIntoDescriptor( + aCx, stream, pullIntoDescriptor, aRv); + if (aRv.Failed()) { + return; + } + } + } +} + +MOZ_CAN_RUN_SCRIPT +void ReadableByteStreamControllerHandleQueueDrain( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv); + +// https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollerfillreadrequestfromqueue +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerFillReadRequestFromQueue( + JSContext* aCx, ReadableByteStreamController* aController, + ReadRequest* aReadRequest, ErrorResult& aRv) { + // Step 1. Assert: controller.[[queueTotalSize]] > 0. + MOZ_ASSERT(aController->QueueTotalSize() > 0); + // Also assert that the queue has a non-zero length; + MOZ_ASSERT(aController->Queue().length() > 0); + + // Step 2. Let entry be controller.[[queue]][0]. + // Step 3. Remove entry from controller.[[queue]]. + RefPtr<ReadableByteStreamQueueEntry> entry = aController->Queue().popFirst(); + + // Assert that we actually got an entry. + MOZ_ASSERT(entry); + + // Step 4. Set controller.[[queueTotalSize]] to controller.[[queueTotalSize]] + // − entry’s byte length. + aController->SetQueueTotalSize(aController->QueueTotalSize() - + double(entry->ByteLength())); + + // Step 5. Perform ! ReadableByteStreamControllerHandleQueueDrain(controller). + ReadableByteStreamControllerHandleQueueDrain(aCx, aController, aRv); + if (aRv.Failed()) { + return; + } + + // Step 6. Let view be ! Construct(%Uint8Array%, « entry’s buffer, entry’s + // byte offset, entry’s byte length »). + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> buffer(aCx, entry->Buffer()); + JS::Rooted<JSObject*> view( + aCx, JS_NewUint8ArrayWithBuffer(aCx, buffer, entry->ByteOffset(), + int64_t(entry->ByteLength()))); + if (!view) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // Step 7. Perform readRequest’s chunk steps, given view. + JS::Rooted<JS::Value> viewValue(aCx, JS::ObjectValue(*view)); + aReadRequest->ChunkSteps(aCx, viewValue, aRv); +} + +MOZ_CAN_RUN_SCRIPT void +ReadableByteStreamControllerProcessReadRequestsUsingQueue( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. Let reader be controller.[[stream]].[[reader]]. + // Step 2. Assert: reader implements ReadableStreamDefaultReader. + RefPtr<ReadableStreamDefaultReader> reader = + aController->Stream()->GetDefaultReader(); + + // Step 3. While reader.[[readRequests]] is not empty, + while (!reader->ReadRequests().isEmpty()) { + // Step 3.1. If controller.[[queueTotalSize]] is 0, return. + if (aController->QueueTotalSize() == 0) { + return; + } + + // Step 3.2. Let readRequest be reader.[[readRequests]][0]. + // Step 3.3. Remove readRequest from reader.[[readRequests]]. + RefPtr<ReadRequest> readRequest = reader->ReadRequests().popFirst(); + + // Step 3.4. Perform ! + // ReadableByteStreamControllerFillReadRequestFromQueue(controller, + // readRequest). + ReadableByteStreamControllerFillReadRequestFromQueue(aCx, aController, + readRequest, aRv); + if (aRv.Failed()) { + return; + } + } +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-enqueue +void ReadableByteStreamControllerEnqueue( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aChunk, ErrorResult& aRv) { + aRv.MightThrowJSException(); + + // Step 1. + RefPtr<ReadableStream> stream = aController->Stream(); + + // Step 2. + if (aController->CloseRequested() || + stream->State() != ReadableStream::ReaderState::Readable) { + return; + } + + // Step 3. + bool isShared; + JS::Rooted<JSObject*> buffer( + aCx, JS_GetArrayBufferViewBuffer(aCx, aChunk, &isShared)); + if (!buffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // Step 4. + size_t byteOffset = JS_GetArrayBufferViewByteOffset(aChunk); + + // Step 5. + size_t byteLength = JS_GetArrayBufferViewByteLength(aChunk); + + // Step 6. + if (JS::IsDetachedArrayBufferObject(buffer)) { + aRv.ThrowTypeError("Detatched Array Buffer"); + return; + } + + // Step 7. + JS::Rooted<JSObject*> transferredBuffer(aCx, + TransferArrayBuffer(aCx, buffer)); + if (!transferredBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // Step 8. + if (!aController->PendingPullIntos().isEmpty()) { + // Step 8.1 + RefPtr<PullIntoDescriptor> firstPendingPullInto = + aController->PendingPullIntos().getFirst(); + + // Step 8.2 + JS::Rooted<JSObject*> pendingBuffer(aCx, firstPendingPullInto->Buffer()); + if (JS::IsDetachedArrayBufferObject(pendingBuffer)) { + aRv.ThrowTypeError("Pending PullInto has detached buffer"); + return; + } + + // Step 8.3. Perform ! + // ReadableByteStreamControllerInvalidateBYOBRequest(controller). + ReadableByteStreamControllerInvalidateBYOBRequest(aController); + + // Step 8.4. Set firstPendingPullInto’s buffer to ! + // TransferArrayBuffer(firstPendingPullInto’s buffer). + pendingBuffer = TransferArrayBuffer(aCx, pendingBuffer); + if (!pendingBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + firstPendingPullInto->SetBuffer(pendingBuffer); + + // Step 8.5. If firstPendingPullInto’s reader type is "none", perform ? + // ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, + // firstPendingPullInto). + if (firstPendingPullInto->GetReaderType() == ReaderType::None) { + ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue( + aCx, aController, firstPendingPullInto, aRv); + if (aRv.Failed()) { + return; + } + } + } + + // Step 9. If ! ReadableStreamHasDefaultReader(stream) is true, + if (ReadableStreamHasDefaultReader(stream)) { + // Step 9.1. Perform ! + // ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller). + ReadableByteStreamControllerProcessReadRequestsUsingQueue(aCx, aController, + aRv); + if (aRv.Failed()) { + return; + } + + // Step 9.2. If ! ReadableStreamGetNumReadRequests(stream) is 0, + if (ReadableStreamGetNumReadRequests(stream) == 0) { + // Step 9.2.1 Assert: controller.[[pendingPullIntos]] is empty. + MOZ_ASSERT(aController->PendingPullIntos().isEmpty()); + + // Step 9.2.2. Perform ! + // ReadableByteStreamControllerEnqueueChunkToQueue(controller, + // transferredBuffer, byteOffset, byteLength). + ReadableByteStreamControllerEnqueueChunkToQueue( + aController, transferredBuffer, byteOffset, byteLength); + + // Step 9.3. Otherwise, + } else { + // Step 9.3.1 Assert: controller.[[queue]] is empty. + MOZ_ASSERT(aController->Queue().isEmpty()); + + // Step 9.3.2. If controller.[[pendingPullIntos]] is not empty, + if (!aController->PendingPullIntos().isEmpty()) { + // Step 9.3.2.1. Assert: controller.[[pendingPullIntos]][0]'s reader + // type is "default". + MOZ_ASSERT( + aController->PendingPullIntos().getFirst()->GetReaderType() == + ReaderType::Default); + + // Step 9.3.2.2. Perform ! + // ReadableByteStreamControllerShiftPendingPullInto(controller). + RefPtr<PullIntoDescriptor> pullIntoDescriptor = + ReadableByteStreamControllerShiftPendingPullInto(aController); + (void)pullIntoDescriptor; + } + + // Step 9.3.3. Let transferredView be ! Construct(%Uint8Array%, « + // transferredBuffer, byteOffset, byteLength »). + JS::Rooted<JSObject*> transferredView( + aCx, JS_NewUint8ArrayWithBuffer(aCx, transferredBuffer, byteOffset, + int64_t(byteLength))); + if (!transferredView) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // Step 9.3.4. Perform ! ReadableStreamFulfillReadRequest(stream, + // transferredView, false). + JS::Rooted<JS::Value> transferredViewValue( + aCx, JS::ObjectValue(*transferredView)); + ReadableStreamFulfillReadRequest(aCx, stream, transferredViewValue, false, + aRv); + if (aRv.Failed()) { + return; + } + } + + // Step 10. Otherwise, if ! ReadableStreamHasBYOBReader(stream) is true, + } else if (ReadableStreamHasBYOBReader(stream)) { + // Step 10.1. Perform ! + // ReadableByteStreamControllerEnqueueChunkToQueue(controller, + // transferredBuffer, byteOffset, byteLength). + ReadableByteStreamControllerEnqueueChunkToQueue( + aController, transferredBuffer, byteOffset, byteLength); + + // Step 10.2 Perform ! + // ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller). + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue( + aCx, aController, aRv); + if (aRv.Failed()) { + return; + } + + // Step 11. Otherwise, + } else { + // Step 11.1. Assert: ! IsReadableStreamLocked(stream) is false. + MOZ_ASSERT(!IsReadableStreamLocked(stream)); + + // Step 11.2. Perform ! + // ReadableByteStreamControllerEnqueueChunkToQueue(controller, + // transferredBuffer, byteOffset, byteLength). + ReadableByteStreamControllerEnqueueChunkToQueue( + aController, transferredBuffer, byteOffset, byteLength); + } + + // Step 12. Perform ! + // ReadableByteStreamControllerCallPullIfNeeded(controller). + ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv); +} + +} // namespace streams_abstract + +// https://streams.spec.whatwg.org/#rbs-controller-enqueue +void ReadableByteStreamController::Enqueue(JSContext* aCx, + const ArrayBufferView& aChunk, + ErrorResult& aRv) { + // Step 1. + JS::Rooted<JSObject*> chunk(aCx, aChunk.Obj()); + if (JS_GetArrayBufferViewByteLength(chunk) == 0) { + aRv.ThrowTypeError("Zero Length View"); + return; + } + + // Step 2. + bool isShared; + JS::Rooted<JSObject*> viewedArrayBuffer( + aCx, JS_GetArrayBufferViewBuffer(aCx, chunk, &isShared)); + if (!viewedArrayBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + if (JS::GetArrayBufferByteLength(viewedArrayBuffer) == 0) { + aRv.ThrowTypeError("Zero Length Buffer"); + return; + } + + // Step 3. + if (CloseRequested()) { + aRv.ThrowTypeError("close requested"); + return; + } + + // Step 4. + if (Stream()->State() != ReadableStream::ReaderState::Readable) { + aRv.ThrowTypeError("Not Readable"); + return; + } + + // Step 5. + ReadableByteStreamControllerEnqueue(aCx, this, chunk, aRv); +} + +// https://streams.spec.whatwg.org/#rbs-controller-error +void ReadableByteStreamController::Error(JSContext* aCx, + JS::Handle<JS::Value> aErrorValue, + ErrorResult& aRv) { + // Step 1. + ReadableByteStreamControllerError(this, aErrorValue, aRv); +} + +// https://streams.spec.whatwg.org/#rbs-controller-private-cancel +already_AddRefed<Promise> ReadableByteStreamController::CancelSteps( + JSContext* aCx, JS::Handle<JS::Value> aReason, ErrorResult& aRv) { + // Step 1. + ReadableByteStreamControllerClearPendingPullIntos(this); + + // Step 2. + ResetQueue(this); + + // Step 3. + Optional<JS::Handle<JS::Value>> reason(aCx, aReason); + RefPtr<UnderlyingSourceAlgorithmsBase> algorithms = mAlgorithms; + RefPtr<Promise> result = algorithms->CancelCallback(aCx, reason, aRv); + if (NS_WARN_IF(aRv.Failed())) { + return nullptr; + } + // Step 4. + ReadableByteStreamControllerClearAlgorithms(this); + + // Step 5. + return result.forget(); +} + +namespace streams_abstract { +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-handle-queue-drain +void ReadableByteStreamControllerHandleQueueDrain( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv) { + // Step 1. + MOZ_ASSERT(aController->Stream()->State() == + ReadableStream::ReaderState::Readable); + + // Step 2. + if (aController->QueueTotalSize() == 0 && aController->CloseRequested()) { + // Step 2.1 + ReadableByteStreamControllerClearAlgorithms(aController); + + // Step 2.2 + RefPtr<ReadableStream> stream = aController->Stream(); + ReadableStreamClose(aCx, stream, aRv); + return; + } + + // Step 3.1 + ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv); +} +} // namespace streams_abstract + +// https://streams.spec.whatwg.org/#rbs-controller-private-pull +void ReadableByteStreamController::PullSteps(JSContext* aCx, + ReadRequest* aReadRequest, + ErrorResult& aRv) { + // Step 1. + ReadableStream* stream = Stream(); + + // Step 2. + MOZ_ASSERT(ReadableStreamHasDefaultReader(stream)); + + // Step 3. + if (QueueTotalSize() > 0) { + // Step 3.1. Assert: ! ReadableStreamGetNumReadRequests ( stream ) is 0. + MOZ_ASSERT(ReadableStreamGetNumReadRequests(stream) == 0); + + // Step 3.2. Perform ! + // ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest). + ReadableByteStreamControllerFillReadRequestFromQueue(aCx, this, + aReadRequest, aRv); + + // Step 3.3. Return. + return; + } + + // Step 4. + Maybe<uint64_t> autoAllocateChunkSize = AutoAllocateChunkSize(); + + // Step 5. + if (autoAllocateChunkSize) { + // Step 5.1 + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> buffer( + aCx, JS::NewArrayBuffer(aCx, *autoAllocateChunkSize)); + // Step 5.2 + if (!buffer) { + // Step 5.2.1 + JS::Rooted<JS::Value> bufferError(aCx); + if (!JS_GetPendingException(aCx, &bufferError)) { + // Uncatchable exception; we should mark aRv and return. + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // It's not expliclitly stated, but I assume the intention here is that + // we perform a normal completion here. + JS_ClearPendingException(aCx); + + aReadRequest->ErrorSteps(aCx, bufferError, aRv); + + // Step 5.2.2. + return; + } + + // Step 5.3 + RefPtr<PullIntoDescriptor> pullIntoDescriptor = new PullIntoDescriptor( + buffer, *autoAllocateChunkSize, 0, *autoAllocateChunkSize, 0, 1, + PullIntoDescriptor::Constructor::Uint8, ReaderType::Default); + + // Step 5.4 + PendingPullIntos().insertBack(pullIntoDescriptor); + } + + // Step 6. + ReadableStreamAddReadRequest(stream, aReadRequest); + + // Step 7. + ReadableByteStreamControllerCallPullIfNeeded(aCx, this, aRv); +} + +// https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontroller-releasesteps +void ReadableByteStreamController::ReleaseSteps() { + // Step 1. If this.[[pendingPullIntos]] is not empty, + if (!PendingPullIntos().isEmpty()) { + // Step 1.1. Let firstPendingPullInto be this.[[pendingPullIntos]][0]. + RefPtr<PullIntoDescriptor> firstPendingPullInto = + PendingPullIntos().popFirst(); + + // Step 1.2. Set firstPendingPullInto’s reader type to "none". + firstPendingPullInto->SetReaderType(ReaderType::None); + + // Step 1.3. Set this.[[pendingPullIntos]] to the list « + // firstPendingPullInto ». + PendingPullIntos().clear(); + PendingPullIntos().insertBack(firstPendingPullInto); + } +} + +namespace streams_abstract { + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-shift-pending-pull-into +already_AddRefed<PullIntoDescriptor> +ReadableByteStreamControllerShiftPendingPullInto( + ReadableByteStreamController* aController) { + // Step 1. + MOZ_ASSERT(!aController->GetByobRequest()); + + // Step 2 + 3 + RefPtr<PullIntoDescriptor> descriptor = + aController->PendingPullIntos().popFirst(); + + // Step 4. + return descriptor.forget(); +} + +JSObject* ConstructFromPullIntoConstructor( + JSContext* aCx, PullIntoDescriptor::Constructor constructor, + JS::Handle<JSObject*> buffer, size_t byteOffset, size_t length) { + switch (constructor) { + case PullIntoDescriptor::Constructor::DataView: + return JS_NewDataView(aCx, buffer, byteOffset, length); + break; + +#define CONSTRUCT_TYPED_ARRAY_TYPE(ExternalT, NativeT, Name) \ + case PullIntoDescriptor::Constructor::Name: \ + return JS_New##Name##ArrayWithBuffer(aCx, buffer, byteOffset, \ + int64_t(length)); \ + break; + + JS_FOR_EACH_TYPED_ARRAY(CONSTRUCT_TYPED_ARRAY_TYPE) + +#undef CONSTRUCT_TYPED_ARRAY_TYPE + + default: + MOZ_ASSERT_UNREACHABLE("Unknown PullIntoDescriptor::Constructor"); + return nullptr; + } +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-convert-pull-into-descriptor +JSObject* ReadableByteStreamControllerConvertPullIntoDescriptor( + JSContext* aCx, PullIntoDescriptor* pullIntoDescriptor, ErrorResult& aRv) { + // Step 1. Let bytesFilled be pullIntoDescriptor’s bytes filled. + uint64_t bytesFilled = pullIntoDescriptor->BytesFilled(); + + // Step 2. Let elementSize be pullIntoDescriptor’s element size. + uint64_t elementSize = pullIntoDescriptor->ElementSize(); + + // Step 3. Assert: bytesFilled ≤ pullIntoDescriptor’s byte length. + MOZ_ASSERT(bytesFilled <= pullIntoDescriptor->ByteLength()); + + // Step 4. Assert: bytesFilled mod elementSize is 0. + MOZ_ASSERT(bytesFilled % elementSize == 0); + + // Step 5. Let buffer be ! TransferArrayBuffer(pullIntoDescriptor’s buffer). + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> srcBuffer(aCx, pullIntoDescriptor->Buffer()); + JS::Rooted<JSObject*> buffer(aCx, TransferArrayBuffer(aCx, srcBuffer)); + if (!buffer) { + aRv.StealExceptionFromJSContext(aCx); + return nullptr; + } + + // Step 6. Return ! Construct(pullIntoDescriptor’s view constructor, + // « buffer, pullIntoDescriptor’s byte offset, bytesFilled ÷ elementSize »). + JS::Rooted<JSObject*> res( + aCx, ConstructFromPullIntoConstructor( + aCx, pullIntoDescriptor->ViewConstructor(), buffer, + pullIntoDescriptor->ByteOffset(), bytesFilled / elementSize)); + if (!res) { + aRv.StealExceptionFromJSContext(aCx); + return nullptr; + } + return res; +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-respond-in-closed-state +MOZ_CAN_RUN_SCRIPT +static void ReadableByteStreamControllerRespondInClosedState( + JSContext* aCx, ReadableByteStreamController* aController, + RefPtr<PullIntoDescriptor>& aFirstDescriptor, ErrorResult& aRv) { + // Step 1. Assert: firstDescriptor ’s bytes filled is 0. + MOZ_ASSERT(aFirstDescriptor->BytesFilled() == 0); + + // Step 2. If firstDescriptor’s reader type is "none", + // perform ! ReadableByteStreamControllerShiftPendingPullInto(controller). + if (aFirstDescriptor->GetReaderType() == ReaderType::None) { + RefPtr<PullIntoDescriptor> discarded = + ReadableByteStreamControllerShiftPendingPullInto(aController); + (void)discarded; + } + + // Step 3. Let stream be controller.[[stream]]. + RefPtr<ReadableStream> stream = aController->Stream(); + + // Step 4. If ! ReadableStreamHasBYOBReader(stream) is true, + if (ReadableStreamHasBYOBReader(stream)) { + // Step 4.1. While ! ReadableStreamGetNumReadIntoRequests(stream) > 0, + while (ReadableStreamGetNumReadIntoRequests(stream) > 0) { + // Step 4.1.1. Let pullIntoDescriptor be ! + // ReadableByteStreamControllerShiftPendingPullInto(controller). + RefPtr<PullIntoDescriptor> pullIntoDescriptor = + ReadableByteStreamControllerShiftPendingPullInto(aController); + + // Step 4.1.2. Perform ! + // ReadableByteStreamControllerCommitPullIntoDescriptor(stream, + // pullIntoDescriptor). + ReadableByteStreamControllerCommitPullIntoDescriptor( + aCx, stream, pullIntoDescriptor, aRv); + } + } +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-fill-head-pull-into-descriptor +void ReadableByteStreamControllerFillHeadPullIntoDescriptor( + ReadableByteStreamController* aController, size_t aSize, + PullIntoDescriptor* aPullIntoDescriptor) { + // Step 1. Assert: either controller.[[pendingPullIntos]] is empty, or + // controller.[[pendingPullIntos]][0] is pullIntoDescriptor. + MOZ_ASSERT(aController->PendingPullIntos().isEmpty() || + aController->PendingPullIntos().getFirst() == aPullIntoDescriptor); + + // Step 2. Assert: controller.[[byobRequest]] is null. + MOZ_ASSERT(!aController->GetByobRequest()); + + // Step 3. Set pullIntoDescriptor’s bytes filled to bytes filled + size. + aPullIntoDescriptor->SetBytesFilled(aPullIntoDescriptor->BytesFilled() + + aSize); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-respond-in-readable-state +MOZ_CAN_RUN_SCRIPT +static void ReadableByteStreamControllerRespondInReadableState( + JSContext* aCx, ReadableByteStreamController* aController, + uint64_t aBytesWritten, PullIntoDescriptor* aPullIntoDescriptor, + ErrorResult& aRv) { + // Step 1. Assert: pullIntoDescriptor’s bytes filled + bytesWritten ≤ + // pullIntoDescriptor’s byte length. + MOZ_ASSERT(aPullIntoDescriptor->BytesFilled() + aBytesWritten <= + aPullIntoDescriptor->ByteLength()); + + // Step 2. Perform + // !ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, + // bytesWritten, pullIntoDescriptor). + ReadableByteStreamControllerFillHeadPullIntoDescriptor( + aController, aBytesWritten, aPullIntoDescriptor); + + // Step 3. If pullIntoDescriptor’s reader type is "none", + if (aPullIntoDescriptor->GetReaderType() == ReaderType::None) { + // Step 3.1. Perform ? + // ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, + // pullIntoDescriptor). + ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue( + aCx, aController, aPullIntoDescriptor, aRv); + if (aRv.Failed()) { + return; + } + + // Step 3.2. Perform ! + // ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller). + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue( + aCx, aController, aRv); + + // Step 3.3. Return. + return; + } + + // Step 4. If pullIntoDescriptor’s bytes filled < pullIntoDescriptor’s element + // size, return. + if (aPullIntoDescriptor->BytesFilled() < aPullIntoDescriptor->ElementSize()) { + return; + } + + // Step 5. Perform + // !ReadableByteStreamControllerShiftPendingPullInto(controller). + RefPtr<PullIntoDescriptor> pullIntoDescriptor = + ReadableByteStreamControllerShiftPendingPullInto(aController); + (void)pullIntoDescriptor; + + // Step 6. Let remainderSize be pullIntoDescriptor’s bytes filled mod + // pullIntoDescriptor’s element size. + size_t remainderSize = + aPullIntoDescriptor->BytesFilled() % aPullIntoDescriptor->ElementSize(); + + // Step 7. If remainderSize > 0, + if (remainderSize > 0) { + // Step 7.1. Let end be pullIntoDescriptor’s byte offset + + // pullIntoDescriptor’s bytes filled. + size_t end = + aPullIntoDescriptor->ByteOffset() + aPullIntoDescriptor->BytesFilled(); + + // Step 7.2. Perform ? + // ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, + // pullIntoDescriptor’s buffer, end − remainderSize, remainderSize). + JS::Rooted<JSObject*> pullIntoBuffer(aCx, aPullIntoDescriptor->Buffer()); + ReadableByteStreamControllerEnqueueClonedChunkToQueue( + aCx, aController, pullIntoBuffer, end - remainderSize, remainderSize, + aRv); + if (aRv.Failed()) { + return; + } + } + + // Step 8. Set pullIntoDescriptor’s bytes filled to pullIntoDescriptor’s bytes + // filled − remainderSize. + aPullIntoDescriptor->SetBytesFilled(aPullIntoDescriptor->BytesFilled() - + remainderSize); + + // Step 9. Perform + // !ReadableByteStreamControllerCommitPullIntoDescriptor(controller.[[stream]], + // pullIntoDescriptor). + RefPtr<ReadableStream> stream(aController->Stream()); + ReadableByteStreamControllerCommitPullIntoDescriptor( + aCx, stream, aPullIntoDescriptor, aRv); + if (aRv.Failed()) { + return; + } + + // Step 10. Perform + // !ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller). + ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue( + aCx, aController, aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-respond-internal +void ReadableByteStreamControllerRespondInternal( + JSContext* aCx, ReadableByteStreamController* aController, + uint64_t aBytesWritten, ErrorResult& aRv) { + // Step 1. + RefPtr<PullIntoDescriptor> firstDescriptor = + aController->PendingPullIntos().getFirst(); + + // Step 2. + JS::Rooted<JSObject*> buffer(aCx, firstDescriptor->Buffer()); +#ifdef DEBUG + bool canTransferBuffer = CanTransferArrayBuffer(aCx, buffer, aRv); + MOZ_ASSERT(!aRv.Failed()); + MOZ_ASSERT(canTransferBuffer); +#endif + + // Step 3. + ReadableByteStreamControllerInvalidateBYOBRequest(aController); + + // Step 4. + auto state = aController->Stream()->State(); + + // Step 5. + if (state == ReadableStream::ReaderState::Closed) { + // Step 5.1 + MOZ_ASSERT(aBytesWritten == 0); + + // Step 5.2 + ReadableByteStreamControllerRespondInClosedState(aCx, aController, + firstDescriptor, aRv); + if (aRv.Failed()) { + return; + } + } else { + // Step 6.1 + MOZ_ASSERT(state == ReadableStream::ReaderState::Readable); + + // Step 6.2. + MOZ_ASSERT(aBytesWritten > 0); + + // Step 6.3 + ReadableByteStreamControllerRespondInReadableState( + aCx, aController, aBytesWritten, firstDescriptor, aRv); + if (aRv.Failed()) { + return; + } + } + // Step 7. + ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-respond +void ReadableByteStreamControllerRespond( + JSContext* aCx, ReadableByteStreamController* aController, + uint64_t aBytesWritten, ErrorResult& aRv) { + // Step 1. + MOZ_ASSERT(!aController->PendingPullIntos().isEmpty()); + + // Step 2. + PullIntoDescriptor* firstDescriptor = + aController->PendingPullIntos().getFirst(); + + // Step 3. + auto state = aController->Stream()->State(); + + // Step 4. + if (state == ReadableStream::ReaderState::Closed) { + // Step 4.1 + if (aBytesWritten != 0) { + aRv.ThrowTypeError("bytesWritten not zero on closed stream"); + return; + } + } else { + // Step 5.1 + MOZ_ASSERT(state == ReadableStream::ReaderState::Readable); + + // Step 5.2 + if (aBytesWritten == 0) { + aRv.ThrowTypeError("bytesWritten 0"); + return; + } + + // Step 5.3 + if (firstDescriptor->BytesFilled() + aBytesWritten > + firstDescriptor->ByteLength()) { + aRv.ThrowRangeError("bytesFilled + bytesWritten > byteLength"); + return; + } + } + + // Step 6. + aRv.MightThrowJSException(); + JS::Rooted<JSObject*> buffer(aCx, firstDescriptor->Buffer()); + JS::Rooted<JSObject*> transferredBuffer(aCx, + TransferArrayBuffer(aCx, buffer)); + if (!transferredBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + firstDescriptor->SetBuffer(transferredBuffer); + + // Step 7. + ReadableByteStreamControllerRespondInternal(aCx, aController, aBytesWritten, + aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-respond-with-new-view +void ReadableByteStreamControllerRespondWithNewView( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aView, ErrorResult& aRv) { + aRv.MightThrowJSException(); + + // Step 1. + MOZ_ASSERT(!aController->PendingPullIntos().isEmpty()); + + // Step 2. + bool isSharedMemory; + JS::Rooted<JSObject*> viewedArrayBuffer( + aCx, JS_GetArrayBufferViewBuffer(aCx, aView, &isSharedMemory)); + if (!viewedArrayBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + MOZ_ASSERT(!JS::IsDetachedArrayBufferObject(viewedArrayBuffer)); + + // Step 3. + RefPtr<PullIntoDescriptor> firstDescriptor = + aController->PendingPullIntos().getFirst(); + + // Step 4. + ReadableStream::ReaderState state = aController->Stream()->State(); + + // Step 5. + if (state == ReadableStream::ReaderState::Closed) { + // Step 5.1 + if (JS_GetArrayBufferViewByteLength(aView) != 0) { + aRv.ThrowTypeError("View has non-zero length in closed stream"); + return; + } + } else { + // Step 6.1 + MOZ_ASSERT(state == ReadableStream::ReaderState::Readable); + + // Step 6.2 + if (JS_GetArrayBufferViewByteLength(aView) == 0) { + aRv.ThrowTypeError("View has zero length in readable stream"); + return; + } + } + + // Step 7. + if (firstDescriptor->ByteOffset() + firstDescriptor->BytesFilled() != + JS_GetArrayBufferViewByteOffset(aView)) { + aRv.ThrowRangeError("Invalid Offset"); + return; + } + + // Step 8. + if (firstDescriptor->BufferByteLength() != + JS::GetArrayBufferByteLength(viewedArrayBuffer)) { + aRv.ThrowRangeError("Mismatched buffer byte lengths"); + return; + } + + // Step 9. + if (firstDescriptor->BytesFilled() + JS_GetArrayBufferViewByteLength(aView) > + firstDescriptor->ByteLength()) { + aRv.ThrowRangeError("Too many bytes"); + return; + } + + // Step 10. Let viewByteLength be view.[[ByteLength]]. + size_t viewByteLength = JS_GetArrayBufferViewByteLength(aView); + + // Step 11. Set firstDescriptor’s buffer to ? + // TransferArrayBuffer(view.[[ViewedArrayBuffer]]). + JS::Rooted<JSObject*> transferedBuffer( + aCx, TransferArrayBuffer(aCx, viewedArrayBuffer)); + if (!transferedBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + firstDescriptor->SetBuffer(transferedBuffer); + + // Step 12. Perform ? ReadableByteStreamControllerRespondInternal(controller, + // viewByteLength). + ReadableByteStreamControllerRespondInternal(aCx, aController, viewByteLength, + aRv); +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-fill-pull-into-descriptor-from-queue +bool ReadableByteStreamControllerFillPullIntoDescriptorFromQueue( + JSContext* aCx, ReadableByteStreamController* aController, + PullIntoDescriptor* aPullIntoDescriptor, ErrorResult& aRv) { + // Step 1. Let elementSize be pullIntoDescriptor.[[elementSize]]. + size_t elementSize = aPullIntoDescriptor->ElementSize(); + + // Step 2. Let currentAlignedBytes be pullIntoDescriptor’s bytes filled − + // (pullIntoDescriptor’s bytes filled mod elementSize). + size_t currentAlignedBytes = + aPullIntoDescriptor->BytesFilled() - + (aPullIntoDescriptor->BytesFilled() % elementSize); + + // Step 3. Let maxBytesToCopy be min(controller.[[queueTotalSize]], + // pullIntoDescriptor’s byte length − pullIntoDescriptor’s bytes filled). + size_t maxBytesToCopy = + std::min(static_cast<size_t>(aController->QueueTotalSize()), + static_cast<size_t>((aPullIntoDescriptor->ByteLength() - + aPullIntoDescriptor->BytesFilled()))); + + // Step 4. Let maxBytesFilled be pullIntoDescriptor’s bytes filled + + // maxBytesToCopy. + size_t maxBytesFilled = aPullIntoDescriptor->BytesFilled() + maxBytesToCopy; + + // Step 5. Let maxAlignedBytes be maxBytesFilled − (maxBytesFilled mod + // elementSize). + size_t maxAlignedBytes = maxBytesFilled - (maxBytesFilled % elementSize); + + // Step 6. Let totalBytesToCopyRemaining be maxBytesToCopy. + size_t totalBytesToCopyRemaining = maxBytesToCopy; + + // Step 7. Let ready be false. + bool ready = false; + + // Step 8. If maxAlignedBytes > currentAlignedBytes, + if (maxAlignedBytes > currentAlignedBytes) { + // Step 8.1. Set totalBytesToCopyRemaining to maxAlignedBytes − + // pullIntoDescriptor’s bytes filled. + totalBytesToCopyRemaining = + maxAlignedBytes - aPullIntoDescriptor->BytesFilled(); + // Step 8.2. Set ready to true. + ready = true; + } + + // Step 9. Let queue be controller.[[queue]]. + LinkedList<RefPtr<ReadableByteStreamQueueEntry>>& queue = + aController->Queue(); + + // Step 10. While totalBytesToCopyRemaining > 0, + while (totalBytesToCopyRemaining > 0) { + // Step 10.1 Let headOfQueue be queue[0]. + ReadableByteStreamQueueEntry* headOfQueue = queue.getFirst(); + + // Step 10.2. Let bytesToCopy be min(totalBytesToCopyRemaining, + // headOfQueue’s byte length). + size_t bytesToCopy = + std::min(totalBytesToCopyRemaining, headOfQueue->ByteLength()); + + // Step 10.3. Let destStart be pullIntoDescriptor’s byte offset + + // pullIntoDescriptor’s bytes filled. + size_t destStart = + aPullIntoDescriptor->ByteOffset() + aPullIntoDescriptor->BytesFilled(); + + // Step 10.4. Perform !CopyDataBlockBytes(pullIntoDescriptor’s + // buffer.[[ArrayBufferData]], destStart, headOfQueue’s + // buffer.[[ArrayBufferData]], headOfQueue’s byte offset, + // bytesToCopy). + JS::Rooted<JSObject*> descriptorBuffer(aCx, aPullIntoDescriptor->Buffer()); + JS::Rooted<JSObject*> queueBuffer(aCx, headOfQueue->Buffer()); + if (!JS::ArrayBufferCopyData(aCx, descriptorBuffer, destStart, queueBuffer, + headOfQueue->ByteOffset(), bytesToCopy)) { + aRv.StealExceptionFromJSContext(aCx); + return false; + } + + // Step 10.5. If headOfQueue’s byte length is bytesToCopy, + if (headOfQueue->ByteLength() == bytesToCopy) { + // Step 10.5.1. Remove queue[0]. + queue.popFirst(); + } else { + // Step 10.6. Otherwise, + + // Step 10.6.1 Set headOfQueue’s byte offset to + // headOfQueue’s byte offset + bytesToCopy. + headOfQueue->SetByteOffset(headOfQueue->ByteOffset() + bytesToCopy); + // Step 10.6.2 Set headOfQueue’s byte length to + // headOfQueue’s byte length − bytesToCopy. + headOfQueue->SetByteLength(headOfQueue->ByteLength() - bytesToCopy); + } + + // Step 10.7. Set controller.[[queueTotalSize]] to + // controller.[[queueTotalSize]] − bytesToCopy. + aController->SetQueueTotalSize(aController->QueueTotalSize() - + (double)bytesToCopy); + + // Step 10.8, Perform + // !ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, + // bytesToCopy, pullIntoDescriptor). + ReadableByteStreamControllerFillHeadPullIntoDescriptor( + aController, bytesToCopy, aPullIntoDescriptor); + + // Step 10.9. Set totalBytesToCopyRemaining to totalBytesToCopyRemaining − + // bytesToCopy. + totalBytesToCopyRemaining = totalBytesToCopyRemaining - bytesToCopy; + } + + // Step 11. If ready is false, + if (!ready) { + // Step 11.1. Assert: controller.[[queueTotalSize]] is 0. + MOZ_ASSERT(aController->QueueTotalSize() == 0); + + // Step 11.2. Assert: pullIntoDescriptor’s bytes filled > 0. + MOZ_ASSERT(aPullIntoDescriptor->BytesFilled() > 0); + + // Step 11.3. Assert: pullIntoDescriptor’s bytes filled < + // pullIntoDescriptor’s + // element size. + MOZ_ASSERT(aPullIntoDescriptor->BytesFilled() < + aPullIntoDescriptor->ElementSize()); + } + + // Step 12. Return ready. + return ready; +} + +// https://streams.spec.whatwg.org/#readable-byte-stream-controller-pull-into +void ReadableByteStreamControllerPullInto( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aView, ReadIntoRequest* aReadIntoRequest, + ErrorResult& aRv) { + aRv.MightThrowJSException(); + + // Step 1. Let stream be controller.[[stream]]. + ReadableStream* stream = aController->Stream(); + + // Step 2. Let elementSize be 1. + size_t elementSize = 1; + + // Step 3. Let ctor be %DataView%. + PullIntoDescriptor::Constructor ctor = + PullIntoDescriptor::Constructor::DataView; + + // Step 4. If view has a [[TypedArrayName]] internal slot (i.e., it is not a + // DataView), + if (JS_IsTypedArrayObject(aView)) { + // Step 4.1. Set elementSize to the element size specified in the typed + // array constructors table for view.[[TypedArrayName]]. + JS::Scalar::Type type = JS_GetArrayBufferViewType(aView); + elementSize = JS::Scalar::byteSize(type); + + // Step 4.2 Set ctor to the constructor specified in the typed array + // constructors table for view.[[TypedArrayName]]. + ctor = PullIntoDescriptor::constructorFromScalar(type); + } + + // Step 5. Let byteOffset be view.[[ByteOffset]]. + size_t byteOffset = JS_GetArrayBufferViewByteOffset(aView); + + // Step 6. Let byteLength be view.[[ByteLength]]. + size_t byteLength = JS_GetArrayBufferViewByteLength(aView); + + // Step 7. Let bufferResult be + // TransferArrayBuffer(view.[[ViewedArrayBuffer]]). + bool isShared; + JS::Rooted<JSObject*> viewedArrayBuffer( + aCx, JS_GetArrayBufferViewBuffer(aCx, aView, &isShared)); + if (!viewedArrayBuffer) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + JS::Rooted<JSObject*> bufferResult( + aCx, TransferArrayBuffer(aCx, viewedArrayBuffer)); + + // Step 8. If bufferResult is an abrupt completion, + if (!bufferResult) { + JS::Rooted<JS::Value> pendingException(aCx); + if (!JS_GetPendingException(aCx, &pendingException)) { + // This means an un-catchable exception. Use StealExceptionFromJSContext + // to setup aRv properly. + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // It's not expliclitly stated, but I assume the intention here is that + // we perform a normal completion here; we also need to clear the + // exception state anyhow to succesfully run ErrorSteps. + JS_ClearPendingException(aCx); + + // Step 8.1. Perform readIntoRequest’s error steps, given + // bufferResult.[[Value]]. + aReadIntoRequest->ErrorSteps(aCx, pendingException, aRv); + + // Step 8.2. Return. + return; + } + + // Step 9. Let buffer be bufferResult.[[Value]]. + JS::Rooted<JSObject*> buffer(aCx, bufferResult); + + // Step 10. Let pullIntoDescriptor be a new pull-into descriptor with + // buffer: buffer, + // buffer byte length: buffer.[[ArrayBufferByteLength]], + // byte offset: byteOffset, + // byte length: byteLength, + // bytes filled: 0, + // element size: elementSize, + // view constructor: ctor, + // and reader type: "byob". + RefPtr<PullIntoDescriptor> pullIntoDescriptor = new PullIntoDescriptor( + buffer, JS::GetArrayBufferByteLength(buffer), byteOffset, byteLength, 0, + elementSize, ctor, ReaderType::BYOB); + + // Step 11. If controller.[[pendingPullIntos]] is not empty, + if (!aController->PendingPullIntos().isEmpty()) { + // Step 11.1. Append pullIntoDescriptor to controller.[[pendingPullIntos]]. + aController->PendingPullIntos().insertBack(pullIntoDescriptor); + + // Step 11.2. Perform !ReadableStreamAddReadIntoRequest(stream, + // readIntoRequest). + ReadableStreamAddReadIntoRequest(stream, aReadIntoRequest); + + // Step 11.3. Return. + return; + } + + // Step 12. If stream.[[state]] is "closed", + if (stream->State() == ReadableStream::ReaderState::Closed) { + // Step 12.1. Let emptyView be !Construct(ctor, « pullIntoDescriptor’s + // buffer, pullIntoDescriptor’s byte offset, 0 »). + JS::Rooted<JSObject*> pullIntoBuffer(aCx, pullIntoDescriptor->Buffer()); + JS::Rooted<JSObject*> emptyView( + aCx, + ConstructFromPullIntoConstructor(aCx, ctor, pullIntoBuffer, + pullIntoDescriptor->ByteOffset(), 0)); + if (!emptyView) { + aRv.StealExceptionFromJSContext(aCx); + return; + } + + // Step 12.2. Perform readIntoRequest’s close steps, given emptyView. + JS::Rooted<JS::Value> emptyViewValue(aCx, JS::ObjectValue(*emptyView)); + aReadIntoRequest->CloseSteps(aCx, emptyViewValue, aRv); + + // Step 12.3. Return. + return; + } + + // Step 13,. If controller.[[queueTotalSize]] > 0, + if (aController->QueueTotalSize() > 0) { + // Step 13.1 If + // !ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, + // pullIntoDescriptor) is true, + bool ready = ReadableByteStreamControllerFillPullIntoDescriptorFromQueue( + aCx, aController, pullIntoDescriptor, aRv); + if (aRv.Failed()) { + return; + } + if (ready) { + // Step 13.1.1 Let filledView be + // !ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor). + JS::Rooted<JSObject*> filledView( + aCx, ReadableByteStreamControllerConvertPullIntoDescriptor( + aCx, pullIntoDescriptor, aRv)); + if (aRv.Failed()) { + return; + } + // Step 13.1.2. Perform + // !ReadableByteStreamControllerHandleQueueDrain(controller). + ReadableByteStreamControllerHandleQueueDrain(aCx, aController, aRv); + if (aRv.Failed()) { + return; + } + // Step 13.1.3. Perform readIntoRequest’s chunk steps, given filledView. + JS::Rooted<JS::Value> filledViewValue(aCx, JS::ObjectValue(*filledView)); + aReadIntoRequest->ChunkSteps(aCx, filledViewValue, aRv); + // Step 13.1.4. Return. + return; + } + + // Step 13.2 If controller.[[closeRequested]] is true, + if (aController->CloseRequested()) { + // Step 13.2.1. Let e be a TypeError exception. + ErrorResult typeError; + typeError.ThrowTypeError("Close Requested True during Pull Into"); + + JS::Rooted<JS::Value> e(aCx); + MOZ_RELEASE_ASSERT(ToJSValue(aCx, std::move(typeError), &e)); + + // Step 13.2.2. Perform !ReadableByteStreamControllerError(controller, e). + ReadableByteStreamControllerError(aController, e, aRv); + if (aRv.Failed()) { + return; + } + + // Step 13.2.3. Perform readIntoRequest’s error steps, given e. + aReadIntoRequest->ErrorSteps(aCx, e, aRv); + + // Step 13.2.4. Return. + return; + } + } + + // Step 14. Append pullIntoDescriptor to controller.[[pendingPullIntos]]. + aController->PendingPullIntos().insertBack(pullIntoDescriptor); + + // Step 15. Perform !ReadableStreamAddReadIntoRequest(stream, + // readIntoRequest). + ReadableStreamAddReadIntoRequest(stream, aReadIntoRequest); + + // Step 16, Perform + // !ReadableByteStreamControllerCallPullIfNeeded(controller). + ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv); +} + +// https://streams.spec.whatwg.org/#set-up-readable-byte-stream-controller +void SetUpReadableByteStreamController( + JSContext* aCx, ReadableStream* aStream, + ReadableByteStreamController* aController, + UnderlyingSourceAlgorithmsBase* aAlgorithms, double aHighWaterMark, + Maybe<uint64_t> aAutoAllocateChunkSize, ErrorResult& aRv) { + // Step 1. Assert: stream.[[controller]] is undefined. + MOZ_ASSERT(!aStream->Controller()); + + // Step 2. If autoAllocateChunkSize is not undefined, + // Step 2.1. Assert: ! IsInteger(autoAllocateChunkSize) is true. Implicit + // Step 2.2. Assert: autoAllocateChunkSize is positive. (Implicit by + // type.) + + // Step 3. Set controller.[[stream]] to stream. + aController->SetStream(aStream); + + // Step 4. Set controller.[[pullAgain]] and controller.[[pulling]] to false. + aController->SetPullAgain(false); + aController->SetPulling(false); + + // Step 5. Set controller.[[byobRequest]] to null. + aController->SetByobRequest(nullptr); + + // Step 6. Perform !ResetQueue(controller). + ResetQueue(aController); + + // Step 7. Set controller.[[closeRequested]] and controller.[[started]] to + // false. + aController->SetCloseRequested(false); + aController->SetStarted(false); + + // Step 8. Set controller.[[strategyHWM]] to highWaterMark. + aController->SetStrategyHWM(aHighWaterMark); + + // Step 9. Set controller.[[pullAlgorithm]] to pullAlgorithm. + // Step 10. Set controller.[[cancelAlgorithm]] to cancelAlgorithm. + aController->SetAlgorithms(*aAlgorithms); + + // Step 11. Set controller.[[autoAllocateChunkSize]] to autoAllocateChunkSize. + aController->SetAutoAllocateChunkSize(aAutoAllocateChunkSize); + + // Step 12. Set controller.[[pendingPullIntos]] to a new empty list. + aController->PendingPullIntos().clear(); + + // Step 13. Set stream.[[controller]] to controller. + aStream->SetController(*aController); + + // Step 14. Let startResult be the result of performing startAlgorithm. + JS::Rooted<JS::Value> startResult(aCx, JS::UndefinedValue()); + RefPtr<ReadableStreamController> controller = aController; + aAlgorithms->StartCallback(aCx, *controller, &startResult, aRv); + if (aRv.Failed()) { + return; + } + + // Let startPromise be a promise resolved with startResult. + RefPtr<Promise> startPromise = + Promise::CreateInfallible(aStream->GetParentObject()); + startPromise->MaybeResolve(startResult); + + // Step 16+17 + startPromise->AddCallbacksWithCycleCollectedArgs( + [](JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv, + ReadableByteStreamController* aController) + MOZ_CAN_RUN_SCRIPT_BOUNDARY { + MOZ_ASSERT(aController); + + // Step 16.1 + aController->SetStarted(true); + + // Step 16.2 + aController->SetPulling(false); + + // Step 16.3 + aController->SetPullAgain(false); + + // Step 16.4: + ReadableByteStreamControllerCallPullIfNeeded( + aCx, MOZ_KnownLive(aController), aRv); + }, + [](JSContext* aCx, JS::Handle<JS::Value> aValue, ErrorResult& aRv, + ReadableByteStreamController* aController) { + // Step 17.1 + ReadableByteStreamControllerError(aController, aValue, aRv); + }, + RefPtr(aController)); +} + +// https://streams.spec.whatwg.org/#set-up-readable-byte-stream-controller-from-underlying-source +void SetUpReadableByteStreamControllerFromUnderlyingSource( + JSContext* aCx, ReadableStream* aStream, + JS::Handle<JSObject*> aUnderlyingSource, + UnderlyingSource& aUnderlyingSourceDict, double aHighWaterMark, + ErrorResult& aRv) { + // Step 1. Let controller be a new ReadableByteStreamController. + auto controller = + MakeRefPtr<ReadableByteStreamController>(aStream->GetParentObject()); + + // Step 2 - 7 + auto algorithms = MakeRefPtr<UnderlyingSourceAlgorithms>( + aStream->GetParentObject(), aUnderlyingSource, aUnderlyingSourceDict); + + // Step 8. Let autoAllocateChunkSize be + // underlyingSourceDict["autoAllocateChunkSize"], if it exists, or undefined + // otherwise. + Maybe<uint64_t> autoAllocateChunkSize = mozilla::Nothing(); + if (aUnderlyingSourceDict.mAutoAllocateChunkSize.WasPassed()) { + uint64_t value = aUnderlyingSourceDict.mAutoAllocateChunkSize.Value(); + // Step 9. If autoAllocateChunkSize is 0, then throw a TypeError + // exception. + if (value == 0) { + aRv.ThrowTypeError("autoAllocateChunkSize can not be zero."); + return; + } + autoAllocateChunkSize = mozilla::Some(value); + } + + // Step 10. Perform ? SetUpReadableByteStreamController(stream, controller, + // startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, + // autoAllocateChunkSize). + SetUpReadableByteStreamController(aCx, aStream, controller, algorithms, + aHighWaterMark, autoAllocateChunkSize, aRv); +} + +} // namespace streams_abstract + +} // namespace mozilla::dom |