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