--- a/dom/media/DOMMediaStream.cpp
+++ b/dom/media/DOMMediaStream.cpp
@@ -505,17 +505,17 @@ DOMMediaStream::AddTrack(MediaStreamTrac
 
   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.GetStream(), aTrack.GetTrackID()));
+                       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);
@@ -536,42 +536,42 @@ DOMMediaStream::AddTrack(MediaStreamTrac
     return;
   }
 
   CombineWithPrincipal(aTrack.GetPrincipal());
 
   // Hook up the underlying track with our underlying playback stream.
   RefPtr<MediaInputPort> inputPort =
     GetPlaybackStream()->AllocateInputPort(aTrack.GetOwnedStream(),
-                                           aTrack.GetTrackID());
+                                           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.GetStream(), aTrack.GetTrackID()));
+                       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;
   }
 
   // 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.
-  toRemove->BlockTrackId(aTrack.GetTrackID());
+  toRemove->BlockTrackId(aTrack.mTrackID);
 
   DebugOnly<bool> removed = mTracks.RemoveElement(toRemove);
   MOZ_ASSERT(removed);
   LOG(LogLevel::Debug, ("DOMMediaStream %p Removed track %p", this, &aTrack));
 }
 
 bool
 DOMMediaStream::HasTrack(const MediaStreamTrack& aTrack) const
@@ -797,17 +797,17 @@ MediaStreamTrack*
 DOMMediaStream::FindOwnedDOMTrack(MediaStream* aInputStream,
                                   TrackID aInputTrackID) const
 {
   MOZ_RELEASE_ASSERT(mOwnedStream);
 
   for (const RefPtr<TrackPort>& info : mOwnedTracks) {
     if (info->GetInputPort() &&
         info->GetInputPort()->GetSource() == aInputStream &&
-        info->GetTrack()->GetInputTrackID() == aInputTrackID) {
+        info->GetTrack()->mInputTrackID == aInputTrackID) {
       // This track is owned externally but in our playback stream.
       return info->GetTrack();
     }
   }
   return nullptr;
 }
 
 DOMMediaStream::TrackPort*
