--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -189,17 +189,16 @@ public:
   virtual void Exit() {};  // Exit action.
   virtual void Step() {}   // Perform a 'cycle' of this state object.
   virtual State GetState() const = 0;
 
   // Event handlers for various events.
   virtual void HandleCDMProxyReady() {}
   virtual void HandleAudioDecoded(MediaData* aAudio) {}
   virtual void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) {}
-  virtual void HandleAudioNotDecoded(const MediaResult& aError);
   virtual void HandleVideoNotDecoded(const MediaResult& aError);
   virtual void HandleAudioWaited(MediaData::Type aType);
   virtual void HandleVideoWaited(MediaData::Type aType);
   virtual void HandleNotWaited(const WaitForDataRejectValue& aRejection);
   virtual void HandleEndOfStream() {}
   virtual void HandleWaitingForData() {}
   virtual void HandleAudioCaptured() {}
 
@@ -526,17 +525,16 @@ public:
   }
 
   void HandleEndOfAudio() override
   {
     AudioQueue().Finish();
     MaybeFinishDecodeFirstFrame();
   }
 
-  void HandleAudioNotDecoded(const MediaResult& aError) override;
   void HandleVideoNotDecoded(const MediaResult& aError) override;
 
   void HandleAudioWaited(MediaData::Type aType) override
   {
     mMaster->RequestAudioData();
   }
 
   void HandleVideoWaited(MediaData::Type aType) override
@@ -847,17 +845,16 @@ public:
 
   State GetState() const override
   {
     return DECODER_STATE_SEEKING;
   }
 
   void HandleAudioDecoded(MediaData* aAudio) override = 0;
   void HandleVideoDecoded(MediaData* aVideo, TimeStamp aDecodeStart) override = 0;
-  void HandleAudioNotDecoded(const MediaResult& aError) override = 0;
   void HandleVideoNotDecoded(const MediaResult& aError) override = 0;
   void HandleAudioWaited(MediaData::Type aType) override = 0;
   void HandleVideoWaited(MediaData::Type aType) override = 0;
   void HandleNotWaited(const WaitForDataRejectValue& aRejection) override = 0;
 
   void HandleVideoSuspendTimeout() override
   {
     // Do nothing since we want a valid video frame to show when seek is done.
@@ -988,17 +985,16 @@ public:
     if (!mSeekJob.mTarget->IsVideoOnly()) {
       MOZ_ASSERT(!mDoneAudioSeeking);
       AudioQueue().Finish();
       mDoneAudioSeeking = true;
       MaybeFinishSeek();
     }
   }
 
