--- a/dom/media/ADTSDecoder.cpp
+++ b/dom/media/ADTSDecoder.cpp
@@ -20,19 +20,18 @@ ADTSDecoder::Clone(MediaDecoderInit& aIn
     return nullptr;
 
   return new ADTSDecoder(aInit);
 }
 
 MediaDecoderStateMachine*
 ADTSDecoder::CreateStateMachine()
 {
-  RefPtr<MediaDecoderReader> reader =
-    new MediaFormatReader(this, new ADTSDemuxer(mResource));
-  return new MediaDecoderStateMachine(this, reader);
+  mReader = new MediaFormatReader(this, new ADTSDemuxer(mResource));
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 /* static */ bool
 ADTSDecoder::IsEnabled()
 {
   RefPtr<PDMFactory> platform = new PDMFactory();
   return platform->SupportsMimeType(NS_LITERAL_CSTRING("audio/mp4a-latm"),
                                     /* DecoderDoctorDiagnostics* */ nullptr);

--- a/dom/media/MediaDecoder.h
+++ b/dom/media/MediaDecoder.h
@@ -36,16 +36,17 @@ class nsIPrincipal;
 namespace mozilla {
 
 namespace dom {
 class HTMLMediaElement;
 }
 
 class AbstractThread;
 class VideoFrameContainer;
+class MediaDecoderReader;
 class MediaDecoderStateMachine;
 
 enum class MediaEventType : int8_t;
 enum class Visibility : uint8_t;
 
 // GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
 // GetTickCount() and conflicts with MediaDecoder::GetCurrentTime implementation.
 #ifdef GetCurrentTime
@@ -516,16 +517,18 @@ protected:
 
   /******
    * The following member variables can be accessed from any thread.
    ******/
 
   // Media data resource.
   RefPtr<MediaResource> mResource;
 
+  RefPtr<MediaDecoderReader> mReader;
+
   // Amount of buffered data ahead of current time required to consider that
   // the next frame is available.
   // An arbitrary value of 250ms is used.
   static constexpr auto DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED =
     media::TimeUnit::FromMicroseconds(250000);
 
 private:
   nsCString GetDebugInfo();

--- a/dom/media/android/AndroidMediaDecoder.cpp
+++ b/dom/media/android/AndroidMediaDecoder.cpp
@@ -14,14 +14,14 @@ AndroidMediaDecoder::AndroidMediaDecoder
                                          const MediaContainerType& aType)
   : ChannelMediaDecoder(aInit)
   , mType(aType)
 {
 }
 
 MediaDecoderStateMachine* AndroidMediaDecoder::CreateStateMachine()
 {
-  return new MediaDecoderStateMachine(
-    this, new AndroidMediaReader(this, mType, mResource));
+  mReader = new AndroidMediaReader(this, mType, mResource);
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 } // namespace mozilla
 

--- a/dom/media/flac/FlacDecoder.cpp
+++ b/dom/media/flac/FlacDecoder.cpp
@@ -21,19 +21,18 @@ FlacDecoder::Clone(MediaDecoderInit& aIn
   }
 
   return new FlacDecoder(aInit);
 }
 
 MediaDecoderStateMachine*
 FlacDecoder::CreateStateMachine()
 {
-  RefPtr<MediaDecoderReader> reader =
-    new MediaFormatReader(this, new FlacDemuxer(mResource));
-  return new MediaDecoderStateMachine(this, reader);
+  mReader = new MediaFormatReader(this, new FlacDemuxer(mResource));
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 /* static */ bool
 FlacDecoder::IsEnabled()
 {
 #ifdef MOZ_FFVPX
   return MediaPrefs::FlacEnabled();
 #else

--- a/dom/media/fmp4/MP4Decoder.cpp
+++ b/dom/media/fmp4/MP4Decoder.cpp
@@ -284,14 +284,16 @@ MP4Decoder::IsVideoAccelerated(layers::K
            });
 
   return promise.forget();
 }
 
 void
 MP4Decoder::GetMozDebugReaderData(nsACString& aString)
 {
-  if (mReader) {
-    mReader->GetMozDebugReaderData(aString);
+  // This is definitely a MediaFormatReader. See CreateStateMachine() above.
+  auto reader = static_cast<MediaFormatReader*>(mReader.get());
+  if (reader) {
+    reader->GetMozDebugReaderData(aString);
   }
 }
 
 } // namespace mozilla

--- a/dom/media/fmp4/MP4Decoder.h
+++ b/dom/media/fmp4/MP4Decoder.h
@@ -49,16 +49,13 @@ public:
 
   // Returns true if the MP4 backend is preffed on.
   static bool IsEnabled();
 
   static already_AddRefed<dom::Promise>
   IsVideoAccelerated(layers::KnowsCompositor* aKnowsCompositor, nsIGlobalObject* aParent);
 
   void GetMozDebugReaderData(nsACString& aString) override;
-
-private:
-  RefPtr<MediaFormatReader> mReader;
 };
 
 } // namespace mozilla
 
 #endif

