diff --git a/dom/media/AbstractThread.cpp b/dom/media/AbstractThread.cpp
index f628920673..4055190b49 100644
--- a/dom/media/AbstractThread.cpp
+++ b/dom/media/AbstractThread.cpp
@@ -80,14 +80,4 @@ AbstractThread::InitStatics()
   sCurrentThreadTLS.set(sMainThread);
 }
 
-#ifdef DEBUG
-void
-TaskDispatcher::AssertIsTailDispatcherIfRequired()
-{
-  AbstractThread* current = AbstractThread::GetCurrent();
-  MOZ_ASSERT_IF(current && current->RequiresTailDispatch(),
-                this == &current->TailDispatcher());
-}
-#endif
-
 } // namespace mozilla
diff --git a/dom/media/MediaDecoderStateMachine.cpp b/dom/media/MediaDecoderStateMachine.cpp
index b7b79d1f25..bb12614429 100644
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -47,7 +47,7 @@ using namespace mozilla::layers;
 using namespace mozilla::dom;
 using namespace mozilla::gfx;
 
-#define NS_DispatchToMainThread(...) CompileError_UseTailDispatchInstead
+#define NS_DispatchToMainThread(...) CompileError_UseAbstractThreadDispatchInstead
 
 // avoid redefined macro in unified build
 #undef DECODER_LOG
@@ -865,12 +865,10 @@ MediaDecoderStateMachine::OnNotDecoded(MediaData::Type aType,
     MOZ_ASSERT(mReader->IsWaitForDataSupported(),
                "Readers that send WAITING_FOR_DATA need to implement WaitForData");
     WaitRequestRef(aType).Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(), __func__,
-                                               &MediaDecoderReader::WaitForData, aType,
-                                               TailDispatcher())
+                                               &MediaDecoderReader::WaitForData, aType)
       ->RefableThen(TaskQueue(), __func__, this,
                     &MediaDecoderStateMachine::OnWaitForDataResolved,
-                    &MediaDecoderStateMachine::OnWaitForDataRejected,
-                    TailDispatcher()));
+                    &MediaDecoderStateMachine::OnWaitForDataRejected));
     return;
   }
 
@@ -1090,7 +1088,7 @@ MediaDecoderStateMachine::CheckIfSeekComplete()
     mDecodeToSeekTarget = false;
     nsCOMPtr<nsIRunnable> task(
       NS_NewRunnableMethod(this, &MediaDecoderStateMachine::SeekCompleted));
-    TailDispatch(TaskQueue(), task.forget());
+    TaskQueue()->Dispatch(task.forget());
   }
 }
 
@@ -1231,7 +1229,7 @@ void MediaDecoderStateMachine::UpdatePlaybackPositionInternal(int64_t aTime)
     mEndTime = aTime;
     nsCOMPtr<nsIRunnable> event =
       NS_NewRunnableMethod(mDecoder, &MediaDecoder::DurationChanged);
-    TailDispatch(AbstractThread::MainThread(), event.forget());
+    AbstractThread::MainThread()->Dispatch(event.forget());
   }
 }
 
@@ -1248,7 +1246,7 @@ void MediaDecoderStateMachine::UpdatePlaybackPosition(int64_t aTime)
         mDecoder,
         &MediaDecoder::PlaybackPositionChanged,
         MediaDecoderEventVisibility::Observable);
-    TailDispatch(AbstractThread::MainThread(), event.forget());
+    AbstractThread::MainThread()->Dispatch(event.forget());
   }
 
   mMetadataManager.DispatchMetadataIfNeeded(mDecoder, aTime);
@@ -1488,8 +1486,8 @@ void MediaDecoderStateMachine::SetDormant(bool aDormant)
       // back to MediaDecoder when we come out of dormant?
       nsRefPtr<MediaDecoder::SeekPromise> unused = mQueuedSeek.mPromise.Ensure(__func__);
     }
-    mPendingSeek.RejectIfExists(__func__, TailDispatcher());
-    mCurrentSeek.RejectIfExists(__func__, TailDispatcher());
+    mPendingSeek.RejectIfExists(__func__);
+    mCurrentSeek.RejectIfExists(__func__);
     SetState(DECODER_STATE_DORMANT);
 
     Reset();
