Purge all uses of PassRefPtr in WebCore/Modules
[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-2016 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 "JSMediaDeviceInfo.h"
45 #include "JSMediaStream.h"
46 #include "MainFrame.h"
47 #include "MediaConstraintsImpl.h"
48 #include "MediaStream.h"
49 #include "MediaStreamPrivate.h"
50 #include "RealtimeMediaSourceCenter.h"
51 #include "SecurityOrigin.h"
52 #include "UserMediaController.h"
53 #include <wtf/MainThread.h>
54
55 namespace WebCore {
56
57 static RefPtr<MediaConstraints> parseOptions(const Dictionary& options, const String& mediaType)
58 {
59     Dictionary constraintsDictionary;
60     if (options.get(mediaType, constraintsDictionary) && !constraintsDictionary.isUndefinedOrNull())
61         return MediaConstraintsImpl::create(constraintsDictionary);
62
63     bool mediaRequested = false;
64     if (!options.get(mediaType, mediaRequested) || !mediaRequested)
65         return nullptr;
66
67     return MediaConstraintsImpl::create();
68 }
69
70 void UserMediaRequest::start(Document* document, const Dictionary& options, MediaDevices::Promise&& promise, ExceptionCode& ec)
71 {
72     if (!options.isObject()) {
73         ec = TypeError;
74         return;
75     }
76
77     UserMediaController* userMedia = UserMediaController::from(document ? document->page() : nullptr);
78     if (!userMedia) {
79         ec = NOT_SUPPORTED_ERR;
80         return;
81     }
82
83     auto audioConstraints = parseOptions(options, AtomicString("audio", AtomicString::ConstructFromLiteral));
84     auto videoConstraints = parseOptions(options, AtomicString("video", AtomicString::ConstructFromLiteral));
85
86     if (!audioConstraints && !videoConstraints) {
87         ec = NOT_SUPPORTED_ERR;
88         return;
89     }
90
91     auto request = adoptRef(*new UserMediaRequest(document, userMedia, WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(promise)));
92     request->start();
93 }
94
95 UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, RefPtr<MediaConstraints>&& audioConstraints, RefPtr<MediaConstraints>&& videoConstraints, MediaDevices::Promise&& promise)
96     : ContextDestructionObserver(context)
97     , m_audioConstraints(WTFMove(audioConstraints))
98     , m_videoConstraints(WTFMove(videoConstraints))
99     , m_controller(controller)
100     , m_promise(WTFMove(promise))
101 {
102 }
103
104 UserMediaRequest::~UserMediaRequest()
105 {
106 }
107
108 SecurityOrigin* UserMediaRequest::userMediaDocumentOrigin() const
109 {
110     if (!m_scriptExecutionContext)
111         return nullptr;
112
113     return m_scriptExecutionContext->securityOrigin();
114 }
115
116 SecurityOrigin* UserMediaRequest::topLevelDocumentOrigin() const
117 {
118     if (!m_scriptExecutionContext)
119         return nullptr;
120
121     return m_scriptExecutionContext->topOrigin();
122 }
123
124 void UserMediaRequest::start()
125 {
126     // 1 - make sure the system is capable of supporting the audio and video constraints. We don't want to ask for
127     // user permission if the constraints can not be suported.
128     RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
129 }
130
131 void UserMediaRequest::constraintsValidated(const Vector<RefPtr<RealtimeMediaSource>>& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>& videoTracks)
132 {
133     for (auto& audioTrack : audioTracks)
134         m_audioDeviceUIDs.append(audioTrack->persistentID());
135     for (auto& videoTrack : videoTracks)
136         m_videoDeviceUIDs.append(videoTrack->persistentID());
137
138     callOnMainThread([protectedThis = makeRef(*this)]() mutable {
139         // 2 - The constraints are valid, ask the user for access to media.
140         if (UserMediaController* controller = protectedThis->m_controller)
141             controller->requestUserMediaAccess(protectedThis.get());
142     });
143 }
144
145 void UserMediaRequest::userMediaAccessGranted(const String& audioDeviceUID, const String& videoDeviceUID)
146 {
147     m_allowedVideoDeviceUID = videoDeviceUID;
148     m_audioDeviceUIDAllowed = audioDeviceUID;
149
150     callOnMainThread([protectedThis = makeRef(*this), audioDeviceUID, videoDeviceUID]() mutable {
151         // 3 - the user granted access, ask platform to create the media stream descriptors.
152         RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.ptr(), audioDeviceUID, videoDeviceUID);
153     });
154 }
155
156 void UserMediaRequest::userMediaAccessDenied()
157 {
158     failedToCreateStreamWithPermissionError();
159 }
160
161 void UserMediaRequest::constraintsInvalid(const String& constraintName)
162 {
163     failedToCreateStreamWithConstraintsError(constraintName);
164 }
165
166 void UserMediaRequest::didCreateStream(RefPtr<MediaStreamPrivate>&& privateStream)
167 {
168     if (!m_scriptExecutionContext)
169         return;
170
171     // 4 - Create the MediaStream and pass it to the success callback.
172     Ref<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, WTFMove(privateStream));
173     if (m_audioConstraints) {
174         for (auto& track : stream->getAudioTracks()) {
175             track->applyConstraints(*m_audioConstraints);
176             track->source().startProducingData();
177         }
178     }
179     if (m_videoConstraints) {
180         for (auto& track : stream->getVideoTracks()) {
181             track->applyConstraints(*m_videoConstraints);
182             track->source().startProducingData();
183         }
184     }
185
186     m_promise.resolve(stream);
187 }
188
189 void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
190 {
191     UNUSED_PARAM(constraintName);
192     ASSERT(!constraintName.isEmpty());
193     if (!m_scriptExecutionContext)
194         return;
195
196     // FIXME: The promise should be rejected with an OverconstrainedError, https://bugs.webkit.org/show_bug.cgi?id=157839.
197     m_promise.reject(DataError);
198 }
199
200 void UserMediaRequest::failedToCreateStreamWithPermissionError()
201 {
202     if (!m_scriptExecutionContext)
203         return;
204
205     m_promise.reject(NotAllowedError);
206 }
207
208 void UserMediaRequest::contextDestroyed()
209 {
210     Ref<UserMediaRequest> protectedThis(*this);
211
212     if (m_controller) {
213         m_controller->cancelUserMediaAccessRequest(*this);
214         m_controller = nullptr;
215     }
216
217     ContextDestructionObserver::contextDestroyed();
218 }
219
220 } // namespace WebCore
221
222 #endif // ENABLE(MEDIA_STREAM)