--- a/dom/html/HTMLCanvasElement.cpp
+++ b/dom/html/HTMLCanvasElement.cpp
@@ -5,17 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/dom/HTMLCanvasElement.h"
 
 #include "ImageEncoder.h"
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "Layers.h"
-#include "MediaTrackGraph.h"
+#include "MediaStreamGraph.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Base64.h"
 #include "mozilla/CheckedInt.h"
 #include "mozilla/dom/CanvasCaptureMediaStream.h"
 #include "mozilla/dom/CanvasRenderingContext2D.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/File.h"
 #include "mozilla/dom/HTMLCanvasElementBinding.h"
@@ -677,25 +677,26 @@ already_AddRefed<CanvasCaptureMediaStrea
 
   if (!mCurrentContext) {
     aRv.Throw(NS_ERROR_NOT_INITIALIZED);
     return nullptr;
   }
 
   auto stream = MakeRefPtr<CanvasCaptureMediaStream>(window, this);
 
+  const TrackID videoTrackId = 1;
   nsCOMPtr<nsIPrincipal> principal = NodePrincipal();
-  nsresult rv = stream->Init(aFrameRate, principal);
+  nsresult rv = stream->Init(aFrameRate, videoTrackId, principal);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return nullptr;
   }
 
   RefPtr<MediaStreamTrack> track =
-      new VideoStreamTrack(window, stream->GetSourceStream(),
+      new VideoStreamTrack(window, stream->GetSourceStream(), videoTrackId,
                            new CanvasCaptureTrackSource(principal, stream));
   stream->AddTrackInternal(track);
 
   // Check site-specific permission and display prompt if appropriate.
   // If no permission, arrange for the frame capture listener to return
   // all-white, opaque image data.
   bool usePlaceholder = !CanvasUtils::IsImageExtractionAllowed(
       OwnerDoc(), nsContentUtils::GetCurrentJSContext(), aSubjectPrincipal);

--- a/dom/html/HTMLMediaElement.cpp
+++ b/dom/html/HTMLMediaElement.cpp
@@ -29,20 +29,19 @@
 #include "MediaContainerType.h"
 #include "MediaError.h"
 #include "MediaManager.h"
 #include "MediaMetadataManager.h"
 #include "MediaResource.h"
 #include "MediaShutdownManager.h"
 #include "MediaSourceDecoder.h"
 #include "MediaStreamError.h"
-#include "MediaTrackGraphImpl.h"
-#include "MediaTrackListener.h"
+#include "MediaStreamGraphImpl.h"
+#include "MediaStreamListener.h"
 #include "MediaStreamWindowCapturer.h"
-#include "MediaTrack.h"
 #include "MediaTrackList.h"
 #include "SVGObserverUtils.h"
 #include "TimeRanges.h"
 #include "VideoFrameContainer.h"
 #include "VideoOutput.h"
 #include "VideoStreamTrack.h"
 #include "base/basictypes.h"
 #include "jsapi.h"
@@ -385,17 +384,18 @@ class HTMLMediaElement::FirstFrameListen
                      AbstractThread* aMainThread)
       : VideoOutput(aContainer, aMainThread) {
     MOZ_ASSERT(NS_IsMainThread());
   }
 
   // NB that this overrides VideoOutput::NotifyRealtimeTrackData, so we can
   // filter out all frames but the first one with a real size. This allows us to
   // later re-use the logic in VideoOutput for rendering that frame.
-  void NotifyRealtimeTrackData(MediaTrackGraph* aGraph, TrackTime aTrackOffset,
+  void NotifyRealtimeTrackData(MediaStreamGraph* aGraph,
+                               StreamTime aTrackOffset,
                                const MediaSegment& aMedia) override {
     MOZ_ASSERT(aMedia.GetType() == MediaSegment::VIDEO);
 
     if (mInitialSizeFound) {
       return;
     }
 
     const VideoSegment& video = static_cast<const VideoSegment&>(aMedia);
@@ -412,17 +412,17 @@ class HTMLMediaElement::FirstFrameListen
         VideoOutput::NotifyRealtimeTrackData(aGraph, aTrackOffset, segment);
         return;
       }
     }
   }
 
  private:
   // Whether a frame with a concrete size has been received. May only be
