--- a/dom/camera/DOMCameraControl.cpp
+++ b/dom/camera/DOMCameraControl.cpp
@@ -326,21 +326,16 @@ nsDOMCameraControl::nsDOMCameraControl(u
 
   // Register the playback listener directly on the camera input stream.
   // We want as low latency as possible for the camera, thus avoiding
   // MediaStreamGraph altogether. Don't do the regular InitStreamCommon()
   // to avoid initializing the Owned and Playback streams. This is OK since
   // we are not user/DOM facing anyway.
   CreateAndAddPlaybackStreamListener(mInput);
 
-  MOZ_ASSERT(mWindow, "Shouldn't be created with a null window!");
-  if (mWindow->GetExtantDoc()) {
-    CombineWithPrincipal(mWindow->GetExtantDoc()->NodePrincipal());
-  }
-
   // Register a listener for camera events.
   mListener = new DOMCameraControlListener(this, mInput);
   mCameraControl->AddListener(mListener);
 
 #ifdef MOZ_WIDGET_GONK
   if (!gotCached || NS_FAILED(sCachedCameraControlStartResult)) {
 #endif
     // Start the camera...
@@ -521,21 +516,27 @@ nsDOMCameraControl::Get(uint32_t aKey, n
 MediaStream*
 nsDOMCameraControl::GetCameraStream() const
 {
   return mInput;
 }
 
 void
 nsDOMCameraControl::TrackCreated(TrackID aTrackID) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_RELEASE_ASSERT(mWindow, "Shouldn't have been created with a null window!");
+  nsIPrincipal* principal = mWindow->GetExtantDoc()
+                          ? mWindow->GetExtantDoc()->NodePrincipal()
+                          : nullptr;
+
   // This track is not connected through a port.
   MediaInputPort* inputPort = nullptr;
   dom::VideoStreamTrack* track =
     new dom::VideoStreamTrack(this, aTrackID, aTrackID, nsString(),
-                              new BasicUnstoppableTrackSource());
+                              new BasicUnstoppableTrackSource(principal));
   RefPtr<TrackPort> port =
     new TrackPort(inputPort, track,
                   TrackPort::InputPortOwnership::OWNED);
   mTracks.AppendElement(port.forget());
   NotifyTrackAdded(track);
 }
 
 #define THROW_IF_NO_CAMERACONTROL(...)                                          \

--- a/dom/html/HTMLCanvasElement.cpp
+++ b/dom/html/HTMLCanvasElement.cpp
@@ -668,28 +668,26 @@ HTMLCanvasElement::CaptureStream(const O
 
   RefPtr<CanvasCaptureMediaStream> stream =
     CanvasCaptureMediaStream::CreateSourceStream(window, this);
   if (!stream) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
-  RefPtr<nsIPrincipal> principal = NodePrincipal();
-  stream->CombineWithPrincipal(principal);
-
   TrackID videoTrackId = 1;
   nsresult rv = stream->Init(aFrameRate, videoTrackId);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return nullptr;
   }
 
+  nsCOMPtr<nsIPrincipal> principal = NodePrincipal();
   stream->CreateOwnDOMTrack(videoTrackId, MediaSegment::VIDEO, nsString(),
-                            new BasicUnstoppableTrackSource());
+                            new BasicUnstoppableTrackSource(principal));
 
   rv = RegisterFrameCaptureListener(stream->FrameCaptureListener());
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return nullptr;
   }
 
   return stream.forget();

--- a/dom/media/DOMMediaStream.cpp
+++ b/dom/media/DOMMediaStream.cpp
@@ -136,17 +136,20 @@ public:
                        "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");
