Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 4129 insertions, 0 deletions

diff --git a/dom/media/MediaTrackGraph.cpp b/dom/media/MediaTrackGraph.cpp
new file mode 100644
index 0000000000..d60015a68d
--- /dev/null
+++ b/dom/media/MediaTrackGraph.cpp
@@ -0,0 +1,4129 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * 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/. */
+
+#include "MediaTrackGraphImpl.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/Unused.h"
+
+#include "AudioSegment.h"
+#include "CrossGraphPort.h"
+#include "VideoSegment.h"
+#include "nsContentUtils.h"
+#include "nsPrintfCString.h"
+#include "nsServiceManagerUtils.h"
+#include "prerror.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Attributes.h"
+#include "ForwardedInputTrack.h"
+#include "ImageContainer.h"
+#include "AudioCaptureTrack.h"
+#include "AudioNodeTrack.h"
+#include "AudioNodeExternalInputTrack.h"
+#if defined(MOZ_WEBRTC)
+#  include "MediaEngineWebRTCAudio.h"
+#endif  // MOZ_WEBRTC
+#include "MediaTrackListener.h"
+#include "mozilla/dom/BaseAudioContextBinding.h"
+#include "mozilla/dom/WorkletThread.h"
+#include "mozilla/media/MediaUtils.h"
+#include <algorithm>
+#include "GeckoProfiler.h"
+#include "VideoFrameContainer.h"
+#include "mozilla/AbstractThread.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "transport/runnable_utils.h"
+#include "VideoUtils.h"
+#include "GraphRunner.h"
+#include "Tracing.h"
+#include "UnderrunHandler.h"
+#include "mozilla/CycleCollectedJSRuntime.h"
+#include "mozilla/Preferences.h"
+
+#include "webaudio/blink/DenormalDisabler.h"
+#include "webaudio/blink/HRTFDatabaseLoader.h"
+
+using namespace mozilla::layers;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::media;
+
+namespace mozilla {
+
+LazyLogModule gMediaTrackGraphLog("MediaTrackGraph");
+#ifdef LOG
+#  undef LOG
+#endif  // LOG
+#define LOG(type, msg) MOZ_LOG(gMediaTrackGraphLog, type, msg)
+
+NativeInputTrack* DeviceInputTrackManager::GetNativeInputTrack() {
+  return mNativeInputTrack.get();
+}
+
+DeviceInputTrack* DeviceInputTrackManager::GetDeviceInputTrack(
+    CubebUtils::AudioDeviceID aID) {
+  if (mNativeInputTrack && mNativeInputTrack->mDeviceId == aID) {
+    return mNativeInputTrack.get();
+  }
+  for (const RefPtr<NonNativeInputTrack>& t : mNonNativeInputTracks) {
+    if (t->mDeviceId == aID) {
+      return t.get();
+    }
+  }
+  return nullptr;
+}
+
+NonNativeInputTrack* DeviceInputTrackManager::GetFirstNonNativeInputTrack() {
+  if (mNonNativeInputTracks.IsEmpty()) {
+    return nullptr;
+  }
+  return mNonNativeInputTracks[0].get();
+}
+
+void DeviceInputTrackManager::Add(DeviceInputTrack* aTrack) {
+  if (NativeInputTrack* native = aTrack->AsNativeInputTrack()) {
+    MOZ_ASSERT(!mNativeInputTrack);
+    mNativeInputTrack = native;
+  } else {
+    NonNativeInputTrack* nonNative = aTrack->AsNonNativeInputTrack();
+    MOZ_ASSERT(nonNative);
+    struct DeviceTrackComparator {
+     public:
+      bool Equals(const RefPtr<NonNativeInputTrack>& aTrack,
+                  CubebUtils::AudioDeviceID aDeviceId) const {
+        return aTrack->mDeviceId == aDeviceId;
+      }
+    };
+    MOZ_ASSERT(!mNonNativeInputTracks.Contains(aTrack->mDeviceId,
+                                               DeviceTrackComparator()));
+    mNonNativeInputTracks.AppendElement(nonNative);
+  }
+}
+
+void DeviceInputTrackManager::Remove(DeviceInputTrack* aTrack) {
+  if (aTrack->AsNativeInputTrack()) {
+    MOZ_ASSERT(mNativeInputTrack);
+    MOZ_ASSERT(mNativeInputTrack.get() == aTrack->AsNativeInputTrack());
+    mNativeInputTrack = nullptr;
+  } else {
+    NonNativeInputTrack* nonNative = aTrack->AsNonNativeInputTrack();
+    MOZ_ASSERT(nonNative);
+    DebugOnly<bool> removed = mNonNativeInputTracks.RemoveElement(nonNative);
+    MOZ_ASSERT(removed);
+  }
+}
+
+namespace {
+/**
+ * A hash table containing the graph instances, one per Window ID,
+ * sample rate, and device ID combination.
+ */
+class GraphKey final {
+ public:
+  GraphKey(uint64_t aWindowID, TrackRate aSampleRate,
+           CubebUtils::AudioDeviceID aOutputDeviceID)
+      : mWindowID(aWindowID),
+        mSampleRate(aSampleRate),
+        mOutputDeviceID(aOutputDeviceID) {}
+  GraphKey(const GraphKey&) = default;
+  ~GraphKey() = default;
+  bool operator==(const GraphKey& b) const {
+    return mWindowID == b.mWindowID && mSampleRate == b.mSampleRate &&
+           mOutputDeviceID == b.mOutputDeviceID;
+  }
+  PLDHashNumber Hash() const {
+    return HashGeneric(mWindowID, mSampleRate, mOutputDeviceID);
+  }
+
+ private:
+  uint64_t mWindowID;
+  TrackRate mSampleRate;
+  CubebUtils::AudioDeviceID mOutputDeviceID;
+};
+nsTHashMap<nsGenericHashKey<GraphKey>, MediaTrackGraphImpl*> gGraphs;
+}  // anonymous namespace
+
+MediaTrackGraphImpl::~MediaTrackGraphImpl() {
+  MOZ_ASSERT(mTracks.IsEmpty() && mSuspendedTracks.IsEmpty(),
+             "All tracks should have been destroyed by messages from the main "
+             "thread");
+  LOG(LogLevel::Debug, ("MediaTrackGraph %p destroyed", this));
+  LOG(LogLevel::Debug, ("MediaTrackGraphImpl::~MediaTrackGraphImpl"));
+}
+
+void MediaTrackGraphImpl::AddTrackGraphThread(MediaTrack* aTrack) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  aTrack->mStartTime = mProcessedTime;
+
+  if (aTrack->IsSuspended()) {
+    mSuspendedTracks.AppendElement(aTrack);
+    LOG(LogLevel::Debug,
+        ("%p: Adding media track %p, in the suspended track array", this,
+         aTrack));
+  } else {
+    mTracks.AppendElement(aTrack);
+    LOG(LogLevel::Debug, ("%p:  Adding media track %p, count %zu", this, aTrack,
+                          mTracks.Length()));
+  }
+
+  SetTrackOrderDirty();
+}
+
+void MediaTrackGraphImpl::RemoveTrackGraphThread(MediaTrack* aTrack) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  // Remove references in mTrackUpdates before we allow aTrack to die.
+  // Pending updates are not needed (since the main thread has already given
+  // up the track) so we will just drop them.
+  {
+    MonitorAutoLock lock(mMonitor);
+    for (uint32_t i = 0; i < mTrackUpdates.Length(); ++i) {
+      if (mTrackUpdates[i].mTrack == aTrack) {
+        mTrackUpdates[i].mTrack = nullptr;
+      }
+    }
+  }
+
+  // Ensure that mFirstCycleBreaker is updated when necessary.
+  SetTrackOrderDirty();
+
+  UnregisterAllAudioOutputs(aTrack);
+
+  if (aTrack->IsSuspended()) {
+    mSuspendedTracks.RemoveElement(aTrack);
+  } else {
+    mTracks.RemoveElement(aTrack);
+  }
+
+  LOG(LogLevel::Debug, ("%p: Removed media track %p, count %zu", this, aTrack,
+                        mTracks.Length()));
+
+  NS_RELEASE(aTrack);  // probably destroying it
+}
+
+TrackTime MediaTrackGraphImpl::GraphTimeToTrackTimeWithBlocking(
+    const MediaTrack* aTrack, GraphTime aTime) const {
+  MOZ_ASSERT(
+      aTime <= mStateComputedTime,
+      "Don't ask about times where we haven't made blocking decisions yet");
+  return std::max<TrackTime>(
+      0, std::min(aTime, aTrack->mStartBlocking) - aTrack->mStartTime);
+}
+
+GraphTime MediaTrackGraphImpl::IterationEnd() const {
+  MOZ_ASSERT(OnGraphThread());
+  return mIterationEndTime;
+}
+
+void MediaTrackGraphImpl::UpdateCurrentTimeForTracks(
+    GraphTime aPrevCurrentTime) {
+  MOZ_ASSERT(OnGraphThread());
+  for (MediaTrack* track : AllTracks()) {
+    // Shouldn't have already notified of ended *and* have output!
+    MOZ_ASSERT_IF(track->mStartBlocking > aPrevCurrentTime,
+                  !track->mNotifiedEnded);
+
+    // Calculate blocked time and fire Blocked/Unblocked events
+    GraphTime blockedTime = mStateComputedTime - track->mStartBlocking;
+    NS_ASSERTION(blockedTime >= 0, "Error in blocking time");
+    track->AdvanceTimeVaryingValuesToCurrentTime(mStateComputedTime,
+                                                 blockedTime);
+    LOG(LogLevel::Verbose,
+        ("%p: MediaTrack %p bufferStartTime=%f blockedTime=%f", this, track,
+         MediaTimeToSeconds(track->mStartTime),
+         MediaTimeToSeconds(blockedTime)));
+    track->mStartBlocking = mStateComputedTime;
+
+    TrackTime trackCurrentTime =
+        track->GraphTimeToTrackTime(mStateComputedTime);
+    if (track->mEnded) {
+      MOZ_ASSERT(track->GetEnd() <= trackCurrentTime);
+      if (!track->mNotifiedEnded) {
+        // Playout of this track ended and listeners have not been notified.
+        track->mNotifiedEnded = true;
+        SetTrackOrderDirty();
+        for (const auto& listener : track->mTrackListeners) {
+          listener->NotifyOutput(this, track->GetEnd());
+          listener->NotifyEnded(this);
+        }
+      }
+    } else {
+      for (const auto& listener : track->mTrackListeners) {
+        listener->NotifyOutput(this, trackCurrentTime);
+      }
+    }
+  }
+}
+
+template <typename C, typename Chunk>
+void MediaTrackGraphImpl::ProcessChunkMetadataForInterval(MediaTrack* aTrack,
+                                                          C& aSegment,
+                                                          TrackTime aStart,
+                                                          TrackTime aEnd) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  MOZ_ASSERT(aTrack);
+
+  TrackTime offset = 0;
+  for (typename C::ConstChunkIterator chunk(aSegment); !chunk.IsEnded();
+       chunk.Next()) {
+    if (offset >= aEnd) {
+      break;
+    }
+    offset += chunk->GetDuration();
+    if (chunk->IsNull() || offset < aStart) {
+      continue;
+    }
+    const PrincipalHandle& principalHandle = chunk->GetPrincipalHandle();
+    if (principalHandle != aSegment.GetLastPrincipalHandle()) {
+      aSegment.SetLastPrincipalHandle(principalHandle);
+      LOG(LogLevel::Debug,
+          ("%p: MediaTrack %p, principalHandle "
+           "changed in %sChunk with duration %lld",
+           this, aTrack,
+           aSegment.GetType() == MediaSegment::AUDIO ? "Audio" : "Video",
+           (long long)chunk->GetDuration()));
+      for (const auto& listener : aTrack->mTrackListeners) {
+        listener->NotifyPrincipalHandleChanged(this, principalHandle);
+      }
+    }
+  }
+}
+
+void MediaTrackGraphImpl::ProcessChunkMetadata(GraphTime aPrevCurrentTime) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  for (MediaTrack* track : AllTracks()) {
+    TrackTime iterationStart = track->GraphTimeToTrackTime(aPrevCurrentTime);
+    TrackTime iterationEnd = track->GraphTimeToTrackTime(mProcessedTime);
+    if (!track->mSegment) {
+      continue;
+    }
+    if (track->mType == MediaSegment::AUDIO) {
+      ProcessChunkMetadataForInterval<AudioSegment, AudioChunk>(
+          track, *track->GetData<AudioSegment>(), iterationStart, iterationEnd);
+    } else if (track->mType == MediaSegment::VIDEO) {
+      ProcessChunkMetadataForInterval<VideoSegment, VideoChunk>(
+          track, *track->GetData<VideoSegment>(), iterationStart, iterationEnd);
+    } else {
+      MOZ_CRASH("Unknown track type");
+    }
+  }
+}
+
+GraphTime MediaTrackGraphImpl::WillUnderrun(MediaTrack* aTrack,
+                                            GraphTime aEndBlockingDecisions) {
+  // Ended tracks can't underrun. ProcessedMediaTracks also can't cause
+  // underrun currently, since we'll always be able to produce data for them
+  // unless they block on some other track.
+  if (aTrack->mEnded || aTrack->AsProcessedTrack()) {
+    return aEndBlockingDecisions;
+  }
+  // This track isn't ended or suspended. We don't need to call
+  // TrackTimeToGraphTime since an underrun is the only thing that can block
+  // it.
+  GraphTime bufferEnd = aTrack->GetEnd() + aTrack->mStartTime;
+#ifdef DEBUG
+  if (bufferEnd < mProcessedTime) {
+    LOG(LogLevel::Error, ("%p: MediaTrack %p underrun, "
+                          "bufferEnd %f < mProcessedTime %f (%" PRId64
+                          " < %" PRId64 "), TrackTime %" PRId64,
+                          this, aTrack, MediaTimeToSeconds(bufferEnd),
+                          MediaTimeToSeconds(mProcessedTime), bufferEnd,
+                          mProcessedTime, aTrack->GetEnd()));
+    NS_ASSERTION(bufferEnd >= mProcessedTime, "Buffer underran");
+  }
+#endif
+  return std::min(bufferEnd, aEndBlockingDecisions);
+}
+
+namespace {
+// Value of mCycleMarker for unvisited tracks in cycle detection.
+const uint32_t NOT_VISITED = UINT32_MAX;
+// Value of mCycleMarker for ordered tracks in muted cycles.
+const uint32_t IN_MUTED_CYCLE = 1;
+}  // namespace
+
+bool MediaTrackGraphImpl::AudioTrackPresent() {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+
+  bool audioTrackPresent = false;
+  for (MediaTrack* track : mTracks) {
+    if (track->AsAudioNodeTrack()) {
+      audioTrackPresent = true;
+      break;
+    }
+
+    if (track->mType == MediaSegment::AUDIO && !track->mNotifiedEnded) {
+      audioTrackPresent = true;
+      break;
+    }
+  }
+
+  // We may not have audio input device when we only have AudioNodeTracks. But
+  // if audioTrackPresent is false, we must have no input device.
+  MOZ_DIAGNOSTIC_ASSERT_IF(
+      !audioTrackPresent,
+      !mDeviceInputTrackManagerGraphThread.GetNativeInputTrack());
+
+  return audioTrackPresent;
+}
+
+void MediaTrackGraphImpl::CheckDriver() {
+  MOZ_ASSERT(OnGraphThread());
+  // An offline graph has only one driver.
+  // Otherwise, if a switch is already pending, let that happen.
+  if (!mRealtime || Switching()) {
+    return;
+  }
+
+  AudioCallbackDriver* audioCallbackDriver =
+      CurrentDriver()->AsAudioCallbackDriver();
+  if (audioCallbackDriver && !audioCallbackDriver->OnFallback()) {
+    for (PendingResumeOperation& op : mPendingResumeOperations) {
+      op.Apply(this);
+    }
+    mPendingResumeOperations.Clear();
+  }
+
+  // Note that this looks for any audio tracks, input or output, and switches
+  // to a SystemClockDriver if there are none active or no resume operations
+  // to make any active.
+  bool needAudioCallbackDriver =
+      !mPendingResumeOperations.IsEmpty() || AudioTrackPresent();
+  if (!needAudioCallbackDriver) {
+    if (audioCallbackDriver && audioCallbackDriver->IsStarted()) {
+      SwitchAtNextIteration(
+          new SystemClockDriver(this, CurrentDriver(), mSampleRate));
+    }
+    return;
+  }
+
+  NativeInputTrack* native =
+      mDeviceInputTrackManagerGraphThread.GetNativeInputTrack();
+  CubebUtils::AudioDeviceID inputDevice = native ? native->mDeviceId : nullptr;
+  uint32_t inputChannelCount =
+      native ? AudioInputChannelCount(native->mDeviceId) : 0;
+  AudioInputType inputPreference =
+      native ? AudioInputDevicePreference(native->mDeviceId)
+             : AudioInputType::Unknown;
+
+  uint32_t graphOutputChannelCount = AudioOutputChannelCount();
+  if (!audioCallbackDriver) {
+    if (graphOutputChannelCount > 0) {
+      AudioCallbackDriver* driver = new AudioCallbackDriver(
+          this, CurrentDriver(), mSampleRate, graphOutputChannelCount,
+          inputChannelCount, mOutputDeviceID, inputDevice, inputPreference);
+      SwitchAtNextIteration(driver);
+    }
+    return;
+  }
+
+  // Check if this graph should switch to a different number of output channels.
+  // Generally, a driver switch is explicitly made by an event (e.g., setting
+  // the AudioDestinationNode channelCount), but if an HTMLMediaElement is
+  // directly playing back via another HTMLMediaElement, the number of channels
+  // of the media determines how many channels to output, and it can change
+  // dynamically.
+  if (graphOutputChannelCount != audioCallbackDriver->OutputChannelCount()) {
+    AudioCallbackDriver* driver = new AudioCallbackDriver(
+        this, CurrentDriver(), mSampleRate, graphOutputChannelCount,
+        inputChannelCount, mOutputDeviceID, inputDevice, inputPreference);
+    SwitchAtNextIteration(driver);
+  }
+}
+
+void MediaTrackGraphImpl::UpdateTrackOrder() {
+  if (!mTrackOrderDirty) {
+    return;
+  }
+
+  mTrackOrderDirty = false;
+
+  // The algorithm for finding cycles is based on Tim Leslie's iterative
+  // implementation [1][2] of Pearce's variant [3] of Tarjan's strongly
+  // connected components (SCC) algorithm.  There are variations (a) to
+  // distinguish whether tracks in SCCs of size 1 are in a cycle and (b) to
+  // re-run the algorithm over SCCs with breaks at DelayNodes.
+  //
+  // [1] http://www.timl.id.au/?p=327
+  // [2]
+  // https://github.com/scipy/scipy/blob/e2c502fca/scipy/sparse/csgraph/_traversal.pyx#L582
+  // [3] http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.102.1707
+  //
+  // There are two stacks.  One for the depth-first search (DFS),
+  mozilla::LinkedList<MediaTrack> dfsStack;
+  // and another for tracks popped from the DFS stack, but still being
+  // considered as part of SCCs involving tracks on the stack.
+  mozilla::LinkedList<MediaTrack> sccStack;
+
+  // An index into mTracks for the next track found with no unsatisfied
+  // upstream dependencies.
+  uint32_t orderedTrackCount = 0;
+
+  for (uint32_t i = 0; i < mTracks.Length(); ++i) {
+    MediaTrack* t = mTracks[i];
+    ProcessedMediaTrack* pt = t->AsProcessedTrack();
+    if (pt) {
+      // The dfsStack initially contains a list of all processed tracks in
+      // unchanged order.
+      dfsStack.insertBack(t);
+      pt->mCycleMarker = NOT_VISITED;
+    } else {
+      // SourceMediaTracks have no inputs and so can be ordered now.
+      mTracks[orderedTrackCount] = t;
+      ++orderedTrackCount;
+    }
+  }
+
+  // mNextStackMarker corresponds to "index" in Tarjan's algorithm.  It is a
+  // counter to label mCycleMarker on the next visited track in the DFS
+  // uniquely in the set of visited tracks that are still being considered.
+  //
+  // In this implementation, the counter descends so that the values are
+  // strictly greater than the values that mCycleMarker takes when the track
+  // has been ordered (0 or IN_MUTED_CYCLE).
+  //
+  // Each new track labelled, as the DFS searches upstream, receives a value
+  // less than those used for all other tracks being considered.
+  uint32_t nextStackMarker = NOT_VISITED - 1;
+  // Reset list of DelayNodes in cycles stored at the tail of mTracks.
+  mFirstCycleBreaker = mTracks.Length();
+
+  // Rearrange dfsStack order as required to DFS upstream and pop tracks
+  // in processing order to place in mTracks.
+  while (auto pt = static_cast<ProcessedMediaTrack*>(dfsStack.getFirst())) {
+    const auto& inputs = pt->mInputs;
+    MOZ_ASSERT(pt->AsProcessedTrack());
+    if (pt->mCycleMarker == NOT_VISITED) {
+      // Record the position on the visited stack, so that any searches
+      // finding this track again know how much of the stack is in the cycle.
+      pt->mCycleMarker = nextStackMarker;
+      --nextStackMarker;
+      // Not-visited input tracks should be processed first.
+      // SourceMediaTracks have already been ordered.
+      for (uint32_t i = inputs.Length(); i--;) {
+        if (inputs[i]->GetSource()->IsSuspended()) {
+          continue;
+        }
+        auto input = inputs[i]->GetSource()->AsProcessedTrack();
+        if (input && input->mCycleMarker == NOT_VISITED) {
+          // It can be that this track has an input which is from a suspended
+          // AudioContext.
+          if (input->isInList()) {
+            input->remove();
+            dfsStack.insertFront(input);
+          }
+        }
+      }
+      continue;
+    }
+
+    // Returning from DFS.  Pop from dfsStack.
+    pt->remove();
+
+    // cycleStackMarker keeps track of the highest marker value on any
+    // upstream track, if any, found receiving input, directly or indirectly,
+    // from the visited stack (and so from |ps|, making a cycle).  In a
+    // variation from Tarjan's SCC algorithm, this does not include |ps|
+    // unless it is part of the cycle.
+    uint32_t cycleStackMarker = 0;
+    for (uint32_t i = inputs.Length(); i--;) {
+      if (inputs[i]->GetSource()->IsSuspended()) {
+        continue;
+      }
+      auto input = inputs[i]->GetSource()->AsProcessedTrack();
+      if (input) {
+        cycleStackMarker = std::max(cycleStackMarker, input->mCycleMarker);
+      }
+    }
+
+    if (cycleStackMarker <= IN_MUTED_CYCLE) {
+      // All inputs have been ordered and their stack markers have been removed.
+      // This track is not part of a cycle.  It can be processed next.
+      pt->mCycleMarker = 0;
+      mTracks[orderedTrackCount] = pt;
+      ++orderedTrackCount;
+      continue;
+    }
+
+    // A cycle has been found.  Record this track for ordering when all
+    // tracks in this SCC have been popped from the DFS stack.
+    sccStack.insertFront(pt);
+
+    if (cycleStackMarker > pt->mCycleMarker) {
+      // Cycles have been found that involve tracks that remain on the stack.
+      // Leave mCycleMarker indicating the most downstream (last) track on
+      // the stack known to be part of this SCC.  In this way, any searches on
+      // other paths that find |ps| will know (without having to traverse from
+      // this track again) that they are part of this SCC (i.e. part of an
+      // intersecting cycle).
+      pt->mCycleMarker = cycleStackMarker;
+      continue;
+    }
+
+    // |pit| is the root of an SCC involving no other tracks on dfsStack, the
+    // complete SCC has been recorded, and tracks in this SCC are part of at
+    // least one cycle.
+    MOZ_ASSERT(cycleStackMarker == pt->mCycleMarker);
+    // If there are DelayNodes in this SCC, then they may break the cycles.
+    bool haveDelayNode = false;
+    auto next = sccStack.getFirst();
+    // Tracks in this SCC are identified by mCycleMarker <= cycleStackMarker.
+    // (There may be other tracks later in sccStack from other incompletely
+    // searched SCCs, involving tracks still on dfsStack.)
+    //
+    // DelayNodes in cycles must behave differently from those not in cycles,
+    // so all DelayNodes in the SCC must be identified.
+    while (next && static_cast<ProcessedMediaTrack*>(next)->mCycleMarker <=
+                       cycleStackMarker) {
+      auto nt = next->AsAudioNodeTrack();
+      // Get next before perhaps removing from list below.
+      next = next->getNext();
+      if (nt && nt->Engine()->AsDelayNodeEngine()) {
+        haveDelayNode = true;
+        // DelayNodes break cycles by producing their output in a
+        // preprocessing phase; they do not need to be ordered before their
+        // consumers.  Order them at the tail of mTracks so that they can be
+        // handled specially.  Do so now, so that DFS ignores them.
+        nt->remove();
+        nt->mCycleMarker = 0;
+        --mFirstCycleBreaker;
+        mTracks[mFirstCycleBreaker] = nt;
+      }
+    }
+    auto after_scc = next;
+    while ((next = sccStack.getFirst()) != after_scc) {
+      next->remove();
+      auto removed = static_cast<ProcessedMediaTrack*>(next);
+      if (haveDelayNode) {
+        // Return tracks to the DFS stack again (to order and detect cycles
+        // without delayNodes).  Any of these tracks that are still inputs
+        // for tracks on the visited stack must be returned to the front of
+        // the stack to be ordered before their dependents.  We know that none
+        // of these tracks need input from tracks on the visited stack, so
+        // they can all be searched and ordered before the current stack head
+        // is popped.
+        removed->mCycleMarker = NOT_VISITED;
+        dfsStack.insertFront(removed);
+      } else {
+        // Tracks in cycles without any DelayNodes must be muted, and so do
+        // not need input and can be ordered now.  They must be ordered before
+        // their consumers so that their muted output is available.
+        removed->mCycleMarker = IN_MUTED_CYCLE;
+        mTracks[orderedTrackCount] = removed;
+        ++orderedTrackCount;
+      }
+    }
+  }
+
+  MOZ_ASSERT(orderedTrackCount == mFirstCycleBreaker);
+}
+
+TrackTime MediaTrackGraphImpl::PlayAudio(AudioMixer* aMixer,
+                                         const TrackKeyAndVolume& aTkv,
+                                         GraphTime aPlayedTime) {
+  MOZ_ASSERT(OnGraphThread());
+  MOZ_ASSERT(mRealtime, "Should only attempt to play audio in realtime mode");
+  MOZ_ASSERT(aMixer, "Can only play audio if there's a mixer");
+
+  TrackTime ticksWritten = 0;
+
+  ticksWritten = 0;
+  MediaTrack* track = aTkv.mTrack;
+  AudioSegment* audio = track->GetData<AudioSegment>();
+  AudioSegment output;
+
+  TrackTime offset = track->GraphTimeToTrackTime(aPlayedTime);
+
+  // We don't update Track->mTracksStartTime here to account for time spent
+  // blocked. Instead, we'll update it in UpdateCurrentTimeForTracks after
+  // the blocked period has completed. But we do need to make sure we play
+  // from the right offsets in the track buffer, even if we've already
+  // written silence for some amount of blocked time after the current time.
+  GraphTime t = aPlayedTime;
+  while (t < mStateComputedTime) {
+    bool blocked = t >= track->mStartBlocking;
+    GraphTime end = blocked ? mStateComputedTime : track->mStartBlocking;
+    NS_ASSERTION(end <= mStateComputedTime, "mStartBlocking is wrong!");
+
+    // Check how many ticks of sound we can provide if we are blocked some
+    // time in the middle of this cycle.
+    TrackTime toWrite = end - t;
+
+    if (blocked) {
+      output.InsertNullDataAtStart(toWrite);
+      ticksWritten += toWrite;
+      LOG(LogLevel::Verbose,
+          ("%p: MediaTrack %p writing %" PRId64 " blocking-silence samples for "
+           "%f to %f (%" PRId64 " to %" PRId64 ")",
+           this, track, toWrite, MediaTimeToSeconds(t), MediaTimeToSeconds(end),
+           offset, offset + toWrite));
+    } else {
+      TrackTime endTicksNeeded = offset + toWrite;
+      TrackTime endTicksAvailable = audio->GetDuration();
+
+      if (endTicksNeeded <= endTicksAvailable) {
+        LOG(LogLevel::Verbose,
+            ("%p: MediaTrack %p writing %" PRId64 " samples for %f to %f "
+             "(samples %" PRId64 " to %" PRId64 ")",
+             this, track, toWrite, MediaTimeToSeconds(t),
+             MediaTimeToSeconds(end), offset, endTicksNeeded));
+        output.AppendSlice(*audio, offset, endTicksNeeded);
+        ticksWritten += toWrite;
+        offset = endTicksNeeded;
+      } else {
+        // MOZ_ASSERT(track->IsEnded(), "Not enough data, and track not
+        // ended."); If we are at the end of the track, maybe write the
+        // remaining samples, and pad with/output silence.
+        if (endTicksNeeded > endTicksAvailable && offset < endTicksAvailable) {
+          output.AppendSlice(*audio, offset, endTicksAvailable);
+
+          LOG(LogLevel::Verbose,
+              ("%p: MediaTrack %p writing %" PRId64 " samples for %f to %f "
+               "(samples %" PRId64 " to %" PRId64 ")",
+               this, track, toWrite, MediaTimeToSeconds(t),
+               MediaTimeToSeconds(end), offset, endTicksNeeded));
+          uint32_t available = endTicksAvailable - offset;
+          ticksWritten += available;
+          toWrite -= available;
+          offset = endTicksAvailable;
+        }
+        output.AppendNullData(toWrite);
+        LOG(LogLevel::Verbose,
+            ("%p MediaTrack %p writing %" PRId64 " padding slsamples for %f to "
+             "%f (samples %" PRId64 " to %" PRId64 ")",
+             this, track, toWrite, MediaTimeToSeconds(t),
+             MediaTimeToSeconds(end), offset, endTicksNeeded));
+        ticksWritten += toWrite;
+      }
+      output.ApplyVolume(mGlobalVolume * aTkv.mVolume);
+    }
+    t = end;
+
+    uint32_t outputChannels;
+    // Use the number of channel the driver expects: this is the number of
+    // channel that can be output by the underlying system level audio stream.
+    // Fall back to something sensible if this graph is being driven by a normal
+    // thread (this can happen when there are no output devices, etc.).
+    if (CurrentDriver()->AsAudioCallbackDriver()) {
+      outputChannels =
+          CurrentDriver()->AsAudioCallbackDriver()->OutputChannelCount();
+    } else {
+      outputChannels = AudioOutputChannelCount();
+    }
+    output.WriteTo(*aMixer, outputChannels, mSampleRate);
+  }
+  return ticksWritten;
+}
+
+DeviceInputTrack* MediaTrackGraphImpl::GetDeviceInputTrackMainThread(
+    CubebUtils::AudioDeviceID aID) {
+  MOZ_ASSERT(NS_IsMainThread());
+  return mDeviceInputTrackManagerMainThread.GetDeviceInputTrack(aID);
+}
+
+NativeInputTrack* MediaTrackGraphImpl::GetNativeInputTrackMainThread() {
+  MOZ_ASSERT(NS_IsMainThread());
+  return mDeviceInputTrackManagerMainThread.GetNativeInputTrack();
+}
+
+void MediaTrackGraphImpl::OpenAudioInputImpl(DeviceInputTrack* aTrack) {
+  MOZ_ASSERT(OnGraphThread());
+  LOG(LogLevel::Debug,
+      ("%p OpenAudioInputImpl: device %p", this, aTrack->mDeviceId));
+
+  mDeviceInputTrackManagerGraphThread.Add(aTrack);
+
+  if (aTrack->AsNativeInputTrack()) {
+    // Switch Drivers since we're adding input (to input-only or full-duplex)
+    AudioCallbackDriver* driver = new AudioCallbackDriver(
+        this, CurrentDriver(), mSampleRate, AudioOutputChannelCount(),
+        AudioInputChannelCount(aTrack->mDeviceId), mOutputDeviceID,
+        aTrack->mDeviceId, AudioInputDevicePreference(aTrack->mDeviceId));
+    LOG(LogLevel::Debug,
+        ("%p OpenAudioInputImpl: starting new AudioCallbackDriver(input) %p",
+         this, driver));
+    SwitchAtNextIteration(driver);
+  } else {
+    NonNativeInputTrack* nonNative = aTrack->AsNonNativeInputTrack();
+    MOZ_ASSERT(nonNative);
+    // Start non-native input right away.
+    nonNative->StartAudio(MakeRefPtr<AudioInputSource>(
+        MakeRefPtr<AudioInputSourceListener>(nonNative),
+        nonNative->GenerateSourceId(), nonNative->mDeviceId,
+        AudioInputChannelCount(nonNative->mDeviceId),
+        AudioInputDevicePreference(nonNative->mDeviceId) ==
+            AudioInputType::Voice,
+        nonNative->mPrincipalHandle, nonNative->mSampleRate, GraphRate(),
+        StaticPrefs::media_clockdrift_buffering()));
+  }
+}
+
+void MediaTrackGraphImpl::OpenAudioInput(DeviceInputTrack* aTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aTrack);
+
+  LOG(LogLevel::Debug, ("%p OpenInput: DeviceInputTrack %p for device %p", this,
+                        aTrack, aTrack->mDeviceId));
+
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrackGraphImpl* aGraph, DeviceInputTrack* aInputTrack)
+        : ControlMessage(nullptr), mGraph(aGraph), mInputTrack(aInputTrack) {}
+    void Run() override {
+      TRACE("MTG::OpenAudioInputImpl ControlMessage");
+      mGraph->OpenAudioInputImpl(mInputTrack);
+    }
+    MediaTrackGraphImpl* mGraph;
+    DeviceInputTrack* mInputTrack;
+  };
+
+  mDeviceInputTrackManagerMainThread.Add(aTrack);
+
+  this->AppendMessage(MakeUnique<Message>(this, aTrack));
+}
+
+void MediaTrackGraphImpl::CloseAudioInputImpl(DeviceInputTrack* aTrack) {
+  MOZ_ASSERT(OnGraphThread());
+
+  LOG(LogLevel::Debug,
+      ("%p CloseAudioInputImpl: device %p", this, aTrack->mDeviceId));
+
+  if (NonNativeInputTrack* nonNative = aTrack->AsNonNativeInputTrack()) {
+    nonNative->StopAudio();
+    mDeviceInputTrackManagerGraphThread.Remove(aTrack);
+    return;
+  }
+
+  MOZ_ASSERT(aTrack->AsNativeInputTrack());
+
+  mDeviceInputTrackManagerGraphThread.Remove(aTrack);
+
+  // Switch Drivers since we're adding or removing an input (to nothing/system
+  // or output only)
+  bool audioTrackPresent = AudioTrackPresent();
+
+  GraphDriver* driver;
+  if (audioTrackPresent) {
+    // We still have audio output
+    LOG(LogLevel::Debug,
+        ("%p: CloseInput: output present (AudioCallback)", this));
+
+    driver = new AudioCallbackDriver(
+        this, CurrentDriver(), mSampleRate, AudioOutputChannelCount(),
+        AudioInputChannelCount(aTrack->mDeviceId), mOutputDeviceID, nullptr,
+        AudioInputDevicePreference(aTrack->mDeviceId));
+    SwitchAtNextIteration(driver);
+  } else if (CurrentDriver()->AsAudioCallbackDriver()) {
+    LOG(LogLevel::Debug,
+        ("%p: CloseInput: no output present (SystemClockCallback)", this));
+
+    driver = new SystemClockDriver(this, CurrentDriver(), mSampleRate);
+    SwitchAtNextIteration(driver);
+  }  // else SystemClockDriver->SystemClockDriver, no switch
+}
+
+void MediaTrackGraphImpl::RegisterAudioOutput(MediaTrack* aTrack, void* aKey) {
+  MOZ_ASSERT(OnGraphThread());
+  MOZ_ASSERT(!mAudioOutputs.Contains(TrackAndKey{aTrack, aKey}));
+
+  TrackKeyAndVolume* tkv = mAudioOutputs.AppendElement();
+  tkv->mTrack = aTrack;
+  tkv->mKey = aKey;
+  tkv->mVolume = 1.0;
+
+  if (!CurrentDriver()->AsAudioCallbackDriver() && !Switching()) {
+    NativeInputTrack* native =
+        mDeviceInputTrackManagerGraphThread.GetNativeInputTrack();
+    CubebUtils::AudioDeviceID inputDevice =
+        native ? native->mDeviceId : nullptr;
+    uint32_t inputChannelCount =
+        native ? AudioInputChannelCount(native->mDeviceId) : 0;
+    AudioInputType inputPreference =
+        native ? AudioInputDevicePreference(native->mDeviceId)
+               : AudioInputType::Unknown;
+
+    AudioCallbackDriver* driver = new AudioCallbackDriver(
+        this, CurrentDriver(), mSampleRate, AudioOutputChannelCount(),
+        inputChannelCount, mOutputDeviceID, inputDevice, inputPreference);
+    SwitchAtNextIteration(driver);
+  }
+}
+
+void MediaTrackGraphImpl::UnregisterAllAudioOutputs(MediaTrack* aTrack) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+
+  mAudioOutputs.RemoveElementsBy([aTrack](const TrackKeyAndVolume& aTkv) {
+    return aTkv.mTrack == aTrack;
+  });
+}
+
+void MediaTrackGraphImpl::UnregisterAudioOutput(MediaTrack* aTrack,
+                                                void* aKey) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+
+  DebugOnly<bool> removed =
+      mAudioOutputs.RemoveElement(TrackAndKey{aTrack, aKey});
+  MOZ_ASSERT(removed, "Audio output not found");
+}
+
+void MediaTrackGraphImpl::CloseAudioInput(DeviceInputTrack* aTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aTrack);
+
+  LOG(LogLevel::Debug, ("%p CloseInput: DeviceInputTrack %p for device %p",
+                        this, aTrack, aTrack->mDeviceId));
+
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrackGraphImpl* aGraph, DeviceInputTrack* aInputTrack)
+        : ControlMessage(nullptr), mGraph(aGraph), mInputTrack(aInputTrack) {}
+    void Run() override {
+      TRACE("MTG::CloseAudioInputImpl ControlMessage");
+      mGraph->CloseAudioInputImpl(mInputTrack);
+    }
+    MediaTrackGraphImpl* mGraph;
+    DeviceInputTrack* mInputTrack;
+  };
+
+  // DeviceInputTrack is still alive (in mTracks) even we remove it here, since
+  // aTrack->Destroy() is called after this. See DeviceInputTrack::CloseAudio
+  // for more details.
+  mDeviceInputTrackManagerMainThread.Remove(aTrack);
+
+  this->AppendMessage(MakeUnique<Message>(this, aTrack));
+
+  if (aTrack->AsNativeInputTrack()) {
+    LOG(LogLevel::Debug,
+        ("%p Native input device %p is closed!", this, aTrack->mDeviceId));
+    SetNewNativeInput();
+  }
+}
+
+// All AudioInput listeners get the same speaker data (at least for now).
+void MediaTrackGraphImpl::NotifyOutputData(AudioDataValue* aBuffer,
+                                           size_t aFrames, TrackRate aRate,
+                                           uint32_t aChannels) {
+  if (!mDeviceInputTrackManagerGraphThread.GetNativeInputTrack()) {
+    return;
+  }
+
+#if defined(MOZ_WEBRTC)
+  for (const auto& track : mTracks) {
+    if (const auto& t = track->AsAudioProcessingTrack()) {
+      t->NotifyOutputData(this, aBuffer, aFrames, aRate, aChannels);
+    }
+  }
+#endif
+}
+
+void MediaTrackGraphImpl::NotifyInputStopped() {
+  NativeInputTrack* native =
+      mDeviceInputTrackManagerGraphThread.GetNativeInputTrack();
+  if (!native) {
+    return;
+  }
+  native->NotifyInputStopped(this);
+}
+
+void MediaTrackGraphImpl::NotifyInputData(const AudioDataValue* aBuffer,
+                                          size_t aFrames, TrackRate aRate,
+                                          uint32_t aChannels,
+                                          uint32_t aAlreadyBuffered) {
+  // Either we have an audio input device, or we just removed the audio input
+  // this iteration, and we're switching back to an output-only driver next
+  // iteration.
+  NativeInputTrack* native =
+      mDeviceInputTrackManagerGraphThread.GetNativeInputTrack();
+  MOZ_ASSERT(native || Switching());
+  if (!native) {
+    return;
+  }
+  native->NotifyInputData(this, aBuffer, aFrames, aRate, aChannels,
+                          aAlreadyBuffered);
+}
+
+void MediaTrackGraphImpl::DeviceChangedImpl() {
+  MOZ_ASSERT(OnGraphThread());
+  NativeInputTrack* native =
+      mDeviceInputTrackManagerGraphThread.GetNativeInputTrack();
+  if (!native) {
+    return;
+  }
+  native->DeviceChanged(this);
+}
+
+void MediaTrackGraphImpl::SetMaxOutputChannelCount(uint32_t aMaxChannelCount) {
+  MOZ_ASSERT(OnGraphThread());
+  mMaxOutputChannelCount = aMaxChannelCount;
+}
+
+void MediaTrackGraphImpl::DeviceChanged() {
+  // This is safe to be called from any thread: this message comes from an
+  // underlying platform API, and we don't have much guarantees. If it is not
+  // called from the main thread (and it probably will rarely be), it will post
+  // itself to the main thread, and the actual device change message will be ran
+  // and acted upon on the graph thread.
+  if (!NS_IsMainThread()) {
+    RefPtr<nsIRunnable> runnable = WrapRunnable(
+        RefPtr<MediaTrackGraphImpl>(this), &MediaTrackGraphImpl::DeviceChanged);
+    mMainThread->Dispatch(runnable.forget());
+    return;
+  }
+
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrackGraph* aGraph)
+        : ControlMessage(nullptr),
+          mGraphImpl(static_cast<MediaTrackGraphImpl*>(aGraph)) {}
+    void Run() override {
+      TRACE("MTG::DeviceChangeImpl ControlMessage");
+      mGraphImpl->DeviceChangedImpl();
+    }
+    // We know that this is valid, because the graph can't shutdown if it has
+    // messages.
+    MediaTrackGraphImpl* mGraphImpl;
+  };
+
+  if (mMainThreadTrackCount == 0 && mMainThreadPortCount == 0) {
+    // This is a special case where the origin of this event cannot control the
+    // lifetime of the graph, because the graph is controling the lifetime of
+    // the AudioCallbackDriver where the event originated.
+    // We know the graph is soon going away, so there's no need to notify about
+    // this device change.
+    return;
+  }
+
+  // Reset the latency, it will get fetched again next time it's queried.
+  MOZ_ASSERT(NS_IsMainThread());
+  mAudioOutputLatency = 0.0;
+
+  // Dispatch to the bg thread to do the (potentially expensive) query of the
+  // maximum channel count, and then dispatch back to the main thread, then to
+  // the graph, with the new info.
+  RefPtr<MediaTrackGraphImpl> self = this;
+  NS_DispatchBackgroundTask(NS_NewRunnableFunction(
+      "MaxChannelCountUpdateOnBgThread", [self{std::move(self)}]() {
+        uint32_t maxChannelCount = CubebUtils::MaxNumberOfChannels();
+        self->Dispatch(NS_NewRunnableFunction(
+            "MaxChannelCountUpdateToMainThread",
+            [self{self}, maxChannelCount]() {
+              class MessageToGraph : public ControlMessage {
+               public:
+                explicit MessageToGraph(MediaTrackGraph* aGraph,
+                                        uint32_t aMaxChannelCount)
+                    : ControlMessage(nullptr),
+                      mGraphImpl(static_cast<MediaTrackGraphImpl*>(aGraph)),
+                      mMaxChannelCount(aMaxChannelCount) {}
+                void Run() override {
+                  TRACE("MTG::SetMaxOutputChannelCount ControlMessage")
+                  mGraphImpl->SetMaxOutputChannelCount(mMaxChannelCount);
+                }
+                MediaTrackGraphImpl* mGraphImpl;
+                uint32_t mMaxChannelCount;
+              };
+              self->AppendMessage(
+                  MakeUnique<MessageToGraph>(self, maxChannelCount));
+            }));
+      }));
+
+  AppendMessage(MakeUnique<Message>(this));
+}
+
+static const char* GetAudioInputTypeString(const AudioInputType& aType) {
+  return aType == AudioInputType::Voice ? "Voice" : "Unknown";
+}
+
+void MediaTrackGraphImpl::ReevaluateInputDevice(CubebUtils::AudioDeviceID aID) {
+  MOZ_ASSERT(OnGraphThread());
+
+  LOG(LogLevel::Debug, ("%p: ReevaluateInputDevice: device %p", this, aID));
+
+  DeviceInputTrack* track =
+      mDeviceInputTrackManagerGraphThread.GetDeviceInputTrack(aID);
+  if (!track) {
+    LOG(LogLevel::Debug,
+        ("%p: No DeviceInputTrack for this device. Ignore", this));
+    return;
+  }
+
+  bool needToSwitch = false;
+
+  if (NonNativeInputTrack* nonNative = track->AsNonNativeInputTrack()) {
+    if (nonNative->NumberOfChannels() != AudioInputChannelCount(aID)) {
+      LOG(LogLevel::Debug,
+          ("%p: %u-channel non-native input device %p (track %p) is "
+           "re-configured to %d-channel",
+           this, nonNative->NumberOfChannels(), aID, track,
+           AudioInputChannelCount(aID)));
+      needToSwitch = true;
+    }
+    if (nonNative->DevicePreference() != AudioInputDevicePreference(aID)) {
+      LOG(LogLevel::Debug,
+          ("%p: %s-type non-native input device %p (track %p) is re-configured "
+           "to %s-type",
+           this, GetAudioInputTypeString(nonNative->DevicePreference()), aID,
+           track, GetAudioInputTypeString(AudioInputDevicePreference(aID))));
+      needToSwitch = true;
+    }
+
+    if (needToSwitch) {
+      nonNative->StopAudio();
+      nonNative->StartAudio(MakeRefPtr<AudioInputSource>(
+          MakeRefPtr<AudioInputSourceListener>(nonNative),
+          nonNative->GenerateSourceId(), aID, AudioInputChannelCount(aID),
+          AudioInputDevicePreference(aID) == AudioInputType::Voice,
+          nonNative->mPrincipalHandle, nonNative->mSampleRate, GraphRate(),
+          StaticPrefs::media_clockdrift_buffering()));
+    }
+
+    return;
+  }
+
+  MOZ_ASSERT(track->AsNativeInputTrack());
+
+  if (AudioCallbackDriver* audioCallbackDriver =
+          CurrentDriver()->AsAudioCallbackDriver()) {
+    if (audioCallbackDriver->InputChannelCount() !=
+        AudioInputChannelCount(aID)) {
+      LOG(LogLevel::Debug,
+          ("%p: ReevaluateInputDevice: %u-channel AudioCallbackDriver %p is "
+           "re-configured to %d-channel",
+           this, audioCallbackDriver->InputChannelCount(), audioCallbackDriver,
+           AudioInputChannelCount(aID)));
+      needToSwitch = true;
+    }
+    if (audioCallbackDriver->InputDevicePreference() !=
+        AudioInputDevicePreference(aID)) {
+      LOG(LogLevel::Debug,
+          ("%p: ReevaluateInputDevice: %s-type AudioCallbackDriver %p is "
+           "re-configured to %s-type",
+           this,
+           GetAudioInputTypeString(
+               audioCallbackDriver->InputDevicePreference()),
+           audioCallbackDriver,
+           GetAudioInputTypeString(AudioInputDevicePreference(aID))));
+      needToSwitch = true;
+    }
+  } else if (Switching() && NextDriver()->AsAudioCallbackDriver()) {
+    // We're already in the process of switching to a audio callback driver,
+    // which will happen at the next iteration.
+    // However, maybe it's not the correct number of channels. Re-query the
+    // correct channel amount at this time.
+    needToSwitch = true;
+  }
+
+  if (needToSwitch) {
+    AudioCallbackDriver* newDriver = new AudioCallbackDriver(
+        this, CurrentDriver(), mSampleRate, AudioOutputChannelCount(),
+        AudioInputChannelCount(aID), mOutputDeviceID, aID,
+        AudioInputDevicePreference(aID));
+    SwitchAtNextIteration(newDriver);
+  }
+}
+
+bool MediaTrackGraphImpl::OnGraphThreadOrNotRunning() const {
+  // either we're on the right thread (and calling CurrentDriver() is safe),
+  // or we're going to fail the assert anyway, so don't cross-check
+  // via CurrentDriver().
+  return mGraphDriverRunning ? OnGraphThread() : NS_IsMainThread();
+}
+
+bool MediaTrackGraphImpl::OnGraphThread() const {
+  // we're on the right thread (and calling mDriver is safe),
+  MOZ_ASSERT(mDriver);
+  if (mGraphRunner && mGraphRunner->OnThread()) {
+    return true;
+  }
+  return mDriver->OnThread();
+}
+
+bool MediaTrackGraphImpl::Destroyed() const {
+  MOZ_ASSERT(NS_IsMainThread());
+  return !mSelfRef;
+}
+
+bool MediaTrackGraphImpl::ShouldUpdateMainThread() {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  if (mRealtime) {
+    return true;
+  }
+
+  TimeStamp now = TimeStamp::Now();
+  // For offline graphs, update now if it has been long enough since the last
+  // update, or if it has reached the end.
+  if ((now - mLastMainThreadUpdate).ToMilliseconds() >
+          CurrentDriver()->IterationDuration() ||
+      mStateComputedTime >= mEndTime) {
+    mLastMainThreadUpdate = now;
+    return true;
+  }
+  return false;
+}
+
+void MediaTrackGraphImpl::PrepareUpdatesToMainThreadState(bool aFinalUpdate) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  mMonitor.AssertCurrentThreadOwns();
+
+  // We don't want to frequently update the main thread about timing update
+  // when we are not running in realtime.
+  if (aFinalUpdate || ShouldUpdateMainThread()) {
+    // Strip updates that will be obsoleted below, so as to keep the length of
+    // mTrackUpdates sane.
+    size_t keptUpdateCount = 0;
+    for (size_t i = 0; i < mTrackUpdates.Length(); ++i) {
+      MediaTrack* track = mTrackUpdates[i].mTrack;
+      // RemoveTrackGraphThread() clears mTrack in updates for
+      // tracks that are removed from the graph.
+      MOZ_ASSERT(!track || track->GraphImpl() == this);
+      if (!track || track->MainThreadNeedsUpdates()) {
+        // Discard this update as it has either been cleared when the track
+        // was destroyed or there will be a newer update below.
+        continue;
+      }
+      if (keptUpdateCount != i) {
+        mTrackUpdates[keptUpdateCount] = std::move(mTrackUpdates[i]);
+        MOZ_ASSERT(!mTrackUpdates[i].mTrack);
+      }
+      ++keptUpdateCount;
+    }
+    mTrackUpdates.TruncateLength(keptUpdateCount);
+
+    mTrackUpdates.SetCapacity(mTrackUpdates.Length() + mTracks.Length() +
+                              mSuspendedTracks.Length());
+    for (MediaTrack* track : AllTracks()) {
+      if (!track->MainThreadNeedsUpdates()) {
+        continue;
+      }
+      TrackUpdate* update = mTrackUpdates.AppendElement();
+      update->mTrack = track;
+      // No blocking to worry about here, since we've passed
+      // UpdateCurrentTimeForTracks.
+      update->mNextMainThreadCurrentTime =
+          track->GraphTimeToTrackTime(mProcessedTime);
+      update->mNextMainThreadEnded = track->mNotifiedEnded;
+    }
+    mNextMainThreadGraphTime = mProcessedTime;
+    if (!mPendingUpdateRunnables.IsEmpty()) {
+      mUpdateRunnables.AppendElements(std::move(mPendingUpdateRunnables));
+    }
+  }
+
+  // If this is the final update, then a stable state event will soon be
+  // posted just before this thread finishes, and so there is no need to also
+  // post here.
+  if (!aFinalUpdate &&
+      // Don't send the message to the main thread if it's not going to have
+      // any work to do.
+      !(mUpdateRunnables.IsEmpty() && mTrackUpdates.IsEmpty())) {
+    EnsureStableStateEventPosted();
+  }
+}
+
+GraphTime MediaTrackGraphImpl::RoundUpToEndOfAudioBlock(GraphTime aTime) {
+  if (aTime % WEBAUDIO_BLOCK_SIZE == 0) {
+    return aTime;
+  }
+  return RoundUpToNextAudioBlock(aTime);
+}
+
+GraphTime MediaTrackGraphImpl::RoundUpToNextAudioBlock(GraphTime aTime) {
+  uint64_t block = aTime >> WEBAUDIO_BLOCK_SIZE_BITS;
+  uint64_t nextBlock = block + 1;
+  GraphTime nextTime = nextBlock << WEBAUDIO_BLOCK_SIZE_BITS;
+  return nextTime;
+}
+
+void MediaTrackGraphImpl::ProduceDataForTracksBlockByBlock(
+    uint32_t aTrackIndex, TrackRate aSampleRate) {
+  MOZ_ASSERT(OnGraphThread());
+  MOZ_ASSERT(aTrackIndex <= mFirstCycleBreaker,
+             "Cycle breaker is not AudioNodeTrack?");
+
+  while (mProcessedTime < mStateComputedTime) {
+    // Microtask checkpoints are in between render quanta.
+    nsAutoMicroTask mt;
+
+    GraphTime next = RoundUpToNextAudioBlock(mProcessedTime);
+    for (uint32_t i = mFirstCycleBreaker; i < mTracks.Length(); ++i) {
+      auto nt = static_cast<AudioNodeTrack*>(mTracks[i]);
+      MOZ_ASSERT(nt->AsAudioNodeTrack());
+      nt->ProduceOutputBeforeInput(mProcessedTime);
+    }
+    for (uint32_t i = aTrackIndex; i < mTracks.Length(); ++i) {
+      ProcessedMediaTrack* pt = mTracks[i]->AsProcessedTrack();
+      if (pt) {
+        pt->ProcessInput(
+            mProcessedTime, next,
+            (next == mStateComputedTime) ? ProcessedMediaTrack::ALLOW_END : 0);
+      }
+    }
+    mProcessedTime = next;
+  }
+  NS_ASSERTION(mProcessedTime == mStateComputedTime,
+               "Something went wrong with rounding to block boundaries");
+}
+
+void MediaTrackGraphImpl::RunMessageAfterProcessing(
+    UniquePtr<ControlMessage> aMessage) {
+  MOZ_ASSERT(OnGraphThread());
+
+  if (mFrontMessageQueue.IsEmpty()) {
+    mFrontMessageQueue.AppendElement();
+  }
+
+  // Only one block is used for messages from the graph thread.
+  MOZ_ASSERT(mFrontMessageQueue.Length() == 1);
+  mFrontMessageQueue[0].mMessages.AppendElement(std::move(aMessage));
+}
+
+void MediaTrackGraphImpl::RunMessagesInQueue() {
+  TRACE("MTG::RunMessagesInQueue");
+  MOZ_ASSERT(OnGraphThread());
+  // Calculate independent action times for each batch of messages (each
+  // batch corresponding to an event loop task). This isolates the performance
+  // of different scripts to some extent.
+  for (uint32_t i = 0; i < mFrontMessageQueue.Length(); ++i) {
+    nsTArray<UniquePtr<ControlMessage>>& messages =
+        mFrontMessageQueue[i].mMessages;
+
+    for (uint32_t j = 0; j < messages.Length(); ++j) {
+      TRACE("ControlMessage::Run");
+      messages[j]->Run();
+    }
+  }
+  mFrontMessageQueue.Clear();
+}
+
+void MediaTrackGraphImpl::UpdateGraph(GraphTime aEndBlockingDecisions) {
+  TRACE("MTG::UpdateGraph");
+  MOZ_ASSERT(OnGraphThread());
+  MOZ_ASSERT(aEndBlockingDecisions >= mProcessedTime);
+  // The next state computed time can be the same as the previous: it
+  // means the driver would have been blocking indefinitly, but the graph has
+  // been woken up right after having been to sleep.
+  MOZ_ASSERT(aEndBlockingDecisions >= mStateComputedTime);
+
+  CheckDriver();
+  UpdateTrackOrder();
+
+  // Always do another iteration if there are tracks waiting to resume.
+  bool ensureNextIteration = !mPendingResumeOperations.IsEmpty();
+
+  for (MediaTrack* track : mTracks) {
+    if (SourceMediaTrack* is = track->AsSourceTrack()) {
+      ensureNextIteration |= is->PullNewData(aEndBlockingDecisions);
+      is->ExtractPendingInput(mStateComputedTime, aEndBlockingDecisions);
+    }
+    if (track->mEnded) {
+      // The track's not suspended, and since it's ended, underruns won't
+      // stop it playing out. So there's no blocking other than what we impose
+      // here.
+      GraphTime endTime = track->GetEnd() + track->mStartTime;
+      if (endTime <= mStateComputedTime) {
+        LOG(LogLevel::Verbose,
+            ("%p: MediaTrack %p is blocked due to being ended", this, track));
+        track->mStartBlocking = mStateComputedTime;
+      } else {
+        LOG(LogLevel::Verbose,
+            ("%p: MediaTrack %p has ended, but is not blocked yet (current "
+             "time %f, end at %f)",
+             this, track, MediaTimeToSeconds(mStateComputedTime),
+             MediaTimeToSeconds(endTime)));
+        // Data can't be added to a ended track, so underruns are irrelevant.
+        MOZ_ASSERT(endTime <= aEndBlockingDecisions);
+        track->mStartBlocking = endTime;
+      }
+    } else {
+      track->mStartBlocking = WillUnderrun(track, aEndBlockingDecisions);
+
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+      if (SourceMediaTrack* s = track->AsSourceTrack()) {
+        if (s->Ended()) {
+          continue;
+        }
+        {
+          MutexAutoLock lock(s->mMutex);
+          if (!s->mUpdateTrack->mPullingEnabled) {
+            // The invariant that data must be provided is only enforced when
+            // pulling.
+            continue;
+          }
+        }
+        if (track->GetEnd() <
+            track->GraphTimeToTrackTime(aEndBlockingDecisions)) {
+          LOG(LogLevel::Error,
+              ("%p: SourceMediaTrack %p (%s) is live and pulled, "
+               "but wasn't fed "
+               "enough data. TrackListeners=%zu. Track-end=%f, "
+               "Iteration-end=%f",
+               this, track,
+               (track->mType == MediaSegment::AUDIO ? "audio" : "video"),
+               track->mTrackListeners.Length(),
+               MediaTimeToSeconds(track->GetEnd()),
+               MediaTimeToSeconds(
+                   track->GraphTimeToTrackTime(aEndBlockingDecisions))));
+          MOZ_DIAGNOSTIC_ASSERT(false,
+                                "A non-ended SourceMediaTrack wasn't fed "
+                                "enough data by NotifyPull");
+        }
+      }
+#endif /* MOZ_DIAGNOSTIC_ASSERT_ENABLED */
+    }
+  }
+
+  for (MediaTrack* track : mSuspendedTracks) {
+    track->mStartBlocking = mStateComputedTime;
+  }
+
+  // If the loop is woken up so soon that IterationEnd() barely advances or
+  // if an offline graph is not currently rendering, we end up having
+  // aEndBlockingDecisions == mStateComputedTime.
+  // Since the process interval [mStateComputedTime, aEndBlockingDecision) is
+  // empty, Process() will not find any unblocked track and so will not
+  // ensure another iteration.  If the graph should be rendering, then ensure
+  // another iteration to render.
+  if (ensureNextIteration || (aEndBlockingDecisions == mStateComputedTime &&
+                              mStateComputedTime < mEndTime)) {
+    EnsureNextIteration();
+  }
+}
+
+void MediaTrackGraphImpl::Process(AudioMixer* aMixer) {
+  TRACE("MTG::Process");
+  MOZ_ASSERT(OnGraphThread());
+  // Play track contents.
+  bool allBlockedForever = true;
+  // True when we've done ProcessInput for all processed tracks.
+  bool doneAllProducing = false;
+  const GraphTime oldProcessedTime = mProcessedTime;
+
+  // Figure out what each track wants to do
+  for (uint32_t i = 0; i < mTracks.Length(); ++i) {
+    MediaTrack* track = mTracks[i];
+    if (!doneAllProducing) {
+      ProcessedMediaTrack* pt = track->AsProcessedTrack();
+      if (pt) {
+        AudioNodeTrack* n = track->AsAudioNodeTrack();
+        if (n) {
+#ifdef DEBUG
+          // Verify that the sampling rate for all of the following tracks is
+          // the same
+          for (uint32_t j = i + 1; j < mTracks.Length(); ++j) {
+            AudioNodeTrack* nextTrack = mTracks[j]->AsAudioNodeTrack();
+            if (nextTrack) {
+              MOZ_ASSERT(n->mSampleRate == nextTrack->mSampleRate,
+                         "All AudioNodeTracks in the graph must have the same "
+                         "sampling rate");
+            }
+          }
+#endif
+          // Since an AudioNodeTrack is present, go ahead and
+          // produce audio block by block for all the rest of the tracks.
+          ProduceDataForTracksBlockByBlock(i, n->mSampleRate);
+          doneAllProducing = true;
+        } else {
+          pt->ProcessInput(mProcessedTime, mStateComputedTime,
+                           ProcessedMediaTrack::ALLOW_END);
+          // Assert that a live track produced enough data
+          MOZ_ASSERT_IF(!track->mEnded,
+                        track->GetEnd() >= GraphTimeToTrackTimeWithBlocking(
+                                               track, mStateComputedTime));
+        }
+      }
+    }
+    if (track->mStartBlocking > oldProcessedTime) {
+      allBlockedForever = false;
+    }
+  }
+  mProcessedTime = mStateComputedTime;
+
+  if (aMixer) {
+    MOZ_ASSERT(mRealtime, "If there's a mixer, this graph must be realtime");
+    aMixer->StartMixing();
+    // This is the number of frames that are written to the output buffer, for
+    // this iteration.
+    TrackTime ticksPlayed = 0;
+    for (auto& t : mAudioOutputs) {
+      TrackTime ticksPlayedForThisTrack =
+          PlayAudio(aMixer, t, oldProcessedTime);
+      if (ticksPlayed == 0) {
+        ticksPlayed = ticksPlayedForThisTrack;
+      } else {
+        MOZ_ASSERT(
+            !ticksPlayedForThisTrack || ticksPlayedForThisTrack == ticksPlayed,
+            "Each track should have the same number of frames.");
+      }
+    }
+
+    if (ticksPlayed == 0) {
+      // Nothing was played, so the mixer doesn't know how many frames were
+      // processed. We still tell it so AudioCallbackDriver knows how much has
+      // been processed. (bug 1406027)
+      aMixer->Mix(
+          nullptr,
+          CurrentDriver()->AsAudioCallbackDriver()->OutputChannelCount(),
+          mStateComputedTime - oldProcessedTime, mSampleRate);
+    }
+    aMixer->FinishMixing();
+  }
+
+  if (!allBlockedForever) {
+    EnsureNextIteration();
+  }
+}
+
+bool MediaTrackGraphImpl::UpdateMainThreadState() {
+  MOZ_ASSERT(OnGraphThread());
+  if (mForceShutDownReceived) {
+    for (MediaTrack* track : AllTracks()) {
+      track->OnGraphThreadDone();
+    }
+  }
+  {
+    MonitorAutoLock lock(mMonitor);
+    bool finalUpdate =
+        mForceShutDownReceived || (IsEmpty() && mBackMessageQueue.IsEmpty());
+    PrepareUpdatesToMainThreadState(finalUpdate);
+    if (!finalUpdate) {
+      SwapMessageQueues();
+      return true;
+    }
+    // The JSContext will not be used again.
+    // Clear main thread access while under monitor.
+    mJSContext = nullptr;
+  }
+  dom::WorkletThread::DeleteCycleCollectedJSContext();
+  // Enter shutdown mode when this iteration is completed.
+  // No need to Destroy tracks here. The main-thread owner of each
+  // track is responsible for calling Destroy on them.
+  return false;
+}
+
+auto MediaTrackGraphImpl::OneIteration(GraphTime aStateTime,
+                                       GraphTime aIterationEnd,
+                                       AudioMixer* aMixer) -> IterationResult {
+  if (mGraphRunner) {
+    return mGraphRunner->OneIteration(aStateTime, aIterationEnd, aMixer);
+  }
+
+  return OneIterationImpl(aStateTime, aIterationEnd, aMixer);
+}
+
+auto MediaTrackGraphImpl::OneIterationImpl(GraphTime aStateTime,
+                                           GraphTime aIterationEnd,
+                                           AudioMixer* aMixer)
+    -> IterationResult {
+  TRACE("MTG::OneIterationImpl");
+
+  mIterationEndTime = aIterationEnd;
+
+  if (SoftRealTimeLimitReached()) {
+    TRACE("MTG::Demoting real-time thread!");
+    DemoteThreadFromRealTime();
+  }
+
+  // Changes to LIFECYCLE_RUNNING occur before starting or reviving the graph
+  // thread, and so the monitor need not be held to check mLifecycleState.
+  // LIFECYCLE_THREAD_NOT_STARTED is possible when shutting down offline
+  // graphs that have not started.
+
+  // While changes occur on mainthread, this assert confirms that
+  // this code shouldn't run if mainthread might be changing the state (to
+  // > LIFECYCLE_RUNNING)
+
+  // Ignore mutex warning: static during execution of the graph
+  MOZ_PUSH_IGNORE_THREAD_SAFETY
+  MOZ_DIAGNOSTIC_ASSERT(mLifecycleState <= LIFECYCLE_RUNNING);
+  MOZ_POP_THREAD_SAFETY
+
+  MOZ_ASSERT(OnGraphThread());
+
+  WebCore::DenormalDisabler disabler;
+
+  // Process graph message from the main thread for this iteration.
+  RunMessagesInQueue();
+
+  // Process MessagePort events.
+  // These require a single thread, which has an nsThread with an event queue.
+  if (mGraphRunner || !mRealtime) {
+    TRACE("MTG::MessagePort events");
+    NS_ProcessPendingEvents(nullptr);
+  }
+
+  GraphTime stateTime = std::min(aStateTime, GraphTime(mEndTime));
+  UpdateGraph(stateTime);
+
+  mStateComputedTime = stateTime;
+
+  GraphTime oldProcessedTime = mProcessedTime;
+  Process(aMixer);
+  MOZ_ASSERT(mProcessedTime == stateTime);
+
+  UpdateCurrentTimeForTracks(oldProcessedTime);
+
+  ProcessChunkMetadata(oldProcessedTime);
+
+  // Process graph messages queued from RunMessageAfterProcessing() on this
+  // thread during the iteration.
+  RunMessagesInQueue();
+
+  if (!UpdateMainThreadState()) {
+    if (Switching()) {
+      // We'll never get to do this switch. Clear mNextDriver to break the
+      // ref-cycle graph->nextDriver->currentDriver->graph.
+      SwitchAtNextIteration(nullptr);
+    }
+    return IterationResult::CreateStop(
+        NewRunnableMethod("MediaTrackGraphImpl::SignalMainThreadCleanup", this,
+                          &MediaTrackGraphImpl::SignalMainThreadCleanup));
+  }
+
+  if (Switching()) {
+    RefPtr<GraphDriver> nextDriver = std::move(mNextDriver);
+    return IterationResult::CreateSwitchDriver(
+        nextDriver, NewRunnableMethod<StoreRefPtrPassByPtr<GraphDriver>>(
+                        "MediaTrackGraphImpl::SetCurrentDriver", this,
+                        &MediaTrackGraphImpl::SetCurrentDriver, nextDriver));
+  }
+
+  return IterationResult::CreateStillProcessing();
+}
+
+void MediaTrackGraphImpl::ApplyTrackUpdate(TrackUpdate* aUpdate) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mMonitor.AssertCurrentThreadOwns();
+
+  MediaTrack* track = aUpdate->mTrack;
+  if (!track) return;
+  track->mMainThreadCurrentTime = aUpdate->mNextMainThreadCurrentTime;
+  track->mMainThreadEnded = aUpdate->mNextMainThreadEnded;
+
+  if (track->ShouldNotifyTrackEnded()) {
+    track->NotifyMainThreadListeners();
+  }
+}
+
+void MediaTrackGraphImpl::ForceShutDown() {
+  MOZ_ASSERT(NS_IsMainThread(), "Must be called on main thread");
+  LOG(LogLevel::Debug, ("%p: MediaTrackGraph::ForceShutdown", this));
+
+  if (mShutdownBlocker) {
+    // Avoid waiting forever for a graph to shut down
+    // synchronously.  Reports are that some 3rd-party audio drivers
+    // occasionally hang in shutdown (both for us and Chrome).
+    NS_NewTimerWithCallback(
+        getter_AddRefs(mShutdownTimer), this,
+        MediaTrackGraph::AUDIO_CALLBACK_DRIVER_SHUTDOWN_TIMEOUT,
+        nsITimer::TYPE_ONE_SHOT);
+  }
+
+  class Message final : public ControlMessage {
+   public:
+    explicit Message(MediaTrackGraphImpl* aGraph)
+        : ControlMessage(nullptr), mGraph(aGraph) {}
+    void Run() override {
+      TRACE("MTG::ForceShutdown ControlMessage");
+      mGraph->mForceShutDownReceived = true;
+    }
+    // The graph owns this message.
+    MediaTrackGraphImpl* MOZ_NON_OWNING_REF mGraph;
+  };
+
+  if (mMainThreadTrackCount > 0 || mMainThreadPortCount > 0) {
+    // If both the track and port counts are zero, the regular shutdown
+    // sequence will progress shortly to shutdown threads and destroy the graph.
+    AppendMessage(MakeUnique<Message>(this));
+    InterruptJS();
+  }
+}
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::Notify(nsITimer* aTimer) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_ASSERTION(!mShutdownBlocker,
+               "MediaTrackGraph took too long to shut down!");
+  // Sigh, graph took too long to shut down.  Stop blocking system
+  // shutdown and hope all is well.
+  RemoveShutdownBlocker();
+  return NS_OK;
+}
+
+bool MediaTrackGraphImpl::AddShutdownBlocker() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mShutdownBlocker);
+
+  class Blocker : public media::ShutdownBlocker {
+    const RefPtr<MediaTrackGraphImpl> mGraph;
+
+   public:
+    Blocker(MediaTrackGraphImpl* aGraph, const nsString& aName)
+        : media::ShutdownBlocker(aName), mGraph(aGraph) {}
+
+    NS_IMETHOD
+    BlockShutdown(nsIAsyncShutdownClient* aProfileBeforeChange) override {
+      mGraph->ForceShutDown();
+      return NS_OK;
+    }
+  };
+
+  nsCOMPtr<nsIAsyncShutdownClient> barrier = media::GetShutdownBarrier();
+  if (!barrier) {
+    // We're already shutting down, we won't be able to add a blocker, bail.
+    LOG(LogLevel::Error,
+        ("%p: Couldn't get shutdown barrier, won't add shutdown blocker",
+         this));
+    return false;
+  }
+
+  // Blocker names must be distinct.
+  nsString blockerName;
+  blockerName.AppendPrintf("MediaTrackGraph %p shutdown", this);
+  mShutdownBlocker = MakeAndAddRef<Blocker>(this, blockerName);
+  nsresult rv = barrier->AddBlocker(mShutdownBlocker,
+                                    NS_LITERAL_STRING_FROM_CSTRING(__FILE__),
+                                    __LINE__, u"MediaTrackGraph shutdown"_ns);
+  MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv));
+  return true;
+}
+
+void MediaTrackGraphImpl::RemoveShutdownBlocker() {
+  if (!mShutdownBlocker) {
+    return;
+  }
+  media::MustGetShutdownBarrier()->RemoveBlocker(mShutdownBlocker);
+  mShutdownBlocker = nullptr;
+}
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::GetName(nsACString& aName) {
+  aName.AssignLiteral("MediaTrackGraphImpl");
+  return NS_OK;
+}
+
+namespace {
+
+class MediaTrackGraphShutDownRunnable : public Runnable {
+ public:
+  explicit MediaTrackGraphShutDownRunnable(MediaTrackGraphImpl* aGraph)
+      : Runnable("MediaTrackGraphShutDownRunnable"), mGraph(aGraph) {}
+  // MOZ_CAN_RUN_SCRIPT_BOUNDARY until Runnable::Run is MOZ_CAN_RUN_SCRIPT.
+  // See bug 1535398.
+  MOZ_CAN_RUN_SCRIPT_BOUNDARY NS_IMETHOD Run() override {
+    TRACE("MTG::MediaTrackGraphShutDownRunnable runnable");
+    MOZ_ASSERT(NS_IsMainThread());
+    MOZ_ASSERT(!mGraph->mGraphDriverRunning && mGraph->mDriver,
+               "We should know the graph thread control loop isn't running!");
+
+    LOG(LogLevel::Debug, ("%p: Shutting down graph", mGraph.get()));
+
+    // We've asserted the graph isn't running.  Use mDriver instead of
+    // CurrentDriver to avoid thread-safety checks
+#if 0  // AudioCallbackDrivers are released asynchronously anyways
+    // XXX a better test would be have setting mGraphDriverRunning make sure
+    // any current callback has finished and block future ones -- or just
+    // handle it all in Shutdown()!
+    if (mGraph->mDriver->AsAudioCallbackDriver()) {
+      MOZ_ASSERT(!mGraph->mDriver->AsAudioCallbackDriver()->InCallback());
+    }
+#endif
+
+    for (MediaTrackGraphImpl::PendingResumeOperation& op :
+         mGraph->mPendingResumeOperations) {
+      op.Abort();
+    }
+
+    if (mGraph->mGraphRunner) {
+      RefPtr<GraphRunner>(mGraph->mGraphRunner)->Shutdown();
+    }
+
+    RefPtr<GraphDriver>(mGraph->mDriver)->Shutdown();
+
+    // Release the driver now so that an AudioCallbackDriver will release its
+    // SharedThreadPool reference.  Each SharedThreadPool reference must be
+    // released before SharedThreadPool::SpinUntilEmpty() runs on
+    // xpcom-shutdown-threads.  Don't wait for GC/CC to release references to
+    // objects owning tracks, or for expiration of mGraph->mShutdownTimer,
+    // which won't otherwise release its reference on the graph until
+    // nsTimerImpl::Shutdown(), which runs after xpcom-shutdown-threads.
+    mGraph->SetCurrentDriver(nullptr);
+
+    // Safe to access these without the monitor since the graph isn't running.
+    // We may be one of several graphs. Drop ticket to eventually unblock
+    // shutdown.
+    if (mGraph->mShutdownTimer && !mGraph->mShutdownBlocker) {
+      MOZ_ASSERT(
+          false,
+          "AudioCallbackDriver took too long to shut down and we let shutdown"
+          " continue - freezing and leaking");
+
+      // The timer fired, so we may be deeper in shutdown now.  Block any
+      // further teardown and just leak, for safety.
+      return NS_OK;
+    }
+
+    // mGraph's thread is not running so it's OK to do whatever here
+    for (MediaTrack* track : mGraph->AllTracks()) {
+      // Clean up all MediaSegments since we cannot release Images too
+      // late during shutdown. Also notify listeners that they were removed
+      // so they can clean up any gfx resources.
+      track->RemoveAllResourcesAndListenersImpl();
+    }
+
+#ifdef DEBUG
+    {
+      MonitorAutoLock lock(mGraph->mMonitor);
+      MOZ_ASSERT(mGraph->mUpdateRunnables.IsEmpty());
+    }
+#endif
+    mGraph->mPendingUpdateRunnables.Clear();
+
+    mGraph->RemoveShutdownBlocker();
+
+    // We can't block past the final LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION
+    // stage, since completion of that stage requires all tracks to be freed,
+    // which requires shutdown to proceed.
+
+    if (mGraph->IsEmpty()) {
+      // mGraph is no longer needed, so delete it.
+      mGraph->Destroy();
+    } else {
+      // The graph is not empty.  We must be in a forced shutdown.
+      // Some later AppendMessage will detect that the graph has
+      // been emptied, and delete it.
+      NS_ASSERTION(mGraph->mForceShutDownReceived, "Not in forced shutdown?");
+      mGraph->LifecycleStateRef() =
+          MediaTrackGraphImpl::LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION;
+    }
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<MediaTrackGraphImpl> mGraph;
+};
+
+class MediaTrackGraphStableStateRunnable : public Runnable {
+ public:
+  explicit MediaTrackGraphStableStateRunnable(MediaTrackGraphImpl* aGraph,
+                                              bool aSourceIsMTG)
+      : Runnable("MediaTrackGraphStableStateRunnable"),
+        mGraph(aGraph),
+        mSourceIsMTG(aSourceIsMTG) {}
+  NS_IMETHOD Run() override {
+    TRACE("MTG::MediaTrackGraphStableStateRunnable ControlMessage");
+    if (mGraph) {
+      mGraph->RunInStableState(mSourceIsMTG);
+    }
+    return NS_OK;
+  }
+
+ private:
+  RefPtr<MediaTrackGraphImpl> mGraph;
+  bool mSourceIsMTG;
+};
+
+/*
+ * Control messages forwarded from main thread to graph manager thread
+ */
+class CreateMessage : public ControlMessage {
+ public:
+  explicit CreateMessage(MediaTrack* aTrack) : ControlMessage(aTrack) {}
+  void Run() override {
+    TRACE("MTG::AddTrackGraphThread ControlMessage");
+    mTrack->GraphImpl()->AddTrackGraphThread(mTrack);
+  }
+  void RunDuringShutdown() override {
+    // Make sure to run this message during shutdown too, to make sure
+    // that we balance the number of tracks registered with the graph
+    // as they're destroyed during shutdown.
+    Run();
+  }
+};
+
+}  // namespace
+
+void MediaTrackGraphImpl::RunInStableState(bool aSourceIsMTG) {
+  MOZ_ASSERT(NS_IsMainThread(), "Must be called on main thread");
+
+  nsTArray<nsCOMPtr<nsIRunnable>> runnables;
+  // When we're doing a forced shutdown, pending control messages may be
+  // run on the main thread via RunDuringShutdown. Those messages must
+  // run without the graph monitor being held. So, we collect them here.
+  nsTArray<UniquePtr<ControlMessage>> controlMessagesToRunDuringShutdown;
+
+  {
+    MonitorAutoLock lock(mMonitor);
+    if (aSourceIsMTG) {
+      MOZ_ASSERT(mPostedRunInStableStateEvent);
+      mPostedRunInStableStateEvent = false;
+    }
+
+    // This should be kept in sync with the LifecycleState enum in
+    // MediaTrackGraphImpl.h
+    const char* LifecycleState_str[] = {
+        "LIFECYCLE_THREAD_NOT_STARTED", "LIFECYCLE_RUNNING",
+        "LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP",
+        "LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN",
+        "LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION"};
+
+    if (LifecycleStateRef() != LIFECYCLE_RUNNING) {
+      LOG(LogLevel::Debug,
+          ("%p: Running stable state callback. Current state: %s", this,
+           LifecycleState_str[LifecycleStateRef()]));
+    }
+
+    runnables = std::move(mUpdateRunnables);
+    for (uint32_t i = 0; i < mTrackUpdates.Length(); ++i) {
+      TrackUpdate* update = &mTrackUpdates[i];
+      if (update->mTrack) {
+        ApplyTrackUpdate(update);
+      }
+    }
+    mTrackUpdates.Clear();
+
+    mMainThreadGraphTime = mNextMainThreadGraphTime;
+
+    if (mCurrentTaskMessageQueue.IsEmpty()) {
+      if (LifecycleStateRef() == LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP &&
+          IsEmpty()) {
+        // Complete shutdown. First, ensure that this graph is no longer used.
+        // A new graph graph will be created if one is needed.
+        // Asynchronously clean up old graph. We don't want to do this
+        // synchronously because it spins the event loop waiting for threads
+        // to shut down, and we don't want to do that in a stable state handler.
+        LifecycleStateRef() = LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN;
+        LOG(LogLevel::Debug,
+            ("%p: Sending MediaTrackGraphShutDownRunnable", this));
+        nsCOMPtr<nsIRunnable> event = new MediaTrackGraphShutDownRunnable(this);
+        mMainThread->Dispatch(event.forget());
+      }
+    } else {
+      if (LifecycleStateRef() <= LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP) {
+        MessageBlock* block = mBackMessageQueue.AppendElement();
+        block->mMessages = std::move(mCurrentTaskMessageQueue);
+        EnsureNextIteration();
+      }
+
+      // If this MediaTrackGraph has entered regular (non-forced) shutdown it
+      // is not able to process any more messages. Those messages being added to
+      // the graph in the first place is an error.
+      MOZ_DIAGNOSTIC_ASSERT(LifecycleStateRef() <
+                                LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP ||
+                            mForceShutDownReceived);
+    }
+
+    if (LifecycleStateRef() == LIFECYCLE_THREAD_NOT_STARTED) {
+      // Start the driver now. We couldn't start it earlier because the graph
+      // might exit immediately on finding it has no tracks. The first message
+      // for a new graph must create a track. Ensure that his message runs on
+      // the first iteration.
+      MOZ_ASSERT(MessagesQueued());
+      SwapMessageQueues();
+
+      LOG(LogLevel::Debug,
+          ("%p: Starting a graph with a %s", this,
+           CurrentDriver()->AsAudioCallbackDriver() ? "AudioCallbackDriver"
+                                                    : "SystemClockDriver"));
+      LifecycleStateRef() = LIFECYCLE_RUNNING;
+      mGraphDriverRunning = true;
+      RefPtr<GraphDriver> driver = CurrentDriver();
+      driver->Start();
+      // It's not safe to Shutdown() a thread from StableState, and
+      // releasing this may shutdown a SystemClockDriver thread.
+      // Proxy the release to outside of StableState.
+      NS_ReleaseOnMainThread("MediaTrackGraphImpl::CurrentDriver",
+                             driver.forget(),
+                             true);  // always proxy
+    }
+
+    if (LifecycleStateRef() == LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP &&
+        mForceShutDownReceived) {
+      // Defer calls to RunDuringShutdown() to happen while mMonitor is not
+      // held.
+      for (uint32_t i = 0; i < mBackMessageQueue.Length(); ++i) {
+        MessageBlock& mb = mBackMessageQueue[i];
+        controlMessagesToRunDuringShutdown.AppendElements(
+            std::move(mb.mMessages));
+      }
+      mBackMessageQueue.Clear();
+      MOZ_ASSERT(mCurrentTaskMessageQueue.IsEmpty());
+      // Stop MediaTrackGraph threads.
+      LifecycleStateRef() = LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN;
+      nsCOMPtr<nsIRunnable> event = new MediaTrackGraphShutDownRunnable(this);
+      mMainThread->Dispatch(event.forget());
+    }
+
+    mGraphDriverRunning = LifecycleStateRef() == LIFECYCLE_RUNNING;
+  }
+
+  // Make sure we get a new current time in the next event loop task
+  if (!aSourceIsMTG) {
+    MOZ_ASSERT(mPostedRunInStableState);
+    mPostedRunInStableState = false;
+  }
+
+  for (uint32_t i = 0; i < controlMessagesToRunDuringShutdown.Length(); ++i) {
+    controlMessagesToRunDuringShutdown[i]->RunDuringShutdown();
+  }
+
+#ifdef DEBUG
+  mCanRunMessagesSynchronously =
+      !mGraphDriverRunning &&
+      LifecycleStateRef() >= LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN;
+#endif
+
+  for (uint32_t i = 0; i < runnables.Length(); ++i) {
+    runnables[i]->Run();
+  }
+}
+
+void MediaTrackGraphImpl::EnsureRunInStableState() {
+  MOZ_ASSERT(NS_IsMainThread(), "main thread only");
+
+  if (mPostedRunInStableState) return;
+  mPostedRunInStableState = true;
+  nsCOMPtr<nsIRunnable> event =
+      new MediaTrackGraphStableStateRunnable(this, false);
+  nsContentUtils::RunInStableState(event.forget());
+}
+
+void MediaTrackGraphImpl::EnsureStableStateEventPosted() {
+  MOZ_ASSERT(OnGraphThread());
+  mMonitor.AssertCurrentThreadOwns();
+
+  if (mPostedRunInStableStateEvent) return;
+  mPostedRunInStableStateEvent = true;
+  nsCOMPtr<nsIRunnable> event =
+      new MediaTrackGraphStableStateRunnable(this, true);
+  mMainThread->Dispatch(event.forget());
+}
+
+void MediaTrackGraphImpl::SignalMainThreadCleanup() {
+  MOZ_ASSERT(mDriver->OnThread());
+
+  MonitorAutoLock lock(mMonitor);
+  // LIFECYCLE_THREAD_NOT_STARTED is possible when shutting down offline
+  // graphs that have not started.
+  MOZ_DIAGNOSTIC_ASSERT(mLifecycleState <= LIFECYCLE_RUNNING);
+  LOG(LogLevel::Debug,
+      ("%p: MediaTrackGraph waiting for main thread cleanup", this));
+  LifecycleStateRef() =
+      MediaTrackGraphImpl::LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP;
+  EnsureStableStateEventPosted();
+}
+
+void MediaTrackGraphImpl::AppendMessage(UniquePtr<ControlMessage> aMessage) {
+  MOZ_ASSERT(NS_IsMainThread(), "main thread only");
+  MOZ_RELEASE_ASSERT(!aMessage->GetTrack() ||
+                     !aMessage->GetTrack()->IsDestroyed());
+  MOZ_DIAGNOSTIC_ASSERT(mMainThreadTrackCount > 0 || mMainThreadPortCount > 0);
+
+  if (!mGraphDriverRunning &&
+      LifecycleStateRef() > LIFECYCLE_WAITING_FOR_MAIN_THREAD_CLEANUP) {
+    // The graph control loop is not running and main thread cleanup has
+    // happened. From now on we can't append messages to
+    // mCurrentTaskMessageQueue, because that will never be processed again, so
+    // just RunDuringShutdown this message. This should only happen during
+    // forced shutdown, or after a non-realtime graph has finished processing.
+#ifdef DEBUG
+    MOZ_ASSERT(mCanRunMessagesSynchronously);
+    mCanRunMessagesSynchronously = false;
+#endif
+    aMessage->RunDuringShutdown();
+#ifdef DEBUG
+    mCanRunMessagesSynchronously = true;
+#endif
+    if (IsEmpty() &&
+        LifecycleStateRef() >= LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION) {
+      Destroy();
+    }
+    return;
+  }
+
+  mCurrentTaskMessageQueue.AppendElement(std::move(aMessage));
+  EnsureRunInStableState();
+}
+
+void MediaTrackGraphImpl::Dispatch(already_AddRefed<nsIRunnable>&& aRunnable) {
+  mMainThread->Dispatch(std::move(aRunnable));
+}
+
+MediaTrack::MediaTrack(TrackRate aSampleRate, MediaSegment::Type aType,
+                       MediaSegment* aSegment)
+    : mSampleRate(aSampleRate),
+      mType(aType),
+      mSegment(aSegment),
+      mStartTime(0),
+      mForgottenTime(0),
+      mEnded(false),
+      mNotifiedEnded(false),
+      mDisabledMode(DisabledTrackMode::ENABLED),
+      mStartBlocking(GRAPH_TIME_MAX),
+      mSuspendedCount(0),
+      mMainThreadCurrentTime(0),
+      mMainThreadEnded(false),
+      mEndedNotificationSent(false),
+      mMainThreadDestroyed(false),
+      mGraph(nullptr) {
+  MOZ_COUNT_CTOR(MediaTrack);
+  MOZ_ASSERT_IF(mSegment, mSegment->GetType() == aType);
+}
+
+MediaTrack::~MediaTrack() {
+  MOZ_COUNT_DTOR(MediaTrack);
+  NS_ASSERTION(mMainThreadDestroyed, "Should have been destroyed already");
+  NS_ASSERTION(mMainThreadListeners.IsEmpty(),
+               "All main thread listeners should have been removed");
+}
+
+size_t MediaTrack::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
+  size_t amount = 0;
+
+  // Not owned:
+  // - mGraph - Not reported here
+  // - mConsumers - elements
+  // Future:
+  // - mLastPlayedVideoFrame
+  // - mTrackListeners - elements
+
+  amount += mTrackListeners.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  amount += mMainThreadListeners.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  amount += mConsumers.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
+  return amount;
+}
+
+size_t MediaTrack::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+  return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+
+void MediaTrack::IncrementSuspendCount() {
+  ++mSuspendedCount;
+  if (mSuspendedCount != 1 || !mGraph) {
+    MOZ_ASSERT(mGraph || mConsumers.IsEmpty());
+    return;
+  }
+  MOZ_ASSERT(mGraph->OnGraphThreadOrNotRunning());
+  for (uint32_t i = 0; i < mConsumers.Length(); ++i) {
+    mConsumers[i]->Suspended();
+  }
+  MOZ_ASSERT(mGraph->mTracks.Contains(this));
+  mGraph->mTracks.RemoveElement(this);
+  mGraph->mSuspendedTracks.AppendElement(this);
+  mGraph->SetTrackOrderDirty();
+}
+
+void MediaTrack::DecrementSuspendCount() {
+  MOZ_ASSERT(mSuspendedCount > 0, "Suspend count underrun");
+  --mSuspendedCount;
+  if (mSuspendedCount != 0 || !mGraph) {
+    MOZ_ASSERT(mGraph || mConsumers.IsEmpty());
+    return;
+  }
+  MOZ_ASSERT(mGraph->OnGraphThreadOrNotRunning());
+  for (uint32_t i = 0; i < mConsumers.Length(); ++i) {
+    mConsumers[i]->Resumed();
+  }
+  MOZ_ASSERT(mGraph->mSuspendedTracks.Contains(this));
+  mGraph->mSuspendedTracks.RemoveElement(this);
+  mGraph->mTracks.AppendElement(this);
+  mGraph->SetTrackOrderDirty();
+}
+
+void ProcessedMediaTrack::DecrementSuspendCount() {
+  mCycleMarker = NOT_VISITED;
+  MediaTrack::DecrementSuspendCount();
+}
+
+MediaTrackGraphImpl* MediaTrack::GraphImpl() { return mGraph; }
+
+const MediaTrackGraphImpl* MediaTrack::GraphImpl() const { return mGraph; }
+
+MediaTrackGraph* MediaTrack::Graph() { return mGraph; }
+
+const MediaTrackGraph* MediaTrack::Graph() const { return mGraph; }
+
+void MediaTrack::SetGraphImpl(MediaTrackGraphImpl* aGraph) {
+  MOZ_ASSERT(!mGraph, "Should only be called once");
+  MOZ_ASSERT(mSampleRate == aGraph->GraphRate());
+  mGraph = aGraph;
+}
+
+void MediaTrack::SetGraphImpl(MediaTrackGraph* aGraph) {
+  MediaTrackGraphImpl* graph = static_cast<MediaTrackGraphImpl*>(aGraph);
+  SetGraphImpl(graph);
+}
+
+TrackTime MediaTrack::GraphTimeToTrackTime(GraphTime aTime) const {
+  NS_ASSERTION(mStartBlocking == GraphImpl()->mStateComputedTime ||
+                   aTime <= mStartBlocking,
+               "Incorrectly ignoring blocking!");
+  return aTime - mStartTime;
+}
+
+GraphTime MediaTrack::TrackTimeToGraphTime(TrackTime aTime) const {
+  NS_ASSERTION(mStartBlocking == GraphImpl()->mStateComputedTime ||
+                   aTime + mStartTime <= mStartBlocking,
+               "Incorrectly ignoring blocking!");
+  return aTime + mStartTime;
+}
+
+TrackTime MediaTrack::GraphTimeToTrackTimeWithBlocking(GraphTime aTime) const {
+  return GraphImpl()->GraphTimeToTrackTimeWithBlocking(this, aTime);
+}
+
+void MediaTrack::RemoveAllResourcesAndListenersImpl() {
+  GraphImpl()->AssertOnGraphThreadOrNotRunning();
+
+  for (auto& l : mTrackListeners.Clone()) {
+    l->NotifyRemoved(Graph());
+  }
+  mTrackListeners.Clear();
+
+  RemoveAllDirectListenersImpl();
+
+  if (mSegment) {
+    mSegment->Clear();
+  }
+}
+
+void MediaTrack::DestroyImpl() {
+  for (int32_t i = mConsumers.Length() - 1; i >= 0; --i) {
+    mConsumers[i]->Disconnect();
+  }
+  if (mSegment) {
+    mSegment->Clear();
+  }
+  mGraph = nullptr;
+}
+
+void MediaTrack::Destroy() {
+  // Keep this track alive until we leave this method
+  RefPtr<MediaTrack> kungFuDeathGrip = this;
+
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrack* aTrack) : ControlMessage(aTrack) {}
+    void RunDuringShutdown() override {
+      TRACE("MediaTrack::Destroy ControlMessage");
+      mTrack->RemoveAllResourcesAndListenersImpl();
+      auto graph = mTrack->GraphImpl();
+      mTrack->DestroyImpl();
+      graph->RemoveTrackGraphThread(mTrack);
+    }
+    void Run() override {
+      mTrack->OnGraphThreadDone();
+      RunDuringShutdown();
+    }
+  };
+  // Keep a reference to the graph, since Message might RunDuringShutdown()
+  // synchronously and make GraphImpl() invalid.
+  RefPtr<MediaTrackGraphImpl> graph = GraphImpl();
+  graph->AppendMessage(MakeUnique<Message>(this));
+  graph->RemoveTrack(this);
+  // Message::RunDuringShutdown may have removed this track from the graph,
+  // but our kungFuDeathGrip above will have kept this track alive if
+  // necessary.
+  mMainThreadDestroyed = true;
+}
+
+TrackTime MediaTrack::GetEnd() const {
+  return mSegment ? mSegment->GetDuration() : 0;
+}
+
+void MediaTrack::AddAudioOutput(void* aKey) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, void* aKey)
+        : ControlMessage(aTrack), mKey(aKey) {}
+    void Run() override {
+      TRACE("MediaTrack::AddAudioOutputImpl ControlMessage");
+      mTrack->AddAudioOutputImpl(mKey);
+    }
+    void* mKey;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aKey));
+}
+
+void MediaTrackGraphImpl::SetAudioOutputVolume(MediaTrack* aTrack, void* aKey,
+                                               float aVolume) {
+  for (auto& tkv : mAudioOutputs) {
+    if (tkv.mKey == aKey && aTrack == tkv.mTrack) {
+      tkv.mVolume = aVolume;
+      return;
+    }
+  }
+  MOZ_CRASH("Audio stream key not found when setting the volume.");
+}
+
+void MediaTrack::SetAudioOutputVolumeImpl(void* aKey, float aVolume) {
+  MOZ_ASSERT(GraphImpl()->OnGraphThread());
+  GraphImpl()->SetAudioOutputVolume(this, aKey, aVolume);
+}
+
+void MediaTrack::SetAudioOutputVolume(void* aKey, float aVolume) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, void* aKey, float aVolume)
+        : ControlMessage(aTrack), mKey(aKey), mVolume(aVolume) {}
+    void Run() override {
+      TRACE("MediaTrack::SetAudioOutputVolumeImpl ControlMessage");
+      mTrack->SetAudioOutputVolumeImpl(mKey, mVolume);
+    }
+    void* mKey;
+    float mVolume;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aKey, aVolume));
+}
+
+void MediaTrack::AddAudioOutputImpl(void* aKey) {
+  LOG(LogLevel::Info, ("MediaTrack %p adding AudioOutput", this));
+  GraphImpl()->RegisterAudioOutput(this, aKey);
+}
+
+void MediaTrack::RemoveAudioOutputImpl(void* aKey) {
+  LOG(LogLevel::Info, ("MediaTrack %p removing AudioOutput", this));
+  GraphImpl()->UnregisterAudioOutput(this, aKey);
+}
+
+void MediaTrack::RemoveAudioOutput(void* aKey) {
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrack* aTrack, void* aKey)
+        : ControlMessage(aTrack), mKey(aKey) {}
+    void Run() override {
+      TRACE("MediaTrack::RemoveAudioOutputImpl ControlMessage");
+      mTrack->RemoveAudioOutputImpl(mKey);
+    }
+    void* mKey;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aKey));
+}
+
+void MediaTrack::Suspend() {
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrack* aTrack) : ControlMessage(aTrack) {}
+    void Run() override {
+      TRACE("MediaTrack::IncrementSuspendCount ControlMessage");
+      mTrack->IncrementSuspendCount();
+    }
+  };
+
+  // This can happen if this method has been called asynchronously, and the
+  // track has been destroyed since then.
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this));
+}
+
+void MediaTrack::Resume() {
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrack* aTrack) : ControlMessage(aTrack) {}
+    void Run() override {
+      TRACE("MediaTrack::DecrementSuspendCount ControlMessage");
+      mTrack->DecrementSuspendCount();
+    }
+  };
+
+  // This can happen if this method has been called asynchronously, and the
+  // track has been destroyed since then.
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this));
+}
+
+void MediaTrack::AddListenerImpl(
+    already_AddRefed<MediaTrackListener> aListener) {
+  RefPtr<MediaTrackListener> l(aListener);
+  mTrackListeners.AppendElement(std::move(l));
+
+  PrincipalHandle lastPrincipalHandle = mSegment->GetLastPrincipalHandle();
+  mTrackListeners.LastElement()->NotifyPrincipalHandleChanged(
+      Graph(), lastPrincipalHandle);
+  if (mNotifiedEnded) {
+    mTrackListeners.LastElement()->NotifyEnded(Graph());
+  }
+  if (CombinedDisabledMode() == DisabledTrackMode::SILENCE_BLACK) {
+    mTrackListeners.LastElement()->NotifyEnabledStateChanged(Graph(), false);
+  }
+}
+
+void MediaTrack::AddListener(MediaTrackListener* aListener) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, MediaTrackListener* aListener)
+        : ControlMessage(aTrack), mListener(aListener) {}
+    void Run() override {
+      TRACE("MediaTrack::AddListenerImpl ControlMessage");
+      mTrack->AddListenerImpl(mListener.forget());
+    }
+    RefPtr<MediaTrackListener> mListener;
+  };
+  MOZ_ASSERT(mSegment, "Segment-less tracks do not support listeners");
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aListener));
+}
+
+void MediaTrack::RemoveListenerImpl(MediaTrackListener* aListener) {
+  for (size_t i = 0; i < mTrackListeners.Length(); ++i) {
+    if (mTrackListeners[i] == aListener) {
+      mTrackListeners[i]->NotifyRemoved(Graph());
+      mTrackListeners.RemoveElementAt(i);
+      return;
+    }
+  }
+}
+
+RefPtr<GenericPromise> MediaTrack::RemoveListener(
+    MediaTrackListener* aListener) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, MediaTrackListener* aListener)
+        : ControlMessage(aTrack), mListener(aListener) {}
+    void Run() override {
+      TRACE("MediaTrack::RemoveListenerImpl ControlMessage");
+      mTrack->RemoveListenerImpl(mListener);
+      mRemovedPromise.Resolve(true, __func__);
+    }
+    void RunDuringShutdown() override {
+      // During shutdown we still want the listener's NotifyRemoved to be
+      // called, since not doing that might block shutdown of other modules.
+      Run();
+    }
+    RefPtr<MediaTrackListener> mListener;
+    MozPromiseHolder<GenericPromise> mRemovedPromise;
+  };
+
+  UniquePtr<Message> message = MakeUnique<Message>(this, aListener);
+  RefPtr<GenericPromise> p = message->mRemovedPromise.Ensure(__func__);
+  if (mMainThreadDestroyed) {
+    message->mRemovedPromise.Reject(NS_ERROR_FAILURE, __func__);
+    return p;
+  }
+  GraphImpl()->AppendMessage(std::move(message));
+  return p;
+}
+
+void MediaTrack::AddDirectListenerImpl(
+    already_AddRefed<DirectMediaTrackListener> aListener) {
+  // Base implementation, for tracks that don't support direct track listeners.
+  RefPtr<DirectMediaTrackListener> listener = aListener;
+  listener->NotifyDirectListenerInstalled(
+      DirectMediaTrackListener::InstallationResult::TRACK_NOT_SUPPORTED);
+}
+
+void MediaTrack::AddDirectListener(DirectMediaTrackListener* aListener) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, DirectMediaTrackListener* aListener)
+        : ControlMessage(aTrack), mListener(aListener) {}
+    void Run() override {
+      TRACE("MediaTrack::AddDirectListenerImpl ControlMessage");
+      mTrack->AddDirectListenerImpl(mListener.forget());
+    }
+    RefPtr<DirectMediaTrackListener> mListener;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aListener));
+}
+
+void MediaTrack::RemoveDirectListenerImpl(DirectMediaTrackListener* aListener) {
+  // Base implementation, the listener was never added so nothing to do.
+}
+
+void MediaTrack::RemoveDirectListener(DirectMediaTrackListener* aListener) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, DirectMediaTrackListener* aListener)
+        : ControlMessage(aTrack), mListener(aListener) {}
+    void Run() override {
+      TRACE("MediaTrack::RemoveDirectListenerImpl ControlMessage");
+      mTrack->RemoveDirectListenerImpl(mListener);
+    }
+    void RunDuringShutdown() override {
+      // During shutdown we still want the listener's
+      // NotifyDirectListenerUninstalled to be called, since not doing that
+      // might block shutdown of other modules.
+      Run();
+    }
+    RefPtr<DirectMediaTrackListener> mListener;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aListener));
+}
+
+void MediaTrack::RunAfterPendingUpdates(
+    already_AddRefed<nsIRunnable> aRunnable) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MediaTrackGraphImpl* graph = GraphImpl();
+  nsCOMPtr<nsIRunnable> runnable(aRunnable);
+
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, already_AddRefed<nsIRunnable> aRunnable)
+        : ControlMessage(aTrack), mRunnable(aRunnable) {}
+    void Run() override {
+      TRACE("MediaTrack::DispatchToMainThreadStableState ControlMessage");
+      mTrack->Graph()->DispatchToMainThreadStableState(mRunnable.forget());
+    }
+    void RunDuringShutdown() override {
+      // Don't run mRunnable now as it may call AppendMessage() which would
+      // assume that there are no remaining controlMessagesToRunDuringShutdown.
+      MOZ_ASSERT(NS_IsMainThread());
+      mTrack->GraphImpl()->Dispatch(mRunnable.forget());
+    }
+
+   private:
+    nsCOMPtr<nsIRunnable> mRunnable;
+  };
+
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  graph->AppendMessage(MakeUnique<Message>(this, runnable.forget()));
+}
+
+void MediaTrack::SetDisabledTrackModeImpl(DisabledTrackMode aMode) {
+  MOZ_DIAGNOSTIC_ASSERT(
+      aMode == DisabledTrackMode::ENABLED ||
+          mDisabledMode == DisabledTrackMode::ENABLED,
+      "Changing disabled track mode for a track is not allowed");
+  DisabledTrackMode oldMode = CombinedDisabledMode();
+  mDisabledMode = aMode;
+  NotifyIfDisabledModeChangedFrom(oldMode);
+}
+
+void MediaTrack::SetDisabledTrackMode(DisabledTrackMode aMode) {
+  class Message : public ControlMessage {
+   public:
+    Message(MediaTrack* aTrack, DisabledTrackMode aMode)
+        : ControlMessage(aTrack), mMode(aMode) {}
+    void Run() override {
+      TRACE("MediaTrack::SetDisabledTrackModeImpl ControlMessage");
+      mTrack->SetDisabledTrackModeImpl(mMode);
+    }
+    DisabledTrackMode mMode;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aMode));
+}
+
+void MediaTrack::ApplyTrackDisabling(MediaSegment* aSegment,
+                                     MediaSegment* aRawSegment) {
+  if (mDisabledMode == DisabledTrackMode::ENABLED) {
+    return;
+  }
+  if (mDisabledMode == DisabledTrackMode::SILENCE_BLACK) {
+    aSegment->ReplaceWithDisabled();
+    if (aRawSegment) {
+      aRawSegment->ReplaceWithDisabled();
+    }
+  } else if (mDisabledMode == DisabledTrackMode::SILENCE_FREEZE) {
+    aSegment->ReplaceWithNull();
+    if (aRawSegment) {
+      aRawSegment->ReplaceWithNull();
+    }
+  } else {
+    MOZ_CRASH("Unsupported mode");
+  }
+}
+
+void MediaTrack::AddMainThreadListener(
+    MainThreadMediaTrackListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aListener);
+  MOZ_ASSERT(!mMainThreadListeners.Contains(aListener));
+
+  mMainThreadListeners.AppendElement(aListener);
+
+  // If it is not yet time to send the notification, then exit here.
+  if (!mEndedNotificationSent) {
+    return;
+  }
+
+  class NotifyRunnable final : public Runnable {
+   public:
+    explicit NotifyRunnable(MediaTrack* aTrack)
+        : Runnable("MediaTrack::NotifyRunnable"), mTrack(aTrack) {}
+
+    NS_IMETHOD Run() override {
+      TRACE("MediaTrack::NotifyMainThreadListeners Runnable");
+      MOZ_ASSERT(NS_IsMainThread());
+      mTrack->NotifyMainThreadListeners();
+      return NS_OK;
+    }
+
+   private:
+    ~NotifyRunnable() = default;
+
+    RefPtr<MediaTrack> mTrack;
+  };
+
+  nsCOMPtr<nsIRunnable> runnable = new NotifyRunnable(this);
+  GraphImpl()->Dispatch(runnable.forget());
+}
+
+void MediaTrack::AdvanceTimeVaryingValuesToCurrentTime(GraphTime aCurrentTime,
+                                                       GraphTime aBlockedTime) {
+  mStartTime += aBlockedTime;
+
+  if (!mSegment) {
+    // No data to be forgotten.
+    return;
+  }
+
+  TrackTime time = aCurrentTime - mStartTime;
+  // Only prune if there is a reasonable chunk (50ms) to forget, so we don't
+  // spend too much time pruning segments.
+  const TrackTime minChunkSize = mSampleRate * 50 / 1000;
+  if (time < mForgottenTime + minChunkSize) {
+    return;
+  }
+
+  mForgottenTime = std::min(GetEnd() - 1, time);
+  mSegment->ForgetUpTo(mForgottenTime);
+}
+
+void MediaTrack::NotifyIfDisabledModeChangedFrom(DisabledTrackMode aOldMode) {
+  DisabledTrackMode mode = CombinedDisabledMode();
+  if (aOldMode == mode) {
+    return;
+  }
+
+  for (const auto& listener : mTrackListeners) {
+    listener->NotifyEnabledStateChanged(
+        Graph(), mode != DisabledTrackMode::SILENCE_BLACK);
+  }
+
+  for (const auto& c : mConsumers) {
+    if (c->GetDestination()) {
+      c->GetDestination()->OnInputDisabledModeChanged(mode);
+    }
+  }
+}
+
+SourceMediaTrack::SourceMediaTrack(MediaSegment::Type aType,
+                                   TrackRate aSampleRate)
+    : MediaTrack(aSampleRate, aType,
+                 aType == MediaSegment::AUDIO
+                     ? static_cast<MediaSegment*>(new AudioSegment())
+                     : static_cast<MediaSegment*>(new VideoSegment())),
+      mMutex("mozilla::media::SourceMediaTrack") {
+  mUpdateTrack = MakeUnique<TrackData>();
+  mUpdateTrack->mInputRate = aSampleRate;
+  mUpdateTrack->mResamplerChannelCount = 0;
+  mUpdateTrack->mData = UniquePtr<MediaSegment>(mSegment->CreateEmptyClone());
+  mUpdateTrack->mEnded = false;
+  mUpdateTrack->mPullingEnabled = false;
+  mUpdateTrack->mGraphThreadDone = false;
+}
+
+void SourceMediaTrack::DestroyImpl() {
+  GraphImpl()->AssertOnGraphThreadOrNotRunning();
+  for (int32_t i = mConsumers.Length() - 1; i >= 0; --i) {
+    // Disconnect before we come under mMutex's lock since it can call back
+    // through RemoveDirectListenerImpl() and deadlock.
+    mConsumers[i]->Disconnect();
+  }
+
+  // Hold mMutex while mGraph is reset so that other threads holding mMutex
+  // can null-check know that the graph will not destroyed.
+  MutexAutoLock lock(mMutex);
+  mUpdateTrack = nullptr;
+  MediaTrack::DestroyImpl();
+}
+
+void SourceMediaTrack::SetPullingEnabled(bool aEnabled) {
+  class Message : public ControlMessage {
+   public:
+    Message(SourceMediaTrack* aTrack, bool aEnabled)
+        : ControlMessage(nullptr), mTrack(aTrack), mEnabled(aEnabled) {}
+    void Run() override {
+      TRACE("SourceMediaTrack::SetPullingEnabled ControlMessage");
+      MutexAutoLock lock(mTrack->mMutex);
+      if (!mTrack->mUpdateTrack) {
+        // We can't enable pulling for a track that has ended. We ignore
+        // this if we're disabling pulling, since shutdown sequences are
+        // complex. If there's truly an issue we'll have issues enabling anyway.
+        MOZ_ASSERT_IF(mEnabled, mTrack->mEnded);
+        return;
+      }
+      MOZ_ASSERT(mTrack->mType == MediaSegment::AUDIO,
+                 "Pulling is not allowed for video");
+      mTrack->mUpdateTrack->mPullingEnabled = mEnabled;
+    }
+    SourceMediaTrack* mTrack;
+    bool mEnabled;
+  };
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aEnabled));
+}
+
+bool SourceMediaTrack::PullNewData(GraphTime aDesiredUpToTime) {
+  TRACE_COMMENT("SourceMediaTrack::PullNewData", "%p", this);
+  TrackTime t;
+  TrackTime current;
+  {
+    if (mEnded) {
+      return false;
+    }
+    MutexAutoLock lock(mMutex);
+    if (mUpdateTrack->mEnded) {
+      return false;
+    }
+    if (!mUpdateTrack->mPullingEnabled) {
+      return false;
+    }
+    // Compute how much track time we'll need assuming we don't block
+    // the track at all.
+    t = GraphTimeToTrackTime(aDesiredUpToTime);
+    current = GetEnd() + mUpdateTrack->mData->GetDuration();
+  }
+  if (t <= current) {
+    return false;
+  }
+  LOG(LogLevel::Verbose, ("%p: Calling NotifyPull track=%p t=%f current end=%f",
+                          GraphImpl(), this, GraphImpl()->MediaTimeToSeconds(t),
+                          GraphImpl()->MediaTimeToSeconds(current)));
+  for (auto& l : mTrackListeners) {
+    l->NotifyPull(Graph(), current, t);
+  }
+  return true;
+}
+
+/**
+ * This moves chunks from aIn to aOut. For audio this is simple. For video
+ * we carry durations over if present, or extend up to aDesiredUpToTime if not.
+ *
+ * We also handle "resetters" from captured media elements. This type of source
+ * pushes future frames into the track, and should it need to remove some, e.g.,
+ * because of a seek or pause, it tells us by letting time go backwards. Without
+ * this, tracks would be live for too long after a seek or pause.
+ */
+static void MoveToSegment(SourceMediaTrack* aTrack, MediaSegment* aIn,
+                          MediaSegment* aOut, TrackTime aCurrentTime,
+                          TrackTime aDesiredUpToTime)
+    MOZ_REQUIRES(aTrack->GetMutex()) {
+  MOZ_ASSERT(aIn->GetType() == aOut->GetType());
+  MOZ_ASSERT(aOut->GetDuration() >= aCurrentTime);
+  MOZ_ASSERT(aDesiredUpToTime >= aCurrentTime);
+  if (aIn->GetType() == MediaSegment::AUDIO) {
+    AudioSegment* in = static_cast<AudioSegment*>(aIn);
+    AudioSegment* out = static_cast<AudioSegment*>(aOut);
+    TrackTime desiredDurationToMove = aDesiredUpToTime - aCurrentTime;
+    TrackTime end = std::min(in->GetDuration(), desiredDurationToMove);
+
+    out->AppendSlice(*in, 0, end);
+    in->RemoveLeading(end);
+
+    aTrack->GetMutex().AssertCurrentThreadOwns();
+    out->ApplyVolume(aTrack->GetVolumeLocked());
+  } else {
+    VideoSegment* in = static_cast<VideoSegment*>(aIn);
+    VideoSegment* out = static_cast<VideoSegment*>(aOut);
+    for (VideoSegment::ConstChunkIterator c(*in); !c.IsEnded(); c.Next()) {
+      MOZ_ASSERT(!c->mTimeStamp.IsNull());
+      VideoChunk* last = out->GetLastChunk();
+      if (!last || last->mTimeStamp.IsNull()) {
+        // This is the first frame, or the last frame pushed to `out` has been
+        // all consumed. Just append and we deal with its duration later.
+        out->AppendFrame(do_AddRef(c->mFrame.GetImage()),
+                         c->mFrame.GetIntrinsicSize(),
+                         c->mFrame.GetPrincipalHandle(),
+                         c->mFrame.GetForceBlack(), c->mTimeStamp);
+        if (c->GetDuration() > 0) {
+          out->ExtendLastFrameBy(c->GetDuration());
+        }
+        continue;
+      }
+
+      // We now know when this frame starts, aka when the last frame ends.
+
+      if (c->mTimeStamp < last->mTimeStamp) {
+        // Time is going backwards. This is a resetting frame from
+        // DecodedStream. Clear everything up to currentTime.
+        out->Clear();
+        out->AppendNullData(aCurrentTime);
+      }
+
+      // Append the current frame (will have duration 0).
+      out->AppendFrame(do_AddRef(c->mFrame.GetImage()),
+                       c->mFrame.GetIntrinsicSize(),
+                       c->mFrame.GetPrincipalHandle(),
+                       c->mFrame.GetForceBlack(), c->mTimeStamp);
+      if (c->GetDuration() > 0) {
+        out->ExtendLastFrameBy(c->GetDuration());
+      }
+    }
+    if (out->GetDuration() < aDesiredUpToTime) {
+      out->ExtendLastFrameBy(aDesiredUpToTime - out->GetDuration());
+    }
+    in->Clear();
+    MOZ_ASSERT(aIn->GetDuration() == 0, "aIn must be consumed");
+  }
+}
+
+void SourceMediaTrack::ExtractPendingInput(GraphTime aCurrentTime,
+                                           GraphTime aDesiredUpToTime) {
+  MutexAutoLock lock(mMutex);
+
+  if (!mUpdateTrack) {
+    MOZ_ASSERT(mEnded);
+    return;
+  }
+
+  TrackTime trackCurrentTime = GraphTimeToTrackTime(aCurrentTime);
+
+  ApplyTrackDisabling(mUpdateTrack->mData.get());
+
+  if (!mUpdateTrack->mData->IsEmpty()) {
+    for (const auto& l : mTrackListeners) {
+      l->NotifyQueuedChanges(GraphImpl(), GetEnd(), *mUpdateTrack->mData);
+    }
+  }
+  TrackTime trackDesiredUpToTime = GraphTimeToTrackTime(aDesiredUpToTime);
+  TrackTime endTime = trackDesiredUpToTime;
+  if (mUpdateTrack->mEnded) {
+    endTime = std::min(trackDesiredUpToTime,
+                       GetEnd() + mUpdateTrack->mData->GetDuration());
+  }
+  LOG(LogLevel::Verbose,
+      ("%p: SourceMediaTrack %p advancing end from %" PRId64 " to %" PRId64,
+       GraphImpl(), this, int64_t(trackCurrentTime), int64_t(endTime)));
+  MoveToSegment(this, mUpdateTrack->mData.get(), mSegment.get(),
+                trackCurrentTime, endTime);
+  if (mUpdateTrack->mEnded && GetEnd() < trackDesiredUpToTime) {
+    mEnded = true;
+    mUpdateTrack = nullptr;
+  }
+}
+
+void SourceMediaTrack::ResampleAudioToGraphSampleRate(MediaSegment* aSegment) {
+  mMutex.AssertCurrentThreadOwns();
+  if (aSegment->GetType() != MediaSegment::AUDIO ||
+      mUpdateTrack->mInputRate == GraphImpl()->GraphRate()) {
+    return;
+  }
+  AudioSegment* segment = static_cast<AudioSegment*>(aSegment);
+  segment->ResampleChunks(mUpdateTrack->mResampler,
+                          &mUpdateTrack->mResamplerChannelCount,
+                          mUpdateTrack->mInputRate, GraphImpl()->GraphRate());
+}
+
+void SourceMediaTrack::AdvanceTimeVaryingValuesToCurrentTime(
+    GraphTime aCurrentTime, GraphTime aBlockedTime) {
+  MutexAutoLock lock(mMutex);
+  MediaTrack::AdvanceTimeVaryingValuesToCurrentTime(aCurrentTime, aBlockedTime);
+}
+
+void SourceMediaTrack::SetAppendDataSourceRate(TrackRate aRate) {
+  MutexAutoLock lock(mMutex);
+  if (!mUpdateTrack) {
+    return;
+  }
+  MOZ_DIAGNOSTIC_ASSERT(mSegment->GetType() == MediaSegment::AUDIO);
+  // Set the new input rate and reset the resampler.
+  mUpdateTrack->mInputRate = aRate;
+  mUpdateTrack->mResampler.own(nullptr);
+  mUpdateTrack->mResamplerChannelCount = 0;
+}
+
+TrackTime SourceMediaTrack::AppendData(MediaSegment* aSegment,
+                                       MediaSegment* aRawSegment) {
+  MutexAutoLock lock(mMutex);
+  MOZ_DIAGNOSTIC_ASSERT(aSegment->GetType() == mType);
+  TrackTime appended = 0;
+  if (!mUpdateTrack || mUpdateTrack->mEnded || mUpdateTrack->mGraphThreadDone) {
+    aSegment->Clear();
+    return appended;
+  }
+
+  // Data goes into mData, and on the next iteration of the MTG moves
+  // into the track's segment after NotifyQueuedTrackChanges().  This adds
+  // 0-10ms of delay before data gets to direct listeners.
+  // Indirect listeners (via subsequent TrackUnion nodes) are synced to
+  // playout time, and so can be delayed by buffering.
+
+  // Apply track disabling before notifying any consumers directly
+  // or inserting into the graph
+  ApplyTrackDisabling(aSegment, aRawSegment);
+
+  ResampleAudioToGraphSampleRate(aSegment);
+
+  // Must notify first, since AppendFrom() will empty out aSegment
+  NotifyDirectConsumers(aRawSegment ? aRawSegment : aSegment);
+  appended = aSegment->GetDuration();
+  mUpdateTrack->mData->AppendFrom(aSegment);  // note: aSegment is now dead
+  {
+    auto graph = GraphImpl();
+    MonitorAutoLock lock(graph->GetMonitor());
+    if (graph->CurrentDriver()) {  // graph has not completed forced shutdown
+      graph->EnsureNextIteration();
+    }
+  }
+
+  return appended;
+}
+
+TrackTime SourceMediaTrack::ClearFutureData() {
+  MutexAutoLock lock(mMutex);
+  auto graph = GraphImpl();
+  if (!mUpdateTrack || !graph) {
+    return 0;
+  }
+
+  TrackTime duration = mUpdateTrack->mData->GetDuration();
+  mUpdateTrack->mData->Clear();
+  return duration;
+}
+
+void SourceMediaTrack::NotifyDirectConsumers(MediaSegment* aSegment) {
+  mMutex.AssertCurrentThreadOwns();
+
+  for (const auto& l : mDirectTrackListeners) {
+    TrackTime offset = 0;  // FIX! need a separate TrackTime.... or the end of
+                           // the internal buffer
+    l->NotifyRealtimeTrackDataAndApplyTrackDisabling(Graph(), offset,
+                                                     *aSegment);
+  }
+}
+
+void SourceMediaTrack::AddDirectListenerImpl(
+    already_AddRefed<DirectMediaTrackListener> aListener) {
+  MutexAutoLock lock(mMutex);
+
+  RefPtr<DirectMediaTrackListener> listener = aListener;
+  LOG(LogLevel::Debug,
+      ("%p: Adding direct track listener %p to source track %p", GraphImpl(),
+       listener.get(), this));
+
+  MOZ_ASSERT(mType == MediaSegment::VIDEO);
+  for (const auto& l : mDirectTrackListeners) {
+    if (l == listener) {
+      listener->NotifyDirectListenerInstalled(
+          DirectMediaTrackListener::InstallationResult::ALREADY_EXISTS);
+      return;
+    }
+  }
+
+  mDirectTrackListeners.AppendElement(listener);
+
+  LOG(LogLevel::Debug,
+      ("%p: Added direct track listener %p", GraphImpl(), listener.get()));
+  listener->NotifyDirectListenerInstalled(
+      DirectMediaTrackListener::InstallationResult::SUCCESS);
+
+  if (mDisabledMode != DisabledTrackMode::ENABLED) {
+    listener->IncreaseDisabled(mDisabledMode);
+  }
+
+  if (mEnded) {
+    return;
+  }
+
+  // Pass buffered data to the listener
+  VideoSegment bufferedData;
+  size_t videoFrames = 0;
+  VideoSegment& segment = *GetData<VideoSegment>();
+  for (VideoSegment::ConstChunkIterator iter(segment); !iter.IsEnded();
+       iter.Next()) {
+    if (iter->mTimeStamp.IsNull()) {
+      // No timestamp means this is only for the graph's internal book-keeping,
+      // denoting a late start of the track.
+      continue;
+    }
+    ++videoFrames;
+    bufferedData.AppendFrame(do_AddRef(iter->mFrame.GetImage()),
+                             iter->mFrame.GetIntrinsicSize(),
+                             iter->mFrame.GetPrincipalHandle(),
+                             iter->mFrame.GetForceBlack(), iter->mTimeStamp);
+  }
+
+  VideoSegment& video = static_cast<VideoSegment&>(*mUpdateTrack->mData);
+  for (VideoSegment::ConstChunkIterator iter(video); !iter.IsEnded();
+       iter.Next()) {
+    ++videoFrames;
+    MOZ_ASSERT(!iter->mTimeStamp.IsNull());
+    bufferedData.AppendFrame(do_AddRef(iter->mFrame.GetImage()),
+                             iter->mFrame.GetIntrinsicSize(),
+                             iter->mFrame.GetPrincipalHandle(),
+                             iter->mFrame.GetForceBlack(), iter->mTimeStamp);
+  }
+
+  LOG(LogLevel::Info,
+      ("%p: Notifying direct listener %p of %zu video frames and duration "
+       "%" PRId64,
+       GraphImpl(), listener.get(), videoFrames, bufferedData.GetDuration()));
+  listener->NotifyRealtimeTrackData(Graph(), 0, bufferedData);
+}
+
+void SourceMediaTrack::RemoveDirectListenerImpl(
+    DirectMediaTrackListener* aListener) {
+  MutexAutoLock lock(mMutex);
+  for (int32_t i = mDirectTrackListeners.Length() - 1; i >= 0; --i) {
+    const RefPtr<DirectMediaTrackListener>& l = mDirectTrackListeners[i];
+    if (l == aListener) {
+      if (mDisabledMode != DisabledTrackMode::ENABLED) {
+        aListener->DecreaseDisabled(mDisabledMode);
+      }
+      aListener->NotifyDirectListenerUninstalled();
+      mDirectTrackListeners.RemoveElementAt(i);
+    }
+  }
+}
+
+void SourceMediaTrack::End() {
+  MutexAutoLock lock(mMutex);
+  if (!mUpdateTrack) {
+    // Already ended
+    return;
+  }
+  mUpdateTrack->mEnded = true;
+  if (auto graph = GraphImpl()) {
+    MonitorAutoLock lock(graph->GetMonitor());
+    if (graph->CurrentDriver()) {  // graph has not completed forced shutdown
+      graph->EnsureNextIteration();
+    }
+  }
+}
+
+void SourceMediaTrack::SetDisabledTrackModeImpl(DisabledTrackMode aMode) {
+  {
+    MutexAutoLock lock(mMutex);
+    for (const auto& l : mDirectTrackListeners) {
+      DisabledTrackMode oldMode = mDisabledMode;
+      bool oldEnabled = oldMode == DisabledTrackMode::ENABLED;
+      if (!oldEnabled && aMode == DisabledTrackMode::ENABLED) {
+        LOG(LogLevel::Debug, ("%p: SourceMediaTrack %p setting "
+                              "direct listener enabled",
+                              GraphImpl(), this));
+        l->DecreaseDisabled(oldMode);
+      } else if (oldEnabled && aMode != DisabledTrackMode::ENABLED) {
+        LOG(LogLevel::Debug, ("%p: SourceMediaTrack %p setting "
+                              "direct listener disabled",
+                              GraphImpl(), this));
+        l->IncreaseDisabled(aMode);
+      }
+    }
+  }
+  MediaTrack::SetDisabledTrackModeImpl(aMode);
+}
+
+uint32_t SourceMediaTrack::NumberOfChannels() const {
+  AudioSegment* audio = GetData<AudioSegment>();
+  MOZ_DIAGNOSTIC_ASSERT(audio);
+  if (!audio) {
+    return 0;
+  }
+  return audio->MaxChannelCount();
+}
+
+void SourceMediaTrack::RemoveAllDirectListenersImpl() {
+  GraphImpl()->AssertOnGraphThreadOrNotRunning();
+  MutexAutoLock lock(mMutex);
+
+  for (auto& l : mDirectTrackListeners.Clone()) {
+    l->NotifyDirectListenerUninstalled();
+  }
+  mDirectTrackListeners.Clear();
+}
+
+void SourceMediaTrack::SetVolume(float aVolume) {
+  MutexAutoLock lock(mMutex);
+  mVolume = aVolume;
+}
+
+float SourceMediaTrack::GetVolumeLocked() {
+  mMutex.AssertCurrentThreadOwns();
+  return mVolume;
+}
+
+SourceMediaTrack::~SourceMediaTrack() = default;
+
+void MediaInputPort::Init() {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  LOG(LogLevel::Debug, ("%p: Adding MediaInputPort %p (from %p to %p)",
+                        mSource->GraphImpl(), this, mSource, mDest));
+  // Only connect the port if it wasn't disconnected on allocation.
+  if (mSource) {
+    mSource->AddConsumer(this);
+    mDest->AddInput(this);
+  }
+  // mPortCount decremented via MediaInputPort::Destroy's message
+  ++mGraph->mPortCount;
+}
+
+void MediaInputPort::Disconnect() {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  NS_ASSERTION(!mSource == !mDest,
+               "mSource and mDest must either both be null or both non-null");
+
+  if (!mSource) {
+    return;
+  }
+
+  mSource->RemoveConsumer(this);
+  mDest->RemoveInput(this);
+  mSource = nullptr;
+  mDest = nullptr;
+
+  mGraph->SetTrackOrderDirty();
+}
+
+MediaTrack* MediaInputPort::GetSource() const {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  return mSource;
+}
+
+ProcessedMediaTrack* MediaInputPort::GetDestination() const {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  return mDest;
+}
+
+MediaInputPort::InputInterval MediaInputPort::GetNextInputInterval(
+    MediaInputPort const* aPort, GraphTime aTime) {
+  InputInterval result = {GRAPH_TIME_MAX, GRAPH_TIME_MAX, false};
+  if (!aPort) {
+    result.mStart = aTime;
+    result.mInputIsBlocked = true;
+    return result;
+  }
+  aPort->mGraph->AssertOnGraphThreadOrNotRunning();
+  if (aTime >= aPort->mDest->mStartBlocking) {
+    return result;
+  }
+  result.mStart = aTime;
+  result.mEnd = aPort->mDest->mStartBlocking;
+  result.mInputIsBlocked = aTime >= aPort->mSource->mStartBlocking;
+  if (!result.mInputIsBlocked) {
+    result.mEnd = std::min(result.mEnd, aPort->mSource->mStartBlocking);
+  }
+  return result;
+}
+
+void MediaInputPort::Suspended() {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  mDest->InputSuspended(this);
+}
+
+void MediaInputPort::Resumed() {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  mDest->InputResumed(this);
+}
+
+void MediaInputPort::Destroy() {
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaInputPort* aPort)
+        : ControlMessage(nullptr), mPort(aPort) {}
+    void Run() override {
+      TRACE("MediaInputPort::Destroy ControlMessage");
+      mPort->Disconnect();
+      --mPort->GraphImpl()->mPortCount;
+      mPort->SetGraphImpl(nullptr);
+      NS_RELEASE(mPort);
+    }
+    void RunDuringShutdown() override { Run(); }
+    MediaInputPort* mPort;
+  };
+  // Keep a reference to the graph, since Message might RunDuringShutdown()
+  // synchronously and make GraphImpl() invalid.
+  RefPtr<MediaTrackGraphImpl> graph = mGraph;
+  graph->AppendMessage(MakeUnique<Message>(this));
+  --graph->mMainThreadPortCount;
+}
+
+MediaTrackGraphImpl* MediaInputPort::GraphImpl() const {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  return mGraph;
+}
+
+MediaTrackGraph* MediaInputPort::Graph() const {
+  mGraph->AssertOnGraphThreadOrNotRunning();
+  return mGraph;
+}
+
+void MediaInputPort::SetGraphImpl(MediaTrackGraphImpl* aGraph) {
+  MOZ_ASSERT(!mGraph || !aGraph, "Should only be set once");
+  DebugOnly<MediaTrackGraphImpl*> graph = mGraph ? mGraph : aGraph;
+  MOZ_ASSERT(graph->OnGraphThreadOrNotRunning());
+  mGraph = aGraph;
+}
+
+already_AddRefed<MediaInputPort> ProcessedMediaTrack::AllocateInputPort(
+    MediaTrack* aTrack, uint16_t aInputNumber, uint16_t aOutputNumber) {
+  // This method creates two references to the MediaInputPort: one for
+  // the main thread, and one for the MediaTrackGraph.
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaInputPort* aPort)
+        : ControlMessage(aPort->mDest), mPort(aPort) {}
+    void Run() override {
+      TRACE("ProcessedMediaTrack::AllocateInputPort ControlMessage");
+      mPort->Init();
+      // The graph holds its reference implicitly
+      mPort->GraphImpl()->SetTrackOrderDirty();
+      Unused << mPort.forget();
+    }
+    void RunDuringShutdown() override { Run(); }
+    RefPtr<MediaInputPort> mPort;
+  };
+
+  MOZ_DIAGNOSTIC_ASSERT(aTrack->mType == mType);
+  RefPtr<MediaInputPort> port;
+  if (aTrack->IsDestroyed()) {
+    // Create a port that's disconnected, which is what it'd be after its source
+    // track is Destroy()ed normally. Disconnect() is idempotent so destroying
+    // this later is fine.
+    port = new MediaInputPort(GraphImpl(), nullptr, nullptr, aInputNumber,
+                              aOutputNumber);
+  } else {
+    MOZ_ASSERT(aTrack->GraphImpl() == GraphImpl());
+    port = new MediaInputPort(GraphImpl(), aTrack, this, aInputNumber,
+                              aOutputNumber);
+  }
+  ++GraphImpl()->mMainThreadPortCount;
+  GraphImpl()->AppendMessage(MakeUnique<Message>(port));
+  return port.forget();
+}
+
+void ProcessedMediaTrack::QueueSetAutoend(bool aAutoend) {
+  class Message : public ControlMessage {
+   public:
+    Message(ProcessedMediaTrack* aTrack, bool aAutoend)
+        : ControlMessage(aTrack), mAutoend(aAutoend) {}
+    void Run() override {
+      TRACE("ProcessedMediaTrack::SetAutoendImpl ControlMessage");
+      static_cast<ProcessedMediaTrack*>(mTrack)->SetAutoendImpl(mAutoend);
+    }
+    bool mAutoend;
+  };
+  if (mMainThreadDestroyed) {
+    return;
+  }
+  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aAutoend));
+}
+
+void ProcessedMediaTrack::DestroyImpl() {
+  for (int32_t i = mInputs.Length() - 1; i >= 0; --i) {
+    mInputs[i]->Disconnect();
+  }
+
+  for (int32_t i = mSuspendedInputs.Length() - 1; i >= 0; --i) {
+    mSuspendedInputs[i]->Disconnect();
+  }
+
+  MediaTrack::DestroyImpl();
+  // The track order is only important if there are connections, in which
+  // case MediaInputPort::Disconnect() called SetTrackOrderDirty().
+  // MediaTrackGraphImpl::RemoveTrackGraphThread() will also call
+  // SetTrackOrderDirty(), for other reasons.
+}
+
+MediaTrackGraphImpl::MediaTrackGraphImpl(
+    GraphDriverType aDriverRequested, GraphRunType aRunTypeRequested,
+    TrackRate aSampleRate, uint32_t aChannelCount,
+    CubebUtils::AudioDeviceID aOutputDeviceID,
+    nsISerialEventTarget* aMainThread)
+    : MediaTrackGraph(aSampleRate),
+      mGraphRunner(aRunTypeRequested == SINGLE_THREAD
+                       ? GraphRunner::Create(this)
+                       : already_AddRefed<GraphRunner>(nullptr)),
+      mFirstCycleBreaker(0)
+      // An offline graph is not initially processing.
+      ,
+      mEndTime(aDriverRequested == OFFLINE_THREAD_DRIVER ? 0 : GRAPH_TIME_MAX),
+      mPortCount(0),
+      mOutputDeviceID(aOutputDeviceID),
+      mMonitor("MediaTrackGraphImpl"),
+      mLifecycleState(LIFECYCLE_THREAD_NOT_STARTED),
+      mPostedRunInStableStateEvent(false),
+      mGraphDriverRunning(false),
+      mPostedRunInStableState(false),
+      mRealtime(aDriverRequested != OFFLINE_THREAD_DRIVER),
+      mTrackOrderDirty(false),
+      mMainThread(aMainThread),
+      mSelfRef(this),
+      mGlobalVolume(CubebUtils::GetVolumeScale())
+#ifdef DEBUG
+      ,
+      mCanRunMessagesSynchronously(false)
+#endif
+      ,
+      mMainThreadGraphTime(0, "MediaTrackGraphImpl::mMainThreadGraphTime"),
+      mAudioOutputLatency(0.0),
+      mMaxOutputChannelCount(std::min(8u, CubebUtils::MaxNumberOfChannels())) {
+  bool failedToGetShutdownBlocker = false;
+  if (!IsNonRealtime()) {
+    failedToGetShutdownBlocker = !AddShutdownBlocker();
+  }
+
+  if ((aRunTypeRequested == SINGLE_THREAD && !mGraphRunner) ||
+      failedToGetShutdownBlocker) {
+    // At least one of the following happened
+    // - Failed to create thread.
+    // - Failed to install a shutdown blocker when one is needed.
+    // Because we have a fail state, jump to last phase of the lifecycle.
+    mLifecycleState = LIFECYCLE_WAITING_FOR_TRACK_DESTRUCTION;
+    RemoveShutdownBlocker();  // No-op if blocker wasn't added.
+#ifdef DEBUG
+    mCanRunMessagesSynchronously = true;
+#endif
+    return;
+  }
+  if (mRealtime) {
+    if (aDriverRequested == AUDIO_THREAD_DRIVER) {
+      // Always start with zero input channels, and no particular preferences
+      // for the input channel.
+      mDriver = new AudioCallbackDriver(this, nullptr, mSampleRate,
+                                        aChannelCount, 0, mOutputDeviceID,
+                                        nullptr, AudioInputType::Unknown);
+    } else {
+      mDriver = new SystemClockDriver(this, nullptr, mSampleRate);
+    }
+  } else {
+    mDriver =
+        new OfflineClockDriver(this, mSampleRate, MEDIA_GRAPH_TARGET_PERIOD_MS);
+  }
+
+  mLastMainThreadUpdate = TimeStamp::Now();
+
+  RegisterWeakAsyncMemoryReporter(this);
+}
+
+#ifdef DEBUG
+bool MediaTrackGraphImpl::InDriverIteration(const GraphDriver* aDriver) const {
+  return aDriver->OnThread() ||
+         (mGraphRunner && mGraphRunner->InDriverIteration(aDriver));
+}
+#endif
+
+void MediaTrackGraphImpl::Destroy() {
+  // First unregister from memory reporting.
+  UnregisterWeakMemoryReporter(this);
+
+  // Clear the self reference which will destroy this instance if all
+  // associated GraphDrivers are destroyed.
+  mSelfRef = nullptr;
+}
+
+// Internal method has a Window ID parameter so that TestAudioTrackGraph
+// GTests can create a graph without a window.
+/* static */
+MediaTrackGraphImpl* MediaTrackGraphImpl::GetInstanceIfExists(
+    uint64_t aWindowID, bool aShouldResistFingerprinting, TrackRate aSampleRate,
+    CubebUtils::AudioDeviceID aOutputDeviceID) {
+  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");
+
+  TrackRate sampleRate =
+      aSampleRate
+          ? aSampleRate
+          : CubebUtils::PreferredSampleRate(aShouldResistFingerprinting);
+  GraphKey key(aWindowID, sampleRate, aOutputDeviceID);
+
+  return gGraphs.Get(key);
+}
+
+// Public method has an nsPIDOMWindowInner* parameter to ensure that the
+// window is a real inner Window, not a WindowProxy.
+/* static */
+MediaTrackGraph* MediaTrackGraph::GetInstanceIfExists(
+    nsPIDOMWindowInner* aWindow, TrackRate aSampleRate,
+    CubebUtils::AudioDeviceID aOutputDeviceID) {
+  return MediaTrackGraphImpl::GetInstanceIfExists(
+      aWindow->WindowID(),
+      aWindow->AsGlobal()->ShouldResistFingerprinting(RFPTarget::Unknown),
+      aSampleRate, aOutputDeviceID);
+}
+
+/* static */
+MediaTrackGraphImpl* MediaTrackGraphImpl::GetInstance(
+    GraphDriverType aGraphDriverRequested, uint64_t aWindowID,
+    bool aShouldResistFingerprinting, TrackRate aSampleRate,
+    CubebUtils::AudioDeviceID aOutputDeviceID,
+    nsISerialEventTarget* aMainThread) {
+  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");
+
+  TrackRate sampleRate =
+      aSampleRate
+          ? aSampleRate
+          : CubebUtils::PreferredSampleRate(aShouldResistFingerprinting);
+  MediaTrackGraphImpl* graph = GetInstanceIfExists(
+      aWindowID, aShouldResistFingerprinting, sampleRate, aOutputDeviceID);
+
+  if (!graph) {
+    GraphRunType runType = DIRECT_DRIVER;
+    if (aGraphDriverRequested != OFFLINE_THREAD_DRIVER &&
+        (StaticPrefs::dom_audioworklet_enabled() ||
+         Preferences::GetBool("media.audiograph.single_thread.enabled",
+                              false))) {
+      runType = SINGLE_THREAD;
+    }
+
+    // In a real time graph, the number of output channels is determined by
+    // the underlying number of channel of the default audio output device, and
+    // capped to 8.
+    uint32_t channelCount =
+        std::min<uint32_t>(8, CubebUtils::MaxNumberOfChannels());
+    graph = new MediaTrackGraphImpl(aGraphDriverRequested, runType, sampleRate,
+                                    channelCount, aOutputDeviceID, aMainThread);
+    GraphKey key(aWindowID, sampleRate, aOutputDeviceID);
+    gGraphs.InsertOrUpdate(key, graph);
+
+    LOG(LogLevel::Debug,
+        ("Starting up MediaTrackGraph %p for window 0x%" PRIx64, graph,
+         aWindowID));
+  }
+
+  return graph;
+}
+
+/* static */
+MediaTrackGraph* MediaTrackGraph::GetInstance(
+    GraphDriverType aGraphDriverRequested, nsPIDOMWindowInner* aWindow,
+    TrackRate aSampleRate, CubebUtils::AudioDeviceID aOutputDeviceID) {
+  return MediaTrackGraphImpl::GetInstance(
+      aGraphDriverRequested, aWindow->WindowID(),
+      aWindow->AsGlobal()->ShouldResistFingerprinting(RFPTarget::Unknown),
+      aSampleRate, aOutputDeviceID,
+      aWindow->EventTargetFor(TaskCategory::Other));
+}
+
+MediaTrackGraph* MediaTrackGraph::CreateNonRealtimeInstance(
+    TrackRate aSampleRate, nsPIDOMWindowInner* aWindow) {
+  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");
+
+  nsISerialEventTarget* mainThread = GetMainThreadSerialEventTarget();
+  // aWindow can be null when the document is being unlinked, so this works when
+  // with a generic main thread if that's the case.
+  if (aWindow) {
+    mainThread =
+        aWindow->AsGlobal()->AbstractMainThreadFor(TaskCategory::Other);
+  }
+
+  // Offline graphs have 0 output channel count: they write the output to a
+  // buffer, not an audio output track.
+  MediaTrackGraphImpl* graph =
+      new MediaTrackGraphImpl(OFFLINE_THREAD_DRIVER, DIRECT_DRIVER, aSampleRate,
+                              0, DEFAULT_OUTPUT_DEVICE, mainThread);
+
+  LOG(LogLevel::Debug, ("Starting up Offline MediaTrackGraph %p", graph));
+
+  return graph;
+}
+
+void MediaTrackGraph::ForceShutDown() {
+  MOZ_ASSERT(NS_IsMainThread(), "Main thread only");
+
+  MediaTrackGraphImpl* graph = static_cast<MediaTrackGraphImpl*>(this);
+
+  graph->ForceShutDown();
+}
+
+NS_IMPL_ISUPPORTS(MediaTrackGraphImpl, nsIMemoryReporter, nsIThreadObserver,
+                  nsITimerCallback, nsINamed)
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
+                                    nsISupports* aData, bool aAnonymize) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mMainThreadTrackCount == 0) {
+    // No tracks to report.
+    FinishCollectReports(aHandleReport, aData, nsTArray<AudioNodeSizes>());
+    return NS_OK;
+  }
+
+  class Message final : public ControlMessage {
+   public:
+    Message(MediaTrackGraphImpl* aGraph, nsIHandleReportCallback* aHandleReport,
+            nsISupports* aHandlerData)
+        : ControlMessage(nullptr),
+          mGraph(aGraph),
+          mHandleReport(aHandleReport),
+          mHandlerData(aHandlerData) {}
+    void Run() override {
+      TRACE("MTG::CollectSizesForMemoryReport ControlMessage");
+      mGraph->CollectSizesForMemoryReport(mHandleReport.forget(),
+                                          mHandlerData.forget());
+    }
+    void RunDuringShutdown() override {
+      // Run this message during shutdown too, so that endReports is called.
+      Run();
+    }
+    MediaTrackGraphImpl* mGraph;
+    // nsMemoryReporterManager keeps the callback and data alive only if it
+    // does not time out.
+    nsCOMPtr<nsIHandleReportCallback> mHandleReport;
+    nsCOMPtr<nsISupports> mHandlerData;
+  };
+
+  AppendMessage(MakeUnique<Message>(this, aHandleReport, aData));
+
+  return NS_OK;
+}
+
+void MediaTrackGraphImpl::CollectSizesForMemoryReport(
+    already_AddRefed<nsIHandleReportCallback> aHandleReport,
+    already_AddRefed<nsISupports> aHandlerData) {
+  class FinishCollectRunnable final : public Runnable {
+   public:
+    explicit FinishCollectRunnable(
+        already_AddRefed<nsIHandleReportCallback> aHandleReport,
+        already_AddRefed<nsISupports> aHandlerData)
+        : mozilla::Runnable("FinishCollectRunnable"),
+          mHandleReport(aHandleReport),
+          mHandlerData(aHandlerData) {}
+
+    NS_IMETHOD Run() override {
+      TRACE("MTG::FinishCollectReports ControlMessage");
+      MediaTrackGraphImpl::FinishCollectReports(mHandleReport, mHandlerData,
+                                                std::move(mAudioTrackSizes));
+      return NS_OK;
+    }
+
+    nsTArray<AudioNodeSizes> mAudioTrackSizes;
+
+   private:
+    ~FinishCollectRunnable() = default;
+
+    // Avoiding nsCOMPtr because NSCAP_ASSERT_NO_QUERY_NEEDED in its
+    // constructor modifies the ref-count, which cannot be done off main
+    // thread.
+    RefPtr<nsIHandleReportCallback> mHandleReport;
+    RefPtr<nsISupports> mHandlerData;
+  };
+
+  RefPtr<FinishCollectRunnable> runnable = new FinishCollectRunnable(
+      std::move(aHandleReport), std::move(aHandlerData));
+
+  auto audioTrackSizes = &runnable->mAudioTrackSizes;
+
+  for (MediaTrack* t : AllTracks()) {
+    AudioNodeTrack* track = t->AsAudioNodeTrack();
+    if (track) {
+      AudioNodeSizes* usage = audioTrackSizes->AppendElement();
+      track->SizeOfAudioNodesIncludingThis(MallocSizeOf, *usage);
+    }
+  }
+
+  mMainThread->Dispatch(runnable.forget());
+}
+
+void MediaTrackGraphImpl::FinishCollectReports(
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData,
+    const nsTArray<AudioNodeSizes>& aAudioTrackSizes) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIMemoryReporterManager> manager =
+      do_GetService("@mozilla.org/memory-reporter-manager;1");
+
+  if (!manager) return;
+
+#define REPORT(_path, _amount, _desc)                                    \
+  aHandleReport->Callback(""_ns, _path, KIND_HEAP, UNITS_BYTES, _amount, \
+                          nsLiteralCString(_desc), aData);
+
+  for (size_t i = 0; i < aAudioTrackSizes.Length(); i++) {
+    const AudioNodeSizes& usage = aAudioTrackSizes[i];
+    const char* const nodeType =
+        usage.mNodeType ? usage.mNodeType : "<unknown>";
+
+    nsPrintfCString enginePath("explicit/webaudio/audio-node/%s/engine-objects",
+                               nodeType);
+    REPORT(enginePath, usage.mEngine,
+           "Memory used by AudioNode engine objects (Web Audio).");
+
+    nsPrintfCString trackPath("explicit/webaudio/audio-node/%s/track-objects",
+                              nodeType);
+    REPORT(trackPath, usage.mTrack,
+           "Memory used by AudioNode track objects (Web Audio).");
+  }
+
+  size_t hrtfLoaders = WebCore::HRTFDatabaseLoader::sizeOfLoaders(MallocSizeOf);
+  if (hrtfLoaders) {
+    REPORT(nsLiteralCString(
+               "explicit/webaudio/audio-node/PannerNode/hrtf-databases"),
+           hrtfLoaders, "Memory used by PannerNode databases (Web Audio).");
+  }
+
+#undef REPORT
+
+  manager->EndReport();
+}
+
+SourceMediaTrack* MediaTrackGraph::CreateSourceTrack(MediaSegment::Type aType) {
+  SourceMediaTrack* track = new SourceMediaTrack(aType, GraphRate());
+  AddTrack(track);
+  return track;
+}
+
+ProcessedMediaTrack* MediaTrackGraph::CreateForwardedInputTrack(
+    MediaSegment::Type aType) {
+  ForwardedInputTrack* track = new ForwardedInputTrack(GraphRate(), aType);
+  AddTrack(track);
+  return track;
+}
+
+AudioCaptureTrack* MediaTrackGraph::CreateAudioCaptureTrack() {
+  AudioCaptureTrack* track = new AudioCaptureTrack(GraphRate());
+  AddTrack(track);
+  return track;
+}
+
+CrossGraphTransmitter* MediaTrackGraph::CreateCrossGraphTransmitter(
+    CrossGraphReceiver* aReceiver) {
+  CrossGraphTransmitter* track =
+      new CrossGraphTransmitter(GraphRate(), aReceiver);
+  AddTrack(track);
+  return track;
+}
+
+CrossGraphReceiver* MediaTrackGraph::CreateCrossGraphReceiver(
+    TrackRate aTransmitterRate) {
+  CrossGraphReceiver* track =
+      new CrossGraphReceiver(GraphRate(), aTransmitterRate);
+  AddTrack(track);
+  return track;
+}
+
+void MediaTrackGraph::AddTrack(MediaTrack* aTrack) {
+  MediaTrackGraphImpl* graph = static_cast<MediaTrackGraphImpl*>(this);
+#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
+  if (graph->mRealtime) {
+    bool found = false;
+    for (const auto& currentGraph : gGraphs.Values()) {
+      if (currentGraph == graph) {
+        found = true;
+        break;
+      }
+    }
+    MOZ_DIAGNOSTIC_ASSERT(found, "Graph must not be shutting down");
+  }
+#endif
+  NS_ADDREF(aTrack);
+  aTrack->SetGraphImpl(graph);
+  ++graph->mMainThreadTrackCount;
+  graph->AppendMessage(MakeUnique<CreateMessage>(aTrack));
+}
+
+void MediaTrackGraphImpl::RemoveTrack(MediaTrack* aTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_DIAGNOSTIC_ASSERT(mMainThreadTrackCount > 0);
+  if (--mMainThreadTrackCount == 0) {
+    LOG(LogLevel::Info, ("MediaTrackGraph %p, last track %p removed from "
+                         "main thread. Graph will shut down.",
+                         this, aTrack));
+    // Find the graph in the hash table and remove it.
+    for (auto iter = gGraphs.Iter(); !iter.Done(); iter.Next()) {
+      if (iter.UserData() == this) {
+        iter.Remove();
+        break;
+      }
+    }
+    // The graph thread will shut itself down soon, but won't be able to do
+    // that if JS continues to run.
+    InterruptJS();
+  }
+}
+
+auto MediaTrackGraph::NotifyWhenDeviceStarted(MediaTrack* aTrack)
+    -> RefPtr<GraphStartedPromise> {
+  MOZ_ASSERT(NS_IsMainThread());
+  MozPromiseHolder<GraphStartedPromise> h;
+  RefPtr<GraphStartedPromise> p = h.Ensure(__func__);
+  aTrack->GraphImpl()->NotifyWhenGraphStarted(aTrack, std::move(h));
+  return p;
+}
+
+void MediaTrackGraphImpl::NotifyWhenGraphStarted(
+    RefPtr<MediaTrack> aTrack,
+    MozPromiseHolder<GraphStartedPromise>&& aHolder) {
+  class GraphStartedNotificationControlMessage : public ControlMessage {
+    RefPtr<MediaTrack> mMediaTrack;
+    MozPromiseHolder<GraphStartedPromise> mHolder;
+
+   public:
+    GraphStartedNotificationControlMessage(
+        RefPtr<MediaTrack> aTrack,
+        MozPromiseHolder<GraphStartedPromise>&& aHolder)
+        : ControlMessage(nullptr),
+          mMediaTrack(std::move(aTrack)),
+          mHolder(std::move(aHolder)) {}
+    void Run() override {
+      TRACE("MTG::GraphStartedNotificationControlMessage ControlMessage");
+      // This runs on the graph thread, so when this runs, and the current
+      // driver is an AudioCallbackDriver, we know the audio hardware is
+      // started. If not, we are going to switch soon, keep reposting this
+      // ControlMessage.
+      MediaTrackGraphImpl* graphImpl = mMediaTrack->GraphImpl();
+      if (graphImpl->CurrentDriver()->AsAudioCallbackDriver() &&
+          graphImpl->CurrentDriver()->ThreadRunning() &&
+          !graphImpl->CurrentDriver()->AsAudioCallbackDriver()->OnFallback()) {
+        // Avoid Resolve's locking on the graph thread by doing it on main.
+        graphImpl->Dispatch(NS_NewRunnableFunction(
+            "MediaTrackGraphImpl::NotifyWhenGraphStarted::Resolver",
+            [holder = std::move(mHolder)]() mutable {
+              holder.Resolve(true, __func__);
+            }));
+      } else {
+        graphImpl->DispatchToMainThreadStableState(
+            NewRunnableMethod<
+                StoreCopyPassByRRef<RefPtr<MediaTrack>>,
+                StoreCopyPassByRRef<MozPromiseHolder<GraphStartedPromise>>>(
+                "MediaTrackGraphImpl::NotifyWhenGraphStarted", graphImpl,
+                &MediaTrackGraphImpl::NotifyWhenGraphStarted,
+                std::move(mMediaTrack), std::move(mHolder)));
+      }
+    }
+    void RunDuringShutdown() override {
+      mHolder.Reject(NS_ERROR_ILLEGAL_DURING_SHUTDOWN, __func__);
+    }
+  };
+
+  if (aTrack->IsDestroyed()) {
+    aHolder.Reject(NS_ERROR_NOT_AVAILABLE, __func__);
+    return;
+  }
+
+  MediaTrackGraphImpl* graph = aTrack->GraphImpl();
+  graph->AppendMessage(MakeUnique<GraphStartedNotificationControlMessage>(
+      std::move(aTrack), std::move(aHolder)));
+}
+
+class AudioContextOperationControlMessage : public ControlMessage {
+  using AudioContextOperationPromise =
+      MediaTrackGraph::AudioContextOperationPromise;
+
+ public:
+  AudioContextOperationControlMessage(
+      MediaTrack* aDestinationTrack, nsTArray<RefPtr<MediaTrack>> aTracks,
+      AudioContextOperation aOperation,
+      MozPromiseHolder<AudioContextOperationPromise>&& aHolder)
+      : ControlMessage(aDestinationTrack),
+        mTracks(std::move(aTracks)),
+        mAudioContextOperation(aOperation),
+        mHolder(std::move(aHolder)) {}
+  void Run() override {
+    TRACE_COMMENT("MTG::ApplyAudioContextOperationImpl ControlMessage",
+                  kAudioContextOptionsStrings[static_cast<uint8_t>(
+                      mAudioContextOperation)]);
+    mTrack->GraphImpl()->ApplyAudioContextOperationImpl(this);
+  }
+  void RunDuringShutdown() override {
+    MOZ_ASSERT(mAudioContextOperation == AudioContextOperation::Close,
+               "We should be reviving the graph?");
+    mHolder.Reject(false, __func__);
+  }
+
+  nsTArray<RefPtr<MediaTrack>> mTracks;
+  AudioContextOperation mAudioContextOperation;
+  MozPromiseHolder<AudioContextOperationPromise> mHolder;
+};
+
+void MediaTrackGraphImpl::ApplyAudioContextOperationImpl(
+    AudioContextOperationControlMessage* aMessage) {
+  MOZ_ASSERT(OnGraphThread());
+  // Initialize state to zero. This silences a GCC warning about uninitialized
+  // values, because although the switch below initializes state for all valid
+  // enum values, the actual value could be any integer that fits in the enum.
+  AudioContextState state{0};
+  switch (aMessage->mAudioContextOperation) {
+    // Suspend and Close operations may be performed immediately because no
+    // specific kind of GraphDriver is required.  CheckDriver() will schedule
+    // a change to a SystemCallbackDriver if all tracks are suspended.
+    case AudioContextOperation::Suspend:
+      state = AudioContextState::Suspended;
+      break;
+    case AudioContextOperation::Close:
+      state = AudioContextState::Closed;
+      break;
+    case AudioContextOperation::Resume:
+      // Resume operations require an AudioCallbackDriver.  CheckDriver() will
+      // schedule an AudioCallbackDriver if necessary and process pending
+      // operations if and when an AudioCallbackDriver is running.
+      mPendingResumeOperations.EmplaceBack(aMessage);
+      return;
+  }
+  // First resolve any pending Resume promises for the same AudioContext so as
+  // to resolve its associated promises in the same order as they were
+  // created.  These Resume operations are considered complete and immediately
+  // canceled by the Suspend or Close.
+  MediaTrack* destinationTrack = aMessage->GetTrack();
+  bool shrinking = false;
+  auto moveDest = mPendingResumeOperations.begin();
+  for (PendingResumeOperation& op : mPendingResumeOperations) {
+    if (op.DestinationTrack() == destinationTrack) {
+      op.Apply(this);
+      shrinking = true;
+      continue;
+    }
+    if (shrinking) {  // Fill-in gaps in the array.
+      *moveDest = std::move(op);
+    }
+    ++moveDest;
+  }
+  mPendingResumeOperations.TruncateLength(moveDest -
+                                          mPendingResumeOperations.begin());
+
+  for (MediaTrack* track : aMessage->mTracks) {
+    track->IncrementSuspendCount();
+  }
+  // Resolve after main thread state is up to date with completed processing.
+  DispatchToMainThreadStableState(NS_NewRunnableFunction(
+      "MediaTrackGraphImpl::ApplyAudioContextOperationImpl",
+      [holder = std::move(aMessage->mHolder), state]() mutable {
+        holder.Resolve(state, __func__);
+      }));
+}
+
+MediaTrackGraphImpl::PendingResumeOperation::PendingResumeOperation(
+    AudioContextOperationControlMessage* aMessage)
+    : mDestinationTrack(aMessage->GetTrack()),
+      mTracks(std::move(aMessage->mTracks)),
+      mHolder(std::move(aMessage->mHolder)) {
+  MOZ_ASSERT(aMessage->mAudioContextOperation == AudioContextOperation::Resume);
+}
+
+void MediaTrackGraphImpl::PendingResumeOperation::Apply(
+    MediaTrackGraphImpl* aGraph) {
+  MOZ_ASSERT(aGraph->OnGraphThread());
+  for (MediaTrack* track : mTracks) {
+    track->DecrementSuspendCount();
+  }
+  // The graph is provided through the parameter so that it is available even
+  // when the track is destroyed.
+  aGraph->DispatchToMainThreadStableState(NS_NewRunnableFunction(
+      "PendingResumeOperation::Apply", [holder = std::move(mHolder)]() mutable {
+        holder.Resolve(AudioContextState::Running, __func__);
+      }));
+}
+
+void MediaTrackGraphImpl::PendingResumeOperation::Abort() {
+  // The graph is shutting down before the operation completed.
+  MOZ_ASSERT(!mDestinationTrack->GraphImpl() ||
+             mDestinationTrack->GraphImpl()->LifecycleStateRef() ==
+                 MediaTrackGraphImpl::LIFECYCLE_WAITING_FOR_THREAD_SHUTDOWN);
+  mHolder.Reject(false, __func__);
+}
+
+auto MediaTrackGraph::ApplyAudioContextOperation(
+    MediaTrack* aDestinationTrack, nsTArray<RefPtr<MediaTrack>> aTracks,
+    AudioContextOperation aOperation) -> RefPtr<AudioContextOperationPromise> {
+  MozPromiseHolder<AudioContextOperationPromise> holder;
+  RefPtr<AudioContextOperationPromise> p = holder.Ensure(__func__);
+  MediaTrackGraphImpl* graphImpl = static_cast<MediaTrackGraphImpl*>(this);
+  graphImpl->AppendMessage(MakeUnique<AudioContextOperationControlMessage>(
+      aDestinationTrack, std::move(aTracks), aOperation, std::move(holder)));
+  return p;
+}
+
+uint32_t MediaTrackGraphImpl::AudioOutputChannelCount() const {
+  MOZ_ASSERT(OnGraphThread());
+  // The audio output channel count for a graph is the maximum of the output
+  // channel count of all the tracks that are in mAudioOutputs, or the max audio
+  // output channel count the machine can do, whichever is smaller.
+  uint32_t channelCount = 0;
+  for (auto& tkv : mAudioOutputs) {
+    channelCount = std::max(channelCount, tkv.mTrack->NumberOfChannels());
+  }
+  channelCount = std::min(channelCount, mMaxOutputChannelCount);
+  if (channelCount) {
+    return channelCount;
+  } else {
+    if (CurrentDriver()->AsAudioCallbackDriver()) {
+      return CurrentDriver()->AsAudioCallbackDriver()->OutputChannelCount();
+    }
+    return 2;
+  }
+}
+
+double MediaTrackGraph::AudioOutputLatency() {
+  return static_cast<MediaTrackGraphImpl*>(this)->AudioOutputLatency();
+}
+
+double MediaTrackGraphImpl::AudioOutputLatency() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (mAudioOutputLatency != 0.0) {
+    return mAudioOutputLatency;
+  }
+  MonitorAutoLock lock(mMonitor);
+  if (CurrentDriver()->AsAudioCallbackDriver()) {
+    mAudioOutputLatency = CurrentDriver()
+                              ->AsAudioCallbackDriver()
+                              ->AudioOutputLatency()
+                              .ToSeconds();
+  } else {
+    // Failure mode: return 0.0 if running on a normal thread.
+    mAudioOutputLatency = 0.0;
+  }
+
+  return mAudioOutputLatency;
+}
+
+bool MediaTrackGraph::IsNonRealtime() const {
+  return !static_cast<const MediaTrackGraphImpl*>(this)->mRealtime;
+}
+
+void MediaTrackGraph::StartNonRealtimeProcessing(uint32_t aTicksToProcess) {
+  MOZ_ASSERT(NS_IsMainThread(), "main thread only");
+
+  MediaTrackGraphImpl* graph = static_cast<MediaTrackGraphImpl*>(this);
+  NS_ASSERTION(!graph->mRealtime, "non-realtime only");
+
+  class Message : public ControlMessage {
+   public:
+    explicit Message(MediaTrackGraphImpl* aGraph, uint32_t aTicksToProcess)
+        : ControlMessage(nullptr),
+          mGraph(aGraph),
+          mTicksToProcess(aTicksToProcess) {}
+    void Run() override {
+      TRACE("MTG::StartNonRealtimeProcessing ControlMessage");
+      MOZ_ASSERT(mGraph->mEndTime == 0,
+                 "StartNonRealtimeProcessing should be called only once");
+      mGraph->mEndTime = mGraph->RoundUpToEndOfAudioBlock(
+          mGraph->mStateComputedTime + mTicksToProcess);
+    }
+    // The graph owns this message.
+    MediaTrackGraphImpl* MOZ_NON_OWNING_REF mGraph;
+    uint32_t mTicksToProcess;
+  };
+
+  graph->AppendMessage(MakeUnique<Message>(graph, aTicksToProcess));
+}
+
+void MediaTrackGraphImpl::InterruptJS() {
+  MonitorAutoLock lock(mMonitor);
+  mInterruptJSCalled = true;
+  if (mJSContext) {
+    JS_RequestInterruptCallback(mJSContext);
+  }
+}
+
+static bool InterruptCallback(JSContext* aCx) {
+  // Interrupt future calls also.
+  JS_RequestInterruptCallback(aCx);
+  // Stop execution.
+  return false;
+}
+
+void MediaTrackGraph::NotifyJSContext(JSContext* aCx) {
+  MOZ_ASSERT(OnGraphThread());
+  MOZ_ASSERT(aCx);
+
+  auto* impl = static_cast<MediaTrackGraphImpl*>(this);
+  MonitorAutoLock lock(impl->mMonitor);
+  if (impl->mJSContext) {
+    MOZ_ASSERT(impl->mJSContext == aCx);
+    return;
+  }
+  JS_AddInterruptCallback(aCx, InterruptCallback);
+  impl->mJSContext = aCx;
+  if (impl->mInterruptJSCalled) {
+    JS_RequestInterruptCallback(aCx);
+  }
+}
+
+void ProcessedMediaTrack::AddInput(MediaInputPort* aPort) {
+  MediaTrack* t = aPort->GetSource();
+  if (!t->IsSuspended()) {
+    mInputs.AppendElement(aPort);
+  } else {
+    mSuspendedInputs.AppendElement(aPort);
+  }
+  GraphImpl()->SetTrackOrderDirty();
+}
+
+void ProcessedMediaTrack::InputSuspended(MediaInputPort* aPort) {
+  GraphImpl()->AssertOnGraphThreadOrNotRunning();
+  mInputs.RemoveElement(aPort);
+  mSuspendedInputs.AppendElement(aPort);
+  GraphImpl()->SetTrackOrderDirty();
+}
+
+void ProcessedMediaTrack::InputResumed(MediaInputPort* aPort) {
+  GraphImpl()->AssertOnGraphThreadOrNotRunning();
+  mSuspendedInputs.RemoveElement(aPort);
+  mInputs.AppendElement(aPort);
+  GraphImpl()->SetTrackOrderDirty();
+}
+
+void MediaTrackGraphImpl::SwitchAtNextIteration(GraphDriver* aNextDriver) {
+  MOZ_ASSERT(OnGraphThread());
+  LOG(LogLevel::Debug, ("%p: Switching to new driver: %p", this, aNextDriver));
+  if (GraphDriver* nextDriver = NextDriver()) {
+    if (nextDriver != CurrentDriver()) {
+      LOG(LogLevel::Debug,
+          ("%p: Discarding previous next driver: %p", this, nextDriver));
+    }
+  }
+  mNextDriver = aNextDriver;
+}
+
+void MediaTrackGraph::RegisterCaptureTrackForWindow(
+    uint64_t aWindowId, ProcessedMediaTrack* aCaptureTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MediaTrackGraphImpl* graphImpl = static_cast<MediaTrackGraphImpl*>(this);
+  graphImpl->RegisterCaptureTrackForWindow(aWindowId, aCaptureTrack);
+}
+
+void MediaTrackGraphImpl::RegisterCaptureTrackForWindow(
+    uint64_t aWindowId, ProcessedMediaTrack* aCaptureTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  WindowAndTrack winAndTrack;
+  winAndTrack.mWindowId = aWindowId;
+  winAndTrack.mCaptureTrackSink = aCaptureTrack;
+  mWindowCaptureTracks.AppendElement(winAndTrack);
+}
+
+void MediaTrackGraph::UnregisterCaptureTrackForWindow(uint64_t aWindowId) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MediaTrackGraphImpl* graphImpl = static_cast<MediaTrackGraphImpl*>(this);
+  graphImpl->UnregisterCaptureTrackForWindow(aWindowId);
+}
+
+void MediaTrackGraphImpl::UnregisterCaptureTrackForWindow(uint64_t aWindowId) {
+  MOZ_ASSERT(NS_IsMainThread());
+  mWindowCaptureTracks.RemoveElementsBy(
+      [aWindowId](const auto& track) { return track.mWindowId == aWindowId; });
+}
+
+already_AddRefed<MediaInputPort> MediaTrackGraph::ConnectToCaptureTrack(
+    uint64_t aWindowId, MediaTrack* aMediaTrack) {
+  return aMediaTrack->GraphImpl()->ConnectToCaptureTrack(aWindowId,
+                                                         aMediaTrack);
+}
+
+already_AddRefed<MediaInputPort> MediaTrackGraphImpl::ConnectToCaptureTrack(
+    uint64_t aWindowId, MediaTrack* aMediaTrack) {
+  MOZ_ASSERT(NS_IsMainThread());
+  for (uint32_t i = 0; i < mWindowCaptureTracks.Length(); i++) {
+    if (mWindowCaptureTracks[i].mWindowId == aWindowId) {
+      ProcessedMediaTrack* sink = mWindowCaptureTracks[i].mCaptureTrackSink;
+      return sink->AllocateInputPort(aMediaTrack);
+    }
+  }
+  return nullptr;
+}
+
+void MediaTrackGraph::DispatchToMainThreadStableState(
+    already_AddRefed<nsIRunnable> aRunnable) {
+  AssertOnGraphThreadOrNotRunning();
+  static_cast<MediaTrackGraphImpl*>(this)
+      ->mPendingUpdateRunnables.AppendElement(std::move(aRunnable));
+}
+
+Watchable<mozilla::GraphTime>& MediaTrackGraphImpl::CurrentTime() {
+  MOZ_ASSERT(NS_IsMainThread());
+  return mMainThreadGraphTime;
+}
+
+GraphTime MediaTrackGraph::ProcessedTime() const {
+  AssertOnGraphThreadOrNotRunning();
+  return static_cast<const MediaTrackGraphImpl*>(this)->mProcessedTime;
+}
+
+uint32_t MediaTrackGraphImpl::AudioInputChannelCount(
+    CubebUtils::AudioDeviceID aID) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  DeviceInputTrack* t =
+      mDeviceInputTrackManagerGraphThread.GetDeviceInputTrack(aID);
+  return t ? t->MaxRequestedInputChannels() : 0;
+}
+
+AudioInputType MediaTrackGraphImpl::AudioInputDevicePreference(
+    CubebUtils::AudioDeviceID aID) {
+  MOZ_ASSERT(OnGraphThreadOrNotRunning());
+  DeviceInputTrack* t =
+      mDeviceInputTrackManagerGraphThread.GetDeviceInputTrack(aID);
+  return t && t->HasVoiceInput() ? AudioInputType::Voice
+                                 : AudioInputType::Unknown;
+}
+
+void MediaTrackGraphImpl::SetNewNativeInput() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!mDeviceInputTrackManagerMainThread.GetNativeInputTrack());
+
+  LOG(LogLevel::Debug, ("%p SetNewNativeInput", this));
+
+  NonNativeInputTrack* track =
+      mDeviceInputTrackManagerMainThread.GetFirstNonNativeInputTrack();
+  if (!track) {
+    LOG(LogLevel::Debug, ("%p No other devices opened. Do nothing", this));
+    return;
+  }
+
+  const CubebUtils::AudioDeviceID deviceId = track->mDeviceId;
+  const PrincipalHandle principal = track->mPrincipalHandle;
+
+  LOG(LogLevel::Debug,
+      ("%p Select device %p as the new native input device", this, deviceId));
+
+  struct TrackListener {
+    DeviceInputConsumerTrack* track;
+    // Keep its reference so it won't be dropped when after
+    // DisconnectDeviceInput().
+    RefPtr<AudioDataListener> listener;
+  };
+  nsTArray<TrackListener> pairs;
+
+  for (const auto& t : track->GetConsumerTracks()) {
+    pairs.AppendElement(
+        TrackListener{t.get(), t->GetAudioDataListener().get()});
+  }
+
+  for (TrackListener& pair : pairs) {
+    pair.track->DisconnectDeviceInput();
+  }
+
+  for (TrackListener& pair : pairs) {
+    pair.track->ConnectDeviceInput(deviceId, pair.listener.get(), principal);
+    LOG(LogLevel::Debug,
+        ("%p: Reinitialize AudioProcessingTrack %p for device %p", this,
+         pair.track, deviceId));
+  }
+
+  LOG(LogLevel::Debug,
+      ("%p Native input device is set to device %p now", this, deviceId));
+
+  MOZ_ASSERT(mDeviceInputTrackManagerMainThread.GetNativeInputTrack());
+}
+
+// nsIThreadObserver methods
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::OnDispatchedEvent() {
+  MonitorAutoLock lock(mMonitor);
+  EnsureNextIteration();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::OnProcessNextEvent(nsIThreadInternal*, bool) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MediaTrackGraphImpl::AfterProcessNextEvent(nsIThreadInternal*, bool) {
+  return NS_OK;
+}
+}  // namespace mozilla