UserMediaRequest.cpp [plain text]
#include "config.h"
#if ENABLE(MEDIA_STREAM)
#include "UserMediaRequest.h"
#include "Dictionary.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "JSMediaDeviceInfo.h"
#include "JSMediaStream.h"
#include "MainFrame.h"
#include "MediaConstraintsImpl.h"
#include "MediaStream.h"
#include "MediaStreamPrivate.h"
#include "RealtimeMediaSourceCenter.h"
#include "SecurityOrigin.h"
#include "UserMediaController.h"
#include <wtf/MainThread.h>
namespace WebCore {
static RefPtr<MediaConstraints> parseOptions(const Dictionary& options, const String& mediaType)
{
Dictionary constraintsDictionary;
if (options.get(mediaType, constraintsDictionary) && !constraintsDictionary.isUndefinedOrNull())
return MediaConstraintsImpl::create(constraintsDictionary);
bool mediaRequested = false;
if (!options.get(mediaType, mediaRequested) || !mediaRequested)
return nullptr;
return MediaConstraintsImpl::create();
}
void UserMediaRequest::start(Document* document, const Dictionary& options, MediaDevices::Promise&& promise, ExceptionCode& ec)
{
if (!options.isObject()) {
ec = TypeError;
return;
}
UserMediaController* userMedia = UserMediaController::from(document ? document->page() : nullptr);
if (!userMedia) {
ec = NOT_SUPPORTED_ERR;
return;
}
auto audioConstraints = parseOptions(options, AtomicString("audio", AtomicString::ConstructFromLiteral));
auto videoConstraints = parseOptions(options, AtomicString("video", AtomicString::ConstructFromLiteral));
if (!audioConstraints && !videoConstraints) {
ec = NOT_SUPPORTED_ERR;
return;
}
auto request = adoptRef(*new UserMediaRequest(document, userMedia, WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(promise)));
request->start();
}
UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints, MediaDevices::Promise&& promise)
: ContextDestructionObserver(context)
, m_audioConstraints(audioConstraints)
, m_videoConstraints(videoConstraints)
, m_controller(controller)
, m_promise(WTFMove(promise))
{
}
UserMediaRequest::~UserMediaRequest()
{
}
SecurityOrigin* UserMediaRequest::userMediaDocumentOrigin() const
{
if (!m_scriptExecutionContext)
return nullptr;
return m_scriptExecutionContext->securityOrigin();
}
SecurityOrigin* UserMediaRequest::topLevelDocumentOrigin() const
{
if (!m_scriptExecutionContext)
return nullptr;
return m_scriptExecutionContext->topOrigin();
}
void UserMediaRequest::start()
{
RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
}
void UserMediaRequest::constraintsValidated(const Vector<RefPtr<RealtimeMediaSource>>& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>& videoTracks)
{
for (auto& audioTrack : audioTracks)
m_audioDeviceUIDs.append(audioTrack->persistentID());
for (auto& videoTrack : videoTracks)
m_videoDeviceUIDs.append(videoTrack->persistentID());
callOnMainThread([protectedThis = makeRef(*this)]() mutable {
if (UserMediaController* controller = protectedThis->m_controller)
controller->requestUserMediaAccess(protectedThis.get());
});
}
void UserMediaRequest::userMediaAccessGranted(const String& audioDeviceUID, const String& videoDeviceUID)
{
m_allowedVideoDeviceUID = videoDeviceUID;
m_audioDeviceUIDAllowed = audioDeviceUID;
callOnMainThread([protectedThis = makeRef(*this), audioDeviceUID, videoDeviceUID]() mutable {
RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.ptr(), audioDeviceUID, videoDeviceUID);
});
}
void UserMediaRequest::userMediaAccessDenied()
{
failedToCreateStreamWithPermissionError();
}
void UserMediaRequest::constraintsInvalid(const String& constraintName)
{
failedToCreateStreamWithConstraintsError(constraintName);
}
void UserMediaRequest::didCreateStream(PassRefPtr<MediaStreamPrivate> privateStream)
{
if (!m_scriptExecutionContext)
return;
Ref<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
if (m_audioConstraints) {
for (auto& track : stream->getAudioTracks()) {
track->applyConstraints(*m_audioConstraints);
track->source().startProducingData();
}
}
if (m_videoConstraints) {
for (auto& track : stream->getVideoTracks()) {
track->applyConstraints(*m_videoConstraints);
track->source().startProducingData();
}
}
m_promise.resolve(stream);
}
void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
{
UNUSED_PARAM(constraintName);
ASSERT(!constraintName.isEmpty());
if (!m_scriptExecutionContext)
return;
m_promise.reject(DataError);
}
void UserMediaRequest::failedToCreateStreamWithPermissionError()
{
if (!m_scriptExecutionContext)
return;
m_promise.reject(NotAllowedError);
}
void UserMediaRequest::contextDestroyed()
{
Ref<UserMediaRequest> protectedThis(*this);
if (m_controller) {
m_controller->cancelUserMediaAccessRequest(*this);
m_controller = nullptr;
}
ContextDestructionObserver::contextDestroyed();
}
}
#endif // ENABLE(MEDIA_STREAM)