--- a/dom/media/encoder/MediaEncoder.cpp
+++ b/dom/media/encoder/MediaEncoder.cpp
@@ -848,34 +848,34 @@ MediaEncoder::EncodeData()
     rv = mVideoEncoder->GetEncodedTrack(encodedVideoData);
     if (NS_FAILED(rv)) {
       // Encoding might be canceled.
       LOG(LogLevel::Error, ("Failed to get encoded data from video encoder."));
       return rv;
     }
     for (const RefPtr<EncodedFrame>& frame :
          encodedVideoData.GetEncodedFrames()) {
-      mEncodedVideoFrames.AppendElement(frame);
+      mEncodedVideoFrames.Push(frame);
     }
   }
 
   if (mAudioEncoder && !mAudioEncoder->IsEncodingComplete()) {
     EncodedFrameContainer encodedAudioData;
     rv = mAudioEncoder->GetEncodedTrack(encodedAudioData);
     if (NS_FAILED(rv)) {
       // Encoding might be canceled.
       LOG(LogLevel::Error, ("Failed to get encoded data from audio encoder."));
       return rv;
     }
     for (const RefPtr<EncodedFrame>& frame :
          encodedAudioData.GetEncodedFrames()) {
       if (frame->mFrameType == EncodedFrame::FrameType::OPUS_AUDIO_FRAME) {
         frame->mTime += mAudioCodecDelay;
       }
-      mEncodedAudioFrames.AppendElement(frame);
+      mEncodedAudioFrames.Push(frame);
     }
   }
 
   return rv;
 }
 
 nsresult
 MediaEncoder::WriteEncodedDataToMuxer()
@@ -885,37 +885,37 @@ MediaEncoder::WriteEncodedDataToMuxer()
   MOZ_ASSERT(mEncoderThread->IsCurrentThreadIn());
 
   MOZ_ASSERT(mVideoEncoder || mAudioEncoder, "Must have atleast one encoder");
 
   nsresult rv;
 
   if (mVideoEncoder) {
     EncodedFrameContainer encodedVideoData;
-    for (const RefPtr<EncodedFrame>& frame : mEncodedVideoFrames) {
+    while (mEncodedVideoFrames.GetSize() > 0) {
+      RefPtr<EncodedFrame> frame = mEncodedVideoFrames.PopFront();
       encodedVideoData.AppendEncodedFrame(frame);
     }
-    mEncodedVideoFrames.Clear();
 
     rv = mWriter->WriteEncodedTrack(
       encodedVideoData,
       mVideoEncoder->IsEncodingComplete() ? ContainerWriter::END_OF_STREAM : 0);
     if (NS_FAILED(rv)) {
       LOG(LogLevel::Error,
           ("Failed to write encoded video track to the muxer."));
       return rv;
     }
   }
 
   if (mAudioEncoder) {
     EncodedFrameContainer encodedAudioData;
-    for (const RefPtr<EncodedFrame>& frame : mEncodedAudioFrames) {
+    while (mEncodedAudioFrames.GetSize() > 0) {
+      RefPtr<EncodedFrame> frame = mEncodedAudioFrames.PopFront();
       encodedAudioData.AppendEncodedFrame(frame);
     }
-    mEncodedAudioFrames.Clear();
 
     rv = mWriter->WriteEncodedTrack(
       encodedAudioData,
       mAudioEncoder->IsEncodingComplete() ? ContainerWriter::END_OF_STREAM : 0);
     if (NS_FAILED(rv)) {
       LOG(LogLevel::Error,
           ("Failed to write encoded audio track to the muxer."));
       return rv;

--- a/dom/media/encoder/MediaEncoder.h
+++ b/dom/media/encoder/MediaEncoder.h
@@ -3,16 +3,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef MediaEncoder_h_
 #define MediaEncoder_h_
 
 #include "ContainerWriter.h"
 #include "CubebUtils.h"
+#include "MediaQueue.h"
 #include "MediaStreamGraph.h"
 #include "MediaStreamListener.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/UniquePtr.h"
 #include "nsIMemoryReporter.h"
 #include "TrackEncoder.h"
 
@@ -269,19 +270,19 @@ private:
   // An audio track that we are encoding. Will be null if the input stream
   // doesn't contain audio on start() or if the input is an AudioNode.
   RefPtr<dom::AudioStreamTrack> mAudioTrack;
   // A video track that we are encoding. Will be null if the input stream
   // doesn't contain video on start() or if the input is an AudioNode.
   RefPtr<dom::VideoStreamTrack> mVideoTrack;
 
   // Audio frames that have been encoded and are pending write to the muxer
-  nsTArray<RefPtr<EncodedFrame>> mEncodedAudioFrames;
+  MediaQueue<EncodedFrame> mEncodedAudioFrames;
   // Video frames that have been encoded and are pending write to the muxer
-  nsTArray<RefPtr<EncodedFrame>> mEncodedVideoFrames;
+  MediaQueue<EncodedFrame> mEncodedVideoFrames;
 
   // How much each audio time stamp should be delayed in microseconds. Used to
   // adjust for opus codec delay.
   uint64_t mAudioCodecDelay = 0;
 
   TimeStamp mStartTime;
   nsString mMIMEType;
   bool mInitialized;