--- a/dom/media/AccurateSeekTask.cpp
+++ b/dom/media/AccurateSeekTask.cpp
@@ -39,19 +39,16 @@ AccurateSeekTask::AccurateSeekTask(const
   , mDoneAudioSeeking(!aInfo.HasAudio() || aTarget.IsVideoOnly())
   , mDoneVideoSeeking(!aInfo.HasVideo())
 {
   AssertOwnerThread();
 
   // Bound the seek time to be inside the media range.
   NS_ASSERTION(aEnd.ToMicroseconds() != -1, "Should know end time by now");
   mTarget.SetTime(std::max(media::TimeUnit(), std::min(mTarget.GetTime(), aEnd)));
-
-  // Configure MediaDecoderReaderWrapper.
-  SetCallbacks();
 }
 
 AccurateSeekTask::~AccurateSeekTask()
 {
   AssertOwnerThread();
   MOZ_ASSERT(mIsDiscarded);
 }
 
@@ -60,17 +57,16 @@ AccurateSeekTask::Discard()
 {
   AssertOwnerThread();
 
   // Disconnect MDSM.
   RejectIfExist(NS_ERROR_DOM_MEDIA_CANCELED, __func__);
 
   // Disconnect MediaDecoderReaderWrapper.
   mSeekRequest.DisconnectIfExists();
-  CancelCallbacks();
 
   mIsDiscarded = true;
 }
 
 bool
 AccurateSeekTask::NeedToResetMDSM() const
 {
   AssertOwnerThread();
@@ -387,17 +383,16 @@ AccurateSeekTask::OnAudioDecoded(MediaDa
 
   if (mTarget.IsFast()) {
     // Non-precise seek; we can stop the seek at the first sample.
     mSeekedAudioData = audio;
     mDoneAudioSeeking = true;
   } else {
     nsresult rv = DropAudioUpToSeekTarget(audio);
     if (NS_FAILED(rv)) {
-      CancelCallbacks();
       RejectIfExist(rv, __func__);
       return;
     }
   }
 
   if (!mDoneAudioSeeking) {
     RequestAudioData();
     return;
@@ -448,17 +443,16 @@ AccurateSeekTask::OnNotDecoded(MediaData
         mSeekedVideoData = mFirstVideoFrameAfterSeek.forget();
       }
     }
     MaybeFinishSeek();
     return;
   }
 
   // This is a decode error, delegate to the generic error path.
-  CancelCallbacks();
   RejectIfExist(aError, __func__);
 }
 
 void
 AccurateSeekTask::OnVideoDecoded(MediaData* aVideoSample)
 {
   AssertOwnerThread();
   MOZ_ASSERT(!mSeekTaskPromise.IsEmpty(), "Seek shouldn't be finished");
@@ -475,76 +469,21 @@ AccurateSeekTask::OnVideoDecoded(MediaDa
 
   if (mTarget.IsFast()) {
     // Non-precise seek. We can stop the seek at the first sample.
     mSeekedVideoData = video;
     mDoneVideoSeeking = true;
   } else {
     nsresult rv = DropVideoUpToSeekTarget(video.get());
     if (NS_FAILED(rv)) {
-      CancelCallbacks();
       RejectIfExist(rv, __func__);
       return;
     }
   }
 
   if (!mDoneVideoSeeking) {
     RequestVideoData();
     return;
   }
   MaybeFinishSeek();
 }
 
-void
-AccurateSeekTask::SetCallbacks()
-{
-  AssertOwnerThread();
-
-  mAudioCallback = mReader->AudioCallback().Connect(
-    OwnerThread(), [this] (AudioCallbackData aData) {
-    if (aData.is<MediaData*>()) {
-      OnAudioDecoded(aData.as<MediaData*>());
-    } else {
-      OnNotDecoded(MediaData::AUDIO_DATA,
-        aData.as<MediaResult>());
-    }
-  });
-
-  mVideoCallback = mReader->VideoCallback().Connect(
-    OwnerThread(), [this] (VideoCallbackData aData) {
-    typedef Tuple<MediaData*, TimeStamp> Type;
-    if (aData.is<Type>()) {
-      OnVideoDecoded(Get<0>(aData.as<Type>()));
-    } else {
-      OnNotDecoded(MediaData::VIDEO_DATA,
-        aData.as<MediaResult>());
-    }
-  });
-
-  mAudioWaitCallback = mReader->AudioWaitCallback().Connect(
-    OwnerThread(), [this] (WaitCallbackData aData) {
-    if (aData.is<MediaData::Type>()) {
-      HandleAudioWaited(aData.as<MediaData::Type>());
-    } else {
-      HandleNotWaited(aData.as<WaitForDataRejectValue>());
-    }
-  });
-
-  mVideoWaitCallback = mReader->VideoWaitCallback().Connect(
-    OwnerThread(), [this] (WaitCallbackData aData) {
-    if (aData.is<MediaData::Type>()) {
-      HandleVideoWaited(aData.as<MediaData::Type>());
-    } else {
-      HandleNotWaited(aData.as<WaitForDataRejectValue>());
-    }
-  });
-}
-
-void
-AccurateSeekTask::CancelCallbacks()
-{
-  AssertOwnerThread();
-  mAudioCallback.DisconnectIfExists();
-  mVideoCallback.DisconnectIfExists();
-  mAudioWaitCallback.DisconnectIfExists();
-  mVideoWaitCallback.DisconnectIfExists();
-}
 } // namespace mozilla

--- a/dom/media/AccurateSeekTask.h
+++ b/dom/media/AccurateSeekTask.h
@@ -61,20 +61,16 @@ private:
   void OnSeekRejected(nsresult aResult);
 
   void OnAudioDecoded(MediaData* aAudioSample);
 
   void OnVideoDecoded(MediaData* aVideoSample);
 
   void OnNotDecoded(MediaData::Type, const MediaResult&);
 
-  void SetCallbacks();
-
-  void CancelCallbacks();
-
   void AdjustFastSeekIfNeeded(MediaData* aSample);
 
   /*
    * Internal state.
    */
   const media::TimeUnit mCurrentTimeBeforeSeek;
   const uint32_t mAudioRate;  // Audio sample rate.
   bool mDoneAudioSeeking;
@@ -85,18 +81,13 @@ private:
   // the seek target, we will still have a frame that we can display as the
   // last frame in the media.
   RefPtr<MediaData> mFirstVideoFrameAfterSeek;
 
   /*
    * Track the current seek promise made by the reader.
    */
   MozPromiseRequestHolder<MediaDecoderReader::SeekPromise> mSeekRequest;
-
-  MediaEventListener mAudioCallback;
-  MediaEventListener mVideoCallback;
-  MediaEventListener mAudioWaitCallback;
-  MediaEventListener mVideoWaitCallback;
 };
 
 } // namespace mozilla
 
 #endif /* ACCURATE_SEEK_TASK_H */

