UserMediaRequest.cpp [plain text]
#include "config.h"
#if ENABLE(MEDIA_STREAM)
#include "UserMediaRequest.h"
#include "Dictionary.h"
#include "Document.h"
#include "ExceptionCode.h"
#include "LocalMediaStream.h"
#include "MediaConstraintsImpl.h"
#include "MediaStreamCenter.h"
#include "MediaStreamDescriptor.h"
#include "SpaceSplitString.h"
#include "UserMediaController.h"
namespace WebCore {
static PassRefPtr<MediaConstraintsImpl> parseOptions(const Dictionary& options, const String& mediaType, ExceptionCode& ec)
{
RefPtr<MediaConstraintsImpl> constraints;
Dictionary constraintsDictionary;
bool ok = options.get(mediaType, constraintsDictionary);
if (ok && !constraintsDictionary.isUndefinedOrNull())
constraints = MediaConstraintsImpl::create(constraintsDictionary, ec);
else {
bool mediaRequested = false;
options.get(mediaType, mediaRequested);
if (mediaRequested)
constraints = MediaConstraintsImpl::create();
}
return constraints.release();
}
PassRefPtr<UserMediaRequest> UserMediaRequest::create(ScriptExecutionContext* context, UserMediaController* controller, const Dictionary& options, PassRefPtr<NavigatorUserMediaSuccessCallback> successCallback, PassRefPtr<NavigatorUserMediaErrorCallback> errorCallback, ExceptionCode& ec)
{
RefPtr<MediaConstraintsImpl> audio = parseOptions(options, ASCIILiteral("audio"), ec);
if (ec)
return 0;
RefPtr<MediaConstraintsImpl> video = parseOptions(options, ASCIILiteral("video"), ec);
if (ec)
return 0;
if (!audio && !video)
return 0;
return adoptRef(new UserMediaRequest(context, controller, audio.release(), video.release(), successCallback, errorCallback));
}
UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, PassRefPtr<MediaConstraintsImpl> audio, PassRefPtr<MediaConstraintsImpl> video, PassRefPtr<NavigatorUserMediaSuccessCallback> successCallback, PassRefPtr<NavigatorUserMediaErrorCallback> errorCallback)
: ContextDestructionObserver(context)
, m_audio(audio)
, m_video(video)
, m_controller(controller)
, m_successCallback(successCallback)
, m_errorCallback(errorCallback)
{
}
UserMediaRequest::~UserMediaRequest()
{
}
bool UserMediaRequest::audio() const
{
return m_audio;
}
bool UserMediaRequest::video() const
{
return m_video;
}
MediaConstraints* UserMediaRequest::audioConstraints() const
{
return m_audio.get();
}
MediaConstraints* UserMediaRequest::videoConstraints() const
{
return m_video.get();
}
Document* UserMediaRequest::ownerDocument()
{
if (m_scriptExecutionContext) {
return toDocument(m_scriptExecutionContext);
}
return 0;
}
void UserMediaRequest::start()
{
MediaStreamCenter::instance().queryMediaStreamSources(this);
}
void UserMediaRequest::didCompleteQuery(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
{
if (m_controller)
m_controller->requestUserMedia(this, audioSources, videoSources);
}
void UserMediaRequest::succeed(const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources)
{
if (!m_scriptExecutionContext)
return;
RefPtr<LocalMediaStream> stream = LocalMediaStream::create(m_scriptExecutionContext, audioSources, videoSources);
m_successCallback->handleEvent(stream.get());
}
void UserMediaRequest::succeed(PassRefPtr<MediaStreamDescriptor> streamDescriptor)
{
if (!m_scriptExecutionContext)
return;
RefPtr<LocalMediaStream> stream = LocalMediaStream::create(m_scriptExecutionContext, streamDescriptor);
m_successCallback->handleEvent(stream.get());
}
void UserMediaRequest::fail()
{
if (!m_scriptExecutionContext)
return;
if (m_errorCallback) {
RefPtr<NavigatorUserMediaError> error = NavigatorUserMediaError::create(NavigatorUserMediaError::PERMISSION_DENIED);
m_errorCallback->handleEvent(error.get());
}
}
void UserMediaRequest::contextDestroyed()
{
RefPtr<UserMediaRequest> protect(this);
if (m_controller) {
m_controller->cancelUserMediaRequest(this);
m_controller = 0;
}
ContextDestructionObserver::contextDestroyed();
}
}
#endif // ENABLE(MEDIA_STREAM)