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 "JSMediaStream.h"
#include "JSNavigatorUserMediaError.h"
#include "MediaConstraintsImpl.h"
#include "MediaStream.h"
#include "MediaStreamPrivate.h"
#include "NavigatorUserMediaErrorCallback.h"
#include "NavigatorUserMediaSuccessCallback.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;
}
RefPtr<MediaConstraints> audioConstraints = parseOptions(options, AtomicString("audio", AtomicString::ConstructFromLiteral));
RefPtr<MediaConstraints> videoConstraints = parseOptions(options, AtomicString("video", AtomicString::ConstructFromLiteral));
if (!audioConstraints && !videoConstraints) {
ec = NOT_SUPPORTED_ERR;
return;
}
Ref<UserMediaRequest> request = adoptRef(*new UserMediaRequest(document, userMedia, audioConstraints.release(), videoConstraints.release(), WTF::move(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(WTF::move(promise))
{
}
UserMediaRequest::~UserMediaRequest()
{
}
SecurityOrigin* UserMediaRequest::securityOrigin() const
{
if (m_scriptExecutionContext)
return m_scriptExecutionContext->securityOrigin();
return nullptr;
}
void UserMediaRequest::start()
{
RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
}
void UserMediaRequest::constraintsValidated()
{
RefPtr<UserMediaRequest> protectedThis(this);
callOnMainThread([protectedThis] {
if (UserMediaController* controller = protectedThis->m_controller)
controller->requestPermission(*protectedThis.get());
});
}
void UserMediaRequest::userMediaAccessGranted()
{
RefPtr<UserMediaRequest> protectedThis(this);
callOnMainThread([protectedThis] {
RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.get(), protectedThis->m_audioConstraints, protectedThis->m_videoConstraints);
});
}
void UserMediaRequest::userMediaAccessDenied()
{
failedToCreateStreamWithPermissionError();
}
void UserMediaRequest::constraintsInvalid(const String& constraintName)
{
failedToCreateStreamWithConstraintsError(constraintName);
}
void UserMediaRequest::didCreateStream(PassRefPtr<MediaStreamPrivate> privateStream)
{
if (!m_scriptExecutionContext)
return;
RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
for (auto& track : stream->getAudioTracks())
track->applyConstraints(*m_audioConstraints);
for (auto& track : stream->getVideoTracks())
track->applyConstraints(*m_videoConstraints);
m_promise.resolve(stream);
}
void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
{
ASSERT(!constraintName.isEmpty());
if (!m_scriptExecutionContext)
return;
m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName));
}
void UserMediaRequest::failedToCreateStreamWithPermissionError()
{
if (!m_scriptExecutionContext)
return;
m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::permissionDeniedErrorName(), emptyString()));
}
void UserMediaRequest::contextDestroyed()
{
Ref<UserMediaRequest> protect(*this);
if (m_controller) {
m_controller->cancelRequest(*this);
m_controller = nullptr;
}
ContextDestructionObserver::contextDestroyed();
}
}
#endif // ENABLE(MEDIA_STREAM)