@@ -1501,7 +1499,7 @@ void MediaDecoderStateMachine::SetDormant(bool aDormant)
     // on that in other places (i.e. seeking), so it seems reasonable to rely on
     // it here as well.
     nsCOMPtr<nsIRunnable> r = NS_NewRunnableMethod(mReader, &MediaDecoderReader::ReleaseMediaResources);
-    TailDispatch(DecodeTaskQueue(), r.forget());
+    DecodeTaskQueue()->Dispatch(r.forget());
     // There's now no possibility of mPendingWakeDecoder being needed again. Revoke it.
     mPendingWakeDecoder = nullptr;
     mDecoder->GetReentrantMonitor().NotifyAll();
@@ -1667,12 +1665,12 @@ MediaDecoderStateMachine::Seek(SeekTarget aTarget)
 
   if (mState < DECODER_STATE_DECODING) {
     DECODER_LOG("Seek() Not Enough Data to continue at this stage, queuing seek");
-    mQueuedSeek.RejectIfExists(__func__, TailDispatcher());
+    mQueuedSeek.RejectIfExists(__func__);
     mQueuedSeek.mTarget = aTarget;
     return mQueuedSeek.mPromise.Ensure(__func__);
   }
-  mQueuedSeek.RejectIfExists(__func__, TailDispatcher());
-  mPendingSeek.RejectIfExists(__func__, TailDispatcher());
+  mQueuedSeek.RejectIfExists(__func__);
+  mPendingSeek.RejectIfExists(__func__);
   mPendingSeek.mTarget = aTarget;
 
   DECODER_LOG("Changed state to SEEKING (to %lld)", mPendingSeek.mTarget.mTime);
@@ -1719,7 +1717,7 @@ MediaDecoderStateMachine::EnqueueDecodeFirstFrameTask()
 
   nsCOMPtr<nsIRunnable> task(
     NS_NewRunnableMethod(this, &MediaDecoderStateMachine::CallDecodeFirstFrame));
-  TailDispatch(TaskQueue(), task.forget());
+  TaskQueue()->Dispatch(task.forget());
   return NS_OK;
 }
 
@@ -1793,7 +1791,7 @@ MediaDecoderStateMachine::DispatchDecodeTasksIfNeeded()
                 VideoQueue().Duration());
     nsCOMPtr<nsIRunnable> task = NS_NewRunnableMethod(
         this, &MediaDecoderStateMachine::SetReaderIdle);
-    TailDispatch(DecodeTaskQueue(), task.forget());
+    DecodeTaskQueue()->Dispatch(task.forget());
   }
 }
 
@@ -1803,7 +1801,7 @@ MediaDecoderStateMachine::InitiateSeek()
   MOZ_ASSERT(OnTaskQueue());
   AssertCurrentThreadInMonitor();
 
-  mCurrentSeek.RejectIfExists(__func__, TailDispatcher());
+  mCurrentSeek.RejectIfExists(__func__);
   mCurrentSeek.Steal(mPendingSeek);
 
   // Bound the seek time to be inside the media range.
@@ -1825,7 +1823,7 @@ MediaDecoderStateMachine::InitiateSeek()
     nsCOMPtr<nsIRunnable> event =
       NS_NewRunnableMethodWithArg<int64_t>(mDecoder, &MediaDecoder::RecreateDecodedStream,
                                           seekTime - mStartTime);
-    TailDispatch(AbstractThread::MainThread(), event.forget());
+    AbstractThread::MainThread()->Dispatch(event.forget());
   }
 
   mDropAudioUntilNextDiscontinuity = HasAudio();
@@ -1848,7 +1846,7 @@ MediaDecoderStateMachine::InitiateSeek()
         mDecoder,
         &MediaDecoder::SeekingStarted,
         mCurrentSeek.mTarget.mEventVisibility);
-  TailDispatch(AbstractThread::MainThread(), startEvent.forget());
+  AbstractThread::MainThread()->Dispatch(startEvent.forget());
 
   // Reset our state machine and decoding pipeline before seeking.
   Reset();
@@ -1856,11 +1854,10 @@ MediaDecoderStateMachine::InitiateSeek()
   // Do the seek.
   mSeekRequest.Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(), __func__,
                                     &MediaDecoderReader::Seek, mCurrentSeek.mTarget.mTime,
