--- a/dom/media/imagecapture/CaptureTask.cpp
+++ b/dom/media/imagecapture/CaptureTask.cpp
@@ -3,16 +3,17 @@
 /* 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 "CaptureTask.h"
 #include "mozilla/dom/ImageCapture.h"
 #include "mozilla/dom/ImageCaptureError.h"
 #include "mozilla/dom/ImageEncoder.h"
+#include "mozilla/dom/MediaStreamTrack.h"
 #include "mozilla/dom/VideoStreamTrack.h"
 #include "gfxUtils.h"
 #include "nsThreadUtils.h"
 
 namespace mozilla {
 
 nsresult
 CaptureTask::TaskComplete(already_AddRefed<dom::Blob> aBlob, nsresult aRv)
@@ -47,41 +48,43 @@ CaptureTask::TaskComplete(already_AddRef
   return rv;
 }
 
 void
 CaptureTask::AttachStream()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  RefPtr<dom::VideoStreamTrack> track = mImageCapture->GetVideoStreamTrack();
+  dom::VideoStreamTrack* track = mImageCapture->GetVideoStreamTrack();
+
+  track->AddPrincipalChangeObserver(this);
 
   RefPtr<DOMMediaStream> domStream = track->GetStream();
-  domStream->AddPrincipalChangeObserver(this);
-
+  MOZ_RELEASE_ASSERT(domStream);
   RefPtr<MediaStream> stream = domStream->GetPlaybackStream();
   stream->AddListener(this);
 }
 
 void
 CaptureTask::DetachStream()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  RefPtr<dom::VideoStreamTrack> track = mImageCapture->GetVideoStreamTrack();
+  dom::VideoStreamTrack* track = mImageCapture->GetVideoStreamTrack();
 
-  RefPtr<DOMMediaStream> domStream = track->GetStream();
-  domStream->RemovePrincipalChangeObserver(this);
+  track->RemovePrincipalChangeObserver(this);
 
+  DOMMediaStream* domStream = track->GetStream();
+  MOZ_RELEASE_ASSERT(domStream);
   RefPtr<MediaStream> stream = domStream->GetPlaybackStream();
   stream->RemoveListener(this);
 }
 
 void
-CaptureTask::PrincipalChanged(DOMMediaStream* aMediaStream)
+CaptureTask::PrincipalChanged(dom::MediaStreamTrack* aMediaStreamTrack)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mPrincipalChanged = true;
 }
 
 void
 CaptureTask::NotifyQueuedTrackChanges(MediaStreamGraph* aGraph, TrackID aID,
                                       StreamTime aTrackOffset,

--- a/dom/media/imagecapture/CaptureTask.h
+++ b/dom/media/imagecapture/CaptureTask.h
@@ -2,69 +2,70 @@
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* 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 CAPTURETASK_H
 #define CAPTURETASK_H
 
-#include "DOMMediaStream.h"
 #include "MediaStreamGraph.h"
+#include "PrincipalChangeObserver.h"
 
 namespace mozilla {
 
 namespace dom {
 class Blob;
 class ImageCapture;
+class MediaStreamTrack;
 } // namespace dom
 
 /**
  * CaptureTask retrieves image from MediaStream and encodes the image to jpeg in
  * ImageEncoder. The whole procedures start at AttachStream(), it will add this
  * class into MediaStream and retrieves an image in MediaStreamGraph thread.
  * Once the image is retrieved, it will be sent to ImageEncoder and the encoded
  * blob will be sent out via encoder callback in main thread.
  *
  * CaptureTask holds a reference of ImageCapture to ensure ImageCapture won't be
  * released during the period of the capturing process described above.
  */
 class CaptureTask : public MediaStreamListener,
