MediaDevices.getUserMedia should migrate from callbacks to DOMPromise
[WebKit-https.git] / Source / WebCore / Modules / mediastream / UserMediaRequest.cpp
1 /*
2  * Copyright (C) 2011 Ericsson AB. All rights reserved.
3  * Copyright (C) 2012 Google Inc. All rights reserved.
4  * Copyright (C) 2013 Apple Inc. All rights reserved.
5  * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer
15  *    in the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of Ericsson nor the names of its contributors
18  *    may be used to endorse or promote products derived from this
19  *    software without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include "config.h"
35
36 #if ENABLE(MEDIA_STREAM)
37
38 #include "UserMediaRequest.h"
39
40 #include "Dictionary.h"
41 #include "Document.h"
42 #include "ExceptionCode.h"
43 #include "Frame.h"
44 #include "JSMediaStream.h"
45 #include "JSNavigatorUserMediaError.h"
46 #include "MediaConstraintsImpl.h"
47 #include "MediaStream.h"
48 #include "MediaStreamPrivate.h"
49 #include "NavigatorUserMediaErrorCallback.h"
50 #include "NavigatorUserMediaSuccessCallback.h"
51 #include "RealtimeMediaSourceCenter.h"
52 #include "SecurityOrigin.h"
53 #include "UserMediaController.h"
54 #include <wtf/MainThread.h>
55
56 namespace WebCore {
57
58 static PassRefPtr<MediaConstraints> parseOptions(const Dictionary& options, const String& mediaType, ExceptionCode& ec)
59 {
60     RefPtr<MediaConstraints> constraints;
61
62     Dictionary constraintsDictionary;
63     bool ok = options.get(mediaType, constraintsDictionary);
64     if (ok && !constraintsDictionary.isUndefinedOrNull())
65         constraints = MediaConstraintsImpl::create(constraintsDictionary, ec);
66     else {
67         bool mediaRequested = false;
68         options.get(mediaType, mediaRequested);
69         if (mediaRequested)
70             constraints = MediaConstraintsImpl::create();
71     }
72
73     return constraints.release();
74 }
75
76 RefPtr<UserMediaRequest> UserMediaRequest::create(ScriptExecutionContext* context, UserMediaController* controller, const Dictionary& options, MediaDevices::Promise&& promise, ExceptionCode& ec)
77 {
78     RefPtr<MediaConstraints> audioConstraints = parseOptions(options, AtomicString("audio", AtomicString::ConstructFromLiteral), ec);
79     if (ec)
80         return nullptr;
81
82     RefPtr<MediaConstraints> videoConstraints = parseOptions(options, AtomicString("video", AtomicString::ConstructFromLiteral), ec);
83     if (ec)
84         return nullptr;
85
86     if (!audioConstraints && !videoConstraints)
87         return nullptr;
88
89     return adoptRef(*new UserMediaRequest(context, controller, audioConstraints.release(), videoConstraints.release(), WTF::move(promise)));
90 }
91
92 UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints, MediaDevices::Promise&& promise)
93     : ContextDestructionObserver(context)
94     , m_audioConstraints(audioConstraints)
95     , m_videoConstraints(videoConstraints)
96     , m_controller(controller)
97     , m_promise(WTF::move(promise))
98 {
99 }
100
101 UserMediaRequest::~UserMediaRequest()
102 {
103 }
104
105 SecurityOrigin* UserMediaRequest::securityOrigin() const
106 {
107     if (m_scriptExecutionContext)
108         return m_scriptExecutionContext->securityOrigin();
109
110     return nullptr;
111 }
112     
113 void UserMediaRequest::start()
114 {
115     // 1 - make sure the system is capable of supporting the audio and video constraints. We don't want to ask for
116     // user permission if the constraints can not be suported.
117     RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
118 }
119
120 void UserMediaRequest::constraintsValidated()
121 {
122     RefPtr<UserMediaRequest> protectedThis(this);
123     callOnMainThread([protectedThis] {
124         // 2 - The constraints are valid, ask the user for access to media.
125         if (UserMediaController* controller = protectedThis->m_controller)
126             controller->requestPermission(*protectedThis.get());
127     });
128 }
129
130 void UserMediaRequest::userMediaAccessGranted()
131 {
132     RefPtr<UserMediaRequest> protectedThis(this);
133     callOnMainThread([protectedThis] {
134         // 3 - the user granted access, ask platform to create the media stream descriptors.
135         RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.get(), protectedThis->m_audioConstraints, protectedThis->m_videoConstraints);
136     });
137 }
138
139 void UserMediaRequest::userMediaAccessDenied()
140 {
141     failedToCreateStreamWithPermissionError();
142 }
143
144 void UserMediaRequest::constraintsInvalid(const String& constraintName)
145 {
146     failedToCreateStreamWithConstraintsError(constraintName);
147 }
148
149 void UserMediaRequest::didCreateStream(PassRefPtr<MediaStreamPrivate> privateStream)
150 {
151     if (!m_scriptExecutionContext)
152         return;
153
154     // 4 - Create the MediaStream and pass it to the success callback.
155     RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
156     for (auto& track : stream->getAudioTracks())
157         track->applyConstraints(m_audioConstraints);
158     for (auto& track : stream->getVideoTracks())
159         track->applyConstraints(m_videoConstraints);
160
161     m_promise.resolve(stream);
162 }
163
164 void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
165 {
166     ASSERT(!constraintName.isEmpty());
167     if (!m_scriptExecutionContext)
168         return;
169
170     m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName));
171 }
172
173 void UserMediaRequest::failedToCreateStreamWithPermissionError()
174 {
175     if (!m_scriptExecutionContext)
176         return;
177
178     // FIXME: Replace NavigatorUserMediaError with MediaStreamError (see bug 143335)
179     m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::permissionDeniedErrorName(), emptyString()));
180 }
181
182 void UserMediaRequest::contextDestroyed()
183 {
184     Ref<UserMediaRequest> protect(*this);
185
186     if (m_controller) {
187         m_controller->cancelRequest(*this);
188         m_controller = nullptr;
189     }
190
191     ContextDestructionObserver::contextDestroyed();
192 }
193
194 } // namespace WebCore
195
196 #endif // ENABLE(MEDIA_STREAM)