--- a/dom/media/AccurateSeekTask.cpp
+++ b/dom/media/AccurateSeekTask.cpp
@@ -398,40 +398,16 @@ AccurateSeekTask::MaybeFinishSeek()
 {
   AssertOwnerThread();
   if (mDoneAudioSeeking && mDoneVideoSeeking) {
     Resolve(__func__); // Call to MDSM::SeekCompleted();
   }
 }
 
 void
-AccurateSeekTask::OnSeekResolved(media::TimeUnit)
-{
-  AssertOwnerThread();
-
-  // We must decode the first samples of active streams, so we can determine
-  // the new stream time. So dispatch tasks to do that.
-  if (!mDoneVideoSeeking) {
-    RequestVideoData();
-  }
-  if (!mDoneAudioSeeking) {
-    RequestAudioData();
-  }
-}
-
-void
-AccurateSeekTask::OnSeekRejected(nsresult aResult)
-{
-  AssertOwnerThread();
-
-  MOZ_ASSERT(NS_FAILED(aResult), "Cancels should also disconnect mSeekRequest");
-  RejectIfExist(aResult, __func__);
-}
-
-void
 AccurateSeekTask::AdjustFastSeekIfNeeded(MediaData* aSample)
 {
   AssertOwnerThread();
   if (mTarget.IsFast() &&
       mTarget.GetTime() > mCurrentTimeBeforeSeek &&
       aSample->mTime < mCurrentTimeBeforeSeek.ToMicroseconds()) {
     // We are doing a fastSeek, but we ended up *before* the previous
     // playback position. This is surprising UX, so switch to an accurate

--- a/dom/media/AccurateSeekTask.h
+++ b/dom/media/AccurateSeekTask.h
@@ -48,20 +48,16 @@ public:
   void RequestAudioData();
 
   nsresult DropAudioUpToSeekTarget(MediaData* aSample);
 
   nsresult DropVideoUpToSeekTarget(MediaData* aSample);
 
   void MaybeFinishSeek();
 
-  void OnSeekResolved(media::TimeUnit);
-
-  void OnSeekRejected(nsresult aResult);
-
   void AdjustFastSeekIfNeeded(MediaData* aSample);
 
   /*
    * Internal state.
    */
   const media::TimeUnit mCurrentTimeBeforeSeek;
   const uint32_t mAudioRate;  // Audio sample rate.
   bool mDoneAudioSeeking;

--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -909,22 +909,20 @@ private:
   }
 
   void DoSeek() override
   {
     // Request the demuxer to perform seek.
     mSeekRequest.Begin(Reader()->Seek(mTask->mTarget, mMaster->Duration())
       ->Then(OwnerThread(), __func__,
              [this] (media::TimeUnit aUnit) {
-               mSeekRequest.Complete();
-               mTask->OnSeekResolved(aUnit);
+               OnSeekResolved(aUnit);
              },
              [this] (nsresult aResult) {
-               mSeekRequest.Complete();
-               mTask->OnSeekRejected(aResult);
+               OnSeekRejected(aResult);
              }));
 
     // Let SeekTask handle the following operations once the demuxer seeking is done.
     mSeekTaskRequest.Begin(mSeekTask->Seek(mMaster->Duration())
       ->Then(OwnerThread(), __func__,
              [this] (const SeekTaskResolveValue& aValue) {
                OnSeekTaskResolved(aValue);
              },
@@ -933,16 +931,36 @@ private:
              }));
   }
 
   int64_t CalculateNewCurrentTime() const override
   {
     return mSeekTask->CalculateNewCurrentTime();
   }
 
+  void OnSeekResolved(media::TimeUnit) {
+    mSeekRequest.Complete();
+
+    // We must decode the first samples of active streams, so we can determine
+    // the new stream time. So dispatch tasks to do that.
+    if (!mTask->mDoneVideoSeeking) {
+      mTask->RequestVideoData();
+    }
+    if (!mTask->mDoneAudioSeeking) {
+      mTask->RequestAudioData();
+    }
+  }
+
+  void OnSeekRejected(nsresult aResult) {
+    mSeekRequest.Complete();
+
+    MOZ_ASSERT(NS_FAILED(aResult), "Cancels should also disconnect mSeekRequest");
+    mTask->RejectIfExist(aResult, __func__);
+  }
+
   void OnSeekTaskResolved(const SeekTaskResolveValue& aValue)
   {
     mSeekTaskRequest.Complete();
 
     if (aValue.mSeekedAudioData) {
       mMaster->Push(aValue.mSeekedAudioData);
       mMaster->mDecodedAudioEndTime = std::max(
         aValue.mSeekedAudioData->GetEndTime(), mMaster->mDecodedAudioEndTime);