summaryrefslogtreecommitdiffstats
path: root/dom/media/MediaDevices.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/media/MediaDevices.cpp804
1 files changed, 804 insertions, 0 deletions
diff --git a/dom/media/MediaDevices.cpp b/dom/media/MediaDevices.cpp
new file mode 100644
index 0000000000..581eec5247
--- /dev/null
+++ b/dom/media/MediaDevices.cpp
@@ -0,0 +1,804 @@
+/* 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 "mozilla/dom/MediaDevices.h"
+
+#include "AudioDeviceInfo.h"
+#include "MediaEngine.h"
+#include "MediaEngineFake.h"
+#include "mozilla/dom/BrowsingContext.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/FeaturePolicyUtils.h"
+#include "mozilla/dom/MediaStreamBinding.h"
+#include "mozilla/dom/MediaDeviceInfo.h"
+#include "mozilla/dom/MediaDevicesBinding.h"
+#include "mozilla/dom/NavigatorBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/WindowContext.h"
+#include "mozilla/intl/Localization.h"
+#include "mozilla/MediaManager.h"
+#include "mozilla/StaticPrefs_media.h"
+#include "MediaTrackConstraints.h"
+#include "nsContentUtils.h"
+#include "nsINamed.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsPIDOMWindow.h"
+#include "nsGlobalWindowInner.h"
+#include "nsQueryObject.h"
+
+namespace mozilla::dom {
+
+using ConstDeviceSetPromise = MediaManager::ConstDeviceSetPromise;
+using LocalDeviceSetPromise = MediaManager::LocalDeviceSetPromise;
+using LocalMediaDeviceSetRefCnt = MediaManager::LocalMediaDeviceSetRefCnt;
+using MediaDeviceSetRefCnt = MediaManager::MediaDeviceSetRefCnt;
+using mozilla::intl::Localization;
+
+MediaDevices::MediaDevices(nsPIDOMWindowInner* aWindow)
+ : DOMEventTargetHelper(aWindow), mDefaultOutputLabel(VoidString()) {}
+
+MediaDevices::~MediaDevices() {
+ MOZ_ASSERT(NS_IsMainThread());
+ mDeviceChangeListener.DisconnectIfExists();
+}
+
+already_AddRefed<Promise> MediaDevices::GetUserMedia(
+ const MediaStreamConstraints& aConstraints, CallerType aCallerType,
+ ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ // Get the relevant global for the promise from the wrapper cache because
+ // DOMEventTargetHelper::GetOwner() returns null if the document is unloaded.
+ // We know the wrapper exists because it is being used for |this| from JS.
+ // See https://github.com/heycam/webidl/issues/932 for why the relevant
+ // global is used instead of the current global.
+ nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(GetWrapper());
+ // global is a window because MediaDevices is exposed only to Window.
+ nsCOMPtr<nsPIDOMWindowInner> owner = do_QueryInterface(global);
+ if (Document* doc = owner->GetExtantDoc()) {
+ if (!owner->IsSecureContext()) {
+ doc->SetUseCounter(eUseCounter_custom_GetUserMediaInsec);
+ }
+ Document* topDoc = doc->GetTopLevelContentDocumentIfSameProcess();
+ IgnoredErrorResult ignored;
+ if (topDoc && !topDoc->HasFocus(ignored)) {
+ doc->SetUseCounter(eUseCounter_custom_GetUserMediaUnfocused);
+ }
+ }
+ RefPtr<Promise> p = Promise::Create(global, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ /* If requestedMediaTypes is the empty set, return a promise rejected with a
+ * TypeError. */
+ if (!MediaManager::IsOn(aConstraints.mVideo) &&
+ !MediaManager::IsOn(aConstraints.mAudio)) {
+ p->MaybeRejectWithTypeError("audio and/or video is required");
+ return p.forget();
+ }
+ /* If the relevant settings object's responsible document is NOT fully
+ * active, return a promise rejected with a DOMException object whose name
+ * attribute has the value "InvalidStateError". */
+ if (!owner->IsFullyActive()) {
+ p->MaybeRejectWithInvalidStateError("The document is not fully active.");
+ return p.forget();
+ }
+ const OwningBooleanOrMediaTrackConstraints& video = aConstraints.mVideo;
+ if (aCallerType != CallerType::System && video.IsMediaTrackConstraints()) {
+ const Optional<nsString>& mediaSource =
+ video.GetAsMediaTrackConstraints().mMediaSource;
+ if (mediaSource.WasPassed() &&
+ !mediaSource.Value().EqualsLiteral("camera")) {
+ WindowContext* wc = owner->GetWindowContext();
+ if (!wc || !wc->HasValidTransientUserGestureActivation()) {
+ p->MaybeRejectWithInvalidStateError(
+ "Display capture requires transient activation "
+ "from a user gesture.");
+ return p.forget();
+ }
+ }
+ }
+ RefPtr<MediaDevices> self(this);
+ GetUserMedia(owner, aConstraints, aCallerType)
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [this, self, p](RefPtr<DOMMediaStream>&& aStream) {
+ if (!GetWindowIfCurrent()) {
+ return; // Leave Promise pending after navigation by design.
+ }
+ p->MaybeResolve(std::move(aStream));
+ },
+ [this, self, p](const RefPtr<MediaMgrError>& error) {
+ nsPIDOMWindowInner* window = GetWindowIfCurrent();
+ if (!window) {
+ return; // Leave Promise pending after navigation by design.
+ }
+ error->Reject(p);
+ });
+ return p.forget();
+}
+
+RefPtr<MediaDevices::StreamPromise> MediaDevices::GetUserMedia(
+ nsPIDOMWindowInner* aWindow, const MediaStreamConstraints& aConstraints,
+ CallerType aCallerType) {
+ MOZ_ASSERT(NS_IsMainThread());
+ bool haveFake = aConstraints.mFake.WasPassed() && aConstraints.mFake.Value();
+ const OwningBooleanOrMediaTrackConstraints& video = aConstraints.mVideo;
+ const OwningBooleanOrMediaTrackConstraints& audio = aConstraints.mAudio;
+ bool isMicrophone =
+ !haveFake &&
+ (audio.IsBoolean()
+ ? audio.GetAsBoolean()
+ : !audio.GetAsMediaTrackConstraints().mMediaSource.WasPassed());
+ bool isCamera =
+ !haveFake &&
+ (video.IsBoolean()
+ ? video.GetAsBoolean()
+ : !video.GetAsMediaTrackConstraints().mMediaSource.WasPassed());
+
+ RefPtr<MediaDevices> self(this);
+ return MediaManager::Get()
+ ->GetUserMedia(aWindow, aConstraints, aCallerType)
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [this, self, isMicrophone,
+ isCamera](RefPtr<DOMMediaStream>&& aStream) {
+ if (isMicrophone) {
+ mCanExposeMicrophoneInfo = true;
+ }
+ if (isCamera) {
+ mCanExposeCameraInfo = true;
+ }
+ return StreamPromise::CreateAndResolve(std::move(aStream),
+ __func__);
+ },
+ [](RefPtr<MediaMgrError>&& aError) {
+ return StreamPromise::CreateAndReject(std::move(aError), __func__);
+ });
+}
+
+already_AddRefed<Promise> MediaDevices::EnumerateDevices(ErrorResult& aRv) {
+ MOZ_ASSERT(NS_IsMainThread());
+ nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(GetWrapper());
+ nsCOMPtr<nsPIDOMWindowInner> owner = do_QueryInterface(global);
+ if (Document* doc = owner->GetExtantDoc()) {
+ if (!owner->IsSecureContext()) {
+ doc->SetUseCounter(eUseCounter_custom_EnumerateDevicesInsec);
+ }
+ Document* topDoc = doc->GetTopLevelContentDocumentIfSameProcess();
+ IgnoredErrorResult ignored;
+ if (topDoc && !topDoc->HasFocus(ignored)) {
+ doc->SetUseCounter(eUseCounter_custom_EnumerateDevicesUnfocused);
+ }
+ }
+ RefPtr<Promise> p = Promise::Create(global, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ mPendingEnumerateDevicesPromises.AppendElement(p);
+ MaybeResumeDeviceExposure();
+ return p.forget();
+}
+
+void MediaDevices::MaybeResumeDeviceExposure() {
+ if (mPendingEnumerateDevicesPromises.IsEmpty() &&
+ !mHaveUnprocessedDeviceListChange) {
+ return;
+ }
+ nsPIDOMWindowInner* window = GetOwner();
+ if (!window || !window->IsFullyActive()) {
+ return;
+ }
+ if (!StaticPrefs::media_devices_unfocused_enabled()) {
+ // Device list changes are not exposed to unfocused contexts because the
+ // timing information would allow fingerprinting for content to identify
+ // concurrent browsing, even when pages are in different containers.
+ BrowsingContext* bc = window->GetBrowsingContext();
+ if (!bc->IsActive() || // background tab or browser window fully obscured
+ !bc->GetIsActiveBrowserWindow()) { // browser window without focus
+ return;
+ }
+ }
+ MediaManager::Get()->GetPhysicalDevices()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr(this), this,
+ haveDeviceListChange = mHaveUnprocessedDeviceListChange,
+ enumerateDevicesPromises = std::move(mPendingEnumerateDevicesPromises)](
+ RefPtr<const MediaDeviceSetRefCnt> aAllDevices) mutable {
+ RefPtr<MediaDeviceSetRefCnt> exposedDevices =
+ FilterExposedDevices(*aAllDevices);
+ if (haveDeviceListChange) {
+ if (ShouldQueueDeviceChange(*exposedDevices)) {
+ NS_DispatchToCurrentThread(NS_NewRunnableFunction(
+ "devicechange", [self = RefPtr(this), this] {
+ DispatchTrustedEvent(u"devicechange"_ns);
+ }));
+ }
+ mLastPhysicalDevices = std::move(aAllDevices);
+ }
+ if (!enumerateDevicesPromises.IsEmpty()) {
+ ResumeEnumerateDevices(std::move(enumerateDevicesPromises),
+ std::move(exposedDevices));
+ }
+ },
+ [](RefPtr<MediaMgrError>&&) {
+ MOZ_ASSERT_UNREACHABLE("GetPhysicalDevices does not reject");
+ });
+ mHaveUnprocessedDeviceListChange = false;
+}
+
+RefPtr<MediaDeviceSetRefCnt> MediaDevices::FilterExposedDevices(
+ const MediaDeviceSet& aDevices) const {
+ nsPIDOMWindowInner* window = GetOwner();
+ RefPtr exposed = new MediaDeviceSetRefCnt();
+ if (!window) {
+ return exposed; // Promises will be left pending
+ }
+ Document* doc = window->GetExtantDoc();
+ if (!doc) {
+ return exposed;
+ }
+ // Only expose devices which are allowed to use:
+ // https://w3c.github.io/mediacapture-main/#dom-mediadevices-enumeratedevices
+ bool dropMics = !FeaturePolicyUtils::IsFeatureAllowed(doc, u"microphone"_ns);
+ bool dropCams = !FeaturePolicyUtils::IsFeatureAllowed(doc, u"camera"_ns);
+ bool dropSpeakers =
+ !Preferences::GetBool("media.setsinkid.enabled") ||
+ !FeaturePolicyUtils::IsFeatureAllowed(doc, u"speaker-selection"_ns);
+
+ if (doc->ShouldResistFingerprinting(RFPTarget::Unknown)) {
+ RefPtr fakeEngine = new MediaEngineFake();
+ fakeEngine->EnumerateDevices(MediaSourceEnum::Microphone,
+ MediaSinkEnum::Other, exposed);
+ fakeEngine->EnumerateDevices(MediaSourceEnum::Camera, MediaSinkEnum::Other,
+ exposed);
+ dropMics = dropCams = true;
+ // Speakers are not handled specially with resistFingerprinting because
+ // they are exposed only when explicitly and individually allowed by the
+ // user.
+ }
+ bool legacy = StaticPrefs::media_devices_enumerate_legacy_enabled();
+ bool outputIsDefault = true; // First output is the default.
+ bool haveDefaultOutput = false;
+ nsTHashSet<nsString> exposedMicrophoneGroupIds;
+ for (const auto& device : aDevices) {
+ switch (device->mKind) {
+ case MediaDeviceKind::Audioinput:
+ if (dropMics) {
+ continue;
+ }
+ if (mCanExposeMicrophoneInfo) {
+ exposedMicrophoneGroupIds.Insert(device->mRawGroupID);
+ }
+ if (!mCanExposeMicrophoneInfo && !legacy) {
+ dropMics = true;
+ }
+ break;
+ case MediaDeviceKind::Videoinput:
+ if (dropCams) {
+ continue;
+ }
+ if (!mCanExposeCameraInfo && !legacy) {
+ dropCams = true;
+ }
+ break;
+ case MediaDeviceKind::Audiooutput:
+ if (dropSpeakers ||
+ (!mExplicitlyGrantedAudioOutputRawIds.Contains(device->mRawID) &&
+ // Assumes aDevices order has microphones before speakers.
+ !exposedMicrophoneGroupIds.Contains(device->mRawGroupID))) {
+ outputIsDefault = false;
+ continue;
+ }
+ if (!haveDefaultOutput && !outputIsDefault) {
+ // Insert a virtual default device so that the first enumerated
+ // device is the default output.
+ if (mDefaultOutputLabel.IsVoid()) {
+ mDefaultOutputLabel.SetIsVoid(false);
+ AutoTArray<nsCString, 1> resourceIds{"dom/media.ftl"_ns};
+ RefPtr l10n = Localization::Create(resourceIds, /*sync*/ true);
+ nsAutoCString translation;
+ IgnoredErrorResult rv;
+ l10n->FormatValueSync("default-audio-output-device-label"_ns, {},
+ translation, rv);
+ if (!rv.Failed()) {
+ AppendUTF8toUTF16(translation, mDefaultOutputLabel);
+ }
+ }
+ RefPtr info = new AudioDeviceInfo(
+ nullptr, mDefaultOutputLabel, u""_ns, u""_ns,
+ CUBEB_DEVICE_TYPE_OUTPUT, CUBEB_DEVICE_STATE_ENABLED,
+ CUBEB_DEVICE_PREF_ALL, CUBEB_DEVICE_FMT_ALL,
+ CUBEB_DEVICE_FMT_S16NE, 2, 44100, 44100, 44100, 128, 128);
+ exposed->AppendElement(
+ new MediaDevice(new MediaEngineFake(), info, u""_ns));
+ }
+ haveDefaultOutput = true;
+ break;
+ case MediaDeviceKind::EndGuard_:
+ continue;
+ // Avoid `default:` so that `-Wswitch` catches missing
+ // enumerators at compile time.
+ }
+ exposed->AppendElement(device);
+ }
+ return exposed;
+}
+
+bool MediaDevices::CanExposeInfo(MediaDeviceKind aKind) const {
+ switch (aKind) {
+ case MediaDeviceKind::Audioinput:
+ return mCanExposeMicrophoneInfo;
+ case MediaDeviceKind::Videoinput:
+ return mCanExposeCameraInfo;
+ case MediaDeviceKind::Audiooutput:
+ // Assumes caller has used FilterExposedDevices()
+ return true;
+ case MediaDeviceKind::EndGuard_:
+ break;
+ // Avoid `default:` so that `-Wswitch` catches missing enumerators at
+ // compile time.
+ }
+ MOZ_ASSERT_UNREACHABLE("unexpected MediaDeviceKind");
+ return false;
+}
+
+bool MediaDevices::ShouldQueueDeviceChange(
+ const MediaDeviceSet& aExposedDevices) const {
+ if (!mLastPhysicalDevices) { // SetupDeviceChangeListener not complete
+ return false;
+ }
+ RefPtr<MediaDeviceSetRefCnt> lastExposedDevices =
+ FilterExposedDevices(*mLastPhysicalDevices);
+ auto exposed = aExposedDevices.begin();
+ auto exposedEnd = aExposedDevices.end();
+ auto last = lastExposedDevices->begin();
+ auto lastEnd = lastExposedDevices->end();
+ // Lists from FilterExposedDevices may have multiple devices of the same
+ // kind even when only a single anonymous device of that kind should be
+ // exposed by enumerateDevices() (but multiple devices are currently exposed
+ // - bug 1528042). "devicechange" events are not queued when the number
+ // of such devices changes but remains non-zero.
+ while (exposed < exposedEnd && last < lastEnd) {
+ // First determine whether there is at least one device of the same kind
+ // in both `aExposedDevices` and `lastExposedDevices`.
+ // A change between zero and non-zero numbers of microphone or camera
+ // devices triggers a devicechange event even if that kind of device is
+ // not yet exposed.
+ MediaDeviceKind kind = (*exposed)->mKind;
+ if (kind != (*last)->mKind) {
+ return true;
+ }
+ // `exposed` and `last` have matching kind.
+ if (CanExposeInfo(kind)) {
+ // Queue "devicechange" if there has been any change in devices of this
+ // exposed kind. ID and kind uniquely identify a device.
+ if ((*exposed)->mRawID != (*last)->mRawID) {
+ return true;
+ }
+ ++exposed;
+ ++last;
+ continue;
+ }
+ // `aExposedDevices` and `lastExposedDevices` both have non-zero numbers
+ // of devices of this unexposed kind.
+ // Skip remaining devices of this kind because all devices of this kind
+ // should be exposed as a single anonymous device.
+ do {
+ ++exposed;
+ } while (exposed != exposedEnd && (*exposed)->mKind == kind);
+ do {
+ ++last;
+ } while (last != lastEnd && (*last)->mKind == kind);
+ }
+ // Queue "devicechange" if the number of exposed devices differs.
+ return exposed < exposedEnd || last < lastEnd;
+}
+
+void MediaDevices::ResumeEnumerateDevices(
+ nsTArray<RefPtr<Promise>>&& aPromises,
+ RefPtr<const MediaDeviceSetRefCnt> aExposedDevices) const {
+ nsCOMPtr<nsPIDOMWindowInner> window = GetOwner();
+ if (!window) {
+ return; // Leave Promise pending after navigation by design.
+ }
+ MediaManager::Get()
+ ->AnonymizeDevices(window, std::move(aExposedDevices))
+ ->Then(GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr(this), this, promises = std::move(aPromises)](
+ const LocalDeviceSetPromise::ResolveOrRejectValue&
+ aLocalDevices) {
+ nsPIDOMWindowInner* window = GetWindowIfCurrent();
+ if (!window) {
+ return; // Leave Promises pending after navigation by design.
+ }
+ for (const RefPtr<Promise>& promise : promises) {
+ if (aLocalDevices.IsReject()) {
+ aLocalDevices.RejectValue()->Reject(promise);
+ } else {
+ ResolveEnumerateDevicesPromise(
+ promise, *aLocalDevices.ResolveValue());
+ }
+ }
+ });
+}
+
+void MediaDevices::ResolveEnumerateDevicesPromise(
+ Promise* aPromise, const LocalMediaDeviceSet& aDevices) const {
+ nsCOMPtr<nsPIDOMWindowInner> window = GetOwner();
+ auto windowId = window->WindowID();
+ nsTArray<RefPtr<MediaDeviceInfo>> infos;
+ bool legacy = StaticPrefs::media_devices_enumerate_legacy_enabled();
+ bool capturePermitted =
+ legacy &&
+ MediaManager::Get()->IsActivelyCapturingOrHasAPermission(windowId);
+
+ for (const RefPtr<LocalMediaDevice>& device : aDevices) {
+ bool exposeInfo = CanExposeInfo(device->Kind()) || legacy;
+ bool exposeLabel = legacy ? capturePermitted : exposeInfo;
+ infos.AppendElement(MakeRefPtr<MediaDeviceInfo>(
+ exposeInfo ? device->mID : u""_ns, device->Kind(),
+ exposeLabel ? device->mName : u""_ns,
+ exposeInfo ? device->mGroupID : u""_ns));
+ }
+ aPromise->MaybeResolve(std::move(infos));
+}
+
+already_AddRefed<Promise> MediaDevices::GetDisplayMedia(
+ const DisplayMediaStreamConstraints& aConstraints, CallerType aCallerType,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(GetWrapper());
+ RefPtr<Promise> p = Promise::Create(global, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ nsCOMPtr<nsPIDOMWindowInner> owner = do_QueryInterface(global);
+ /* If the relevant global object of this does not have transient activation,
+ * return a promise rejected with a DOMException object whose name attribute
+ * has the value InvalidStateError. */
+ WindowContext* wc = owner->GetWindowContext();
+ if (!wc || !wc->HasValidTransientUserGestureActivation()) {
+ p->MaybeRejectWithInvalidStateError(
+ "getDisplayMedia requires transient activation from a user gesture.");
+ return p.forget();
+ }
+ /* If constraints.video is false, return a promise rejected with a newly
+ * created TypeError. */
+ if (!MediaManager::IsOn(aConstraints.mVideo)) {
+ p->MaybeRejectWithTypeError("video is required");
+ return p.forget();
+ }
+ MediaStreamConstraints c;
+ auto& vc = c.mVideo.SetAsMediaTrackConstraints();
+
+ if (aConstraints.mVideo.IsMediaTrackConstraints()) {
+ vc = aConstraints.mVideo.GetAsMediaTrackConstraints();
+ /* If CS contains a member named advanced, return a promise rejected with
+ * a newly created TypeError. */
+ if (vc.mAdvanced.WasPassed()) {
+ p->MaybeRejectWithTypeError("advanced not allowed");
+ return p.forget();
+ }
+ auto getCLR = [](const auto& aCon) -> const ConstrainLongRange& {
+ static ConstrainLongRange empty;
+ return (aCon.WasPassed() && !aCon.Value().IsLong())
+ ? aCon.Value().GetAsConstrainLongRange()
+ : empty;
+ };
+ auto getCDR = [](auto&& aCon) -> const ConstrainDoubleRange& {
+ static ConstrainDoubleRange empty;
+ return (aCon.WasPassed() && !aCon.Value().IsDouble())
+ ? aCon.Value().GetAsConstrainDoubleRange()
+ : empty;
+ };
+ const auto& w = getCLR(vc.mWidth);
+ const auto& h = getCLR(vc.mHeight);
+ const auto& f = getCDR(vc.mFrameRate);
+ /* If CS contains a member whose name specifies a constrainable property
+ * applicable to display surfaces, and whose value in turn is a dictionary
+ * containing a member named either min or exact, return a promise
+ * rejected with a newly created TypeError. */
+ if (w.mMin.WasPassed() || h.mMin.WasPassed() || f.mMin.WasPassed()) {
+ p->MaybeRejectWithTypeError("min not allowed");
+ return p.forget();
+ }
+ if (w.mExact.WasPassed() || h.mExact.WasPassed() || f.mExact.WasPassed()) {
+ p->MaybeRejectWithTypeError("exact not allowed");
+ return p.forget();
+ }
+ /* If CS contains a member whose name, failedConstraint specifies a
+ * constrainable property, constraint, applicable to display surfaces, and
+ * whose value in turn is a dictionary containing a member named max, and
+ * that member's value in turn is less than the constrainable property's
+ * floor value, then let failedConstraint be the name of the constraint,
+ * let message be either undefined or an informative human-readable
+ * message, and return a promise rejected with a new OverconstrainedError
+ * created by calling OverconstrainedError(failedConstraint, message). */
+ // We fail early without incurring a prompt, on known-to-fail constraint
+ // values that don't reveal anything about the user's system.
+ const char* badConstraint = nullptr;
+ if (w.mMax.WasPassed() && w.mMax.Value() < 1) {
+ badConstraint = "width";
+ }
+ if (h.mMax.WasPassed() && h.mMax.Value() < 1) {
+ badConstraint = "height";
+ }
+ if (f.mMax.WasPassed() && f.mMax.Value() < 1) {
+ badConstraint = "frameRate";
+ }
+ if (badConstraint) {
+ p->MaybeReject(MakeRefPtr<dom::MediaStreamError>(
+ owner, *MakeRefPtr<MediaMgrError>(
+ MediaMgrError::Name::OverconstrainedError, "",
+ NS_ConvertASCIItoUTF16(badConstraint))));
+ return p.forget();
+ }
+ }
+ /* If the relevant settings object's responsible document is NOT fully
+ * active, return a promise rejected with a DOMException object whose name
+ * attribute has the value "InvalidStateError". */
+ if (!owner->IsFullyActive()) {
+ p->MaybeRejectWithInvalidStateError("The document is not fully active.");
+ return p.forget();
+ }
+ // We ask for "screen" sharing.
+ //
+ // If this is a privileged call or permission is disabled, this gives us full
+ // screen sharing by default, which is useful for internal testing.
+ //
+ // If this is a non-priviliged call, GetUserMedia() will change it to "window"
+ // for us.
+ vc.mMediaSource.Reset();
+ vc.mMediaSource.Construct().AssignASCII(
+ dom::MediaSourceEnumValues::GetString(MediaSourceEnum::Screen));
+
+ RefPtr<MediaDevices> self(this);
+ MediaManager::Get()
+ ->GetUserMedia(owner, c, aCallerType)
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [this, self, p](RefPtr<DOMMediaStream>&& aStream) {
+ if (!GetWindowIfCurrent()) {
+ return; // leave promise pending after navigation.
+ }
+ p->MaybeResolve(std::move(aStream));
+ },
+ [this, self, p](RefPtr<MediaMgrError>&& error) {
+ nsPIDOMWindowInner* window = GetWindowIfCurrent();
+ if (!window) {
+ return; // leave promise pending after navigation.
+ }
+ error->Reject(p);
+ });
+ return p.forget();
+}
+
+already_AddRefed<Promise> MediaDevices::SelectAudioOutput(
+ const AudioOutputOptions& aOptions, CallerType aCallerType,
+ ErrorResult& aRv) {
+ nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(GetWrapper());
+ RefPtr<Promise> p = Promise::Create(global, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+ /* (This includes the expected user activation update of
+ * https://github.com/w3c/mediacapture-output/issues/107)
+ * If the relevant global object of this does not have transient activation,
+ * return a promise rejected with a DOMException object whose name attribute
+ * has the value InvalidStateError. */
+ nsCOMPtr<nsPIDOMWindowInner> owner = do_QueryInterface(global);
+ WindowContext* wc = owner->GetWindowContext();
+ if (!wc || !wc->HasValidTransientUserGestureActivation()) {
+ p->MaybeRejectWithInvalidStateError(
+ "selectAudioOutput requires transient user activation.");
+ return p.forget();
+ }
+ RefPtr<MediaDevices> self(this);
+ MediaManager::Get()
+ ->SelectAudioOutput(owner, aOptions, aCallerType)
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [this, self, p](RefPtr<LocalMediaDevice> aDevice) {
+ nsPIDOMWindowInner* window = GetWindowIfCurrent();
+ if (!window) {
+ return; // Leave Promise pending after navigation by design.
+ }
+ MOZ_ASSERT(aDevice->Kind() == dom::MediaDeviceKind::Audiooutput);
+ mExplicitlyGrantedAudioOutputRawIds.Insert(aDevice->RawID());
+ p->MaybeResolve(
+ MakeRefPtr<MediaDeviceInfo>(aDevice->mID, aDevice->Kind(),
+ aDevice->mName, aDevice->mGroupID));
+ },
+ [this, self, p](const RefPtr<MediaMgrError>& error) {
+ nsPIDOMWindowInner* window = GetWindowIfCurrent();
+ if (!window) {
+ return; // Leave Promise pending after navigation by design.
+ }
+ error->Reject(p);
+ });
+ return p.forget();
+}
+
+static RefPtr<AudioDeviceInfo> CopyWithNullDeviceId(
+ AudioDeviceInfo* aDeviceInfo) {
+ MOZ_ASSERT(aDeviceInfo->Preferred());
+
+ nsString vendor;
+ aDeviceInfo->GetVendor(vendor);
+ uint16_t type;
+ aDeviceInfo->GetType(&type);
+ uint16_t state;
+ aDeviceInfo->GetState(&state);
+ uint16_t pref;
+ aDeviceInfo->GetPreferred(&pref);
+ uint16_t supportedFormat;
+ aDeviceInfo->GetSupportedFormat(&supportedFormat);
+ uint16_t defaultFormat;
+ aDeviceInfo->GetDefaultFormat(&defaultFormat);
+ uint32_t maxChannels;
+ aDeviceInfo->GetMaxChannels(&maxChannels);
+ uint32_t defaultRate;
+ aDeviceInfo->GetDefaultRate(&defaultRate);
+ uint32_t maxRate;
+ aDeviceInfo->GetMaxRate(&maxRate);
+ uint32_t minRate;
+ aDeviceInfo->GetMinRate(&minRate);
+ uint32_t maxLatency;
+ aDeviceInfo->GetMaxLatency(&maxLatency);
+ uint32_t minLatency;
+ aDeviceInfo->GetMinLatency(&minLatency);
+
+ return MakeRefPtr<AudioDeviceInfo>(
+ nullptr, aDeviceInfo->Name(), aDeviceInfo->GroupID(), vendor, type, state,
+ pref, supportedFormat, defaultFormat, maxChannels, defaultRate, maxRate,
+ minRate, maxLatency, minLatency);
+}
+
+RefPtr<MediaDevices::SinkInfoPromise> MediaDevices::GetSinkDevice(
+ const nsString& aDeviceId) {
+ MOZ_ASSERT(NS_IsMainThread());
+ return MediaManager::Get()
+ ->GetPhysicalDevices()
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr(this), this,
+ aDeviceId](RefPtr<const MediaDeviceSetRefCnt> aRawDevices) {
+ nsCOMPtr<nsPIDOMWindowInner> window = GetOwner();
+ if (!window) {
+ return LocalDeviceSetPromise::CreateAndReject(
+ new MediaMgrError(MediaMgrError::Name::AbortError), __func__);
+ }
+ // Don't filter if matching the preferred device, because that may
+ // not be exposed.
+ RefPtr devices = aDeviceId.IsEmpty()
+ ? std::move(aRawDevices)
+ : FilterExposedDevices(*aRawDevices);
+ return MediaManager::Get()->AnonymizeDevices(window,
+ std::move(devices));
+ },
+ [](RefPtr<MediaMgrError>&& reason) {
+ MOZ_ASSERT_UNREACHABLE("GetPhysicalDevices does not reject");
+ return RefPtr<LocalDeviceSetPromise>();
+ })
+ ->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [aDeviceId](RefPtr<LocalMediaDeviceSetRefCnt> aDevices) {
+ RefPtr<AudioDeviceInfo> outputInfo;
+ // Check for a matching device.
+ for (const RefPtr<LocalMediaDevice>& device : *aDevices) {
+ if (device->Kind() != dom::MediaDeviceKind::Audiooutput) {
+ continue;
+ }
+ if (aDeviceId.IsEmpty()) {
+ MOZ_ASSERT(device->GetAudioDeviceInfo()->Preferred(),
+ "First Audiooutput should be preferred");
+ return SinkInfoPromise::CreateAndResolve(
+ CopyWithNullDeviceId(device->GetAudioDeviceInfo()),
+ __func__);
+ } else if (aDeviceId.Equals(device->mID)) {
+ return SinkInfoPromise::CreateAndResolve(
+ device->GetAudioDeviceInfo(), __func__);
+ }
+ }
+ /* If sinkId is not the empty string and does not match any audio
+ * output device identified by the result that would be provided
+ * by enumerateDevices(), reject p with a new DOMException whose
+ * name is NotFoundError and abort these substeps. */
+ return SinkInfoPromise::CreateAndReject(NS_ERROR_NOT_AVAILABLE,
+ __func__);
+ },
+ // aRejectMethod =
+ [](RefPtr<MediaMgrError>&& aError) {
+ return SinkInfoPromise::CreateAndReject(NS_ERROR_NOT_AVAILABLE,
+ __func__);
+ });
+}
+
+NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(MediaDevices,
+ DOMEventTargetHelper)
+NS_IMPL_CYCLE_COLLECTION_INHERITED(MediaDevices, DOMEventTargetHelper,
+ mPendingEnumerateDevicesPromises)
+
+void MediaDevices::OnDeviceChange() {
+ MOZ_ASSERT(NS_IsMainThread());
+ if (NS_FAILED(CheckCurrentGlobalCorrectness())) {
+ // This is a ghost window, don't do anything.
+ return;
+ }
+
+ // Do not fire event to content script when
+ // privacy.resistFingerprinting is true.
+
+ if (nsContentUtils::ShouldResistFingerprinting(
+ "Guarding the more expensive RFP check with a simple one",
+ RFPTarget::Unknown)) {
+ nsCOMPtr<nsPIDOMWindowInner> window = GetOwner();
+ auto* wrapper = GetWrapper();
+ if (!window && wrapper) {
+ nsCOMPtr<nsIGlobalObject> global = xpc::NativeGlobal(wrapper);
+ window = do_QueryInterface(global);
+ }
+ if (!window) {
+ return;
+ }
+
+ if (nsGlobalWindowInner::Cast(window)->ShouldResistFingerprinting(
+ RFPTarget::Unknown)) {
+ return;
+ }
+ }
+
+ mHaveUnprocessedDeviceListChange = true;
+ MaybeResumeDeviceExposure();
+}
+
+mozilla::dom::EventHandlerNonNull* MediaDevices::GetOndevicechange() {
+ return GetEventHandler(nsGkAtoms::ondevicechange);
+}
+
+void MediaDevices::SetupDeviceChangeListener() {
+ if (mIsDeviceChangeListenerSetUp) {
+ return;
+ }
+
+ nsPIDOMWindowInner* window = GetOwner();
+ if (!window) {
+ return;
+ }
+
+ nsISerialEventTarget* mainThread =
+ window->EventTargetFor(TaskCategory::Other);
+ if (!mainThread) {
+ return;
+ }
+
+ mDeviceChangeListener = MediaManager::Get()->DeviceListChangeEvent().Connect(
+ mainThread, this, &MediaDevices::OnDeviceChange);
+ mIsDeviceChangeListenerSetUp = true;
+
+ MediaManager::Get()->GetPhysicalDevices()->Then(
+ GetCurrentSerialEventTarget(), __func__,
+ [self = RefPtr(this), this](RefPtr<const MediaDeviceSetRefCnt> aDevices) {
+ mLastPhysicalDevices = std::move(aDevices);
+ },
+ [](RefPtr<MediaMgrError>&& reason) {
+ MOZ_ASSERT_UNREACHABLE("GetPhysicalDevices does not reject");
+ });
+}
+
+void MediaDevices::SetOndevicechange(
+ mozilla::dom::EventHandlerNonNull* aCallback) {
+ SetEventHandler(nsGkAtoms::ondevicechange, aCallback);
+}
+
+void MediaDevices::EventListenerAdded(nsAtom* aType) {
+ DOMEventTargetHelper::EventListenerAdded(aType);
+ SetupDeviceChangeListener();
+}
+
+JSObject* MediaDevices::WrapObject(JSContext* aCx,
+ JS::Handle<JSObject*> aGivenProto) {
+ return MediaDevices_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+} // namespace mozilla::dom