The Tor Browser: content/media/MediaRecorder.cpp@97036ab72558 (annotated)

content/media/MediaRecorder.cpp@97036ab72558 (annotated)

content/media/MediaRecorder.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 #include "MediaRecorder.h"
 #include "GeneratedEvents.h"
 #include "MediaEncoder.h"
 #include "mozilla/DOMEventTargetHelper.h"
 #include "nsError.h"
 #include "nsIDocument.h"
 #include "nsIDOMRecordErrorEvent.h"
 #include "nsTArray.h"
 #include "DOMMediaStream.h"
 #include "EncodedBufferCache.h"
 #include "nsIDOMFile.h"
 #include "mozilla/dom/BlobEvent.h"
 #include "nsIPrincipal.h"
 #include "nsMimeTypes.h"
 #include "mozilla/dom/AudioStreamTrack.h"
 #include "mozilla/dom/VideoStreamTrack.h"
 #ifdef PR_LOGGING
 PRLogModuleInfo* gMediaRecorderLog;
 #define LOG(type, msg) PR_LOG(gMediaRecorderLog, type, msg)
 #else
 #define LOG(type, msg)
 #endif
 namespace mozilla {
 namespace dom {
 NS_IMPL_CYCLE_COLLECTION_INHERITED(MediaRecorder, DOMEventTargetHelper,
                                    mStream)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(MediaRecorder)
 NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
 NS_IMPL_ADDREF_INHERITED(MediaRecorder, DOMEventTargetHelper)
 NS_IMPL_RELEASE_INHERITED(MediaRecorder, DOMEventTargetHelper)
 /**
  * Session is an object to represent a single recording event.
  * In original design, all recording context is stored in MediaRecorder, which causes
  * a problem if someone calls MediaRecoder::Stop and MedaiRecorder::Start quickly.
  * To prevent blocking main thread, media encoding is executed in a second thread,
  * named as Read Thread. For the same reason, we do not wait Read Thread shutdown in
  * MediaRecorder::Stop. If someone call MediaRecoder::Start before Read Thread shutdown,
  * the same recording context in MediaRecoder might be access by two Reading Threads,
  * which cause a  problem.
  * In the new design, we put recording context into Session object, including Read
  * Thread.  Each Session has its own recording context and Read Thread, problem is been
  * resolved.
  *
  * Life cycle of a Session object.
  * 1) Initialization Stage (in main thread)
  *    Setup media streams in MSG, and bind MediaEncoder with Source Stream when mStream is available.
  *    Resource allocation, such as encoded data cache buffer and MediaEncoder.
  *    Create read thread.
  *    Automatically switch to Extract stage in the end of this stage.
  * 2) Extract Stage (in Read Thread)
  *    Pull encoded A/V frames from MediaEncoder, dispatch to OnDataAvailable handler.
  *    Unless a client calls Session::Stop, Session object keeps stay in this stage.
  * 3) Destroy Stage (in main thread)
  *    Switch from Extract stage to Destroy stage by calling Session::Stop.
  *    Release session resource and remove associated streams from MSG.
  *
  * Lifetime of a Session object.
  * 1) MediaRecorder creates a Session in MediaRecorder::Start function.
  * 2) A Session is destroyed in DestroyRunnable after MediaRecorder::Stop being called
  *    _and_ all encoded media data been passed to OnDataAvailable handler.
  */
 class MediaRecorder::Session: public nsIObserver
 {
   NS_DECL_THREADSAFE_ISUPPORTS
   // Main thread task.
   // Create a blob event and send back to client.
   class PushBlobRunnable : public nsRunnable
   {
   public:
     PushBlobRunnable(Session* aSession)
       : mSession(aSession)
     { }
     NS_IMETHODIMP Run()
     {
       LOG(PR_LOG_DEBUG, ("Session.PushBlobRunnable s=(%p)", mSession.get()));
       MOZ_ASSERT(NS_IsMainThread());
       nsRefPtr<MediaRecorder> recorder = mSession->mRecorder;
       if (!recorder) {
 	 return NS_OK;
       }
       recorder->SetMimeType(mSession->mMimeType);
       if (mSession->IsEncoderError()) {
         recorder->NotifyError(NS_ERROR_UNEXPECTED);
       }
       nsresult rv = recorder->CreateAndDispatchBlobEvent(mSession->GetEncodedData());
       if (NS_FAILED(rv)) {
         recorder->NotifyError(rv);
       }
       return NS_OK;
     }
   private:
     nsRefPtr<Session> mSession;
   };
   // Record thread task and it run in Media Encoder thread.
   // Fetch encoded Audio/Video data from MediaEncoder.
   class ExtractRunnable : public nsRunnable
   {
   public:
     ExtractRunnable(Session *aSession)
       : mSession(aSession) {}
     NS_IMETHODIMP Run()
     {
       MOZ_ASSERT(NS_GetCurrentThread() == mSession->mReadThread);
       mSession->Extract();
       LOG(PR_LOG_DEBUG, ("Session.ExtractRunnable shutdown = %d", mSession->mEncoder->IsShutdown()));
       if (!mSession->mEncoder->IsShutdown()) {
         NS_DispatchToCurrentThread(new ExtractRunnable(mSession));
       } else {
         // Flush out remainding encoded data.
         NS_DispatchToMainThread(new PushBlobRunnable(mSession));
         // Destroy this Session object in main thread.
         NS_DispatchToMainThread(new DestroyRunnable(already_AddRefed<Session>(mSession)));
       }
       return NS_OK;
     }
   private:
     nsRefPtr<Session> mSession;
   };
   // For Ensure recorder has tracks to record.
   class TracksAvailableCallback : public DOMMediaStream::OnTracksAvailableCallback
   {
   public:
     TracksAvailableCallback(Session *aSession)
      : mSession(aSession) {}
     virtual void NotifyTracksAvailable(DOMMediaStream* aStream)
     {
       uint8_t trackType = aStream->GetHintContents();
       // ToDo: GetHintContents return 0 when recording media tags.
       if (trackType == 0) {
         nsTArray<nsRefPtr<mozilla::dom::AudioStreamTrack> > audioTracks;
         aStream->GetAudioTracks(audioTracks);
         nsTArray<nsRefPtr<mozilla::dom::VideoStreamTrack> > videoTracks;
         aStream->GetVideoTracks(videoTracks);
         // What is inside the track
         if (videoTracks.Length() > 0) {
           trackType |= DOMMediaStream::HINT_CONTENTS_VIDEO;
         }
         if (audioTracks.Length() > 0) {
           trackType |= DOMMediaStream::HINT_CONTENTS_AUDIO;
         }
       }
       LOG(PR_LOG_DEBUG, ("Session.NotifyTracksAvailable track type = (%d)", trackType));
       mSession->AfterTracksAdded(trackType);
     }
   private:
     nsRefPtr<Session> mSession;
   };
   // Main thread task.
   // To delete RecordingSession object.
   class DestroyRunnable : public nsRunnable
   {
   public:
     DestroyRunnable(already_AddRefed<Session>&& aSession)
       : mSession(aSession) {}
     NS_IMETHODIMP Run()
     {
       LOG(PR_LOG_DEBUG, ("Session.DestroyRunnable session refcnt = (%d) stopIssued %d s=(%p)",
                          (int)mSession->mRefCnt, mSession->mStopIssued, mSession.get()));
       MOZ_ASSERT(NS_IsMainThread() && mSession.get());
       nsRefPtr<MediaRecorder> recorder = mSession->mRecorder;
       if (!recorder) {
         return NS_OK;
       }
       // SourceMediaStream is ended, and send out TRACK_EVENT_END notification.
       // Read Thread will be terminate soon.
       // We need to switch MediaRecorder to "Stop" state first to make sure
       // MediaRecorder is not associated with this Session anymore, then, it's
       // safe to delete this Session.
       // Also avoid to run if this session already call stop before
       if (!mSession->mStopIssued) {
         ErrorResult result;
         mSession->mStopIssued = true;
         recorder->Stop(result);
         NS_DispatchToMainThread(new DestroyRunnable(mSession.forget()));
         return NS_OK;
       }
       // Dispatch stop event and clear MIME type.
       mSession->mMimeType = NS_LITERAL_STRING("");
       recorder->SetMimeType(mSession->mMimeType);
       recorder->DispatchSimpleEvent(NS_LITERAL_STRING("stop"));
       recorder->RemoveSession(mSession);
       mSession->mRecorder = nullptr;
       return NS_OK;
     }
   private:
     // Call mSession::Release automatically while DestroyRunnable be destroy.
     nsRefPtr<Session> mSession;
   };
   friend class PushBlobRunnable;
   friend class ExtractRunnable;
   friend class DestroyRunnable;
   friend class TracksAvailableCallback;
 public:
   Session(MediaRecorder* aRecorder, int32_t aTimeSlice)
     : mRecorder(aRecorder),
       mTimeSlice(aTimeSlice),
       mStopIssued(false)
   {
     MOZ_ASSERT(NS_IsMainThread());
     AddRef();
     mEncodedBufferCache = new EncodedBufferCache(MAX_ALLOW_MEMORY_BUFFER);
     mLastBlobTimeStamp = TimeStamp::Now();
   }
   // Only DestroyRunnable is allowed to delete Session object.
   virtual ~Session()
   {
     LOG(PR_LOG_DEBUG, ("Session.~Session (%p)", this));
     CleanupStreams();
   }
   void Start()
   {
     LOG(PR_LOG_DEBUG, ("Session.Start %p", this));
     MOZ_ASSERT(NS_IsMainThread());
     SetupStreams();
   }
   void Stop()
   {
     LOG(PR_LOG_DEBUG, ("Session.Stop %p", this));
     MOZ_ASSERT(NS_IsMainThread());
     mStopIssued = true;
     CleanupStreams();
     nsContentUtils::UnregisterShutdownObserver(this);
   }
   nsresult Pause()
   {
     LOG(PR_LOG_DEBUG, ("Session.Pause"));
     MOZ_ASSERT(NS_IsMainThread());
     NS_ENSURE_TRUE(mTrackUnionStream, NS_ERROR_FAILURE);
     mTrackUnionStream->ChangeExplicitBlockerCount(-1);
     return NS_OK;
   }
   nsresult Resume()
   {
     LOG(PR_LOG_DEBUG, ("Session.Resume"));
     MOZ_ASSERT(NS_IsMainThread());
     NS_ENSURE_TRUE(mTrackUnionStream, NS_ERROR_FAILURE);
     mTrackUnionStream->ChangeExplicitBlockerCount(1);
     return NS_OK;
   }
   already_AddRefed<nsIDOMBlob> GetEncodedData()
   {
     MOZ_ASSERT(NS_IsMainThread());
     return mEncodedBufferCache->ExtractBlob(mMimeType);
   }
   bool IsEncoderError()
   {
     if (mEncoder && mEncoder->HasError()) {
       return true;
     }
     return false;
   }
   void ForgetMediaRecorder()
   {
     LOG(PR_LOG_DEBUG, ("Session.ForgetMediaRecorder (%p)", mRecorder));
     mRecorder = nullptr;
   }
 private:
   // Pull encoded meida data from MediaEncoder and put into EncodedBufferCache.
   // Destroy this session object in the end of this function.
   void Extract()
   {
     MOZ_ASSERT(NS_GetCurrentThread() == mReadThread);
     LOG(PR_LOG_DEBUG, ("Session.Extract %p", this));
     // Whether push encoded data back to onDataAvailable automatically.
     const bool pushBlob = (mTimeSlice > 0) ? true : false;
     // Pull encoded media data from MediaEncoder
     nsTArray<nsTArray<uint8_t> > encodedBuf;
     mEncoder->GetEncodedData(&encodedBuf, mMimeType);
     // Append pulled data into cache buffer.
     for (uint32_t i = 0; i < encodedBuf.Length(); i++) {
       mEncodedBufferCache->AppendBuffer(encodedBuf[i]);
     }
     if (pushBlob) {
       if ((TimeStamp::Now() - mLastBlobTimeStamp).ToMilliseconds() > mTimeSlice) {
         NS_DispatchToMainThread(new PushBlobRunnable(this));
         mLastBlobTimeStamp = TimeStamp::Now();
       }
     }
   }
   // Bind media source with MediaEncoder to receive raw media data.
   void SetupStreams()
   {
     MOZ_ASSERT(NS_IsMainThread());
     // Create a Track Union Stream
     MediaStreamGraph* gm = mRecorder->mStream->GetStream()->Graph();
     mTrackUnionStream = gm->CreateTrackUnionStream(nullptr);
     MOZ_ASSERT(mTrackUnionStream, "CreateTrackUnionStream failed");
     mTrackUnionStream->SetAutofinish(true);
     // Bind this Track Union Stream with Source Media
     mInputPort = mTrackUnionStream->AllocateInputPort(mRecorder->mStream->GetStream(), MediaInputPort::FLAG_BLOCK_OUTPUT);
     // Allocate encoder and bind with the Track Union Stream.
     TracksAvailableCallback* tracksAvailableCallback = new TracksAvailableCallback(mRecorder->mSessions.LastElement());
     mRecorder->mStream->OnTracksAvailable(tracksAvailableCallback);
   }
   void AfterTracksAdded(uint8_t aTrackTypes)
   {
     LOG(PR_LOG_DEBUG, ("Session.AfterTracksAdded %p", this));
     MOZ_ASSERT(NS_IsMainThread());
     // Allocate encoder and bind with union stream.
     // At this stage, the API doesn't allow UA to choose the output mimeType format.
     nsCOMPtr<nsIDocument> doc = mRecorder->GetOwner()->GetExtantDoc();
     uint16_t appStatus = nsIPrincipal::APP_STATUS_NOT_INSTALLED;
     if (doc) {
       doc->NodePrincipal()->GetAppStatus(&appStatus);
     }
     // Only allow certificated application can assign AUDIO_3GPP
     if (appStatus == nsIPrincipal::APP_STATUS_CERTIFIED &&
          mRecorder->mMimeType.EqualsLiteral(AUDIO_3GPP)) {
       mEncoder = MediaEncoder::CreateEncoder(NS_LITERAL_STRING(AUDIO_3GPP), aTrackTypes);
     } else {
       mEncoder = MediaEncoder::CreateEncoder(NS_LITERAL_STRING(""), aTrackTypes);
     }
     if (!mEncoder) {
       DoSessionEndTask(NS_ERROR_ABORT);
       return;
     }
     // Media stream is ready but UA issues a stop method follow by start method.
     // The Session::stop would clean the mTrackUnionStream. If the AfterTracksAdded
     // comes after stop command, this function would crash.
     if (!mTrackUnionStream) {
       DoSessionEndTask(NS_OK);
       return;
     }
     mTrackUnionStream->AddListener(mEncoder);
     // Create a thread to read encode media data from MediaEncoder.
     if (!mReadThread) {
       nsresult rv = NS_NewNamedThread("Media Encoder", getter_AddRefs(mReadThread));
       if (NS_FAILED(rv)) {
         DoSessionEndTask(rv);
         return;
       }
     }
     // In case source media stream does not notify track end, recieve
     // shutdown notification and stop Read Thread.
     nsContentUtils::RegisterShutdownObserver(this);
     mReadThread->Dispatch(new ExtractRunnable(this), NS_DISPATCH_NORMAL);
   }
   // application should get blob and onstop event
   void DoSessionEndTask(nsresult rv)
   {
     MOZ_ASSERT(NS_IsMainThread());
     if (NS_FAILED(rv)) {
       mRecorder->NotifyError(rv);
     }
     CleanupStreams();
     // Destroy this session object in main thread.
     NS_DispatchToMainThread(new PushBlobRunnable(this));
     NS_DispatchToMainThread(new DestroyRunnable(already_AddRefed<Session>(this)));
   }
   void CleanupStreams()
   {
     if (mInputPort.get()) {
       mInputPort->Destroy();
       mInputPort = nullptr;
     }
     if (mTrackUnionStream.get()) {
       mTrackUnionStream->Destroy();
       mTrackUnionStream = nullptr;
     }
   }
   NS_IMETHODIMP Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
   {
     MOZ_ASSERT(NS_IsMainThread());
     LOG(PR_LOG_DEBUG, ("Session.Observe XPCOM_SHUTDOWN %p", this));
     if (strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID) == 0) {
       // Force stop Session to terminate Read Thread.
       mEncoder->Cancel();
       if (mReadThread) {
         mReadThread->Shutdown();
         mReadThread = nullptr;
       }
       if (mRecorder) {
         mRecorder->RemoveSession(this);
         mRecorder = nullptr;
       }
       Stop();
     }
     return NS_OK;
   }
 private:
   // Hold weak a reference to MediaRecoder and can be accessed ONLY on main thread.
   MediaRecorder* mRecorder;
   // Receive track data from source and dispatch to Encoder.
   // Pause/ Resume controller.
   nsRefPtr<ProcessedMediaStream> mTrackUnionStream;
   nsRefPtr<MediaInputPort> mInputPort;
   // Runnable thread for read data from MediaEncode.
   nsCOMPtr<nsIThread> mReadThread;
   // MediaEncoder pipeline.
   nsRefPtr<MediaEncoder> mEncoder;
   // A buffer to cache encoded meda data.
   nsAutoPtr<EncodedBufferCache> mEncodedBufferCache;
   // Current session mimeType
   nsString mMimeType;
   // Timestamp of the last fired dataavailable event.
   TimeStamp mLastBlobTimeStamp;
   // The interval of passing encoded data from EncodedBufferCache to onDataAvailable
   // handler. "mTimeSlice < 0" means Session object does not push encoded data to
   // onDataAvailable, instead, it passive wait the client side pull encoded data
   // by calling requestData API.
   const int32_t mTimeSlice;
   // Indicate this session's stop has been called.
   bool mStopIssued;
 };
 NS_IMPL_ISUPPORTS(MediaRecorder::Session, nsIObserver)
 MediaRecorder::~MediaRecorder()
 {
   LOG(PR_LOG_DEBUG, ("~MediaRecorder (%p)", this));
   for (uint32_t i = 0; i < mSessions.Length(); i ++) {
     if (mSessions[i]) {
       mSessions[i]->ForgetMediaRecorder();
       mSessions[i]->Stop();
     }
   }
 }
 MediaRecorder::MediaRecorder(DOMMediaStream& aStream, nsPIDOMWindow* aOwnerWindow)
   : DOMEventTargetHelper(aOwnerWindow),
     mState(RecordingState::Inactive),
     mMutex("Session.Data.Mutex")
 {
   MOZ_ASSERT(aOwnerWindow);
   MOZ_ASSERT(aOwnerWindow->IsInnerWindow());
   mStream = &aStream;
 #ifdef PR_LOGGING
   if (!gMediaRecorderLog) {
     gMediaRecorderLog = PR_NewLogModule("MediaRecorder");
   }
 #endif
 }
 void
 MediaRecorder::SetMimeType(const nsString &aMimeType)
 {
   MutexAutoLock lock(mMutex);
   mMimeType = aMimeType;
 }
 void
 MediaRecorder::GetMimeType(nsString &aMimeType)
 {
   MutexAutoLock lock(mMutex);
   aMimeType = mMimeType;
 }
 void
 MediaRecorder::Start(const Optional<int32_t>& aTimeSlice, ErrorResult& aResult)
 {
   LOG(PR_LOG_DEBUG, ("MediaRecorder.Start %p", this));
   if (mState != RecordingState::Inactive) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   if (mStream->GetStream()->IsFinished() || mStream->GetStream()->IsDestroyed()) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   if (!mStream->GetPrincipal()) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   if (!CheckPrincipal()) {
     aResult.Throw(NS_ERROR_DOM_SECURITY_ERR);
     return;
   }
   int32_t timeSlice = 0;
   if (aTimeSlice.WasPassed()) {
     if (aTimeSlice.Value() < 0) {
       aResult.Throw(NS_ERROR_INVALID_ARG);
       return;
     }
     timeSlice = aTimeSlice.Value();
   }
   mState = RecordingState::Recording;
   // Start a session
   mSessions.AppendElement();
   mSessions.LastElement() = new Session(this, timeSlice);
   mSessions.LastElement()->Start();
 }
 void
 MediaRecorder::Stop(ErrorResult& aResult)
 {
   LOG(PR_LOG_DEBUG, ("MediaRecorder.Stop %p", this));
   if (mState == RecordingState::Inactive) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   mState = RecordingState::Inactive;
   if (mSessions.Length() > 0) {
     mSessions.LastElement()->Stop();
   }
 }
 void
 MediaRecorder::Pause(ErrorResult& aResult)
 {
   LOG(PR_LOG_DEBUG, ("MediaRecorder.Pause"));
   if (mState != RecordingState::Recording) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   MOZ_ASSERT(mSessions.Length() > 0);
   nsresult rv = mSessions.LastElement()->Pause();
   if (NS_FAILED(rv)) {
     NotifyError(rv);
     return;
   }
   mState = RecordingState::Paused;
 }
 void
 MediaRecorder::Resume(ErrorResult& aResult)
 {
   LOG(PR_LOG_DEBUG, ("MediaRecorder.Resume"));
   if (mState != RecordingState::Paused) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   MOZ_ASSERT(mSessions.Length() > 0);
   nsresult rv = mSessions.LastElement()->Resume();
   if (NS_FAILED(rv)) {
     NotifyError(rv);
     return;
   }
   mState = RecordingState::Recording;
 }
 class CreateAndDispatchBlobEventRunnable : public nsRunnable {
   nsCOMPtr<nsIDOMBlob> mBlob;
   nsRefPtr<MediaRecorder> mRecorder;
 public:
   CreateAndDispatchBlobEventRunnable(already_AddRefed<nsIDOMBlob>&& aBlob,
                                      MediaRecorder* aRecorder)
     : mBlob(aBlob), mRecorder(aRecorder)
   { }
   NS_IMETHOD
   Run();
 };
 NS_IMETHODIMP
 CreateAndDispatchBlobEventRunnable::Run()
 {
   return mRecorder->CreateAndDispatchBlobEvent(mBlob.forget());
 }
 void
 MediaRecorder::RequestData(ErrorResult& aResult)
 {
   if (mState != RecordingState::Recording) {
     aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   NS_DispatchToMainThread(
     new CreateAndDispatchBlobEventRunnable(mSessions.LastElement()->GetEncodedData(),
                                            this),
                                            NS_DISPATCH_NORMAL);
 }
 JSObject*
 MediaRecorder::WrapObject(JSContext* aCx)
 {
   return MediaRecorderBinding::Wrap(aCx, this);
 }
 /* static */ already_AddRefed<MediaRecorder>
 MediaRecorder::Constructor(const GlobalObject& aGlobal,
                            DOMMediaStream& aStream,
                            const MediaRecorderOptions& aInitDict,
                            ErrorResult& aRv)
 {
   nsCOMPtr<nsIScriptGlobalObject> sgo = do_QueryInterface(aGlobal.GetAsSupports());
   if (!sgo) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
   nsCOMPtr<nsPIDOMWindow> ownerWindow = do_QueryInterface(aGlobal.GetAsSupports());
   if (!ownerWindow) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
   nsRefPtr<MediaRecorder> object = new MediaRecorder(aStream, ownerWindow);
   object->SetMimeType(aInitDict.mMimeType);
   return object.forget();
 }
 nsresult
 MediaRecorder::CreateAndDispatchBlobEvent(already_AddRefed<nsIDOMBlob>&& aBlob)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
   if (!CheckPrincipal()) {
     // Media is not same-origin, don't allow the data out.
     nsRefPtr<nsIDOMBlob> blob = aBlob;
     return NS_ERROR_DOM_SECURITY_ERR;
   }
   BlobEventInit init;
   init.mBubbles = false;
   init.mCancelable = false;
   init.mData = aBlob;
   nsRefPtr<BlobEvent> event =
     BlobEvent::Constructor(this,
                            NS_LITERAL_STRING("dataavailable"),
                            init);
   event->SetTrusted(true);
   return DispatchDOMEvent(nullptr, event, nullptr, nullptr);
 }
 void
 MediaRecorder::DispatchSimpleEvent(const nsAString & aStr)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
   nsresult rv = CheckInnerWindowCorrectness();
   if (NS_FAILED(rv)) {
     return;
   }
   nsCOMPtr<nsIDOMEvent> event;
   rv = NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
   if (NS_FAILED(rv)) {
     NS_WARNING("Failed to create the error event!!!");
     return;
   }
   rv = event->InitEvent(aStr, false, false);
   if (NS_FAILED(rv)) {
     NS_WARNING("Failed to init the error event!!!");
     return;
   }
   event->SetTrusted(true);
   rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr);
   if (NS_FAILED(rv)) {
     NS_ERROR("Failed to dispatch the event!!!");
     return;
   }
 }
 void
 MediaRecorder::NotifyError(nsresult aRv)
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
   nsresult rv = CheckInnerWindowCorrectness();
   if (NS_FAILED(rv)) {
     return;
   }
   nsString errorMsg;
   switch (aRv) {
   case NS_ERROR_DOM_SECURITY_ERR:
     errorMsg = NS_LITERAL_STRING("SecurityError");
     break;
   case NS_ERROR_OUT_OF_MEMORY:
     errorMsg = NS_LITERAL_STRING("OutOfMemoryError");
     break;
   default:
     errorMsg = NS_LITERAL_STRING("GenericError");
   }
   nsCOMPtr<nsIDOMEvent> event;
   rv = NS_NewDOMRecordErrorEvent(getter_AddRefs(event), this, nullptr, nullptr);
   nsCOMPtr<nsIDOMRecordErrorEvent> errorEvent = do_QueryInterface(event);
   rv = errorEvent->InitRecordErrorEvent(NS_LITERAL_STRING("error"),
                                         false, false, errorMsg);
   event->SetTrusted(true);
   rv = DispatchDOMEvent(nullptr, event, nullptr, nullptr);
   if (NS_FAILED(rv)) {
     NS_ERROR("Failed to dispatch the error event!!!");
     return;
   }
   return;
 }
 bool MediaRecorder::CheckPrincipal()
 {
   NS_ABORT_IF_FALSE(NS_IsMainThread(), "Not running on main thread");
   if (!mStream) {
     return false;
   }
   nsCOMPtr<nsIPrincipal> principal = mStream->GetPrincipal();
   if (!GetOwner())
     return false;
   nsCOMPtr<nsIDocument> doc = GetOwner()->GetExtantDoc();
   if (!doc || !principal)
     return false;
   bool subsumes;
   if (NS_FAILED(doc->NodePrincipal()->Subsumes(principal, &subsumes)))
     return false;
   return subsumes;
 }
 void
 MediaRecorder::RemoveSession(Session* aSession)
 {
   LOG(PR_LOG_DEBUG, ("MediaRecorder.RemoveSession (%p)", aSession));
   mSessions.RemoveElement(aSession);
 }
 }
 }

The Tor Browser / annotate

content/media/MediaRecorder.cpp@97036ab72558 (annotated)

content/media/MediaRecorder.cpp