--- a/netwerk/ipc/DocumentLoadListener.cpp
+++ b/netwerk/ipc/DocumentLoadListener.cpp
@@ -522,16 +522,19 @@ auto DocumentLoadListener::Open(
   }
 
   if (auto* ctx = GetBrowsingContext()) {
     ctx->StartDocumentLoad(this);
   }
 
   *aRv = NS_OK;
   mOpenPromise = new OpenPromise::Private(__func__);
+  // We make the promise use direct task dispatch in order to reduce the number
+  // of event loops iterations.
+  mOpenPromise->UseDirectTaskDispatch(__func__);
   return mOpenPromise;
 }
 
 /* static */
 bool DocumentLoadListener::OpenFromParent(
     dom::CanonicalBrowsingContext* aBrowsingContext,
     nsDocShellLoadState* aLoadState, uint64_t aOuterWindowId,
     uint32_t* aOutIdent) {

--- a/netwerk/ipc/ParentProcessDocumentChannel.cpp
+++ b/netwerk/ipc/ParentProcessDocumentChannel.cpp
@@ -61,16 +61,19 @@ ParentProcessDocumentChannel::RedirectTo
       NS_ASSERTION(false, msg.get());
       return RedirectToRealChannelPromise::CreateAndResolve(
           NS_ERROR_CONTENT_BLOCKED, __func__);
     }
   }
   mStreamFilterEndpoints = std::move(aStreamFilterEndpoints);
 
   RefPtr<RedirectToRealChannelPromise> p = mPromise.Ensure(__func__);
+  // We make the promise use direct task dispatch in order to reduce the number
+  // of event loops iterations.
+  mPromise.UseDirectTaskDispatch(__func__);
 
   nsresult rv =
       gHttpHandler->AsyncOnChannelRedirect(this, channel, aRedirectFlags);
   if (NS_FAILED(rv)) {
     LOG(
         ("ParentProcessDocumentChannel RedirectToRealChannel "
          "AsyncOnChannelRedirect failed [this=%p "
          "aRv=%d]",
@@ -171,28 +174,32 @@ NS_IMETHODIMP ParentProcessDocumentChann
         // RedirectToRealChannelPromise given as parameter.
         RefPtr<RedirectToRealChannelPromise> p =
             self->RedirectToRealChannel(
                     std::move(aResolveValue.mStreamFilterEndpoints),
                     aResolveValue.mRedirectFlags, aResolveValue.mLoadFlags)
                 ->Then(
                     GetCurrentThreadSerialEventTarget(), __func__,
                     [self](RedirectToRealChannelPromise::ResolveOrRejectValue&&
-                               aValue) {
+                               aValue) -> RefPtr<RedirectToRealChannelPromise> {
                       MOZ_ASSERT(aValue.IsResolve());
                       nsresult rv = aValue.ResolveValue();
                       if (NS_FAILED(rv)) {
                         self->DisconnectChildListeners(rv, rv);
                       }
                       self->mLoadGroup = nullptr;
                       self->mListener = nullptr;
                       self->mCallbacks = nullptr;
                       self->RemoveObserver();
-                      return RedirectToRealChannelPromise::
-                          CreateAndResolveOrReject(std::move(aValue), __func__);
+                      auto p =
+                          MakeRefPtr<RedirectToRealChannelPromise::Private>(
+                              __func__);
+                      p->UseDirectTaskDispatch(__func__);
+                      p->ResolveOrReject(std::move(aValue), __func__);
+                      return p;
                     });
         // We chain the promise the DLL is waiting on to the one returned by
         // RedirectToRealChannel. As soon as the promise returned is
         // resolved or rejected, so will the DLL's promise.
         p->ChainTo(aResolveValue.mPromise.forget(), __func__);
       },
       [self](DocumentLoadListener::OpenPromiseFailedType&& aRejectValue) {
         self->DisconnectChildListeners(aRejectValue.mStatus,