--- a/dom/media/hls/HLSDecoder.h
+++ b/dom/media/hls/HLSDecoder.h
@@ -32,16 +32,13 @@ public:
   // with the a platform decoder backend.
   // If provided, codecs are checked for support.
   static bool IsSupportedType(const MediaContainerType& aContainerType);
 
   nsresult Load(nsIChannel* aChannel,
                 bool aIsPrivateBrowsing,
                 nsIStreamListener**) override;
   nsresult Load(MediaResource*) override;
-
-private:
-  RefPtr<MediaFormatReader> mReader;
 };
 
 } // namespace mozilla
 
 #endif /* HLSDecoder_h_ */

--- a/dom/media/mediasource/MediaSourceDecoder.cpp
+++ b/dom/media/mediasource/MediaSourceDecoder.cpp
@@ -240,17 +240,19 @@ MediaSourceDecoder::SetMediaSourceDurati
     SetExplicitDuration(PositiveInfinity<double>());
   }
 }
 
 void
 MediaSourceDecoder::GetMozDebugReaderData(nsACString& aString)
 {
   if (mReader && mDemuxer) {
-    mReader->GetMozDebugReaderData(aString);
+    // This is definitely a MediaFormatReader. See CreateStateMachine() above.
+    auto reader = static_cast<MediaFormatReader*>(mReader.get());
+    reader->GetMozDebugReaderData(aString);
     mDemuxer->GetMozDebugReaderData(aString);
   }
 }
 
 double
 MediaSourceDecoder::GetDuration()
 {
   MOZ_ASSERT(NS_IsMainThread());

--- a/dom/media/mediasource/MediaSourceDecoder.h
+++ b/dom/media/mediasource/MediaSourceDecoder.h
@@ -81,17 +81,16 @@ private:
   void DoSetMediaSourceDuration(double aDuration);
   media::TimeInterval ClampIntervalToEnd(const media::TimeInterval& aInterval);
 
   // The owning MediaSource holds a strong reference to this decoder, and
   // calls Attach/DetachMediaSource on this decoder to set and clear
   // mMediaSource.
   dom::MediaSource* mMediaSource;
   RefPtr<MediaSourceDemuxer> mDemuxer;
-  RefPtr<MediaFormatReader> mReader;
   MediaEventProducer<void> mWaitingForKeyEvent;
 
   bool mEnded;
 };
 
 } // namespace mozilla
 
 #endif /* MOZILLA_MEDIASOURCEDECODER_H_ */