-                    public dom::PrincipalChangeObserver<DOMMediaStream>
+                    public dom::PrincipalChangeObserver<dom::MediaStreamTrack>
 {
 public:
   // MediaStreamListener methods.
   void NotifyQueuedTrackChanges(MediaStreamGraph* aGraph, TrackID aID,
                                 StreamTime aTrackOffset,
                                 uint32_t aTrackEvents,
                                 const MediaSegment& aQueuedMedia,
                                 MediaStream* aInputStream,
                                 TrackID aInputTrackID) override;
 
   void NotifyEvent(MediaStreamGraph* aGraph,
                    MediaStreamGraphEvent aEvent) override;
 
-  // PrincipalChangeObserver<DOMMediaStream> method.
-  void PrincipalChanged(DOMMediaStream* aMediaStream) override;
+  // PrincipalChangeObserver<MediaStreamTrack> method.
+  void PrincipalChanged(dom::MediaStreamTrack* aMediaStreamTrack) override;
 
   // CaptureTask methods.
 
   // It is called when aBlob is ready to post back to script in company with
   // aRv == NS_OK. If aRv is not NS_OK, it will post an error event to script.
   //
   // Note:
   //   this function should be called on main thread.
   nsresult TaskComplete(already_AddRefed<dom::Blob> aBlob, nsresult aRv);
 
-  // Add listeners into MediaStream and PrincipalChangeObserver. It should be on
-  // main thread only.
+  // Add listeners into MediaStream and PrincipalChangeObserver.
+  // It should be on main thread only.
   void AttachStream();
 
-  // Remove listeners from MediaStream and PrincipalChangeObserver. It should be
-  // on main thread only.
+  // 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)
     : mImageCapture(aImageCapture)
     , mTrackID(aTrackID)
     , mImageGrabbedOrTrackEnd(false)
     , mPrincipalChanged(false) {}
@@ -82,16 +83,16 @@ protected:
   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.
+  // True after MediaStreamTrack principal changes while waiting for a photo
+  // to finish and we should raise a security error.
   bool mPrincipalChanged;
 };
 
 } // namespace mozilla
 
 #endif // CAPTURETASK_H

--- a/dom/media/imagecapture/ImageCapture.cpp
+++ b/dom/media/imagecapture/ImageCapture.cpp
@@ -73,30 +73,29 @@ ImageCapture::GetVideoStreamTrack() cons
 }
 
 nsresult
 ImageCapture::TakePhotoByMediaEngine()
 {
   // Callback for TakPhoto(), it also monitor the principal. If principal
   // changes, it returns PHOTO_ERROR with security error.
   class TakePhotoCallback : public MediaEnginePhotoCallback,
-                            public PrincipalChangeObserver<DOMMediaStream>
+                            public PrincipalChangeObserver<MediaStreamTrack>
   {
   public:
     TakePhotoCallback(VideoStreamTrack* aVideoTrack, ImageCapture* aImageCapture)
       : mVideoTrack(aVideoTrack)
       , mImageCapture(aImageCapture)
       , mPrincipalChanged(false)
     {
       MOZ_ASSERT(NS_IsMainThread());
-      MOZ_RELEASE_ASSERT(mVideoTrack->GetStream());
-      mVideoTrack->GetStream()->AddPrincipalChangeObserver(this);
+      mVideoTrack->AddPrincipalChangeObserver(this);
     }
 
-    void PrincipalChanged(DOMMediaStream* aMediaStream) override
+    void PrincipalChanged(MediaStreamTrack* aMediaStream) override
     {
       mPrincipalChanged = true;
     }
 
     nsresult PhotoComplete(already_AddRefed<Blob> aBlob) override
     {
       RefPtr<Blob> blob = aBlob;
 
@@ -110,18 +109,17 @@ ImageCapture::TakePhotoByMediaEngine()
     {
       return mImageCapture->PostErrorEvent(ImageCaptureError::PHOTO_ERROR, aRv);
     }
 
   protected:
     ~TakePhotoCallback()
     {
       MOZ_ASSERT(NS_IsMainThread());
-      MOZ_RELEASE_ASSERT(mVideoTrack->GetStream());
-      mVideoTrack->GetStream()->RemovePrincipalChangeObserver(this);
+      mVideoTrack->RemovePrincipalChangeObserver(this);
     }
 
     RefPtr<VideoStreamTrack> mVideoTrack;
     RefPtr<ImageCapture> mImageCapture;
     bool mPrincipalChanged;
   };
 
   RefPtr<MediaEnginePhotoCallback> callback =
@@ -208,21 +206,17 @@ ImageCapture::PostErrorEvent(uint16_t aE
   return DispatchTrustedEvent(event);
 }
 
 bool
 ImageCapture::CheckPrincipal()
 {
   MOZ_ASSERT(NS_IsMainThread());
 
-  RefPtr<DOMMediaStream> ms = mVideoStreamTrack->GetStream();
-  if (!ms) {
-    return false;
-  }
-  nsCOMPtr<nsIPrincipal> principal = ms->GetPrincipal();
+  nsCOMPtr<nsIPrincipal> principal = mVideoStreamTrack->GetPrincipal();
 
   if (!GetOwner()) {
     return false;
   }
   nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc();
   if (!doc || !principal) {
     return false;
   }