-        source = new BasicUnstoppableTrackSource();
+        nsPIDOMWindowInner* window = mStream->GetParentObject();
+        nsIDocument* doc = window ? window->GetExtantDoc() : nullptr;
+        nsIPrincipal* principal = doc ? doc->NodePrincipal() : nullptr;
+        source = new BasicUnstoppableTrackSource(principal);
       }
       track = mStream->CreateOwnDOMTrack(aTrackID, aType, nsString(), source);
     }
   }
 
   void DoNotifyTrackEnded(MediaStream* aInputStream, TrackID aInputTrackID)
   {
     MOZ_ASSERT(NS_IsMainThread());
@@ -644,22 +647,22 @@ void
 DOMMediaStream::InitTrackUnionStream(MediaStreamGraph* aGraph)
 {
   InitInputStreamCommon(aGraph->CreateTrackUnionStream(nullptr), aGraph);
   InitOwnedStreamCommon(aGraph);
   InitPlaybackStreamCommon(aGraph);
 }
 
 void
-DOMMediaStream::InitAudioCaptureStream(MediaStreamGraph* aGraph)
+DOMMediaStream::InitAudioCaptureStream(nsIPrincipal* aPrincipal, MediaStreamGraph* aGraph)
 {
   const TrackID AUDIO_TRACK = 1;
 
   RefPtr<BasicUnstoppableTrackSource> audioCaptureSource =
-    new BasicUnstoppableTrackSource(MediaSourceEnum::AudioCapture);
+    new BasicUnstoppableTrackSource(aPrincipal, MediaSourceEnum::AudioCapture);
 
   AudioCaptureStream* audioCaptureStream =
     static_cast<AudioCaptureStream*>(aGraph->CreateAudioCaptureStream(this, AUDIO_TRACK));
   InitInputStreamCommon(audioCaptureStream, aGraph);
   InitOwnedStreamCommon(aGraph);
   InitPlaybackStreamCommon(aGraph);
   CreateOwnDOMTrack(AUDIO_TRACK, MediaSegment::AUDIO, nsString(), audioCaptureSource);
   audioCaptureStream->Start();
@@ -725,21 +728,23 @@ DOMMediaStream::CreateTrackUnionStream(n
 {
   RefPtr<DOMMediaStream> stream = new DOMMediaStream(aWindow, aTrackSourceGetter);
   stream->InitTrackUnionStream(aGraph);
   return stream.forget();
 }
 
 already_AddRefed<DOMMediaStream>
 DOMMediaStream::CreateAudioCaptureStream(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(aGraph);
+  stream->InitAudioCaptureStream(aPrincipal, aGraph);
   return stream.forget();
 }
 
 already_AddRefed<Promise>
 DOMMediaStream::ApplyConstraintsToTrack(TrackID aTrackID,
                                         const MediaTrackConstraints& aConstraints,
                                         ErrorResult &aRv)
 {
@@ -1096,27 +1101,16 @@ DOMLocalMediaStream::CreateTrackUnionStr
                                             MediaStreamTrackSourceGetter* aTrackSourceGetter)
 {
   RefPtr<DOMLocalMediaStream> stream =
     new DOMLocalMediaStream(aWindow, aTrackSourceGetter);
   stream->InitTrackUnionStream(aGraph);
   return stream.forget();
 }
 
-already_AddRefed<DOMLocalMediaStream>
-DOMLocalMediaStream::CreateAudioCaptureStream(nsPIDOMWindowInner* aWindow,
-                                              MediaStreamGraph* aGraph)
-{
-  // AudioCapture doesn't create tracks dynamically
-  MediaStreamTrackSourceGetter* getter = nullptr;
-  RefPtr<DOMLocalMediaStream> stream = new DOMLocalMediaStream(aWindow, getter);
-  stream->InitAudioCaptureStream(aGraph);
-  return stream.forget();
-}
-
 DOMAudioNodeMediaStream::DOMAudioNodeMediaStream(nsPIDOMWindowInner* aWindow, AudioNode* aNode)
   : DOMMediaStream(aWindow, nullptr),
     mStreamNode(aNode)
 {
 }
 
 DOMAudioNodeMediaStream::~DOMAudioNodeMediaStream()
 {

--- a/dom/media/DOMMediaStream.h
+++ b/dom/media/DOMMediaStream.h
@@ -507,17 +507,19 @@ public:
                                                                  MediaStreamGraph* aGraph,
                                                                  MediaStreamTrackSourceGetter* aTrackSourceGetter = nullptr);
 
   /**
    * Create an DOMMediaStream whose underlying input stream is an
    * AudioCaptureStream.
    */
   static already_AddRefed<DOMMediaStream>
-  CreateAudioCaptureStream(nsPIDOMWindowInner* aWindow, MediaStreamGraph* aGraph);
+  CreateAudioCaptureStream(nsPIDOMWindowInner* aWindow,
+                           nsIPrincipal* aPrincipal,
+                           MediaStreamGraph* aGraph);
 
   void SetLogicalStreamStartTime(StreamTime aTime)
   {
     mLogicalStreamStartTime = aTime;
   }
 
   /**
    * Called for each track in our owned stream to indicate to JS that we
@@ -554,17 +556,17 @@ public:
   void UnregisterTrackListener(TrackListener* aListener);
 
 protected:
   virtual ~DOMMediaStream();
 
   void Destroy();
   void InitSourceStream(MediaStreamGraph* aGraph);
   void InitTrackUnionStream(MediaStreamGraph* aGraph);
-  void InitAudioCaptureStream(MediaStreamGraph* aGraph);
+  void InitAudioCaptureStream(nsIPrincipal* aPrincipal, MediaStreamGraph* aGraph);
 
   // Sets up aStream as mInputStream. A producer may append data to a
   // SourceMediaStream input stream, or connect another stream to a
   // TrackUnionStream input stream.
   void InitInputStreamCommon(MediaStream* aStream, MediaStreamGraph* aGraph);
 
   // Sets up a new TrackUnionStream as mOwnedStream and connects it to
   // mInputStream with a TRACK_ANY MediaInputPort if available.
@@ -705,23 +707,16 @@ public:
   /**
    * Create an nsDOMLocalMediaStream whose underlying stream is a TrackUnionStream.
    */
   static already_AddRefed<DOMLocalMediaStream>
   CreateTrackUnionStream(nsPIDOMWindowInner* aWindow,
                          MediaStreamGraph* aGraph,
                          MediaStreamTrackSourceGetter* aTrackSourceGetter = nullptr);
 
-  /**
-   * Create an nsDOMLocalMediaStream whose underlying stream is an
-   * AudioCaptureStream. */
-  static already_AddRefed<DOMLocalMediaStream>
-  CreateAudioCaptureStream(nsPIDOMWindowInner* aWindow,
-                           MediaStreamGraph* aGraph);
-
 protected:
   virtual ~DOMLocalMediaStream();
 
   void StopImpl();
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(DOMLocalMediaStream,
                               NS_DOMLOCALMEDIASTREAM_IID)

--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -885,28 +885,30 @@ public:
 
     MediaStreamGraph::GraphDriverType graphDriverType =
       mAudioDevice ? MediaStreamGraph::AUDIO_THREAD_DRIVER
                    : MediaStreamGraph::SYSTEM_THREAD_DRIVER;
     MediaStreamGraph* msg =
       MediaStreamGraph::GetInstance(graphDriverType,
                                     dom::AudioChannel::Normal);
 
-    RefPtr<DOMLocalMediaStream> domStream;
+    RefPtr<DOMMediaStream> domStream;
     RefPtr<SourceMediaStream> stream;
     // AudioCapture is a special case, here, in the sense that we're not really
     // using the audio source and the SourceMediaStream, which acts as
     // placeholders. We re-route a number of stream internaly in the MSG and mix
     // them down instead.
     if (mAudioDevice &&
         mAudioDevice->GetMediaSource() == MediaSourceEnum::AudioCapture) {
-      domStream = DOMLocalMediaStream::CreateAudioCaptureStream(window, msg);
       // It should be possible to pipe the capture stream to anything. CORS is
       // not a problem here, we got explicit user content.
-      domStream->SetPrincipal(window->GetExtantDoc()->NodePrincipal());
+      nsCOMPtr<nsIPrincipal> principal = window->GetExtantDoc()->NodePrincipal();
+      domStream =
+        DOMMediaStream::CreateAudioCaptureStream(window, principal, msg);
+
       stream = msg->CreateSourceStream(nullptr); // Placeholder
       msg->RegisterCaptureStreamForWindow(
             mWindowID, domStream->GetInputStream()->AsProcessedStream());
       window->SetAudioCapture(true);
     } else {
       class LocalTrackSource : public MediaStreamTrackSource
       {
       public:

--- a/dom/media/MediaStreamTrack.h
+++ b/dom/media/MediaStreamTrack.h
@@ -138,19 +138,20 @@ protected:
 };
 
 /**
  * Basic implementation of MediaStreamTrackSource that ignores Stop().
  */
 class BasicUnstoppableTrackSource : public MediaStreamTrackSource
 {
 public:
-  explicit BasicUnstoppableTrackSource(const MediaSourceEnum aMediaSource =
+  explicit BasicUnstoppableTrackSource(nsIPrincipal* aPrincipal,
+                                       const MediaSourceEnum aMediaSource =
                                          MediaSourceEnum::Other)
-    : MediaStreamTrackSource(nullptr, true), mMediaSource(aMediaSource) {}
+    : MediaStreamTrackSource(aPrincipal, true), mMediaSource(aMediaSource) {}
 
   MediaSourceEnum GetMediaSource() const override { return mMediaSource; }
 
   void Stop() override {}
 
 protected:
   ~BasicUnstoppableTrackSource() {}
 

--- a/dom/media/webaudio/MediaStreamAudioDestinationNode.cpp
+++ b/dom/media/webaudio/MediaStreamAudioDestinationNode.cpp
@@ -30,32 +30,29 @@ MediaStreamAudioDestinationNode::MediaSt
               ChannelCountMode::Explicit,
               ChannelInterpretation::Speakers)
   , mDOMStream(
       DOMAudioNodeMediaStream::CreateTrackUnionStream(GetOwner(),
                                                       this,
                                                       aContext->Graph()))
 {
   // Ensure an audio track with the correct ID is exposed to JS
+  nsIDocument* doc = aContext->GetParentObject()->GetExtantDoc();
   RefPtr<MediaStreamTrackSource> source =
-    new BasicUnstoppableTrackSource(MediaSourceEnum::AudioCapture);
+    new BasicUnstoppableTrackSource(doc->NodePrincipal(),
+                                    MediaSourceEnum::AudioCapture);
   mDOMStream->CreateOwnDOMTrack(AudioNodeStream::AUDIO_TRACK,
                                 MediaSegment::AUDIO, nsString(), source);
 
   ProcessedMediaStream* outputStream = mDOMStream->GetInputStream()->AsProcessedStream();
   MOZ_ASSERT(!!outputStream);
   AudioNodeEngine* engine = new AudioNodeEngine(this);
   mStream = AudioNodeStream::Create(aContext, engine,
                                     AudioNodeStream::EXTERNAL_OUTPUT);
   mPort = outputStream->AllocateInputPort(mStream, AudioNodeStream::AUDIO_TRACK);
-
-  nsIDocument* doc = aContext->GetParentObject()->GetExtantDoc();
-  if (doc) {
-    mDOMStream->CombineWithPrincipal(doc->NodePrincipal());
-  }
 }
 
 MediaStreamAudioDestinationNode::~MediaStreamAudioDestinationNode()
 {
 }
 
 size_t
 MediaStreamAudioDestinationNode::SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const