Add m-esr52 at 52.6.0

1 files changed, 1678 insertions, 0 deletions

diff --git a/dom/media/DOMMediaStream.cpp b/dom/media/DOMMediaStream.cpp
new file mode 100644
index 0000000000..6794ee32f2
--- /dev/null
+++ b/dom/media/DOMMediaStream.cpp
@@ -0,0 +1,1678 @@
+/* -*- 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 "nsContentUtils.h"
+#include "nsServiceManagerUtils.h"
+#include "nsIScriptError.h"
+#include "nsIUUIDGenerator.h"
+#include "nsPIDOMWindow.h"
+#include "mozilla/dom/MediaStreamBinding.h"
+#include "mozilla/dom/MediaStreamTrackEvent.h"
+#include "mozilla/dom/LocalMediaStreamBinding.h"
+#include "mozilla/dom/AudioNode.h"
+#include "AudioChannelAgent.h"
+#include "mozilla/dom/AudioTrack.h"
+#include "mozilla/dom/AudioTrackList.h"
+#include "mozilla/dom/VideoTrack.h"
+#include "mozilla/dom/VideoTrackList.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/media/MediaUtils.h"
+#include "MediaStreamGraph.h"
+#include "AudioStreamTrack.h"
+#include "VideoStreamTrack.h"
+#include "Layers.h"
+
+// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
+// GetTickCount() and conflicts with NS_DECL_NSIDOMMEDIASTREAM, containing
+// currentTime getter.
+#ifdef GetCurrentTime
+#undef GetCurrentTime
+#endif
+
+#ifdef LOG
+#undef LOG
+#endif
+
+// GetCurrentTime is defined in winbase.h as zero argument macro forwarding to
+// GetTickCount() and conflicts with MediaStream::GetCurrentTime.
+#ifdef GetCurrentTime
+#undef GetCurrentTime
+#endif
+
+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(nsTArray<RefPtr<DOMMediaStream::TrackPort>>& aTracks)
+{
+  for (auto& port : aTracks) {
+    if (port->GetTrack()->ReadyState() == MediaStreamTrackState::Live) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+DOMMediaStream::TrackPort::TrackPort(MediaInputPort* aInputPort,
+                                     MediaStreamTrack* aTrack,
+                                     const InputPortOwnership aOwnership)
+  : mInputPort(aInputPort)
+  , mTrack(aTrack)
+  , mOwnership(aOwnership)
+{
+  MOZ_ASSERT(mInputPort);
+  MOZ_ASSERT(mTrack);
+
+  MOZ_COUNT_CTOR(TrackPort);
+}
+
+DOMMediaStream::TrackPort::~TrackPort()
+{
+  MOZ_COUNT_DTOR(TrackPort);
+
+  if (mOwnership == InputPortOwnership::OWNED) {
+    DestroyInputPort();
+  }
+}
+
+void
+DOMMediaStream::TrackPort::DestroyInputPort()
+{
+  if (mInputPort) {
+    mInputPort->Destroy();
+    mInputPort = nullptr;
+  }
+}
+
+MediaStream*
+DOMMediaStream::TrackPort::GetSource() const
+{
+  return mInputPort ? mInputPort->GetSource() : nullptr;
+}
+
+TrackID
+DOMMediaStream::TrackPort::GetSourceTrackId() const
+{
+  return mInputPort ? mInputPort->GetSourceTrackId() : TRACK_INVALID;
+}
+
+already_AddRefed<Pledge<bool>>
+DOMMediaStream::TrackPort::BlockSourceTrackId(TrackID aTrackId, BlockingMode aBlockingMode)
+{
+  if (mInputPort) {
+    return mInputPort->BlockSourceTrackId(aTrackId, aBlockingMode);
+  }
+  RefPtr<Pledge<bool>> rejected = new Pledge<bool>();
+  rejected->Reject(NS_ERROR_FAILURE);
+  return rejected.forget();
+}
+
+NS_IMPL_CYCLE_COLLECTION(DOMMediaStream::TrackPort, mTrack)
+NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(DOMMediaStream::TrackPort, AddRef)
+NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(DOMMediaStream::TrackPort, Release)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(MediaStreamTrackSourceGetter)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(MediaStreamTrackSourceGetter)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MediaStreamTrackSourceGetter)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+NS_IMPL_CYCLE_COLLECTION_0(MediaStreamTrackSourceGetter)
+
+/**
+ * Listener registered on the Owned stream to detect added and ended owned
+ * tracks for keeping the list of MediaStreamTracks in sync with the tracks
+ * added and ended directly at the source.
+ */
+class DOMMediaStream::OwnedStreamListener : public MediaStreamListener {
+public:
+  explicit OwnedStreamListener(DOMMediaStream* aStream)
+    : mStream(aStream)
+  {}
+
+  void Forget() { mStream = nullptr; }
+
+  void DoNotifyTrackCreated(TrackID aTrackID, MediaSegment::Type aType,
+                            MediaStream* aInputStream, TrackID aInputTrackID)
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (!mStream) {
+      return;
+    }
+
+    MediaStreamTrack* track =
+      mStream->FindOwnedDOMTrack(aInputStream, aInputTrackID, aTrackID);
+
+    if (track) {
+      LOG(LogLevel::Debug, ("DOMMediaStream %p Track %d from owned stream %p "
+                            "bound to MediaStreamTrack %p.",
+                            mStream, aTrackID, aInputStream, track));
+      return;
+    }
+
+    // Track had not been created on main thread before, create it now.
+    NS_WARNING_ASSERTION(
+      !mStream->mTracks.IsEmpty(),
+      "A new track was detected on the input stream; creating a corresponding "
+      "MediaStreamTrack. Initial tracks should be added manually to "
+      "immediately and synchronously be available to JS.");
+    RefPtr<MediaStreamTrackSource> source;
+    if (mStream->mTrackSourceGetter) {
+      source = mStream->mTrackSourceGetter->GetMediaStreamTrackSource(aTrackID);
+    }
+    if (!source) {
+      NS_ASSERTION(false, "Dynamic track created without an explicit TrackSource");
+      nsPIDOMWindowInner* window = mStream->GetParentObject();
+      nsIDocument* doc = window ? window->GetExtantDoc() : nullptr;
+      nsIPrincipal* principal = doc ? doc->NodePrincipal() : nullptr;
+      source = new BasicTrackSource(principal);
+    }
+
+    RefPtr<MediaStreamTrack> newTrack =
+      mStream->CreateDOMTrack(aTrackID, aType, source);
+    NS_DispatchToMainThread(NewRunnableMethod<RefPtr<MediaStreamTrack>>(
+        mStream, &DOMMediaStream::AddTrackInternal, newTrack));
+  }
+
+  void DoNotifyTrackEnded(MediaStream* aInputStream, TrackID aInputTrackID,
+                          TrackID aTrackID)
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (!mStream) {
+      return;
+    }
+
+    RefPtr<MediaStreamTrack> track =
+      mStream->FindOwnedDOMTrack(aInputStream, aInputTrackID, aTrackID);
+    NS_ASSERTION(track, "Owned MediaStreamTracks must be known by the DOMMediaStream");
+    if (track) {
+      LOG(LogLevel::Debug, ("DOMMediaStream %p MediaStreamTrack %p ended at the source. Marking it ended.",
+                            mStream, track.get()));
+      NS_DispatchToMainThread(NewRunnableMethod(
+        track, &MediaStreamTrack::OverrideEnded));
+    }
+  }
+
+  void NotifyQueuedTrackChanges(MediaStreamGraph* aGraph, TrackID aID,
+                                StreamTime aTrackOffset, TrackEventCommand aTrackEvents,
+                                const MediaSegment& aQueuedMedia,
+                                MediaStream* aInputStream,
+                                TrackID aInputTrackID) override
+  {
+    if (aTrackEvents & TrackEventCommand::TRACK_EVENT_CREATED) {
+      nsCOMPtr<nsIRunnable> runnable =
+        NewRunnableMethod<TrackID, MediaSegment::Type, RefPtr<MediaStream>, TrackID>(
+          this, &OwnedStreamListener::DoNotifyTrackCreated,
+          aID, aQueuedMedia.GetType(), aInputStream, aInputTrackID);
+      aGraph->DispatchToMainThreadAfterStreamStateUpdate(runnable.forget());
+    } else if (aTrackEvents & TrackEventCommand::TRACK_EVENT_ENDED) {
+      nsCOMPtr<nsIRunnable> runnable =
+        NewRunnableMethod<RefPtr<MediaStream>, TrackID, TrackID>(
+          this, &OwnedStreamListener::DoNotifyTrackEnded,
+          aInputStream, aInputTrackID, aID);
+      aGraph->DispatchToMainThreadAfterStreamStateUpdate(runnable.forget());
+    }
+  }
+
+private:
+  // These fields may only be accessed on the main thread
+  DOMMediaStream* mStream;
+};
+
+/**
+ * Listener registered on the Playback stream to detect when tracks end and when
+ * all new tracks this iteration have been created - for when several tracks are
+ * queued by the source and committed all at once.
+ */
+class DOMMediaStream::PlaybackStreamListener : public MediaStreamListener {
+public:
+  explicit PlaybackStreamListener(DOMMediaStream* aStream)
+    : mStream(aStream)
+  {}
+
+  void Forget()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+    mStream = nullptr;
+  }
+
+  void DoNotifyFinishedTrackCreation()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (!mStream) {
+      return;
+    }
+
+    // The owned stream listener adds its tracks after another main thread
+    // dispatch. We have to do the same to notify of created tracks to stay
+    // in sync. (Or NotifyTracksCreated is called before tracks are added).
+    NS_DispatchToMainThread(
+        NewRunnableMethod(mStream, &DOMMediaStream::NotifyTracksCreated));
+  }
+
+  void DoNotifyFinished()
+  {
+    MOZ_ASSERT(NS_IsMainThread());
+
+    if (!mStream) {
+      return;
+    }
+
+    NS_DispatchToMainThread(NewRunnableMethod(
+      mStream, &DOMMediaStream::NotifyFinished));
+  }
+
+  // The methods below are called on the MediaStreamGraph thread.
+
+  void NotifyFinishedTrackCreation(MediaStreamGraph* aGraph) override
+  {
+    nsCOMPtr<nsIRunnable> runnable =
+      NewRunnableMethod(this, &PlaybackStreamListener::DoNotifyFinishedTrackCreation);
+    aGraph->DispatchToMainThreadAfterStreamStateUpdate(runnable.forget());
+  }
+
+
+  void NotifyEvent(MediaStreamGraph* aGraph,
+                   MediaStreamGraphEvent event) override
+  {
+    if (event == MediaStreamGraphEvent::EVENT_FINISHED) {
+      aGraph->DispatchToMainThreadAfterStreamStateUpdate(
+        NewRunnableMethod(this, &PlaybackStreamListener::DoNotifyFinished));
+    }
+  }
+
+private:
+  // These fields may only be accessed on the main thread
+  DOMMediaStream* mStream;
+};
+
+class DOMMediaStream::PlaybackTrackListener : public MediaStreamTrackConsumer
+{
+public:
+  explicit PlaybackTrackListener(DOMMediaStream* aStream) :
+    mStream(aStream) {}
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PlaybackTrackListener,
+                                           MediaStreamTrackConsumer)
+
+  void NotifyEnded(MediaStreamTrack* aTrack) override
+  {
+    if (!mStream) {
+      MOZ_ASSERT(false);
+      return;
+    }
+
+    if (!aTrack) {
+      MOZ_ASSERT(false);
+      return;
+    }
+
+    MOZ_ASSERT(mStream->HasTrack(*aTrack));
+    mStream->NotifyTrackRemoved(aTrack);
+  }
+
+protected:
+  virtual ~PlaybackTrackListener() {}
+
+  RefPtr<DOMMediaStream> mStream;
+};
+
+NS_IMPL_ADDREF_INHERITED(DOMMediaStream::PlaybackTrackListener,
+                         MediaStreamTrackConsumer)
+NS_IMPL_RELEASE_INHERITED(DOMMediaStream::PlaybackTrackListener,
+                          MediaStreamTrackConsumer)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DOMMediaStream::PlaybackTrackListener)
+NS_INTERFACE_MAP_END_INHERITING(MediaStreamTrackConsumer)
+NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMMediaStream::PlaybackTrackListener,
+                                   MediaStreamTrackConsumer,
+                                   mStream)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(DOMMediaStream)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(DOMMediaStream,
+                                                DOMEventTargetHelper)
+  tmp->Destroy();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mWindow)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwnedTracks)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTracks)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mConsumersToKeepAlive)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTrackSourceGetter)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPlaybackTrackListener)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPrincipal)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mVideoPrincipal)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(DOMMediaStream,
+                                                  DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mWindow)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwnedTracks)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTracks)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mConsumersToKeepAlive)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTrackSourceGetter)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPlaybackTrackListener)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPrincipal)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mVideoPrincipal)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_ADDREF_INHERITED(DOMMediaStream, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(DOMMediaStream, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DOMMediaStream)
+  NS_INTERFACE_MAP_ENTRY(DOMMediaStream)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(DOMLocalMediaStream, DOMMediaStream)
+NS_IMPL_RELEASE_INHERITED(DOMLocalMediaStream, DOMMediaStream)
+
+NS_INTERFACE_MAP_BEGIN(DOMLocalMediaStream)
+  NS_INTERFACE_MAP_ENTRY(DOMLocalMediaStream)
+NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream,
+                                   mStreamNode)
+
+NS_IMPL_ADDREF_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream)
+NS_IMPL_RELEASE_INHERITED(DOMAudioNodeMediaStream, DOMMediaStream)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DOMAudioNodeMediaStream)
+NS_INTERFACE_MAP_END_INHERITING(DOMMediaStream)
+
+DOMMediaStream::DOMMediaStream(nsPIDOMWindowInner* aWindow,
+                               MediaStreamTrackSourceGetter* aTrackSourceGetter)
+  : mLogicalStreamStartTime(0), mWindow(aWindow),
+    mInputStream(nullptr), mOwnedStream(nullptr), mPlaybackStream(nullptr),
+    mTracksPendingRemoval(0), mTrackSourceGetter(aTrackSourceGetter),
+    mPlaybackTrackListener(MakeAndAddRef<PlaybackTrackListener>(this)),
+    mTracksCreated(false), mNotifiedOfMediaStreamGraphShutdown(false),
+    mActive(false), mSetInactiveOnFinish(false)
+{
+  nsresult rv;
+  nsCOMPtr<nsIUUIDGenerator> uuidgen =
+    do_GetService("@mozilla.org/uuid-generator;1", &rv);
+
+  if (NS_SUCCEEDED(rv) && uuidgen) {
+    nsID uuid;
+    memset(&uuid, 0, sizeof(uuid));
+    rv = uuidgen->GenerateUUIDInPlace(&uuid);
+    if (NS_SUCCEEDED(rv)) {
+      char buffer[NSID_LENGTH];
+      uuid.ToProvidedString(buffer);
+      mID = NS_ConvertASCIItoUTF16(buffer);
+    }
+  }
+}
+
+DOMMediaStream::~DOMMediaStream()
+{
+  Destroy();
+}
+
+void
+DOMMediaStream::Destroy()
+{
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Being destroyed.", this));
+  if (mOwnedListener) {
+    mOwnedListener->Forget();
+    mOwnedListener = nullptr;
+  }
+  if (mPlaybackListener) {
+    mPlaybackListener->Forget();
+    mPlaybackListener = nullptr;
+  }
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    // We must remove ourselves from each track's principal change observer list
+    // before we die. CC may have cleared info->mTrack so guard against it.
+    MediaStreamTrack* track = info->GetTrack();
+    if (track) {
+      track->RemovePrincipalChangeObserver(this);
+      if (!track->Ended()) {
+        track->RemoveConsumer(mPlaybackTrackListener);
+      }
+    }
+  }
+  if (mPlaybackPort) {
+    mPlaybackPort->Destroy();
+    mPlaybackPort = nullptr;
+  }
+  if (mOwnedPort) {
+    mOwnedPort->Destroy();
+    mOwnedPort = nullptr;
+  }
+  if (mPlaybackStream) {
+    mPlaybackStream->UnregisterUser();
+    mPlaybackStream = nullptr;
+  }
+  if (mOwnedStream) {
+    mOwnedStream->UnregisterUser();
+    mOwnedStream = nullptr;
+  }
+  if (mInputStream) {
+    mInputStream->UnregisterUser();
+    mInputStream = nullptr;
+  }
+  mRunOnTracksAvailable.Clear();
+  mTrackListeners.Clear();
+}
+
+JSObject*
+DOMMediaStream::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return dom::MediaStreamBinding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */ already_AddRefed<DOMMediaStream>
+DOMMediaStream::Constructor(const GlobalObject& aGlobal,
+                            ErrorResult& aRv)
+{
+  Sequence<OwningNonNull<MediaStreamTrack>> emptyTrackSeq;
+  return Constructor(aGlobal, emptyTrackSeq, aRv);
+}
+
+/* static */ already_AddRefed<DOMMediaStream>
+DOMMediaStream::Constructor(const GlobalObject& aGlobal,
+                            const DOMMediaStream& aStream,
+                            ErrorResult& aRv)
+{
+  nsTArray<RefPtr<MediaStreamTrack>> tracks;
+  aStream.GetTracks(tracks);
+
+  Sequence<OwningNonNull<MediaStreamTrack>> nonNullTrackSeq;
+  if (!nonNullTrackSeq.SetLength(tracks.Length(), fallible)) {
+    MOZ_ASSERT(false);
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return nullptr;
+  }
+
+  for (size_t i = 0; i < tracks.Length(); ++i) {
+    nonNullTrackSeq[i] = tracks[i];
+  }
+
+  return Constructor(aGlobal, nonNullTrackSeq, aRv);
+}
+
+/* static */ already_AddRefed<DOMMediaStream>
+DOMMediaStream::Constructor(const GlobalObject& aGlobal,
+                            const Sequence<OwningNonNull<MediaStreamTrack>>& aTracks,
+                            ErrorResult& aRv)
+{
+  nsCOMPtr<nsPIDOMWindowInner> ownerWindow = do_QueryInterface(aGlobal.GetAsSupports());
+  if (!ownerWindow) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  // Streams created from JS cannot have dynamically created tracks.
+  MediaStreamTrackSourceGetter* getter = nullptr;
+  RefPtr<DOMMediaStream> newStream = new DOMMediaStream(ownerWindow, getter);
+
+  for (MediaStreamTrack& track : aTracks) {
+    if (!newStream->GetPlaybackStream()) {
+      MOZ_RELEASE_ASSERT(track.Graph());
+      newStream->InitPlaybackStreamCommon(track.Graph());
+    }
+    newStream->AddTrack(track);
+  }
+
+  if (!newStream->GetPlaybackStream()) {
+    MOZ_ASSERT(aTracks.IsEmpty());
+    MediaStreamGraph* graph =
+      MediaStreamGraph::GetInstance(MediaStreamGraph::SYSTEM_THREAD_DRIVER,
+                                    AudioChannel::Normal);
+    newStream->InitPlaybackStreamCommon(graph);
+  }
+
+  return newStream.forget();
+}
+
+double
+DOMMediaStream::CurrentTime()
+{
+  if (!mPlaybackStream) {
+    return 0.0;
+  }
+  return mPlaybackStream->
+    StreamTimeToSeconds(mPlaybackStream->GetCurrentTime() - mLogicalStreamStartTime);
+}
+
+void
+DOMMediaStream::GetId(nsAString& aID) const
+{
+  aID = mID;
+}
+
+void
+DOMMediaStream::GetAudioTracks(nsTArray<RefPtr<AudioStreamTrack> >& aTracks) const
+{
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    AudioStreamTrack* t = info->GetTrack()->AsAudioStreamTrack();
+    if (t) {
+      aTracks.AppendElement(t);
+    }
+  }
+}
+
+void
+DOMMediaStream::GetVideoTracks(nsTArray<RefPtr<VideoStreamTrack> >& aTracks) const
+{
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    VideoStreamTrack* t = info->GetTrack()->AsVideoStreamTrack();
+    if (t) {
+      aTracks.AppendElement(t);
+    }
+  }
+}
+
+void
+DOMMediaStream::GetTracks(nsTArray<RefPtr<MediaStreamTrack> >& aTracks) const
+{
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    aTracks.AppendElement(info->GetTrack());
+  }
+}
+
+void
+DOMMediaStream::AddTrack(MediaStreamTrack& aTrack)
+{
+  MOZ_RELEASE_ASSERT(mPlaybackStream);
+
+  RefPtr<ProcessedMediaStream> dest = mPlaybackStream->AsProcessedStream();
+  MOZ_ASSERT(dest);
+  if (!dest) {
+    return;
+  }
+
+  LOG(LogLevel::Info, ("DOMMediaStream %p Adding track %p (from stream %p with ID %d)",
+                       this, &aTrack, aTrack.mOwningStream.get(), aTrack.mTrackID));
+
+  if (mPlaybackStream->Graph() != aTrack.Graph()) {
+    NS_ASSERTION(false, "Cannot combine tracks from different MediaStreamGraphs");
+    LOG(LogLevel::Error, ("DOMMediaStream %p Own MSG %p != aTrack's MSG %p",
+                         this, mPlaybackStream->Graph(), aTrack.Graph()));
+
+    nsAutoString trackId;
+    aTrack.GetId(trackId);
+    const char16_t* params[] = { trackId.get() };
+    nsCOMPtr<nsPIDOMWindowInner> pWindow = GetParentObject();
+    nsIDocument* document = pWindow ? pWindow->GetExtantDoc() : nullptr;
+    nsContentUtils::ReportToConsole(nsIScriptError::errorFlag,
+                                    NS_LITERAL_CSTRING("Media"),
+                                    document,
+                                    nsContentUtils::eDOM_PROPERTIES,
+                                    "MediaStreamAddTrackDifferentAudioChannel",
+                                    params, ArrayLength(params));
+    return;
+  }
+
+  if (HasTrack(aTrack)) {
+    LOG(LogLevel::Debug, ("DOMMediaStream %p already contains track %p", this, &aTrack));
+    return;
+  }
+
+  // Hook up the underlying track with our underlying playback stream.
+  RefPtr<MediaInputPort> inputPort =
+    GetPlaybackStream()->AllocateInputPort(aTrack.GetOwnedStream(),
+                                           aTrack.mTrackID);
+  RefPtr<TrackPort> trackPort =
+    new TrackPort(inputPort, &aTrack, TrackPort::InputPortOwnership::OWNED);
+  mTracks.AppendElement(trackPort.forget());
+  NotifyTrackAdded(&aTrack);
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Added track %p", this, &aTrack));
+}
+
+void
+DOMMediaStream::RemoveTrack(MediaStreamTrack& aTrack)
+{
+  LOG(LogLevel::Info, ("DOMMediaStream %p Removing track %p (from stream %p with ID %d)",
+                       this, &aTrack, aTrack.mOwningStream.get(), aTrack.mTrackID));
+
+  RefPtr<TrackPort> toRemove = FindPlaybackTrackPort(aTrack);
+  if (!toRemove) {
+    LOG(LogLevel::Debug, ("DOMMediaStream %p does not contain track %p", this, &aTrack));
+    return;
+  }
+
+  DebugOnly<bool> removed = mTracks.RemoveElement(toRemove);
+  NS_ASSERTION(removed, "If there's a track port we should be able to remove it");
+
+  // If the track comes from a TRACK_ANY input port (i.e., mOwnedPort), we need
+  // to block it in the port. Doing this for a locked track is still OK as it
+  // will first block the track, then destroy the port. Both cause the track to
+  // end.
+  // If the track has already ended, it's input port might be gone, so in those
+  // cases blocking the underlying track should be avoided.
+  if (!aTrack.Ended()) {
+    BlockPlaybackTrack(toRemove);
+    NotifyTrackRemoved(&aTrack);
+  }
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Removed track %p", this, &aTrack));
+}
+
+class ClonedStreamSourceGetter :
+  public MediaStreamTrackSourceGetter
+{
+public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(ClonedStreamSourceGetter,
+                                           MediaStreamTrackSourceGetter)
+
+  explicit ClonedStreamSourceGetter(DOMMediaStream* aStream)
+    : mStream(aStream) {}
+
+  already_AddRefed<MediaStreamTrackSource>
+  GetMediaStreamTrackSource(TrackID aInputTrackID) override
+  {
+    MediaStreamTrack* sourceTrack =
+      mStream->FindOwnedDOMTrack(mStream->GetOwnedStream(), aInputTrackID);
+    MOZ_RELEASE_ASSERT(sourceTrack);
+
+    return do_AddRef(&sourceTrack->GetSource());
+  }
+
+protected:
+  virtual ~ClonedStreamSourceGetter() {}
+
+  RefPtr<DOMMediaStream> mStream;
+};
+
+NS_IMPL_ADDREF_INHERITED(ClonedStreamSourceGetter,
+                         MediaStreamTrackSourceGetter)
+NS_IMPL_RELEASE_INHERITED(ClonedStreamSourceGetter,
+                          MediaStreamTrackSourceGetter)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(ClonedStreamSourceGetter)
+NS_INTERFACE_MAP_END_INHERITING(MediaStreamTrackSourceGetter)
+NS_IMPL_CYCLE_COLLECTION_INHERITED(ClonedStreamSourceGetter,
+                                   MediaStreamTrackSourceGetter,
+                                   mStream)
+
+already_AddRefed<DOMMediaStream>
+DOMMediaStream::Clone()
+{
+  return CloneInternal(TrackForwardingOption::CURRENT);
+}
+
+already_AddRefed<DOMMediaStream>
+DOMMediaStream::CloneInternal(TrackForwardingOption aForwarding)
+{
+  RefPtr<DOMMediaStream> newStream =
+    new DOMMediaStream(GetParentObject(), new ClonedStreamSourceGetter(this));
+
+  LOG(LogLevel::Info, ("DOMMediaStream %p created clone %p, forwarding %s tracks",
+                       this, newStream.get(),
+                       aForwarding == TrackForwardingOption::ALL
+                         ? "all" : "current"));
+
+  MOZ_RELEASE_ASSERT(mPlaybackStream);
+  MOZ_RELEASE_ASSERT(mPlaybackStream->Graph());
+  MediaStreamGraph* graph = mPlaybackStream->Graph();
+
+  // We initiate the owned and playback streams first, since we need to create
+  // all existing DOM tracks before we add the generic input port from
+  // mInputStream to mOwnedStream (see AllocateInputPort wrt. destination
+  // TrackID as to why).
+  newStream->InitOwnedStreamCommon(graph);
+  newStream->InitPlaybackStreamCommon(graph);
+
+  // Set up existing DOM tracks.
+  TrackID allocatedTrackID = 1;
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    MediaStreamTrack& track = *info->GetTrack();
+
+    LOG(LogLevel::Debug, ("DOMMediaStream %p forwarding external track %p to clone %p",
+                          this, &track, newStream.get()));
+    RefPtr<MediaStreamTrack> trackClone =
+      newStream->CloneDOMTrack(track, allocatedTrackID++);
+  }
+
+  if (aForwarding == TrackForwardingOption::ALL) {
+    // Set up an input port from our input stream to the new DOM stream's owned
+    // stream, to allow for dynamically added tracks at the source to appear in
+    // the clone. The clone may treat mInputStream as its own mInputStream but
+    // ownership remains with us.
+    newStream->mInputStream = mInputStream;
+    if (mInputStream) {
+      // We have already set up track-locked input ports for all existing DOM
+      // tracks, so now we need to block those in the generic input port to
+      // avoid ending up with double instances of them.
+      nsTArray<TrackID> tracksToBlock;
+      for (const RefPtr<TrackPort>& info : mOwnedTracks) {
+        tracksToBlock.AppendElement(info->GetTrack()->mTrackID);
+      }
+
+      newStream->mInputStream->RegisterUser();
+      newStream->mOwnedPort =
+        newStream->mOwnedStream->AllocateInputPort(mInputStream,
+                                                   TRACK_ANY, TRACK_ANY, 0, 0,
+                                                   &tracksToBlock);
+    }
+  }
+
+  return newStream.forget();
+}
+
+bool
+DOMMediaStream::Active() const
+{
+  return mActive;
+}
+
+MediaStreamTrack*
+DOMMediaStream::GetTrackById(const nsAString& aId) const
+{
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    nsString id;
+    info->GetTrack()->GetId(id);
+    if (id == aId) {
+      return info->GetTrack();
+    }
+  }
+  return nullptr;
+}
+
+MediaStreamTrack*
+DOMMediaStream::GetOwnedTrackById(const nsAString& aId)
+{
+  for (const RefPtr<TrackPort>& info : mOwnedTracks) {
+    nsString id;
+    info->GetTrack()->GetId(id);
+    if (id == aId) {
+      return info->GetTrack();
+    }
+  }
+  return nullptr;
+}
+
+bool
+DOMMediaStream::HasTrack(const MediaStreamTrack& aTrack) const
+{
+  return !!FindPlaybackTrackPort(aTrack);
+}
+
+bool
+DOMMediaStream::OwnsTrack(const MediaStreamTrack& aTrack) const
+{
+  return !!FindOwnedTrackPort(aTrack);
+}
+
+bool
+DOMMediaStream::AddDirectListener(DirectMediaStreamListener* aListener)
+{
+  if (GetInputStream() && GetInputStream()->AsSourceStream()) {
+    GetInputStream()->AsSourceStream()->AddDirectListener(aListener);
+    return true; // application should ignore NotifyQueuedTrackData
+  }
+  return false;
+}
+
+void
+DOMMediaStream::RemoveDirectListener(DirectMediaStreamListener* aListener)
+{
+  if (GetInputStream() && GetInputStream()->AsSourceStream()) {
+    GetInputStream()->AsSourceStream()->RemoveDirectListener(aListener);
+  }
+}
+
+bool
+DOMMediaStream::IsFinished() const
+{
+  return !mPlaybackStream || mPlaybackStream->IsFinished();
+}
+
+void
+DOMMediaStream::SetInactiveOnFinish()
+{
+  mSetInactiveOnFinish = true;
+}
+
+void
+DOMMediaStream::InitSourceStream(MediaStreamGraph* aGraph)
+{
+  InitInputStreamCommon(aGraph->CreateSourceStream(), aGraph);
+  InitOwnedStreamCommon(aGraph);
+  InitPlaybackStreamCommon(aGraph);
+}
+
+void
+DOMMediaStream::InitTrackUnionStream(MediaStreamGraph* aGraph)
+{
+  InitInputStreamCommon(aGraph->CreateTrackUnionStream(), aGraph);
+  InitOwnedStreamCommon(aGraph);
+  InitPlaybackStreamCommon(aGraph);
+}
+
+void
+DOMMediaStream::InitAudioCaptureStream(nsIPrincipal* aPrincipal, MediaStreamGraph* aGraph)
+{
+  const TrackID AUDIO_TRACK = 1;
+
+  RefPtr<BasicTrackSource> audioCaptureSource =
+    new BasicTrackSource(aPrincipal, MediaSourceEnum::AudioCapture);
+
+  AudioCaptureStream* audioCaptureStream =
+    static_cast<AudioCaptureStream*>(aGraph->CreateAudioCaptureStream(AUDIO_TRACK));
+  InitInputStreamCommon(audioCaptureStream, aGraph);
+  InitOwnedStreamCommon(aGraph);
+  InitPlaybackStreamCommon(aGraph);
+  RefPtr<MediaStreamTrack> track =
+    CreateDOMTrack(AUDIO_TRACK, MediaSegment::AUDIO, audioCaptureSource);
+  AddTrackInternal(track);
+
+  audioCaptureStream->Start();
+}
+
+void
+DOMMediaStream::InitInputStreamCommon(MediaStream* aStream,
+                                      MediaStreamGraph* aGraph)
+{
+  MOZ_ASSERT(!mOwnedStream, "Input stream must be initialized before owned stream");
+
+  mInputStream = aStream;
+  mInputStream->RegisterUser();
+}
+
+void
+DOMMediaStream::InitOwnedStreamCommon(MediaStreamGraph* aGraph)
+{
+  MOZ_ASSERT(!mPlaybackStream, "Owned stream must be initialized before playback stream");
+
+  mOwnedStream = aGraph->CreateTrackUnionStream();
+  mOwnedStream->SetAutofinish(true);
+  mOwnedStream->RegisterUser();
+  if (mInputStream) {
+    mOwnedPort = mOwnedStream->AllocateInputPort(mInputStream);
+  }
+
+  // Setup track listeners
+  mOwnedListener = new OwnedStreamListener(this);
+  mOwnedStream->AddListener(mOwnedListener);
+}
+
+void
+DOMMediaStream::InitPlaybackStreamCommon(MediaStreamGraph* aGraph)
+{
+  mPlaybackStream = aGraph->CreateTrackUnionStream();
+  mPlaybackStream->SetAutofinish(true);
+  mPlaybackStream->RegisterUser();
+  if (mOwnedStream) {
+    mPlaybackPort = mPlaybackStream->AllocateInputPort(mOwnedStream);
+  }
+
+  mPlaybackListener = new PlaybackStreamListener(this);
+  mPlaybackStream->AddListener(mPlaybackListener);
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Initiated with mInputStream=%p, mOwnedStream=%p, mPlaybackStream=%p",
+                        this, mInputStream, mOwnedStream, mPlaybackStream));
+}
+
+already_AddRefed<DOMMediaStream>
+DOMMediaStream::CreateSourceStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                          MediaStreamGraph* aGraph,
+                                          MediaStreamTrackSourceGetter* aTrackSourceGetter)
+{
+  RefPtr<DOMMediaStream> stream = new DOMMediaStream(aWindow, aTrackSourceGetter);
+  stream->InitSourceStream(aGraph);
+  return stream.forget();
+}
+
+already_AddRefed<DOMMediaStream>
+DOMMediaStream::CreateTrackUnionStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                              MediaStreamGraph* aGraph,
+                                              MediaStreamTrackSourceGetter* aTrackSourceGetter)
+{
+  RefPtr<DOMMediaStream> stream = new DOMMediaStream(aWindow, aTrackSourceGetter);
+  stream->InitTrackUnionStream(aGraph);
+  return stream.forget();
+}
+
+already_AddRefed<DOMMediaStream>
+DOMMediaStream::CreateAudioCaptureStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                                nsIPrincipal* aPrincipal,
+                                                MediaStreamGraph* aGraph)
+{
+  // Audio capture doesn't create tracks dynamically
+  MediaStreamTrackSourceGetter* getter = nullptr;
+  RefPtr<DOMMediaStream> stream = new DOMMediaStream(aWindow, getter);
+  stream->InitAudioCaptureStream(aPrincipal, aGraph);
+  return stream.forget();
+}
+
+void
+DOMMediaStream::PrincipalChanged(MediaStreamTrack* aTrack)
+{
+  MOZ_ASSERT(aTrack);
+  NS_ASSERTION(HasTrack(*aTrack), "Principal changed for an unknown track");
+  LOG(LogLevel::Info, ("DOMMediaStream %p Principal changed for track %p",
+                       this, aTrack));
+  RecomputePrincipal();
+}
+
+void
+DOMMediaStream::RecomputePrincipal()
+{
+  nsCOMPtr<nsIPrincipal> previousPrincipal = mPrincipal.forget();
+  nsCOMPtr<nsIPrincipal> previousVideoPrincipal = mVideoPrincipal.forget();
+
+  if (mTracksPendingRemoval > 0) {
+    LOG(LogLevel::Info, ("DOMMediaStream %p RecomputePrincipal() Cannot "
+                         "recompute stream principal with tracks pending "
+                         "removal.", this));
+    return;
+  }
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Recomputing principal. "
+                        "Old principal was %p.", this, previousPrincipal.get()));
+
+  // mPrincipal is recomputed based on all current tracks, and tracks that have
+  // not ended in our playback stream.
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    if (info->GetTrack()->Ended()) {
+      continue;
+    }
+    LOG(LogLevel::Debug, ("DOMMediaStream %p Taking live track %p with "
+                          "principal %p into account.", this,
+                          info->GetTrack(), info->GetTrack()->GetPrincipal()));
+    nsContentUtils::CombineResourcePrincipals(&mPrincipal,
+                                              info->GetTrack()->GetPrincipal());
+    if (info->GetTrack()->AsVideoStreamTrack()) {
+      nsContentUtils::CombineResourcePrincipals(&mVideoPrincipal,
+                                                info->GetTrack()->GetPrincipal());
+    }
+  }
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p new principal is %p.",
+                        this, mPrincipal.get()));
+
+  if (previousPrincipal != mPrincipal ||
+      previousVideoPrincipal != mVideoPrincipal) {
+    NotifyPrincipalChanged();
+  }
+}
+
+void
+DOMMediaStream::NotifyPrincipalChanged()
+{
+  if (!mPrincipal) {
+    // When all tracks are removed, mPrincipal will change to nullptr.
+    LOG(LogLevel::Info, ("DOMMediaStream %p Principal changed to nothing.",
+                         this));
+  } else {
+    LOG(LogLevel::Info, ("DOMMediaStream %p Principal changed. Now: "
+                         "null=%d, codebase=%d, expanded=%d, system=%d", this,
+                          mPrincipal->GetIsNullPrincipal(),
+                          mPrincipal->GetIsCodebasePrincipal(),
+                          mPrincipal->GetIsExpandedPrincipal(),
+                          mPrincipal->GetIsSystemPrincipal()));
+  }
+
+  for (uint32_t i = 0; i < mPrincipalChangeObservers.Length(); ++i) {
+    mPrincipalChangeObservers[i]->PrincipalChanged(this);
+  }
+}
+
+
+bool
+DOMMediaStream::AddPrincipalChangeObserver(
+  PrincipalChangeObserver<DOMMediaStream>* aObserver)
+{
+  return mPrincipalChangeObservers.AppendElement(aObserver) != nullptr;
+}
+
+bool
+DOMMediaStream::RemovePrincipalChangeObserver(
+  PrincipalChangeObserver<DOMMediaStream>* aObserver)
+{
+  return mPrincipalChangeObservers.RemoveElement(aObserver);
+}
+
+void
+DOMMediaStream::AddTrackInternal(MediaStreamTrack* aTrack)
+{
+  MOZ_ASSERT(aTrack->mOwningStream == this);
+  MOZ_ASSERT(FindOwnedDOMTrack(aTrack->GetInputStream(),
+                               aTrack->mInputTrackID,
+                               aTrack->mTrackID));
+  MOZ_ASSERT(!FindPlaybackDOMTrack(aTrack->GetOwnedStream(),
+                                   aTrack->mTrackID));
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Adding owned track %p", this, aTrack));
+
+  mTracks.AppendElement(
+    new TrackPort(mPlaybackPort, aTrack, TrackPort::InputPortOwnership::EXTERNAL));
+
+  NotifyTrackAdded(aTrack);
+
+  DispatchTrackEvent(NS_LITERAL_STRING("addtrack"), aTrack);
+}
+
+already_AddRefed<MediaStreamTrack>
+DOMMediaStream::CreateDOMTrack(TrackID aTrackID, MediaSegment::Type aType,
+                               MediaStreamTrackSource* aSource,
+                               const MediaTrackConstraints& aConstraints)
+{
+  MOZ_RELEASE_ASSERT(mInputStream);
+  MOZ_RELEASE_ASSERT(mOwnedStream);
+
+  MOZ_ASSERT(FindOwnedDOMTrack(GetInputStream(), aTrackID) == nullptr);
+
+  RefPtr<MediaStreamTrack> track;
+  switch (aType) {
+  case MediaSegment::AUDIO:
+    track = new AudioStreamTrack(this, aTrackID, aTrackID, aSource, aConstraints);
+    break;
+  case MediaSegment::VIDEO:
+    track = new VideoStreamTrack(this, aTrackID, aTrackID, aSource, aConstraints);
+    break;
+  default:
+    MOZ_CRASH("Unhandled track type");
+  }
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Created new track %p with ID %u",
+                        this, track.get(), aTrackID));
+
+  mOwnedTracks.AppendElement(
+    new TrackPort(mOwnedPort, track, TrackPort::InputPortOwnership::EXTERNAL));
+
+  return track.forget();
+}
+
+already_AddRefed<MediaStreamTrack>
+DOMMediaStream::CloneDOMTrack(MediaStreamTrack& aTrack,
+                              TrackID aCloneTrackID)
+{
+  MOZ_RELEASE_ASSERT(mOwnedStream);
+  MOZ_RELEASE_ASSERT(mPlaybackStream);
+  MOZ_RELEASE_ASSERT(IsTrackIDExplicit(aCloneTrackID));
+
+  TrackID inputTrackID = aTrack.mInputTrackID;
+  MediaStream* inputStream = aTrack.GetInputStream();
+
+  RefPtr<MediaStreamTrack> newTrack = aTrack.CloneInternal(this, aCloneTrackID);
+
+  newTrack->mOriginalTrack =
+    aTrack.mOriginalTrack ? aTrack.mOriginalTrack.get() : &aTrack;
+
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Created new track %p cloned from stream %p track %d",
+                        this, newTrack.get(), inputStream, inputTrackID));
+
+  RefPtr<MediaInputPort> inputPort =
+    mOwnedStream->AllocateInputPort(inputStream, inputTrackID, aCloneTrackID);
+
+  mOwnedTracks.AppendElement(
+    new TrackPort(inputPort, newTrack, TrackPort::InputPortOwnership::OWNED));
+
+  mTracks.AppendElement(
+    new TrackPort(mPlaybackPort, newTrack, TrackPort::InputPortOwnership::EXTERNAL));
+
+  NotifyTrackAdded(newTrack);
+
+  newTrack->SetEnabled(aTrack.Enabled());
+  newTrack->SetReadyState(aTrack.ReadyState());
+
+  if (aTrack.Ended()) {
+    // For extra suspenders, make sure that we don't forward data by mistake
+    // to the clone when the original has already ended.
+    // We only block END_EXISTING to allow any pending clones to end.
+    RefPtr<Pledge<bool, nsresult>> blockingPledge =
+      inputPort->BlockSourceTrackId(inputTrackID,
+                                    BlockingMode::END_EXISTING);
+    Unused << blockingPledge;
+  }
+
+  return newTrack.forget();
+}
+
+static DOMMediaStream::TrackPort*
+FindTrackPortAmongTracks(const MediaStreamTrack& aTrack,
+                         const nsTArray<RefPtr<DOMMediaStream::TrackPort>>& aTracks)
+{
+  for (const RefPtr<DOMMediaStream::TrackPort>& info : aTracks) {
+    if (info->GetTrack() == &aTrack) {
+      return info;
+    }
+  }
+  return nullptr;
+}
+
+MediaStreamTrack*
+DOMMediaStream::FindOwnedDOMTrack(MediaStream* aInputStream,
+                                  TrackID aInputTrackID,
+                                  TrackID aTrackID) const
+{
+  MOZ_RELEASE_ASSERT(mOwnedStream);
+
+  for (const RefPtr<TrackPort>& info : mOwnedTracks) {
+    if (info->GetInputPort() &&
+        info->GetInputPort()->GetSource() == aInputStream &&
+        info->GetTrack()->mInputTrackID == aInputTrackID &&
+        (aTrackID == TRACK_ANY || info->GetTrack()->mTrackID == aTrackID)) {
+      // This track is owned externally but in our playback stream.
+      return info->GetTrack();
+    }
+  }
+  return nullptr;
+}
+
+DOMMediaStream::TrackPort*
+DOMMediaStream::FindOwnedTrackPort(const MediaStreamTrack& aTrack) const
+{
+  return FindTrackPortAmongTracks(aTrack, mOwnedTracks);
+}
+
+
+MediaStreamTrack*
+DOMMediaStream::FindPlaybackDOMTrack(MediaStream* aInputStream, TrackID aInputTrackID) const
+{
+  if (!mPlaybackStream) {
+    // One would think we can assert mPlaybackStream here, but track clones have
+    // a dummy DOMMediaStream that doesn't have a playback stream, so we can't.
+    return nullptr;
+  }
+
+  for (const RefPtr<TrackPort>& info : mTracks) {
+    if (info->GetInputPort() == mPlaybackPort &&
+        aInputStream == mOwnedStream &&
+        info->GetTrack()->mInputTrackID == aInputTrackID) {
+      // This track is in our owned and playback streams.
+      return info->GetTrack();
+    }
+    if (info->GetInputPort() &&
+        info->GetInputPort()->GetSource() == aInputStream &&
+        info->GetSourceTrackId() == aInputTrackID) {
+      // This track is owned externally but in our playback stream.
+      MOZ_ASSERT(IsTrackIDExplicit(aInputTrackID));
+      return info->GetTrack();
+    }
+  }
+  return nullptr;
+}
+
+DOMMediaStream::TrackPort*
+DOMMediaStream::FindPlaybackTrackPort(const MediaStreamTrack& aTrack) const
+{
+  return FindTrackPortAmongTracks(aTrack, mTracks);
+}
+
+void
+DOMMediaStream::OnTracksAvailable(OnTracksAvailableCallback* aRunnable)
+{
+  if (mNotifiedOfMediaStreamGraphShutdown) {
+    // No more tracks will ever be added, so just delete the callback now.
+    delete aRunnable;
+    return;
+  }
+  mRunOnTracksAvailable.AppendElement(aRunnable);
+  CheckTracksAvailable();
+}
+
+void
+DOMMediaStream::NotifyTracksCreated()
+{
+  mTracksCreated = true;
+  CheckTracksAvailable();
+}
+
+void
+DOMMediaStream::NotifyFinished()
+{
+  if (!mSetInactiveOnFinish) {
+    return;
+  }
+
+  if (!mActive) {
+    // This can happen if the stream never became active.
+    return;
+  }
+
+  MOZ_ASSERT(!ContainsLiveTracks(mTracks));
+  mActive = false;
+  NotifyInactive();
+}
+
+void
+DOMMediaStream::NotifyActive()
+{
+  LOG(LogLevel::Info, ("DOMMediaStream %p NotifyActive(). ", this));
+
+  MOZ_ASSERT(mActive);
+  for (int32_t i = mTrackListeners.Length() - 1; i >= 0; --i) {
+    mTrackListeners[i]->NotifyActive();
+  }
+}
+
+void
+DOMMediaStream::NotifyInactive()
+{
+  LOG(LogLevel::Info, ("DOMMediaStream %p NotifyInactive(). ", this));
+
+  MOZ_ASSERT(!mActive);
+  for (int32_t i = mTrackListeners.Length() - 1; i >= 0; --i) {
+    mTrackListeners[i]->NotifyInactive();
+  }
+}
+
+void
+DOMMediaStream::CheckTracksAvailable()
+{
+  if (!mTracksCreated) {
+    return;
+  }
+  nsTArray<nsAutoPtr<OnTracksAvailableCallback> > callbacks;
+  callbacks.SwapElements(mRunOnTracksAvailable);
+
+  for (uint32_t i = 0; i < callbacks.Length(); ++i) {
+    callbacks[i]->NotifyTracksAvailable(this);
+  }
+}
+
+void
+DOMMediaStream::RegisterTrackListener(TrackListener* aListener)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mNotifiedOfMediaStreamGraphShutdown) {
+    // No more tracks will ever be added, so just do nothing.
+    return;
+  }
+  mTrackListeners.AppendElement(aListener);
+}
+
+void
+DOMMediaStream::UnregisterTrackListener(TrackListener* aListener)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+  mTrackListeners.RemoveElement(aListener);
+}
+
+void
+DOMMediaStream::NotifyTrackAdded(const RefPtr<MediaStreamTrack>& aTrack)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mTracksPendingRemoval > 0) {
+    // If there are tracks pending removal we may not degrade the current
+    // principals until those tracks have been confirmed removed from the
+    // playback stream. Instead combine with the new track and the (potentially)
+    // degraded principal will be calculated when it's safe.
+    nsContentUtils::CombineResourcePrincipals(&mPrincipal,
+                                              aTrack->GetPrincipal());
+    LOG(LogLevel::Debug, ("DOMMediaStream %p saw a track get added. Combining "
+                          "its principal %p into our while waiting for pending "
+                          "tracks to be removed. New principal is %p.",
+                          this, aTrack->GetPrincipal(), mPrincipal.get()));
+    if (aTrack->AsVideoStreamTrack()) {
+      nsContentUtils::CombineResourcePrincipals(&mVideoPrincipal,
+                                                aTrack->GetPrincipal());
+    }
+  } else {
+    LOG(LogLevel::Debug, ("DOMMediaStream %p saw a track get added. "
+                          "Recomputing principal.", this));
+    RecomputePrincipal();
+  }
+
+  aTrack->AddPrincipalChangeObserver(this);
+  aTrack->AddConsumer(mPlaybackTrackListener);
+
+  for (int32_t i = mTrackListeners.Length() - 1; i >= 0; --i) {
+    mTrackListeners[i]->NotifyTrackAdded(aTrack);
+  }
+
+  if (mActive) {
+    return;
+  }
+
+  // Check if we became active.
+  if (ContainsLiveTracks(mTracks)) {
+    mActive = true;
+    NotifyActive();
+  }
+}
+
+void
+DOMMediaStream::NotifyTrackRemoved(const RefPtr<MediaStreamTrack>& aTrack)
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  aTrack->RemoveConsumer(mPlaybackTrackListener);
+  aTrack->RemovePrincipalChangeObserver(this);
+
+  for (int32_t i = mTrackListeners.Length() - 1; i >= 0; --i) {
+    mTrackListeners[i]->NotifyTrackRemoved(aTrack);
+
+  }
+
+  // Don't call RecomputePrincipal here as the track may still exist in the
+  // playback stream in the MediaStreamGraph. It will instead be called when the
+  // track has been confirmed removed by the graph. See BlockPlaybackTrack().
+
+  if (!mActive) {
+    NS_ASSERTION(false, "Shouldn't remove a live track if already inactive");
+    return;
+  }
+
+  if (mSetInactiveOnFinish) {
+    // For compatibility with mozCaptureStream we in some cases do not go
+    // inactive until the playback stream finishes.
+    return;
+  }
+
+  // Check if we became inactive.
+  if (!ContainsLiveTracks(mTracks)) {
+    mActive = false;
+    NotifyInactive();
+  }
+}
+
+nsresult
+DOMMediaStream::DispatchTrackEvent(const nsAString& aName,
+                                   const RefPtr<MediaStreamTrack>& aTrack)
+{
+  MOZ_ASSERT(aName == NS_LITERAL_STRING("addtrack"),
+             "Only 'addtrack' is supported at this time");
+
+  MediaStreamTrackEventInit init;
+  init.mTrack = aTrack;
+
+  RefPtr<MediaStreamTrackEvent> event =
+    MediaStreamTrackEvent::Constructor(this, aName, init);
+
+  return DispatchTrustedEvent(event);
+}
+
+void
+DOMMediaStream::BlockPlaybackTrack(TrackPort* aTrack)
+{
+  MOZ_ASSERT(aTrack);
+  ++mTracksPendingRemoval;
+  RefPtr<Pledge<bool>> p =
+    aTrack->BlockSourceTrackId(aTrack->GetTrack()->mTrackID,
+                               BlockingMode::CREATION);
+  RefPtr<DOMMediaStream> self = this;
+  p->Then([self] (const bool& aIgnore) { self->NotifyPlaybackTrackBlocked(); },
+          [] (const nsresult& aIgnore) { NS_ERROR("Could not remove track from MSG"); }
+  );
+}
+
+void
+DOMMediaStream::NotifyPlaybackTrackBlocked()
+{
+  MOZ_ASSERT(mTracksPendingRemoval > 0,
+             "A track reported finished blocking more times than we asked for");
+  if (--mTracksPendingRemoval == 0) {
+    // The MediaStreamGraph has reported a track was blocked and we are not
+    // waiting for any further tracks to get blocked. It is now safe to
+    // recompute the principal based on our main thread track set state.
+    LOG(LogLevel::Debug, ("DOMMediaStream %p saw all tracks pending removal "
+                          "finish. Recomputing principal.", this));
+    RecomputePrincipal();
+  }
+}
+
+DOMLocalMediaStream::~DOMLocalMediaStream()
+{
+  if (mInputStream) {
+    // Make sure Listeners of this stream know it's going away
+    StopImpl();
+  }
+}
+
+JSObject*
+DOMLocalMediaStream::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+  return dom::LocalMediaStreamBinding::Wrap(aCx, this, aGivenProto);
+}
+
+void
+DOMLocalMediaStream::Stop()
+{
+  LOG(LogLevel::Debug, ("DOMMediaStream %p Stop()", this));
+  nsCOMPtr<nsPIDOMWindowInner> pWindow = GetParentObject();
+  nsIDocument* document = pWindow ? pWindow->GetExtantDoc() : nullptr;
+  nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
+                                  NS_LITERAL_CSTRING("Media"),
+                                  document,
+                                  nsContentUtils::eDOM_PROPERTIES,
+                                  "MediaStreamStopDeprecatedWarning");
+
+  StopImpl();
+}
+
+void
+DOMLocalMediaStream::StopImpl()
+{
+  if (mInputStream && mInputStream->AsSourceStream()) {
+    mInputStream->AsSourceStream()->EndAllTrackAndFinish();
+  }
+}
+
+already_AddRefed<DOMLocalMediaStream>
+DOMLocalMediaStream::CreateSourceStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                               MediaStreamGraph* aGraph,
+                                               MediaStreamTrackSourceGetter* aTrackSourceGetter)
+{
+  RefPtr<DOMLocalMediaStream> stream =
+    new DOMLocalMediaStream(aWindow, aTrackSourceGetter);
+  stream->InitSourceStream(aGraph);
+  return stream.forget();
+}
+
+already_AddRefed<DOMLocalMediaStream>
+DOMLocalMediaStream::CreateTrackUnionStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                                   MediaStreamGraph* aGraph,
+                                                   MediaStreamTrackSourceGetter* aTrackSourceGetter)
+{
+  RefPtr<DOMLocalMediaStream> stream =
+    new DOMLocalMediaStream(aWindow, aTrackSourceGetter);
+  stream->InitTrackUnionStream(aGraph);
+  return stream.forget();
+}
+
+DOMAudioNodeMediaStream::DOMAudioNodeMediaStream(nsPIDOMWindowInner* aWindow, AudioNode* aNode)
+  : DOMMediaStream(aWindow, nullptr),
+    mStreamNode(aNode)
+{
+}
+
+DOMAudioNodeMediaStream::~DOMAudioNodeMediaStream()
+{
+}
+
+already_AddRefed<DOMAudioNodeMediaStream>
+DOMAudioNodeMediaStream::CreateTrackUnionStreamAsInput(nsPIDOMWindowInner* aWindow,
+                                                       AudioNode* aNode,
+                                                       MediaStreamGraph* aGraph)
+{
+  RefPtr<DOMAudioNodeMediaStream> stream = new DOMAudioNodeMediaStream(aWindow, aNode);
+  stream->InitTrackUnionStream(aGraph);
+  return stream.forget();
+}
+
+DOMHwMediaStream::DOMHwMediaStream(nsPIDOMWindowInner* aWindow)
+  : DOMLocalMediaStream(aWindow, nullptr)
+{
+#ifdef MOZ_WIDGET_GONK
+  if (!mWindow) {
+    NS_ERROR("Expected window here.");
+    mPrincipalHandle = PRINCIPAL_HANDLE_NONE;
+    return;
+  }
+  nsIDocument* doc = mWindow->GetExtantDoc();
+  if (!doc) {
+    NS_ERROR("Expected document here.");
+    mPrincipalHandle = PRINCIPAL_HANDLE_NONE;
+    return;
+  }
+  mPrincipalHandle = MakePrincipalHandle(doc->NodePrincipal());
+#endif
+}
+
+DOMHwMediaStream::~DOMHwMediaStream()
+{
+}
+
+already_AddRefed<DOMHwMediaStream>
+DOMHwMediaStream::CreateHwStream(nsPIDOMWindowInner* aWindow,
+                                 OverlayImage* aImage)
+{
+  RefPtr<DOMHwMediaStream> stream = new DOMHwMediaStream(aWindow);
+
+  MediaStreamGraph* graph =
+    MediaStreamGraph::GetInstance(MediaStreamGraph::SYSTEM_THREAD_DRIVER,
+                                  AudioChannel::Normal);
+  stream->InitSourceStream(graph);
+  stream->Init(stream->GetInputStream(), aImage);
+
+  return stream.forget();
+}
+
+void
+DOMHwMediaStream::Init(MediaStream* stream, OverlayImage* aImage)
+{
+  SourceMediaStream* srcStream = stream->AsSourceStream();
+
+#ifdef MOZ_WIDGET_GONK
+  if (aImage) {
+    mOverlayImage = aImage;
+  } else {
+    Data imageData;
+    imageData.mOverlayId = DEFAULT_IMAGE_ID;
+    imageData.mSize.width = DEFAULT_IMAGE_WIDTH;
+    imageData.mSize.height = DEFAULT_IMAGE_HEIGHT;
+
+    mOverlayImage = new OverlayImage();
+    mOverlayImage->SetData(imageData);
+  }
+#endif
+
+  if (srcStream) {
+    VideoSegment segment;
+#ifdef MOZ_WIDGET_GONK
+    const StreamTime delta = STREAM_TIME_MAX; // Because MediaStreamGraph will run out frames in non-autoplay mode,
+                                              // we must give it bigger frame length to cover this situation.
+
+    RefPtr<Image> image = static_cast<Image*>(mOverlayImage.get());
+    mozilla::gfx::IntSize size = image->GetSize();
+
+    segment.AppendFrame(image.forget(), delta, size, mPrincipalHandle);
+#endif
+    srcStream->AddTrack(TRACK_VIDEO_PRIMARY, 0, new VideoSegment());
+    srcStream->AppendToTrack(TRACK_VIDEO_PRIMARY, &segment);
+    srcStream->AdvanceKnownTracksTime(STREAM_TIME_MAX);
+  }
+}
+
+int32_t
+DOMHwMediaStream::RequestOverlayId()
+{
+#ifdef MOZ_WIDGET_GONK
+  return mOverlayImage->GetOverlayId();
+#else
+  return -1;
+#endif
+}
+
+void
+DOMHwMediaStream::SetImageSize(uint32_t width, uint32_t height)
+{
+#ifdef MOZ_WIDGET_GONK
+  if (mOverlayImage->GetSidebandStream().IsValid()) {
+    OverlayImage::SidebandStreamData imgData;
+    imgData.mStream = mOverlayImage->GetSidebandStream();
+    imgData.mSize = IntSize(width, height);
+    mOverlayImage->SetData(imgData);
+  } else {
+    OverlayImage::Data imgData;
+    imgData.mOverlayId = mOverlayImage->GetOverlayId();
+    imgData.mSize = IntSize(width, height);
+    mOverlayImage->SetData(imgData);
+  }
+#endif
+
+  SourceMediaStream* srcStream = GetInputStream()->AsSourceStream();
+  StreamTracks::Track* track = srcStream->FindTrack(TRACK_VIDEO_PRIMARY);
+
+  if (!track || !track->GetSegment()) {
+    return;
+  }
+
+#ifdef MOZ_WIDGET_GONK
+  // Clear the old segment.
+  // Changing the existing content of segment is a Very BAD thing, and this way will
+  // confuse consumers of MediaStreams.
+  // It is only acceptable for DOMHwMediaStream
+  // because DOMHwMediaStream doesn't have consumers of TV streams currently.
+  track->GetSegment()->Clear();
+
+  // Change the image size.
+  const StreamTime delta = STREAM_TIME_MAX;
+  RefPtr<Image> image = static_cast<Image*>(mOverlayImage.get());
+  mozilla::gfx::IntSize size = image->GetSize();
+  VideoSegment segment;
+
+  segment.AppendFrame(image.forget(), delta, size, mPrincipalHandle);
+  srcStream->AppendToTrack(TRACK_VIDEO_PRIMARY, &segment);
+#endif
+}
+
+void
+DOMHwMediaStream::SetOverlayImage(OverlayImage* aImage)
+{
+  if (!aImage) {
+    return;
+  }
+#ifdef MOZ_WIDGET_GONK
+  mOverlayImage = aImage;
+#endif
+
+  SourceMediaStream* srcStream = GetInputStream()->AsSourceStream();
+  StreamTracks::Track* track = srcStream->FindTrack(TRACK_VIDEO_PRIMARY);
+
+  if (!track || !track->GetSegment()) {
+    return;
+  }
+
+#ifdef MOZ_WIDGET_GONK
+  // Clear the old segment.
+  // Changing the existing content of segment is a Very BAD thing, and this way will
+  // confuse consumers of MediaStreams.
+  // It is only acceptable for DOMHwMediaStream
+  // because DOMHwMediaStream doesn't have consumers of TV streams currently.
+  track->GetSegment()->Clear();
+
+  // Change the image size.
+  const StreamTime delta = STREAM_TIME_MAX;
+  RefPtr<Image> image = static_cast<Image*>(mOverlayImage.get());
+  mozilla::gfx::IntSize size = image->GetSize();
+  VideoSegment segment;
+
+  segment.AppendFrame(image.forget(), delta, size, mPrincipalHandle);
+  srcStream->AppendToTrack(TRACK_VIDEO_PRIMARY, &segment);
+#endif
+}
+
+void
+DOMHwMediaStream::SetOverlayId(int32_t aOverlayId)
+{
+#ifdef MOZ_WIDGET_GONK
+  OverlayImage::Data imgData;
+
+  imgData.mOverlayId = aOverlayId;
+  imgData.mSize = mOverlayImage->GetSize();
+
+  mOverlayImage->SetData(imgData);
+#endif
+}