Bug 1757653 - Remove redundant `extern`s in dom/streams r=mgaudet

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

dom/streams/ReadableByteStreamController.h

@@ -336,41 +336,41 @@ struct PullIntoDescriptor final
   ~PullIntoDescriptor() = default;
 };
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerRespond(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespond(
     JSContext* aCx, ReadableByteStreamController* aController,
     uint64_t aBytesWritten, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerRespondInternal(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespondInternal(
     JSContext* aCx, ReadableByteStreamController* aController,
     uint64_t aBytesWritten, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerRespondWithNewView(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerRespondWithNewView(
     JSContext* aCx, ReadableByteStreamController* aController,
     JS::Handle<JSObject*> aView, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerPullInto(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerPullInto(
     JSContext* aCx, ReadableByteStreamController* aController,
     JS::HandleObject aView, ReadIntoRequest* aReadIntoRequest,
     ErrorResult& aRv);
 
-extern void ReadableByteStreamControllerError(
+void ReadableByteStreamControllerError(
     ReadableByteStreamController* aController, JS::HandleValue aValue,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerEnqueue(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerEnqueue(
     JSContext* aCx, ReadableByteStreamController* aController,
     JS::HandleObject aChunk, ErrorResult& aRv);
 
-extern already_AddRefed<ReadableStreamBYOBRequest>
+already_AddRefed<ReadableStreamBYOBRequest>
 ReadableByteStreamControllerGetBYOBRequest(
     JSContext* aCx, ReadableByteStreamController* aController,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerClose(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerClose(
     JSContext* aCx, ReadableByteStreamController* aController,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void SetUpReadableByteStreamController(
+MOZ_CAN_RUN_SCRIPT void SetUpReadableByteStreamController(
     JSContext* aCx, ReadableStream* aStream,
     ReadableByteStreamController* aController,
     UnderlyingSourceStartCallbackHelper* aStartAlgorithm,
@@ -379,7 +379,7 @@ MOZ_CAN_RUN_SCRIPT extern void SetUpReadableByteStreamController(
     UnderlyingSourceErrorCallbackHelper* aErrorAlgorithm, double aHighWaterMark,
     Maybe<uint64_t> aAutoAllocateChunkSize, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableByteStreamControllerCallPullIfNeeded(
+MOZ_CAN_RUN_SCRIPT void ReadableByteStreamControllerCallPullIfNeeded(
     JSContext* aCx, ReadableByteStreamController* aController,
     ErrorResult& aRv);
 

dom/streams/ReadableStream.h

@@ -163,42 +163,41 @@ class ReadableStream final : public nsISupports, public nsWrapperCache {
   RefPtr<BodyStreamHolder> mNativeUnderlyingSource;
 };
 
-extern bool IsReadableStreamLocked(ReadableStream* aStream);
+bool IsReadableStreamLocked(ReadableStream* aStream);
 
-extern double ReadableStreamGetNumReadRequests(ReadableStream* aStream);
+double ReadableStreamGetNumReadRequests(ReadableStream* aStream);
 
-extern void ReadableStreamError(JSContext* aCx, ReadableStream* aStream,
-                                JS::Handle<JS::Value> aValue, ErrorResult& aRv);
+void ReadableStreamError(JSContext* aCx, ReadableStream* aStream,
+                         JS::Handle<JS::Value> aValue, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableStreamClose(JSContext* aCx,
-                                                   ReadableStream* aStream,
-                                                   ErrorResult& aRv);
+MOZ_CAN_RUN_SCRIPT void ReadableStreamClose(JSContext* aCx,
+                                            ReadableStream* aStream,
+                                            ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableStreamFulfillReadRequest(
+MOZ_CAN_RUN_SCRIPT void ReadableStreamFulfillReadRequest(
     JSContext* aCx, ReadableStream* aStream, JS::Handle<JS::Value> aChunk,
     bool done, ErrorResult& aRv);
 
-extern void ReadableStreamAddReadRequest(ReadableStream* aStream,
-                                         ReadRequest* aReadRequest);
-extern void ReadableStreamAddReadIntoRequest(ReadableStream* aStream,
-                                             ReadIntoRequest* aReadIntoRequest);
+void ReadableStreamAddReadRequest(ReadableStream* aStream,
+                                  ReadRequest* aReadRequest);
+void ReadableStreamAddReadIntoRequest(ReadableStream* aStream,
+                                      ReadIntoRequest* aReadIntoRequest);
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<Promise> ReadableStreamCancel(
+MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> ReadableStreamCancel(
     JSContext* aCx, ReadableStream* aStream, JS::Handle<JS::Value> aError,
     ErrorResult& aRv);
 
-extern already_AddRefed<ReadableStreamDefaultReader>
+already_AddRefed<ReadableStreamDefaultReader>
 AcquireReadableStreamDefaultReader(ReadableStream* aStream, ErrorResult& aRv);
 
-extern bool ReadableStreamHasBYOBReader(ReadableStream* aStream);
-extern bool ReadableStreamHasDefaultReader(ReadableStream* aStream);
+bool ReadableStreamHasBYOBReader(ReadableStream* aStream);
+bool ReadableStreamHasDefaultReader(ReadableStream* aStream);
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<ReadableStream>
-CreateReadableByteStream(JSContext* aCx, nsIGlobalObject* aGlobal,
-                         UnderlyingSourceStartCallbackHelper* aStartAlgorithm,
-                         UnderlyingSourcePullCallbackHelper* aPullAlgorithm,
-                         UnderlyingSourceCancelCallbackHelper* aCancelAlgorithm,
-                         ErrorResult& aRv);
+MOZ_CAN_RUN_SCRIPT already_AddRefed<ReadableStream> CreateReadableByteStream(
+    JSContext* aCx, nsIGlobalObject* aGlobal,
+    UnderlyingSourceStartCallbackHelper* aStartAlgorithm,
+    UnderlyingSourcePullCallbackHelper* aPullAlgorithm,
+    UnderlyingSourceCancelCallbackHelper* aCancelAlgorithm, ErrorResult& aRv);
 
 }  // namespace mozilla::dom
 

dom/streams/ReadableStreamDefaultController.h

@@ -138,7 +138,7 @@ class ReadableStreamDefaultController final : public ReadableStreamController,
   RefPtr<ReadableStream> mStream;
 };
 
-MOZ_CAN_RUN_SCRIPT extern void SetUpReadableStreamDefaultController(
+MOZ_CAN_RUN_SCRIPT void SetUpReadableStreamDefaultController(
     JSContext* aCx, ReadableStream* aStream,
     ReadableStreamDefaultController* aController,
     UnderlyingSourceStartCallbackHelper* aStartAlgorithm,
@@ -147,29 +147,29 @@ MOZ_CAN_RUN_SCRIPT extern void SetUpReadableStreamDefaultController(
     double aHighWaterMark, QueuingStrategySize* aSizeAlgorithm,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void
+MOZ_CAN_RUN_SCRIPT void
 SetupReadableStreamDefaultControllerFromUnderlyingSource(
     JSContext* aCx, ReadableStream* aStream, JS::HandleObject aUnderlyingSource,
     UnderlyingSource& aUnderlyingSourceDict, double aHighWaterMark,
     QueuingStrategySize* aSizeAlgorithm, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableStreamDefaultControllerEnqueue(
+MOZ_CAN_RUN_SCRIPT void ReadableStreamDefaultControllerEnqueue(
     JSContext* aCx, ReadableStreamDefaultController* aController,
     JS::Handle<JS::Value> aChunk, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableStreamDefaultControllerClose(
+MOZ_CAN_RUN_SCRIPT void ReadableStreamDefaultControllerClose(
     JSContext* aCx, ReadableStreamDefaultController* aController,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void ReadableStreamDefaultReaderRead(
+MOZ_CAN_RUN_SCRIPT void ReadableStreamDefaultReaderRead(
     JSContext* aCx, ReadableStreamGenericReader* reader, ReadRequest* aRequest,
     ErrorResult& aRv);
 
-extern void ReadableStreamDefaultControllerError(
+void ReadableStreamDefaultControllerError(
     JSContext* aCx, ReadableStreamDefaultController* aController,
     JS::Handle<JS::Value> aValue, ErrorResult& aRv);
 
-extern void ReadableStreamDefaultControllerClearAlgorithms(
+void ReadableStreamDefaultControllerClearAlgorithms(
     ReadableStreamDefaultController* aController);
 
 }  // namespace mozilla::dom

dom/streams/ReadableStreamDefaultReader.h

@@ -90,9 +90,9 @@ class ReadableStreamDefaultReader final : public ReadableStreamGenericReader,
   LinkedList<RefPtr<ReadRequest>> mReadRequests = {};
 };
 
-extern void SetUpReadableStreamDefaultReader(
-    ReadableStreamDefaultReader* aReader, ReadableStream* aStream,
-    ErrorResult& aRv);
+void SetUpReadableStreamDefaultReader(ReadableStreamDefaultReader* aReader,
+                                      ReadableStream* aStream,
+                                      ErrorResult& aRv);
 
 void ReadableStreamDefaultReaderErrorReadRequests(
     JSContext* aCx, ReadableStreamDefaultReader* aReader,

dom/streams/StreamUtils.h

@@ -11,8 +11,8 @@ namespace mozilla::dom {
 
 struct QueuingStrategy;
 
-extern double ExtractHighWaterMark(const QueuingStrategy& aStrategy,
-                                   double aDefaultHWM, ErrorResult& aRv);
+double ExtractHighWaterMark(const QueuingStrategy& aStrategy,
+                            double aDefaultHWM, ErrorResult& aRv);
 
 }  // namespace mozilla::dom
 

dom/streams/TransformStreamDefaultController.h

@@ -75,7 +75,7 @@ class TransformStreamDefaultController final : public nsISupports,
   JS::Heap<JSObject*> mTransformer;
 };
 
-extern void SetUpTransformStreamDefaultControllerFromTransformer(
+void SetUpTransformStreamDefaultControllerFromTransformer(
     JSContext* aCx, TransformStream& aStream, JS::HandleObject aTransformer,
     Transformer& aTransformerDict);
 

dom/streams/WritableStream.h

@@ -184,17 +184,17 @@ inline bool IsWritableStreamLocked(WritableStream* aStream) {
   return aStream->Locked();
 }
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<Promise> WritableStreamAbort(
+MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> WritableStreamAbort(
     JSContext* aCx, WritableStream* aStream, JS::Handle<JS::Value> aReason,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<Promise> WritableStreamClose(
+MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> WritableStreamClose(
     JSContext* aCx, WritableStream* aStream, ErrorResult& aRv);
 
-extern already_AddRefed<Promise> WritableStreamAddWriteRequest(
-    WritableStream* aStream, ErrorResult& aRv);
+already_AddRefed<Promise> WritableStreamAddWriteRequest(WritableStream* aStream,
+                                                        ErrorResult& aRv);
 
-extern already_AddRefed<WritableStreamDefaultWriter>
+already_AddRefed<WritableStreamDefaultWriter>
 AcquireWritableStreamDefaultWriter(WritableStream* aStream, ErrorResult& aRv);
 
 }  // namespace mozilla::dom

dom/streams/WritableStreamDefaultController.h

@@ -154,7 +154,7 @@ class WritableStreamDefaultController final : public nsISupports,
   RefPtr<WritableStream> mStream;
 };
 
-MOZ_CAN_RUN_SCRIPT extern void SetUpWritableStreamDefaultController(
+MOZ_CAN_RUN_SCRIPT void SetUpWritableStreamDefaultController(
     JSContext* aCx, WritableStream* aStream,
     WritableStreamDefaultController* aController,
     UnderlyingSinkStartCallbackHelper* aStartAlgorithm,
@@ -163,29 +163,28 @@ MOZ_CAN_RUN_SCRIPT extern void SetUpWritableStreamDefaultController(
     UnderlyingSinkAbortCallbackHelper* aAbortAlgorithm, double aHighWaterMark,
     QueuingStrategySize* aSizeAlgorithm, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void
-SetUpWritableStreamDefaultControllerFromUnderlyingSink(
+MOZ_CAN_RUN_SCRIPT void SetUpWritableStreamDefaultControllerFromUnderlyingSink(
     JSContext* aCx, WritableStream* aStream, JS::HandleObject aUnderlyingSink,
     UnderlyingSink& aUnderlyingSinkDict, double aHighWaterMark,
     QueuingStrategySize* aSizeAlgorithm, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void WritableStreamDefaultControllerClose(
+MOZ_CAN_RUN_SCRIPT void WritableStreamDefaultControllerClose(
     JSContext* aCx, WritableStreamDefaultController* aController,
     ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void WritableStreamDefaultControllerWrite(
+MOZ_CAN_RUN_SCRIPT void WritableStreamDefaultControllerWrite(
     JSContext* aCx, WritableStreamDefaultController* aController,
     JS::Handle<JS::Value> aChunk, double chunkSize, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void WritableStreamDefaultControllerError(
+MOZ_CAN_RUN_SCRIPT void WritableStreamDefaultControllerError(
     JSContext* aCx, WritableStreamDefaultController* aController,
     JS::Handle<JS::Value> aError, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern void WritableStreamDefaultControllerErrorIfNeeded(
+MOZ_CAN_RUN_SCRIPT void WritableStreamDefaultControllerErrorIfNeeded(
     JSContext* aCx, WritableStreamDefaultController* aController,
     JS::Handle<JS::Value> aError, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern double WritableStreamDefaultControllerGetChunkSize(
+MOZ_CAN_RUN_SCRIPT double WritableStreamDefaultControllerGetChunkSize(
     JSContext* aCx, WritableStreamDefaultController* aController,
     JS::Handle<JS::Value> aChunk, ErrorResult& aRv);
 

dom/streams/WritableStreamDefaultWriter.h

@@ -83,31 +83,30 @@ class WritableStreamDefaultWriter final : public nsISupports,
   RefPtr<Promise> mClosedPromise;
 };
 
-extern void SetUpWritableStreamDefaultWriter(
-    WritableStreamDefaultWriter* aWriter, WritableStream* aStream,
-    ErrorResult& aRv);
+void SetUpWritableStreamDefaultWriter(WritableStreamDefaultWriter* aWriter,
+                                      WritableStream* aStream,
+                                      ErrorResult& aRv);
 
-extern void WritableStreamDefaultWriterEnsureClosedPromiseRejected(
+void WritableStreamDefaultWriterEnsureClosedPromiseRejected(
     WritableStreamDefaultWriter* aWriter, JS::Handle<JS::Value> aError,
     ErrorResult& aRv);
 
-extern void WritableStreamDefaultWriterEnsureReadyPromiseRejected(
+void WritableStreamDefaultWriterEnsureReadyPromiseRejected(
     WritableStreamDefaultWriter* aWriter, JS::Handle<JS::Value> aError,
     ErrorResult& aRv);
 
-extern Nullable<double> WritableStreamDefaultWriterGetDesiredSize(
+Nullable<double> WritableStreamDefaultWriterGetDesiredSize(
     WritableStreamDefaultWriter* aWriter);
 
-extern void WritableStreamDefaultWriterRelease(
-    JSContext* aCx, WritableStreamDefaultWriter* aWriter, ErrorResult& aRv);
+void WritableStreamDefaultWriterRelease(JSContext* aCx,
+                                        WritableStreamDefaultWriter* aWriter,
+                                        ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<Promise>
-WritableStreamDefaultWriterWrite(JSContext* aCx,
-                                 WritableStreamDefaultWriter* aWriter,
-                                 JS::Handle<JS::Value> aChunk,
-                                 ErrorResult& aRv);
+MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise> WritableStreamDefaultWriterWrite(
+    JSContext* aCx, WritableStreamDefaultWriter* aWriter,
+    JS::Handle<JS::Value> aChunk, ErrorResult& aRv);
 
-MOZ_CAN_RUN_SCRIPT extern already_AddRefed<Promise>
+MOZ_CAN_RUN_SCRIPT already_AddRefed<Promise>
 WritableStreamDefaultWriterCloseWithErrorPropagation(
     JSContext* aCx, WritableStreamDefaultWriter* aWriter, ErrorResult& aRv);