-                                    GetEndTime(), TailDispatcher())
+                                    GetEndTime())
     ->RefableThen(TaskQueue(), __func__, this,
                   &MediaDecoderStateMachine::OnSeekCompleted,
-                  &MediaDecoderStateMachine::OnSeekFailed,
-                  TailDispatcher()));
+                  &MediaDecoderStateMachine::OnSeekFailed));
 }
 
 nsresult
@@ -1967,11 +1964,10 @@ MediaDecoderStateMachine::EnsureVideoDecodeTaskQueued()
 
   mVideoDataRequest.Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(), __func__,
                                          &MediaDecoderReader::RequestVideoData,
-                                         skipToNextKeyFrame, currentTime, TailDispatcher())
+                                         skipToNextKeyFrame, currentTime)
     ->RefableThen(TaskQueue(), __func__, this,
                   &MediaDecoderStateMachine::OnVideoDecoded,
-                  &MediaDecoderStateMachine::OnVideoNotDecoded,
-                  TailDispatcher()));
+                  &MediaDecoderStateMachine::OnVideoNotDecoded));
   return NS_OK;
 }
 
@@ -2111,7 +2107,7 @@ MediaDecoderStateMachine::DecodeError()
   // machine.
   nsCOMPtr<nsIRunnable> event =
     NS_NewRunnableMethod(mDecoder, &MediaDecoder::DecodeError);
-  TailDispatch(AbstractThread::MainThread(), event.forget());
+  AbstractThread::MainThread()->Dispatch(event.forget());
 }
 
 void
@@ -2185,7 +2181,7 @@ MediaDecoderStateMachine::EnqueueLoadedMetadataEvent()
                                     MediaDecoderEventVisibility::Observable;
   nsCOMPtr<nsIRunnable> metadataLoadedEvent =
     new MetadataEventRunner(mDecoder, info, mMetadataTags, visibility);
-  TailDispatch(AbstractThread::MainThread(), metadataLoadedEvent.forget());
+  AbstractThread::MainThread()->Dispatch(metadataLoadedEvent.forget());
   mSentLoadedMetadataEvent = true;
 }
 
@@ -2200,7 +2196,7 @@ MediaDecoderStateMachine::EnqueueFirstFrameLoadedEvent()
                                     MediaDecoderEventVisibility::Observable;
   nsCOMPtr<nsIRunnable> event =
     new FirstFrameLoadedEventRunner(mDecoder, info, visibility);
-  TailDispatch(AbstractThread::MainThread(), event.forget());
+  AbstractThread::MainThread()->Dispatch(event.forget());
   mSentFirstFrameLoadedEvent = true;
 }
 
@@ -2251,22 +2247,19 @@ MediaDecoderStateMachine::DecodeFirstFrame()
   } else {
     if (HasAudio()) {
       mAudioDataRequest.Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(),
-                                             __func__, &MediaDecoderReader::RequestAudioData,
-                                             TailDispatcher())
+                                             __func__, &MediaDecoderReader::RequestAudioData)
         ->RefableThen(TaskQueue(), __func__, this,
                       &MediaDecoderStateMachine::OnAudioDecoded,
-                      &MediaDecoderStateMachine::OnAudioNotDecoded,
-                      TailDispatcher()));
+                      &MediaDecoderStateMachine::OnAudioNotDecoded));
     }
     if (HasVideo()) {
       mVideoDecodeStartTime = TimeStamp::Now();
       mVideoDataRequest.Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(),
                                              __func__, &MediaDecoderReader::RequestVideoData, false,
-                                             int64_t(0), TailDispatcher())
+                                             int64_t(0))
         ->RefableThen(TaskQueue(), __func__, this,
                       &MediaDecoderStateMachine::OnVideoDecoded,
-                      &MediaDecoderStateMachine::OnVideoNotDecoded,
-                      TailDispatcher()));
+                      &MediaDecoderStateMachine::OnVideoNotDecoded));
     }
   }
 
@@ -2450,7 +2443,7 @@ MediaDecoderStateMachine::SeekCompleted()
   // if we need to buffer after the seek.
   mQuickBuffering = false;
 
-  mCurrentSeek.Resolve(mState == DECODER_STATE_COMPLETED, __func__, TailDispatcher());
+  mCurrentSeek.Resolve(mState == DECODER_STATE_COMPLETED, __func__);
   ScheduleStateMachine();
 
   if (video) {
@@ -2458,7 +2451,7 @@ MediaDecoderStateMachine::SeekCompleted()
     RenderVideoFrame(video, TimeStamp::Now());
     nsCOMPtr<nsIRunnable> event =
       NS_NewRunnableMethod(mDecoder, &MediaDecoder::Invalidate);
-    TailDispatch(AbstractThread::MainThread(), event.forget());
+    AbstractThread::MainThread()->Dispatch(event.forget());
   }
 }
 
