--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -1394,33 +1394,33 @@ private:
              },
              [this] (const SeekTaskRejectValue& aValue) {
                OnSeekTaskRejected(aValue);
              }));
 
     if (!mTask->IsVideoRequestPending() && mTask->NeedMoreVideo()) {
       mTask->RequestVideoData();
     }
-    mTask->MaybeFinishSeek(); // Might resolve mSeekTaskPromise and modify audio queue.
+    MaybeFinishSeek(); // Might resolve mSeekTaskPromise and modify audio queue.
   }
 
   void HandleAudioDecoded(MediaData* aAudio) override
   {
     MOZ_ASSERT(aAudio);
     MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
     // The MDSM::mDecodedAudioEndTime will be updated once the whole SeekTask is
     // resolved.
 
     SSAMPLELOG("OnAudioDecoded [%lld,%lld]", aAudio->mTime, aAudio->GetEndTime());
 
     // We accept any audio data here.
     mTask->mSeekedAudioData = aAudio;
 
-    mTask->MaybeFinishSeek();
+    MaybeFinishSeek();
   }
 
   void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) override
   {
     MOZ_ASSERT(aVideo);
     MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
     // The MDSM::mDecodedVideoEndTime will be updated once the whole SeekTask is
@@ -1432,33 +1432,33 @@ private:
       mTask->mSeekedVideoData = aVideo;
     }
 
     if (mTask->NeedMoreVideo()) {
       mTask->RequestVideoData();
       return;
     }
 
-    mTask->MaybeFinishSeek();
+    MaybeFinishSeek();
   }
 
   void HandleNotDecoded(MediaData::Type aType, const MediaResult& aError) override
   {
     switch (aType) {
     case MediaData::AUDIO_DATA:
     {
       MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
       SSAMPLELOG("OnAudioNotDecoded (aError=%u)", aError.Code());
 
       // We don't really handle audio deocde error here. Let MDSM to trigger further
       // audio decoding tasks if it needs to play audio, and MDSM will then receive
       // the decoding state from MediaDecoderReader.
 
-      mTask->MaybeFinishSeek();
+      MaybeFinishSeek();
       break;
     }
     case MediaData::VIDEO_DATA:
     {
       MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
       SSAMPLELOG("OnVideoNotDecoded (aError=%u)", aError.Code());
 
@@ -1481,64 +1481,64 @@ private:
           default:
             // Reject the promise since we can't finish video seek anyway.
             mTask->RejectIfExist(aError, __func__);
             break;
         }
         return;
       }
 
-      mTask->MaybeFinishSeek();
+      MaybeFinishSeek();
       break;
     }
     default:
       MOZ_ASSERT_UNREACHABLE("We cannot handle RAW_DATA or NULL_DATA here.");
     }
   }
 
   void HandleAudioWaited(MediaData::Type aType) override
   {
     MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
     // We don't make an audio decode request here, instead, let MDSM to
     // trigger further audio decode tasks if MDSM itself needs to play audio.
-    mTask->MaybeFinishSeek();
+    MaybeFinishSeek();
   }
 
   void HandleVideoWaited(MediaData::Type aType) override
   {
     MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
     if (mTask->NeedMoreVideo()) {
       mTask->RequestVideoData();
       return;
     }
-    mTask->MaybeFinishSeek();
+    MaybeFinishSeek();
   }
 
   void HandleNotWaited(const WaitForDataRejectValue& aRejection) override
   {
     MOZ_ASSERT(mSeekTaskRequest.Exists(), "Seek shouldn't be finished");
 
     switch(aRejection.mType) {
     case MediaData::AUDIO_DATA:
     {
       // We don't make an audio decode request here, instead, let MDSM to
       // trigger further audio decode tasks if MDSM itself needs to play audio.
-      mTask->MaybeFinishSeek();
+      MaybeFinishSeek();
       break;
     }
     case MediaData::VIDEO_DATA:
     {
       if (mTask->NeedMoreVideo()) {
         // Reject if we can't finish video seeking.
         mTask->RejectIfExist(NS_ERROR_DOM_MEDIA_CANCELED, __func__);
         return;
       }
-      mTask->MaybeFinishSeek();
+      MaybeFinishSeek();
       break;
     }
     default:
       MOZ_ASSERT_UNREACHABLE("We cannot handle RAW_DATA or NULL_DATA here.");
     }
   }
 
   int64_t CalculateNewCurrentTime() const override
