Replace WTF::move with WTFMove
[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-2015 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 "JSNavigatorUserMediaError.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     RefPtr<MediaConstraints> audioConstraints = parseOptions(options, AtomicString("audio", AtomicString::ConstructFromLiteral));
84     RefPtr<MediaConstraints> videoConstraints = parseOptions(options, AtomicString("video", AtomicString::ConstructFromLiteral));
85
86     if (!audioConstraints && !videoConstraints) {
87         ec = NOT_SUPPORTED_ERR;
88         return;
89     }
90
91     Ref<UserMediaRequest> request = adoptRef(*new UserMediaRequest(document, userMedia, audioConstraints.release(), videoConstraints.release(), WTFMove(promise)));
92     request->start();
93 }
94
95 UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, PassRefPtr<MediaConstraints> audioConstraints, PassRefPtr<MediaConstraints> videoConstraints, MediaDevices::Promise&& promise)
96     : ContextDestructionObserver(context)
97     , m_audioConstraints(audioConstraints)
98     , m_videoConstraints(videoConstraints)
99     , m_controller(controller)
100     , m_promise(WTFMove(promise))
101 {
102 }
103
104 UserMediaRequest::~UserMediaRequest()
105 {
106 }
107
108 SecurityOrigin* UserMediaRequest::securityOrigin() const
109 {
110     if (m_scriptExecutionContext)
111         return m_scriptExecutionContext->securityOrigin();
112
113     return nullptr;
114 }
115     
116 void UserMediaRequest::start()
117 {
118     // 1 - make sure the system is capable of supporting the audio and video constraints. We don't want to ask for
119     // user permission if the constraints can not be suported.
120     RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
121 }
122
123 void UserMediaRequest::constraintsValidated(const Vector<RefPtr<RealtimeMediaSource>>& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>& videoTracks)
124 {
125     for (auto& audioTrack : audioTracks)
126         m_audioDeviceUIDs.append(audioTrack->persistentID());
127     for (auto& videoTrack : videoTracks)
128         m_videoDeviceUIDs.append(videoTrack->persistentID());
129
130     RefPtr<UserMediaRequest> protectedThis(this);
131     callOnMainThread([protectedThis] {
132         // 2 - The constraints are valid, ask the user for access to media.
133         if (UserMediaController* controller = protectedThis->m_controller)
134             controller->requestUserMediaAccess(*protectedThis.get());
135     });
136 }
137
138 void UserMediaRequest::userMediaAccessGranted(const String& audioDeviceUID, const String& videoDeviceUID)
139 {
140     m_allowedVideoDeviceUID = videoDeviceUID;
141     m_audioDeviceUIDAllowed = audioDeviceUID;
142
143     RefPtr<UserMediaRequest> protectedThis(this);
144     callOnMainThread([protectedThis, audioDeviceUID, videoDeviceUID] {
145         // 3 - the user granted access, ask platform to create the media stream descriptors.
146         RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.get(), audioDeviceUID, videoDeviceUID);
147     });
148 }
149
150 void UserMediaRequest::userMediaAccessDenied()
151 {
152     failedToCreateStreamWithPermissionError();
153 }
154
155 void UserMediaRequest::constraintsInvalid(const String& constraintName)
156 {
157     failedToCreateStreamWithConstraintsError(constraintName);
158 }
159
160 void UserMediaRequest::didCreateStream(PassRefPtr<MediaStreamPrivate> privateStream)
161 {
162     if (!m_scriptExecutionContext)
163         return;
164
165     // 4 - Create the MediaStream and pass it to the success callback.
166     RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
167     if (m_audioConstraints) {
168         for (auto& track : stream->getAudioTracks()) {
169             track->applyConstraints(*m_audioConstraints);
170             track->source().startProducingData();
171         }
172     }
173     if (m_videoConstraints) {
174         for (auto& track : stream->getVideoTracks()) {
175             track->applyConstraints(*m_videoConstraints);
176             track->source().startProducingData();
177         }
178     }
179
180     m_promise.resolve(stream);
181 }
182
183 void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
184 {
185     ASSERT(!constraintName.isEmpty());
186     if (!m_scriptExecutionContext)
187         return;
188
189     m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::constraintNotSatisfiedErrorName(), constraintName));
190 }
191
192 void UserMediaRequest::failedToCreateStreamWithPermissionError()
193 {
194     if (!m_scriptExecutionContext)
195         return;
196
197     // FIXME: Replace NavigatorUserMediaError with MediaStreamError (see bug 143335)
198     m_promise.reject(NavigatorUserMediaError::create(NavigatorUserMediaError::permissionDeniedErrorName(), emptyString()));
199 }
200
201 void UserMediaRequest::contextDestroyed()
202 {
203     Ref<UserMediaRequest> protect(*this);
204
205     if (m_controller) {
206         m_controller->cancelUserMediaAccessRequest(*this);
207         m_controller = nullptr;
208     }
209
210     ContextDestructionObserver::contextDestroyed();
211 }
212
213 } // namespace WebCore
214
215 #endif // ENABLE(MEDIA_STREAM)