Bug 1809408 - Part 1: Move ReadableStream internal algorithms to internal namespace r=mgaudet

Differential Revision: https://phabricator.services.mozilla.com/D167782

dom/base/StructuredCloneHolder.cpp

@@ -1583,7 +1583,7 @@ bool StructuredCloneHolder::CustomCanTransferHandler(
       // https://streams.spec.whatwg.org/#ref-for-transfer-steps
       // Step 1: If ! IsReadableStreamLocked(value) is true, throw a
       // "DataCloneError" DOMException.
-      return !IsReadableStreamLocked(stream);
+      return !stream->Locked();
     }
   }
 
@@ -1605,7 +1605,7 @@ bool StructuredCloneHolder::CustomCanTransferHandler(
       // https://streams.spec.whatwg.org/#ref-for-transfer-steps②
       // Step 3 + 4: If ! Is{Readable,Writable}StreamLocked(value) is true,
       // throw a "DataCloneError" DOMException.
-      return !IsReadableStreamLocked(stream->Readable()) &&
+      return !stream->Readable()->Locked() &&
              !IsWritableStreamLocked(stream->Writable());
     }
   }

dom/streams/ReadableByteStreamController.cpp

@@ -41,6 +41,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION_CLASS(ReadableByteStreamController)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(ReadableByteStreamController,
                                                 ReadableStreamController)
