Bug 1754004 - Part 11: Simplify the IPCStream serialization API, r=asuth,necko-reviewers,kershaw

As serializing IPCStream no longer requires a manager or FileDescriptor array,
the arguments are no longer necessary, and can be removed. The AutoIPCStream
helper can also be removed, as managed actors are no longer used for
serialization, so a delayed start callback is not necessary.

The delayed start parameter is also removed from nsIIPCSerializableInputStream
instances, but is still present as `aAllowLazy` on the toplevel serialization
methods.

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

dom/cache/AutoUtils.cpp

@@ -23,7 +23,6 @@
 using mozilla::Maybe;
 using mozilla::Unused;
 using mozilla::dom::cache::CacheReadStream;
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::PBackgroundParent;
 
 namespace {
@@ -55,12 +54,6 @@ AutoChildOpArgs::AutoChildOpArgs(TypeUtils* aTypeUtils,
     : mTypeUtils(aTypeUtils), mOpArgs(aOpArgs), mSent(false) {
   MOZ_DIAGNOSTIC_ASSERT(mTypeUtils);
   MOZ_RELEASE_ASSERT(aEntryCount != 0);
-  // We are using AutoIPCStream objects to cleanup target IPCStream
-  // structures embedded in our CacheOpArgs.  These IPCStream structs
-  // must not move once we attach our AutoIPCStream to them.  Therefore,
-  // its important that any arrays containing streams are pre-sized for
-  // the number of entries we have in order to avoid realloc moving
-  // things around on us.
   if (mOpArgs.type() == CacheOpArgs::TCachePutAllArgs) {
     CachePutAllArgs& args = mOpArgs.get_CachePutAllArgs();
     args.requestResponseList().SetCapacity(aEntryCount);
@@ -117,8 +110,6 @@ AutoChildOpArgs::~AutoChildOpArgs() {
       // Other types do not need cleanup
       break;
   }
-
-  mStreamCleanupList.Clear();
 }
 
 void AutoChildOpArgs::Add(const InternalRequest& aRequest,
@@ -130,7 +121,7 @@ void AutoChildOpArgs::Add(const InternalRequest& aRequest,
     case CacheOpArgs::TCacheMatchArgs: {
       CacheMatchArgs& args = mOpArgs.get_CacheMatchArgs();
       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
-                                 aSchemeAction, mStreamCleanupList, aRv);
+                                 aSchemeAction, aRv);
       break;
     }
     case CacheOpArgs::TCacheMatchAllArgs: {
@@ -138,14 +129,13 @@ void AutoChildOpArgs::Add(const InternalRequest& aRequest,
       MOZ_DIAGNOSTIC_ASSERT(args.maybeRequest().isNothing());
       args.maybeRequest().emplace(CacheRequest());
       mTypeUtils->ToCacheRequest(args.maybeRequest().ref(), aRequest,
-                                 aBodyAction, aSchemeAction, mStreamCleanupList,
+                                 aBodyAction, aSchemeAction, aRv);
-                                 aRv);
       break;
     }
     case CacheOpArgs::TCacheDeleteArgs: {
       CacheDeleteArgs& args = mOpArgs.get_CacheDeleteArgs();
       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
-                                 aSchemeAction, mStreamCleanupList, aRv);
+                                 aSchemeAction, aRv);
       break;
     }
     case CacheOpArgs::TCacheKeysArgs: {
@@ -153,14 +143,13 @@ void AutoChildOpArgs::Add(const InternalRequest& aRequest,
       MOZ_DIAGNOSTIC_ASSERT(args.maybeRequest().isNothing());
       args.maybeRequest().emplace(CacheRequest());
       mTypeUtils->ToCacheRequest(args.maybeRequest().ref(), aRequest,
-                                 aBodyAction, aSchemeAction, mStreamCleanupList,
+                                 aBodyAction, aSchemeAction, aRv);
-                                 aRv);
       break;
     }
     case CacheOpArgs::TStorageMatchArgs: {
       StorageMatchArgs& args = mOpArgs.get_StorageMatchArgs();
       mTypeUtils->ToCacheRequest(args.request(), aRequest, aBodyAction,
-                                 aSchemeAction, mStreamCleanupList, aRv);
+                                 aSchemeAction, aRv);
       break;
     }
     default:
@@ -273,10 +262,6 @@ void AutoChildOpArgs::Add(JSContext* aCx, const InternalRequest& aRequest,
         return;
       }
 
-      // Ensure that we don't realloc the array since this can result
-      // in our AutoIPCStream objects to reference the wrong memory
-      // location.  This should never happen and is a UAF if it does.
-      // Therefore make this a release assertion.
       MOZ_RELEASE_ASSERT(args.requestResponseList().Length() <
                          args.requestResponseList().Capacity());
 
