[MediaStream] RealtimeMediaSource should be able to vend hashed IDs
[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-2017 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 #include "UserMediaRequest.h"
36
37 #if ENABLE(MEDIA_STREAM)
38
39 #include "CaptureDeviceManager.h"
40 #include "DeprecatedGlobalSettings.h"
41 #include "Document.h"
42 #include "DocumentLoader.h"
43 #include "Frame.h"
44 #include "HTMLIFrameElement.h"
45 #include "HTMLParserIdioms.h"
46 #include "JSMediaStream.h"
47 #include "JSOverconstrainedError.h"
48 #include "Logging.h"
49 #include "MediaConstraints.h"
50 #include "RealtimeMediaSourceCenter.h"
51 #include "SchemeRegistry.h"
52 #include "Settings.h"
53 #include "UserMediaController.h"
54
55 namespace WebCore {
56
57 RefPtr<UserMediaRequest> UserMediaRequest::create(Document& document, MediaStreamRequest&& request, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
58 {
59     auto result = adoptRef(new UserMediaRequest(document, WTFMove(request), WTFMove(promise)));
60     result->suspendIfNeeded();
61     return result;
62 }
63
64 UserMediaRequest::UserMediaRequest(Document& document, MediaStreamRequest&& request, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
65     : ActiveDOMObject(&document)
66     , m_promise(WTFMove(promise))
67     , m_request(WTFMove(request))
68 {
69 }
70
71 UserMediaRequest::~UserMediaRequest() = default;
72
73 SecurityOrigin* UserMediaRequest::userMediaDocumentOrigin() const
74 {
75     if (!m_scriptExecutionContext)
76         return nullptr;
77     return m_scriptExecutionContext->securityOrigin();
78 }
79
80 SecurityOrigin* UserMediaRequest::topLevelDocumentOrigin() const
81 {
82     if (!m_scriptExecutionContext)
83         return nullptr;
84     return &m_scriptExecutionContext->topOrigin();
85 }
86
87 static bool isSecure(DocumentLoader& documentLoader)
88 {
89     auto& response = documentLoader.response();
90     if (SecurityOrigin::isLocalHostOrLoopbackIPAddress(documentLoader.response().url().host()))
91         return true;
92     return SchemeRegistry::shouldTreatURLSchemeAsSecure(response.url().protocol().toStringWithoutCopying())
93         && response.certificateInfo()
94         && !response.certificateInfo()->containsNonRootSHA1SignedCertificate();
95 }
96
97 static bool isAllowedToUse(Document& document, Document& topDocument, bool requiresAudio, bool requiresVideo)
98 {
99     if (&document == &topDocument)
100         return true;
101
102     auto* parentDocument = document.parentDocument();
103     if (!parentDocument)
104         return false;
105
106     if (document.securityOrigin().isSameSchemeHostPort(parentDocument->securityOrigin()))
107         return true;
108
109     auto* element = document.ownerElement();
110     ASSERT(element);
111     if (!element)
112         return false;
113
114     if (!is<HTMLIFrameElement>(*element))
115         return false;
116     auto& allow = downcast<HTMLIFrameElement>(*element).allow();
117
118     bool allowCameraAccess = false;
119     bool allowMicrophoneAccess = false;
120     for (auto allowItem : StringView { allow }.split(';')) {
121         auto item = allowItem.stripLeadingAndTrailingMatchedCharacters(isHTMLSpace<UChar>);
122         if (!allowCameraAccess && item == "camera")
123             allowCameraAccess = true;
124         else if (!allowMicrophoneAccess && item == "microphone")
125             allowMicrophoneAccess = true;
126     }
127     return (allowCameraAccess || !requiresVideo) && (allowMicrophoneAccess || !requiresAudio);
128 }
129
130 static bool canCallGetUserMedia(Document& document, bool wantsAudio, bool wantsVideo, String& errorMessage)
131 {
132     ASSERT(wantsAudio || wantsVideo);
133
134     bool requiresSecureConnection = DeprecatedGlobalSettings::mediaCaptureRequiresSecureConnection();
135     auto& documentLoader = *document.loader();
136     if (requiresSecureConnection && !isSecure(documentLoader)) {
137         errorMessage = "Trying to call getUserMedia from an insecure document.";
138         return false;
139     }
140
141     auto& topDocument = document.topDocument();
142     if (&document != &topDocument) {
143         for (auto* ancestorDocument = &document; ancestorDocument != &topDocument; ancestorDocument = ancestorDocument->parentDocument()) {
144             if (requiresSecureConnection && !isSecure(*ancestorDocument->loader())) {
145                 errorMessage = "Trying to call getUserMedia from a document with an insecure parent frame.";
146                 return false;
147             }
148
149             if (!isAllowedToUse(*ancestorDocument, topDocument, wantsAudio, wantsVideo)) {
150                 errorMessage = "The top-level frame has prevented a document with a different security origin to call getUserMedia.";
151                 return false;
152             }
153         }
154     }
155     
156     return true;
157 }
158
159 static bool hasInvalidGetDisplayMediaConstraint(const MediaConstraints& constraints)
160 {
161     // https://w3c.github.io/mediacapture-screen-share/#navigator-additions
162     // 1. Let constraints be the method's first argument.
163     // 2. For each member present in constraints whose value, value, is a dictionary, run the following steps:
164     //     1. If value contains a member named advanced, return a promise rejected with a newly created TypeError.
165     //     2. If value contains a member which in turn is a dictionary containing a member named either min or
166     //        exact, return a promise rejected with a newly created TypeError.
167     if (!constraints.isValid)
168         return false;
169
170     if (!constraints.advancedConstraints.isEmpty())
171         return true;
172
173     bool invalid = false;
174     constraints.mandatoryConstraints.filter([&invalid] (const MediaConstraint& constraint) mutable {
175         switch (constraint.constraintType()) {
176         case MediaConstraintType::Width:
177         case MediaConstraintType::Height: {
178             auto& intConstraint = downcast<IntConstraint>(constraint);
179             int value;
180             invalid = intConstraint.getExact(value) || intConstraint.getMin(value);
181             break;
182         }
183
184         case MediaConstraintType::AspectRatio:
185         case MediaConstraintType::FrameRate: {
186             auto& doubleConstraint = downcast<DoubleConstraint>(constraint);
187             double value;
188             invalid = doubleConstraint.getExact(value) || doubleConstraint.getMin(value);
189             break;
190         }
191
192         case MediaConstraintType::DisplaySurface:
193         case MediaConstraintType::LogicalSurface: {
194             auto& boolConstraint = downcast<BooleanConstraint>(constraint);
195             bool value;
196             invalid = boolConstraint.getExact(value);
197             break;
198         }
199
200         case MediaConstraintType::FacingMode:
201         case MediaConstraintType::DeviceId:
202         case MediaConstraintType::GroupId: {
203             auto& stringConstraint = downcast<StringConstraint>(constraint);
204             Vector<String> values;
205             invalid = stringConstraint.getExact(values);
206             break;
207         }
208
209         case MediaConstraintType::SampleRate:
210         case MediaConstraintType::SampleSize:
211         case MediaConstraintType::Volume:
212         case MediaConstraintType::EchoCancellation:
213             // Ignored.
214             break;
215
216         case MediaConstraintType::Unknown:
217             ASSERT_NOT_REACHED();
218             break;
219         }
220
221         return invalid;
222     });
223
224     return invalid;
225 }
226
227 void UserMediaRequest::start()
228 {
229     ASSERT(m_scriptExecutionContext);
230     if (!m_scriptExecutionContext) {
231         deny(MediaAccessDenialReason::UserMediaDisabled);
232         return;
233     }
234
235     if (m_request.type == MediaStreamRequest::Type::DisplayMedia) {
236         if (hasInvalidGetDisplayMediaConstraint(m_request.videoConstraints)) {
237             deny(MediaAccessDenialReason::IllegalConstraint);
238             return;
239         }
240     }
241
242     // https://w3c.github.io/mediacapture-main/getusermedia.html#dom-mediadevices-getusermedia()
243     // 1. Let constraints be the method's first argument.
244     // 2. Let requestedMediaTypes be the set of media types in constraints with either a dictionary
245     //    value or a value of "true".
246     // 3. If requestedMediaTypes is the empty set, return a promise rejected with a TypeError. The word
247     //    "optional" occurs in the WebIDL due to WebIDL rules, but the argument must be supplied in order
248     //    for the call to succeed.
249     if (!m_request.audioConstraints.isValid && !m_request.videoConstraints.isValid) {
250         deny(MediaAccessDenialReason::NoConstraints);
251         return;
252     }
253
254     // 4. If the current settings object's responsible document is NOT allowed to use the feature indicated by
255     //    attribute name allowusermedia, return a promise rejected with a DOMException object whose name
256     //    attribute has the value SecurityError.
257     auto& document = downcast<Document>(*m_scriptExecutionContext);
258     auto* controller = UserMediaController::from(document.page());
259     if (!controller) {
260         deny(MediaAccessDenialReason::UserMediaDisabled);
261         return;
262     }
263
264     // 6.3 Optionally, e.g., based on a previously-established user preference, for security reasons,
265     //     or due to platform limitations, jump to the step labeled Permission Failure below.
266     // ...
267     // 6.10 Permission Failure: Reject p with a new DOMException object whose name attribute has
268     //      the value NotAllowedError.
269     String errorMessage;
270     if (!canCallGetUserMedia(document, m_request.audioConstraints.isValid, m_request.videoConstraints.isValid, errorMessage)) {
271         deny(MediaAccessDenialReason::PermissionDenied);
272         document.domWindow()->printErrorMessage(errorMessage);
273         return;
274     }
275
276     controller->requestUserMediaAccess(*this);
277 }
278
279 void UserMediaRequest::allow(CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt)
280 {
281     RELEASE_LOG(MediaStream, "UserMediaRequest::allow %s %s", audioDevice ? audioDevice.persistentId().utf8().data() : "", videoDevice ? videoDevice.persistentId().utf8().data() : "");
282
283     auto callback = [this, protector = makePendingActivity(*this)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
284         if (!m_scriptExecutionContext)
285             return;
286
287         if (!privateStream) {
288             RELEASE_LOG(MediaStream, "UserMediaRequest::allow failed to create media stream!");
289             deny(MediaAccessDenialReason::HardwareError);
290             return;
291         }
292         privateStream->monitorOrientation(downcast<Document>(m_scriptExecutionContext)->orientationNotifier());
293
294         auto stream = MediaStream::create(*m_scriptExecutionContext, privateStream.releaseNonNull());
295         if (stream->getTracks().isEmpty()) {
296             deny(MediaAccessDenialReason::HardwareError);
297             return;
298         }
299
300         m_pendingActivationMediaStream = PendingActivationMediaStream::create(WTFMove(protector), *this, WTFMove(stream));
301     };
302
303     auto& document = downcast<Document>(*scriptExecutionContext());
304     document.setDeviceIDHashSalt(deviceIdentifierHashSalt);
305
306     RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), WTFMove(deviceIdentifierHashSalt), WTFMove(audioDevice), WTFMove(videoDevice), m_request);
307
308     if (!m_scriptExecutionContext)
309         return;
310
311 #if ENABLE(WEB_RTC)
312     if (auto* page = document.page())
313         page->rtcController().disableICECandidateFilteringForDocument(document);
314 #endif
315 }
316
317 void UserMediaRequest::deny(MediaAccessDenialReason reason, const String& message)
318 {
319     if (!m_scriptExecutionContext)
320         return;
321
322     ExceptionCode code;
323     switch (reason) {
324     case MediaAccessDenialReason::IllegalConstraint:
325         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - invalid constraints");
326         code = TypeError;
327         break;
328     case MediaAccessDenialReason::NoConstraints:
329         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - no constraints");
330         code = TypeError;
331         break;
332     case MediaAccessDenialReason::UserMediaDisabled:
333         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - user media disabled");
334         code = SecurityError;
335         break;
336     case MediaAccessDenialReason::NoCaptureDevices:
337         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - no capture devices");
338         code = NotFoundError;
339         break;
340     case MediaAccessDenialReason::InvalidConstraint:
341         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - invalid constraint - %s", message.utf8().data());
342         m_promise.rejectType<IDLInterface<OverconstrainedError>>(OverconstrainedError::create(message, "Invalid constraint"_s).get());
343         return;
344     case MediaAccessDenialReason::HardwareError:
345         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - hardware error");
346         code = NotReadableError;
347         break;
348     case MediaAccessDenialReason::OtherFailure:
349         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - other failure");
350         code = AbortError;
351         break;
352     case MediaAccessDenialReason::PermissionDenied:
353         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - permission denied");
354         code = NotAllowedError;
355         break;
356     case MediaAccessDenialReason::InvalidAccess:
357         RELEASE_LOG(MediaStream, "UserMediaRequest::deny - invalid access");
358         code = InvalidAccessError;
359         break;
360     }
361
362     if (!message.isEmpty())
363         m_promise.reject(code, message);
364     else
365         m_promise.reject(code);
366 }
367
368 void UserMediaRequest::stop()
369 {
370     // Protecting 'this' since nulling m_pendingActivationMediaStream might destroy it.
371     Ref<UserMediaRequest> protectedThis(*this);
372
373     m_pendingActivationMediaStream = nullptr;
374
375     auto& document = downcast<Document>(*m_scriptExecutionContext);
376     if (auto* controller = UserMediaController::from(document.page()))
377         controller->cancelUserMediaAccessRequest(*this);
378 }
379
380 const char* UserMediaRequest::activeDOMObjectName() const
381 {
382     return "UserMediaRequest";
383 }
384
385 bool UserMediaRequest::canSuspendForDocumentSuspension() const
386 {
387     return !hasPendingActivity();
388 }
389
390 Document* UserMediaRequest::document() const
391 {
392     return downcast<Document>(m_scriptExecutionContext);
393 }
394
395 UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream(Ref<PendingActivity<UserMediaRequest>>&& protectingUserMediaRequest, UserMediaRequest& userMediaRequest, Ref<MediaStream>&& stream)
396     : m_protectingUserMediaRequest(WTFMove(protectingUserMediaRequest))
397     , m_userMediaRequest(userMediaRequest)
398     , m_mediaStream(WTFMove(stream))
399 {
400     m_mediaStream->privateStream().addObserver(*this);
401     m_mediaStream->startProducingData();
402 }
403
404 UserMediaRequest::PendingActivationMediaStream::~PendingActivationMediaStream()
405 {
406     m_mediaStream->privateStream().removeObserver(*this);
407 }
408
409 void UserMediaRequest::PendingActivationMediaStream::characteristicsChanged()
410 {
411     if (!m_userMediaRequest.m_pendingActivationMediaStream)
412         return;
413
414     for (auto& track : m_mediaStream->privateStream().tracks()) {
415         if (track->source().captureDidFail()) {
416             m_userMediaRequest.mediaStreamDidFail(track->source().type());
417             return;
418         }
419     }
420
421     if (m_mediaStream->privateStream().hasVideo() || m_mediaStream->privateStream().hasAudio()) {
422         m_userMediaRequest.mediaStreamIsReady(WTFMove(m_mediaStream));
423         return;
424     }
425 }
426
427 void UserMediaRequest::mediaStreamIsReady(Ref<MediaStream>&& stream)
428 {
429     RELEASE_LOG(MediaStream, "UserMediaRequest::mediaStreamIsReady");
430     stream->document()->setHasCaptureMediaStreamTrack();
431     m_promise.resolve(WTFMove(stream));
432     // We are in an observer iterator loop, we do not want to change the observers within this loop.
433     callOnMainThread([stream = WTFMove(m_pendingActivationMediaStream)] { });
434 }
435
436 void UserMediaRequest::mediaStreamDidFail(RealtimeMediaSource::Type type)
437 {
438     RELEASE_LOG(MediaStream, "UserMediaRequest::mediaStreamDidFail");
439     const char* typeDescription = "";
440     switch (type) {
441     case RealtimeMediaSource::Type::Audio:
442         typeDescription = "audio";
443         break;
444     case RealtimeMediaSource::Type::Video:
445         typeDescription = "video";
446         break;
447     case RealtimeMediaSource::Type::None:
448         typeDescription = "unknown";
449         break;
450     }
451     m_promise.reject(NotReadableError, makeString("Failed starting capture of a "_s, typeDescription, " track"_s));
452     // We are in an observer iterator loop, we do not want to change the observers within this loop.
453     callOnMainThread([stream = WTFMove(m_pendingActivationMediaStream)] { });
454 }
455
456 } // namespace WebCore
457
458 #endif // ENABLE(MEDIA_STREAM)