@@ -106,6 +108,7 @@ void ReadableByteStreamController::ClearPendingPullIntos() {
   mPendingPullIntos.clear();
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamcontrollergetbyobrequest
 already_AddRefed<ReadableStreamBYOBRequest>
 ReadableByteStreamControllerGetBYOBRequest(
@@ -150,6 +153,7 @@ ReadableByteStreamControllerGetBYOBRequest(
   RefPtr<ReadableStreamBYOBRequest> request(aController->GetByobRequest());
   return request.forget();
 }
+}  // namespace streams_abstract
 
 already_AddRefed<ReadableStreamBYOBRequest>
 ReadableByteStreamController::GetByobRequest(JSContext* aCx, ErrorResult& aRv) {
@@ -186,6 +190,8 @@ JSObject* ReadableByteStreamController::WrapObject(
   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) {
@@ -316,6 +322,8 @@ void ReadableByteStreamControllerClose(
   ReadableStreamClose(aCx, stream, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rbs-controller-close
 void ReadableByteStreamController::Close(JSContext* aCx, ErrorResult& aRv) {
   // Step 1.
@@ -334,6 +342,8 @@ void ReadableByteStreamController::Close(JSContext* aCx, ErrorResult& aRv) {
   ReadableByteStreamControllerClose(aCx, this, aRv);
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-byte-stream-controller-enqueue-chunk-to-queue
 void ReadableByteStreamControllerEnqueueChunkToQueue(
     ReadableByteStreamController* aController,
@@ -928,6 +938,8 @@ void ReadableByteStreamControllerEnqueue(
   ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rbs-controller-enqueue
 void ReadableByteStreamController::Enqueue(JSContext* aCx,
                                            const ArrayBufferView& aChunk,
@@ -1000,6 +1012,7 @@ already_AddRefed<Promise> ReadableByteStreamController::CancelSteps(
   return result.forget();
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#readable-byte-stream-controller-handle-queue-drain
 void ReadableByteStreamControllerHandleQueueDrain(
     JSContext* aCx, ReadableByteStreamController* aController,
@@ -1022,6 +1035,7 @@ void ReadableByteStreamControllerHandleQueueDrain(
   // Step 3.1
   ReadableByteStreamControllerCallPullIfNeeded(aCx, aController, aRv);
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#rbs-controller-private-pull
 void ReadableByteStreamController::PullSteps(JSContext* aCx,
@@ -1110,6 +1124,8 @@ void ReadableByteStreamController::ReleaseSteps() {
   }
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-byte-stream-controller-shift-pending-pull-into
 already_AddRefed<PullIntoDescriptor>
 ReadableByteStreamControllerShiftPendingPullInto(
@@ -1963,4 +1979,6 @@ void SetUpReadableByteStreamControllerFromUnderlyingSource(
                                     aHighWaterMark, autoAllocateChunkSize, aRv);
 }
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom

dom/streams/ReadableByteStreamController.h

@@ -309,6 +309,8 @@ struct PullIntoDescriptor final
   ~PullIntoDescriptor() = default;
 };
 
+namespace streams_abstract {
+
 MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespond(
     JSContext* aCx, ReadableByteStreamController* aController,
     uint64_t aBytesWritten, ErrorResult& aRv);
@@ -359,6 +361,8 @@ MOZ_CAN_RUN_SCRIPT void SetUpReadableByteStreamControllerFromUnderlyingSource(
     UnderlyingSource& aUnderlyingSourceDict, double aHighWaterMark,
     ErrorResult& aRv);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif

dom/streams/ReadableStream.cpp

@@ -106,6 +106,8 @@ void ReadableStream::SetReader(ReadableStreamGenericReader* aReader) {
   mReader = aReader;
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-has-byob-reader
 bool ReadableStreamHasBYOBReader(ReadableStream* aStream) {
   // Step 1. Let reader be stream.[[reader]].
@@ -136,6 +138,8 @@ bool ReadableStreamHasDefaultReader(ReadableStream* aStream) {
   return reader->IsDefault();
 }
 
+}  // namespace streams_abstract
+
 // Streams Spec: 4.2.4: https://streams.spec.whatwg.org/#rs-prototype
 /* static */
 already_AddRefed<ReadableStream> ReadableStream::Constructor(
@@ -229,6 +233,8 @@ bool ReadableStream::Locked() const {
   return mReader;
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#initialize-readable-stream
 static void InitializeReadableStream(ReadableStream* aStream) {
   // Step 1.
@@ -405,6 +411,8 @@ already_AddRefed<Promise> ReadableStreamCancel(JSContext* aCx,
   return returnResult.unwrap().forget();
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rs-cancel
 already_AddRefed<Promise> ReadableStream::Cancel(JSContext* aCx,
                                                  JS::Handle<JS::Value> aReason,
@@ -421,6 +429,7 @@ already_AddRefed<Promise> ReadableStream::Cancel(JSContext* aCx,
   return ReadableStreamCancel(aCx, thisRefPtr, aReason, aRv);
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#acquire-readable-stream-reader
 already_AddRefed<ReadableStreamDefaultReader>
 AcquireReadableStreamDefaultReader(ReadableStream* aStream, ErrorResult& aRv) {
@@ -437,6 +446,7 @@ AcquireReadableStreamDefaultReader(ReadableStream* aStream, ErrorResult& aRv) {
   // Step 3.
   return reader.forget();
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#rs-get-reader
 void ReadableStream::GetReader(const ReadableStreamGetReaderOptions& aOptions,
@@ -466,11 +476,13 @@ void ReadableStream::GetReader(const ReadableStreamGetReaderOptions& aOptions,
   resultReader.SetAsReadableStreamBYOBReader() = byobReader;
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#is-readable-stream-locked
 bool IsReadableStreamLocked(ReadableStream* aStream) {
   // Step 1 + 2.
   return aStream->Locked();
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#rs-pipe-through
 MOZ_CAN_RUN_SCRIPT already_AddRefed<ReadableStream> ReadableStream::PipeThrough(
@@ -513,6 +525,8 @@ MOZ_CAN_RUN_SCRIPT already_AddRefed<ReadableStream> ReadableStream::PipeThrough(
   return do_AddRef(aTransform.mReadable.get());
 };
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-get-num-read-requests
 double ReadableStreamGetNumReadRequests(ReadableStream* aStream) {
   // Step 1.
@@ -612,6 +626,8 @@ void ReadableStreamAddReadRequest(ReadableStream* aStream,
   aStream->GetDefaultReader()->ReadRequests().insertBack(aReadRequest);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaulttee
 // Step 14, 15
 MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise>
@@ -953,6 +969,8 @@ already_AddRefed<Promise> ReadableStream::IteratorReturn(
   return Promise::CreateResolvedWithUndefined(GetParentObject(), aRv);
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-add-read-into-request
 void ReadableStreamAddReadIntoRequest(ReadableStream* aStream,
                                       ReadIntoRequest* aReadIntoRequest) {
@@ -994,6 +1012,8 @@ already_AddRefed<ReadableStream> CreateReadableByteStream(
   return stream.forget();
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#readablestream-set-up
 // (except this instead creates a new ReadableStream rather than accepting an
 // existing instance)

dom/streams/ReadableStream.h

@@ -206,6 +206,8 @@ class ReadableStream : public nsISupports, public nsWrapperCache {
   JS::Heap<JS::Value> mStoredError;
 };
 
+namespace streams_abstract {
+
 bool IsReadableStreamLocked(ReadableStream* aStream);
 
 double ReadableStreamGetNumReadRequests(ReadableStream* aStream);
@@ -246,6 +248,8 @@ MOZ_CAN_RUN_SCRIPT already_AddRefed<ReadableStream> CreateReadableByteStream(
     JSContext* aCx, nsIGlobalObject* aGlobal,
     UnderlyingSourceAlgorithmsBase* aAlgorithms, ErrorResult& aRv);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif  // mozilla_dom_ReadableStream_h

dom/streams/ReadableStreamBYOBReader.cpp

@@ -23,6 +23,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_INHERITED(ReadableStreamBYOBReader,
                                                 ReadableStreamGenericReader,
                                                 mReadIntoRequests)
@@ -168,6 +170,7 @@ NS_IMPL_RELEASE_INHERITED(Read_ReadIntoRequest, ReadIntoRequest)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Read_ReadIntoRequest)
 NS_INTERFACE_MAP_END_INHERITING(ReadIntoRequest)
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#readable-stream-byob-reader-read
 void ReadableStreamBYOBReaderRead(JSContext* aCx,
                                   ReadableStreamBYOBReader* aReader,
@@ -201,6 +204,7 @@ void ReadableStreamBYOBReaderRead(JSContext* aCx,
   ReadableByteStreamControllerPullInto(aCx, controller, aView, aReadIntoRequest,
                                        aRv);
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#byob-reader-read
 already_AddRefed<Promise> ReadableStreamBYOBReader::Read(
@@ -269,6 +273,8 @@ already_AddRefed<Promise> ReadableStreamBYOBReader::Read(
   return promise.forget();
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#abstract-opdef-readablestreambyobreadererrorreadintorequests
 void ReadableStreamBYOBReaderErrorReadIntoRequests(
     JSContext* aCx, ReadableStreamBYOBReader* aReader,
@@ -312,6 +318,8 @@ void ReadableStreamBYOBReaderRelease(JSContext* aCx,
   ReadableStreamBYOBReaderErrorReadIntoRequests(aCx, aReader, error, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#byob-reader-release-lock
 void ReadableStreamBYOBReader::ReleaseLock(ErrorResult& aRv) {
   // Step 1. If this.[[stream]] is undefined, return.
@@ -330,6 +338,7 @@ void ReadableStreamBYOBReader::ReleaseLock(ErrorResult& aRv) {
   ReadableStreamBYOBReaderRelease(cx, thisRefPtr, aRv);
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#acquire-readable-stream-byob-reader
 already_AddRefed<ReadableStreamBYOBReader> AcquireReadableStreamBYOBReader(
     ReadableStream* aStream, ErrorResult& aRv) {
@@ -346,5 +355,6 @@ already_AddRefed<ReadableStreamBYOBReader> AcquireReadableStreamBYOBReader(
   // Step 3. Return reader.
   return reader.forget();
 }
+}  // namespace streams_abstract
 
 }  // namespace mozilla::dom

dom/streams/ReadableStreamBYOBReader.h

@@ -66,6 +66,8 @@ class ReadableStreamBYOBReader final : public ReadableStreamGenericReader,
   LinkedList<RefPtr<ReadIntoRequest>> mReadIntoRequests;
 };
 
+namespace streams_abstract {
+
 already_AddRefed<ReadableStreamBYOBReader> AcquireReadableStreamBYOBReader(
     ReadableStream* aStream, ErrorResult& aRv);
 
@@ -82,6 +84,8 @@ void ReadableStreamBYOBReaderRelease(JSContext* aCx,
                                      ReadableStreamBYOBReader* aReader,
                                      ErrorResult& aRv);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif  // mozilla_dom_ReadableStreamBYOBReader_h

dom/streams/ReadableStreamBYOBRequest.cpp

@@ -20,6 +20,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 ReadableStreamBYOBRequest::ReadableStreamBYOBRequest(nsIGlobalObject* aGlobal)
     : mGlobal(aGlobal) {
   mozilla::HoldJSObjects(this);

dom/streams/ReadableStreamDefaultController.cpp

@@ -4,6 +4,8 @@
  * 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/ReadableStreamDefaultController.h"
+
 #include "js/Exception.h"
 #include "js/TypeDecls.h"
 #include "js/Value.h"
@@ -14,7 +16,6 @@
 #include "mozilla/dom/Promise-inl.h"
 #include "mozilla/dom/ReadableStream.h"
 #include "mozilla/dom/ReadableStreamController.h"
-#include "mozilla/dom/ReadableStreamDefaultController.h"
 #include "mozilla/dom/ReadableStreamDefaultControllerBinding.h"
 #include "mozilla/dom/ReadableStreamDefaultReaderBinding.h"
 #include "mozilla/dom/UnderlyingSourceBinding.h"
@@ -24,6 +25,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION(ReadableStreamController, mGlobal, mAlgorithms,
                          mStream)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(ReadableStreamController)
@@ -96,6 +99,8 @@ JSObject* ReadableStreamDefaultController::WrapObject(
   return ReadableStreamDefaultController_Binding::Wrap(aCx, this, aGivenProto);
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-default-controller-can-close-or-enqueue
 static bool ReadableStreamDefaultControllerCanCloseOrEnqueue(
     ReadableStreamDefaultController* aController) {
@@ -169,12 +174,16 @@ Nullable<double> ReadableStreamDefaultControllerGetDesiredSize(
   return aController->StrategyHWM() - aController->QueueTotalSize();
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rs-default-controller-desired-size
 Nullable<double> ReadableStreamDefaultController::GetDesiredSize() {
   // Step 1.
   return ReadableStreamDefaultControllerGetDesiredSize(this);
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-default-controller-clear-algorithms
 //
 // Note: nullptr is used to indicate we run the default algorithm at the
@@ -221,6 +230,8 @@ void ReadableStreamDefaultControllerClose(
   }
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rs-default-controller-close
 void ReadableStreamDefaultController::Close(JSContext* aCx, ErrorResult& aRv) {
   // Step 1.
@@ -233,6 +244,8 @@ void ReadableStreamDefaultController::Close(JSContext* aCx, ErrorResult& aRv) {
   ReadableStreamDefaultControllerClose(aCx, this, aRv);
 }
 
+namespace streams_abstract {
+
 MOZ_CAN_RUN_SCRIPT static void ReadableStreamDefaultControllerCallPullIfNeeded(
     JSContext* aCx, ReadableStreamDefaultController* aController,
     ErrorResult& aRv);
@@ -328,6 +341,8 @@ void ReadableStreamDefaultControllerEnqueue(
   ReadableStreamDefaultControllerCallPullIfNeeded(aCx, aController, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rs-default-controller-close
 void ReadableStreamDefaultController::Enqueue(JSContext* aCx,
                                               JS::Handle<JS::Value> aChunk,
@@ -348,6 +363,8 @@ void ReadableStreamDefaultController::Error(JSContext* aCx,
   ReadableStreamDefaultControllerError(aCx, this, aError, aRv);
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-default-controller-should-call-pull
 bool ReadableStreamDefaultControllerShouldCallPull(
     ReadableStreamDefaultController* aController) {
@@ -559,6 +576,8 @@ void SetupReadableStreamDefaultControllerFromUnderlyingSource(
                                        aHighWaterMark, aSizeAlgorithm, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#rs-default-controller-private-cancel
 already_AddRefed<Promise> ReadableStreamDefaultController::CancelSteps(
     JSContext* aCx, JS::Handle<JS::Value> aReason, ErrorResult& aRv) {

dom/streams/ReadableStreamDefaultController.h

@@ -113,6 +113,8 @@ class ReadableStreamDefaultController final : public ReadableStreamController,
   RefPtr<QueuingStrategySize> mStrategySizeAlgorithm;
 };
 
+namespace streams_abstract {
+
 MOZ_CAN_RUN_SCRIPT void SetUpReadableStreamDefaultController(
     JSContext* aCx, ReadableStream* aStream,
     ReadableStreamDefaultController* aController,
@@ -154,6 +156,8 @@ bool ReadableStreamDefaultControllerCanCloseOrEnqueueAndThrow(
 bool ReadableStreamDefaultControllerShouldCallPull(
     ReadableStreamDefaultController* aController);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif  // mozilla_dom_ReadableStreamDefaultController_h

dom/streams/ReadableStreamDefaultReader.cpp

@@ -5,6 +5,7 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/dom/ReadableStreamDefaultReader.h"
+
 #include "mozilla/dom/AutoEntryScript.h"
 #include "mozilla/dom/ReadableStream.h"
 #include "mozilla/dom/RootedDictionary.h"
@@ -21,6 +22,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION(ReadableStreamGenericReader, mClosedPromise, mStream,
                          mGlobal)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(ReadableStreamGenericReader)
@@ -57,6 +60,7 @@ JSObject* ReadableStreamDefaultReader::WrapObject(
   return ReadableStreamDefaultReader_Binding::Wrap(aCx, this, aGivenProto);
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-initialize
 bool ReadableStreamReaderGenericInitialize(ReadableStreamGenericReader* aReader,
                                            ReadableStream* aStream) {
@@ -98,6 +102,7 @@ bool ReadableStreamReaderGenericInitialize(ReadableStreamGenericReader* aReader,
       return false;
   }
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#default-reader-constructor &&
 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
@@ -198,6 +203,7 @@ NS_INTERFACE_MAP_END
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Read_ReadRequest)
 NS_INTERFACE_MAP_END_INHERITING(ReadRequest)
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#readable-stream-default-reader-read
 void ReadableStreamDefaultReaderRead(JSContext* aCx,
                                      ReadableStreamGenericReader* aReader,
@@ -232,6 +238,7 @@ void ReadableStreamDefaultReaderRead(JSContext* aCx,
     }
   }
 }
+}  // namespace streams_abstract
 
 // Return a raw pointer here to avoid refcounting, but make sure it's safe
 // (the object should be kept alive by the callee).
@@ -262,6 +269,8 @@ already_AddRefed<Promise> ReadableStreamDefaultReader::Read(ErrorResult& aRv) {
   return promise.forget();
 }
 
+namespace streams_abstract {
+
 // https://streams.spec.whatwg.org/#readable-stream-reader-generic-release
 void ReadableStreamReaderGenericRelease(ReadableStreamGenericReader* aReader,
                                         ErrorResult& aRv) {
@@ -342,6 +351,8 @@ void ReadableStreamDefaultReaderRelease(JSContext* aCx,
   ReadableStreamDefaultReaderErrorReadRequests(aCx, aReader, error, aRv);
 }
 
+}  // namespace streams_abstract
+
 // https://streams.spec.whatwg.org/#default-reader-release-lock
 void ReadableStreamDefaultReader::ReleaseLock(ErrorResult& aRv) {
   // Step 1. If this.[[stream]] is undefined, return.
@@ -394,6 +405,7 @@ already_AddRefed<Promise> ReadableStreamGenericReader::Cancel(
   return ReadableStreamGenericReaderCancel(aCx, this, aReason, aRv);
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
 void SetUpReadableStreamDefaultReader(ReadableStreamDefaultReader* aReader,
                                       ReadableStream* aStream,
@@ -413,6 +425,7 @@ void SetUpReadableStreamDefaultReader(ReadableStreamDefaultReader* aReader,
   // Step 3.
   aReader->ReadRequests().clear();
 }
+}  // namespace streams_abstract
 
 // https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-a-chunk
 // To read a chunk from a ReadableStreamDefaultReader reader, given a read

dom/streams/ReadableStreamDefaultReader.h

@@ -101,6 +101,8 @@ class ReadableStreamDefaultReader final : public ReadableStreamGenericReader,
   LinkedList<RefPtr<ReadRequest>> mReadRequests = {};
 };
 
+namespace streams_abstract {
+
 void SetUpReadableStreamDefaultReader(ReadableStreamDefaultReader* aReader,
                                       ReadableStream* aStream,
                                       ErrorResult& aRv);
@@ -113,6 +115,8 @@ void ReadableStreamDefaultReaderRelease(JSContext* aCx,
                                         ReadableStreamDefaultReader* aReader,
                                         ErrorResult& aRv);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif  // mozilla_dom_ReadableStreamDefaultReader_h

dom/streams/ReadableStreamGenericReader.h

@@ -62,12 +62,16 @@ class ReadableStreamGenericReader : public nsISupports {
   RefPtr<ReadableStream> mStream;
 };
 
+namespace streams_abstract {
+
 bool ReadableStreamReaderGenericInitialize(ReadableStreamGenericReader* aReader,
                                            ReadableStream* aStream);
 
 void ReadableStreamReaderGenericRelease(ReadableStreamGenericReader* aReader,
                                         ErrorResult& aRv);
 
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom
 
 #endif

dom/streams/ReadableStreamPipeTo.cpp

@@ -884,6 +884,7 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(PipeToPump)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mLastWritePromise)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#readable-stream-pipe-to
 already_AddRefed<Promise> ReadableStreamPipeTo(
     ReadableStream* aSource, WritableStream* aDest, bool aPreventClose,
@@ -950,5 +951,6 @@ already_AddRefed<Promise> ReadableStreamPipeTo(
   // Step 16. Return promise.
   return promise.forget();
 }
+}  // namespace streams_abstract
 
 }  // namespace mozilla::dom

dom/streams/ReadableStreamPipeTo.h

@@ -21,10 +21,12 @@ class Promise;
 class ReadableStream;
 class WritableStream;
 
+namespace streams_abstract {
 MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> ReadableStreamPipeTo(
     ReadableStream* aSource, WritableStream* aDest, bool aPreventClose,
     bool aPreventAbort, bool aPreventCancel, AbortSignal* aSignal,
     ErrorResult& aRv);
+}
 
 }  // namespace dom
 }  // namespace mozilla

dom/streams/ReadableStreamTee.cpp

@@ -26,6 +26,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION_INHERITED(ReadableStreamDefaultTeeSourceAlgorithms,
                                    UnderlyingSourceAlgorithmsBase, mTeeState)
 NS_IMPL_ADDREF_INHERITED(ReadableStreamDefaultTeeSourceAlgorithms,
@@ -957,6 +959,7 @@ void ForwardReaderError(TeeState* aTeeState,
       RefPtr(aTeeState), RefPtr(aThisReader));
 }
 
+namespace streams_abstract {
 // https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamtee
 void ReadableByteStreamTee(JSContext* aCx, ReadableStream* aStream,
                            nsTArray<RefPtr<ReadableStream>>& aResult,
@@ -1003,4 +1006,6 @@ void ReadableByteStreamTee(JSContext* aCx, ReadableStream* aStream,
   aResult.AppendElement(teeState->Branch1());
   aResult.AppendElement(teeState->Branch2());
 }
+}  // namespace streams_abstract
+
 }  // namespace mozilla::dom

dom/streams/ReadableStreamTee.h

@@ -81,9 +81,11 @@ struct ReadableStreamDefaultTeeReadRequest final : public ReadRequest {
   ~ReadableStreamDefaultTeeReadRequest() override = default;
 };
 
+namespace streams_abstract {
 MOZ_CAN_RUN_SCRIPT void ReadableByteStreamTee(
     JSContext* aCx, ReadableStream* aStream,
     nsTArray<RefPtr<ReadableStream>>& aResult, ErrorResult& aRv);
+}
 
 }  // namespace mozilla::dom
 #endif

dom/streams/TeeState.cpp

@@ -14,6 +14,8 @@
 
 namespace mozilla::dom {
 
+using namespace streams_abstract;
+
 NS_IMPL_CYCLE_COLLECTION_WITH_JS_MEMBERS(TeeState,
                                          (mStream, mReader, mBranch1, mBranch2,
                                           mCancelPromise),