diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/streams/ReadableByteStreamController.h | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/dom/streams/ReadableByteStreamController.h b/dom/streams/ReadableByteStreamController.h new file mode 100644 index 0000000000..45e03ba3b4 --- /dev/null +++ b/dom/streams/ReadableByteStreamController.h @@ -0,0 +1,230 @@ +/* -*- 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/. */ + +#ifndef mozilla_dom_ReadableByteStreamController_h +#define mozilla_dom_ReadableByteStreamController_h + +#include <cstddef> +#include "UnderlyingSourceCallbackHelpers.h" +#include "js/RootingAPI.h" +#include "js/TypeDecls.h" +#include "mozilla/Attributes.h" +#include "mozilla/ErrorResult.h" +#include "mozilla/dom/BindingDeclarations.h" +#include "mozilla/dom/QueuingStrategyBinding.h" +#include "mozilla/dom/QueueWithSizes.h" +#include "mozilla/dom/ReadableStream.h" +#include "mozilla/dom/ReadRequest.h" +#include "mozilla/dom/ReadableStreamBYOBRequest.h" +#include "mozilla/dom/ReadableStreamController.h" +#include "mozilla/dom/TypedArray.h" +#include "nsCycleCollectionParticipant.h" +#include "nsWrapperCache.h" +#include "mozilla/dom/Nullable.h" +#include "nsTArray.h" +#include "nsISupportsImpl.h" + +namespace mozilla::dom { + +// https://streams.spec.whatwg.org/#pull-into-descriptor-reader-type +// Indicates what type of readable stream reader initiated this request, +// or None if the initiating reader was released. +enum ReaderType { Default, BYOB, None }; + +struct PullIntoDescriptor; +struct ReadableByteStreamQueueEntry; +struct ReadIntoRequest; + +class ReadableByteStreamController final : public ReadableStreamController, + public nsWrapperCache { + public: + NS_DECL_ISUPPORTS_INHERITED + NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_INHERITED( + ReadableByteStreamController, ReadableStreamController) + + public: + explicit ReadableByteStreamController(nsIGlobalObject* aGlobal); + + protected: + ~ReadableByteStreamController() override; + + public: + bool IsDefault() override { return false; } + bool IsByte() override { return true; } + ReadableStreamDefaultController* AsDefault() override { return nullptr; } + ReadableByteStreamController* AsByte() override { return this; } + + JSObject* WrapObject(JSContext* aCx, + JS::Handle<JSObject*> aGivenProto) override; + + already_AddRefed<ReadableStreamBYOBRequest> GetByobRequest(JSContext* aCx, + ErrorResult& aRv); + + Nullable<double> GetDesiredSize() const; + + MOZ_CAN_RUN_SCRIPT void Close(JSContext* aCx, ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT void Enqueue(JSContext* aCx, const ArrayBufferView& aChunk, + ErrorResult& aRv); + + void Error(JSContext* aCx, JS::Handle<JS::Value> aErrorValue, + ErrorResult& aRv); + + MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> CancelSteps( + JSContext* aCx, JS::Handle<JS::Value> aReason, ErrorResult& aRv) override; + MOZ_CAN_RUN_SCRIPT void PullSteps(JSContext* aCx, ReadRequest* aReadRequest, + ErrorResult& aRv) override; + void ReleaseSteps() override; + + // Internal Slot Accessors + Maybe<uint64_t> AutoAllocateChunkSize() { return mAutoAllocateChunkSize; } + void SetAutoAllocateChunkSize(Maybe<uint64_t>& aSize) { + mAutoAllocateChunkSize = aSize; + } + + ReadableStreamBYOBRequest* GetByobRequest() const { return mByobRequest; } + void SetByobRequest(ReadableStreamBYOBRequest* aByobRequest) { + mByobRequest = aByobRequest; + } + + LinkedList<RefPtr<PullIntoDescriptor>>& PendingPullIntos() { + return mPendingPullIntos; + } + void ClearPendingPullIntos(); + + double QueueTotalSize() const { return mQueueTotalSize; } + void SetQueueTotalSize(double aQueueTotalSize) { + mQueueTotalSize = aQueueTotalSize; + } + void AddToQueueTotalSize(double aLength) { mQueueTotalSize += aLength; } + + double StrategyHWM() const { return mStrategyHWM; } + void SetStrategyHWM(double aStrategyHWM) { mStrategyHWM = aStrategyHWM; } + + bool CloseRequested() const { return mCloseRequested; } + void SetCloseRequested(bool aCloseRequested) { + mCloseRequested = aCloseRequested; + } + + LinkedList<RefPtr<ReadableByteStreamQueueEntry>>& Queue() { return mQueue; } + void ClearQueue(); + + bool Started() const { return mStarted; } + void SetStarted(bool aStarted) { mStarted = aStarted; } + + bool Pulling() const { return mPulling; } + void SetPulling(bool aPulling) { mPulling = aPulling; } + + bool PullAgain() const { return mPullAgain; } + void SetPullAgain(bool aPullAgain) { mPullAgain = aPullAgain; } + + private: + // A boolean flag indicating whether the stream has been closed by its + // underlying byte source, but still has chunks in its internal queue that + // have not yet been read + bool mCloseRequested = false; + + // A boolean flag set to true if the stream’s mechanisms requested a call + // to the underlying byte source's pull algorithm to pull more data, but the + // pull could not yet be done since a previous call is still executing + bool mPullAgain = false; + + // A boolean flag indicating whether the underlying byte source has finished + // starting + bool mStarted = false; + + // A boolean flag set to true while the underlying byte source's pull + // algorithm is executing and the returned promise has not yet fulfilled, + // used to prevent reentrant calls + bool mPulling = false; + + // A positive integer, when the automatic buffer allocation feature is + // enabled. In that case, this value specifies the size of buffer to allocate. + // It is undefined otherwise. + Maybe<uint64_t> mAutoAllocateChunkSize; + + // A ReadableStreamBYOBRequest instance representing the current BYOB pull + // request, or null if there are no pending requests + RefPtr<ReadableStreamBYOBRequest> mByobRequest; + + // A list of pull-into descriptors + LinkedList<RefPtr<PullIntoDescriptor>> mPendingPullIntos; + + // A list of readable byte stream queue entries representing the stream’s + // internal queue of chunks + // + // This is theoretically supposed to be a QueueWithSizes, but it is + // mostly not actually manipulated or used like QueueWithSizes, so instead we + // use a LinkedList. + LinkedList<RefPtr<ReadableByteStreamQueueEntry>> mQueue; + + // The total size, in bytes, of all the chunks stored in [[queue]] (see § 8.1 + // Queue-with-sizes) + double mQueueTotalSize = 0.0; + + // A number supplied to the constructor as part of the stream’s queuing + // strategy, indicating the point at which the stream will apply backpressure + // to its underlying byte source + double mStrategyHWM = 0.0; +}; + +namespace streams_abstract { + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespond( + JSContext* aCx, ReadableByteStreamController* aController, + uint64_t aBytesWritten, ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespondInternal( + JSContext* aCx, ReadableByteStreamController* aController, + uint64_t aBytesWritten, ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespondWithNewView( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aView, ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerPullInto( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aView, ReadIntoRequest* aReadIntoRequest, + ErrorResult& aRv); + +void ReadableByteStreamControllerError( + ReadableByteStreamController* aController, JS::Handle<JS::Value> aValue, + ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerEnqueue( + JSContext* aCx, ReadableByteStreamController* aController, + JS::Handle<JSObject*> aChunk, ErrorResult& aRv); + +already_AddRefed<ReadableStreamBYOBRequest> +ReadableByteStreamControllerGetBYOBRequest( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerClose( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void SetUpReadableByteStreamController( + JSContext* aCx, ReadableStream* aStream, + ReadableByteStreamController* aController, + UnderlyingSourceAlgorithmsBase* aAlgorithms, double aHighWaterMark, + Maybe<uint64_t> aAutoAllocateChunkSize, ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerCallPullIfNeeded( + JSContext* aCx, ReadableByteStreamController* aController, + ErrorResult& aRv); + +MOZ_CAN_RUN_SCRIPT void SetUpReadableByteStreamControllerFromUnderlyingSource( + JSContext* aCx, ReadableStream* aStream, + JS::Handle<JSObject*> aUnderlyingSource, + UnderlyingSource& aUnderlyingSourceDict, double aHighWaterMark, + ErrorResult& aRv); + +} // namespace streams_abstract + +} // namespace mozilla::dom + +#endif |