@@ -2530,8 +2523,7 @@ MediaDecoderStateMachine::FinishShutdown()
   TaskQueue()->BeginShutdown()->Then(AbstractThread::MainThread(), __func__,
                                      disposer.get(),
                                      &DecoderDisposer::OnTaskQueueShutdown,
-                                     &DecoderDisposer::OnTaskQueueShutdown,
-                                     TailDispatcher());
+                                     &DecoderDisposer::OnTaskQueueShutdown);
 }
 
 nsresult MediaDecoderStateMachine::RunStateMachine()
@@ -2557,9 +2549,10 @@ nsresult MediaDecoderStateMachine::RunStateMachine()
     }
 
     case DECODER_STATE_SHUTDOWN: {
-      mQueuedSeek.RejectIfExists(__func__, TailDispatcher());
-      mPendingSeek.RejectIfExists(__func__, TailDispatcher());
-      mCurrentSeek.RejectIfExists(__func__, TailDispatcher());
+      mQueuedSeek.RejectIfExists(__func__);
+      mPendingSeek.RejectIfExists(__func__);
+      mCurrentSeek.RejectIfExists(__func__);
+
       if (IsPlaying()) {
         StopPlayback();
       }
@@ -2570,7 +2563,7 @@ nsresult MediaDecoderStateMachine::RunStateMachine()
       // the queue to spin down.
       nsCOMPtr<nsIRunnable> task
         = NS_NewRunnableMethod(this, &MediaDecoderStateMachine::ShutdownReader);
-      TailDispatch(DecodeTaskQueue(), task.forget());
+      DecodeTaskQueue()->Dispatch(task.forget());
 
       DECODER_LOG("Shutdown started");
       return NS_OK;
@@ -2595,11 +2588,10 @@ nsresult MediaDecoderStateMachine::RunStateMachine()
       if (!mMetadataRequest.Exists()) {
         DECODER_LOG("Dispatching AsyncReadMetadata");
         mMetadataRequest.Begin(ProxyMediaCall(DecodeTaskQueue(), mReader.get(), __func__,
-                                              &MediaDecoderReader::AsyncReadMetadata, TailDispatcher())
+                                              &MediaDecoderReader::AsyncReadMetadata)
           ->RefableThen(TaskQueue(), __func__, this,
                         &MediaDecoderStateMachine::OnMetadataRead,
-                        &MediaDecoderStateMachine::OnMetadataNotRead,
-                        TailDispatcher()));
+                        &MediaDecoderStateMachine::OnMetadataNotRead));
       }
       return NS_OK;
     }
@@ -2720,7 +2712,7 @@ nsresult MediaDecoderStateMachine::RunStateMachine()
 
         nsCOMPtr<nsIRunnable> event =
           NS_NewRunnableMethod(mDecoder, &MediaDecoder::PlaybackEnded);
-        TailDispatch(AbstractThread::MainThread(), event.forget());
+        AbstractThread::MainThread()->Dispatch(event.forget());
 
         mSentPlaybackEndedEvent = true;
       }
@@ -2774,7 +2766,7 @@ MediaDecoderStateMachine::Reset()
 
   nsCOMPtr<nsIRunnable> resetTask =
     NS_NewRunnableMethod(mReader, &MediaDecoderReader::ResetDecode);
