--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -672,21 +672,21 @@ public:
   void Enter() override
   {
     // SeekTask will register its callbacks to MediaDecoderReaderWrapper.
     mMaster->CancelMediaDecoderReaderWrapperCallback();
 
     // Create a new SeekTask instance for the incoming seek task.
     if (mSeekJob.mTarget.IsAccurate() ||
         mSeekJob.mTarget.IsFast()) {
-      mMaster->mSeekTask = new AccurateSeekTask(
+      mSeekTask = new AccurateSeekTask(
         mMaster->mDecoderID, OwnerThread(), Reader(), mSeekJob.mTarget,
         mMaster->mInfo, mMaster->Duration(), mMaster->GetMediaTime());
     } else if (mSeekJob.mTarget.IsNextFrame()) {
-      mMaster->mSeekTask = new NextFrameSeekTask(
+      mSeekTask = new NextFrameSeekTask(
         mMaster->mDecoderID, OwnerThread(), Reader(), mSeekJob.mTarget,
         mMaster->mInfo, mMaster->Duration(),mMaster->GetMediaTime(),
         mMaster->AudioQueue(), mMaster->VideoQueue());
     } else {
       MOZ_DIAGNOSTIC_ASSERT(false, "Cannot handle this seek task.");
     }
 
     // Don't stop playback for a video-only seek since audio is playing.
@@ -694,34 +694,34 @@ public:
       mMaster->StopPlayback();
     }
 
     // mSeekJob.mTarget.mTime might be different from
     // mSeekTask->GetSeekTarget().mTime because the seek task might clamp the
     // seek target to [0, duration]. We want to update the playback position to
     // the clamped value.
     mMaster->UpdatePlaybackPositionInternal(
-      mMaster->mSeekTask->GetSeekTarget().GetTime().ToMicroseconds());
+      mSeekTask->GetSeekTarget().GetTime().ToMicroseconds());
 
     if (mSeekJob.mTarget.mEventVisibility ==
         MediaDecoderEventVisibility::Observable) {
       mMaster->mOnPlaybackEvent.Notify(MediaEventType::SeekStarted);
     }
 
     // Reset our state machine and decoding pipeline before seeking.
-    if (mMaster->mSeekTask->NeedToResetMDSM()) {
+    if (mSeekTask->NeedToResetMDSM()) {
       if (mSeekJob.mTarget.IsVideoOnly()) {
         mMaster->Reset(TrackInfo::kVideoTrack);
       } else {
         mMaster->Reset();
       }
     }
 
     // Do the seek.
-    mSeekTaskRequest.Begin(mMaster->mSeekTask->Seek(mMaster->Duration())
+    mSeekTaskRequest.Begin(mSeekTask->Seek(mMaster->Duration())
       ->Then(OwnerThread(), __func__,
              [this] (const SeekTaskResolveValue& aValue) {
                OnSeekTaskResolved(aValue);
              },
              [this] (const SeekTaskRejectValue& aValue) {
                OnSeekTaskRejected(aValue);
              }));
 
@@ -729,20 +729,20 @@ public:
     MOZ_ASSERT(!mMaster->mCurrentSeek.Exists());
     mMaster->mCurrentSeek = Move(mSeekJob);
   }
 
   void Exit() override
   {
     mSeekTaskRequest.DisconnectIfExists();
 
-    if (mMaster->mSeekTask) {
+    if (mSeekTask) {
       mMaster->mCurrentSeek.RejectIfExists(__func__);
-      mMaster->mSeekTask->Discard();
-      mMaster->mSeekTask = nullptr;
+      mSeekTask->Discard();
+      mSeekTask = nullptr;
 
       // Reset the MediaDecoderReaderWrapper's callbask.
       mMaster->SetMediaDecoderReaderWrapperCallback();
     }
   }
 
   State GetState() const override
   {
@@ -832,17 +832,17 @@ private:
       mMaster->VideoQueue().Finish();
     }
 
     mMaster->DecodeError(aValue.mError);
   }
 
   void SeekCompleted()
   {
-    int64_t seekTime = mMaster->mSeekTask->GetSeekTarget().GetTime().ToMicroseconds();
+    int64_t seekTime = mSeekTask->GetSeekTarget().GetTime().ToMicroseconds();
     int64_t newCurrentTime = seekTime;
 
     // Setup timestamp state.
     RefPtr<MediaData> video = mMaster->VideoQueue().PeekFront();
     if (seekTime == mMaster->Duration().ToMicroseconds()) {
       newCurrentTime = seekTime;
     } else if (mMaster->HasAudio()) {
       RefPtr<MediaData> audio = mMaster->AudioQueue().PeekFront();
@@ -906,16 +906,17 @@ private:
       mMaster->mOnPlaybackEvent.Notify(MediaEventType::Invalidate);
     }
 
     SetState(nextState);
   }
 
   SeekJob mSeekJob;
   MozPromiseRequestHolder<SeekTask::SeekTaskPromise> mSeekTaskRequest;
+  RefPtr<SeekTask> mSeekTask;
 };
 
 class MediaDecoderStateMachine::BufferingState
   : public MediaDecoderStateMachine::StateObject
 {
 public:
   explicit BufferingState(Master* aPtr) : StateObject(aPtr) {}
 
@@ -2137,17 +2138,17 @@ void MediaDecoderStateMachine::Visibilit
     mReader->SetVideoBlankDecode(false);
 
     if (mIsReaderSuspended) {
       return;
     }
 
     // If an existing seek is in flight don't bother creating a new
     // one to catch up.
-    if (mSeekTask || mQueuedSeek.Exists()) {
+    if (mState == DECODER_STATE_SEEKING || mQueuedSeek.Exists()) {
       return;
     }
 
     // Start counting recovery time from right now.
     TimeStamp start = TimeStamp::Now();
     // Local reference to mInfo, so that it will be copied in the lambda below.
     MediaInfo& info = mInfo;
     bool hw = mReader->VideoIsHardwareAccelerated();

--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -614,19 +614,16 @@ private:
     return mPlayState == MediaDecoder::PLAY_STATE_PLAYING ||
            mNextPlayState == MediaDecoder::PLAY_STATE_PLAYING;
   }
 
   // Queued seek - moves to mCurrentSeek when DecodeFirstFrame completes.
   SeekJob mQueuedSeek;
   SeekJob mCurrentSeek;
 
-  // mSeekTask is responsible for executing the current seek request.
-  RefPtr<SeekTask> mSeekTask;
-
   // Media Fragment end time in microseconds. Access controlled by decoder monitor.
   int64_t mFragmentEndTime;
 
   // The media sink resource.  Used on the state machine thread.
   RefPtr<media::MediaSink> mMediaSink;
 
   const RefPtr<MediaDecoderReaderWrapper> mReader;