--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -776,19 +776,16 @@ public:
     // in the middle of seeking and won't have a valid video frame to show
     // when seek is done.
     if (mMaster->mVideoDecodeSuspended) {
       mMaster->mVideoDecodeSuspended = false;
       mMaster->mOnPlaybackEvent.Notify(MediaEventType::ExitVideoSuspend);
       Reader()->SetVideoBlankDecode(false);
     }
 
-    // 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()) {
       mSeekTask = new AccurateSeekTask(
         mMaster->mDecoderID, OwnerThread(), Reader(), mSeekJob.mTarget,
         Info(), mMaster->Duration(), mMaster->GetMediaTime());
     } else if (mSeekJob.mTarget.IsNextFrame()) {
       mSeekTask = new NextFrameSeekTask(
@@ -840,19 +837,16 @@ public:
     return mSeekJob.mPromise.Ensure(__func__);
   }
 
   void Exit() override
   {
     mSeekTaskRequest.DisconnectIfExists();
     mSeekJob.RejectIfExists(__func__);
     mSeekTask->Discard();
-
-    // Reset the MediaDecoderReaderWrapper's callbask.
-    mMaster->SetMediaDecoderReaderWrapperCallback();
   }
 
   State GetState() const override
   {
     return DECODER_STATE_SEEKING;
   }
 
   void HandleAudioDecoded(MediaData* aAudio) override
@@ -2061,17 +2055,16 @@ MediaDecoderStateMachine::OnVideoPopped(
   DispatchVideoDecodeTaskIfNeeded();
 }
 
 void
 MediaDecoderStateMachine::OnNotDecoded(MediaData::Type aType,
                                        const MediaResult& aError)
 {
   MOZ_ASSERT(OnTaskQueue());
-  MOZ_ASSERT(mState != DECODER_STATE_SEEKING);
 
   SAMPLE_LOG("OnNotDecoded (aType=%u, aError=%u)", aType, aError.Code());
 
   mStateObj->HandleNotDecoded(aType, aError);
 }
 
 void
 MediaDecoderStateMachine::OnVideoDecoded(MediaData* aVideo,

--- a/dom/media/NextFrameSeekTask.cpp
+++ b/dom/media/NextFrameSeekTask.cpp
@@ -31,38 +31,32 @@ NextFrameSeekTask::NextFrameSeekTask(con
   : SeekTask(aDecoderID, aThread, aReader, aTarget)
   , mAudioQueue(aAudioQueue)
   , mVideoQueue(aVideoQueue)
   , mCurrentTime(aCurrentTime)
   , mDuration(aDuration)
 {
   AssertOwnerThread();
   MOZ_ASSERT(aInfo.HasVideo());
-
-  // Configure MediaDecoderReaderWrapper.
-  SetCallbacks();
 }
 
 NextFrameSeekTask::~NextFrameSeekTask()
 {
   AssertOwnerThread();
   MOZ_ASSERT(mIsDiscarded);
 }
 
 void
 NextFrameSeekTask::Discard()
 {
   AssertOwnerThread();
 
   // Disconnect MDSM.
   RejectIfExist(NS_ERROR_DOM_MEDIA_CANCELED, __func__);
 
-  // Disconnect MediaDecoderReader.
-  CancelCallbacks();
-
   mIsDiscarded = true;
 }
 
 bool
 NextFrameSeekTask::NeedToResetMDSM() const
 {
   AssertOwnerThread();
   return false;
@@ -142,17 +136,16 @@ NextFrameSeekTask::HandleNotWaited(const
     // trigger further audio decode tasks if MDSM itself needs to play audio.
     MaybeFinishSeek();
     break;
   }
   case MediaData::VIDEO_DATA:
   {
     if (NeedMoreVideo()) {
       // Reject if we can't finish video seeking.
-      CancelCallbacks();
       RejectIfExist(NS_ERROR_DOM_MEDIA_CANCELED, __func__);
       return;
     }
     MaybeFinishSeek();
     break;
   }
   default:
     MOZ_ASSERT_UNREACHABLE("We cannot handle RAW_DATA or NULL_DATA here.");
@@ -334,86 +327,27 @@ NextFrameSeekTask::OnVideoNotDecoded(con
         break;
       case NS_ERROR_DOM_MEDIA_CANCELED:
         RequestVideoData();
         break;
       case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
         MOZ_ASSERT(false, "Shouldn't want more data for ended video.");
         break;
       default:
-        // We might lose the audio sample after canceling the callbacks.
-        // However it doesn't really matter because MDSM is gonna shut down
-        // when seek fails.
-        CancelCallbacks();
         // Reject the promise since we can't finish video seek anyway.
         RejectIfExist(aError, __func__);
         break;
     }
     return;
   }
 
   MaybeFinishSeek();
 }
 
 void
-NextFrameSeekTask::SetCallbacks()
-{
-  AssertOwnerThread();
-
-  // Register dummy callbcak for audio decoding since we don't need to handle
-  // the decoded audio samples.
-  mAudioCallback = mReader->AudioCallback().Connect(
-    OwnerThread(), [this] (AudioCallbackData aData) {
-    if (aData.is<MediaData*>()) {
-      OnAudioDecoded(aData.as<MediaData*>());
-    } else {
-      OnAudioNotDecoded(aData.as<MediaResult>());
-    }
-  });
-
-  mVideoCallback = mReader->VideoCallback().Connect(
-    OwnerThread(), [this] (VideoCallbackData aData) {
-    typedef Tuple<MediaData*, TimeStamp> Type;
-    if (aData.is<Type>()) {
-      OnVideoDecoded(Get<0>(aData.as<Type>()));
-    } else {
-      OnVideoNotDecoded(aData.as<MediaResult>());
-    }
-  });
-
-  mAudioWaitCallback = mReader->AudioWaitCallback().Connect(
-    OwnerThread(), [this] (WaitCallbackData aData) {
-    if (aData.is<MediaData::Type>()) {
-      HandleAudioWaited(aData.as<MediaData::Type>());
-    } else {
-      HandleNotWaited(aData.as<WaitForDataRejectValue>());
-    }
-  });
-
-  mVideoWaitCallback = mReader->VideoWaitCallback().Connect(
-    OwnerThread(), [this] (WaitCallbackData aData) {
-    if (aData.is<MediaData::Type>()) {
-      HandleVideoWaited(aData.as<MediaData::Type>());
-    } else {
-      HandleNotWaited(aData.as<WaitForDataRejectValue>());
-    }
-  });
-}
-
-void
-NextFrameSeekTask::CancelCallbacks()
-{
-  AssertOwnerThread();
-  mAudioCallback.DisconnectIfExists();
-  mVideoCallback.DisconnectIfExists();
-  mAudioWaitCallback.DisconnectIfExists();
-  mVideoWaitCallback.DisconnectIfExists();
-}
-
-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
@@ -72,38 +72,29 @@ private:
   void OnAudioDecoded(MediaData* aAudioSample);
 
   void OnAudioNotDecoded(const MediaResult& aError);
 
   void OnVideoDecoded(MediaData* aVideoSample);
 
   void OnVideoNotDecoded(const MediaResult& aError);
 
-  void SetCallbacks();
-
-  void CancelCallbacks();
-
   // 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;
   MediaQueue<MediaData>& mVideoQueue;
 
   /*
    * Internal state.
    */
   const int64_t mCurrentTime;
   media::TimeUnit mDuration;
-
-  MediaEventListener mAudioCallback;
-  MediaEventListener mVideoCallback;
-  MediaEventListener mAudioWaitCallback;
-  MediaEventListener mVideoWaitCallback;
 };
 
 } // namespace media
 } // namespace mozilla
 
 #endif /* NEXTFRAME_SEEK_TASK_H */