-  void HandleAudioNotDecoded(const MediaResult& aError) override;
   void HandleVideoNotDecoded(const MediaResult& aError) override;
 
   void HandleAudioWaited(MediaData::Type aType) override
   {
     MOZ_ASSERT(!mDoneAudioSeeking || !mDoneVideoSeeking, "Seek shouldn't be finished");
 
     // Ignore pending requests from video-only seek.
     if (mSeekJob.mTarget->IsVideoOnly()) {
@@ -1426,17 +1422,16 @@ private:
   void HandleEndOfAudio() override
   {
     MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
     MOZ_ASSERT(NeedMoreVideo());
     // We don't care about audio decode errors in this state which will be
     // handled by other states after seeking.
   }
 
-  void HandleAudioNotDecoded(const MediaResult& aError) override;
   void HandleVideoNotDecoded(const MediaResult& aError) override;
 
   void HandleAudioWaited(MediaData::Type aType) override
   {
     // We don't care about audio in this state.
   }
 
   void HandleVideoWaited(MediaData::Type aType) override
@@ -1720,17 +1715,16 @@ public:
     MOZ_DIAGNOSTIC_ASSERT(false, "Shouldn't escape the SHUTDOWN state.");
   }
 
   State GetState() const override
   {
     return DECODER_STATE_SHUTDOWN;
   }
 
-  void HandleAudioNotDecoded(const MediaResult& aError) override {}
   void HandleVideoNotDecoded(const MediaResult& aError) override {}
 
   RefPtr<MediaDecoder::SeekPromise> HandleSeek(SeekTarget aTarget) override
   {
     MOZ_DIAGNOSTIC_ASSERT(false, "Can't seek in shutdown state.");
     return MediaDecoder::SeekPromise::CreateAndReject(true, __func__);
   }
 
@@ -1769,35 +1763,16 @@ void
 MediaDecoderStateMachine::
 StateObject::HandleNotWaited(const WaitForDataRejectValue& aRejection)
 {
 
 }
 
 void
 MediaDecoderStateMachine::
-StateObject::HandleAudioNotDecoded(const MediaResult& aError)
-{
-  switch (aError.Code()) {
-    case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_CANCELED:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
-      MOZ_ASSERT(false);
-      break;
-    default:
-      mMaster->DecodeError(aError);
-  }
-}
-
-void
-MediaDecoderStateMachine::
 StateObject::HandleVideoNotDecoded(const MediaResult& aError)
 {
   switch (aError.Code()) {
     case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
       mMaster->WaitForData(MediaData::VIDEO_DATA);
       HandleWaitingForData();
       break;
     case NS_ERROR_DOM_MEDIA_CANCELED:
@@ -2005,35 +1980,16 @@ DecodingFirstFrameState::Enter()
   }
   if (mMaster->HasVideo()) {
     mMaster->RequestVideoData(false, media::TimeUnit());
   }
 }
 
 void
 MediaDecoderStateMachine::
-DecodingFirstFrameState::HandleAudioNotDecoded(const MediaResult& aError)
-{
-  switch (aError.Code()) {
-    case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_CANCELED:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
-      MOZ_ASSERT(false);
-      break;
-    default:
-      mMaster->DecodeError(aError);
-  }
-}
-
-void
-MediaDecoderStateMachine::
 DecodingFirstFrameState::HandleVideoNotDecoded(const MediaResult& aError)
 {
   switch (aError.Code()) {
     case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
       mMaster->WaitForData(MediaData::VIDEO_DATA);
       break;
     case NS_ERROR_DOM_MEDIA_CANCELED:
       mMaster->RequestVideoData(false, media::TimeUnit());
@@ -2223,39 +2179,16 @@ SeekingState::SeekCompleted()
     mMaster->mOnPlaybackEvent.Notify(MediaEventType::Invalidate);
   }
 
   SetState<DecodingState>();
 }
 
 void
 MediaDecoderStateMachine::
-AccurateSeekingState::HandleAudioNotDecoded(const MediaResult& aError)
-{
-  if (mSeekJob.mTarget->IsVideoOnly()) {
-    return;
-  }
-  MOZ_ASSERT(!mDoneAudioSeeking);
-  switch (aError.Code()) {
-    case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_CANCELED:
-      MOZ_ASSERT(false);
-      break;
-    case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
-      MOZ_ASSERT(false);
-      break;
-    default:
-      mMaster->DecodeError(aError);
-  }
-}
-
-void
-MediaDecoderStateMachine::
 AccurateSeekingState::HandleVideoNotDecoded(const MediaResult& aError)
 {
   MOZ_ASSERT(!mDoneVideoSeeking);
   switch (aError.Code()) {
     case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
       mMaster->WaitForData(MediaData::VIDEO_DATA);
       break;
     case NS_ERROR_DOM_MEDIA_CANCELED:
@@ -2273,26 +2206,16 @@ AccurateSeekingState::HandleVideoNotDeco
       break;
     default:
       mMaster->DecodeError(aError);
   }
 }
 
 void
 MediaDecoderStateMachine::
-NextFrameSeekingState::HandleAudioNotDecoded(const MediaResult& aError)
-{
-  MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
-  MOZ_ASSERT(NeedMoreVideo());
-  // We don't care about audio decode errors in this state which will be
-  // handled by other states after seeking.
-}
-
-void
-MediaDecoderStateMachine::
 NextFrameSeekingState::HandleVideoNotDecoded(const MediaResult& aError)
 {
   MOZ_ASSERT(!mSeekJob.mPromise.IsEmpty(), "Seek shouldn't be finished");
   MOZ_ASSERT(NeedMoreVideo());
   // Video seek not finished.
   switch (aError.Code()) {
     case NS_ERROR_DOM_MEDIA_WAITING_FOR_DATA:
       mMaster->WaitForData(MediaData::VIDEO_DATA);
@@ -3095,17 +3018,17 @@ MediaDecoderStateMachine::RequestAudioDa
             break;
           case NS_ERROR_DOM_MEDIA_CANCELED:
             mStateObj->HandleAudioCanceled();
             break;
           case NS_ERROR_DOM_MEDIA_END_OF_STREAM:
             mStateObj->HandleEndOfAudio();
             break;
           default:
-            mStateObj->HandleAudioNotDecoded(aError);
+            DecodeError(aError);
         }
       })
   );
 }
 
 void
 MediaDecoderStateMachine::EnsureVideoDecodeTaskQueued()
 {