--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -721,24 +721,23 @@ public:
              [this] (const SeekTaskResolveValue& aValue) {
                OnSeekTaskResolved(aValue);
              },
              [this] (const SeekTaskRejectValue& aValue) {
                OnSeekTaskRejected(aValue);
              }));
 
     MOZ_ASSERT(!mMaster->mQueuedSeek.Exists());
-    MOZ_ASSERT(!mMaster->mCurrentSeek.Exists());
-    mMaster->mCurrentSeek = Move(mSeekJob);
+    mCurrentSeek = Move(mSeekJob);
   }
 
   void Exit() override
   {
     mSeekTaskRequest.DisconnectIfExists();
-    mMaster->mCurrentSeek.RejectIfExists(__func__);
+    mCurrentSeek.RejectIfExists(__func__);
     mSeekTask->Discard();
 
     // Reset the MediaDecoderReaderWrapper's callbask.
     mMaster->SetMediaDecoderReaderWrapperCallback();
   }
 
   State GetState() const override
   {
@@ -746,26 +745,26 @@ public:
   }
 
   bool HandleDormant(bool aDormant) override
   {
     if (!aDormant) {
       return true;
     }
     MOZ_ASSERT(!mMaster->mQueuedSeek.Exists());
-    MOZ_ASSERT(mMaster->mCurrentSeek.Exists());
+    MOZ_ASSERT(mCurrentSeek.Exists());
     // Because both audio and video decoders are going to be reset in this
     // method later, we treat a VideoOnly seek task as a normal Accurate
     // seek task so that while it is resumed, both audio and video playback
     // are handled.
-    if (mMaster->mCurrentSeek.mTarget.IsVideoOnly()) {
-      mMaster->mCurrentSeek.mTarget.SetType(SeekTarget::Accurate);
-      mMaster->mCurrentSeek.mTarget.SetVideoOnly(false);
+    if (mCurrentSeek.mTarget.IsVideoOnly()) {
+      mCurrentSeek.mTarget.SetType(SeekTarget::Accurate);
+      mCurrentSeek.mTarget.SetVideoOnly(false);
     }
-    mMaster->mQueuedSeek = Move(mMaster->mCurrentSeek);
+    mMaster->mQueuedSeek = Move(mCurrentSeek);
     SetState(DECODER_STATE_DORMANT);
     return true;
   }
 
   bool HandleAudioDecoded(MediaData* aAudio) override
   {
     MOZ_ASSERT(false);
     return true;
@@ -871,17 +870,17 @@ private:
       // we report playback ended to the media element.
       nextState = DECODER_STATE_COMPLETED;
     } else {
       nextState = DECODER_STATE_DECODING;
     }
 
     // We want to resolve the seek request prior finishing the first frame
     // to ensure that the seeked event is fired prior loadeded.
-    mMaster->mCurrentSeek.Resolve(nextState == DECODER_STATE_COMPLETED, __func__);
+    mCurrentSeek.Resolve(nextState == DECODER_STATE_COMPLETED, __func__);
 
     // Notify FirstFrameLoaded now if we haven't since we've decoded some data
     // for readyState to transition to HAVE_CURRENT_DATA and fire 'loadeddata'.
     if (!mMaster->mSentFirstFrameLoadedEvent) {
       // Only MSE can start seeking before finishing decoding first frames.
       MOZ_ASSERT(Reader()->ForceZeroStartTime());
       mMaster->FinishDecodeFirstFrame();
     }
@@ -898,16 +897,17 @@ private:
     }
 
     SetState(nextState);
   }
 
   SeekJob mSeekJob;
   MozPromiseRequestHolder<SeekTask::SeekTaskPromise> mSeekTaskRequest;
   RefPtr<SeekTask> mSeekTask;
+  SeekJob mCurrentSeek;
 };
 
 class MediaDecoderStateMachine::BufferingState
   : public MediaDecoderStateMachine::StateObject
 {
 public:
   explicit BufferingState(Master* aPtr) : StateObject(aPtr) {}
 

--- a/dom/media/MediaDecoderStateMachine.h
+++ b/dom/media/MediaDecoderStateMachine.h
@@ -612,17 +612,16 @@ private:
   {
     MOZ_ASSERT(OnTaskQueue());
     return mPlayState == MediaDecoder::PLAY_STATE_PLAYING ||
            mNextPlayState == MediaDecoder::PLAY_STATE_PLAYING;
   }
 
   // Queued seek - moves to mCurrentSeek when DecodeFirstFrame completes.
   SeekJob mQueuedSeek;
-  SeekJob mCurrentSeek;
 
   // 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;