-  // accessed on the MTG's appending thread. (this is a direct listener so we
+  // accessed on the MSG's appending thread. (this is a direct listener so we
   // get called by whoever is producing this track's data)
   bool mInitialSizeFound = false;
 };
 
 /**
  * Helper class that manages audio and video outputs for all enabled tracks in a
  * media element. It also manages calculating the current time when playing a
  * MediaStream.
@@ -436,31 +436,31 @@ class HTMLMediaElement::MediaStreamRende
                       VideoFrameContainer* aVideoContainer,
                       void* aAudioOutputKey)
       : mVideoContainer(aVideoContainer),
         mAudioOutputKey(aAudioOutputKey),
         mWatchManager(this, aMainThread) {}
 
   void UpdateGraphTime() {
     mGraphTime =
-        mGraphTimeDummy->mTrack->Graph()->CurrentTime() - *mGraphTimeOffset;
+        mGraphTimeDummy->mStream->Graph()->CurrentTime() - *mGraphTimeOffset;
   }
 
   void Start() {
     if (mRendering) {
       return;
     }
 
     mRendering = true;
 
     if (!mGraphTimeDummy) {
       return;
     }
 
-    MediaTrackGraph* graph = mGraphTimeDummy->mTrack->Graph();
+    MediaStreamGraph* graph = mGraphTimeDummy->mStream->Graph();
     mGraphTimeOffset = Some(graph->CurrentTime().Ref() - mGraphTime);
     mWatchManager.Watch(graph->CurrentTime(),
                         &MediaStreamRenderer::UpdateGraphTime);
 
     for (const auto& t : mAudioTracks) {
       if (t) {
         t->AsAudioStreamTrack()->AddAudioOutput(mAudioOutputKey);
         t->AsAudioStreamTrack()->SetAudioOutputVolume(mAudioOutputKey,
@@ -479,17 +479,17 @@ class HTMLMediaElement::MediaStreamRende
     }
 
     mRendering = false;
 
     if (!mGraphTimeDummy) {
       return;
     }
 
-    mWatchManager.Unwatch(mGraphTimeDummy->mTrack->Graph()->CurrentTime(),
+    mWatchManager.Unwatch(mGraphTimeDummy->mStream->Graph()->CurrentTime(),
                           &MediaStreamRenderer::UpdateGraphTime);
 
     for (const auto& t : mAudioTracks) {
       if (t) {
         t->AsAudioStreamTrack()->RemoveAudioOutput(mAudioOutputKey);
       }
     }
 
@@ -553,17 +553,18 @@ class HTMLMediaElement::MediaStreamRende
     mVideoTrack = nullptr;
   }
 
   double CurrentTime() const {
     if (!mGraphTimeDummy) {
       return 0.0;
     }
 
-    return mGraphTimeDummy->mTrack->GraphImpl()->MediaTimeToSeconds(mGraphTime);
+    return mGraphTimeDummy->mStream->GraphImpl()->MediaTimeToSeconds(
+        mGraphTime);
   }
 
   Watchable<GraphTime>& CurrentGraphTime() { return mGraphTime; }
 
   // Set if we're rendering video.
   const RefPtr<VideoFrameContainer> mVideoContainer;
 
   // Set if we're rendering audio, nullptr otherwise.
@@ -584,35 +585,35 @@ class HTMLMediaElement::MediaStreamRende
     MOZ_DIAGNOSTIC_ASSERT(!mVideoTrack);
   }
 
   void EnsureGraphTimeDummy() {
     if (mGraphTimeDummy) {
       return;
     }
 
-    MediaTrackGraph* graph = nullptr;
+    MediaStreamGraph* graph = nullptr;
     for (const auto& t : mAudioTracks) {
       if (t && !t->Ended()) {
         graph = t->Graph();
         break;
       }
     }
 
     if (!graph && mVideoTrack && !mVideoTrack->Ended()) {
       graph = mVideoTrack->Graph();
     }
 
     if (!graph) {
       return;
     }
 
     // This dummy keeps `graph` alive and ensures access to it.
-    mGraphTimeDummy = MakeRefPtr<SharedDummyTrack>(
-        graph->CreateSourceTrack(MediaSegment::AUDIO));
+    mGraphTimeDummy =
+        MakeRefPtr<SharedDummyStream>(graph->CreateSourceStream());
 
     if (mRendering) {
       mGraphTimeOffset = Some(graph->CurrentTime() - mGraphTime);
       mWatchManager.Watch(graph->CurrentTime(),
                           &MediaStreamRenderer::UpdateGraphTime);
     }
   }
 
@@ -621,20 +622,20 @@ class HTMLMediaElement::MediaStreamRende
   bool mRendering = false;
 
   // The audio output volume for all audio tracks.
   float mAudioOutputVolume = 1.0f;
 
   // WatchManager for mGraphTime.
   WatchManager<MediaStreamRenderer> mWatchManager;
 
-  // A dummy MediaTrack to guarantee a MediaTrackGraph is kept alive while
+  // A dummy MediaStream to guarantee a MediaStreamGraph is kept alive while
   // we're actively rendering, so we can track the graph's current time. Set
   // when the first track is added, never unset.
-  RefPtr<SharedDummyTrack> mGraphTimeDummy;
+  RefPtr<SharedDummyStream> mGraphTimeDummy;
 
   // Watchable that relays the graph's currentTime updates to the media element
   // only while we're rendering. This is the current time of the rendering in
   // GraphTime units.
   Watchable<GraphTime> mGraphTime = {0, "MediaStreamRenderer::mGraphTime"};
 
   // Nothing until a track has been added. Then, the current GraphTime at the
   // time when we were last Start()ed.
@@ -651,45 +652,46 @@ class HTMLMediaElement::StreamCaptureTra
     : public MediaStreamTrackSource,
       public MediaStreamTrackSource::Sink {
  public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(StreamCaptureTrackSource,
                                            MediaStreamTrackSource)
 
   StreamCaptureTrackSource(MediaStreamTrackSource* aCapturedTrackSource,
-                           ProcessedMediaTrack* aStream, MediaInputPort* aPort)
+                           ProcessedMediaStream* aStream, MediaInputPort* aPort)
       : MediaStreamTrackSource(aCapturedTrackSource->GetPrincipal(),
                                nsString()),
         mCapturedTrackSource(aCapturedTrackSource),
-        mTrack(aStream),
+        mStream(aStream),
         mPort(aPort) {
     MOZ_ASSERT(mCapturedTrackSource);
-    MOZ_ASSERT(mTrack);
+    MOZ_ASSERT(mStream);
     MOZ_ASSERT(mPort);
 
     mCapturedTrackSource->RegisterSink(this);
   }
 
   void SetEnabled(bool aEnabled) {
-    if (!mTrack) {
+    if (!mStream) {
       return;
     }
-    mTrack->SetEnabled(aEnabled ? DisabledTrackMode::ENABLED
-                                : DisabledTrackMode::SILENCE_FREEZE);
+    mStream->SetTrackEnabled(mPort->GetDestinationTrackId(),
+                             aEnabled ? DisabledTrackMode::ENABLED
+                                      : DisabledTrackMode::SILENCE_FREEZE);
   }
 
   void Destroy() override {
     if (mCapturedTrackSource) {
       mCapturedTrackSource->UnregisterSink(this);
       mCapturedTrackSource = nullptr;
     }
-    if (mTrack) {
-      mTrack->Destroy();
-      mTrack = nullptr;
+    if (mStream) {
+      mStream->Destroy();
+      mStream = nullptr;
     }
     if (mPort) {
       mPort->Destroy();
       mPort = nullptr;
     }
   }
 
   MediaSourceEnum GetMediaSource() const override {
@@ -740,22 +742,22 @@ class HTMLMediaElement::StreamCaptureTra
 
     Destroy();
     MediaStreamTrackSource::OverrideEnded();
   }
 
  private:
   virtual ~StreamCaptureTrackSource() {
     MOZ_ASSERT(!mCapturedTrackSource);
-    MOZ_ASSERT(!mTrack);
+    MOZ_ASSERT(!mStream);
     MOZ_ASSERT(!mPort);
   };
 
   RefPtr<MediaStreamTrackSource> mCapturedTrackSource;
-  RefPtr<ProcessedMediaTrack> mTrack;
+  RefPtr<ProcessedMediaStream> mStream;
   RefPtr<MediaInputPort> mPort;
 };
 
 NS_IMPL_ADDREF_INHERITED(HTMLMediaElement::StreamCaptureTrackSource,
                          MediaStreamTrackSource)
 NS_IMPL_RELEASE_INHERITED(HTMLMediaElement::StreamCaptureTrackSource,
                           MediaStreamTrackSource)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
@@ -1075,29 +1077,29 @@ class HTMLMediaElement::AudioChannelAgen
                  "this = %p, Error : unknown suspended type!\n",
                  this));
     }
     return NS_OK;
   }
 
   NS_IMETHODIMP WindowAudioCaptureChanged(bool aCapture) override {
     MOZ_ASSERT(mAudioChannelAgent);
-    AudioCaptureTrackChangeIfNeeded();
+    AudioCaptureStreamChangeIfNeeded();
     return NS_OK;
   }
 
-  void AudioCaptureTrackChangeIfNeeded() {
+  void AudioCaptureStreamChangeIfNeeded() {
     MOZ_ASSERT(!mIsShutDown);
     if (!IsPlayingStarted()) {
       return;
     }
 
     MOZ_ASSERT(mAudioChannelAgent);
     bool isCapturing = mAudioChannelAgent->IsWindowAudioCapturingEnabled();
-    mOwner->AudioCaptureTrackChange(isCapturing);
+    mOwner->AudioCaptureStreamChange(isCapturing);
   }
 
   void NotifyAudioPlaybackChanged(AudibleChangedReasons aReason) {
     MOZ_ASSERT(!mIsShutDown);
     if (!IsPlayingStarted()) {
       return;
     }
 
@@ -1169,18 +1171,18 @@ class HTMLMediaElement::AudioChannelAgen
   }
 
   void StopAudioChanelAgent() {
     MOZ_ASSERT(mAudioChannelAgent);
     MOZ_ASSERT(mAudioChannelAgent->IsPlayingStarted());
     mAudioChannelAgent->NotifyStoppedPlaying();
     NotifyMediaStopped(mAudioChannelAgent->WindowID());
     // If we have started audio capturing before, we have to tell media element
-    // to clear the output capturing track.
-    mOwner->AudioCaptureTrackChange(false);
+    // to clear the output capturing stream.
+    mOwner->AudioCaptureStreamChange(false);
   }
 
   void SetSuspended(SuspendTypes aSuspend) {
     if (mSuspended == aSuspend) {
       return;
     }
 
     MaybeNotifyMediaResumed(aSuspend);
@@ -1898,17 +1900,17 @@ void HTMLMediaElement::AbortExistingLoad
   // We need to remove FirstFrameListener before VideoTracks get emptied.
   if (mFirstFrameListener) {
     mSelectedVideoStreamTrack->RemoveVideoOutput(mFirstFrameListener);
     mFirstFrameListener = nullptr;
   }
 
   // When aborting the existing loads, empty the objects in audio track list and
   // video track list, no events (in particular, no removetrack events) are
-  // fired as part of this. Ending MediaTrack sends track ended notifications,
+  // fired as part of this. Ending MediaStream sends track ended notifications,
   // so we empty the track lists prior.
   if (AudioTracks()) {
     AudioTracks()->EmptyTracks();
   }
   if (VideoTracks()) {
     VideoTracks()->EmptyTracks();
   }
 
@@ -2259,17 +2261,17 @@ void HTMLMediaElement::NotifyLoadError(c
   } else if (mSourceLoadCandidate) {
     DispatchAsyncSourceError(mSourceLoadCandidate);
     QueueLoadFromSourceTask();
   } else {
     NS_WARNING("Should know the source we were loading from!");
   }
 }
 
-void HTMLMediaElement::NotifyMediaTrackEnabled(dom::MediaTrack* aTrack) {
+void HTMLMediaElement::NotifyMediaTrackEnabled(MediaTrack* aTrack) {
   MOZ_ASSERT(aTrack);
   if (!aTrack) {
     return;
   }
 #ifdef DEBUG
   nsString id;
   aTrack->GetId(id);
 
@@ -2331,17 +2333,17 @@ void HTMLMediaElement::NotifyMediaTrackE
         // If the output stream is for audio only we ignore video tracks.
         continue;
       }
       AddCaptureMediaTrackToOutputStream(aTrack, ms);
     }
   }
 }
 
-void HTMLMediaElement::NotifyMediaTrackDisabled(dom::MediaTrack* aTrack) {
+void HTMLMediaElement::NotifyMediaTrackDisabled(MediaTrack* aTrack) {
   MOZ_ASSERT(aTrack);
   if (!aTrack) {
     return;
   }
 #ifdef DEBUG
   nsString id;
   aTrack->GetId(id);
 
@@ -2401,17 +2403,17 @@ void HTMLMediaElement::NotifyMediaTrackD
       continue;
     }
     MOZ_ASSERT(ms.mCapturingMediaStream);
     for (int32_t i = ms.mTracks.Length() - 1; i >= 0; --i) {
       if (ms.mTracks[i].first() != aTrack->GetId()) {
         continue;
       }
       // The source of this track just ended. Force-notify that it ended.
-      // If we bounce it to the MediaTrackGraph it might not be picked up,
+      // If we bounce it to the MediaStreamGraph it might not be picked up,
       // for instance if the MediaInputPort was destroyed in the same
       // iteration as it was added.
       mMainThreadEventTarget->Dispatch(NewRunnableMethod(
           "StreamCaptureTrackSource::OverrideEnded",
           static_cast<StreamCaptureTrackSource*>(ms.mTracks[i].second().get()),
           &StreamCaptureTrackSource::OverrideEnded));
 
       ms.mTracks.RemoveElementAt(i);
@@ -3155,18 +3157,17 @@ void HTMLMediaElement::SetCapturedOutput
       LOG(LogLevel::Debug, ("%s track %p for captured MediaStream %p",
                             aEnabled ? "Enabled" : "Disabled",
                             pair.second().get(), ms.mStream.get()));
     }
   }
 }
 
 void HTMLMediaElement::AddCaptureMediaTrackToOutputStream(
-    dom::MediaTrack* aTrack, OutputMediaStream& aOutputStream,
-    bool aAsyncAddtrack) {
+    MediaTrack* aTrack, OutputMediaStream& aOutputStream, bool aAsyncAddtrack) {
   if (aOutputStream.mCapturingDecoder) {
     MOZ_ASSERT(!aOutputStream.mCapturingMediaStream);
     return;
   }
   aOutputStream.mCapturingMediaStream = true;
 
   if (aOutputStream.mStream == mSrcStream) {
     // Cycle detected. This can happen since tracks are added async.
@@ -3187,52 +3188,50 @@ void HTMLMediaElement::AddCaptureMediaTr
   }
   MOZ_DIAGNOSTIC_ASSERT(!inputTrack->Ended());
 
   nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
   if (!window) {
     return;
   }
 
-  MediaSegment::Type type = inputTrack->AsAudioStreamTrack()
-                                ? MediaSegment::AUDIO
-                                : MediaSegment::VIDEO;
-  ProcessedMediaTrack* track =
-      inputTrack->Graph()->CreateForwardedInputTrack(type);
-  RefPtr<MediaInputPort> port = inputTrack->ForwardTrackContentsTo(track);
+  ProcessedMediaStream* stream = inputTrack->Graph()->CreateTrackUnionStream();
+  RefPtr<MediaInputPort> port = inputTrack->ForwardTrackContentsTo(stream);
   auto source = MakeRefPtr<StreamCaptureTrackSource>(&inputTrack->GetSource(),
-                                                     track, port);
+                                                     stream, port);
 
   // Track is muted initially, so we don't leak data if it's added while paused
-  // and an MTG iteration passes before the mute comes into effect.
+  // and an MSG iteration passes before the mute comes into effect.
   source->SetEnabled(mSrcStreamIsPlaying);
 
-  RefPtr<MediaStreamTrack> domTrack;
+  RefPtr<MediaStreamTrack> track;
   if (inputTrack->AsAudioStreamTrack()) {
-    domTrack = new AudioStreamTrack(window, track, source);
+    track =
+        new AudioStreamTrack(window, stream, inputTrack->GetTrackID(), source);
   } else {
-    domTrack = new VideoStreamTrack(window, track, source);
+    track =
+        new VideoStreamTrack(window, stream, inputTrack->GetTrackID(), source);
   }
 
   aOutputStream.mTracks.AppendElement(
       Pair<nsString, RefPtr<MediaStreamTrackSource>>(aTrack->GetId(),
                                                      source.get()));
 
   if (aAsyncAddtrack) {
     mMainThreadEventTarget->Dispatch(
         NewRunnableMethod<StoreRefPtrPassByPtr<MediaStreamTrack>>(
             "DOMMediaStream::AddTrackInternal", aOutputStream.mStream,
-            &DOMMediaStream::AddTrackInternal, domTrack));
+            &DOMMediaStream::AddTrackInternal, track));
   } else {
-    aOutputStream.mStream->AddTrackInternal(domTrack);
+    aOutputStream.mStream->AddTrackInternal(track);
   }
 
   LOG(LogLevel::Debug,
       ("Created %s track %p from track %p through MediaInputPort %p",
-       inputTrack->AsAudioStreamTrack() ? "audio" : "video", domTrack.get(),
+       inputTrack->AsAudioStreamTrack() ? "audio" : "video", track.get(),
        inputTrack, port.get()));
 }
 
 void HTMLMediaElement::DiscardFinishWhenEndedOutputStreams() {
   // Discard all output streams that have finished now.
   for (int32_t i = mOutputStreams.Length() - 1; i >= 0; --i) {
     if (!mOutputStreams[i].mFinishWhenEnded) {
       continue;
@@ -3260,35 +3259,35 @@ bool HTMLMediaElement::CanBeCaptured(Str
       ContainsRestrictedContent()) {
     return false;
   }
   return true;
 }
 
 already_AddRefed<DOMMediaStream> HTMLMediaElement::CaptureStreamInternal(
     StreamCaptureBehavior aFinishBehavior, StreamCaptureType aStreamCaptureType,
-    MediaTrackGraph* aGraph) {
+    MediaStreamGraph* aGraph) {
   MOZ_RELEASE_ASSERT(aGraph);
   MOZ_ASSERT(CanBeCaptured(aStreamCaptureType));
 
   MarkAsContentSource(CallerAPI::CAPTURE_STREAM);
   MarkAsTainted();
 
   // We don't support routing to a different graph.
   if (!mOutputStreams.IsEmpty() &&
-      aGraph != mOutputStreams[0].mGraphKeepAliveDummyStream->mTrack->Graph()) {
+      aGraph !=
+          mOutputStreams[0].mGraphKeepAliveDummyStream->mStream->Graph()) {
     return nullptr;
   }
 
   OutputMediaStream* out = mOutputStreams.AppendElement();
   nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
   out->mGraphKeepAliveDummyStream =
       mOutputStreams.Length() == 1
-          ? MakeRefPtr<SharedDummyTrack>(
-                aGraph->CreateSourceTrack(MediaSegment::AUDIO))
+          ? MakeRefPtr<SharedDummyStream>(aGraph->CreateSourceStream())
           : mOutputStreams[0].mGraphKeepAliveDummyStream;
   out->mStream = MakeAndAddRef<DOMMediaStream>(window);
   out->mStream->SetFinishedOnInactive(false);
   out->mFinishWhenEnded =
       aFinishBehavior == StreamCaptureBehavior::FINISH_WHEN_ENDED;
   out->mCapturingAudioOnly =
       aStreamCaptureType == StreamCaptureType::CAPTURE_AUDIO;
 
@@ -3339,17 +3338,17 @@ already_AddRefed<DOMMediaStream> HTMLMed
       }
     }
   }
   RefPtr<DOMMediaStream> result = out->mStream;
   return result.forget();
 }
 
 already_AddRefed<DOMMediaStream> HTMLMediaElement::CaptureAudio(
-    ErrorResult& aRv, MediaTrackGraph* aGraph) {
+    ErrorResult& aRv, MediaStreamGraph* aGraph) {
   MOZ_RELEASE_ASSERT(aGraph);
 
   if (!CanBeCaptured(StreamCaptureType::CAPTURE_AUDIO)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
   RefPtr<DOMMediaStream> stream =
@@ -3372,64 +3371,64 @@ RefPtr<GenericNonExclusivePromise> HTMLM
     return GenericNonExclusivePromise::CreateAndResolve(true, __func__);
   }
   AUTOPLAY_LOG("create allow-to-play promise for MediaElement %p", this);
   return mAllowedToPlayPromise.Ensure(__func__);
 }
 
 already_AddRefed<DOMMediaStream> HTMLMediaElement::MozCaptureStream(
     ErrorResult& aRv) {
-  MediaTrackGraph::GraphDriverType graphDriverType =
-      HasAudio() ? MediaTrackGraph::AUDIO_THREAD_DRIVER
-                 : MediaTrackGraph::SYSTEM_THREAD_DRIVER;
+  MediaStreamGraph::GraphDriverType graphDriverType =
+      HasAudio() ? MediaStreamGraph::AUDIO_THREAD_DRIVER
+                 : MediaStreamGraph::SYSTEM_THREAD_DRIVER;
 
   nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
   if (!window) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
   if (!CanBeCaptured(StreamCaptureType::CAPTURE_ALL_TRACKS)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
-  MediaTrackGraph* graph = MediaTrackGraph::GetInstance(
-      graphDriverType, window, MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE);
+  MediaStreamGraph* graph = MediaStreamGraph::GetInstance(
+      graphDriverType, window, MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
 
   RefPtr<DOMMediaStream> stream =
       CaptureStreamInternal(StreamCaptureBehavior::CONTINUE_WHEN_ENDED,
                             StreamCaptureType::CAPTURE_ALL_TRACKS, graph);
   if (!stream) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
   return stream.forget();
 }
 
 already_AddRefed<DOMMediaStream> HTMLMediaElement::MozCaptureStreamUntilEnded(
     ErrorResult& aRv) {
-  MediaTrackGraph::GraphDriverType graphDriverType =
-      HasAudio() ? MediaTrackGraph::AUDIO_THREAD_DRIVER
-                 : MediaTrackGraph::SYSTEM_THREAD_DRIVER;
+  MediaStreamGraph::GraphDriverType graphDriverType =
+      HasAudio() ? MediaStreamGraph::AUDIO_THREAD_DRIVER
+                 : MediaStreamGraph::SYSTEM_THREAD_DRIVER;
 
   nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
   if (!window) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
   if (!CanBeCaptured(StreamCaptureType::CAPTURE_ALL_TRACKS)) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
-  MediaTrackGraph* graph = MediaTrackGraph::GetInstance(
-      graphDriverType, window, MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE);
+  MediaStreamGraph* graph = MediaStreamGraph::GetInstance(
+      graphDriverType, window, MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
 
   RefPtr<DOMMediaStream> stream =
       CaptureStreamInternal(StreamCaptureBehavior::FINISH_WHEN_ENDED,
                             StreamCaptureType::CAPTURE_ALL_TRACKS, graph);
   if (!stream) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
@@ -4846,17 +4845,17 @@ void HTMLMediaElement::UpdateSrcMediaStr
         mSelectedVideoStreamTrack->AddVideoOutput(mFirstFrameListener);
       }
     }
 
     SetCapturedOutputStreamsEnabled(false);  // Mute
   }
 }
 
-void HTMLMediaElement::UpdateSrcTrackTime() {
+void HTMLMediaElement::UpdateSrcStreamTime() {
   MOZ_ASSERT(NS_IsMainThread());
 
   if (mSrcStreamPlaybackEnded) {
     // We do a separate FireTimeUpdate() when this is set.
     return;
   }
 
   FireTimeUpdate(true);
@@ -4871,17 +4870,17 @@ void HTMLMediaElement::SetupSrcMediaStre
   nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
   if (!window) {
     return;
   }
 
   mMediaStreamRenderer = MakeAndAddRef<MediaStreamRenderer>(
       mAbstractMainThread, GetVideoFrameContainer(), this);
   mWatchManager.Watch(mMediaStreamRenderer->CurrentGraphTime(),
-                      &HTMLMediaElement::UpdateSrcTrackTime);
+                      &HTMLMediaElement::UpdateSrcStreamTime);
   SetVolumeInternal();
 
   UpdateSrcMediaStreamPlaying();
   mSrcStreamVideoPrincipal = NodePrincipal();
 
   // If we pause this media element, track changes in the underlying stream
   // will continue to fire events at this element and alter its track list.
   // That's simpler than delaying the events, but probably confusing...
@@ -4911,17 +4910,17 @@ void HTMLMediaElement::EndSrcMediaStream
   if (mFirstFrameListener) {
     mSelectedVideoStreamTrack->RemoveVideoOutput(mFirstFrameListener);
   }
   mSelectedVideoStreamTrack = nullptr;
   mFirstFrameListener = nullptr;
 
   if (mMediaStreamRenderer) {
     mWatchManager.Unwatch(mMediaStreamRenderer->CurrentGraphTime(),
-                          &HTMLMediaElement::UpdateSrcTrackTime);
+                          &HTMLMediaElement::UpdateSrcStreamTime);
     mMediaStreamRenderer = nullptr;
   }
 
   mSrcStream->UnregisterTrackListener(mMediaStreamTrackListener.get());
   mMediaStreamTrackListener = nullptr;
   mSrcStreamTracksAvailable = false;
   mSrcStreamPlaybackEnded = false;
   mSrcStreamVideoPrincipal = nullptr;
@@ -4990,17 +4989,17 @@ void HTMLMediaElement::NotifyMediaStream
     MOZ_DIAGNOSTIC_ASSERT(VideoTracks(), "Element can't have been unlinked");
     RefPtr<VideoTrack> videoTrack =
         CreateVideoTrack(t, VideoTracks()->GetOwnerGlobal());
     VideoTracks()->AddTrack(videoTrack);
     // New MediaStreamTrack added, set the new added video track as selected
     // video track when there is no selected track.
     if (VideoTracks()->SelectedIndex() == -1) {
       MOZ_ASSERT(!mSelectedVideoStreamTrack);
-      videoTrack->SetEnabledInternal(true, dom::MediaTrack::FIRE_NO_EVENTS);
+      videoTrack->SetEnabledInternal(true, MediaTrack::FIRE_NO_EVENTS);
     }
   }
 
   UpdateReadyStateInternal();
 
   if (!mSrcStreamTracksAvailable) {
     mAbstractMainThread->Dispatch(NS_NewRunnableFunction(
         "HTMLMediaElement::NotifyMediaStreamTrackAdded->FirstFrameLoaded",
@@ -5028,19 +5027,19 @@ void HTMLMediaElement::NotifyMediaStream
   aTrack->GetId(id);
 
   LOG(LogLevel::Debug, ("%p, Removing %sTrack with id %s", this,
                         aTrack->AsAudioStreamTrack() ? "Audio" : "Video",
                         NS_ConvertUTF16toUTF8(id).get()));
 
   MOZ_DIAGNOSTIC_ASSERT(AudioTracks() && VideoTracks(),
                         "Element can't have been unlinked");
-  if (dom::MediaTrack* t = AudioTracks()->GetTrackById(id)) {
+  if (MediaTrack* t = AudioTracks()->GetTrackById(id)) {
     AudioTracks()->RemoveTrack(t);
-  } else if (dom::MediaTrack* t = VideoTracks()->GetTrackById(id)) {
+  } else if (MediaTrack* t = VideoTracks()->GetTrackById(id)) {
     VideoTracks()->RemoveTrack(t);
   } else {
     NS_ASSERTION(aTrack->AsVideoStreamTrack() && !IsVideo(),
                  "MediaStreamTrack ended but did not exist in track lists. "
                  "This is only allowed if a video element ends and we are an "
                  "audio element.");
     return;
   }
@@ -7022,39 +7021,39 @@ bool HTMLMediaElement::ShouldElementBePa
 
 void HTMLMediaElement::SetMediaInfo(const MediaInfo& aInfo) {
   const bool oldHasAudio = mMediaInfo.HasAudio();
   mMediaInfo = aInfo;
   if ((aInfo.HasAudio() != oldHasAudio) && mResumeDelayedPlaybackAgent) {
     mResumeDelayedPlaybackAgent->UpdateAudibleState(this, IsAudible());
   }
   if (mAudioChannelWrapper) {
-    mAudioChannelWrapper->AudioCaptureTrackChangeIfNeeded();
+    mAudioChannelWrapper->AudioCaptureStreamChangeIfNeeded();
   }
   UpdateWakeLock();
 }
 
-void HTMLMediaElement::AudioCaptureTrackChange(bool aCapture) {
+void HTMLMediaElement::AudioCaptureStreamChange(bool aCapture) {
   // No need to capture a silent media element.
   if (!HasAudio()) {
     return;
   }
 
   if (aCapture && !mStreamWindowCapturer) {
     nsPIDOMWindowInner* window = OwnerDoc()->GetInnerWindow();
     if (!window) {
       return;
     }
 
-    MediaTrackGraph* mtg = MediaTrackGraph::GetInstance(
-        MediaTrackGraph::AUDIO_THREAD_DRIVER, window,
-        MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE);
+    MediaStreamGraph* msg = MediaStreamGraph::GetInstance(
+        MediaStreamGraph::AUDIO_THREAD_DRIVER, window,
+        MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
     RefPtr<DOMMediaStream> stream =
         CaptureStreamInternal(StreamCaptureBehavior::CONTINUE_WHEN_ENDED,
-                              StreamCaptureType::CAPTURE_AUDIO, mtg);
+                              StreamCaptureType::CAPTURE_AUDIO, msg);
     mStreamWindowCapturer =
         MakeUnique<MediaStreamWindowCapturer>(stream, window->WindowID());
   } else if (!aCapture && mStreamWindowCapturer) {
     for (size_t i = 0; i < mOutputStreams.Length(); i++) {
       if (mOutputStreams[i].mStream == mStreamWindowCapturer->mStream) {
         if (mOutputStreams[i].mCapturingDecoder && mDecoder) {
           mDecoder->RemoveOutputStream(mOutputStreams[i].mStream);
         }
@@ -7349,17 +7348,17 @@ already_AddRefed<Promise> HTMLMediaEleme
                       return SinkInfoPromise::CreateAndResolve(aInfo, __func__);
                     }
                     return SinkInfoPromise::CreateAndReject(
                         aValue.RejectValue(), __func__);
                   });
               return p;
             }
             if (self->mSrcAttrStream) {
-              // Set Sink Id through MTG is not supported yet.
+              // Set Sink Id through MSG is not supported yet.
               return SinkInfoPromise::CreateAndReject(NS_ERROR_ABORT, __func__);
             }
             // No media attached to the element save it for later.
             return SinkInfoPromise::CreateAndResolve(aInfo, __func__);
           },
           [](nsresult res) {
             // Promise is rejected, sink not found.
             return SinkInfoPromise::CreateAndReject(res, __func__);

--- a/dom/html/HTMLMediaElement.h
+++ b/dom/html/HTMLMediaElement.h
@@ -48,20 +48,20 @@ namespace mozilla {
 class AbstractThread;
 class ChannelMediaDecoder;
 class DecoderDoctorDiagnostics;
 class DOMMediaStream;
 class ErrorResult;
 class MediaResource;
 class MediaDecoder;
 class MediaInputPort;
-class MediaTrack;
-class MediaTrackGraph;
+class MediaStream;
+class MediaStreamGraph;
 class MediaStreamWindowCapturer;
-struct SharedDummyTrack;
+struct SharedDummyStream;
 class VideoFrameContainer;
 namespace dom {
 class MediaKeys;
 class TextTrack;
 class TimeRanges;
 class WakeLock;
 class MediaStreamTrack;
 class MediaStreamTrackSource;
@@ -104,16 +104,17 @@ class HTMLMediaElement : public nsGeneri
                          public MediaDecoderOwner,
                          public PrincipalChangeObserver<MediaStreamTrack>,
                          public SupportsWeakPtr<HTMLMediaElement>,
                          public nsStubMutationObserver {
  public:
   typedef mozilla::TimeStamp TimeStamp;
   typedef mozilla::layers::ImageContainer ImageContainer;
   typedef mozilla::VideoFrameContainer VideoFrameContainer;
+  typedef mozilla::MediaStream MediaStream;
   typedef mozilla::MediaResource MediaResource;
   typedef mozilla::MediaDecoderOwner MediaDecoderOwner;
   typedef mozilla::MetadataTags MetadataTags;
 
   MOZ_DECLARE_WEAKREFERENCE_TYPENAME(HTMLMediaElement)
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
 
   CORSMode GetCORSMode() { return mCORSMode; }
@@ -329,23 +330,23 @@ class HTMLMediaElement : public nsGeneri
    * whether it's appropriate to fire an error event.
    */
   void NotifyLoadError(const nsACString& aErrorDetails = nsCString());
 
   /**
    * Called by one of our associated MediaTrackLists (audio/video) when an
    * AudioTrack is enabled or a VideoTrack is selected.
    */