-  TailDispatch(DecodeTaskQueue(), resetTask.forget());
+  DecodeTaskQueue()->Dispatch(resetTask.forget());
 }
 
 void MediaDecoderStateMachine::RenderVideoFrame(VideoData* aData,
@@ -2805,7 +2797,7 @@ void MediaDecoderStateMachine::RenderVideoFrame(VideoData* aData,
           mCorruptFrames.mean() >= 1 /* 10% */) {
         nsCOMPtr<nsIRunnable> task =
           NS_NewRunnableMethod(mReader, &MediaDecoderReader::DisableHardwareAcceleration);
-        TailDispatch(DecodeTaskQueue(), task.forget());
+        DecodeTaskQueue()->Dispatch(task.forget());
         mDisabledHardwareAcceleration = true;
       }
     } else {
diff --git a/dom/media/MediaDecoderStateMachine.h b/dom/media/MediaDecoderStateMachine.h
index 6e40c291de..15b745003e 100644
--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -328,22 +328,6 @@ public:
 
   void NotifyDataArrived(const char* aBuffer, uint32_t aLength, int64_t aOffset);
 
-  // Returns the tail dispatcher associated with TaskQueue(), which will fire
-  // its tasks when the current task completes. May only be called when running
-  // in TaskQueue().
-  TaskDispatcher& TailDispatcher()
-  {
-    MOZ_ASSERT(OnTaskQueue());
-    return TaskQueue()->TailDispatcher();
-  }
-
-  // Convenience method to perform a tail dispatch.
-  void TailDispatch(AbstractThread* aThread,
-                    already_AddRefed<nsIRunnable> aTask)
-  {
-    TailDispatcher().AddTask(aThread, Move(aTask));
-  }
-
   // Returns the state machine task queue.
   MediaTaskQueue* TaskQueue() const { return mTaskQueue; }
 
@@ -805,7 +789,7 @@ protected:
         mRequest.Begin(mMediaTimer->WaitUntil(mTarget, __func__)->RefableThen(
           mSelf->TaskQueue(), __func__, mSelf,
           &MediaDecoderStateMachine::OnDelayedSchedule,
-          &MediaDecoderStateMachine::NotReached, mSelf->TailDispatcher()));
+          &MediaDecoderStateMachine::NotReached));
       }
 
       void CompleteRequest()
@@ -895,17 +879,17 @@ protected:
     return mTarget.IsValid();
   }
 
-  void Resolve(bool aAtEnd, const char* aCallSite, TaskDispatcher& aDispatcher)
+  void Resolve(bool aAtEnd, const char* aCallSite)
   {
     mTarget.Reset();
     MediaDecoder::SeekResolveValue val(aAtEnd, mTarget.mEventVisibility);
-    mPromise.Resolve(val, aCallSite, aDispatcher);
+    mPromise.Resolve(val, aCallSite);
   }
 
-  void RejectIfExists(const char* aCallSite, TaskDispatcher& aDispatcher)
+  void RejectIfExists(const char* aCallSite)
   {
     mTarget.Reset();
-    mPromise.RejectIfExists(true, aCallSite, aDispatcher);
+    mPromise.RejectIfExists(true, aCallSite);
   }
 
   ~SeekJob()
diff --git a/dom/media/MediaPromise.h b/dom/media/MediaPromise.h
index e7b998b7e7..7551d4ce6f 100644
--- a/dom/media/MediaPromise.h
+++ b/dom/media/MediaPromise.h
@@ -10,7 +10,6 @@
 #include "prlog.h"
 
 #include "AbstractThread.h"
-#include "TaskDispatcher.h"
 
 #include "nsTArray.h"
 #include "nsThreadUtils.h"
@@ -75,20 +74,18 @@ public:
   class Private;
 
   static nsRefPtr<MediaPromise>