@@ -825,17 +825,17 @@ DOMMediaStream::FindOwnedTrackPort(const
 MediaStreamTrack*
 DOMMediaStream::FindPlaybackDOMTrack(MediaStream* aInputStream, TrackID aInputTrackID) const
 {
   MOZ_RELEASE_ASSERT(mPlaybackStream);
 
   for (const RefPtr<TrackPort>& info : mTracks) {
     if (info->GetInputPort() == mPlaybackPort &&
         aInputStream == mOwnedStream &&
-        info->GetTrack()->GetInputTrackID() == aInputTrackID) {
+        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));

--- a/dom/media/MediaStreamTrack.cpp
+++ b/dom/media/MediaStreamTrack.cpp
@@ -113,17 +113,17 @@ MediaStreamTrack::ApplyConstraints(const
   if (MOZ_LOG_TEST(gMediaStreamTrackLog, LogLevel::Info)) {
     nsString str;
     aConstraints.ToJSON(str);
 
     LOG(LogLevel::Info, ("MediaStreamTrack %p ApplyConstraints() with "
                          "constraints %s", this, NS_ConvertUTF16toUTF8(str).get()));
   }
 
-  return GetStream()->ApplyConstraintsToTrack(mTrackID, aConstraints, aRv);
+  return mOwningStream->ApplyConstraintsToTrack(mTrackID, aConstraints, aRv);
 }
 
 nsIPrincipal*
 MediaStreamTrack::GetPrincipal()
 {
   return mOwningStream->GetPrincipal();
 }
 
@@ -133,32 +133,32 @@ MediaStreamTrack::Graph()
   return GetOwnedStream()->Graph();
 }
 
 DOMMediaStream*
 MediaStreamTrack::GetInputDOMStream()
 {
   MediaStreamTrack* originalTrack =
     mOriginalTrack ? mOriginalTrack.get() : this;
-  MOZ_RELEASE_ASSERT(originalTrack->GetStream());
-  return originalTrack->GetStream();
+  MOZ_RELEASE_ASSERT(originalTrack->mOwningStream);
+  return originalTrack->mOwningStream;
 }
 
 MediaStream*
 MediaStreamTrack::GetInputStream()
 {
   DOMMediaStream* inputDOMStream = GetInputDOMStream();
   MOZ_RELEASE_ASSERT(inputDOMStream->GetInputStream());
   return inputDOMStream->GetInputStream();
 }
 
 ProcessedMediaStream*
 MediaStreamTrack::GetOwnedStream()
 {
-  return GetStream()->GetOwnedStream();
+  return mOwningStream->GetOwnedStream();
 }
 
 bool
 MediaStreamTrack::AddPrincipalChangeObserver(PrincipalChangeObserver* aObserver)
 {
   PrincipalChangeObserverForwarder* observer =
     mPrincipalChangeObservers.AppendElement();
   observer->Init(aObserver, this);

--- a/dom/media/MediaStreamTrack.h
+++ b/dom/media/MediaStreamTrack.h
@@ -16,16 +16,17 @@
 namespace mozilla {
 
 class MediaEnginePhotoCallback;
 class MediaStream;
 class MediaStreamGraph;
 class MediaStreamListener;
 class PeerConnectionImpl;
 class ProcessedMediaStream;
+class RemoteSourceStreamInfo;
 
 namespace dom {
 
 class AudioStreamTrack;
 class VideoStreamTrack;
 
 /**
  * Common interface through which a MediaStreamTrack can communicate with its
@@ -133,51 +134,35 @@ protected:
 /**
  * Class representing a track in a DOMMediaStream.
  */
 class MediaStreamTrack : public DOMEventTargetHelper {
   // DOMMediaStream owns MediaStreamTrack instances, and requires access to
   // some internal state, e.g., GetInputStream(), GetOwnedStream().
   friend class mozilla::DOMMediaStream;
 
-  // PeerConnectionImpl.cpp needs to know our owning DOMStream and bound track id.
+  // PeerConnection and friends need to know our owning DOMStream and track id.
   friend class mozilla::PeerConnectionImpl;
+  friend class mozilla::RemoteSourceStreamInfo;
 
 public:
   /**
    * aTrackID is the MediaStreamGraph track ID for the track in the
    * MediaStream owned by aStream.
    */
   MediaStreamTrack(DOMMediaStream* aStream, TrackID aTrackID,
                    TrackID aInputTrackID,
                    MediaStreamTrackSource* aSource);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MediaStreamTrack,
                                            DOMEventTargetHelper)
 
-  DOMMediaStream* GetParentObject() const { return mOwningStream; }
   virtual JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) override = 0;
 
-  /**
-   * Returns the DOMMediaStream owning this track.
-   */
-  DOMMediaStream* GetStream() const { return mOwningStream; }
-
-  /**
-   * Returns the TrackID this stream has in its owning DOMMediaStream's Owned
-   * stream.
-   */
-  TrackID GetTrackID() const { return mTrackID; }
-
-  /**
-   * Returns the TrackID this MediaStreamTrack has in its input MSG-MediaStream.
-   */
-  TrackID GetInputTrackID() const { return mInputTrackID; }
-
   virtual AudioStreamTrack* AsAudioStreamTrack() { return nullptr; }
   virtual VideoStreamTrack* AsVideoStreamTrack() { return nullptr; }
 
   // WebIDL
   virtual void GetKind(nsAString& aKind) = 0;
   void GetId(nsAString& aID) const;
   void GetLabel(nsAString& aLabel) { aLabel.Truncate(); }
   bool Enabled() { return mEnabled; }

--- a/dom/media/imagecapture/CaptureTask.h
+++ b/dom/media/imagecapture/CaptureTask.h
@@ -54,36 +54,33 @@ public:
   // main thread only.
   void AttachStream();
 
   // Remove listeners from MediaStream and PrincipalChangeObserver. It should be
   // on main thread only.
   void DetachStream();
 
   // CaptureTask should be created on main thread.
-  CaptureTask(dom::ImageCapture* aImageCapture, TrackID aTrackID)
+  CaptureTask(dom::ImageCapture* aImageCapture)
     : mImageCapture(aImageCapture)
-    , mTrackID(aTrackID)
     , mImageGrabbedOrTrackEnd(false)
     , mPrincipalChanged(false) {}
 
 protected:
   virtual ~CaptureTask() {}
 
   // Post a runnable on main thread to end this task and call TaskComplete to post
   // error event to script. It is called off-main-thread.
   void PostTrackEndEvent();
 
   // The ImageCapture associates with this task. This reference count should not
   // change in this class unless it clears this reference after a blob or error
   // event to script.
   RefPtr<dom::ImageCapture> mImageCapture;
 
-  TrackID mTrackID;
-
   // True when an image is retrieved from MediaStreamGraph or MediaStreamGraph
   // sends a track finish, end, or removed event.
   bool mImageGrabbedOrTrackEnd;
 
   // True when MediaStream principal is changed in the period of taking photo
   // and it causes a NS_ERROR_DOM_SECURITY_ERR error to script.
   bool mPrincipalChanged;
 };

--- a/dom/media/imagecapture/ImageCapture.cpp
+++ b/dom/media/imagecapture/ImageCapture.cpp
@@ -146,17 +146,17 @@ ImageCapture::TakePhoto(ErrorResult& aRe
   // Try if MediaEngine supports taking photo.
   nsresult rv = TakePhotoByMediaEngine();
 
   // It falls back to MediaStreamGraph image capture if MediaEngine doesn't
   // support TakePhoto().
   if (rv == NS_ERROR_NOT_IMPLEMENTED) {
     IC_LOG("MediaEngine doesn't support TakePhoto(), it falls back to MediaStreamGraph.");
     RefPtr<CaptureTask> task =
-      new CaptureTask(this, mVideoStreamTrack->GetTrackID());
+      new CaptureTask(this);
 
     // It adds itself into MediaStreamGraph, so ImageCapture doesn't need to hold
     // the reference.
     task->AttachStream();
   }
 }
 
 nsresult

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.cpp
@@ -201,23 +201,22 @@ public:
 
     for (size_t i = 0; i < tracks.Length(); i++) {
       std::string trackId;
       // This is the first chance we get to set the string track id on this
       // track. It would be nice if we could specify this along with the numeric
       // track id from the start, but we're stuck doing this fixup after the
       // fact.
       nsresult rv = wrapper.impl()->GetRemoteTrackId(streamId,
-                                                     tracks[i]->GetTrackID(),
+                                                     *tracks[i],
                                                      &trackId);
 
       if (NS_FAILED(rv)) {
-        CSFLogError(logTag, "%s: Failed to get string track id for %u, rv = %u",
-                            __FUNCTION__,
-                            static_cast<unsigned>(tracks[i]->GetTrackID()),
+        CSFLogError(logTag, "%s: Failed to get string track id for %p, rv = %u",
+                            __FUNCTION__, tracks[i].get(),
                             static_cast<unsigned>(rv));
         MOZ_ASSERT(false);
         continue;
       }
 
       std::string origTrackId = PeerConnectionImpl::GetTrackId(*tracks[i]);
 
       if (origTrackId == trackId) {
@@ -2082,24 +2081,24 @@ PeerConnectionImpl::PrincipalChanged(DOM
     CSFLogInfo(logTag, "Can't update sink principal; document gone");
   }
 }
 #endif
 
 #if !defined(MOZILLA_EXTERNAL_LINKAGE)
 nsresult
 PeerConnectionImpl::GetRemoteTrackId(const std::string streamId,
-                                     TrackID numericTrackId,
+                                     const MediaStreamTrack& aTrack,
                                      std::string* trackId) const
 {
   if (IsClosed()) {
     return NS_ERROR_UNEXPECTED;
   }
 
-  return mMedia->GetRemoteTrackId(streamId, numericTrackId, trackId);
+  return mMedia->GetRemoteTrackId(streamId, aTrack, trackId);
 }
 #endif
 
 std::string
 PeerConnectionImpl::GetTrackId(const MediaStreamTrack& aTrack)
 {
 #if !defined(MOZILLA_EXTERNAL_LINKAGE)
   nsString wideTrackId;

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionImpl.h
@@ -616,17 +616,17 @@ public:
 
   static nsresult ExecuteStatsQuery_s(RTCStatsQuery *query);
 
   // for monitoring changes in stream ownership
   // PeerConnectionMedia can't do it because it doesn't know about principals
   virtual void PrincipalChanged(DOMMediaStream* aMediaStream) override;
 
   nsresult GetRemoteTrackId(const std::string streamId,
-                            TrackID numericTrackId,
+                            const dom::MediaStreamTrack& track,
                             std::string* trackId) const;
 #endif
 
   static std::string GetStreamId(const DOMMediaStream& aStream);
   static std::string GetTrackId(const dom::MediaStreamTrack& track);
 
   void OnMediaError(const std::string& aError);
 

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.cpp
@@ -754,29 +754,29 @@ PeerConnectionMedia::RemoveRemoteTrack(c
   if (!remoteSourceStream->GetTrackCount()) {
     mRemoteSourceStreams.RemoveElement(remoteSourceStream);
   }
   return NS_OK;
 }
 
 nsresult
 PeerConnectionMedia::GetRemoteTrackId(const std::string streamId,
-                                      TrackID numericTrackId,
+                                      const MediaStreamTrack& track,
                                       std::string* trackId) const
 {
   auto* ncThis = const_cast<PeerConnectionMedia*>(this);
   const RemoteSourceStreamInfo* info =
     ncThis->GetRemoteStreamById(streamId);
 
   if (!info) {
     CSFLogError(logTag, "%s: Could not find stream info", __FUNCTION__);
     return NS_ERROR_NOT_AVAILABLE;
   }
 
-  return info->GetTrackId(numericTrackId, trackId);
+  return info->GetTrackId(track, trackId);
 }
 
 void
 PeerConnectionMedia::SelfDestruct()
 {
   ASSERT_ON_THREAD(mMainThread);
 
   CSFLogDebug(logTag, "%s: ", __FUNCTION__);

--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionMedia.h
@@ -178,18 +178,20 @@ class RemoteSourceStreamInfo : public So
     for (size_t i = 0; i < mTrackIdMap.size(); ++i) {
       if (mTrackIdMap[i] == trackId) {
         return static_cast<TrackID>(i + 1);
       }
     }
     return TRACK_INVALID;
   }
 
-  nsresult GetTrackId(TrackID numericTrackId, std::string* trackId) const
+  nsresult GetTrackId(const dom::MediaStreamTrack& track, std::string* trackId) const
   {
+    TrackID numericTrackId = track.mTrackID;
+
     if (numericTrackId <= 0 ||
         static_cast<size_t>(numericTrackId) > mTrackIdMap.size()) {
       return NS_ERROR_INVALID_ARG;;
     }
 
     *trackId = mTrackIdMap[numericTrackId - 1];
     return NS_OK;
   }
@@ -266,17 +268,17 @@ class PeerConnectionMedia : public sigsl
                     const std::string& trackId);
 
   nsresult RemoveLocalTrack(const std::string& streamId,
                             const std::string& trackId);
   nsresult RemoveRemoteTrack(const std::string& streamId,
                             const std::string& trackId);
 
   nsresult GetRemoteTrackId(const std::string streamId,
-                            TrackID numericTrackId,
+                            const dom::MediaStreamTrack& track,
                             std::string* trackId) const;
 
   // Get a specific local stream
   uint32_t LocalStreamsLength()
   {
     return mLocalSourceStreams.Length();
   }
   LocalSourceStreamInfo* GetLocalStreamByIndex(int index);

--- a/media/webrtc/signaling/test/FakeMediaStreams.h
+++ b/media/webrtc/signaling/test/FakeMediaStreams.h
@@ -27,16 +27,17 @@
 #include "nsISupportsImpl.h"
 
 class nsIDOMWindow;
 
 namespace mozilla {
    class MediaStreamGraphImpl;
    class MediaSegment;
    class PeerConnectionImpl;
+   class RemoteSourceStreamInfo;
 };
 
 
 namespace mozilla {
 
 class MediaStreamGraph;
 
 static MediaStreamGraph* gGraph;
@@ -285,30 +286,31 @@ class Fake_SourceMediaStream : public Fa
   nsCOMPtr<nsITimer> mTimer;
 };
 
 class Fake_DOMMediaStream;
 
 class Fake_MediaStreamTrack
 {
   friend class mozilla::PeerConnectionImpl;
+  friend class mozilla::RemoteSourceStreamInfo;
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Fake_MediaStreamTrack)
 
   Fake_MediaStreamTrack(bool aIsVideo, Fake_DOMMediaStream* aOwningStream) :
     mIsVideo (aIsVideo),
-    mOwningStream (aOwningStream)
+    mOwningStream (aOwningStream),
+    mTrackID(mIsVideo ? 1 : 0)
   {
     static size_t counter = 0;
     std::ostringstream os;
     os << counter++;
     mID = os.str();
   }
 
-  mozilla::TrackID GetTrackID() { return mIsVideo ? 1 : 0; }
   std::string GetId() const { return mID; }
   void AssignId(const std::string& id) { mID = id; }
   const Fake_MediaStreamTrack* AsVideoStreamTrack() const
   {
     return mIsVideo? this : nullptr;
   }
   const Fake_MediaStreamTrack* AsAudioStreamTrack() const
   {
@@ -321,19 +323,18 @@ public:
   const char* typeName () const
   {
     return "Fake_MediaStreamTrack";
   }
 private:
   ~Fake_MediaStreamTrack() {}
 
   const bool mIsVideo;
-protected:
   Fake_DOMMediaStream* mOwningStream;
-private:
+  mozilla::TrackID mTrackID;
   std::string mID;
 };
 
 class Fake_DOMMediaStream : public nsISupports
 {
 protected:
   virtual ~Fake_DOMMediaStream() {
     // Note: memory leak
@@ -493,11 +494,15 @@ class Fake_VideoStreamSource : public Fa
 
 namespace mozilla {
 typedef Fake_MediaStream MediaStream;
 typedef Fake_SourceMediaStream SourceMediaStream;
 typedef Fake_MediaStreamListener MediaStreamListener;
 typedef Fake_MediaStreamDirectListener MediaStreamDirectListener;
 typedef Fake_DOMMediaStream DOMMediaStream;
 typedef Fake_DOMMediaStream DOMLocalMediaStream;
+
+namespace dom {
+typedef Fake_MediaStreamTrack MediaStreamTrack;
+}
 }
 
 #endif