summaryrefslogtreecommitdiffstats
path: root/dom/streams/ReadableByteStreamController.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/streams/ReadableByteStreamController.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/streams/ReadableByteStreamController.h')
-rw-r--r--dom/streams/ReadableByteStreamController.h230
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