-  CreateAndResolve(ResolveValueType aResolveValue, const char* aResolveSite,
-                   TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+  CreateAndResolve(ResolveValueType aResolveValue, const char* aResolveSite)
   {
     nsRefPtr<typename MediaPromise::Private> p = new MediaPromise::Private(aResolveSite);
-    p->Resolve(aResolveValue, aResolveSite, aDispatcher);
+    p->Resolve(aResolveValue, aResolveSite);
     return Move(p);
   }
 
   static nsRefPtr<MediaPromise>
-  CreateAndReject(RejectValueType aRejectValue, const char* aRejectSite,
-                  TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+  CreateAndReject(RejectValueType aRejectValue, const char* aRejectSite)
   {
     nsRefPtr<typename MediaPromise::Private> p = new MediaPromise::Private(aRejectSite);
-    p->Reject(aRejectValue, aRejectSite, aDispatcher);
+    p->Reject(aRejectValue, aRejectSite);
     return Move(p);
   }
 
@@ -174,8 +171,7 @@ protected:
 
     explicit ThenValueBase(const char* aCallSite) : mCallSite(aCallSite) {}
 
-    virtual void Dispatch(MediaPromise *aPromise,
-                          TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>()) = 0;
+    virtual void Dispatch(MediaPromise *aPromise) = 0;
 
   protected:
     virtual void DoResolve(ResolveValueType aResolveValue) = 0;
@@ -223,7 +219,7 @@ protected:
       , mResolveMethod(aResolveMethod)
       , mRejectMethod(aRejectMethod) {}
 
-    void Dispatch(MediaPromise *aPromise, TaskDispatcher& aDispatcher) override
+    void Dispatch(MediaPromise *aPromise) override
     {
       aPromise->mMutex.AssertCurrentThreadOwns();
       MOZ_ASSERT(!aPromise->IsPending());
@@ -239,7 +235,7 @@ protected:
       // then shut down the thread or task queue that the promise result would
       // be dispatched on. So we unfortunately can't assert that promise
       // dispatch succeeds. :-(
-      aDispatcher.AddTask(mResponseTarget, runnable.forget(), AbstractThread::DontAssertDispatchSuccess);
+      mResponseTarget->Dispatch(runnable.forget(), AbstractThread::DontAssertDispatchSuccess);
     }
 
 #ifdef DEBUG
@@ -308,18 +304,8 @@ public:
 
   template<typename ThisType, typename ResolveMethodType, typename RejectMethodType>
   already_AddRefed<Consumer> RefableThen(AbstractThread* aResponseThread, const char* aCallSite, ThisType* aThisVal,
-                                         ResolveMethodType aResolveMethod, RejectMethodType aRejectMethod,
-                                         TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+                                         ResolveMethodType aResolveMethod, RejectMethodType aRejectMethod)
   {
-    // {Refable,}Then() rarely dispatch directly - they do so only in the case
-    // where the promise has already been resolved by the time {Refable,}Then()
-    // is invoked. This case is rare, but it _can_ happen, which makes it a ripe
-    // target for race bugs. So we do an extra assertion here to make sure our
-    // caller is using tail dispatch correctly no matter what, rather than
-    // relying on the assertion in Dispatch(), which may be called extremely
-    // infrequently.
-    aDispatcher.AssertIsTailDispatcherIfRequired();
-
     MutexAutoLock lock(mMutex);
     MOZ_ASSERT(aResponseThread->IsDispatchReliable());
     MOZ_DIAGNOSTIC_ASSERT(!IsExclusive || !mHaveConsumer);
@@ -329,7 +315,7 @@ public:
     PROMISE_LOG("%s invoking Then() [this=%p, thenValue=%p, aThisVal=%p, isPending=%d]",
                 aCallSite, this, thenValue.get(), aThisVal, (int) IsPending());
     if (!IsPending()) {
-      thenValue->Dispatch(this, aDispatcher);
+      thenValue->Dispatch(this);
     } else {
       mThenValues.AppendElement(thenValue);
     }
@@ -339,16 +325,14 @@ public:
 
   template<typename ThisType, typename ResolveMethodType, typename RejectMethodType>
   void Then(AbstractThread* aResponseThread, const char* aCallSite, ThisType* aThisVal,
-            ResolveMethodType aResolveMethod, RejectMethodType aRejectMethod,
-            TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+            ResolveMethodType aResolveMethod, RejectMethodType aRejectMethod)
   {
     nsRefPtr<Consumer> c =
-      RefableThen(aResponseThread, aCallSite, aThisVal, aResolveMethod, aRejectMethod, aDispatcher);
+      RefableThen(aResponseThread, aCallSite, aThisVal, aResolveMethod, aRejectMethod);
     return;
   }
 
-  void ChainTo(already_AddRefed<Private> aChainedPromise, const char* aCallSite,
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+  void ChainTo(already_AddRefed<Private> aChainedPromise, const char* aCallSite)
   {
     MutexAutoLock lock(mMutex);
     MOZ_DIAGNOSTIC_ASSERT(!IsExclusive || !mHaveConsumer);
@@ -357,7 +341,7 @@ public:
     PROMISE_LOG("%s invoking Chain() [this=%p, chainedPromise=%p, isPending=%d]",
                 aCallSite, this, chainedPromise.get(), (int) IsPending());
     if (!IsPending()) {
-      ForwardTo(chainedPromise, aDispatcher);
+      ForwardTo(chainedPromise);
     } else {
       mChainedPromises.AppendElement(chainedPromise);
     }
@@ -365,27 +349,27 @@ public:
 
 protected:
   bool IsPending() { return mResolveValue.isNothing() && mRejectValue.isNothing(); }
-  void DispatchAll(TaskDispatcher& aDispatcher)
+  void DispatchAll()
   {
     mMutex.AssertCurrentThreadOwns();
     for (size_t i = 0; i < mThenValues.Length(); ++i) {
-      mThenValues[i]->Dispatch(this, aDispatcher);
+      mThenValues[i]->Dispatch(this);
     }
     mThenValues.Clear();
 
     for (size_t i = 0; i < mChainedPromises.Length(); ++i) {
-      ForwardTo(mChainedPromises[i], aDispatcher);
+      ForwardTo(mChainedPromises[i]);
     }
     mChainedPromises.Clear();
   }
 
-  void ForwardTo(Private* aOther, TaskDispatcher& aDispatcher)
+  void ForwardTo(Private* aOther)
   {
     MOZ_ASSERT(!IsPending());
     if (mResolveValue.isSome()) {
-      aOther->Resolve(mResolveValue.ref(), "<chained promise>", aDispatcher);
+      aOther->Resolve(mResolveValue.ref(), "<chained promise>");
     } else {
-      aOther->Reject(mRejectValue.ref(), "<chained promise>", aDispatcher);
+      aOther->Reject(mRejectValue.ref(), "<chained promise>");
     }
   }
 
@@ -413,24 +397,22 @@ class MediaPromise<ResolveValueT, RejectValueT, IsExclusive>::Private
 public:
   explicit Private(const char* aCreationSite) : MediaPromise(aCreationSite) {}
 
-  void Resolve(ResolveValueT aResolveValue, const char* aResolveSite,
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+  void Resolve(ResolveValueT aResolveValue, const char* aResolveSite)
   {
     MutexAutoLock lock(mMutex);
     MOZ_ASSERT(IsPending());
     PROMISE_LOG("%s resolving MediaPromise (%p created at %s)", aResolveSite, this, mCreationSite);
     mResolveValue.emplace(aResolveValue);
-    DispatchAll(aDispatcher);
+    DispatchAll();
   }
 
-  void Reject(RejectValueT aRejectValue, const char* aRejectSite,
-              TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+  void Reject(RejectValueT aRejectValue, const char* aRejectSite)
   {
     MutexAutoLock lock(mMutex);
     MOZ_ASSERT(IsPending());
     PROMISE_LOG("%s rejecting MediaPromise (%p created at %s)", aRejectSite, this, mCreationSite);
     mRejectValue.emplace(aRejectValue);
-    DispatchAll(aDispatcher);
+    DispatchAll();
   }
 };
 
@@ -491,44 +473,40 @@ public:
   }
 
   void Resolve(typename PromiseType::ResolveValueType aResolveValue,
-               const char* aMethodName,
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+               const char* aMethodName)
   {
     if (mMonitor) {
       mMonitor->AssertCurrentThreadOwns();
     }
     MOZ_ASSERT(mPromise);
-    mPromise->Resolve(aResolveValue, aMethodName, aDispatcher);
+    mPromise->Resolve(aResolveValue, aMethodName);
     mPromise = nullptr;
   }
 
   void ResolveIfExists(typename PromiseType::ResolveValueType aResolveValue,
-                       const char* aMethodName,
-                       TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+                       const char* aMethodName)
   {
     if (!IsEmpty()) {
-      Resolve(aResolveValue, aMethodName, aDispatcher);
+      Resolve(aResolveValue, aMethodName);
     }
   }
 
   void Reject(typename PromiseType::RejectValueType aRejectValue,
-              const char* aMethodName,
-              TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+              const char* aMethodName)
   {
     if (mMonitor) {
       mMonitor->AssertCurrentThreadOwns();
     }
     MOZ_ASSERT(mPromise);
-    mPromise->Reject(aRejectValue, aMethodName, aDispatcher);
+    mPromise->Reject(aRejectValue, aMethodName);
     mPromise = nullptr;
   }
 
   void RejectIfExists(typename PromiseType::RejectValueType aRejectValue,
-                      const char* aMethodName,
-                      TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+                      const char* aMethodName)
   {
     if (!IsEmpty()) {
-      Reject(aRejectValue, aMethodName, aDispatcher);
+      Reject(aRejectValue, aMethodName);
     }
   }
 
@@ -664,13 +642,12 @@ private:
 
 template<typename PromiseType>
 static nsRefPtr<PromiseType>
-ProxyInternal(AbstractThread* aTarget, MethodCallBase<PromiseType>* aMethodCall, const char* aCallerName,
-              TaskDispatcher& aDispatcher)
+ProxyInternal(AbstractThread* aTarget, MethodCallBase<PromiseType>* aMethodCall, const char* aCallerName)
 {
   nsRefPtr<typename PromiseType::Private> p = new (typename PromiseType::Private)(aCallerName);
   nsRefPtr<ProxyRunnable<PromiseType>> r = new ProxyRunnable<PromiseType>(p, aMethodCall);
   MOZ_ASSERT(aTarget->IsDispatchReliable());
-  aDispatcher.AddTask(aTarget, r.forget());
+  aTarget->Dispatch(r.forget());
   return Move(p);
 }
 
@@ -679,34 +656,31 @@ ProxyInternal(AbstractThread* aTarget, MethodCallBase<PromiseType>* aMethodCall,
 template<typename PromiseType, typename ThisType>
 static nsRefPtr<PromiseType>
 ProxyMediaCall(AbstractThread* aTarget, ThisType* aThisVal, const char* aCallerName,
-               nsRefPtr<PromiseType>(ThisType::*aMethod)(),
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+               nsRefPtr<PromiseType>(ThisType::*aMethod)())
 {
   typedef detail::MethodCallWithNoArgs<PromiseType, ThisType> MethodCallType;
   MethodCallType* methodCall = new MethodCallType(aThisVal, aMethod);
-  return detail::ProxyInternal(aTarget, methodCall, aCallerName, aDispatcher);
+  return detail::ProxyInternal(aTarget, methodCall, aCallerName);
 }
 
 template<typename PromiseType, typename ThisType, typename Arg1Type>
 static nsRefPtr<PromiseType>
 ProxyMediaCall(AbstractThread* aTarget, ThisType* aThisVal, const char* aCallerName,
-               nsRefPtr<PromiseType>(ThisType::*aMethod)(Arg1Type), Arg1Type aArg1,
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+               nsRefPtr<PromiseType>(ThisType::*aMethod)(Arg1Type), Arg1Type aArg1)
 {
   typedef detail::MethodCallWithOneArg<PromiseType, ThisType, Arg1Type> MethodCallType;
   MethodCallType* methodCall = new MethodCallType(aThisVal, aMethod, aArg1);
-  return detail::ProxyInternal(aTarget, methodCall, aCallerName, aDispatcher);
+  return detail::ProxyInternal(aTarget, methodCall, aCallerName);
 }
 
 template<typename PromiseType, typename ThisType, typename Arg1Type, typename Arg2Type>
 static nsRefPtr<PromiseType>
 ProxyMediaCall(AbstractThread* aTarget, ThisType* aThisVal, const char* aCallerName,
-               nsRefPtr<PromiseType>(ThisType::*aMethod)(Arg1Type, Arg2Type), Arg1Type aArg1, Arg2Type aArg2,
-               TaskDispatcher& aDispatcher = PassByRef<AutoTaskDispatcher>())
+               nsRefPtr<PromiseType>(ThisType::*aMethod)(Arg1Type, Arg2Type), Arg1Type aArg1, Arg2Type aArg2)
 {
   typedef detail::MethodCallWithTwoArgs<PromiseType, ThisType, Arg1Type, Arg2Type> MethodCallType;
   MethodCallType* methodCall = new MethodCallType(aThisVal, aMethod, aArg1, aArg2);
-  return detail::ProxyInternal(aTarget, methodCall, aCallerName, aDispatcher);
+  return detail::ProxyInternal(aTarget, methodCall, aCallerName);
 }
 
 #undef PROMISE_LOG
diff --git a/dom/media/TaskDispatcher.h b/dom/media/TaskDispatcher.h
index 6fd7e6f454..0cd366a754 100644
--- a/dom/media/TaskDispatcher.h
+++ b/dom/media/TaskDispatcher.h
@@ -44,12 +44,6 @@ public:
   virtual void AddTask(AbstractThread* aThread,
                        already_AddRefed<nsIRunnable> aRunnable,
                        AbstractThread::DispatchFailureHandling aFailureHandling = AbstractThread::AssertDispatchSuccess) = 0;
-
-#ifdef DEBUG
-  void AssertIsTailDispatcherIfRequired();
-#else
-  void AssertIsTailDispatcherIfRequired() {}
-#endif
 };
 
 /*