--- a/dom/media/mp3/MP3Decoder.cpp
+++ b/dom/media/mp3/MP3Decoder.cpp
@@ -21,19 +21,18 @@ MP3Decoder::Clone(MediaDecoderInit& aIni
   if (!IsEnabled()) {
     return nullptr;
   }
   return new MP3Decoder(aInit);
 }
 
 MediaDecoderStateMachine*
 MP3Decoder::CreateStateMachine() {
-  RefPtr<MediaDecoderReader> reader =
-    new MediaFormatReader(this, new MP3Demuxer(mResource));
-  return new MediaDecoderStateMachine(this, reader);
+  mReader = new MediaFormatReader(this, new MP3Demuxer(mResource));
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 /* static */
 bool
 MP3Decoder::IsEnabled() {
   RefPtr<PDMFactory> platform = new PDMFactory();
   return platform->SupportsMimeType(NS_LITERAL_CSTRING("audio/mpeg"),
                                     /* DecoderDoctorDiagnostics* */ nullptr);

--- a/dom/media/ogg/OggDecoder.cpp
+++ b/dom/media/ogg/OggDecoder.cpp
@@ -11,21 +11,20 @@
 #include "OggDemuxer.h"
 #include "OggDecoder.h"
 
 namespace mozilla {
 
 MediaDecoderStateMachine* OggDecoder::CreateStateMachine()
 {
   RefPtr<OggDemuxer> demuxer = new OggDemuxer(mResource);
-  RefPtr<MediaFormatReader> reader =
-    new MediaFormatReader(this, demuxer, GetVideoFrameContainer());
-  demuxer->SetChainingEvents(&reader->TimedMetadataProducer(),
-                             &reader->MediaNotSeekableProducer());
-  return new MediaDecoderStateMachine(this, reader);
+  mReader = new MediaFormatReader(this, demuxer, GetVideoFrameContainer());
+  demuxer->SetChainingEvents(&mReader->TimedMetadataProducer(),
+                             &mReader->MediaNotSeekableProducer());
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 /* static */
 bool
 OggDecoder::IsSupportedType(const MediaContainerType& aContainerType)
 {
   if (!MediaPrefs::OggEnabled()) {
     return false;

--- a/dom/media/wave/WaveDecoder.cpp
+++ b/dom/media/wave/WaveDecoder.cpp
@@ -17,18 +17,18 @@ ChannelMediaDecoder*
 WaveDecoder::Clone(MediaDecoderInit& aInit)
 {
   return new WaveDecoder(aInit);
 }
 
 MediaDecoderStateMachine*
 WaveDecoder::CreateStateMachine()
 {
-  return new MediaDecoderStateMachine(
-    this, new MediaFormatReader(this, new WAVDemuxer(mResource)));
+  mReader = new MediaFormatReader(this, new WAVDemuxer(mResource));
+  return new MediaDecoderStateMachine(this, mReader);
 }
 
 /* static */ bool
 WaveDecoder::IsSupportedType(const MediaContainerType& aContainerType)
 {
   if (!IsWaveEnabled()) {
     return false;
   }

--- a/dom/media/webm/WebMDecoder.cpp
+++ b/dom/media/webm/WebMDecoder.cpp
@@ -63,15 +63,17 @@ WebMDecoder::IsSupportedType(const Media
     return false;
   }
   return true;
 }
 
 void
 WebMDecoder::GetMozDebugReaderData(nsACString& aString)
 {
-  if (mReader) {
-    mReader->GetMozDebugReaderData(aString);
+  // This is definitely a MediaFormatReader. See CreateStateMachine() above.
+  auto reader = static_cast<MediaFormatReader*>(mReader.get());
+  if (reader) {
+    reader->GetMozDebugReaderData(aString);
   }
 }
 
 } // namespace mozilla
 

--- a/dom/media/webm/WebMDecoder.h
+++ b/dom/media/webm/WebMDecoder.h
@@ -30,16 +30,13 @@ public:
   MediaDecoderStateMachine* CreateStateMachine() override;
 
   // Returns true if aContainerType is a WebM type that we think we can render
   // with an enabled platform decoder backend.
   // If provided, codecs are checked for support.
   static bool IsSupportedType(const MediaContainerType& aContainerType);
 
   void GetMozDebugReaderData(nsACString& aString) override;
-
-private:
-  RefPtr<MediaFormatReader> mReader;
 };
 
 } // namespace mozilla
 
 #endif