-  void NotifyMediaTrackEnabled(dom::MediaTrack* aTrack);
+  void NotifyMediaTrackEnabled(MediaTrack* aTrack);
 
   /**
    * Called by one of our associated MediaTrackLists (audio/video) when an
    * AudioTrack is disabled or a VideoTrack is unselected.
    */
-  void NotifyMediaTrackDisabled(dom::MediaTrack* aTrack);
+  void NotifyMediaTrackDisabled(MediaTrack* aTrack);
 
   /**
    * Returns the current load ID. Asynchronous events store the ID that was
    * current when they were enqueued, and if it has changed when they come to
    * fire, they consider themselves cancelled, and don't fire.
    */
   uint32_t GetCurrentLoadID() { return mCurrentLoadID; }
 
@@ -607,17 +608,17 @@ class HTMLMediaElement : public nsGeneri
   // in the URL bar of the browser window.
   already_AddRefed<nsIPrincipal> GetTopLevelPrincipal();
 
   bool ContainsRestrictedContent();
 
   void NotifyWaitingForKey() override;
 
   already_AddRefed<DOMMediaStream> CaptureAudio(ErrorResult& aRv,
-                                                MediaTrackGraph* aGraph);
+                                                MediaStreamGraph* aGraph);
 
   already_AddRefed<DOMMediaStream> MozCaptureStream(ErrorResult& aRv);
 
   already_AddRefed<DOMMediaStream> MozCaptureStreamUntilEnded(ErrorResult& aRv);
 
   bool MozAudioCaptured() const { return mAudioCaptured; }
 
   void MozGetMetadata(JSContext* aCx, JS::MutableHandle<JSObject*> aResult,
@@ -749,17 +750,17 @@ class HTMLMediaElement : public nsGeneri
   struct OutputMediaStream {
     OutputMediaStream();
     ~OutputMediaStream();
 
     RefPtr<DOMMediaStream> mStream;
     // Dummy stream to keep mGraph from shutting down when MediaDecoder shuts
     // down. Shared across all OutputMediaStreams as one stream is enough to
     // keep the graph alive.
-    RefPtr<SharedDummyTrack> mGraphKeepAliveDummyStream;
+    RefPtr<SharedDummyStream> mGraphKeepAliveDummyStream;
     bool mFinishWhenEnded;
     bool mCapturingAudioOnly;
     bool mCapturingDecoder;
     bool mCapturingMediaStream;
 
     // The following members are keeping state for a captured MediaStream.
     nsTArray<Pair<nsString, RefPtr<MediaStreamTrackSource>>> mTracks;
   };
@@ -824,17 +825,17 @@ class HTMLMediaElement : public nsGeneri
    */
   enum { REMOVING_SRC_STREAM = 0x1 };
   void UpdateSrcMediaStreamPlaying(uint32_t aFlags = 0);
 
   /**
    * mSrcStream's graph's CurrentTime() has been updated. It might be time to
    * fire "timeupdate".
    */
-  void UpdateSrcTrackTime();
+  void UpdateSrcStreamTime();
 
   /**
    * Called by our DOMMediaStream::TrackListener when a new MediaStreamTrack has
    * been added to the playback stream of |mSrcStream|.
    */
   void NotifyMediaStreamTrackAdded(const RefPtr<MediaStreamTrack>& aTrack);
 
   /**
@@ -852,17 +853,17 @@ class HTMLMediaElement : public nsGeneri
    */
   void SetCapturedOutputStreamsEnabled(bool aEnabled);
 
   /**
    * Create a new MediaStreamTrack for aTrack and add it to the DOMMediaStream
    * in aOutputStream. This automatically sets the output track to enabled or
    * disabled depending on our current playing state.
    */
-  void AddCaptureMediaTrackToOutputStream(dom::MediaTrack* aTrack,
+  void AddCaptureMediaTrackToOutputStream(MediaTrack* aTrack,
                                           OutputMediaStream& aOutputStream,
                                           bool aAsyncAddtrack = true);
 
   /**
    * Discard all output streams that are flagged to finish when playback ends.
    */
   void DiscardFinishWhenEndedOutputStreams();
 
@@ -874,17 +875,17 @@ class HTMLMediaElement : public nsGeneri
    * The stream will never finish.
    *
    * When aType is CAPTURE_AUDIO, we stop playout of audio and instead route it
    * to the DOMMediaStream. Volume and mute state will be applied to the audio
    * reaching the stream. No video tracks will be captured in this case.
    */
   already_AddRefed<DOMMediaStream> CaptureStreamInternal(
       StreamCaptureBehavior aBehavior, StreamCaptureType aType,
-      MediaTrackGraph* aGraph);
+      MediaStreamGraph* aGraph);
 
   /**
    * Initialize a decoder as a clone of an existing decoder in another
    * element.
    * mLoadingSrc must already be set.
    */
   nsresult InitializeDecoderAsClone(ChannelMediaDecoder* aOriginal);
 
@@ -1187,17 +1188,17 @@ class HTMLMediaElement : public nsGeneri
   // Recomputes ready state and fires events as necessary based on current
   // state.
   void UpdateReadyStateInternal();
 
   // Determine if the element should be paused because of suspend conditions.
   bool ShouldElementBePaused();
 
   // Create or destroy the captured stream.
-  void AudioCaptureTrackChange(bool aCapture);
+  void AudioCaptureStreamChange(bool aCapture);
 
   // A method to check whether the media element is allowed to start playback.
   bool AudioChannelAgentBlockedPlay();
 
   // If the network state is empty and then we would trigger DoLoad().
   void MaybeDoLoad();
 
   // Anything we need to check after played success and not related with spec.
@@ -1299,24 +1300,25 @@ class HTMLMediaElement : public nsGeneri
 
   // The DocGroup-specific AbstractThread::MainThread() of this HTML element.
   RefPtr<AbstractThread> mAbstractMainThread;
 
   // A reference to the VideoFrameContainer which contains the current frame
   // of video to display.
   RefPtr<VideoFrameContainer> mVideoFrameContainer;
 
-  // Holds a reference to the MediaStream that has been set in the src
-  // attribute.
+  // Holds a reference to the DOM wrapper for the MediaStream that has been
+  // set in the src attribute.
   RefPtr<DOMMediaStream> mSrcAttrStream;
 
   // Holds the triggering principal for the src attribute.
   nsCOMPtr<nsIPrincipal> mSrcAttrTriggeringPrincipal;
 
-  // Holds a reference to the MediaStream that we're actually playing.
+  // Holds a reference to the DOM wrapper for the MediaStream that we're
+  // actually playing.
   // At most one of mDecoder and mSrcStream can be non-null.
   RefPtr<DOMMediaStream> mSrcStream;
 
   // The MediaStreamRenderer handles rendering of our selected video track, and
   // enabled audio tracks, while mSrcStream is set.
   RefPtr<MediaStreamRenderer> mMediaStreamRenderer;
 
   // True once mSrcStream's initial set of tracks are known.

--- a/dom/media/AudioBufferUtils.h
+++ b/dom/media/AudioBufferUtils.h
@@ -95,20 +95,20 @@ class AudioCallbackBufferWrapper {
   }
 
   /**
    * Check that the buffer is completly filled, and reset internal state so this
    * instance can be reused.
    */
   void BufferFilled() {
     // It's okay to have exactly zero samples here, it can happen we have an
-    // audio callback driver because of a hint on MTG creation, but the
-    // AudioOutputStream has not been created yet, or if all the tracks have
+    // audio callback driver because of a hint on MSG creation, but the
+    // AudioOutputStream has not been created yet, or if all the streams have
     // finished but we're still running. Note: it's also ok if we had data in
-    // the scratch buffer - and we usually do - and all the tracks were ended
+    // the scratch buffer - and we usually do - and all the streams were ended
     // (no mixer callback occured).
     // XXX Remove this warning, or find a way to avoid it if the mixer callback
     // isn't called.
     NS_WARNING_ASSERTION(
         Available() == 0 || mSampleWriteOffset == 0,
         "Audio Buffer is not full by the end of the callback.");
     // Make sure the data returned is always set and not random!
     if (Available()) {
@@ -130,17 +130,17 @@ class AudioCallbackBufferWrapper {
   /* The position at which new samples should be written. We want to return to
    * the audio callback iff this is equal to mSamples. */
   uint32_t mSampleWriteOffset;
   uint32_t mChannels;
 };
 
 /**
  * This is a class that interfaces with the AudioCallbackBufferWrapper, and is
- * responsible for storing the excess of data produced by the MediaTrackGraph
+ * responsible for storing the excess of data produced by the MediaStreamGraph
  * because of different rounding constraints, to be used the next time the audio
  * backend calls back.
  */
 template <typename T, uint32_t BLOCK_SIZE>
 class SpillBuffer {
  public:
   SpillBuffer() : mBuffer(nullptr), mPosition(0), mChannels(0) {}
 

rename from dom/media/AudioCaptureTrack.cpp
rename to dom/media/AudioCaptureStream.cpp
--- a/dom/media/AudioCaptureTrack.cpp
+++ b/dom/media/AudioCaptureStream.cpp
@@ -1,115 +1,124 @@
 /* -*- 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 "MediaTrackListener.h"
+#include "MediaStreamGraphImpl.h"
+#include "MediaStreamListener.h"
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/Unused.h"
 
 #include "AudioSegment.h"
 #include "mozilla/Logging.h"
 #include "mozilla/Attributes.h"
-#include "AudioCaptureTrack.h"
+#include "AudioCaptureStream.h"
 #include "ImageContainer.h"
 #include "AudioNodeEngine.h"
-#include "AudioNodeTrack.h"
-#include "AudioNodeExternalInputTrack.h"
+#include "AudioNodeStream.h"
+#include "AudioNodeExternalInputStream.h"
 #include "webaudio/MediaStreamAudioDestinationNode.h"
 #include <algorithm>
 #include "DOMMediaStream.h"
 
 using namespace mozilla::layers;
 using namespace mozilla::dom;
 using namespace mozilla::gfx;
 
 namespace mozilla {
 
 // We are mixing to mono until PeerConnection can accept stereo
 static const uint32_t MONO = 1;
 
-AudioCaptureTrack::AudioCaptureTrack(TrackRate aRate)
-    : ProcessedMediaTrack(aRate, MediaSegment::AUDIO, new AudioSegment()),
-      mStarted(false) {
+AudioCaptureStream::AudioCaptureStream(TrackID aTrackId)
+    : ProcessedMediaStream(), mTrackId(aTrackId), mStarted(false) {
   MOZ_ASSERT(NS_IsMainThread());
-  MOZ_COUNT_CTOR(AudioCaptureTrack);
+  MOZ_COUNT_CTOR(AudioCaptureStream);
   mMixer.AddCallback(this);
 }
 
-AudioCaptureTrack::~AudioCaptureTrack() {
-  MOZ_COUNT_DTOR(AudioCaptureTrack);
+AudioCaptureStream::~AudioCaptureStream() {
+  MOZ_COUNT_DTOR(AudioCaptureStream);
   mMixer.RemoveCallback(this);
 }
 
-void AudioCaptureTrack::Start() {
+void AudioCaptureStream::Start() {
   class Message : public ControlMessage {
    public:
-    explicit Message(AudioCaptureTrack* aTrack)
-        : ControlMessage(aTrack), mTrack(aTrack) {}
+    explicit Message(AudioCaptureStream* aStream)
+        : ControlMessage(aStream), mStream(aStream) {}
 
-    virtual void Run() { mTrack->mStarted = true; }
+    virtual void Run() { mStream->mStarted = true; }
 
    protected:
-    AudioCaptureTrack* mTrack;
+    AudioCaptureStream* mStream;
   };
   GraphImpl()->AppendMessage(MakeUnique<Message>(this));
 }
 
-void AudioCaptureTrack::ProcessInput(GraphTime aFrom, GraphTime aTo,
-                                     uint32_t aFlags) {
+void AudioCaptureStream::ProcessInput(GraphTime aFrom, GraphTime aTo,
+                                      uint32_t aFlags) {
   if (!mStarted) {
     return;
   }
 
   uint32_t inputCount = mInputs.Length();
+  StreamTracks::Track* track = EnsureTrack(mTrackId);
 
-  if (mEnded) {
+  if (IsFinishedOnGraphThread()) {
     return;
   }
 
-  // If the captured track is connected back to a object on the page (be it an
-  // HTMLMediaElement with a track as source, or an AudioContext), a cycle
+  // If the captured stream is connected back to a object on the page (be it an
+  // HTMLMediaElement with a stream as source, or an AudioContext), a cycle
   // situation occur. This can work if it's an AudioContext with at least one
-  // DelayNode, but the MTG will mute the whole cycle otherwise.
+  // DelayNode, but the MSG will mute the whole cycle otherwise.
   if (InMutedCycle() || inputCount == 0) {
-    GetData<AudioSegment>()->AppendNullData(aTo - aFrom);
+    track->Get<AudioSegment>()->AppendNullData(aTo - aFrom);
   } else {
     // We mix down all the tracks of all inputs, to a stereo track. Everything
     // is {up,down}-mixed to stereo.
     mMixer.StartMixing();
     AudioSegment output;
     for (uint32_t i = 0; i < inputCount; i++) {
-      MediaTrack* s = mInputs[i]->GetSource();
-      AudioSegment* inputSegment = s->GetData<AudioSegment>();
-      TrackTime inputStart = s->GraphTimeToTrackTimeWithBlocking(aFrom);
-      TrackTime inputEnd = s->GraphTimeToTrackTimeWithBlocking(aTo);
-      AudioSegment toMix;
-      if (s->Ended() && inputSegment->GetDuration() <= inputStart) {
+      MediaStream* s = mInputs[i]->GetSource();
+      StreamTracks::TrackIter track(s->GetStreamTracks(), MediaSegment::AUDIO);
+      if (track.IsEnded()) {
+        // No tracks for this input. Still we append data to trigger the mixer.
+        AudioSegment toMix;
         toMix.AppendNullData(aTo - aFrom);
-      } else {
-        toMix.AppendSlice(*inputSegment, inputStart, inputEnd);
-        // Care for tracks blocked in the [aTo, aFrom] range.
-        if (inputEnd - inputStart < aTo - aFrom) {
-          toMix.AppendNullData((aTo - aFrom) - (inputEnd - inputStart));
+        toMix.Mix(mMixer, MONO, Graph()->GraphRate());
+      }
+      for (; !track.IsEnded(); track.Next()) {
+        AudioSegment* inputSegment = track->Get<AudioSegment>();
+        StreamTime inputStart = s->GraphTimeToStreamTimeWithBlocking(aFrom);
+        StreamTime inputEnd = s->GraphTimeToStreamTimeWithBlocking(aTo);
+        AudioSegment toMix;
+        if (track->IsEnded() && inputSegment->GetDuration() <= inputStart) {
+          toMix.AppendNullData(aTo - aFrom);
+        } else {
+          toMix.AppendSlice(*inputSegment, inputStart, inputEnd);
+          // Care for streams blocked in the [aTo, aFrom] range.
+          if (inputEnd - inputStart < aTo - aFrom) {
+            toMix.AppendNullData((aTo - aFrom) - (inputEnd - inputStart));
+          }
         }
+        toMix.Mix(mMixer, MONO, Graph()->GraphRate());
       }
-      toMix.Mix(mMixer, MONO, Graph()->GraphRate());
     }
     // This calls MixerCallback below
     mMixer.FinishMixing();
   }
 }
 
-void AudioCaptureTrack::MixerCallback(AudioDataValue* aMixedBuffer,
-                                      AudioSampleFormat aFormat,
-                                      uint32_t aChannels, uint32_t aFrames,
-                                      uint32_t aSampleRate) {
+void AudioCaptureStream::MixerCallback(AudioDataValue* aMixedBuffer,
+                                       AudioSampleFormat aFormat,
+                                       uint32_t aChannels, uint32_t aFrames,
+                                       uint32_t aSampleRate) {
   AutoTArray<nsTArray<AudioDataValue>, MONO> output;
   AutoTArray<const AudioDataValue*, MONO> bufferPtrs;
   output.SetLength(MONO);
   bufferPtrs.SetLength(MONO);
 
   uint32_t written = 0;
   // We need to copy here, because the mixer will reuse the storage, we should
   // not hold onto it. Buffers are in planar format.
@@ -124,12 +133,12 @@ void AudioCaptureTrack::MixerCallback(Au
       new mozilla::SharedChannelArrayBuffer<AudioDataValue>(&output);
   chunk.mDuration = aFrames;
   chunk.mBufferFormat = aFormat;
   chunk.mChannelData.SetLength(MONO);
   for (uint32_t channel = 0; channel < aChannels; channel++) {
     chunk.mChannelData[channel] = bufferPtrs[channel];
   }
 
-  // Now we have mixed data, simply append it.
-  GetData<AudioSegment>()->AppendAndConsumeChunk(&chunk);
+  // Now we have mixed data, simply append it to out track.
+  EnsureTrack(mTrackId)->Get<AudioSegment>()->AppendAndConsumeChunk(&chunk);
 }
 }  // namespace mozilla

rename from dom/media/AudioCaptureTrack.h
rename to dom/media/AudioCaptureStream.h
--- a/dom/media/AudioCaptureTrack.h
+++ b/dom/media/AudioCaptureStream.h
@@ -1,41 +1,43 @@
 /* -*- 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/. */
 
-#ifndef MOZILLA_AUDIOCAPTURETRACK_H_
-#define MOZILLA_AUDIOCAPTURETRACK_H_
+#ifndef MOZILLA_AUDIOCAPTURESTREAM_H_
+#define MOZILLA_AUDIOCAPTURESTREAM_H_
 
-#include "MediaTrackGraph.h"
+#include "MediaStreamGraph.h"
 #include "AudioMixer.h"
+#include "StreamTracks.h"
 #include <algorithm>
 
 namespace mozilla {
 
 class AbstractThread;
 class DOMMediaStream;
 
 /**
- * See MediaTrackGraph::CreateAudioCaptureTrack.
+ * See MediaStreamGraph::CreateAudioCaptureStream.
  */
-class AudioCaptureTrack : public ProcessedMediaTrack,
-                          public MixerCallbackReceiver {
+class AudioCaptureStream : public ProcessedMediaStream,
+                           public MixerCallbackReceiver {
  public:
-  explicit AudioCaptureTrack(TrackRate aRate);
-  virtual ~AudioCaptureTrack();
+  explicit AudioCaptureStream(TrackID aTrackId);
+  virtual ~AudioCaptureStream();
 
   void Start();
 
   void ProcessInput(GraphTime aFrom, GraphTime aTo, uint32_t aFlags) override;
 
  protected:
   void MixerCallback(AudioDataValue* aMixedBuffer, AudioSampleFormat aFormat,
                      uint32_t aChannels, uint32_t aFrames,
                      uint32_t aSampleRate) override;
   AudioMixer mMixer;
+  TrackID mTrackId;
   bool mStarted;
   bool mTrackCreated;
 };
 }  // namespace mozilla
 
-#endif /* MOZILLA_AUDIOCAPTURETRACK_H_ */
+#endif /* MOZILLA_AUDIOCAPTURESTREAM_H_ */

--- a/dom/media/AudioSampleFormat.h
+++ b/dom/media/AudioSampleFormat.h
@@ -7,17 +7,17 @@
 #define MOZILLA_AUDIOSAMPLEFORMAT_H_
 
 #include "mozilla/Assertions.h"
 #include <algorithm>
 
 namespace mozilla {
 
 /**
- * Audio formats supported in MediaTracks and media elements.
+ * Audio formats supported in MediaStreams and media elements.
  *
  * Only one of these is supported by AudioStream, and that is determined
  * at compile time (roughly, FLOAT32 on desktops, S16 on mobile). Media decoders
  * produce that format only; queued AudioData always uses that format.
  */
 enum AudioSampleFormat {
   // Silence: format will be chosen later
   AUDIO_FORMAT_SILENCE,

--- a/dom/media/AudioSegment.h
+++ b/dom/media/AudioSegment.h
@@ -144,30 +144,30 @@ void DownmixAndInterleave(const nsTArray
  * pointers so it can represent a subinterval of a buffer without copying.
  * An AudioChunk can store its individual channels anywhere; it maintains
  * separate pointers to each channel's buffer.
  */
 struct AudioChunk {
   typedef mozilla::AudioSampleFormat SampleFormat;
 
   // Generic methods
-  void SliceTo(TrackTime aStart, TrackTime aEnd) {
+  void SliceTo(StreamTime aStart, StreamTime aEnd) {
     MOZ_ASSERT(aStart >= 0 && aStart < aEnd && aEnd <= mDuration,
                "Slice out of bounds");
     if (mBuffer) {
       MOZ_ASSERT(aStart < INT32_MAX,
                  "Can't slice beyond 32-bit sample lengths");
       for (uint32_t channel = 0; channel < mChannelData.Length(); ++channel) {
         mChannelData[channel] = AddAudioSampleOffset(
             mChannelData[channel], mBufferFormat, int32_t(aStart));
       }
     }
     mDuration = aEnd - aStart;
   }
-  TrackTime GetDuration() const { return mDuration; }
+  StreamTime GetDuration() const { return mDuration; }
   bool CanCombineWithFollowing(const AudioChunk& aOther) const {
     if (aOther.mBuffer != mBuffer) {
       return false;
     }
     if (!mBuffer) {
       return true;
     }
     if (aOther.mVolume != mVolume) {
@@ -188,17 +188,17 @@ struct AudioChunk {
           AddAudioSampleOffset(mChannelData[channel], mBufferFormat,
                                int32_t(mDuration))) {
         return false;
       }
     }
     return true;
   }
   bool IsNull() const { return mBuffer == nullptr; }
-  void SetNull(TrackTime aDuration) {
+  void SetNull(StreamTime aDuration) {
     mBuffer = nullptr;
     mChannelData.Clear();
     mDuration = aDuration;
     mVolume = 1.0f;
     mBufferFormat = AUDIO_FORMAT_SILENCE;
     mPrincipalHandle = PRINCIPAL_HANDLE_NONE;
   }
 
@@ -257,17 +257,17 @@ struct AudioChunk {
   T* ChannelDataForWrite(size_t aChannel) {
     MOZ_ASSERT(AudioSampleTypeToFormat<T>::Format == mBufferFormat);
     MOZ_ASSERT(!mBuffer->IsShared());
     return static_cast<T*>(const_cast<void*>(mChannelData[aChannel]));
   }
 
   const PrincipalHandle& GetPrincipalHandle() const { return mPrincipalHandle; }
 
-  TrackTime mDuration = 0;             // in frames within the buffer
+  StreamTime mDuration = 0;            // in frames within the buffer
   RefPtr<ThreadSharedObject> mBuffer;  // the buffer object whose lifetime is
                                        // managed; null means data is all zeroes
   // one pointer per channel; empty if and only if mBuffer is null
   AutoTArray<const void*, GUESS_AUDIO_CHANNELS> mChannelData;
   float mVolume = 1.0f;  // volume multiplier to apply
   // format of frames in mBuffer (or silence if mBuffer is null)
   SampleFormat mBufferFormat = AUDIO_FORMAT_SILENCE;
   // principalHandle for the data in this chunk.

--- a/dom/media/AudioStreamTrack.cpp
+++ b/dom/media/AudioStreamTrack.cpp
@@ -1,49 +1,49 @@
 /* -*- 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 "AudioStreamTrack.h"
 
-#include "MediaTrackGraph.h"
+#include "MediaStreamGraph.h"
 #include "nsContentUtils.h"
 
 namespace mozilla {
 namespace dom {
 
 void AudioStreamTrack::AddAudioOutput(void* aKey) {
   if (Ended()) {
     return;
   }
-  mTrack->AddAudioOutput(aKey);
+  mStream->AddAudioOutput(aKey);
 }
 
 void AudioStreamTrack::RemoveAudioOutput(void* aKey) {
   if (Ended()) {
     return;
   }
-  mTrack->RemoveAudioOutput(aKey);
+  mStream->RemoveAudioOutput(aKey);
 }
 
 void AudioStreamTrack::SetAudioOutputVolume(void* aKey, float aVolume) {
   if (Ended()) {
     return;
   }
-  mTrack->SetAudioOutputVolume(aKey, aVolume);
+  mStream->SetAudioOutputVolume(aKey, aVolume);
 }
 
 void AudioStreamTrack::GetLabel(nsAString& aLabel, CallerType aCallerType) {
   if (nsContentUtils::ResistFingerprinting(aCallerType)) {
     aLabel.AssignLiteral("Internal Microphone");
     return;
   }
   MediaStreamTrack::GetLabel(aLabel, aCallerType);
 }
 
 already_AddRefed<MediaStreamTrack> AudioStreamTrack::CloneInternal() {
-  return do_AddRef(new AudioStreamTrack(mWindow, mInputTrack, mSource,
-                                        ReadyState(), mConstraints));
+  return do_AddRef(new AudioStreamTrack(mWindow, mInputStream, mTrackID,
+                                        mSource, ReadyState(), mConstraints));
 }
 
 }  // namespace dom
 }  // namespace mozilla

--- a/dom/media/AudioStreamTrack.h
+++ b/dom/media/AudioStreamTrack.h
@@ -10,21 +10,21 @@
 #include "DOMMediaStream.h"
 
 namespace mozilla {
 namespace dom {
 
 class AudioStreamTrack : public MediaStreamTrack {
  public:
   AudioStreamTrack(
-      nsPIDOMWindowInner* aWindow, mozilla::MediaTrack* aInputTrack,
+      nsPIDOMWindowInner* aWindow, MediaStream* aInputStream, TrackID aTrackID,
       MediaStreamTrackSource* aSource,
       MediaStreamTrackState aReadyState = MediaStreamTrackState::Live,
       const MediaTrackConstraints& aConstraints = MediaTrackConstraints())
-      : MediaStreamTrack(aWindow, aInputTrack, aSource, aReadyState,
+      : MediaStreamTrack(aWindow, aInputStream, aTrackID, aSource, aReadyState,
                          aConstraints) {}
 
   AudioStreamTrack* AsAudioStreamTrack() override { return this; }
   const AudioStreamTrack* AsAudioStreamTrack() const override { return this; }
 
   void AddAudioOutput(void* aKey);
   void RemoveAudioOutput(void* aKey);
   void SetAudioOutputVolume(void* aKey, float aVolume);

--- a/dom/media/CanvasCaptureMediaStream.cpp
+++ b/dom/media/CanvasCaptureMediaStream.cpp
@@ -2,38 +2,41 @@
 /* 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 "CanvasCaptureMediaStream.h"
 
 #include "DOMMediaStream.h"
 #include "ImageContainer.h"
-#include "MediaTrackGraph.h"
-#include "Tracing.h"
-#include "VideoSegment.h"
+#include "MediaStreamGraph.h"
 #include "gfxPlatform.h"
 #include "mozilla/Atomics.h"
 #include "mozilla/dom/CanvasCaptureMediaStreamBinding.h"
 #include "mozilla/gfx/2D.h"
 #include "nsContentUtils.h"
+#include "Tracing.h"
 
 using namespace mozilla::layers;
 using namespace mozilla::gfx;
 
 namespace mozilla {
 namespace dom {
 
-OutputStreamDriver::OutputStreamDriver(SourceMediaTrack* aSourceStream,
+OutputStreamDriver::OutputStreamDriver(SourceMediaStream* aSourceStream,
+                                       const TrackID& aTrackId,
                                        const PrincipalHandle& aPrincipalHandle)
     : FrameCaptureListener(),
+      mTrackId(aTrackId),
       mSourceStream(aSourceStream),
       mPrincipalHandle(aPrincipalHandle) {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(mSourceStream);
+  MOZ_ASSERT(IsTrackIDExplicit(mTrackId));
+  mSourceStream->AddTrack(aTrackId, new VideoSegment());
 
   // All CanvasCaptureMediaStreams shall at least get one frame.
   mFrameCaptureRequested = true;
 }
 
 OutputStreamDriver::~OutputStreamDriver() {
   MOZ_ASSERT(NS_IsMainThread());
   EndTrack();
@@ -45,31 +48,32 @@ void OutputStreamDriver::EndTrack() {
     mSourceStream->Destroy();
   }
 }
 
 void OutputStreamDriver::SetImage(const RefPtr<layers::Image>& aImage,
                                   const TimeStamp& aTime) {
   MOZ_ASSERT(NS_IsMainThread());
 
-  TRACE_COMMENT("SourceMediaTrack %p", mSourceStream.get());
+  TRACE_COMMENT("SourceMediaStream %p track %i", mSourceStream.get(), mTrackId);
 
   VideoSegment segment;
   segment.AppendFrame(do_AddRef(aImage), aImage->GetSize(), mPrincipalHandle,
                       false, aTime);
-  mSourceStream->AppendData(&segment);
+  mSourceStream->AppendToTrack(mTrackId, &segment);
 }
 
 // ----------------------------------------------------------------------
 
 class TimerDriver : public OutputStreamDriver {
  public:
-  explicit TimerDriver(SourceMediaTrack* aSourceStream, const double& aFPS,
+  explicit TimerDriver(SourceMediaStream* aSourceStream, const double& aFPS,
+                       const TrackID& aTrackId,
                        const PrincipalHandle& aPrincipalHandle)
-      : OutputStreamDriver(aSourceStream, aPrincipalHandle),
+      : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle),
         mFPS(aFPS),
         mTimer(nullptr) {
     if (mFPS == 0.0) {
       return;
     }
 
     NS_NewTimerWithFuncCallback(
         getter_AddRefs(mTimer), &TimerTick, this, int(1000 / mFPS),
@@ -109,19 +113,19 @@ class TimerDriver : public OutputStreamD
   const double mFPS;
   nsCOMPtr<nsITimer> mTimer;
 };
 
 // ----------------------------------------------------------------------
 
 class AutoDriver : public OutputStreamDriver {
  public:
-  explicit AutoDriver(SourceMediaTrack* aSourceStream,
+  explicit AutoDriver(SourceMediaStream* aSourceStream, const TrackID& aTrackId,
                       const PrincipalHandle& aPrincipalHandle)
-      : OutputStreamDriver(aSourceStream, aPrincipalHandle) {}
+      : OutputStreamDriver(aSourceStream, aTrackId, aPrincipalHandle) {}
 
   void NewFrame(already_AddRefed<Image> aImage,
                 const TimeStamp& aTime) override {
     // Don't reset `mFrameCaptureRequested` since AutoDriver shall always have
     // `mFrameCaptureRequested` set to true.
     // This also means we should accept every frame as NewFrame is called only
     // after something changed.
 
@@ -161,30 +165,32 @@ JSObject* CanvasCaptureMediaStream::Wrap
 
 void CanvasCaptureMediaStream::RequestFrame() {
   if (mOutputStreamDriver) {
     mOutputStreamDriver->RequestFrameCapture();
   }
 }
 
 nsresult CanvasCaptureMediaStream::Init(const dom::Optional<double>& aFPS,
+                                        const TrackID aTrackId,
                                         nsIPrincipal* aPrincipal) {
-  MediaTrackGraph* graph = MediaTrackGraph::GetInstance(
-      MediaTrackGraph::SYSTEM_THREAD_DRIVER, mWindow,
-      MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE);
-  SourceMediaTrack* source = graph->CreateSourceTrack(MediaSegment::VIDEO);
+  MediaStreamGraph* graph = MediaStreamGraph::GetInstance(
+      MediaStreamGraph::SYSTEM_THREAD_DRIVER, mWindow,
+      MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
+  SourceMediaStream* source = graph->CreateSourceStream();
   PrincipalHandle principalHandle = MakePrincipalHandle(aPrincipal);
   if (!aFPS.WasPassed()) {
-    mOutputStreamDriver = new AutoDriver(source, principalHandle);
+    mOutputStreamDriver = new AutoDriver(source, aTrackId, principalHandle);
   } else if (aFPS.Value() < 0) {
     return NS_ERROR_ILLEGAL_VALUE;
   } else {
     // Cap frame rate to 60 FPS for sanity
     double fps = std::min(60.0, aFPS.Value());
-    mOutputStreamDriver = new TimerDriver(source, fps, principalHandle);
+    mOutputStreamDriver =
+        new TimerDriver(source, fps, aTrackId, principalHandle);
   }
   return NS_OK;
 }
 
 FrameCaptureListener* CanvasCaptureMediaStream::FrameCaptureListener() {
   return mOutputStreamDriver;
 }
 
@@ -193,17 +199,17 @@ void CanvasCaptureMediaStream::StopCaptu
     return;
   }
 
   mOutputStreamDriver->EndTrack();
   mOutputStreamDriver->Forget();
   mOutputStreamDriver = nullptr;
 }
 
-SourceMediaTrack* CanvasCaptureMediaStream::GetSourceStream() const {
+SourceMediaStream* CanvasCaptureMediaStream::GetSourceStream() const {
   if (!mOutputStreamDriver) {
     return nullptr;
   }
   return mOutputStreamDriver->mSourceStream;
 }
 
 }  // namespace dom
 }  // namespace mozilla

--- a/dom/media/CanvasCaptureMediaStream.h
+++ b/dom/media/CanvasCaptureMediaStream.h
@@ -3,23 +3,23 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_dom_CanvasCaptureMediaStream_h_
 #define mozilla_dom_CanvasCaptureMediaStream_h_
 
 #include "DOMMediaStream.h"
 #include "mozilla/dom/HTMLCanvasElement.h"
-#include "PrincipalHandle.h"
+#include "StreamTracks.h"
 
 class nsIPrincipal;
 
 namespace mozilla {
 class DOMMediaStream;
-class SourceMediaTrack;
+class SourceMediaStream;
 
 namespace layers {
 class Image;
 }  // namespace layers
 
 namespace dom {
 class CanvasCaptureMediaStream;
 class HTMLCanvasElement;
@@ -42,86 +42,88 @@ class OutputStreamFrameListener;
  * |        | ------------------------> |   OutputStreamDriver   |
  * | Canvas |  SetFrameCapture()        | (FrameCaptureListener) |
  * |________| ------------------------> |________________________|
  *                                                  |
  *                                                  | SetImage() -
  *                                                  | AppendToTrack()
  *                                                  |
  *                                                  v
- *                                      __________________________
- *                                     |                          |
- *                                     |  MTG / SourceMediaTrack  |
- *                                     |__________________________|
+ *                                      ___________________________
+ *                                     |                           |
+ *                                     |  MSG / SourceMediaStream  |
+ *                                     |___________________________|
  * ----------------------------------------------------------------------------
  */
 
 /*
  * Base class for drivers of the output stream.
  * It is up to each sub class to implement the NewFrame() callback of
  * FrameCaptureListener.
  */
 class OutputStreamDriver : public FrameCaptureListener {
  public:
-  OutputStreamDriver(SourceMediaTrack* aSourceStream,
+  OutputStreamDriver(SourceMediaStream* aSourceStream, const TrackID& aTrackId,
                      const PrincipalHandle& aPrincipalHandle);
 
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OutputStreamDriver);
 
   /*
    * Sub classes can SetImage() to update the image being appended to the
-   * output stream. It will be appended on the next NotifyPull from MTG.
+   * output stream. It will be appended on the next NotifyPull from MSG.
    */
   void SetImage(const RefPtr<layers::Image>& aImage, const TimeStamp& aTime);
 
   /*
    * Ends the track in mSourceStream when we know there won't be any more images
    * requested for it.
    */
   void EndTrack();
 
   /*
    * Makes sure any internal resources this driver is holding that may create
    * reference cycles are released.
    */
   virtual void Forget() {}
 
-  const RefPtr<SourceMediaTrack> mSourceStream;
+  const TrackID mTrackId;
+  const RefPtr<SourceMediaStream> mSourceStream;
   const PrincipalHandle mPrincipalHandle;
 
  protected:
   virtual ~OutputStreamDriver();
 };
 
 class CanvasCaptureMediaStream : public DOMMediaStream {
  public:
   CanvasCaptureMediaStream(nsPIDOMWindowInner* aWindow,
                            HTMLCanvasElement* aCanvas);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(CanvasCaptureMediaStream,
                                            DOMMediaStream)
 
-  nsresult Init(const dom::Optional<double>& aFPS, nsIPrincipal* aPrincipal);
+  nsresult Init(const dom::Optional<double>& aFPS, const TrackID aTrackId,
+                nsIPrincipal* aPrincipal);
 
   JSObject* WrapObject(JSContext* aCx,
                        JS::Handle<JSObject*> aGivenProto) override;
 
   // WebIDL
   HTMLCanvasElement* Canvas() const { return mCanvas; }
   void RequestFrame();
 
   dom::FrameCaptureListener* FrameCaptureListener();
 
   /**
    * Stops capturing for this stream at mCanvas.
    */
   void StopCapture();
 
-  SourceMediaTrack* GetSourceStream() const;
+  SourceMediaStream* GetSourceStream() const;
 
  protected:
   ~CanvasCaptureMediaStream();
 
  private:
   RefPtr<HTMLCanvasElement> mCanvas;
   RefPtr<OutputStreamDriver> mOutputStreamDriver;
 };

--- a/dom/media/CubebUtils.cpp
+++ b/dom/media/CubebUtils.cpp
@@ -38,17 +38,17 @@
 
 #define AUDIOIPC_POOL_SIZE_DEFAULT 2
 #define AUDIOIPC_STACK_SIZE_DEFAULT (64 * 4096)
 
 #define PREF_VOLUME_SCALE "media.volume_scale"
 #define PREF_CUBEB_BACKEND "media.cubeb.backend"
 #define PREF_CUBEB_OUTPUT_DEVICE "media.cubeb.output_device"
 #define PREF_CUBEB_LATENCY_PLAYBACK "media.cubeb_latency_playback_ms"
-#define PREF_CUBEB_LATENCY_MTG "media.cubeb_latency_mtg_frames"
+#define PREF_CUBEB_LATENCY_MSG "media.cubeb_latency_msg_frames"
 // Allows to get something non-default for the preferred sample-rate, to allow
 // troubleshooting in the field and testing.
 #define PREF_CUBEB_FORCE_SAMPLE_RATE "media.cubeb.force_sample_rate"
 #define PREF_CUBEB_LOGGING_LEVEL "media.cubeb.logging_level"
 // Hidden pref used by tests to force failure to obtain cubeb context
 #define PREF_CUBEB_FORCE_NULL_CONTEXT "media.cubeb.force_null_context"
 // Hidden pref to disable BMO 1427011 experiment; can be removed once proven.
 #define PREF_CUBEB_DISABLE_DEVICE_SWITCHING \
@@ -107,23 +107,23 @@ StaticMutex sMutex;
 enum class CubebState {
   Uninitialized = 0,
   Initialized,
   Shutdown
 } sCubebState = CubebState::Uninitialized;
 cubeb* sCubebContext;
 double sVolumeScale = 1.0;
 uint32_t sCubebPlaybackLatencyInMilliseconds = 100;
-uint32_t sCubebMTGLatencyInFrames = 512;
+uint32_t sCubebMSGLatencyInFrames = 512;
 // If sCubebForcedSampleRate is zero, PreferredSampleRate will return the
 // preferred sample-rate for the audio backend in use. Otherwise, it will be
 // used as the preferred sample-rate.
 uint32_t sCubebForcedSampleRate = 0;
 bool sCubebPlaybackLatencyPrefSet = false;
-bool sCubebMTGLatencyPrefSet = false;
+bool sCubebMSGLatencyPrefSet = false;
 bool sAudioStreamInitEverSucceeded = false;
 bool sCubebForceNullContext = false;
 bool sCubebDisableDeviceSwitching = true;
 #ifdef MOZ_CUBEB_REMOTING
 bool sCubebSandbox = false;
 size_t sAudioIPCPoolSize;
 size_t sAudioIPCStackSize;
 #endif
@@ -221,25 +221,25 @@ void PrefChanged(const char* aPref, void
     StaticMutexAutoLock lock(sMutex);
     // Arbitrary default stream latency of 100ms.  The higher this
     // value, the longer stream volume changes will take to become
     // audible.
     sCubebPlaybackLatencyPrefSet = Preferences::HasUserValue(aPref);
     uint32_t value = Preferences::GetUint(aPref, CUBEB_NORMAL_LATENCY_MS);
     sCubebPlaybackLatencyInMilliseconds =
         std::min<uint32_t>(std::max<uint32_t>(value, 1), 1000);
-  } else if (strcmp(aPref, PREF_CUBEB_LATENCY_MTG) == 0) {
+  } else if (strcmp(aPref, PREF_CUBEB_LATENCY_MSG) == 0) {
     StaticMutexAutoLock lock(sMutex);
-    sCubebMTGLatencyPrefSet = Preferences::HasUserValue(aPref);
+    sCubebMSGLatencyPrefSet = Preferences::HasUserValue(aPref);
     uint32_t value = Preferences::GetUint(aPref, CUBEB_NORMAL_LATENCY_FRAMES);
     // 128 is the block size for the Web Audio API, which limits how low the
     // latency can be here.
     // We don't want to limit the upper limit too much, so that people can
     // experiment.
-    sCubebMTGLatencyInFrames =
+    sCubebMSGLatencyInFrames =
         std::min<uint32_t>(std::max<uint32_t>(value, 128), 1e6);
   } else if (strcmp(aPref, PREF_CUBEB_FORCE_SAMPLE_RATE) == 0) {
     StaticMutexAutoLock lock(sMutex);
     sCubebForcedSampleRate = Preferences::GetUint(aPref);
   } else if (strcmp(aPref, PREF_CUBEB_LOGGING_LEVEL) == 0) {
     nsAutoCString value;
     Preferences::GetCString(aPref, value);
     LogModule* cubebLog = LogModule::Get("cubeb");
@@ -575,47 +575,47 @@ uint32_t GetCubebPlaybackLatencyInMillis
   return sCubebPlaybackLatencyInMilliseconds;
 }
 
 bool CubebPlaybackLatencyPrefSet() {
   StaticMutexAutoLock lock(sMutex);
   return sCubebPlaybackLatencyPrefSet;
 }
 
-bool CubebMTGLatencyPrefSet() {
+bool CubebMSGLatencyPrefSet() {
   StaticMutexAutoLock lock(sMutex);
-  return sCubebMTGLatencyPrefSet;
+  return sCubebMSGLatencyPrefSet;
 }
 
-uint32_t GetCubebMTGLatencyInFrames(cubeb_stream_params* params) {
+uint32_t GetCubebMSGLatencyInFrames(cubeb_stream_params* params) {
   StaticMutexAutoLock lock(sMutex);
-  if (sCubebMTGLatencyPrefSet) {
-    MOZ_ASSERT(sCubebMTGLatencyInFrames > 0);
-    return sCubebMTGLatencyInFrames;
+  if (sCubebMSGLatencyPrefSet) {
+    MOZ_ASSERT(sCubebMSGLatencyInFrames > 0);
+    return sCubebMSGLatencyInFrames;
   }
 
 #ifdef MOZ_WIDGET_ANDROID
   return AndroidGetAudioOutputFramesPerBuffer();
 #else
   cubeb* context = GetCubebContextUnlocked();
   if (!context) {
-    return sCubebMTGLatencyInFrames;  // default 512
+    return sCubebMSGLatencyInFrames;  // default 512
   }
   uint32_t latency_frames = 0;
   if (cubeb_get_min_latency(context, params, &latency_frames) != CUBEB_OK) {
     NS_WARNING("Could not get minimal latency from cubeb.");
-    return sCubebMTGLatencyInFrames;  // default 512
+    return sCubebMSGLatencyInFrames;  // default 512
   }
   return latency_frames;
 #endif
 }
 
 static const char* gInitCallbackPrefs[] = {
     PREF_VOLUME_SCALE,           PREF_CUBEB_OUTPUT_DEVICE,
-    PREF_CUBEB_LATENCY_PLAYBACK, PREF_CUBEB_LATENCY_MTG,
+    PREF_CUBEB_LATENCY_PLAYBACK, PREF_CUBEB_LATENCY_MSG,
     PREF_CUBEB_BACKEND,          PREF_CUBEB_FORCE_NULL_CONTEXT,
     PREF_CUBEB_SANDBOX,          PREF_AUDIOIPC_POOL_SIZE,
     PREF_AUDIOIPC_STACK_SIZE,    nullptr,
 };
 static const char* gCallbackPrefs[] = {
     PREF_CUBEB_FORCE_SAMPLE_RATE,
     // We don't want to call the callback on startup, because the pref is the
     // empty string by default ("", which means "logging disabled"). Because the

--- a/dom/media/CubebUtils.h
+++ b/dom/media/CubebUtils.h
@@ -40,17 +40,17 @@ uint32_t PreferredSampleRate();
 enum Side { Input, Output };
 
 double GetVolumeScale();
 bool GetFirstStream();
 cubeb* GetCubebContext();
 void ReportCubebStreamInitFailure(bool aIsFirstStream);
 void ReportCubebBackendUsed();
 uint32_t GetCubebPlaybackLatencyInMilliseconds();
-uint32_t GetCubebMTGLatencyInFrames(cubeb_stream_params* params);
+uint32_t GetCubebMSGLatencyInFrames(cubeb_stream_params* params);
 bool CubebLatencyPrefSet();
 void GetCurrentBackend(nsAString& aBackend);
 cubeb_stream_prefs GetDefaultStreamPrefs();
 char* GetForcedOutputDevice();
 // No-op on all platforms but Android, where it tells the device's AudioManager
 // to switch to "communication mode", which might change audio routing,
 // bluetooth communication type, etc.
 void SetInCommunication(bool aInCommunication);

--- a/dom/media/DOMMediaStream.cpp
+++ b/dom/media/DOMMediaStream.cpp
@@ -1,22 +1,22 @@
 /* -*- 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 "DOMMediaStream.h"
 
-#include "AudioCaptureTrack.h"
+#include "AudioCaptureStream.h"
 #include "AudioChannelAgent.h"
 #include "AudioStreamTrack.h"
 #include "Layers.h"
-#include "MediaTrackGraph.h"
-#include "MediaTrackGraphImpl.h"
-#include "MediaTrackListener.h"
+#include "MediaStreamGraph.h"
+#include "MediaStreamGraphImpl.h"
+#include "MediaStreamListener.h"
 #include "VideoStreamTrack.h"
 #include "mozilla/dom/AudioTrack.h"
 #include "mozilla/dom/AudioTrackList.h"
 #include "mozilla/dom/DocGroup.h"
 #include "mozilla/dom/HTMLCanvasElement.h"
 #include "mozilla/dom/MediaStreamBinding.h"
 #include "mozilla/dom/MediaStreamTrackEvent.h"
 #include "mozilla/dom/Promise.h"
@@ -39,16 +39,18 @@
 using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::layers;
 using namespace mozilla::media;
 
 static LazyLogModule gMediaStreamLog("MediaStream");
 #define LOG(type, msg) MOZ_LOG(gMediaStreamLog, type, msg)
 
+const TrackID TRACK_VIDEO_PRIMARY = 1;
+
 static bool ContainsLiveTracks(
     const nsTArray<RefPtr<MediaStreamTrack>>& aTracks) {
   for (const auto& track : aTracks) {
     if (track->ReadyState() == MediaStreamTrackState::Live) {
       return true;
     }
   }
 
@@ -227,35 +229,35 @@ already_AddRefed<Promise> DOMMediaStream
     return nullptr;
   }
 
   RefPtr<Promise> p = Promise::Create(go, aRv);
   if (aRv.Failed()) {
     return nullptr;
   }
 
-  MediaTrackGraph* graph = MediaTrackGraph::GetInstanceIfExists(
-      window, MediaTrackGraph::REQUEST_DEFAULT_SAMPLE_RATE);
+  MediaStreamGraph* graph = MediaStreamGraph::GetInstanceIfExists(
+      window, MediaStreamGraph::REQUEST_DEFAULT_SAMPLE_RATE);
   if (!graph) {
     p->MaybeResolve(0);
     return p.forget();
   }
 
-  auto* graphImpl = static_cast<MediaTrackGraphImpl*>(graph);
+  auto* graphImpl = static_cast<MediaStreamGraphImpl*>(graph);
 
   class Counter : public ControlMessage {
    public:
-    Counter(MediaTrackGraphImpl* aGraph, const RefPtr<Promise>& aPromise)
+    Counter(MediaStreamGraphImpl* aGraph, const RefPtr<Promise>& aPromise)
         : ControlMessage(nullptr), mGraph(aGraph), mPromise(aPromise) {
       MOZ_ASSERT(NS_IsMainThread());
     }
 
     void Run() override {
       uint32_t streams =
-          mGraph->mTracks.Length() + mGraph->mSuspendedTracks.Length();
+          mGraph->mStreams.Length() + mGraph->mSuspendedStreams.Length();
       mGraph->DispatchToMainThreadStableState(NS_NewRunnableFunction(
           "DOMMediaStream::CountUnderlyingStreams (stable state)",
           [promise = std::move(mPromise), streams]() mutable {
             NS_DispatchToMainThread(NS_NewRunnableFunction(
                 "DOMMediaStream::CountUnderlyingStreams",
                 [promise = std::move(promise), streams]() {
                   promise->MaybeResolve(streams);
                 }));
@@ -268,17 +270,17 @@ already_AddRefed<Promise> DOMMediaStream
     void RunDuringShutdown() override {
       NS_ReleaseOnMainThreadSystemGroup(
           "DOMMediaStream::CountUnderlyingStreams::Counter::RunDuringShutdown",
           mPromise.forget());
     }
 
    private:
     // mGraph owns this Counter instance and decides its lifetime.
-    MediaTrackGraphImpl* mGraph;
+    MediaStreamGraphImpl* mGraph;
     RefPtr<Promise> mPromise;
   };
   graphImpl->AppendMessage(MakeUnique<Counter>(graphImpl, p));
 
   return p.forget();
 }
 
 void DOMMediaStream::GetId(nsAString& aID) const { aID = mID; }
@@ -322,32 +324,34 @@ void DOMMediaStream::GetVideoTracks(
 void DOMMediaStream::GetTracks(
     nsTArray<RefPtr<MediaStreamTrack>>& aTracks) const {
   for (const auto& track : mTracks) {
     aTracks.AppendElement(track);
   }
 }
 
 void DOMMediaStream::AddTrack(MediaStreamTrack& aTrack) {
-  LOG(LogLevel::Info, ("DOMMediaStream %p Adding track %p (from track %p)",
-                       this, &aTrack, aTrack.GetTrack()));
+  LOG(LogLevel::Info,
+      ("DOMMediaStream %p Adding track %p (from stream %p with ID %d)", this,
+       &aTrack, aTrack.GetStream(), aTrack.GetTrackID()));
 
   if (HasTrack(aTrack)) {
     LOG(LogLevel::Debug,
         ("DOMMediaStream %p already contains track %p", this, &aTrack));
     return;
   }
 
   mTracks.AppendElement(&aTrack);
   NotifyTrackAdded(&aTrack);
 }
 
 void DOMMediaStream::RemoveTrack(MediaStreamTrack& aTrack) {
-  LOG(LogLevel::Info, ("DOMMediaStream %p Removing track %p (from track %p)",
-                       this, &aTrack, aTrack.GetTrack()));
+  LOG(LogLevel::Info,
+      ("DOMMediaStream %p Removing track %p (from stream %p with ID %d)", this,
+       &aTrack, aTrack.GetStream(), aTrack.GetTrackID()));
 
   if (!mTracks.RemoveElement(&aTrack)) {
     LOG(LogLevel::Debug,
         ("DOMMediaStream %p does not contain track %p", this, &aTrack));
     return;
   }
 
   if (!aTrack.Ended()) {

--- a/dom/media/DOMMediaStream.h
+++ b/dom/media/DOMMediaStream.h
@@ -6,25 +6,29 @@
 #ifndef NSDOMMEDIASTREAM_H_
 #define NSDOMMEDIASTREAM_H_
 
 #include "ImageContainer.h"
 
 #include "nsAutoPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsWrapperCache.h"
+#include "StreamTracks.h"
 #include "nsIPrincipal.h"
 #include "MediaTrackConstraints.h"
 #include "mozilla/DOMEventTargetHelper.h"
 #include "mozilla/RelativeTimeline.h"
 
 namespace mozilla {
 
 class AbstractThread;
 class DOMMediaStream;
+class MediaStream;
+class MediaInputPort;
+class ProcessedMediaStream;
 
 enum class BlockingMode;
 
 namespace dom {
 class HTMLCanvasElement;
 class MediaStreamTrack;
 class MediaStreamTrackSource;
 class AudioStreamTrack;

--- a/dom/media/DriftCompensation.h
+++ b/dom/media/DriftCompensation.h
@@ -14,19 +14,19 @@
 
 namespace mozilla {
 
 static LazyLogModule gDriftCompensatorLog("DriftCompensator");
 #define LOG(type, ...) MOZ_LOG(gDriftCompensatorLog, type, (__VA_ARGS__))
 
 /**
  * DriftCompensator can be used to handle drift between audio and video tracks
- * from the MediaTrackGraph.
+ * from the MediaStreamGraph.
  *
- * Drift can occur because audio is driven by a MediaTrackGraph running off an
+ * Drift can occur because audio is driven by a MediaStreamGraph running off an
  * audio callback, thus it's progressed by the clock of one the audio output
  * devices on the user's machine. Video on the other hand is always expressed in
  * wall-clock TimeStamps, i.e., it's progressed by the system clock. These
  * clocks will, over time, drift apart.
  *
  * Do not use the DriftCompensator across multiple audio tracks, as it will
  * automatically record the start time of the first audio samples, and all
  * samples for the same audio track on the same audio clock will have to be
@@ -37,17 +37,17 @@ static LazyLogModule gDriftCompensatorLo
  * - The video thread for compensating drift of video frames to match the audio
  *   clock.
  */
 class DriftCompensator {
   const RefPtr<nsIEventTarget> mVideoThread;
   const TrackRate mAudioRate;
 
   // Number of audio samples produced. Any thread.
-  Atomic<TrackTime> mAudioSamples{0};
+  Atomic<StreamTime> mAudioSamples{0};
 
   // Time the first audio samples were added. mVideoThread only.
   TimeStamp mAudioStartTime;
 
   void SetAudioStartTime(TimeStamp aTime) {
     MOZ_ASSERT(mVideoThread->IsOnCurrentThread());
     MOZ_ASSERT(mAudioStartTime.IsNull());
     mAudioStartTime = aTime;
@@ -73,32 +73,32 @@ class DriftCompensator {
         &DriftCompensator::SetAudioStartTime, aStart));
     MOZ_DIAGNOSTIC_ASSERT(NS_SUCCEEDED(rv));
     Unused << rv;
   }
 
   /**
    * aSamples is the number of samples fed by an AudioStream.
    */
-  void NotifyAudio(TrackTime aSamples) {
+  void NotifyAudio(StreamTime aSamples) {
     MOZ_ASSERT(aSamples > 0);
     mAudioSamples += aSamples;
 
     LOG(LogLevel::Verbose,
         "DriftCompensator %p Processed another %" PRId64
         " samples; now %.3fs audio",
         this, aSamples, static_cast<double>(mAudioSamples) / mAudioRate);
   }
 
   /**
    * Drift compensates a video TimeStamp based on historical audio data.
    */
   virtual TimeStamp GetVideoTime(TimeStamp aNow, TimeStamp aTime) {
     MOZ_ASSERT(mVideoThread->IsOnCurrentThread());
-    TrackTime samples = mAudioSamples;
+    StreamTime samples = mAudioSamples;
 
     if (samples / mAudioRate < 10) {
       // We don't apply compensation for the first 10 seconds because of the
       // higher inaccuracy during this time.
       LOG(LogLevel::Debug, "DriftCompensator %p %" PRId64 "ms so far; ignoring",
           this, samples * 1000 / mAudioRate);
       return aTime;
     }

--- a/dom/media/GraphDriver.cpp
+++ b/dom/media/GraphDriver.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 <MediaStreamGraphImpl.h>
 #include "mozilla/dom/AudioContext.h"
 #include "mozilla/dom/AudioDeviceInfo.h"
 #include "mozilla/dom/WorkletThread.h"
 #include "mozilla/SharedThreadPool.h"
 #include "mozilla/ClearOnShutdown.h"
 #include "mozilla/Unused.h"
 #include "mozilla/MathAlgorithms.h"
 #include "CubebDeviceEnumerator.h"
@@ -18,25 +18,25 @@
 #ifdef MOZ_WEBRTC
 #  include "webrtc/MediaEngineWebRTC.h"
 #endif
 
 #ifdef XP_MACOSX
 #  include <sys/sysctl.h>
 #endif
 
-extern mozilla::LazyLogModule gMediaTrackGraphLog;
+extern mozilla::LazyLogModule gMediaStreamGraphLog;
 #ifdef LOG
 #  undef LOG
 #endif  // LOG
-#define LOG(type, msg) MOZ_LOG(gMediaTrackGraphLog, type, msg)
+#define LOG(type, msg) MOZ_LOG(gMediaStreamGraphLog, type, msg)
 
 namespace mozilla {
 
-GraphDriver::GraphDriver(MediaTrackGraphImpl* aGraphImpl)
+GraphDriver::GraphDriver(MediaStreamGraphImpl* aGraphImpl)
     : mIterationStart(0),
       mIterationEnd(0),
       mGraphImpl(aGraphImpl),
       mPreviousDriver(nullptr),
       mNextDriver(nullptr) {}
 
 void GraphDriver::SetGraphTime(GraphDriver* aPreviousDriver,
                                GraphTime aLastSwitchNextIterationStart,
@@ -139,49 +139,49 @@ void GraphDriver::SetNextDriver(GraphDri
 }
 
 void GraphDriver::SetPreviousDriver(GraphDriver* aPreviousDriver) {
   MOZ_ASSERT(OnGraphThread() || !ThreadRunning());
   GraphImpl()->GetMonitor().AssertCurrentThreadOwns();
   mPreviousDriver = aPreviousDriver;
 }
 
-ThreadedDriver::ThreadedDriver(MediaTrackGraphImpl* aGraphImpl)
+ThreadedDriver::ThreadedDriver(MediaStreamGraphImpl* aGraphImpl)
     : GraphDriver(aGraphImpl), mThreadRunning(false) {}
 
-class MediaTrackGraphShutdownThreadRunnable : public Runnable {
+class MediaStreamGraphShutdownThreadRunnable : public Runnable {
  public:
-  explicit MediaTrackGraphShutdownThreadRunnable(
+  explicit MediaStreamGraphShutdownThreadRunnable(
       already_AddRefed<nsIThread> aThread)
-      : Runnable("MediaTrackGraphShutdownThreadRunnable"), mThread(aThread) {}
+      : Runnable("MediaStreamGraphShutdownThreadRunnable"), mThread(aThread) {}
   NS_IMETHOD Run() override {
     MOZ_ASSERT(NS_IsMainThread());
     MOZ_ASSERT(mThread);
 
     mThread->Shutdown();
     mThread = nullptr;
     return NS_OK;
   }
 
  private:
   nsCOMPtr<nsIThread> mThread;
 };
 
 ThreadedDriver::~ThreadedDriver() {
   if (mThread) {
     nsCOMPtr<nsIRunnable> event =
-        new MediaTrackGraphShutdownThreadRunnable(mThread.forget());
+        new MediaStreamGraphShutdownThreadRunnable(mThread.forget());
     SystemGroup::Dispatch(TaskCategory::Other, event.forget());
   }
 }
 
-class MediaTrackGraphInitThreadRunnable : public Runnable {
+class MediaStreamGraphInitThreadRunnable : public Runnable {
  public:
-  explicit MediaTrackGraphInitThreadRunnable(ThreadedDriver* aDriver)
-      : Runnable("MediaTrackGraphInitThreadRunnable"), mDriver(aDriver) {}
+  explicit MediaStreamGraphInitThreadRunnable(ThreadedDriver* aDriver)
+      : Runnable("MediaStreamGraphInitThreadRunnable"), mDriver(aDriver) {}
   NS_IMETHOD Run() override {
     MOZ_ASSERT(!mDriver->ThreadRunning());
     LOG(LogLevel::Debug, ("Starting a new system driver for graph %p",
                           mDriver->mGraphImpl.get()));
 
     RefPtr<GraphDriver> previousDriver;
     {
       MonitorAutoLock mon(mDriver->mGraphImpl->GetMonitor());
@@ -216,39 +216,39 @@ class MediaTrackGraphInitThreadRunnable 
 
 void ThreadedDriver::Start() {
   MOZ_ASSERT(!ThreadRunning());
   LOG(LogLevel::Debug,
       ("Starting thread for a SystemClockDriver  %p", mGraphImpl.get()));
   Unused << NS_WARN_IF(mThread);
   MOZ_ASSERT(!mThread);  // Ensure we haven't already started it
 
-  nsCOMPtr<nsIRunnable> event = new MediaTrackGraphInitThreadRunnable(this);
+  nsCOMPtr<nsIRunnable> event = new MediaStreamGraphInitThreadRunnable(this);
   // Note: mThread may be null during event->Run() if we pass to NewNamedThread!
   // See AudioInitTask
-  nsresult rv = NS_NewNamedThread("MediaTrackGrph", getter_AddRefs(mThread));
+  nsresult rv = NS_NewNamedThread("MediaStreamGrph", getter_AddRefs(mThread));
   if (NS_SUCCEEDED(rv)) {
     mThread->EventTarget()->Dispatch(event.forget(), NS_DISPATCH_NORMAL);
   }
 }
 
 void ThreadedDriver::Shutdown() {
   NS_ASSERTION(NS_IsMainThread(), "Must be called on main thread");
   // mGraph's thread is not running so it's OK to do whatever here
-  LOG(LogLevel::Debug, ("Stopping threads for MediaTrackGraph %p", this));
+  LOG(LogLevel::Debug, ("Stopping threads for MediaStreamGraph %p", this));
 
   if (mThread) {
     LOG(LogLevel::Debug,
         ("%p: Stopping ThreadedDriver's %p thread", GraphImpl(), this));
     mThread->Shutdown();
     mThread = nullptr;
   }
 }
 
-SystemClockDriver::SystemClockDriver(MediaTrackGraphImpl* aGraphImpl)
+SystemClockDriver::SystemClockDriver(MediaStreamGraphImpl* aGraphImpl)
     : ThreadedDriver(aGraphImpl),
       mInitialTimeStamp(TimeStamp::Now()),
       mCurrentTimeStamp(TimeStamp::Now()),
       mLastTimeStamp(TimeStamp::Now()),
       mIsFallback(false) {}
 
 SystemClockDriver::~SystemClockDriver() {}
 
@@ -315,17 +315,17 @@ void ThreadedDriver::RunThread() {
 
 MediaTime SystemClockDriver::GetIntervalForIteration() {
   TimeStamp now = TimeStamp::Now();
   MediaTime interval =
       GraphImpl()->SecondsToMediaTime((now - mCurrentTimeStamp).ToSeconds());
   mCurrentTimeStamp = now;
 
   MOZ_LOG(
-      gMediaTrackGraphLog, LogLevel::Verbose,
+      gMediaStreamGraphLog, LogLevel::Verbose,
       ("%p: Updating current time to %f (real %f, StateComputedTime() %f)",
        GraphImpl(), GraphImpl()->MediaTimeToSeconds(IterationEnd() + interval),
        (now - mInitialTimeStamp).ToSeconds(),
        GraphImpl()->MediaTimeToSeconds(StateComputedTime())));
 
   return interval;
 }
 
@@ -378,17 +378,17 @@ TimeDuration SystemClockDriver::WaitInte
   timeoutMS = std::max<int64_t>(0, std::min<int64_t>(timeoutMS, 60 * 1000));
   LOG(LogLevel::Verbose,
       ("%p: Waiting for next iteration; at %f, timeout=%f", GraphImpl(),
        (now - mInitialTimeStamp).ToSeconds(), timeoutMS / 1000.0));
 
   return TimeDuration::FromMilliseconds(timeoutMS);
 }
 
-OfflineClockDriver::OfflineClockDriver(MediaTrackGraphImpl* aGraphImpl,
+OfflineClockDriver::OfflineClockDriver(MediaStreamGraphImpl* aGraphImpl,
                                        GraphTime aSlice)
     : ThreadedDriver(aGraphImpl), mSlice(aSlice) {}
 
 OfflineClockDriver::~OfflineClockDriver() {}
 
 MediaTime OfflineClockDriver::GetIntervalForIteration() {
   return GraphImpl()->MillisecondsToMediaTime(mSlice);
 }
@@ -441,25 +441,25 @@ AsyncCubebTask::Run() {
     default:
       MOZ_CRASH("Operation not implemented.");
   }
 
   // The thread will kill itself after a bit
   return NS_OK;
 }
 
-TrackAndPromiseForOperation::TrackAndPromiseForOperation(
-    MediaTrack* aTrack, void* aPromise, dom::AudioContextOperation aOperation,
+StreamAndPromiseForOperation::StreamAndPromiseForOperation(
+    MediaStream* aStream, void* aPromise, dom::AudioContextOperation aOperation,
     dom::AudioContextOperationFlags aFlags)
-    : mTrack(aTrack),
+    : mStream(aStream),
       mPromise(aPromise),
       mOperation(aOperation),
       mFlags(aFlags) {}
 
-AudioCallbackDriver::AudioCallbackDriver(MediaTrackGraphImpl* aGraphImpl,
+AudioCallbackDriver::AudioCallbackDriver(MediaStreamGraphImpl* aGraphImpl,
                                          uint32_t aInputChannelCount,
                                          AudioInputType aAudioInputType)
     : GraphDriver(aGraphImpl),
       mOutputChannels(0),
       mSampleRate(0),
       mInputChannelCount(aInputChannelCount),
       mIterationDurationMS(MEDIA_GRAPH_TARGET_PERIOD_MS),
       mStarted(false),
@@ -584,20 +584,20 @@ bool AudioCallbackDriver::Init() {
   output.layout = CUBEB_LAYOUT_UNDEFINED;
   output.prefs = CubebUtils::GetDefaultStreamPrefs();
 #if !defined(XP_WIN)
   if (mInputDevicePreference == CUBEB_DEVICE_PREF_VOICE) {
     output.prefs |= static_cast<cubeb_stream_prefs>(CUBEB_STREAM_PREF_VOICE);
   }
 #endif
 
-  uint32_t latencyFrames = CubebUtils::GetCubebMTGLatencyInFrames(&output);
+  uint32_t latencyFrames = CubebUtils::GetCubebMSGLatencyInFrames(&output);
 
   // Macbook and MacBook air don't have enough CPU to run very low latency
-  // MediaTrackGraphs, cap the minimal latency to 512 frames int this case.
+  // MediaStreamGraphs, cap the minimal latency to 512 frames int this case.
   if (IsMacbookOrMacbookAir()) {
     latencyFrames = std::max((uint32_t)512, latencyFrames);
   }
 
   // On OSX, having a latency that is lower than 10ms is very common. It's
   // not very useful when doing voice, because all the WebRTC code deal in 10ms
   // chunks of audio.  Take the first power of two above 10ms at the current
   // rate in this case. It's probably 512, for common rates.
@@ -630,17 +630,17 @@ bool AudioCallbackDriver::Init() {
     DebugOnly<int> rv =
         cubeb_stream_set_volume(mAudioStream, CubebUtils::GetVolumeScale());
     NS_WARNING_ASSERTION(
         rv == CUBEB_OK,
         "Could not set the audio stream volume in GraphDriver.cpp");
     CubebUtils::ReportCubebBackendUsed();
   } else {
     NS_WARNING(
-        "Could not create a cubeb stream for MediaTrackGraph, falling "
+        "Could not create a cubeb stream for MediaStreamGraph, falling "
         "back to a SystemClockDriver");
     // Only report failures when we're not coming from a driver that was
     // created itself as a fallback driver because of a previous audio driver
     // failure.
     if (!mFromFallback) {
       CubebUtils::ReportCubebStreamInitFailure(firstStream);
     }
     MonitorAutoLock lock(GraphImpl()->GetMonitor());
@@ -693,28 +693,28 @@ void AudioCallbackDriver::Start() {
       new AsyncCubebTask(AsAudioCallbackDriver(), AsyncCubebOperation::INIT);
   initEvent->Dispatch();
 }
 
 bool AudioCallbackDriver::StartStream() {
   MOZ_ASSERT(!IsStarted() && OnCubebOperationThread());
   mShouldFallbackIfError = true;
   if (cubeb_stream_start(mAudioStream) != CUBEB_OK) {
-    NS_WARNING("Could not start cubeb stream for MTG.");
+    NS_WARNING("Could not start cubeb stream for MSG.");
     return false;
   }
 
   mStarted = true;
   return true;
 }
 
 void AudioCallbackDriver::Stop() {
   MOZ_ASSERT(OnCubebOperationThread());
   if (cubeb_stream_stop(mAudioStream) != CUBEB_OK) {
-    NS_WARNING("Could not stop cubeb stream for MTG.");
+    NS_WARNING("Could not stop cubeb stream for MSG.");
   }
   mStarted = false;
 }
 
 void AudioCallbackDriver::RemoveMixerCallback() {
   MOZ_ASSERT(OnGraphThread() || !ThreadRunning());
 
   if (mAddedMixer) {
@@ -1048,49 +1048,49 @@ uint32_t AudioCallbackDriver::IterationD
   MOZ_ASSERT(OnGraphThread());
   // The real fix would be to have an API in cubeb to give us the number. Short
   // of that, we approximate it here. bug 1019507
   return mIterationDurationMS;
 }
 
 bool AudioCallbackDriver::IsStarted() { return mStarted; }
 
-void AudioCallbackDriver::EnqueueTrackAndPromiseForOperation(
-    MediaTrack* aTrack, void* aPromise, dom::AudioContextOperation aOperation,
+void AudioCallbackDriver::EnqueueStreamAndPromiseForOperation(
+    MediaStream* aStream, void* aPromise, dom::AudioContextOperation aOperation,
     dom::AudioContextOperationFlags aFlags) {
   MOZ_ASSERT(OnGraphThread() || !ThreadRunning());
   MonitorAutoLock mon(mGraphImpl->GetMonitor());
   MOZ_ASSERT((aFlags | dom::AudioContextOperationFlags::SendStateChange) ||
              !aPromise);
   if (aFlags == dom::AudioContextOperationFlags::SendStateChange) {
     mPromisesForOperation.AppendElement(
-        TrackAndPromiseForOperation(aTrack, aPromise, aOperation, aFlags));
+        StreamAndPromiseForOperation(aStream, aPromise, aOperation, aFlags));
   }
 }
 
 void AudioCallbackDriver::CompleteAudioContextOperations(
     AsyncCubebOperation aOperation) {
   MOZ_ASSERT(OnCubebOperationThread());
-  AutoTArray<TrackAndPromiseForOperation, 1> array;
+  AutoTArray<StreamAndPromiseForOperation, 1> array;
 
   // We can't lock for the whole function because AudioContextOperationCompleted
   // will grab the monitor
   {
     MonitorAutoLock mon(GraphImpl()->GetMonitor());
     array.SwapElements(mPromisesForOperation);
   }
 
   for (uint32_t i = 0; i < array.Length(); i++) {
-    TrackAndPromiseForOperation& s = array[i];
+    StreamAndPromiseForOperation& s = array[i];
     if ((aOperation == AsyncCubebOperation::INIT &&
          s.mOperation == dom::AudioContextOperation::Resume) ||
         (aOperation == AsyncCubebOperation::SHUTDOWN &&
          s.mOperation != dom::AudioContextOperation::Resume)) {
       MOZ_ASSERT(s.mFlags == dom::AudioContextOperationFlags::SendStateChange);
-      GraphImpl()->AudioContextOperationCompleted(s.mTrack, s.mPromise,
+      GraphImpl()->AudioContextOperationCompleted(s.mStream, s.mPromise,
                                                   s.mOperation, s.mFlags);
       array.RemoveElementAt(i);
       i--;
     }
   }
 
   if (!array.IsEmpty()) {
     MonitorAutoLock mon(GraphImpl()->GetMonitor());

--- a/dom/media/GraphDriver.h
+++ b/dom/media/GraphDriver.h
@@ -28,101 +28,101 @@ template <>
 class nsAutoRefTraits<cubeb_stream> : public nsPointerRefTraits<cubeb_stream> {
  public:
   static void Release(cubeb_stream* aStream) { cubeb_stream_destroy(aStream); }
 };
 
 namespace mozilla {
 
 /**
- * Assume we can run an iteration of the MediaTrackGraph loop in this much time
+ * Assume we can run an iteration of the MediaStreamGraph loop in this much time
  * or less.
  * We try to run the control loop at this rate.
  */
 static const int MEDIA_GRAPH_TARGET_PERIOD_MS = 10;
 
 /**
- * Assume that we might miss our scheduled wakeup of the MediaTrackGraph by
+ * Assume that we might miss our scheduled wakeup of the MediaStreamGraph by
  * this much.
  */
 static const int SCHEDULE_SAFETY_MARGIN_MS = 10;
 
 /**
  * Try have this much audio buffered in streams and queued to the hardware.
  * The maximum delay to the end of the next control loop
  * is 2*MEDIA_GRAPH_TARGET_PERIOD_MS + SCHEDULE_SAFETY_MARGIN_MS.
  * There is no point in buffering more audio than this in a stream at any
  * given time (until we add processing).
  * This is not optimal yet.
  */
 static const int AUDIO_TARGET_MS =
     2 * MEDIA_GRAPH_TARGET_PERIOD_MS + SCHEDULE_SAFETY_MARGIN_MS;
 
-class MediaTrack;
-class MediaTrackGraphImpl;
+class MediaStream;
+class MediaStreamGraphImpl;
 
 class AudioCallbackDriver;
 class OfflineClockDriver;
 class SystemClockDriver;
 
 namespace dom {
 enum class AudioContextOperation;
 }
 
 /**
  * A driver is responsible for the scheduling of the processing, the thread
- * management, and give the different clocks to a MediaTrackGraph. This is an
- * abstract base class. A MediaTrackGraph can be driven by an
+ * management, and give the different clocks to a MediaStreamGraph. This is an
+ * abstract base class. A MediaStreamGraph can be driven by an
  * OfflineClockDriver, if the graph is offline, or a SystemClockDriver, if the
  * graph is real time.
- * A MediaTrackGraph holds an owning reference to its driver.
+ * A MediaStreamGraph holds an owning reference to its driver.
  *
  * The lifetime of drivers is a complicated affair. Here are the different
  * scenarii that can happen:
  *
- * Starting a MediaTrackGraph with an AudioCallbackDriver
+ * Starting a MediaStreamGraph with an AudioCallbackDriver
  * - A new thread T is created, from the main thread.
  * - On this thread T, cubeb is initialized if needed, and a cubeb_stream is
  *   created and started
  * - The thread T posts a message to the main thread to terminate itself.
  * - The graph runs off the audio thread
  *
- * Starting a MediaTrackGraph with a SystemClockDriver:
+ * Starting a MediaStreamGraph with a SystemClockDriver:
  * - A new thread T is created from the main thread.
  * - The graph runs off this thread.
  *
  * Switching from a SystemClockDriver to an AudioCallbackDriver:
  * - A new AudioCallabackDriver is created and initialized on the graph thread
- * - At the end of the MTG iteration, the SystemClockDriver transfers its timing
+ * - At the end of the MSG iteration, the SystemClockDriver transfers its timing
  *   info and a reference to itself to the AudioCallbackDriver. It then starts
  *   the AudioCallbackDriver.
  * - When the AudioCallbackDriver starts, it checks if it has been switched from
  *   a SystemClockDriver, and if that is the case, sends a message to the main
  *   thread to shut the SystemClockDriver thread down.
  * - The graph now runs off an audio callback
  *
  * Switching from an AudioCallbackDriver to a SystemClockDriver:
  * - A new SystemClockDriver is created, and set as mNextDriver.
- * - At the end of the MTG iteration, the AudioCallbackDriver transfers its
+ * - At the end of the MSG iteration, the AudioCallbackDriver transfers its
  *   timing info and a reference to itself to the SystemClockDriver. A new
  *   SystemClockDriver is started from the current audio thread.
  * - When starting, the SystemClockDriver checks if it has been switched from an
  *   AudioCallbackDriver. If yes, it creates a new temporary thread to release
  *   the cubeb_streams. This temporary thread closes the cubeb_stream, and
  *   then dispatches a message to the main thread to be terminated.
  * - The graph now runs off a normal thread.
  *
  * Two drivers cannot run at the same time for the same graph. The thread safety
  * of the different attributes of drivers, and they access pattern is documented
  * next to the members themselves.
  *
  */
 class GraphDriver {
  public:
-  explicit GraphDriver(MediaTrackGraphImpl* aGraphImpl);
+  explicit GraphDriver(MediaStreamGraphImpl* aGraphImpl);
 
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(GraphDriver);
   /* For {System,Offline}ClockDriver, this waits until it's time to process
    * more data.  For AudioCallbackDriver, this is a no-op. */
   virtual void WaitForNextIteration() = 0;
   /* Wakes up the graph if it is waiting. */
   virtual void WakeUp() = 0;
   /* Start the graph, init the driver, start the thread.
@@ -173,20 +173,20 @@ class GraphDriver {
                     GraphTime aLastSwitchNextIterationEnd);
   /**
    * Call this to indicate that another iteration of the control loop is
    * required on its regular schedule. The monitor must not be held.
    * This function has to be idempotent.
    */
   void EnsureNextIteration();
 
-  MediaTrackGraphImpl* GraphImpl() const { return mGraphImpl; }
+  MediaStreamGraphImpl* GraphImpl() const { return mGraphImpl; }
 
 #ifdef DEBUG
-  // True if the current thread is driving the MTG.
+  // True if the current thread is driving the MSG.
   bool OnGraphThread();
 #endif
   // True if the current thread is the GraphDriver's thread.
   virtual bool OnThread() = 0;
   // GraphDriver's thread has started and the thread is running.
   virtual bool ThreadRunning() = 0;
 
  protected:
@@ -195,18 +195,18 @@ class GraphDriver {
   void SetNextDriver(GraphDriver* aNextDriver);
 
   // Time of the start of this graph iteration. This must be accessed while
   // having the monitor.
   GraphTime mIterationStart;
   // Time of the end of this graph iteration. This must be accessed while having
   // the monitor.
   GraphTime mIterationEnd;
-  // The MediaTrackGraphImpl associated with this driver.
-  const RefPtr<MediaTrackGraphImpl> mGraphImpl;
+  // The MediaStreamGraphImpl associated with this driver.
+  const RefPtr<MediaStreamGraphImpl> mGraphImpl;
 
   // This is non-null only when this driver has recently switched from an other
   // driver, and has not cleaned it up yet (for example because the audio stream
   // is currently calling the callback during initialization).
   //
   // This is written to when changing driver, from the previous driver's thread,
   // or a thread created for the occasion. This is read each time we need to
   // check whether we're changing driver (in Switching()), from the graph
@@ -215,35 +215,35 @@ class GraphDriver {
   RefPtr<GraphDriver> mPreviousDriver;
   // This is non-null only when this driver is going to switch to an other
   // driver at the end of this iteration.
   // This must be accessed using the {Set,Get}NextDriver methods.
   RefPtr<GraphDriver> mNextDriver;
   virtual ~GraphDriver() {}
 };
 
-class MediaTrackGraphInitThreadRunnable;
+class MediaStreamGraphInitThreadRunnable;
 
 /**
  * This class is a driver that manages its own thread.
  */
 class ThreadedDriver : public GraphDriver {
  public:
-  explicit ThreadedDriver(MediaTrackGraphImpl* aGraphImpl);
+  explicit ThreadedDriver(MediaStreamGraphImpl* aGraphImpl);
   virtual ~ThreadedDriver();
   void WaitForNextIteration() override;
   void WakeUp() override;
   void Start() override;
   void Shutdown() override;
   /**
    * Runs main control loop on the graph thread. Normally a single invocation
    * of this runs for the entire lifetime of the graph thread.
    */
   void RunThread();
-  friend class MediaTrackGraphInitThreadRunnable;
+  friend class MediaStreamGraphInitThreadRunnable;
   uint32_t IterationDuration() override { return MEDIA_GRAPH_TARGET_PERIOD_MS; }
 
   nsIThread* Thread() { return mThread; }
 
   bool OnThread() override {
     return !mThread || mThread->EventTarget()->IsOnCurrentThread();
   }
 
@@ -263,22 +263,22 @@ class ThreadedDriver : public GraphDrive
 
  private:
   // This is true if the thread is running. It is false
   // before starting the thread and after stopping it.
   Atomic<bool> mThreadRunning;
 };
 
 /**
- * A SystemClockDriver drives a MediaTrackGraph using a system clock, and waits
+ * A SystemClockDriver drives a MediaStreamGraph using a system clock, and waits
  * using a monitor, between each iteration.
  */
 class SystemClockDriver : public ThreadedDriver {
  public:
-  explicit SystemClockDriver(MediaTrackGraphImpl* aGraphImpl);
+  explicit SystemClockDriver(MediaStreamGraphImpl* aGraphImpl);
   virtual ~SystemClockDriver();
   TimeDuration WaitInterval() override;
   MediaTime GetIntervalForIteration() override;
   void MarkAsFallback();
   bool IsFallback();
   SystemClockDriver* AsSystemClockDriver() override { return this; }
 
  private:
@@ -294,32 +294,32 @@ class SystemClockDriver : public Threade
 };
 
 /**
  * An OfflineClockDriver runs the graph as fast as possible, without waiting
  * between iteration.
  */
 class OfflineClockDriver : public ThreadedDriver {
  public:
-  OfflineClockDriver(MediaTrackGraphImpl* aGraphImpl, GraphTime aSlice);
+  OfflineClockDriver(MediaStreamGraphImpl* aGraphImpl, GraphTime aSlice);
   virtual ~OfflineClockDriver();
   TimeDuration WaitInterval() override;
   MediaTime GetIntervalForIteration() override;
   OfflineClockDriver* AsOfflineClockDriver() override { return this; }
 
  private:
   // Time, in GraphTime, for each iteration
   GraphTime mSlice;
 };
 
-struct TrackAndPromiseForOperation {
-  TrackAndPromiseForOperation(MediaTrack* aTrack, void* aPromise,
-                              dom::AudioContextOperation aOperation,
-                              dom::AudioContextOperationFlags aFlags);
-  RefPtr<MediaTrack> mTrack;
+struct StreamAndPromiseForOperation {
+  StreamAndPromiseForOperation(MediaStream* aStream, void* aPromise,
+                               dom::AudioContextOperation aOperation,
+                               dom::AudioContextOperationFlags aFlags);
+  RefPtr<MediaStream> mStream;
   void* mPromise;
   dom::AudioContextOperation mOperation;
   dom::AudioContextOperationFlags mFlags;
 };
 
 enum class AsyncCubebOperation { INIT, SHUTDOWN };
 enum class AudioInputType { Unknown, Voice };
 
@@ -347,17 +347,17 @@ class AudioCallbackDriver : public Graph
                             public MixerCallbackReceiver
 #if defined(XP_WIN)
     ,
                             public audio::DeviceChangeListener
 #endif
 {
  public:
   /** If aInputChannelCount is zero, then this driver is output-only. */
-  AudioCallbackDriver(MediaTrackGraphImpl* aGraphImpl,
+  AudioCallbackDriver(MediaStreamGraphImpl* aGraphImpl,
                       uint32_t aInputChannelCount,
                       AudioInputType aAudioInputType);
   virtual ~AudioCallbackDriver();
 
   void Start() override;
   void WaitForNextIteration() override;
   void WakeUp() override;
   void Shutdown() override;
@@ -405,18 +405,19 @@ class AudioCallbackDriver : public Graph
     if (mInputDevicePreference == CUBEB_DEVICE_PREF_VOICE) {
       return AudioInputType::Voice;
     }
     return AudioInputType::Unknown;
   }
 
   /* Enqueue a promise that is going to be resolved when a specific operation
    * occurs on the cubeb stream. */
-  void EnqueueTrackAndPromiseForOperation(
-      MediaTrack* aTrack, void* aPromise, dom::AudioContextOperation aOperation,
+  void EnqueueStreamAndPromiseForOperation(
+      MediaStream* aStream, void* aPromise,
+      dom::AudioContextOperation aOperation,
       dom::AudioContextOperationFlags aFlags);
 
   std::thread::id ThreadId() { return mAudioThreadId.load(); }
 
   bool OnThread() override {
     return mAudioThreadId.load() == std::this_thread::get_id();
   }
 
@@ -454,17 +455,17 @@ class AudioCallbackDriver : public Graph
    *  the graph will try to re-open an audio stream later. */
   void FallbackToSystemClockDriver();
 
   /* This is true when the method is executed on CubebOperation thread pool. */
   bool OnCubebOperationThread() {
     return mInitShutdownThread->IsOnCurrentThreadInfallible();
   }
 
-  /* MediaTrackGraphs are always down/up mixed to output channels. */
+  /* MediaStreamGraphs are always down/up mixed to output channels. */
   uint32_t mOutputChannels;
   /* The size of this buffer comes from the fact that some audio backends can
    * call back with a number of frames lower than one block (128 frames), so we
    * need to keep at most two block in the SpillBuffer, because we always round
    * up to block boundaries during an iteration.
    * This is only ever accessed on the audio callback thread. */
   SpillBuffer<AudioDataValue, WEBAUDIO_BLOCK_SIZE * 2> mScratchBuffer;
   /* Wrapper to ensure we write exactly the number of frames we need in the
@@ -505,17 +506,17 @@ class AudioCallbackDriver : public Graph
     ~AutoInCallback();
     AudioCallbackDriver* mDriver;
   };
 
   /* Shared thread pool with up to one thread for off-main-thread
    * initialization and shutdown of the audio stream via AsyncCubebTask. */
   const RefPtr<SharedThreadPool> mInitShutdownThread;
   /* This must be accessed with the graph monitor held. */
-  AutoTArray<TrackAndPromiseForOperation, 1> mPromisesForOperation;
+  AutoTArray<StreamAndPromiseForOperation, 1> mPromisesForOperation;
   cubeb_device_pref mInputDevicePreference;
   /* This is used to signal adding the mixer callback on first run
    * of audio callback. This is atomic because it is touched from different
    * threads, the audio callback thread and the state change thread. However,
    * the order of the threads does not allow concurent access. */
   Atomic<bool> mAddedMixer;
   /* Contains the id of the audio thread for as long as the callback
    * is taking place, after that it is reseted to an invalid value. */
@@ -547,14 +548,14 @@ class AsyncCubebTask : public Runnable {
  protected:
   virtual ~AsyncCubebTask();
 
  private:
   NS_IMETHOD Run() final;
 
   RefPtr<AudioCallbackDriver> mDriver;
   AsyncCubebOperation mOperation;
-  RefPtr<MediaTrackGraphImpl> mShutdownGrip;
+  RefPtr<MediaStreamGraphImpl> mShutdownGrip;
 };
 
 }  // namespace mozilla
 
 #endif  // GRAPHDRIVER_H_

--- a/dom/media/GraphRunner.cpp
+++ b/dom/media/GraphRunner.cpp
@@ -2,33 +2,33 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 #include "GraphRunner.h"
 
 #include "GraphDriver.h"
-#include "MediaTrackGraph.h"
-#include "MediaTrackGraphImpl.h"
+#include "MediaStreamGraph.h"
+#include "MediaStreamGraphImpl.h"
 #include "mozilla/dom/WorkletThread.h"
 #include "nsISupportsImpl.h"
 #include "prthread.h"
 #include "Tracing.h"
 #include "audio_thread_priority.h"
 
 namespace mozilla {
 
 static void Start(void* aArg) {
   NS_SetCurrentThreadName("GraphRunner");
   GraphRunner* th = static_cast<GraphRunner*>(aArg);
   th->Run();
 }
 
-GraphRunner::GraphRunner(MediaTrackGraphImpl* aGraph)
+GraphRunner::GraphRunner(MediaStreamGraphImpl* aGraph)
     : mMonitor("GraphRunner::mMonitor"),
       mGraph(aGraph),
       mStateEnd(0),
       mStillProcessing(true),
       mThreadState(ThreadState::Wait),
       // Note that mThread needs to be initialized last, as it may pre-empt the
       // thread running this ctor and enter Run() with uninitialized members.
       mThread(PR_CreateThread(PR_SYSTEM_THREAD, &Start, this,