@@ -1585,16 +1585,30 @@ private:
 
     if (aValue.mIsVideoQueueFinished) {
       VideoQueue().Finish();
     }
 
     mMaster->DecodeError(aValue.mError);
   }
 
+  void MaybeFinishSeek()
+  {
+    if (mTask->IsAudioSeekComplete() && mTask->IsVideoSeekComplete()) {
+      mTask->UpdateSeekTargetTime();
+
+      auto time = mTask->mTarget.GetTime().ToMicroseconds();
+      DiscardFrames(mTask->mAudioQueue, [time] (int64_t aSampleTime) {
+        return aSampleTime < time;
+      });
+
+      mTask->Resolve(__func__); // Call to MDSM::SeekCompleted();
+    }
+  }
+
   // For refactoring only, will be removed later.
   RefPtr<NextFrameSeekTask> mTask;
 
 };
 
 /**
  * Purpose: stop playback until enough data is decoded to continue playback.
  *

--- a/dom/media/NextFrameSeekTask.cpp
+++ b/dom/media/NextFrameSeekTask.cpp
@@ -87,33 +87,16 @@ NextFrameSeekTask::HandleVideoWaited(Med
 {
 }
 
 void
 NextFrameSeekTask::HandleNotWaited(const WaitForDataRejectValue& aRejection)
 {
 }
 
-/*
- * Remove samples from the queue until aCompare() returns false.
- * aCompare A function object with the signature bool(int64_t) which returns
- *          true for samples that should be removed.
- */
-template <typename Function> static void
-DiscardFrames(MediaQueue<MediaData>& aQueue, const Function& aCompare)
-{
-  while(aQueue.GetSize() > 0) {
-    if (aCompare(aQueue.PeekFront()->mTime)) {
-      RefPtr<MediaData> releaseMe = aQueue.PopFront();
-      continue;
-    }
-    break;
-  }
-}
-
 RefPtr<NextFrameSeekTask::SeekTaskPromise>
 NextFrameSeekTask::Seek(const media::TimeUnit&)
 {
   AssertOwnerThread();
 
   RefPtr<SeekTaskPromise> promise = mSeekTaskPromise.Ensure(__func__);
 
   return promise;
@@ -158,32 +141,16 @@ NextFrameSeekTask::IsVideoSeekComplete()
 {
   AssertOwnerThread();
   // Don't finish seek until there are no pending requests. Otherwise, we might
   // lose video samples for the promise is resolved asynchronously.
   return !IsVideoRequestPending() && !NeedMoreVideo();
 }
 
 void
-NextFrameSeekTask::MaybeFinishSeek()
-{
-  AssertOwnerThread();
-  if (IsAudioSeekComplete() && IsVideoSeekComplete()) {
-    UpdateSeekTargetTime();
-
-    auto time = mTarget.GetTime().ToMicroseconds();
-    DiscardFrames(mAudioQueue, [time] (int64_t aSampleTime) {
-      return aSampleTime < time;
-    });
-
-    Resolve(__func__); // Call to MDSM::SeekCompleted();
-  }
-}
-
-void
 NextFrameSeekTask::UpdateSeekTargetTime()
 {
   AssertOwnerThread();
 
   RefPtr<MediaData> data = mVideoQueue.PeekFront();
   if (data) {
     mTarget.SetTime(TimeUnit::FromMicroseconds(data->mTime));
   } else if (mSeekedVideoData) {

--- a/dom/media/NextFrameSeekTask.h
+++ b/dom/media/NextFrameSeekTask.h
@@ -59,18 +59,16 @@ public:
   bool NeedMoreVideo() const;
 
   bool IsVideoRequestPending() const;
 
   bool IsAudioSeekComplete() const;
 
   bool IsVideoSeekComplete() const;
 
-  void MaybeFinishSeek();
-
   // Update the seek target's time before resolving this seek task, the updated
   // time will be used in the MDSM::SeekCompleted() to update the MDSM's position.
   void UpdateSeekTargetTime();
 
   /*
    * Data shared with MDSM.
    */
   MediaQueue<MediaData>& mAudioQueue;