@@ -292,10 +277,9 @@ void AutoChildOpArgs::Add(JSContext* aCx, const InternalRequest& aRequest,
       pair.response().body() = Nothing();
 
       mTypeUtils->ToCacheRequest(pair.request(), aRequest, aBodyAction,
-                                 aSchemeAction, mStreamCleanupList, aRv);
+                                 aSchemeAction, aRv);
       if (!aRv.Failed()) {
-        mTypeUtils->ToCacheResponse(aCx, pair.response(), aResponse,
+        mTypeUtils->ToCacheResponse(aCx, pair.response(), aResponse, aRv);
-                                    mStreamCleanupList, aRv);
       }
 
       if (aRv.Failed()) {
@@ -313,9 +297,6 @@ void AutoChildOpArgs::Add(JSContext* aCx, const InternalRequest& aRequest,
 const CacheOpArgs& AutoChildOpArgs::SendAsOpArgs() {
   MOZ_DIAGNOSTIC_ASSERT(!mSent);
   mSent = true;
-  for (UniquePtr<AutoIPCStream>& autoStream : mStreamCleanupList) {
-    autoStream->TakeOptionalValue();
-  }
   return mOpArgs;
 }
 
@@ -330,12 +311,6 @@ AutoParentOpResult::AutoParentOpResult(
       mSent(false) {
   MOZ_DIAGNOSTIC_ASSERT(mManager);
   MOZ_RELEASE_ASSERT(aEntryCount != 0);
-  // We are using AutoIPCStream objects to cleanup target IPCStream
-  // structures embedded in our CacheOpArgs.  These IPCStream structs
-  // must not move once we attach our AutoIPCStream to them.  Therefore,
-  // its important that any arrays containing streams are pre-sized for
-  // the number of entries we have in order to avoid realloc moving
-  // things around on us.
   if (mOpResult.type() == CacheOpResult::TCacheMatchAllResult) {
     CacheMatchAllResult& result = mOpResult.get_CacheMatchAllResult();
     result.responseList().SetCapacity(aEntryCount);
@@ -370,8 +345,6 @@ AutoParentOpResult::~AutoParentOpResult() {
     QM_WARNONLY_TRY(
         OkIf(PCacheStreamControlParent::Send__delete__(mStreamControl)));
   }
-
-  mStreamCleanupList.Clear();
 }
 
 void AutoParentOpResult::Add(CacheId aOpenedCacheId,
@@ -399,10 +372,6 @@ void AutoParentOpResult::Add(const SavedResponse& aSavedResponse,
     }
     case CacheOpResult::TCacheMatchAllResult: {
       CacheMatchAllResult& result = mOpResult.get_CacheMatchAllResult();
-      // Ensure that we don't realloc the array since this can result
-      // in our AutoIPCStream objects to reference the wrong memory
-      // location.  This should never happen and is a UAF if it does.
-      // Therefore make this a release assertion.
       MOZ_RELEASE_ASSERT(result.responseList().Length() <
                          result.responseList().Capacity());
       result.responseList().AppendElement(aSavedResponse.mValue);
@@ -430,10 +399,6 @@ void AutoParentOpResult::Add(const SavedRequest& aSavedRequest,
   switch (mOpResult.type()) {
     case CacheOpResult::TCacheKeysResult: {
       CacheKeysResult& result = mOpResult.get_CacheKeysResult();
-      // Ensure that we don't realloc the array since this can result
-      // in our AutoIPCStream objects to reference the wrong memory
-      // location.  This should never happen and is a UAF if it does.
-      // Therefore make this a release assertion.
       MOZ_RELEASE_ASSERT(result.requestList().Length() <
                          result.requestList().Capacity());
       result.requestList().AppendElement(aSavedRequest.mValue);
@@ -457,9 +422,6 @@ void AutoParentOpResult::Add(const SavedRequest& aSavedRequest,
 const CacheOpResult& AutoParentOpResult::SendAsOpResult() {
   MOZ_DIAGNOSTIC_ASSERT(!mSent);
   mSent = true;
-  for (UniquePtr<AutoIPCStream>& autoStream : mStreamCleanupList) {
-    autoStream->TakeOptionalValue();
-  }
   return mOpResult;
 }
 
@@ -504,7 +466,7 @@ void AutoParentOpResult::SerializeReadStream(const nsID& aId,
   RefPtr<ReadStream> readStream =
       ReadStream::Create(mStreamControl, aId, stream);
   ErrorResult rv;
-  readStream->Serialize(aReadStreamOut, mStreamCleanupList, rv);
+  readStream->Serialize(aReadStreamOut, rv);
   MOZ_DIAGNOSTIC_ASSERT(!rv.Failed());
 }
 

dom/cache/AutoUtils.h

@@ -22,7 +22,6 @@ class ErrorResult;
 
 namespace ipc {
 class PBackgroundParent;
-class AutoIPCStream;
 }  // namespace ipc
 
 namespace dom {
@@ -65,7 +64,6 @@ class MOZ_STACK_CLASS AutoChildOpArgs final {
  private:
   TypeUtils* mTypeUtils;
   CacheOpArgs mOpArgs;
-  nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>> mStreamCleanupList;
   bool mSent;
 };
 
@@ -92,7 +90,6 @@ class MOZ_STACK_CLASS AutoParentOpResult final {
   mozilla::ipc::PBackgroundParent* mManager;
   CacheOpResult mOpResult;
   CacheStreamControlParent* mStreamControl;
-  nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>> mStreamCleanupList;
   bool mSent;
 };
 

dom/cache/CacheStreamControlChild.cpp

@@ -17,7 +17,6 @@
 
 namespace mozilla::dom::cache {
 
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::FileDescriptor;
 
 // declared in ActorUtils.h
@@ -73,15 +72,12 @@ void CacheStreamControlChild::SerializeControl(
   aReadStreamOut->controlChild() = this;
 }
 
-void CacheStreamControlChild::SerializeStream(
+void CacheStreamControlChild::SerializeStream(CacheReadStream* aReadStreamOut,
-    CacheReadStream* aReadStreamOut, nsIInputStream* aStream,
+                                              nsIInputStream* aStream) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList) {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlChild);
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
-  UniquePtr<AutoIPCStream> autoStream(
+  MOZ_ALWAYS_TRUE(mozilla::ipc::SerializeIPCStream(
-      new AutoIPCStream(aReadStreamOut->stream()));
+      do_AddRef(aStream), aReadStreamOut->stream(), /* aAllowLazy */ false));
-  autoStream->Serialize(aStream, Manager());
-  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 void CacheStreamControlChild::OpenStream(const nsID& aId,

dom/cache/CacheStreamControlChild.h

@@ -13,9 +13,6 @@
 #include "nsTObserverArray.h"
 
 namespace mozilla {
-namespace ipc {
-class AutoIPCStream;
-}  // namespace ipc
 namespace dom {
 namespace cache {
 
@@ -36,9 +33,7 @@ class CacheStreamControlChild final : public PCacheStreamControlChild,
   virtual void SerializeControl(CacheReadStream* aReadStreamOut) override;
 
   virtual void SerializeStream(CacheReadStream* aReadStreamOut,
-                               nsIInputStream* aStream,
+                               nsIInputStream* aStream) override;
-                               nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>&
-                                   aStreamCleanupList) override;
 
   virtual void OpenStream(const nsID& aId,
                           InputStreamResolver&& aResolver) override;

dom/cache/CacheStreamControlParent.cpp

@@ -18,7 +18,6 @@
 
 namespace mozilla::dom::cache {
 
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::FileDescriptor;
 
 // declared in ActorUtils.h
@@ -44,18 +43,14 @@ void CacheStreamControlParent::SerializeControl(
   aReadStreamOut->controlParent() = this;
 }
 
-void CacheStreamControlParent::SerializeStream(
+void CacheStreamControlParent::SerializeStream(CacheReadStream* aReadStreamOut,
-    CacheReadStream* aReadStreamOut, nsIInputStream* aStream,
+                                               nsIInputStream* aStream) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList) {
   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
 
-  UniquePtr<AutoIPCStream> autoStream(
+  DebugOnly<bool> ok = mozilla::ipc::SerializeIPCStream(
-      new AutoIPCStream(aReadStreamOut->stream()));
+      do_AddRef(aStream), aReadStreamOut->stream(), /* aAllowLazy */ false);
-  DebugOnly<bool> ok = autoStream->Serialize(aStream, Manager());
   MOZ_ASSERT(ok);
-
-  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 void CacheStreamControlParent::OpenStream(const nsID& aId,
@@ -120,9 +115,11 @@ mozilla::ipc::IPCResult CacheStreamControlParent::RecvOpenStream(
 
   OpenStream(aStreamId, [aResolver, self = RefPtr{this}](
                             nsCOMPtr<nsIInputStream>&& aStream) {
-    AutoIPCStream autoStream;
+    Maybe<IPCStream> stream;
-    if (self->CanSend() && autoStream.Serialize(aStream, self->Manager())) {
+    if (self->CanSend() &&
-      aResolver(autoStream.TakeOptionalValue());
+        mozilla::ipc::SerializeIPCStream(aStream.forget(), stream,
+                                         /* aAllowLazy */ false)) {
+      aResolver(stream);
     } else {
       aResolver(Nothing());
     }

dom/cache/CacheStreamControlParent.h

@@ -13,9 +13,6 @@
 #include "nsTObserverArray.h"
 
 namespace mozilla {
-namespace ipc {
-class AutoIPCStream;
-}  // namespace ipc
 namespace dom {
 namespace cache {
 
@@ -38,9 +35,7 @@ class CacheStreamControlParent final : public PCacheStreamControlParent,
   virtual void SerializeControl(CacheReadStream* aReadStreamOut) override;
 
   virtual void SerializeStream(CacheReadStream* aReadStreamOut,
-                               nsIInputStream* aStream,
+                               nsIInputStream* aStream) override;
-                               nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>&
-                                   aStreamCleanupList) override;
 
   virtual void OpenStream(const nsID& aId,
                           InputStreamResolver&& aResolver) override;

dom/cache/ReadStream.cpp

@@ -20,7 +20,6 @@
 namespace mozilla::dom::cache {
 
 using mozilla::Unused;
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::IPCStream;
 
 // ----------------------------------------------------------------------------
@@ -32,13 +31,9 @@ class ReadStream::Inner final : public ReadStream::Controllable {
  public:
   Inner(StreamControl* aControl, const nsID& aId, nsIInputStream* aStream);
 
-  void Serialize(Maybe<CacheReadStream>* aReadStreamOut,
+  void Serialize(Maybe<CacheReadStream>* aReadStreamOut, ErrorResult& aRv);
-                 nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
-                 ErrorResult& aRv);
 
-  void Serialize(CacheReadStream* aReadStreamOut,
+  void Serialize(CacheReadStream* aReadStreamOut, ErrorResult& aRv);
-                 nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList,
-                 ErrorResult& aRv);
 
   // ReadStream::Controllable methods
   virtual void CloseStream() override;
@@ -191,18 +186,16 @@ ReadStream::Inner::Inner(StreamControl* aControl, const nsID& aId,
   mControl->AddReadStream(SafeRefPtrFromThis());
 }
 
-void ReadStream::Inner::Serialize(
+void ReadStream::Inner::Serialize(Maybe<CacheReadStream>* aReadStreamOut,
-    Maybe<CacheReadStream>* aReadStreamOut,
+                                  ErrorResult& aRv) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
   MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
   aReadStreamOut->emplace(CacheReadStream());
-  Serialize(&aReadStreamOut->ref(), aStreamCleanupList, aRv);
+  Serialize(&aReadStreamOut->ref(), aRv);
 }
 
-void ReadStream::Inner::Serialize(
+void ReadStream::Inner::Serialize(CacheReadStream* aReadStreamOut,
-    CacheReadStream* aReadStreamOut,
+                                  ErrorResult& aRv) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
   MOZ_ASSERT(mOwningEventTarget->IsOnCurrentThread());
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
 
@@ -219,7 +212,7 @@ void ReadStream::Inner::Serialize(
 
   {
     MutexAutoLock lock(mMutex);
-    mControl->SerializeStream(aReadStreamOut, mStream, aStreamCleanupList);
+    mControl->SerializeStream(aReadStreamOut, mStream);
   }
 
   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut->stream().isNothing() ||
@@ -554,16 +547,13 @@ already_AddRefed<ReadStream> ReadStream::Create(
       static_cast<CacheStreamControlParent*>(aControl), aId, aStream));
 }
 
-void ReadStream::Serialize(
+void ReadStream::Serialize(Maybe<CacheReadStream>* aReadStreamOut,
-    Maybe<CacheReadStream>* aReadStreamOut,
+                           ErrorResult& aRv) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
+  mInner->Serialize(aReadStreamOut, aRv);
-  mInner->Serialize(aReadStreamOut, aStreamCleanupList, aRv);
 }
 
-void ReadStream::Serialize(
+void ReadStream::Serialize(CacheReadStream* aReadStreamOut, ErrorResult& aRv) {
-    CacheReadStream* aReadStreamOut,
+  mInner->Serialize(aReadStreamOut, aRv);
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
-  mInner->Serialize(aReadStreamOut, aStreamCleanupList, aRv);
 }
 
 ReadStream::ReadStream(SafeRefPtr<ReadStream::Inner> aInner)

dom/cache/ReadStream.h

@@ -19,9 +19,6 @@
 namespace mozilla {
 class ErrorResult;
 
-namespace ipc {
-class AutoIPCStream;
-}  // namespace ipc
 namespace dom {
 namespace cache {
 
@@ -78,14 +75,8 @@ class ReadStream final : public nsIInputStream {
       PCacheStreamControlParent* aControl, const nsID& aId,
       nsIInputStream* aStream);
 
-  void Serialize(
+  void Serialize(Maybe<CacheReadStream>* aReadStreamOut, ErrorResult& aRv);
-      Maybe<CacheReadStream>* aReadStreamOut,
+  void Serialize(CacheReadStream* aReadStreamOut, ErrorResult& aRv);
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList,
-      ErrorResult& aRv);
-  void Serialize(
-      CacheReadStream* aReadStreamOut,
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList,
-      ErrorResult& aRv);
 
  private:
   class Inner;

dom/cache/StreamControl.h

@@ -15,9 +15,6 @@
 struct nsID;
 
 namespace mozilla {
-namespace ipc {
-class AutoIPCStream;
-}  // namespace ipc
 namespace dom {
 namespace cache {
 
@@ -31,9 +28,8 @@ class StreamControl {
   // abstract interface that must be implemented by child class
   virtual void SerializeControl(CacheReadStream* aReadStreamOut) = 0;
 
-  virtual void SerializeStream(
+  virtual void SerializeStream(CacheReadStream* aReadStreamOut,
-      CacheReadStream* aReadStreamOut, nsIInputStream* aStream,
+                               nsIInputStream* aStream) = 0;
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList) = 0;
 
   virtual void OpenStream(const nsID& aId, InputStreamResolver&& aResolver) = 0;
 

dom/cache/TypeUtils.cpp

@@ -33,7 +33,6 @@
 
 namespace mozilla::dom::cache {
 
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::BackgroundChild;
 using mozilla::ipc::FileDescriptor;
 using mozilla::ipc::PBackgroundChild;
@@ -111,10 +110,9 @@ SafeRefPtr<InternalRequest> TypeUtils::ToInternalRequest(
   return ToInternalRequest(aIn.GetAsUSVString(), aRv);
 }
 
-void TypeUtils::ToCacheRequest(
+void TypeUtils::ToCacheRequest(CacheRequest& aOut, const InternalRequest& aIn,
-    CacheRequest& aOut, const InternalRequest& aIn, BodyAction aBodyAction,
+                               BodyAction aBodyAction,
-    SchemeAction aSchemeAction,
+                               SchemeAction aSchemeAction, ErrorResult& aRv) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
   aIn.GetMethod(aOut.method());
   nsCString url(aIn.GetURLWithoutFragment());
   bool schemeValid;
@@ -159,7 +157,7 @@ void TypeUtils::ToCacheRequest(
 
   nsCOMPtr<nsIInputStream> stream;
   aIn.GetBody(getter_AddRefs(stream));
-  SerializeCacheStream(stream, &aOut.body(), aStreamCleanupList, aRv);
+  SerializeCacheStream(stream, &aOut.body(), aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
@@ -202,9 +200,8 @@ void TypeUtils::ToCacheResponseWithoutBody(CacheResponse& aOut,
   aOut.paddingSize() = aIn.GetPaddingSize();
 }
 
-void TypeUtils::ToCacheResponse(
+void TypeUtils::ToCacheResponse(JSContext* aCx, CacheResponse& aOut,
-    JSContext* aCx, CacheResponse& aOut, Response& aIn,
+                                Response& aIn, ErrorResult& aRv) {
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
   bool bodyUsed = aIn.GetBodyUsed(aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
@@ -229,7 +226,7 @@ void TypeUtils::ToCacheResponse(
     }
   }
 
-  SerializeCacheStream(stream, &aOut.body(), aStreamCleanupList, aRv);
+  SerializeCacheStream(stream, &aOut.body(), aRv);
   if (NS_WARN_IF(aRv.Failed())) {
     return;
   }
@@ -482,9 +479,9 @@ SafeRefPtr<InternalRequest> TypeUtils::ToInternalRequest(const nsAString& aIn,
   return request->GetInternalRequest();
 }
 
-void TypeUtils::SerializeCacheStream(
+void TypeUtils::SerializeCacheStream(nsIInputStream* aStream,
-    nsIInputStream* aStream, Maybe<CacheReadStream>* aStreamOut,
+                                     Maybe<CacheReadStream>* aStreamOut,
-    nsTArray<UniquePtr<AutoIPCStream>>& aStreamCleanupList, ErrorResult& aRv) {
+                                     ErrorResult& aRv) {
   *aStreamOut = Nothing();
   if (!aStream) {
     return;
@@ -492,7 +489,7 @@ void TypeUtils::SerializeCacheStream(
 
   RefPtr<ReadStream> controlled = do_QueryObject(aStream);
   if (controlled) {
-    controlled->Serialize(aStreamOut, aStreamCleanupList, aRv);
+    controlled->Serialize(aStreamOut, aRv);
     return;
   }
 
@@ -502,10 +499,9 @@ void TypeUtils::SerializeCacheStream(
   cacheStream.controlChild() = nullptr;
   cacheStream.controlParent() = nullptr;
 
-  UniquePtr<AutoIPCStream> autoStream(new AutoIPCStream(cacheStream.stream()));
+  MOZ_ALWAYS_TRUE(mozilla::ipc::SerializeIPCStream(do_AddRef(aStream),
-  autoStream->Serialize(aStream, GetIPCManager());
+                                                   cacheStream.stream(),
-
+                                                   /* aAllowLazy */ false));
-  aStreamCleanupList.AppendElement(std::move(autoStream));
 }
 
 }  // namespace mozilla::dom::cache

dom/cache/TypeUtils.h

@@ -21,7 +21,6 @@ namespace mozilla {
 
 namespace ipc {
 class PBackgroundChild;
-class AutoIPCStream;
 }  // namespace ipc
 
 namespace dom {
@@ -73,19 +72,15 @@ class TypeUtils {
       JSContext* aCx, const OwningRequestOrUSVString& aIn,
       BodyAction aBodyAction, ErrorResult& aRv);
 
-  void ToCacheRequest(
+  void ToCacheRequest(CacheRequest& aOut, const InternalRequest& aIn,
-      CacheRequest& aOut, const InternalRequest& aIn, BodyAction aBodyAction,
+                      BodyAction aBodyAction, SchemeAction aSchemeAction,
-      SchemeAction aSchemeAction,
+                      ErrorResult& aRv);
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList,
-      ErrorResult& aRv);
 
   void ToCacheResponseWithoutBody(CacheResponse& aOut, InternalResponse& aIn,
                                   ErrorResult& aRv);
 
-  void ToCacheResponse(
+  void ToCacheResponse(JSContext* aCx, CacheResponse& aOut, Response& aIn,
-      JSContext* aCx, CacheResponse& aOut, Response& aIn,
+                       ErrorResult& aRv);
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList,
-      ErrorResult& aRv);
 
   void ToCacheQueryParams(CacheQueryParams& aOut, const CacheQueryOptions& aIn);
 
@@ -128,10 +123,9 @@ class TypeUtils {
   SafeRefPtr<InternalRequest> ToInternalRequest(const nsAString& aIn,
                                                 ErrorResult& aRv);
 
-  void SerializeCacheStream(
+  void SerializeCacheStream(nsIInputStream* aStream,
-      nsIInputStream* aStream, Maybe<CacheReadStream>* aStreamOut,
+                            Maybe<CacheReadStream>* aStreamOut,
-      nsTArray<UniquePtr<mozilla::ipc::AutoIPCStream>>& aStreamCleanupList,
+                            ErrorResult& aRv);
-      ErrorResult& aRv);
 
   void SerializeSendStream(nsIInputStream* aStream,
                            CacheReadStream& aReadStreamOut, ErrorResult& aRv);

dom/fetch/InternalResponse.cpp

@@ -134,9 +134,7 @@ InternalResponseMetadata InternalResponse::GetMetadata() {
 
 void InternalResponse::ToChildToParentInternalResponse(
     ChildToParentInternalResponse* aIPCResponse,
-    mozilla::ipc::PBackgroundChild* aManager,
+    mozilla::ipc::PBackgroundChild* aManager) {
-    UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoBodyStream,
-    UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoAlternativeBodyStream) {
   *aIPCResponse = ChildToParentInternalResponse(GetMetadata(), Nothing(),
                                                 UNKNOWN_BODY_SIZE, Nothing());
 
@@ -148,9 +146,8 @@ void InternalResponse::ToChildToParentInternalResponse(
     aIPCResponse->body().emplace(ChildToParentStream());
     aIPCResponse->bodySize() = bodySize;
 
-    aAutoBodyStream.reset(
+    DebugOnly<bool> ok = mozilla::ipc::SerializeIPCStream(
-        new mozilla::ipc::AutoIPCStream(aIPCResponse->body()->stream()));
+        body.forget(), aIPCResponse->body()->stream(), /* aAllowLazy */ false);
-    DebugOnly<bool> ok = aAutoBodyStream->Serialize(body, aManager);
     MOZ_ASSERT(ok);
   }
 
@@ -158,10 +155,9 @@ void InternalResponse::ToChildToParentInternalResponse(
   if (alternativeBody) {
     aIPCResponse->alternativeBody().emplace(ChildToParentStream());
 
-    aAutoAlternativeBodyStream.reset(new mozilla::ipc::AutoIPCStream(
+    DebugOnly<bool> ok = mozilla::ipc::SerializeIPCStream(
-        aIPCResponse->alternativeBody()->stream()));
+        alternativeBody.forget(), aIPCResponse->alternativeBody()->stream(),
-    DebugOnly<bool> ok =
+        /* aAllowLazy */ false);
-        aAutoAlternativeBodyStream->Serialize(alternativeBody, aManager);
     MOZ_ASSERT(ok);
   }
 }

dom/fetch/InternalResponse.h

@@ -23,7 +23,6 @@
 
 namespace mozilla {
 namespace ipc {
-class AutoIPCStream;
 class PBackgroundChild;
 class PBackgroundParent;
 class PrincipalInfo;
@@ -52,12 +51,9 @@ class InternalResponse final : public AtomicSafeRefCounted<InternalResponse> {
   static SafeRefPtr<InternalResponse> FromIPC(
       const ParentToParentInternalResponse& aIPCResponse);
 
-  // Note: the AutoIPCStreams must outlive the ChildToParentInternalResponse.
   void ToChildToParentInternalResponse(
       ChildToParentInternalResponse* aIPCResponse,
-      mozilla::ipc::PBackgroundChild* aManager,
+      mozilla::ipc::PBackgroundChild* aManager);
-      UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoBodyStream,
-      UniquePtr<mozilla::ipc::AutoIPCStream>& aAutoAlternativeBodyStream);
 
   ParentToParentInternalResponse ToParentToParentInternalResponse();
 

dom/file/TemporaryFileBlobImpl.cpp

@@ -50,22 +50,12 @@ class TemporaryFileInputStream final : public nsFileInputStream {
     return NS_OK;
   }
 
-  void Serialize(InputStreamParams& aParams,
+  void Serialize(InputStreamParams& aParams, uint32_t aMaxSize,
-                 FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
+                 uint32_t* aSizeUsed) override {
-                 uint32_t aMaxSize, uint32_t* aSizeUsed,
-                 ParentToChildStreamActorManager* aManager) override {
     MOZ_CRASH("This inputStream cannot be serialized.");
   }
 
-  void Serialize(InputStreamParams& aParams,
+  bool Deserialize(const InputStreamParams& aParams) override {
-                 FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-                 uint32_t aMaxSize, uint32_t* aSizeUsed,
-                 ChildToParentStreamActorManager* aManager) override {
-    MOZ_CRASH("This inputStream cannot be serialized.");
-  }
-
-  bool Deserialize(const InputStreamParams& aParams,
-                   const FileDescriptorArray& aFileDescriptors) override {
     MOZ_CRASH("This inputStream cannot be deserialized.");
     return false;
   }

dom/file/ipc/IPCBlobUtils.cpp

@@ -136,12 +136,12 @@ nsresult SerializeInternal(BlobImpl* aBlobImpl, M* aManager,
     return NS_OK;
   }
 
-  mozilla::ipc::AutoIPCStream ipcStream(true /* delayed start */);
+  IPCStream stream;
-  if (!ipcStream.Serialize(inputStream, aManager)) {
+  if (!mozilla::ipc::SerializeIPCStream(inputStream.forget(), stream,
+                                        /* aAllowLazy */ true)) {
     return NS_ERROR_FAILURE;
   }
-
+  aIPCBlob.inputStream() = stream;
-  aIPCBlob.inputStream() = ipcStream.TakeValue();
   return NS_OK;
 }
 

dom/file/ipc/IPCBlobUtils.h

@@ -68,9 +68,8 @@
  * stream except for huge memory streams. In this case we end up using
  * DataPipe. See more information in IPCStreamUtils.h.
  *
- * In order to populate IPCStream correctly, we use AutoIPCStream as documented
+ * In order to populate IPCStream correctly, we use SerializeIPCStream as
- * in IPCStreamUtils.h. Note that we use the 'delayed start' feature because,
+ * documented in IPCStreamUtils.h.
- * often, the stream doesn't need to be read on the parent side.
  *
  * Parent to Child Blob Serialization
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

dom/file/ipc/RemoteLazyInputStream.cpp

@@ -885,27 +885,14 @@ void RemoteLazyInputStream::SerializedComplexity(uint32_t aMaxSize,
   *aTransferables = 1;
 }
 
-void RemoteLazyInputStream::Serialize(
+void RemoteLazyInputStream::Serialize(mozilla::ipc::InputStreamParams& aParams,
-    mozilla::ipc::InputStreamParams& aParams,
+                                      uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  *aSizeUsed = 0;
-  aParams = mozilla::ipc::RemoteLazyInputStreamParams(this);
-}
-
-void RemoteLazyInputStream::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
   *aSizeUsed = 0;
   aParams = mozilla::ipc::RemoteLazyInputStreamParams(this);
 }
 
 bool RemoteLazyInputStream::Deserialize(
-    const mozilla::ipc::InputStreamParams& aParams,
+    const mozilla::ipc::InputStreamParams& aParams) {
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_CRASH("This should never be called.");
   return false;
 }

dom/file/ipc/RemoteLazyInputStreamParent.cpp

@@ -66,41 +66,15 @@ mozilla::ipc::IPCResult RemoteLazyInputStreamParent::RecvStreamNeeded(
     return IPC_OK();
   }
 
-  // XXX: This should be much cleaner once the API for serializing IPCStream has
+  Maybe<IPCStream> ipcStream;
-  // been simplified.
+  if (NS_WARN_IF(!SerializeIPCStream(stream.forget(), ipcStream,
-  ipc::InputStreamParams params;
+                                     /* aAllowLazy */ false))) {
-  if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
+    return IPC_FAIL(this, "IPCStream serialization failed!");
-          do_QueryInterface(stream)) {
-    nsTArray<FileDescriptor> unused;
-    uint32_t sizeUsed = 0;
-    serializable->Serialize(
-        params, unused, false, 128 * 1024, &sizeUsed,
-        (mozilla::ipc::ParentToChildStreamActorManager*)nullptr);
-    MOZ_ASSERT(unused.IsEmpty());
-  } else {
-    RefPtr<ipc::DataPipeSender> sender;
-    RefPtr<ipc::DataPipeReceiver> receiver;
-    nsresult rv = NewDataPipe(ipc::kDefaultDataPipeCapacity,
-                              getter_AddRefs(sender), getter_AddRefs(receiver));
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return IPC_FAIL(this, "NewDataPipe failed");
-    }
-
-    nsCOMPtr<nsIEventTarget> target =
-        do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
-
-    rv = NS_AsyncCopy(stream, sender, target, NS_ASYNCCOPY_VIA_WRITESEGMENTS,
-                      ipc::kDefaultDataPipeCapacity, nullptr, nullptr);
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return IPC_FAIL(this, "NS_AsyncCopy failed");
-    }
-
-    params = ipc::DataPipeReceiverStreamParams(receiver);
   }
 
   MOZ_LOG(gRemoteLazyStreamLog, LogLevel::Verbose,
           ("Parent::RecvStreamNeeded resolve %s", nsIDToCString(mID).get()));
-  aResolver(Some(IPCStream(params)));
+  aResolver(ipcStream);
   return IPC_OK();
 }
 

dom/ipc/ContentChild.h

@@ -68,7 +68,6 @@ enum class CallerType : uint32_t;
 class ContentChild final : public PContentChild,
                            public nsIDOMProcessChild,
                            public mozilla::ipc::IShmemAllocator,
-                           public mozilla::ipc::ChildToParentStreamActorManager,
                            public ProcessActor {
   using ClonedMessageData = mozilla::dom::ClonedMessageData;
   using FileDescriptor = mozilla::ipc::FileDescriptor;

dom/ipc/ContentParent.h

@@ -105,22 +105,20 @@ struct CancelContentJSOptions;
     }                                                \
   }
 
-class ContentParent final
+class ContentParent final : public PContentParent,
-    : public PContentParent,
+                            public nsIDOMProcessParent,
-      public nsIDOMProcessParent,
+                            public nsIObserver,
-      public nsIObserver,
+                            public nsIDOMGeoPositionCallback,
-      public nsIDOMGeoPositionCallback,
+                            public nsIDOMGeoPositionErrorCallback,
-      public nsIDOMGeoPositionErrorCallback,
+                            public nsIAsyncShutdownBlocker,
-      public nsIAsyncShutdownBlocker,
+                            public nsIInterfaceRequestor,
-      public nsIInterfaceRequestor,
+                            public gfx::gfxVarReceiver,
-      public gfx::gfxVarReceiver,
+                            public mozilla::LinkedListElement<ContentParent>,
-      public mozilla::LinkedListElement<ContentParent>,
+                            public gfx::GPUProcessListener,
-      public gfx::GPUProcessListener,
+                            public mozilla::MemoryReportingProcess,
-      public mozilla::MemoryReportingProcess,
+                            public mozilla::dom::ipc::MessageManagerCallback,
-      public mozilla::dom::ipc::MessageManagerCallback,
+                            public mozilla::ipc::IShmemAllocator,
-      public mozilla::ipc::IShmemAllocator,
+                            public ProcessActor {
-      public mozilla::ipc::ParentToChildStreamActorManager,
-      public ProcessActor {
   typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost;
   typedef mozilla::ipc::TestShellParent TestShellParent;
   typedef mozilla::ipc::PrincipalInfo PrincipalInfo;

dom/ipc/StructuredCloneData.cpp

@@ -25,7 +25,6 @@ using namespace mozilla::ipc;
 
 namespace mozilla::dom::ipc {
 
-using mozilla::ipc::AutoIPCStream;
 using mozilla::ipc::IPCStream;
 using mozilla::ipc::PBackgroundChild;
 using mozilla::ipc::PBackgroundParent;
@@ -62,7 +61,6 @@ StructuredCloneData& StructuredCloneData::operator=(
   mBlobImplArray = std::move(aOther.mBlobImplArray);
   mExternalData = std::move(aOther.mExternalData);
   mSharedData = std::move(aOther.mSharedData);
-  mIPCStreams = std::move(aOther.mIPCStreams);
   mInitialized = aOther.mInitialized;
 
   return *this;
@@ -181,24 +179,16 @@ bool BuildClonedMessageData(M* aManager, StructuredCloneData& aData,
 
   const nsTArray<nsCOMPtr<nsIInputStream>>& inputStreams = aData.InputStreams();
   if (!inputStreams.IsEmpty()) {
-    if (NS_WARN_IF(
-            !aData.IPCStreams().SetCapacity(inputStreams.Length(), fallible))) {
-      return false;
-    }
-
     nsTArray<IPCStream>& streams = aClonedData.inputStreams();
     uint32_t length = inputStreams.Length();
     streams.SetCapacity(length);
     for (uint32_t i = 0; i < length; ++i) {
-      AutoIPCStream* stream = aData.IPCStreams().AppendElement(fallible);
+      IPCStream value;
-      if (NS_WARN_IF(!stream)) {
+      if (!mozilla::ipc::SerializeIPCStream(do_AddRef(inputStreams[i]), value,
+                                            /* aAllowLazy */ false)) {
         return false;
       }
-
+      streams.AppendElement(value);
-      if (!stream->Serialize(inputStreams[i], aManager)) {
-        return false;
-      }
-      streams.AppendElement(stream->TakeValue());
     }
   }
 

dom/ipc/StructuredCloneData.h

@@ -23,7 +23,6 @@ class PickleIterator;
 namespace mozilla {
 namespace ipc {
 
-class AutoIPCStream;
 class PBackgroundChild;
 class PBackgroundParent;
 
@@ -275,10 +274,6 @@ class StructuredCloneData : public StructuredCloneHolder {
 
   bool SupportsTransferring() { return mSupportsTransferring; }
 
-  FallibleTArray<mozilla::ipc::AutoIPCStream>& IPCStreams() {
-    return mIPCStreams;
-  }
-
   // For IPC serialization
   void WriteIPCParams(IPC::MessageWriter* aWriter) const;
   bool ReadIPCParams(IPC::MessageReader* aReader);
@@ -290,9 +285,6 @@ class StructuredCloneData : public StructuredCloneHolder {
   JSStructuredCloneData mExternalData;
   RefPtr<SharedJSAllocatedData> mSharedData;
 
-  // This array is needed because AutoIPCStream DTOR must be executed after the
-  // sending of the data via IPC. This will be fixed by bug 1353475.
-  FallibleTArray<mozilla::ipc::AutoIPCStream> mIPCStreams;
   bool mInitialized;
 };
 

dom/network/UDPSocketChild.cpp

@@ -142,13 +142,15 @@ nsresult UDPSocketChild::SendBinaryStream(const nsACString& aHost,
                                           nsIInputStream* aStream) {
   NS_ENSURE_ARG(aStream);
 
-  mozilla::ipc::AutoIPCStream autoStream;
+  mozilla::ipc::IPCStream stream;
-  autoStream.Serialize(aStream, static_cast<mozilla::dom::ContentChild*>(
+  if (NS_WARN_IF(!mozilla::ipc::SerializeIPCStream(do_AddRef(aStream), stream,
-                                    gNeckoChild->Manager()));
+                                                   /* aAllowLazy */ false))) {
+    return NS_ERROR_UNEXPECTED;
+  }
 
   UDPSOCKET_LOG(
       ("%s: %s:%u", __FUNCTION__, PromiseFlatCString(aHost).get(), aPort));
-  SendOutgoingData(UDPData(autoStream.TakeValue()),
+  SendOutgoingData(UDPData(stream),
                    UDPSocketAddr(UDPAddressInfo(nsCString(aHost), aPort)));
 
   return NS_OK;

dom/quota/DecryptingInputStream.cpp

@@ -86,14 +86,6 @@ void DecryptingInputStreamBase::SerializedComplexity(uint32_t aMaxSize,
       ->SerializedComplexity(aMaxSize, aSizeUsed, aPipes, aTransferables);
 }
 
-void DecryptingInputStreamBase::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  MOZ_CRASH("Not implemented");
-}
-
 size_t DecryptingInputStreamBase::PlainLength() const {
   MOZ_ASSERT(mNextByte <= mPlainBytes);
   return mPlainBytes - mNextByte;

dom/quota/DecryptingInputStream.h

@@ -28,11 +28,6 @@
 #include "nsTArray.h"
 #include "nscore.h"
 
-namespace mozilla::ipc {
-class ChildToParentStreamActorManager;
-class ParentToChildStreamActorManager;
-}  // namespace mozilla::ipc
-
 template <class T>
 class nsCOMPtr;
 
@@ -57,12 +52,6 @@ class DecryptingInputStreamBase : public nsIInputStream,
                             uint32_t* aPipes,
                             uint32_t* aTransferables) override;
 
-  using nsIIPCSerializableInputStream::Serialize;
-  void Serialize(mozilla::ipc::InputStreamParams& aParams,
-                 FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-                 uint32_t aMaxSize, uint32_t* aSizeUsed,
-                 mozilla::ipc::ChildToParentStreamActorManager* aManager) final;
-
  protected:
   DecryptingInputStreamBase(MovingNotNull<nsCOMPtr<nsIInputStream>> aBaseStream,
                             size_t aBlockSize);
@@ -127,15 +116,10 @@ class DecryptingInputStream final : public DecryptingInputStreamBase {
 
   NS_IMETHOD Clone(nsIInputStream** _retval) override;
 
-  using DecryptingInputStreamBase::Serialize;
+  void Serialize(mozilla::ipc::InputStreamParams& aParams, uint32_t aMaxSize,
-  void Serialize(
+                 uint32_t* aSizeUsed) override;
-      mozilla::ipc::InputStreamParams& aParams,
-      FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-      uint32_t aMaxSize, uint32_t* aSizeUsed,
-      mozilla::ipc::ParentToChildStreamActorManager* aManager) override;
 
-  bool Deserialize(const mozilla::ipc::InputStreamParams& aParams,
+  bool Deserialize(const mozilla::ipc::InputStreamParams& aParams) override;
-                   const FileDescriptorArray& aFileDescriptors) override;
 
  private:
   ~DecryptingInputStream();

dom/quota/DecryptingInputStream_impl.h

@@ -464,17 +464,14 @@ NS_IMETHODIMP DecryptingInputStream<CipherStrategy>::Clone(
 
 template <typename CipherStrategy>
 void DecryptingInputStream<CipherStrategy>::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
+    mozilla::ipc::InputStreamParams& aParams, uint32_t aMaxSize,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
+    uint32_t* aSizeUsed) {
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
   MOZ_ASSERT(mBaseStream);
   MOZ_ASSERT(mBaseIPCSerializableInputStream);
 
   mozilla::ipc::InputStreamParams baseStreamParams;
   (*mBaseIPCSerializableInputStream)
-      ->Serialize(baseStreamParams, aFileDescriptors, aDelayedStart, aMaxSize,
+      ->Serialize(baseStreamParams, aMaxSize, aSizeUsed);
-                  aSizeUsed, aManager);
 
   MOZ_ASSERT(baseStreamParams.type() ==
              mozilla::ipc::InputStreamParams::TFileInputStreamParams);
@@ -491,8 +488,7 @@ void DecryptingInputStream<CipherStrategy>::Serialize(
 
 template <typename CipherStrategy>
 bool DecryptingInputStream<CipherStrategy>::Deserialize(
-    const mozilla::ipc::InputStreamParams& aParams,
+    const mozilla::ipc::InputStreamParams& aParams) {
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_ASSERT(aParams.type() ==
              mozilla::ipc::InputStreamParams::TEncryptedFileInputStreamParams);
   const auto& params = aParams.get_EncryptedFileInputStreamParams();
@@ -503,8 +499,8 @@ bool DecryptingInputStream<CipherStrategy>::Deserialize(
   nsCOMPtr<nsIIPCSerializableInputStream> baseSerializable =
       do_QueryInterface(stream);
 
-  if (NS_WARN_IF(!baseSerializable->Deserialize(params.fileInputStreamParams(),
+  if (NS_WARN_IF(
-                                                aFileDescriptors))) {
+          !baseSerializable->Deserialize(params.fileInputStreamParams()))) {
     return false;
   }
 

dom/serviceworkers/FetchEventOpProxyChild.cpp

@@ -37,8 +37,7 @@ namespace {
 
 nsresult GetIPCSynthesizeResponseArgs(
     ChildToParentSynthesizeResponseArgs* aIPCArgs,
-    SynthesizeResponseArgs&& aArgs, UniquePtr<AutoIPCStream>& aAutoBodyStream,
+    SynthesizeResponseArgs&& aArgs) {
-    UniquePtr<AutoIPCStream>& aAutoAlternativeBodyStream) {
   MOZ_ASSERT(RemoteWorkerService::Thread()->IsOnCurrentThread());
 
   SafeRefPtr<InternalResponse> internalResponse;
@@ -56,8 +55,7 @@ nsresult GetIPCSynthesizeResponseArgs(
   }
 
   internalResponse->ToChildToParentInternalResponse(
-      &aIPCArgs->internalResponse(), bgChild, aAutoBodyStream,
+      &aIPCArgs->internalResponse(), bgChild);
-      aAutoAlternativeBodyStream);
   return NS_OK;
 }
 
@@ -135,13 +133,8 @@ void FetchEventOpProxyChild::Initialize(
 
                if (result.is<SynthesizeResponseArgs>()) {
                  ChildToParentSynthesizeResponseArgs ipcArgs;
-                 UniquePtr<AutoIPCStream> autoBodyStream =
-                     MakeUnique<AutoIPCStream>();
-                 UniquePtr<AutoIPCStream> autoAlternativeBodyStream =
-                     MakeUnique<AutoIPCStream>();
                  nsresult rv = GetIPCSynthesizeResponseArgs(
-                     &ipcArgs, result.extract<SynthesizeResponseArgs>(),
+                     &ipcArgs, result.extract<SynthesizeResponseArgs>());
-                     autoBodyStream, autoAlternativeBodyStream);
 
                  if (NS_WARN_IF(NS_FAILED(rv))) {
                    Unused << self->SendRespondWith(
@@ -150,14 +143,6 @@ void FetchEventOpProxyChild::Initialize(
                  }
 
                  Unused << self->SendRespondWith(ipcArgs);
-
-                 if (ipcArgs.internalResponse().body()) {
-                   autoBodyStream->TakeValue();
-                 }
-
-                 if (ipcArgs.internalResponse().alternativeBody()) {
-                   autoAlternativeBodyStream->TakeValue();
-                 }
                } else if (result.is<ResetInterceptionArgs>()) {
                  Unused << self->SendRespondWith(
                      result.extract<ResetInterceptionArgs>());

dom/webbrowserpersist/WebBrowserPersistDocumentChild.cpp

@@ -76,12 +76,12 @@ void WebBrowserPersistDocumentChild::Start(
   ENSURE(aDocument->GetPostData(getter_AddRefs(postDataStream)));
 #undef ENSURE
 
-  mozilla::ipc::AutoIPCStream autoStream;
+  Maybe<mozilla::ipc::IPCStream> stream;
-  autoStream.Serialize(postDataStream,
+  mozilla::ipc::SerializeIPCStream(postDataStream.forget(), stream,
-                       static_cast<mozilla::dom::ContentChild*>(Manager()));
+                                   /* aAllowLazy */ false);
 
   mDocument = aDocument;
-  SendAttributes(attrs, autoStream.TakeOptionalValue());
+  SendAttributes(attrs, stream);
 }
 
 mozilla::ipc::IPCResult WebBrowserPersistDocumentChild::RecvSetPersistFlags(

ipc/glue/BackgroundChildImpl.h

@@ -29,8 +29,7 @@ namespace ipc {
 
 // Instances of this class should never be created directly. This class is meant
 // to be inherited in BackgroundImpl.
-class BackgroundChildImpl : public PBackgroundChild,
+class BackgroundChildImpl : public PBackgroundChild {
-                            public ChildToParentStreamActorManager {
  public:
   class ThreadLocal;
 

ipc/glue/BackgroundParentImpl.h

@@ -15,8 +15,7 @@ namespace mozilla::ipc {
 
 // Instances of this class should never be created directly. This class is meant
 // to be inherited in BackgroundImpl.
-class BackgroundParentImpl : public PBackgroundParent,
+class BackgroundParentImpl : public PBackgroundParent {
-                             public ParentToChildStreamActorManager {
  protected:
   BackgroundParentImpl();
   virtual ~BackgroundParentImpl();

ipc/glue/DataPipe.cpp

@@ -663,27 +663,13 @@ void DataPipeReceiver::SerializedComplexity(uint32_t aMaxSize,
   *aTransferables = 1;
 }
 
-void DataPipeReceiver::Serialize(InputStreamParams& aParams,
+void DataPipeReceiver::Serialize(InputStreamParams& aParams, uint32_t aMaxSize,
-                                 FileDescriptorArray& aFileDescriptors,
+                                 uint32_t* aSizeUsed) {
-                                 bool aDelayedStart, uint32_t aMaxSize,
-                                 uint32_t* aSizeUsed,
-                                 ParentToChildStreamActorManager* aManager) {
   *aSizeUsed = 0;
   aParams = DataPipeReceiverStreamParams(this);
 }
 
-void DataPipeReceiver::Serialize(InputStreamParams& aParams,
+bool DataPipeReceiver::Deserialize(const InputStreamParams& aParams) {
-                                 FileDescriptorArray& aFileDescriptors,
-                                 bool aDelayedStart, uint32_t aMaxSize,
-                                 uint32_t* aSizeUsed,
-                                 ChildToParentStreamActorManager* aManager) {
-  *aSizeUsed = 0;
-  aParams = DataPipeReceiverStreamParams(this);
-}
-
-bool DataPipeReceiver::Deserialize(
-    const InputStreamParams& aParams,
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_CRASH("Handled directly in `DeserializeInputStream`");
 }
 

ipc/glue/IPCStream.ipdlh

@@ -9,7 +9,10 @@ namespace mozilla {
 namespace ipc {
 
 // Use IPCStream in your ipdl to represent serialized nsIInputStreams. Then use
-// AutoIPCStream from IPCStreamUtils.h to perform the serialization.
+// SerializeIPCStream from IPCStreamUtils.h to perform the serialization.
+//
+// NOTE: If you don't need to handle nsIInputStream serialization failure,
+// `nsIInputStream` may be used directly by IPDL protocols.
 struct IPCStream
 {
   InputStreamParams stream;

ipc/glue/IPCStreamUtils.cpp

@@ -6,107 +6,28 @@
 
 #include "IPCStreamUtils.h"
 
+#include "ipc/IPCMessageUtilsSpecializations.h"
+
 #include "nsIHttpHeaderVisitor.h"
 #include "nsIIPCSerializableInputStream.h"
 #include "mozIRemoteLazyInputStream.h"
 
 #include "mozilla/Assertions.h"
-#include "mozilla/dom/ContentChild.h"
-#include "mozilla/dom/ContentParent.h"
 #include "mozilla/dom/File.h"
+#include "mozilla/ipc/IPCStream.h"
 #include "mozilla/ipc/InputStreamUtils.h"
-#include "mozilla/net/SocketProcessChild.h"
-#include "mozilla/net/SocketProcessParent.h"
 #include "mozilla/InputStreamLengthHelper.h"
 #include "mozilla/RemoteLazyInputStreamParent.h"
 #include "mozilla/Unused.h"
 #include "nsIMIMEInputStream.h"
 #include "nsNetCID.h"
-#include "BackgroundParentImpl.h"
-#include "BackgroundChildImpl.h"
 
 using namespace mozilla::dom;
 
-namespace mozilla {
+namespace mozilla::ipc {
-namespace ipc {
 
 namespace {
 
-// These serialization and cleanup functions could be externally exposed.  For
-// now, though, keep them private to encourage use of the safer RAII
-// AutoIPCStream class.
-
-template <typename M>
-bool SerializeInputStreamWithFdsChild(nsIIPCSerializableInputStream* aStream,
-                                      IPCStream& aValue, bool aDelayedStart,
-                                      M* aManager) {
-  MOZ_RELEASE_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
-
-  // If you change this size, please also update the payload size in
-  // test_reload_large_postdata.html.
-  const uint64_t kTooLargeStream = 1024 * 1024;
-
-  uint32_t sizeUsed = 0;
-  AutoTArray<FileDescriptor, 4> fds;
-  aStream->Serialize(aValue.stream(), fds, aDelayedStart, kTooLargeStream,
-                     &sizeUsed, aManager);
-
-  MOZ_ASSERT(sizeUsed <= kTooLargeStream);
-
-  if (aValue.stream().type() == InputStreamParams::T__None) {
-    MOZ_CRASH("Serialize failed!");
-  }
-
-  MOZ_ASSERT(fds.IsEmpty(), "argument is unused");
-
-  return true;
-}
-
-template <typename M>
-bool SerializeInputStreamWithFdsParent(nsIIPCSerializableInputStream* aStream,
-                                       IPCStream& aValue, bool aDelayedStart,
-                                       M* aManager) {
-  MOZ_RELEASE_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
-
-  const uint64_t kTooLargeStream = 1024 * 1024;
-
-  uint32_t sizeUsed = 0;
-  AutoTArray<FileDescriptor, 4> fds;
-  aStream->Serialize(aValue.stream(), fds, aDelayedStart, kTooLargeStream,
-                     &sizeUsed, aManager);
-
-  MOZ_ASSERT(sizeUsed <= kTooLargeStream);
-
-  if (aValue.stream().type() == InputStreamParams::T__None) {
-    MOZ_CRASH("Serialize failed!");
-  }
-
-  MOZ_ASSERT(fds.IsEmpty(), "argument is unused");
-
-  return true;
-}
-
-template <typename M>
-bool SerializeInputStream(nsIInputStream* aStream, IPCStream& aValue,
-                          M* aManager, bool aDelayedStart) {
-  MOZ_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
-
-  InputStreamParams params;
-  InputStreamHelper::SerializeInputStreamAsPipe(aStream, params, aDelayedStart,
-                                                aManager);
-
-  if (params.type() == InputStreamParams::T__None) {
-    return false;
-  }
-
-  aValue.stream() = params;
-
-  return true;
-}
-
 class MIMEStreamHeaderVisitor final : public nsIHttpHeaderVisitor {
  public:
   explicit MIMEStreamHeaderVisitor(
@@ -130,11 +51,9 @@ class MIMEStreamHeaderVisitor final : public nsIHttpHeaderVisitor {
 
 NS_IMPL_ISUPPORTS(MIMEStreamHeaderVisitor, nsIHttpHeaderVisitor)
 
-template <typename M>
+static bool SerializeLazyInputStream(nsIInputStream* aStream,
-bool SerializeLazyInputStream(nsIInputStream* aStream, IPCStream& aValue,
+                                     IPCStream& aValue) {
-                              M* aManager) {
   MOZ_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
   MOZ_ASSERT(XRE_IsParentProcess());
 
   // If we're serializing a MIME stream, ensure we preserve header data which
@@ -155,7 +74,7 @@ bool SerializeLazyInputStream(nsIInputStream* aStream, IPCStream& aValue,
     }
     if (dataStream) {
       IPCStream data;
-      if (!SerializeLazyInputStream(dataStream, data, aManager)) {
+      if (!SerializeLazyInputStream(dataStream, data)) {
         return false;
       }
       params.optionalStream().emplace(std::move(data.stream()));
@@ -176,99 +95,66 @@ bool SerializeLazyInputStream(nsIInputStream* aStream, IPCStream& aValue,
   return true;
 }
 
-template <typename M>
+}  // anonymous namespace
-bool SerializeInputStreamChild(nsIInputStream* aStream, M* aManager,
-                               IPCStream* aValue,
-                               Maybe<IPCStream>* aOptionalValue,
-                               bool aDelayedStart) {
-  MOZ_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(aValue || aOptionalValue);
 
-  nsCOMPtr<nsIIPCSerializableInputStream> serializable =
+bool SerializeIPCStream(already_AddRefed<nsIInputStream> aInputStream,
-      do_QueryInterface(aStream);
+                        IPCStream& aValue, bool aAllowLazy) {
-
+  nsCOMPtr<nsIInputStream> stream(std::move(aInputStream));
-  if (serializable) {
+  if (!stream) {
-    if (aValue) {
+    MOZ_ASSERT_UNREACHABLE(
-      return SerializeInputStreamWithFdsChild(serializable, *aValue,
+        "Use the Maybe<...> overload to serialize optional nsIInputStreams");
-                                              aDelayedStart, aManager);
-    }
-
-    return SerializeInputStreamWithFdsChild(serializable, aOptionalValue->ref(),
-                                            aDelayedStart, aManager);
-  }
-
-  if (aValue) {
-    return SerializeInputStream(aStream, *aValue, aManager, aDelayedStart);
-  }
-
-  return SerializeInputStream(aStream, aOptionalValue->ref(), aManager,
-                              aDelayedStart);
-}
-
-template <typename M>
-bool SerializeInputStreamParent(nsIInputStream* aStream, M* aManager,
-                                IPCStream* aValue,
-                                Maybe<IPCStream>* aOptionalValue,
-                                bool aDelayedStart) {
-  MOZ_ASSERT(aStream);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(aValue || aOptionalValue);
-
-  // When requesting a delayed start stream from the parent process, serialize
-  // it as a remote lazy stream to avoid bloating payloads.
-  if (aDelayedStart && XRE_IsParentProcess()) {
-    if (aValue) {
-      return SerializeLazyInputStream(aStream, *aValue, aManager);
-    }
-
-    return SerializeLazyInputStream(aStream, aOptionalValue->ref(), aManager);
-  }
-
-  nsCOMPtr<nsIIPCSerializableInputStream> serializable =
-      do_QueryInterface(aStream);
-
-  if (serializable) {
-    if (aValue) {
-      return SerializeInputStreamWithFdsParent(serializable, *aValue,
-                                               aDelayedStart, aManager);
-    }
-
-    return SerializeInputStreamWithFdsParent(
-        serializable, aOptionalValue->ref(), aDelayedStart, aManager);
-  }
-
-  if (aValue) {
-    return SerializeInputStream(aStream, *aValue, aManager, aDelayedStart);
-  }
-
-  return SerializeInputStream(aStream, aOptionalValue->ref(), aManager,
-                              aDelayedStart);
-}
-
-// Returns false if the serialization should not proceed. This means that the
-// inputStream is null.
-bool NormalizeOptionalValue(nsIInputStream* aStream, IPCStream* aValue,
-                            Maybe<IPCStream>* aOptionalValue) {
-  if (aValue) {
-    // if aStream is null, we will crash when serializing.
-    return true;
-  }
-
-  if (!aStream) {
-    aOptionalValue->reset();
     return false;
   }
 
-  aOptionalValue->emplace();
+  // When requesting a delayed start stream from the parent process, serialize
+  // it as a remote lazy stream to avoid bloating payloads.
+  if (aAllowLazy && XRE_IsParentProcess()) {
+    return SerializeLazyInputStream(stream, aValue);
+  }
+
+  if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
+          do_QueryInterface(stream)) {
+    // If you change this size, please also update the payload size in
+    // test_reload_large_postdata.html.
+    const uint64_t kTooLargeStream = 1024 * 1024;
+
+    uint32_t sizeUsed = 0;
+    serializable->Serialize(aValue.stream(), kTooLargeStream, &sizeUsed);
+
+    MOZ_ASSERT(sizeUsed <= kTooLargeStream);
+
+    if (aValue.stream().type() == InputStreamParams::T__None) {
+      MOZ_CRASH("Serialize failed!");
+    }
+    return true;
+  }
+
+  InputStreamHelper::SerializeInputStreamAsPipe(stream, aValue.stream());
+  if (aValue.stream().type() == InputStreamParams::T__None) {
+    MOZ_ASSERT_UNREACHABLE("Serializing as a pipe failed");
+    return false;
+  }
   return true;
 }
 
-}  // anonymous namespace
+bool SerializeIPCStream(already_AddRefed<nsIInputStream> aInputStream,
+                        Maybe<IPCStream>& aValue, bool aAllowLazy) {
+  nsCOMPtr<nsIInputStream> stream(std::move(aInputStream));
+  if (!stream) {
+    aValue.reset();
+    return true;
+  }
+
+  IPCStream value;
+  if (SerializeIPCStream(stream.forget(), value, aAllowLazy)) {
+    aValue = Some(value);
+    return true;
+  }
+  return false;
+}
 
 already_AddRefed<nsIInputStream> DeserializeIPCStream(const IPCStream& aValue) {
-  nsTArray<FileDescriptor> fds;  // NOTE: Unused, should be removed.
+  return InputStreamHelper::DeserializeInputStream(aValue.stream());
-  return InputStreamHelper::DeserializeInputStream(aValue.stream(), fds);
 }
 
 already_AddRefed<nsIInputStream> DeserializeIPCStream(
@@ -280,250 +166,26 @@ already_AddRefed<nsIInputStream> DeserializeIPCStream(
   return DeserializeIPCStream(aValue.ref());
 }
 
-AutoIPCStream::AutoIPCStream(bool aDelayedStart)
+}  // namespace mozilla::ipc
-    : mOptionalValue(&mInlineValue), mDelayedStart(aDelayedStart) {}
 
-AutoIPCStream::AutoIPCStream(IPCStream& aTarget, bool aDelayedStart)
+void IPC::ParamTraits<nsIInputStream*>::Write(IPC::MessageWriter* aWriter,
-    : mValue(&aTarget), mDelayedStart(aDelayedStart) {}
+                                              nsIInputStream* aParam) {
+  mozilla::Maybe<mozilla::ipc::IPCStream> stream;
+  if (!mozilla::ipc::SerializeIPCStream(do_AddRef(aParam), stream,
+                                        /* aAllowLazy */ true)) {
+    MOZ_CRASH("Failed to serialize nsIInputStream");
+  }
 
-AutoIPCStream::AutoIPCStream(Maybe<IPCStream>& aTarget, bool aDelayedStart)
+  WriteParam(aWriter, stream);
-    : mOptionalValue(&aTarget), mDelayedStart(aDelayedStart) {
-  mOptionalValue->reset();
 }
 
-AutoIPCStream::~AutoIPCStream() { MOZ_ASSERT(mValue || mOptionalValue); }
+bool IPC::ParamTraits<nsIInputStream*>::Read(IPC::MessageReader* aReader,
-
+                                             RefPtr<nsIInputStream>* aResult) {
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              dom::ContentChild* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  if (!SerializeInputStreamChild(aStream, aManager, mValue, mOptionalValue,
-                                 mDelayedStart)) {
-    MOZ_CRASH("IPCStream creation failed!");
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              PBackgroundChild* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  BackgroundChildImpl* impl = static_cast<BackgroundChildImpl*>(aManager);
-  if (!SerializeInputStreamChild(aStream, impl, mValue, mOptionalValue,
-                                 mDelayedStart)) {
-    MOZ_CRASH("IPCStream creation failed!");
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              net::SocketProcessChild* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  if (!SerializeInputStreamChild(aStream, aManager, mValue, mOptionalValue,
-                                 mDelayedStart)) {
-    MOZ_CRASH("IPCStream creation failed!");
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              dom::ContentParent* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  if (!SerializeInputStreamParent(aStream, aManager, mValue, mOptionalValue,
-                                  mDelayedStart)) {
-    return false;
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              PBackgroundParent* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  BackgroundParentImpl* impl = static_cast<BackgroundParentImpl*>(aManager);
-  if (!SerializeInputStreamParent(aStream, impl, mValue, mOptionalValue,
-                                  mDelayedStart)) {
-    return false;
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::Serialize(nsIInputStream* aStream,
-                              net::SocketProcessParent* aManager) {
-  MOZ_ASSERT(aStream || !mValue);
-  MOZ_ASSERT(aManager);
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!IsSet());
-
-  // If NormalizeOptionalValue returns false, we don't have to proceed.
-  if (!NormalizeOptionalValue(aStream, mValue, mOptionalValue)) {
-    return true;
-  }
-
-  if (!SerializeInputStreamParent(aStream, aManager, mValue, mOptionalValue,
-                                  mDelayedStart)) {
-    return false;
-  }
-
-  return true;
-}
-
-bool AutoIPCStream::IsSet() const {
-  MOZ_ASSERT(mValue || mOptionalValue);
-  if (mValue) {
-    return mValue->stream().type() != InputStreamParams::T__None;
-  } else {
-    return mOptionalValue->isSome() &&
-           mOptionalValue->ref().stream().type() != InputStreamParams::T__None;
-  }
-}
-
-IPCStream& AutoIPCStream::TakeValue() {
-  MOZ_ASSERT(mValue || mOptionalValue);
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(IsSet());
-
-  mTaken = true;
-
-  if (mValue) {
-    return *mValue;
-  }
-
-  IPCStream& value = mOptionalValue->ref();
-  return value;
-}
-
-Maybe<IPCStream>& AutoIPCStream::TakeOptionalValue() {
-  MOZ_ASSERT(!mTaken);
-  MOZ_ASSERT(!mValue);
-  MOZ_ASSERT(mOptionalValue);
-  mTaken = true;
-  return *mOptionalValue;
-}
-
-void IPDLParamTraits<nsIInputStream*>::Write(IPC::MessageWriter* aWriter,
-                                             IProtocol* aActor,
-                                             nsIInputStream* aParam) {
-  auto autoStream = MakeRefPtr<HoldIPCStream>(/* aDelayedStart */ true);
-
-  bool ok = false;
-  bool found = false;
-
-  // We can only serialize our nsIInputStream if it's going to be sent over one
-  // of the protocols we support, or a protocol which is managed by one of the
-  // protocols we support.
-  IProtocol* actor = aActor;
-  while (!found && actor) {
-    switch (actor->GetProtocolId()) {
-      case PContentMsgStart:
-        if (actor->GetSide() == mozilla::ipc::ParentSide) {
-          ok = autoStream->Serialize(
-              aParam, static_cast<mozilla::dom::ContentParent*>(actor));
-        } else {
-          MOZ_RELEASE_ASSERT(actor->GetSide() == mozilla::ipc::ChildSide);
-          ok = autoStream->Serialize(
-              aParam, static_cast<mozilla::dom::ContentChild*>(actor));
-        }
-        found = true;
-        break;
-      case PBackgroundMsgStart:
-        if (actor->GetSide() == mozilla::ipc::ParentSide) {
-          ok = autoStream->Serialize(
-              aParam, static_cast<mozilla::ipc::PBackgroundParent*>(actor));
-        } else {
-          MOZ_RELEASE_ASSERT(actor->GetSide() == mozilla::ipc::ChildSide);
-          ok = autoStream->Serialize(
-              aParam, static_cast<mozilla::ipc::PBackgroundChild*>(actor));
-        }
-        found = true;
-        break;
-      default:
-        break;
-    }
-
-    // Try the actor's manager.
-    actor = actor->Manager();
-  }
-
-  if (!found) {
-    aActor->FatalError(
-        "Attempt to send nsIInputStream over an unsupported ipdl protocol");
-  }
-  MOZ_RELEASE_ASSERT(ok, "Failed to serialize nsIInputStream");
-
-  WriteIPDLParam(aWriter, aActor, autoStream->TakeOptionalValue());
-
-  // Dispatch the autoStream to an async runnable, so that we guarantee it
-  // outlives this callstack, and doesn't shut down any actors we created
-  // until after we've finished sending the current message.
-  NS_ProxyRelease("IPDLParamTraits<nsIInputStream*>::Write::autoStream",
-                  NS_GetCurrentThread(), autoStream.forget(), true);
-}
-
-bool IPDLParamTraits<nsIInputStream*>::Read(IPC::MessageReader* aReader,
-                                            IProtocol* aActor,
-                                            RefPtr<nsIInputStream>* aResult) {
   mozilla::Maybe<mozilla::ipc::IPCStream> ipcStream;
-  if (!ReadIPDLParam(aReader, aActor, &ipcStream)) {
+  if (!ReadParam(aReader, &ipcStream)) {
     return false;
   }
 
   *aResult = mozilla::ipc::DeserializeIPCStream(ipcStream);
   return true;
 }
-
-}  // namespace ipc
-}  // namespace mozilla

ipc/glue/IPCStreamUtils.h

@@ -11,22 +11,23 @@
 #include "nsCOMPtr.h"
 #include "nsIInputStream.h"
 
-namespace mozilla {
+namespace mozilla::ipc {
 
-namespace dom {
+// Serialize an IPCStream to be sent over IPC fallibly.
-class ContentChild;
+//
-class ContentParent;
+// If |aAllowLazy| is true the stream may be serialized as a
-}  // namespace dom
+// RemoteLazyInputStream when being sent from child to parent.
+//
+// ParamTraits<nsIInputStream> may be used instead if serialization cannot be
+// fallible.
+[[nodiscard]] bool SerializeIPCStream(
+    already_AddRefed<nsIInputStream> aInputStream, IPCStream& aValue,
+    bool aAllowLazy);
 
-namespace net {
+// If serialization fails, `aValue` will be initialized to `Nothing()`, so this
-class SocketProcessParent;
+// return value is safe to ignore.
-class SocketProcessChild;
+bool SerializeIPCStream(already_AddRefed<nsIInputStream> aInputStream,
-}  // namespace net
+                        Maybe<IPCStream>& aValue, bool aAllowLazy);
-
-namespace ipc {
-
-class PBackgroundChild;
-class PBackgroundParent;
 
 // Deserialize an IPCStream received from an actor call.  These methods
 // work in both the child and parent.
@@ -35,184 +36,16 @@ already_AddRefed<nsIInputStream> DeserializeIPCStream(const IPCStream& aValue);
 already_AddRefed<nsIInputStream> DeserializeIPCStream(
     const Maybe<IPCStream>& aValue);
 
-// RAII helper class that serializes an nsIInputStream into an IPCStream struct.
+}  // namespace mozilla::ipc
-// Any file descriptor actors are automatically managed correctly.
-//
-// Here is a simple example:
-//
-//  // in ipdl file
-//  Protocol PMyStuff
-//  {
-//  parent:
-//    async DoStuff(IPCStream aStream);
-//  child:
-//    async StuffDone(IPCStream aStream);
-//  };
-//
-//  // in child c++ code
-//  void CallDoStuff(PMyStuffChild* aActor, nsIInputStream* aStream)
-//  {
-//    AutoIPCStream autoStream;
-//    autoStream.Serialize(aStream, aActor->Manager());
-//    aActor->SendDoStuff(autoStream.TakeValue());
-//  }
-//
-//  // in parent c++ code
-//  bool
-//  MyStuffParent::RecvDoStuff(const IPCStream& aIPCStream) {
-//    nsCOMPtr<nsIInputStream> stream = DeserializeIPCStream(aIPCStream);
-//    // Do something with stream...
-//
-//    // You can also serialize streams from parent-to-child.
-//    AutoIPCStream anotherStream;
-//    anotherStream.Serialize(mFileStream, Manager());
-//    SendStuffDone(anotherStream.TakeValue());
-//  }
-//
-// The AutoIPCStream RAII class may also be used if your stream is embedded
-// in a more complex IPDL structure.  In this case you attach the AutoIPCStream
-// to the embedded IPCStream and call TakeValue() after you pass the structure.
-// For example:
-//
-//  // in ipdl file
-//  struct Stuff
-//  {
-//    IPCStream stream;
-//    nsCString name;
-//  };
-//
-//  Protocol PMyStuff
-//  {
-//  parent:
-//    async DoStuff(Stuff aStream);
-//  };
-//
-//  // in child c++ code
-//  void CallDoStuff(PMyStuffChild* aActor, nsIInputStream* aStream)
-//  {
-//    Stuff stuff;
-//    AutoIPCStream autoStream(stuff.stream()); // attach to IPCStream here
-//    autoStream.Serialize(aStream, aActor->Manager());
-//    aActor->SendDoStuff(stuff);
-//    autoStream.TakeValue();                   // call take value after send
-//  }
-//
-//  // in parent c++ code
-//  bool
-//  MyStuffParent::RecvDoStuff(const Stuff& aStuff) {
-//    nsCOMPtr<nsIInputStream> stream = DeserializeIPCStream(aStuff.stream());
-//    /* do something with the nsIInputStream */
-//  }
-//
-// Note: This example is about child-to-parent inputStream, but AutoIPCStream
-// works also parent-to-child.
-//
-// The AutoIPCStream class also supports Maybe<IPCStream> values.  As long as
-// you did not initialize the object with a non-optional IPCStream, you can call
-// TakeOptionalValue() instead.
-//
-// The AutoIPCStream class can also be used to serialize nsIInputStream objects
-// on the parent side to send to the child.
-//
-// Like SerializeInputStream(), the AutoIPCStream will crash if
-// serialization cannot be completed.
-//
-// NOTE: This is not a MOZ_STACK_CLASS so that it can be more easily integrated
-//       with complex ipdl structures.  For example, you may want to create an
-//       array of RAII AutoIPCStream objects or build your own wrapping
-//       RAII object to handle other actors that need to be cleaned up.
-class AutoIPCStream {
- public:
-  // Implicitly create an Maybe<IPCStream> value.  Either
-  // TakeValue() or TakeOptionalValue() can be used.
-  explicit AutoIPCStream(bool aDelayedStart = false);
 
-  // Wrap an existing IPCStream.  Only TakeValue() may be
+namespace IPC {
-  // used.  If a nullptr nsIInputStream is passed to SerializeOrSend() then
-  // a crash will be forced.
-  explicit AutoIPCStream(IPCStream& aTarget, bool aDelayedStart = false);
-
-  // Wrap an existing Maybe<IPCStream>.  Either TakeValue()
-  // or TakeOptionalValue can be used.
-  explicit AutoIPCStream(Maybe<IPCStream>& aTarget, bool aDelayedStart = false);
-
-  AutoIPCStream(const AutoIPCStream&) = delete;
-  AutoIPCStream(AutoIPCStream&&) = delete;
-
-  AutoIPCStream& operator=(const AutoIPCStream&) = delete;
-  AutoIPCStream& operator=(AutoIPCStream&&) = delete;
-
-  ~AutoIPCStream();
-
-  // Serialize the input stream or create a SendStream actor using the PContent
-  // manager.  If neither of these succeed, then crash.  This should only be
-  // used on the main thread.
-  bool Serialize(nsIInputStream* aStream, dom::ContentChild* aManager);
-
-  // Serialize the input stream or create a SendStream actor using the
-  // PBackground manager.  If neither of these succeed, then crash.  This can
-  // be called on the main thread or Worker threads.
-  bool Serialize(nsIInputStream* aStream, PBackgroundChild* aManager);
-
-  // Serialize the input stream or create a SendStream actor using the
-  // SocketProcess manager.  If neither of these succeed, then crash.  This
-  // should only be used on the main thread.
-  bool Serialize(nsIInputStream* aStream, net::SocketProcessChild* aManager);
-
-  // Serialize the input stream.
-  [[nodiscard]] bool Serialize(nsIInputStream* aStream,
-                               dom::ContentParent* aManager);
-
-  // Serialize the input stream.
-  [[nodiscard]] bool Serialize(nsIInputStream* aStream,
-                               PBackgroundParent* aManager);
-
-  // Serialize the input stream.
-  [[nodiscard]] bool Serialize(nsIInputStream* aStream,
-                               net::SocketProcessParent* aManager);
-
-  bool Serialize(nsIInputStream* aStream);
-
-  // Get the IPCStream as a non-optional value.  This will
-  // assert if a stream has not been serialized or if it has already been taken.
-  // This should only be called if the value is being, or has already been, sent
-  // to the other side.
-  IPCStream& TakeValue();
-
-  // Get the Maybe<IPCStream> value. This will assert if the value has already
-  // been taken. This should only be called if the value is being, or has
-  // already been, sent to the other side.
-  Maybe<IPCStream>& TakeOptionalValue();
-
- private:
-  bool IsSet() const;
-
-  Maybe<IPCStream> mInlineValue;
-  IPCStream* const mValue = nullptr;
-  Maybe<IPCStream>* const mOptionalValue = nullptr;
-  bool mTaken = false;
-  const bool mDelayedStart;
-};
-
-class HoldIPCStream final : public AutoIPCStream {
- public:
-  NS_INLINE_DECL_REFCOUNTING(HoldIPCStream)
-
-  using AutoIPCStream::AutoIPCStream;
-
- private:
-  ~HoldIPCStream() = default;
-};
 
 template <>
-struct IPDLParamTraits<nsIInputStream*> {
+struct ParamTraits<nsIInputStream*> {
-  static void Write(IPC::MessageWriter* aWriter, IProtocol* aActor,
+  static void Write(MessageWriter* aWriter, nsIInputStream* aParam);
-                    nsIInputStream* aParam);
+  static bool Read(MessageReader* aReader, RefPtr<nsIInputStream>* aResult);
-  static bool Read(IPC::MessageReader* aReader, IProtocol* aActor,
-                   RefPtr<nsIInputStream>* aResult);
 };
 
-}  // namespace ipc
+}  // namespace IPC
-}  // namespace mozilla
 
 #endif  // mozilla_ipc_IPCStreamUtils_h

ipc/glue/InputStreamUtils.cpp

@@ -42,14 +42,11 @@ using namespace mozilla::dom;
 namespace mozilla {
 namespace ipc {
 
-namespace {
+void InputStreamHelper::SerializedComplexity(nsIInputStream* aInputStream,
-
+                                             uint32_t aMaxSize,
-template <typename M>
+                                             uint32_t* aSizeUsed,
-void SerializeInputStreamInternal(nsIInputStream* aInputStream,
+                                             uint32_t* aPipes,
-                                  InputStreamParams& aParams,
+                                             uint32_t* aTransferables) {
-                                  nsTArray<FileDescriptor>& aFileDescriptors,
-                                  bool aDelayedStart, uint32_t aMaxSize,
-                                  uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(aInputStream);
 
   nsCOMPtr<nsIIPCSerializableInputStream> serializable =
@@ -58,18 +55,31 @@ void SerializeInputStreamInternal(nsIInputStream* aInputStream,
     MOZ_CRASH("Input stream is not serializable!");
   }
 
-  serializable->Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
+  serializable->SerializedComplexity(aMaxSize, aSizeUsed, aPipes,
-                          aSizeUsed, aManager);
+                                     aTransferables);
+}
+
+void InputStreamHelper::SerializeInputStream(nsIInputStream* aInputStream,
+                                             InputStreamParams& aParams,
+                                             uint32_t aMaxSize,
+                                             uint32_t* aSizeUsed) {
+  MOZ_ASSERT(aInputStream);
+
+  nsCOMPtr<nsIIPCSerializableInputStream> serializable =
+      do_QueryInterface(aInputStream);
+  if (!serializable) {
+    MOZ_CRASH("Input stream is not serializable!");
+  }
+
+  serializable->Serialize(aParams, aMaxSize, aSizeUsed);
 
   if (aParams.type() == InputStreamParams::T__None) {
     MOZ_CRASH("Serialize failed!");
   }
 }
 
-template <typename M>
+void InputStreamHelper::SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
-void SerializeInputStreamAsPipeInternal(nsIInputStream* aInputStream,
+                                                   InputStreamParams& aParams) {
-                                        InputStreamParams& aParams,
-                                        bool aDelayedStart, M* aManager) {
   MOZ_ASSERT(aInputStream);
 
   // Let's try to take the length using InputStreamLengthHelper. If the length
@@ -104,60 +114,8 @@ void SerializeInputStreamAsPipeInternal(nsIInputStream* aInputStream,
   }
 }
 
-}  // namespace
-
-void InputStreamHelper::SerializedComplexity(nsIInputStream* aInputStream,
-                                             uint32_t aMaxSize,
-                                             uint32_t* aSizeUsed,
-                                             uint32_t* aPipes,
-                                             uint32_t* aTransferables) {
-  MOZ_ASSERT(aInputStream);
-
-  nsCOMPtr<nsIIPCSerializableInputStream> serializable =
-      do_QueryInterface(aInputStream);
-  if (!serializable) {
-    MOZ_CRASH("Input stream is not serializable!");
-  }
-
-  serializable->SerializedComplexity(aMaxSize, aSizeUsed, aPipes,
-                                     aTransferables);
-}
-
-void InputStreamHelper::SerializeInputStream(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    nsTArray<FileDescriptor>& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    ParentToChildStreamActorManager* aManager) {
-  SerializeInputStreamInternal(aInputStream, aParams, aFileDescriptors,
-                               aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-void InputStreamHelper::SerializeInputStream(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    nsTArray<FileDescriptor>& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    ChildToParentStreamActorManager* aManager) {
-  SerializeInputStreamInternal(aInputStream, aParams, aFileDescriptors,
-                               aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-void InputStreamHelper::SerializeInputStreamAsPipe(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    bool aDelayedStart, ParentToChildStreamActorManager* aManager) {
-  SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
-                                     aManager);
-}
-
-void InputStreamHelper::SerializeInputStreamAsPipe(
-    nsIInputStream* aInputStream, InputStreamParams& aParams,
-    bool aDelayedStart, ChildToParentStreamActorManager* aManager) {
-  SerializeInputStreamAsPipeInternal(aInputStream, aParams, aDelayedStart,
-                                     aManager);
-}
-
 already_AddRefed<nsIInputStream> InputStreamHelper::DeserializeInputStream(
-    const InputStreamParams& aParams,
+    const InputStreamParams& aParams) {
-    const nsTArray<FileDescriptor>& aFileDescriptors) {
   if (aParams.type() == InputStreamParams::TRemoteLazyInputStreamParams) {
     const RemoteLazyInputStreamParams& params =
         aParams.get_RemoteLazyInputStreamParams();
@@ -238,7 +196,7 @@ already_AddRefed<nsIInputStream> InputStreamHelper::DeserializeInputStream(
 
   MOZ_ASSERT(serializable);
 
-  if (!serializable->Deserialize(aParams, aFileDescriptors)) {
+  if (!serializable->Deserialize(aParams)) {
     MOZ_ASSERT(false, "Deserialize failed!");
     return nullptr;
   }

ipc/glue/InputStreamUtils.h

@@ -17,12 +17,8 @@ namespace ipc {
 
 class FileDescriptor;
 
-// TODO: These interfaces are no longer necessary and should be removed.
+// If you want to serialize an inputStream, please use SerializeIPCStream or
-class ParentToChildStreamActorManager {};
+// nsIInputStream directly.
-
-class ChildToParentStreamActorManager {};
-
-// If you want to serialize an inputStream, please use AutoIPCStream.
 class InputStreamHelper {
  public:
   static void SerializedComplexity(nsIInputStream* aInputStream,
@@ -33,40 +29,19 @@ class InputStreamHelper {
   // The manager is needed in case a stream needs to serialize itself as
   // IPCRemoteStream.
   // The stream serializes itself fully only if the resulting IPC message will
-  // be smaller than |aMaxSize|. Otherwise, the stream serializes itself as
+  // be smaller than |aMaxSize|. Otherwise, the stream serializes itself as a
-  // IPCRemoteStream, and, its content will be sent to the other side of the IPC
+  // DataPipe, and, its content will be sent to the other side of the IPC pipe
-  // pipe in chunks. This sending can start immediatelly or at the first read
+  // in chunks. The IPC message size is returned into |aSizeUsed|.
-  // based on the value of |aDelayedStart|. The IPC message size is returned
-  // into |aSizeUsed|.
-  // XXX: The aManager and aFileDescriptors arguments are no longer necessary
-  // and should be removed.
   static void SerializeInputStream(nsIInputStream* aInputStream,
                                    InputStreamParams& aParams,
-                                   nsTArray<FileDescriptor>& aFileDescriptors,
+                                   uint32_t aMaxSize, uint32_t* aSizeUsed);
-                                   bool aDelayedStart, uint32_t aMaxSize,
-                                   uint32_t* aSizeUsed,
-                                   ParentToChildStreamActorManager* aManager);
 
-  static void SerializeInputStream(nsIInputStream* aInputStream,
+  // When a stream wants to serialize itself as a DataPipe, it uses this method.
-                                   InputStreamParams& aParams,
+  static void SerializeInputStreamAsPipe(nsIInputStream* aInputStream,
-                                   nsTArray<FileDescriptor>& aFileDescriptors,
+                                         InputStreamParams& aParams);
-                                   bool aDelayedStart, uint32_t aMaxSize,
-                                   uint32_t* aSizeUsed,
-                                   ChildToParentStreamActorManager* aManager);
-
-  // When a stream wants to serialize itself as IPCRemoteStream, it uses one of
-  // these methods.
-  static void SerializeInputStreamAsPipe(
-      nsIInputStream* aInputStream, InputStreamParams& aParams,
-      bool aDelayedStart, ParentToChildStreamActorManager* aManager);
-
-  static void SerializeInputStreamAsPipe(
-      nsIInputStream* aInputStream, InputStreamParams& aParams,
-      bool aDelayedStart, ChildToParentStreamActorManager* aManager);
 
   static already_AddRefed<nsIInputStream> DeserializeInputStream(
-      const InputStreamParams& aParams,
+      const InputStreamParams& aParams);
-      const nsTArray<FileDescriptor>& aFileDescriptors);
 };
 
 }  // namespace ipc

ipc/glue/nsIIPCSerializableInputStream.h

@@ -17,8 +17,6 @@ namespace ipc {
 
 class FileDescriptor;
 class InputStreamParams;
-class ChildToParentStreamActorManager;
-class ParentToChildStreamActorManager;
 
 }  // namespace ipc
 
@@ -33,8 +31,6 @@ class ParentToChildStreamActorManager;
 
 class NS_NO_VTABLE nsIIPCSerializableInputStream : public nsISupports {
  public:
-  typedef nsTArray<mozilla::ipc::FileDescriptor> FileDescriptorArray;
-
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IIPCSERIALIZABLEINPUTSTREAM_IID)
 
   // Determine the serialized complexity of this input stream, initializing
@@ -70,39 +66,23 @@ class NS_NO_VTABLE nsIIPCSerializableInputStream : public nsISupports {
                                     uint32_t* aPipes,
                                     uint32_t* aTransferables) = 0;
 
-  virtual void Serialize(
+  virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,
-      mozilla::ipc::InputStreamParams& aParams,
+                         uint32_t aMaxSize, uint32_t* aSizeUsed) = 0;
-      FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-      uint32_t aMaxSize, uint32_t* aSizeUsed,
-      mozilla::ipc::ParentToChildStreamActorManager* aManager) = 0;
 
-  virtual void Serialize(
+  virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams) = 0;
-      mozilla::ipc::InputStreamParams& aParams,
-      FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-      uint32_t aMaxSize, uint32_t* aSizeUsed,
-      mozilla::ipc::ChildToParentStreamActorManager* aManager) = 0;
-
-  virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams,
-                           const FileDescriptorArray& aFileDescriptors) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
                               NS_IIPCSERIALIZABLEINPUTSTREAM_IID)
 
-#define NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM                                 \
+#define NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM                               \
-  virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed,   \
+  virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed, \
-                                    uint32_t* aPipes,                         \
+                                    uint32_t* aPipes,                       \
-                                    uint32_t* aTransferrables) override;      \
+                                    uint32_t* aTransferrables) override;    \
-  virtual void Serialize(                                                     \
+  virtual void Serialize(mozilla::ipc::InputStreamParams&, uint32_t,        \
-      mozilla::ipc::InputStreamParams&, FileDescriptorArray&, bool, uint32_t, \
+                         uint32_t*) override;                               \
-      uint32_t*, mozilla::ipc::ParentToChildStreamActorManager*) override;    \
+                                                                            \
-                                                                              \
+  virtual bool Deserialize(const mozilla::ipc::InputStreamParams&) override;
-  virtual void Serialize(                                                     \
-      mozilla::ipc::InputStreamParams&, FileDescriptorArray&, bool, uint32_t, \
-      uint32_t*, mozilla::ipc::ChildToParentStreamActorManager*) override;    \
-                                                                              \
-  virtual bool Deserialize(const mozilla::ipc::InputStreamParams&,            \
-                           const FileDescriptorArray&) override;
 
 #define NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(_to)                       \
   virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed, \
@@ -111,28 +91,14 @@ NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
     _to SerializedComplexity(aMaxSize, aSizeUsed, aPipes, aTransferables);  \
   };                                                                        \
                                                                             \
-  virtual void Serialize(                                                   \
+  virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,          \
-      mozilla::ipc::InputStreamParams& aParams,                             \
+                         uint32_t aMaxSize, uint32_t* aSizeUsed) override { \
-      FileDescriptorArray& aFileDescriptors, bool aDelayedStart,            \
+    _to Serialize(aParams, aMaxSize, aSizeUsed);                            \
-      uint32_t aMaxSize, uint32_t* aSizeUsed,                               \
-      mozilla::ipc::ParentToChildStreamActorManager* aManager) override {   \
-    _to Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,       \
-                  aSizeUsed, aManager);                                     \
   }                                                                         \
                                                                             \
-  virtual void Serialize(                                                   \
+  virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams)  \
-      mozilla::ipc::InputStreamParams& aParams,                             \
-      FileDescriptorArray& aFileDescriptors, bool aDelayedStart,            \
-      uint32_t aMaxSize, uint32_t* aSizeUsed,                               \
-      mozilla::ipc::ChildToParentStreamActorManager* aManager) override {   \
-    _to Serialize(aParams, aFileDescriptors, aDelayedStart, aMaxSize,       \
-                  aSizeUsed, aManager);                                     \
-  }                                                                         \
-                                                                            \
-  virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams,  \
-                           const FileDescriptorArray& aFileDescriptors)     \
       override {                                                            \
-    return _to Deserialize(aParams, aFileDescriptors);                      \
+    return _to Deserialize(aParams);                                        \
   }
 
 #endif  // mozilla_ipc_nsIIPCSerializableInputStream_h

netwerk/base/nsBufferedStreams.cpp

@@ -599,26 +599,8 @@ void nsBufferedInputStream::SerializedComplexity(uint32_t aMaxSize,
   }
 }
 
-void nsBufferedInputStream::Serialize(
+void nsBufferedInputStream::Serialize(InputStreamParams& aParams,
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
+                                      uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void nsBufferedInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void nsBufferedInputStream::SerializeInternal(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(aSizeUsed);
   *aSizeUsed = 0;
 
@@ -629,9 +611,8 @@ void nsBufferedInputStream::SerializeInternal(
     MOZ_ASSERT(stream);
 
     InputStreamParams wrappedParams;
-    InputStreamHelper::SerializeInputStream(stream, wrappedParams,
+    InputStreamHelper::SerializeInputStream(stream, wrappedParams, aMaxSize,
-                                            aFileDescriptors, aDelayedStart,
+                                            aSizeUsed);
-                                            aMaxSize, aSizeUsed, aManager);
 
     params.optionalStream().emplace(wrappedParams);
   }
@@ -641,9 +622,7 @@ void nsBufferedInputStream::SerializeInternal(
   aParams = params;
 }
 
-bool nsBufferedInputStream::Deserialize(
+bool nsBufferedInputStream::Deserialize(const InputStreamParams& aParams) {
-    const InputStreamParams& aParams,
-    const FileDescriptorArray& aFileDescriptors) {
   if (aParams.type() != InputStreamParams::TBufferedInputStreamParams) {
     NS_ERROR("Received unknown parameters from the other process!");
     return false;
@@ -655,8 +634,7 @@ bool nsBufferedInputStream::Deserialize(
 
   nsCOMPtr<nsIInputStream> stream;
   if (wrappedParams.isSome()) {
-    stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref(),
+    stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref());
-                                                       aFileDescriptors);
     if (!stream) {
       NS_WARNING("Failed to deserialize wrapped stream!");
       return false;

netwerk/base/nsBufferedStreams.h

@@ -112,12 +112,6 @@ class nsBufferedInputStream final : public nsBufferedStream,
  protected:
   virtual ~nsBufferedInputStream() = default;
 
-  template <typename M>
-  void SerializeInternal(mozilla::ipc::InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   NS_IMETHOD Fill() override;
   NS_IMETHOD Flush() override { return NS_OK; }  // no-op for input streams
 

netwerk/base/nsFileStreams.cpp

@@ -547,29 +547,11 @@ void nsFileInputStream::SerializedComplexity(uint32_t aMaxSize,
   *aTransferables = 1;
 }
 
-void nsFileInputStream::Serialize(InputStreamParams& aParams,
+void nsFileInputStream::Serialize(InputStreamParams& aParams, uint32_t aMaxSize,
-                                  FileDescriptorArray& aFileDescriptors,
+                                  uint32_t* aSizeUsed) {
-                                  bool aDelayedStart, uint32_t aMaxSize,
-                                  uint32_t* aSizeUsed,
-                                  ParentToChildStreamActorManager* aManager) {
   MOZ_ASSERT(aSizeUsed);
   *aSizeUsed = 0;
 
-  SerializeInternal(aParams);
-}
-
-void nsFileInputStream::Serialize(InputStreamParams& aParams,
-                                  FileDescriptorArray& aFileDescriptors,
-                                  bool aDelayedStart, uint32_t aMaxSize,
-                                  uint32_t* aSizeUsed,
-                                  ChildToParentStreamActorManager* aManager) {
-  MOZ_ASSERT(aSizeUsed);
-  *aSizeUsed = 0;
-
-  SerializeInternal(aParams);
-}
-
-void nsFileInputStream::SerializeInternal(InputStreamParams& aParams) {
   FileInputStreamParams params;
 
   if (NS_SUCCEEDED(DoPendingOpen())) {
@@ -600,9 +582,7 @@ void nsFileInputStream::SerializeInternal(InputStreamParams& aParams) {
   aParams = params;
 }
 
-bool nsFileInputStream::Deserialize(
+bool nsFileInputStream::Deserialize(const InputStreamParams& aParams) {
-    const InputStreamParams& aParams,
-    const FileDescriptorArray& aFileDescriptors) {
   NS_ASSERTION(!mFD, "Already have a file descriptor?!");
   NS_ASSERTION(mState == nsFileStreamBase::eUnitialized, "Deferring open?!");
   NS_ASSERTION(!mFile, "Should never have a file here!");

netwerk/base/nsFileStreams.h

@@ -155,8 +155,6 @@ class nsFileInputStream : public nsFileStreamBase,
  protected:
   virtual ~nsFileInputStream() = default;
 
-  void SerializeInternal(mozilla::ipc::InputStreamParams& aParams);
-
   nsresult SeekInternal(int32_t aWhence, int64_t aOffset,
                         bool aClearBuf = true);
 

netwerk/base/nsMIMEInputStream.cpp

@@ -59,12 +59,6 @@ class nsMIMEInputStream : public nsIMIMEInputStream,
  private:
   void InitStreams();
 
-  template <typename M>
-  void SerializeInternal(InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   struct MOZ_STACK_CLASS ReadSegmentsState {
     nsCOMPtr<nsIInputStream> mThisStream;
     nsWriteSegmentFun mWriter{nullptr};
@@ -340,27 +334,8 @@ void nsMIMEInputStream::SerializedComplexity(uint32_t aMaxSize,
   }
 }
 
-void nsMIMEInputStream::Serialize(
+void nsMIMEInputStream::Serialize(InputStreamParams& aParams, uint32_t aMaxSize,
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
+                                  uint32_t* aSizeUsed) {
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void nsMIMEInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void nsMIMEInputStream::SerializeInternal(InputStreamParams& aParams,
-                                          FileDescriptorArray& aFileDescriptors,
-                                          bool aDelayedStart, uint32_t aMaxSize,
-                                          uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(aSizeUsed);
   *aSizeUsed = 0;
 
@@ -377,17 +352,15 @@ void nsMIMEInputStream::SerializeInternal(InputStreamParams& aParams,
 
   if (nsCOMPtr<nsIIPCSerializableInputStream> serializable =
           do_QueryInterface(mStream)) {
-    InputStreamHelper::SerializeInputStream(mStream, wrappedParams,
+    InputStreamHelper::SerializeInputStream(mStream, wrappedParams, aMaxSize,
-                                            aFileDescriptors, aDelayedStart,
+                                            aSizeUsed);
-                                            aMaxSize, aSizeUsed, aManager);
   } else {
     // Falling back to sending the underlying stream over a pipe when
     // sending an nsMIMEInputStream over IPC is potentially wasteful
     // if it is sent several times. This can possibly happen with
     // fission. There are two ways to improve this, see bug 1648369
     // and bug 1648370.
-    InputStreamHelper::SerializeInputStreamAsPipe(mStream, wrappedParams,
+    InputStreamHelper::SerializeInputStreamAsPipe(mStream, wrappedParams);
-                                                  aDelayedStart, aManager);
   }
 
   NS_ASSERTION(wrappedParams.type() != InputStreamParams::T__None,
@@ -397,9 +370,7 @@ void nsMIMEInputStream::SerializeInternal(InputStreamParams& aParams,
   aParams = params;
 }
 
-bool nsMIMEInputStream::Deserialize(
+bool nsMIMEInputStream::Deserialize(const InputStreamParams& aParams) {
-    const InputStreamParams& aParams,
-    const FileDescriptorArray& aFileDescriptors) {
   if (aParams.type() != InputStreamParams::TMIMEInputStreamParams) {
     NS_ERROR("Received unknown parameters from the other process!");
     return false;
@@ -410,8 +381,7 @@ bool nsMIMEInputStream::Deserialize(
 
   if (wrappedParams.isSome()) {
     nsCOMPtr<nsIInputStream> stream;
-    stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref(),
+    stream = InputStreamHelper::DeserializeInputStream(wrappedParams.ref());
-                                                       aFileDescriptors);
     if (!stream) {
       NS_WARNING("Failed to deserialize wrapped stream!");
       return false;

netwerk/ipc/SocketProcessChild.h

@@ -25,9 +25,7 @@ class BackgroundDataBridgeParent;
 
 // The IPC actor implements PSocketProcessChild in child process.
 // This is allocated and kept alive by SocketProcessImpl.
-class SocketProcessChild final
+class SocketProcessChild final : public PSocketProcessChild {
-    : public PSocketProcessChild,
-      public mozilla::ipc::ChildToParentStreamActorManager {
  public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SocketProcessChild)
 

netwerk/ipc/SocketProcessParent.h

@@ -27,8 +27,7 @@ class SocketProcessHost;
 // by SocketProcessHost.
 class SocketProcessParent final
     : public PSocketProcessParent,
-      public ipc::CrashReporterHelper<GeckoProcessType_Socket>,
+      public ipc::CrashReporterHelper<GeckoProcessType_Socket> {
-      public ipc::ParentToChildStreamActorManager {
  public:
   friend class SocketProcessHost;
 

netwerk/protocol/gio/GIOChannelChild.cpp

@@ -102,9 +102,9 @@ GIOChannelChild::AsyncOpen(nsIStreamListener* aListener) {
     mLoadGroup->AddRequest(this, nullptr);
   }
 
-  mozilla::ipc::AutoIPCStream autoStream;
+  Maybe<mozilla::ipc::IPCStream> ipcStream;
-  autoStream.Serialize(mUploadStream,
+  mozilla::ipc::SerializeIPCStream(do_AddRef(mUploadStream), ipcStream,
-                       static_cast<ContentChild*>(gNeckoChild->Manager()));
+                                   /* aAllowLazy */ false);
 
   uint32_t loadFlags = 0;
   GetLoadFlags(&loadFlags);
@@ -113,7 +113,7 @@ GIOChannelChild::AsyncOpen(nsIStreamListener* aListener) {
   SerializeURI(nsBaseChannel::URI(), openArgs.uri());
   openArgs.startPos() = mStartPos;
   openArgs.entityID() = mEntityID;
-  openArgs.uploadStream() = autoStream.TakeOptionalValue();
+  openArgs.uploadStream() = ipcStream;
   openArgs.loadFlags() = loadFlags;
 
   nsCOMPtr<nsILoadInfo> loadInfo = LoadInfo();

netwerk/protocol/http/HttpBackgroundChannelParent.cpp

@@ -172,7 +172,6 @@ bool HttpBackgroundChannelParent::OnStartRequest(
   }
 
   HttpChannelAltDataStream altData;
-  ipc::AutoIPCStream altDataInputStream(true /* delay start */);
   if (aAltDataSource) {
     nsAutoCString altDataType;
     Unused << aAltDataSource->GetAltDataType(altDataType);
@@ -182,11 +181,12 @@ bool HttpBackgroundChannelParent::OnStartRequest(
       nsresult rv = aAltDataSource->OpenAlternativeInputStream(
           altDataType, getter_AddRefs(inputStream));
       if (NS_SUCCEEDED(rv)) {
-        Unused << altDataInputStream.Serialize(inputStream, Manager());
+        Unused << mozilla::ipc::SerializeIPCStream(inputStream.forget(),
+                                                   altData.altDataInputStream(),
+                                                   /* aAllowLazy */ true);
       }
     }
   }
-  altData.altDataInputStream() = altDataInputStream.TakeOptionalValue();
 
   return SendOnStartRequest(aResponseHead, aUseResponseHead, aRequestHeaders,
                             aArgs, altData);

netwerk/protocol/http/HttpChannelChild.cpp

@@ -2131,10 +2131,10 @@ nsresult HttpChannelChild::ContinueAsyncOpen() {
   openArgs.preferredAlternativeTypes() = mPreferredCachedAltDataTypes.Clone();
   openArgs.referrerInfo() = mReferrerInfo;
 
-  AutoIPCStream autoStream(openArgs.uploadStream());
   if (mUploadStream) {
-    autoStream.Serialize(mUploadStream, ContentChild::GetSingleton());
+    MOZ_ALWAYS_TRUE(SerializeIPCStream(do_AddRef(mUploadStream),
-    autoStream.TakeOptionalValue();
+                                       openArgs.uploadStream(),
+                                       /* aAllowLazy */ false));
   }
 
   Maybe<CorsPreflightArgs> optionalCorsPreflightArgs;

netwerk/protocol/http/HttpChannelParent.cpp

@@ -1456,19 +1456,17 @@ mozilla::ipc::IPCResult HttpChannelParent::RecvOpenOriginalCacheInputStream() {
   if (mIPCClosed) {
     return IPC_OK();
   }
-  AutoIPCStream autoStream;
+  Maybe<IPCStream> ipcStream;
   if (mCacheEntry) {
     nsCOMPtr<nsIInputStream> inputStream;
     nsresult rv = mCacheEntry->OpenInputStream(0, getter_AddRefs(inputStream));
     if (NS_SUCCEEDED(rv)) {
-      PContentParent* pcp = Manager()->Manager();
+      Unused << mozilla::ipc::SerializeIPCStream(
-      Unused << autoStream.Serialize(inputStream,
+          inputStream.forget(), ipcStream, /* aAllowLazy */ false);
-                                     static_cast<ContentParent*>(pcp));
     }
   }
 
-  Unused << SendOriginalCacheInputStreamAvailable(
+  Unused << SendOriginalCacheInputStreamAvailable(ipcStream);
-      autoStream.TakeOptionalValue());
   return IPC_OK();
 }
 

netwerk/protocol/http/HttpTransactionParent.cpp

@@ -110,9 +110,9 @@ nsresult HttpTransactionParent::Init(
   HttpConnectionInfoCloneArgs infoArgs;
   nsHttpConnectionInfo::SerializeHttpConnectionInfo(cinfo, infoArgs);
 
-  mozilla::ipc::AutoIPCStream autoStream;
+  Maybe<mozilla::ipc::IPCStream> ipcStream;
-  if (requestBody &&
+  if (!mozilla::ipc::SerializeIPCStream(do_AddRef(requestBody), ipcStream,
-      !autoStream.Serialize(requestBody, SocketProcessParent::GetSingleton())) {
+                                        /* aAllowLazy */ false)) {
     return NS_ERROR_FAILURE;
   }
 
@@ -144,10 +144,8 @@ nsresult HttpTransactionParent::Init(
 
   // TODO: Figure out if we have to implement nsIThreadRetargetableRequest in
   // bug 1544378.
-  if (!SendInit(caps, infoArgs, *requestHead,
+  if (!SendInit(caps, infoArgs, *requestHead, ipcStream, requestContentLength,
-                requestBody ? Some(autoStream.TakeValue()) : Nothing(),
+                requestBodyHasHeaders, topLevelOuterContentWindowId,
-                requestContentLength, requestBodyHasHeaders,
-                topLevelOuterContentWindowId,
                 static_cast<uint8_t>(trafficCategory), requestContextID,
                 classOfService, initialRwin, responseTimeoutEnabled, mChannelId,
                 !!mTransactionObserver, pushedStreamArg, throttleQueue,

netwerk/protocol/websocket/WebSocketChannelChild.cpp

@@ -700,9 +700,12 @@ WebSocketChannelChild::SendBinaryStream(nsIInputStream* aStream,
 
   LOG(("WebSocketChannelChild::SendBinaryStream() %p\n", this));
 
-  AutoIPCStream autoStream;
+  IPCStream ipcStream;
-  autoStream.Serialize(aStream, static_cast<mozilla::dom::ContentChild*>(
+  if (NS_WARN_IF(!mozilla::ipc::SerializeIPCStream(do_AddRef(aStream),
-                                    gNeckoChild->Manager()));
+                                                   ipcStream,
+                                                   /* aAllowLazy */ false))) {
+    return NS_ERROR_UNEXPECTED;
+  }
 
   {
     MutexAutoLock lock(mMutex);
@@ -711,7 +714,7 @@ WebSocketChannelChild::SendBinaryStream(nsIInputStream* aStream,
     }
   }
 
-  if (!SendSendBinaryStream(autoStream.TakeValue(), aLength)) {
+  if (!SendSendBinaryStream(ipcStream, aLength)) {
     return NS_ERROR_UNEXPECTED;
   }
 

toolkit/components/antitracking/ContentBlockingLog.cpp

@@ -22,8 +22,6 @@
 
 namespace mozilla {
 
-using ipc::AutoIPCStream;
-
 typedef Telemetry::OriginMetricID OriginMetricID;
 
 // sync with TelemetryOriginData.inc

xpcom/ds/nsTArray.h

@@ -95,7 +95,6 @@ class IndexCursorResponse;
 }  // namespace mozilla::dom
 
 namespace mozilla::ipc {
-class AutoIPCStream;
 class ContentSecurityPolicy;
 template <class T>
 class Endpoint;
@@ -827,9 +826,6 @@ struct MOZ_NEEDS_MEMMOVABLE_TYPE nsTArray_RelocationStrategy {
     using Type = nsTArray_RelocateUsingMoveConstructor<T<S>>;       \
   };
 
-// TODO mozilla::ipc::AutoIPCStream is not even movable, so memmovable use with
-// nsTArray (in StructuredCloneData) seems at least quirky
-
 MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(JS::Heap)
 MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(std::function)
 MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR_FOR_TEMPLATE(mozilla::ipc::Endpoint)

xpcom/io/InputStreamLengthWrapper.cpp

@@ -255,35 +255,14 @@ void InputStreamLengthWrapper::SerializedComplexity(uint32_t aMaxSize,
 }
 
 void InputStreamLengthWrapper::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
+    mozilla::ipc::InputStreamParams& aParams, uint32_t aMaxSize,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
+    uint32_t* aSizeUsed) {
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void InputStreamLengthWrapper::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void InputStreamLengthWrapper::SerializeInternal(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(mInputStream);
   MOZ_ASSERT(mWeakIPCSerializableInputStream);
 
   InputStreamLengthWrapperParams params;
   InputStreamHelper::SerializeInputStream(mInputStream, params.stream(),
-                                          aFileDescriptors, aDelayedStart,
+                                          aMaxSize, aSizeUsed);
-                                          aMaxSize, aSizeUsed, aManager);
   params.length() = mLength;
   params.consumed() = mConsumed;
 
@@ -291,8 +270,7 @@ void InputStreamLengthWrapper::SerializeInternal(
 }
 
 bool InputStreamLengthWrapper::Deserialize(
-    const mozilla::ipc::InputStreamParams& aParams,
+    const mozilla::ipc::InputStreamParams& aParams) {
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_ASSERT(!mInputStream);
   MOZ_ASSERT(!mWeakIPCSerializableInputStream);
 
@@ -304,8 +282,8 @@ bool InputStreamLengthWrapper::Deserialize(
   const InputStreamLengthWrapperParams& params =
       aParams.get_InputStreamLengthWrapperParams();
 
-  nsCOMPtr<nsIInputStream> stream = InputStreamHelper::DeserializeInputStream(
+  nsCOMPtr<nsIInputStream> stream =
-      params.stream(), aFileDescriptors);
+      InputStreamHelper::DeserializeInputStream(params.stream());
   if (!stream) {
     NS_WARNING("Deserialize failed!");
     return false;

xpcom/io/InputStreamLengthWrapper.h

@@ -59,12 +59,6 @@ class InputStreamLengthWrapper final : public nsIAsyncInputStream,
  private:
   ~InputStreamLengthWrapper();
 
-  template <typename M>
-  void SerializeInternal(mozilla::ipc::InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   void SetSourceStream(already_AddRefed<nsIInputStream> aInputStream);
 
   nsCOMPtr<nsIInputStream> mInputStream;

xpcom/io/NonBlockingAsyncInputStream.cpp

@@ -330,37 +330,15 @@ void NonBlockingAsyncInputStream::SerializedComplexity(
 }
 
 void NonBlockingAsyncInputStream::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
+    mozilla::ipc::InputStreamParams& aParams, uint32_t aMaxSize,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
+    uint32_t* aSizeUsed) {
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void NonBlockingAsyncInputStream::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void NonBlockingAsyncInputStream::SerializeInternal(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(mWeakIPCSerializableInputStream);
-  InputStreamHelper::SerializeInputStream(mInputStream, aParams,
+  InputStreamHelper::SerializeInputStream(mInputStream, aParams, aMaxSize,
-                                          aFileDescriptors, aDelayedStart,
+                                          aSizeUsed);
-                                          aMaxSize, aSizeUsed, aManager);
 }
 
 bool NonBlockingAsyncInputStream::Deserialize(
-    const mozilla::ipc::InputStreamParams& aParams,
+    const mozilla::ipc::InputStreamParams& aParams) {
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_CRASH("NonBlockingAsyncInputStream cannot be deserialized!");
   return true;
 }

xpcom/io/NonBlockingAsyncInputStream.h

@@ -45,12 +45,6 @@ class NonBlockingAsyncInputStream final : public nsIAsyncInputStream,
       already_AddRefed<nsIInputStream> aInputStream);
   ~NonBlockingAsyncInputStream();
 
-  template <typename M>
-  void SerializeInternal(mozilla::ipc::InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   class AsyncWaitRunnable;
 
   void RunAsyncWaitCallback(AsyncWaitRunnable* aRunnable,

xpcom/io/SlicedInputStream.cpp

@@ -441,44 +441,21 @@ void SlicedInputStream::SerializedComplexity(uint32_t aMaxSize,
   }
 }
 
-void SlicedInputStream::Serialize(
+void SlicedInputStream::Serialize(mozilla::ipc::InputStreamParams& aParams,
-    mozilla::ipc::InputStreamParams& aParams,
+                                  uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void SlicedInputStream::Serialize(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void SlicedInputStream::SerializeInternal(
-    mozilla::ipc::InputStreamParams& aParams,
-    FileDescriptorArray& aFileDescriptors, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(mInputStream);
   MOZ_ASSERT(mWeakIPCSerializableInputStream);
 
   uint32_t sizeUsed = 0, pipes = 0, transferables = 0;
   SerializedComplexity(aMaxSize, &sizeUsed, &pipes, &transferables);
   if (pipes > 0 && transferables == 0) {
-    InputStreamHelper::SerializeInputStreamAsPipe(mInputStream, aParams,
+    InputStreamHelper::SerializeInputStreamAsPipe(mInputStream, aParams);
-                                                  aDelayedStart, aManager);
     return;
   }
 
   SlicedInputStreamParams params;
   InputStreamHelper::SerializeInputStream(mInputStream, params.stream(),
-                                          aFileDescriptors, aDelayedStart,
+                                          aMaxSize, aSizeUsed);
-                                          aMaxSize, aSizeUsed, aManager);
   params.start() = mStart;
   params.length() = mLength;
   params.curPos() = mCurPos;
@@ -488,8 +465,7 @@ void SlicedInputStream::SerializeInternal(
 }
 
 bool SlicedInputStream::Deserialize(
-    const mozilla::ipc::InputStreamParams& aParams,
+    const mozilla::ipc::InputStreamParams& aParams) {
-    const FileDescriptorArray& aFileDescriptors) {
   MOZ_ASSERT(!mInputStream);
   MOZ_ASSERT(!mWeakIPCSerializableInputStream);
 
@@ -500,8 +476,8 @@ bool SlicedInputStream::Deserialize(
 
   const SlicedInputStreamParams& params = aParams.get_SlicedInputStreamParams();
 
-  nsCOMPtr<nsIInputStream> stream = InputStreamHelper::DeserializeInputStream(
+  nsCOMPtr<nsIInputStream> stream =
-      params.stream(), aFileDescriptors);
+      InputStreamHelper::DeserializeInputStream(params.stream());
   if (!stream) {
     NS_WARNING("Deserialize failed!");
     return false;

xpcom/io/SlicedInputStream.h

@@ -61,12 +61,6 @@ class SlicedInputStream final : public nsIAsyncInputStream,
  private:
   ~SlicedInputStream();
 
-  template <typename M>
-  void SerializeInternal(mozilla::ipc::InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   void SetSourceStream(already_AddRefed<nsIInputStream> aInputStream);
 
   uint64_t AdjustRange(uint64_t aRange);

xpcom/io/nsMultiplexInputStream.cpp

@@ -124,12 +124,6 @@ class nsMultiplexInputStream final : public nsIMultiplexInputStream,
                                     uint32_t* aPipes, uint32_t* aTransferables,
                                     bool* aSerializeAsPipe);
 
-  template <typename M>
-  void SerializeInternal(InputStreamParams& aParams,
-                         FileDescriptorArray& aFileDescriptors,
-                         bool aDelayedStart, uint32_t aMaxSize,
-                         uint32_t* aSizeUsed, M* aManager);
-
   static nsresult ReadSegCb(nsIInputStream* aIn, void* aClosure,
                             const char* aFromRawSegment, uint32_t aToOffset,
                             uint32_t aCount, uint32_t* aWriteCount);
@@ -1033,26 +1027,8 @@ void nsMultiplexInputStream::SerializedComplexityInternal(
   }
 }
 
-void nsMultiplexInputStream::Serialize(
+void nsMultiplexInputStream::Serialize(InputStreamParams& aParams,
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
+                                       uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-void nsMultiplexInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aFileDescriptors, aDelayedStart, aMaxSize,
-                    aSizeUsed, aManager);
-}
-
-template <typename M>
-void nsMultiplexInputStream::SerializeInternal(
-    InputStreamParams& aParams, FileDescriptorArray& aFileDescriptors,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager) {
   MutexAutoLock lock(mLock);
 
   // Check if we should serialize this stream as a pipe to reduce complexity.
@@ -1063,8 +1039,7 @@ void nsMultiplexInputStream::SerializeInternal(
   if (serializeAsPipe) {
     *aSizeUsed = 0;
     MutexAutoUnlock unlock(mLock);
-    InputStreamHelper::SerializeInputStreamAsPipe(this, aParams, aDelayedStart,
+    InputStreamHelper::SerializeInputStreamAsPipe(this, aParams);
-                                                  aManager);
     return;
   }
 
@@ -1080,10 +1055,9 @@ void nsMultiplexInputStream::SerializeInternal(
     streams.SetCapacity(streamCount);
     for (uint32_t index = 0; index < streamCount; index++) {
       uint32_t sizeUsed = 0;
-      InputStreamHelper::SerializeInputStream(
+      InputStreamHelper::SerializeInputStream(mStreams[index].mOriginalStream,
-          mStreams[index].mOriginalStream, *streams.AppendElement(),
+                                              *streams.AppendElement(),
-          aFileDescriptors, aDelayedStart, maxSize.value(), &sizeUsed,
+                                              maxSize.value(), &sizeUsed);
-          aManager);
 
       MOZ_ASSERT(maxSize.value() >= sizeUsed);
 
@@ -1105,9 +1079,7 @@ void nsMultiplexInputStream::SerializeInternal(
   *aSizeUsed = totalSizeUsed.value();
 }
 
-bool nsMultiplexInputStream::Deserialize(
+bool nsMultiplexInputStream::Deserialize(const InputStreamParams& aParams) {
-    const InputStreamParams& aParams,
-    const FileDescriptorArray& aFileDescriptors) {
   if (aParams.type() != InputStreamParams::TMultiplexInputStreamParams) {
     NS_ERROR("Received unknown parameters from the other process!");
     return false;
@@ -1120,8 +1092,8 @@ bool nsMultiplexInputStream::Deserialize(
 
   uint32_t streamCount = streams.Length();
   for (uint32_t index = 0; index < streamCount; index++) {
-    nsCOMPtr<nsIInputStream> stream = InputStreamHelper::DeserializeInputStream(
+    nsCOMPtr<nsIInputStream> stream =
-        streams[index], aFileDescriptors);
+        InputStreamHelper::DeserializeInputStream(streams[index]);
     if (!stream) {
       NS_WARNING("Deserialize failed!");
       return false;

xpcom/io/nsStorageStream.cpp

@@ -377,10 +377,6 @@ class nsStorageInputStream final : public nsIInputStream,
   uint32_t SegOffset(uint32_t aPosition) {
     return aPosition & (mSegmentSize - 1);
   }
-
-  template <typename M>
-  void SerializeInternal(InputStreamParams& aParams, bool aDelayedStart,
-                         uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager);
 };
 
 NS_IMPL_ISUPPORTS(nsStorageInputStream, nsIInputStream, nsISeekableStream,
@@ -589,25 +585,8 @@ void nsStorageInputStream::SerializedComplexity(uint32_t aMaxSize,
   }
 }
 
-void nsStorageInputStream::Serialize(
+void nsStorageInputStream::Serialize(InputStreamParams& aParams,
-    InputStreamParams& aParams, FileDescriptorArray&, bool aDelayedStart,
+                                     uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-void nsStorageInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray&, bool aDelayedStart,
-    uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-template <typename M>
-void nsStorageInputStream::SerializeInternal(InputStreamParams& aParams,
-                                             bool aDelayedStart,
-                                             uint32_t aMaxSize,
-                                             uint32_t* aSizeUsed, M* aManager) {
   MOZ_ASSERT(aSizeUsed);
   *aSizeUsed = 0;
 
@@ -616,8 +595,7 @@ void nsStorageInputStream::SerializeInternal(InputStreamParams& aParams,
   MOZ_ASSERT(NS_SUCCEEDED(rv));
 
   if (remaining >= aMaxSize) {
-    mozilla::ipc::InputStreamHelper::SerializeInputStreamAsPipe(
+    mozilla::ipc::InputStreamHelper::SerializeInputStreamAsPipe(this, aParams);
-        this, aParams, aDelayedStart, aManager);
     return;
   }
 
@@ -649,8 +627,7 @@ void nsStorageInputStream::SerializeInternal(InputStreamParams& aParams,
   aParams = params;
 }
 
-bool nsStorageInputStream::Deserialize(const InputStreamParams& aParams,
+bool nsStorageInputStream::Deserialize(const InputStreamParams& aParams) {
-                                       const FileDescriptorArray&) {
   MOZ_ASSERT_UNREACHABLE(
       "We should never attempt to deserialize a storage "
       "input stream.");

xpcom/io/nsStringStream.cpp

@@ -129,10 +129,6 @@ class nsStringInputStream final : public nsIStringInputStream,
  private:
   ~nsStringInputStream() = default;
 
-  template <typename M>
-  void SerializeInternal(InputStreamParams& aParams, bool aDelayedStart,
-                         uint32_t aMaxSize, uint32_t* aSizeUsed, M* aManager);
-
   size_t Length() const { return mSource ? mSource->Data().Length() : 0; }
 
   size_t LengthRemaining() const { return Length() - mOffset; }
@@ -463,25 +459,8 @@ void nsStringInputStream::SerializedComplexity(uint32_t aMaxSize,
   }
 }
 
-void nsStringInputStream::Serialize(
+void nsStringInputStream::Serialize(InputStreamParams& aParams,
-    InputStreamParams& aParams, FileDescriptorArray& /* aFDs */,
+                                    uint32_t aMaxSize, uint32_t* aSizeUsed) {
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ParentToChildStreamActorManager* aManager) {
-  SerializeInternal(aParams, aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-void nsStringInputStream::Serialize(
-    InputStreamParams& aParams, FileDescriptorArray& /* aFDs */,
-    bool aDelayedStart, uint32_t aMaxSize, uint32_t* aSizeUsed,
-    mozilla::ipc::ChildToParentStreamActorManager* aManager) {
-  SerializeInternal(aParams, aDelayedStart, aMaxSize, aSizeUsed, aManager);
-}
-
-template <typename M>
-void nsStringInputStream::SerializeInternal(InputStreamParams& aParams,
-                                            bool aDelayedStart,
-                                            uint32_t aMaxSize,
-                                            uint32_t* aSizeUsed, M* aManager) {
   ReentrantMonitorAutoEnter lock(mMon);
 
   MOZ_DIAGNOSTIC_ASSERT(!Closed(), "cannot send a closed stream!");
@@ -498,8 +477,7 @@ void nsStringInputStream::SerializeInternal(InputStreamParams& aParams,
       mSource = source;
     }
 
-    InputStreamHelper::SerializeInputStreamAsPipe(this, aParams, aDelayedStart,
+    InputStreamHelper::SerializeInputStreamAsPipe(this, aParams);
-                                                  aManager);
     return;
   }
 
@@ -510,8 +488,7 @@ void nsStringInputStream::SerializeInternal(InputStreamParams& aParams,
   aParams = params;
 }
 
-bool nsStringInputStream::Deserialize(const InputStreamParams& aParams,
+bool nsStringInputStream::Deserialize(const InputStreamParams& aParams) {
-                                      const FileDescriptorArray& /* aFDs */) {
   if (aParams.type() != InputStreamParams::TStringInputStreamParams) {
     NS_ERROR("Received unknown parameters from the other process!");
     return false;

xpcom/tests/gtest/TestNonBlockingAsyncInputStream.cpp

@@ -284,14 +284,9 @@ class QIInputStream final : public nsIInputStream,
   // nsIIPCSerializableInputStream
   void SerializedComplexity(uint32_t, uint32_t*, uint32_t*,
                             uint32_t*) override {}
-  void Serialize(mozilla::ipc::InputStreamParams&, FileDescriptorArray&, bool,
+  void Serialize(mozilla::ipc::InputStreamParams&, uint32_t,
-                 uint32_t, uint32_t*,
+                 uint32_t*) override {}
-                 mozilla::ipc::ParentToChildStreamActorManager*) override {}
+  bool Deserialize(const mozilla::ipc::InputStreamParams&) override {
-  void Serialize(mozilla::ipc::InputStreamParams&, FileDescriptorArray&, bool,
-                 uint32_t, uint32_t*,
-                 mozilla::ipc::ChildToParentStreamActorManager*) override {}
-  bool Deserialize(const mozilla::ipc::InputStreamParams&,
-                   const FileDescriptorArray&) override {
     return false;
   }