Changeset 207463 in webkit


Ignore:
Timestamp:
Oct 18, 2016, 7:53:06 AM (9 years ago)
Author:
eric.carlson@apple.com
Message:

Source/WebCore:
[MediaStream] Resolve constraints and enumerate devices in the UI process
​https://bugs.webkit.org/show_bug.cgi?id=162147
<rdar://problem/28803569>

Reviewed by Darin Adler.

Restructure gUM constraint validation and MediaDevices.enumerateDevices so all media device
access happens in the UI process.

No new tests, updated results of existing tests.

  • CMakeLists.txt: Add MediaDevicesEnumerationRequest.cpp, delete UserMediaPermissionCheck.cpp.
  • Modules/mediastream/MediaConstraintsImpl.cpp:

(WebCore::MediaConstraintsImpl::create): Only create from MediaConstraintsData.
(WebCore::MediaConstraintsImpl::initialize): Deleted.

  • Modules/mediastream/MediaConstraintsImpl.h:
  • Modules/mediastream/MediaDevicesEnumerationRequest.cpp: Added.

(WebCore::MediaDevicesEnumerationRequest::create):
(WebCore::MediaDevicesEnumerationRequest::MediaDevicesEnumerationRequest):
(WebCore::MediaDevicesEnumerationRequest::~MediaDevicesEnumerationRequest):
(WebCore::MediaDevicesEnumerationRequest::userMediaDocumentOrigin):
(WebCore::MediaDevicesEnumerationRequest::topLevelDocumentOrigin):
(WebCore::MediaDevicesEnumerationRequest::contextDestroyed):
(WebCore::MediaDevicesEnumerationRequest::start):
(WebCore::MediaDevicesEnumerationRequest::cancel):
(WebCore::MediaDevicesEnumerationRequest::setDeviceInfo):
(WebCore::MediaDevicesEnumerationRequest::finish):

  • Modules/mediastream/MediaDevicesEnumerationRequest.h: Added.
  • Modules/mediastream/MediaDevicesRequest.cpp:

(WebCore::MediaDevicesRequest::~MediaDevicesRequest): Clear the enumeration request.
(WebCore::MediaDevicesRequest::contextDestroyed): Ditto.
(WebCore::MediaDevicesRequest::start): Create and use a MediaDevicesEnumerationRequest.
(WebCore::MediaDevicesRequest::didCompletePermissionCheck): Deleted.

  • Modules/mediastream/MediaDevicesRequest.h:
  • Modules/mediastream/UserMediaClient.h:
  • Modules/mediastream/UserMediaController.h:

(WebCore::UserMediaController::enumerateMediaDevices): New.
(WebCore::UserMediaController::cancelMediaDevicesEnumerationRequest): New.
(WebCore::UserMediaController::checkUserMediaPermission): Deleted.
(WebCore::UserMediaController::cancelUserMediaPermissionCheck): Deleted.

  • Modules/mediastream/UserMediaPermissionCheck.h: Deleted.
  • Modules/mediastream/UserMediaPermissionCheck.cpp: Deleted.
  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::UserMediaRequest):
(WebCore::UserMediaRequest::start):
(WebCore::UserMediaRequest::allow):
(WebCore::UserMediaRequest::deny):
(WebCore::UserMediaRequest::constraintsValidated): Deleted.
(WebCore::UserMediaRequest::userMediaAccessGranted): Deleted.
(WebCore::UserMediaRequest::userMediaAccessDenied): Deleted.
(WebCore::UserMediaRequest::constraintsInvalid): Deleted.
(WebCore::UserMediaRequest::didCreateStream): Deleted.
(WebCore::UserMediaRequest::failedToCreateStreamWithConstraintsError): Deleted.
(WebCore::UserMediaRequest::failedToCreateStreamWithPermissionError): Deleted.

  • Modules/mediastream/UserMediaRequest.h:
  • WebCore.xcodeproj/project.pbxproj: Add MediaDevicesEnumerationRequest.*.
  • platform/mediastream/CaptureDevice.h:

(WebCore::CaptureDevice::CaptureDevice):
(WebCore::CaptureDevice::setPersistentId): Add setter for argument decoder.
(WebCore::CaptureDevice::setLabel): Ditto.
(WebCore::CaptureDevice::setGroupId): Ditto.
(WebCore::CaptureDevice::setKind): Ditto.

  • platform/mediastream/CaptureDeviceManager.h: Remove unnecessary include.
  • platform/mediastream/MediaConstraints.h:

(WebCore::MediaConstraint::encode): New.
(WebCore::MediaConstraint::decode): Ditto.
(WebCore::NumericConstraint::encode): Ditto.
(WebCore::NumericConstraint::decode): Ditto.

  • platform/mediastream/MediaStreamCreationClient.h: Deleted.
  • platform/mediastream/RealtimeMediaSourceCenter.h: Use completion handlers instead of client interface.
  • platform/mediastream/mac/AVCaptureDeviceManager.mm:

(WebCore::AVCaptureDeviceManager::refreshCaptureDeviceList): Drive-by fix: don't initialize
group id, we don't support it.

  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:

(WebCore::RealtimeMediaSourceCenterMac::validateRequestConstraints): Update for interface change.
(WebCore::RealtimeMediaSourceCenterMac::createMediaStream): Ditto.

  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.h:
  • platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.cpp:

(WebCore::RealtimeMediaSourceCenterOwr::validateRequestConstraints): Ditto.
(WebCore::RealtimeMediaSourceCenterOwr::createMediaStream): Ditto.
(WebCore::RealtimeMediaSourceCenterOwr::mediaSourcesAvailable): Ditto.

  • platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.h:
  • platform/mock/MockRealtimeMediaSourceCenter.cpp:

(WebCore::MockRealtimeMediaSourceCenter::validateRequestConstraints): Ditto.
(WebCore::MockRealtimeMediaSourceCenter::createMediaStream): Ditto.

  • platform/mock/MockRealtimeMediaSourceCenter.h:

Source/WebKit:
Fix CMake build.

Patch by Alex Christensen <​achristensen@webkit.org> on 2016-10-14

  • PlatformMac.cmake:

Source/WebKit2:
[MediaStream] Resolve constraints and enumerate devices in the UI process
​https://bugs.webkit.org/show_bug.cgi?id=162147
<rdar://problem/28803569>

Reviewed by Darin Adler.

Restructure gUM constraint validation and MediaDevices.enumerateDevices so all media device
access happens in the UI process.

  • Scripts/webkit/messages.py:

(headers_for_type): Special case MediaConstraintsData.

  • Shared/WebCoreArgumentCoders.cpp:

(IPC::encodeMediaTrackConstraintSetMap): MediaTrackConstraintSetMap encoder.
(IPC::ArgumentCoder<MediaConstraintsData>::encode): MediaConstraintsData encoder.
(IPC::decodeMediaTrackConstraintSetMap): MediaTrackConstraintSetMap decoder.
(IPC::ArgumentCoder<MediaConstraintsData>::decode): MediaConstraintsData decoder.
(IPC::ArgumentCoder<CaptureDevice>::encode): CaptureDevice enoder.
(IPC::ArgumentCoder<CaptureDevice>::decode): CaptureDevice decoder.

  • Shared/WebCoreArgumentCoders.h:
  • UIProcess/API/APIUIClient.h: Remove UserMediaPermissionCheckProxy forward declaration.
  • UIProcess/API/C/WKUserMediaPermissionRequest.cpp:

(toWK): Translate UserMediaPermissionRequestDenialReason to UserMediaAccessDenialReason.
(WKUserMediaPermissionRequestDeny): Add "reason" parameter.

  • UIProcess/API/C/WKUserMediaPermissionRequest.h:
  • UIProcess/UserMediaPermissionRequestManagerProxy.cpp:

(WebKit::UserMediaPermissionRequestManagerProxy::invalidateRequests): Invalidate pending device requests.
(WebKit::UserMediaPermissionRequestManagerProxy::createRequest): Make private.
(WebKit::toWebCore): Map from UserMediaAccessDenialReason to MediaAccessDenialReason, cast to

uint64_t to pass to web process.

(WebKit::UserMediaPermissionRequestManagerProxy::denyRequest): Send to web process.
(WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasGranted): Ditto.
(WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame): Validate

constraints and make sure gUM is enabled before prompting user.

(WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame): New.
(WebKit::UserMediaPermissionRequestManagerProxy::didCompleteUserMediaPermissionCheck): Send

results of device enumeration to web process.

(WebKit::UserMediaPermissionRequestManagerProxy::didReceiveUserMediaPermissionDecision): Deleted.
(WebKit::UserMediaPermissionRequestManagerProxy::createUserMediaPermissionCheck): Deleted.

  • UIProcess/UserMediaPermissionRequestManagerProxy.h:
  • UIProcess/UserMediaPermissionRequestProxy.cpp:

(WebKit::UserMediaPermissionRequestProxy::allow):
(WebKit::UserMediaPermissionRequestProxy::deny): Take "reason" parameter.

  • UIProcess/UserMediaPermissionRequestProxy.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::requestUserMediaPermissionForFrame):
(WebKit::WebPageProxy::enumerateMediaDevicesForFrame):
(WebKit::WebPageProxy::checkUserMediaPermissionForFrame): Deleted.

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebPageProxy.messages.in:
  • WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:

(WebKit::UserMediaPermissionRequestManager::startUserMediaRequest): userMediaAccessDenied -> deny.

Pass the audio and video constraints to the UI process.

(WebKit::UserMediaPermissionRequestManager::userMediaAccessWasGranted):
(WebKit::UserMediaPermissionRequestManager::userMediaAccessWasDenied):
(WebKit::UserMediaPermissionRequestManager::enumerateMediaDevices): Send the enumeration request

to the UI process.

(WebKit::UserMediaPermissionRequestManager::cancelMediaDevicesEnumeration):
(WebKit::UserMediaPermissionRequestManager::didCompleteMediaDeviceEnumeration):
(WebKit::UserMediaPermissionRequestManager::didReceiveUserMediaPermissionDecision): Deleted.
(WebKit::UserMediaPermissionRequestManager::startUserMediaPermissionCheck): Deleted.
(WebKit::UserMediaPermissionRequestManager::cancelUserMediaPermissionCheck): Deleted.
(WebKit::UserMediaPermissionRequestManager::didCompleteUserMediaPermissionCheck): Deleted.

  • WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
  • WebProcess/WebCoreSupport/WebUserMediaClient.cpp:

(WebKit::WebUserMediaClient::enumerateMediaDevices): New.
(WebKit::WebUserMediaClient::cancelMediaDevicesEnumerationRequest): New.
(WebKit::WebUserMediaClient::checkUserMediaPermission): Deleted.
(WebKit::WebUserMediaClient::cancelUserMediaPermissionCheck): Deleted.

  • WebProcess/WebCoreSupport/WebUserMediaClient.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::userMediaAccessWasGranted): New.
(WebKit::WebPage::userMediaAccessWasDenied): Ditto.
(WebKit::WebPage::didCompleteMediaDeviceEnumeration):
(WebKit::WebPage::didReceiveUserMediaPermissionDecision): Deleted.
(WebKit::WebPage::didCompleteUserMediaPermissionCheck): Deleted.

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/WebPage.messages.in:

Tools:
[MediaStream] Resolve constraints and enumerate devices in the UI process
​https://bugs.webkit.org/show_bug.cgi?id=162147
<rdar://problem/28803569>

Reviewed by Darin Adler.

  • WebKitTestRunner/TestController.cpp:

(WTR::TestController::resetPreferencesToConsistentValues): Enable mock capture devices.
(WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible): Update for API changes.

LayoutTests:
[MediaStream] Resolve constraints and enumerate devices in the UI process
​https://bugs.webkit.org/show_bug.cgi?id=162147
<rdar://problem/28803569>

Reviewed by Darin Adler.

  • fast/mediastream/getusermedia-expected.txt: Updated.
  • fast/mediastream/getusermedia.html: Ditto.
  • fast/mediastream/mock-media-source-expected.txt: Ditto.
Location:
trunk
Files:
2 added
3 deleted
54 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r207461 r207463  
     12016-10-18  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Resolve constraints and enumerate devices in the UI process
     4        https://bugs.webkit.org/show_bug.cgi?id=162147
     5        <rdar://problem/28803569>
     6
     7        Reviewed by Darin Adler.
     8
     9        * fast/mediastream/getusermedia-expected.txt: Updated.
     10        * fast/mediastream/getusermedia.html: Ditto.
     11        * fast/mediastream/mock-media-source-expected.txt: Ditto.
     12
    1132016-10-18  Caitlin Potter  <caitp@igalia.com>
    214

  • trunk/LayoutTests/fast/mediastream/getusermedia-expected.txt

    r204516 r207463  
    2929PASS navigator.webkitGetUserMedia({audio:true, video:{width:{exact:11}}}, gotStreamInError, error1); did not throw exception.
    3030PASS Error callback called.
    31 FAIL errorArg.name should be OverConstrainedError. Was DataError.
     31FAIL errorArg.name should be OverconstrainedError. Was Error.
     32PASS errorArg.message is "Invalid constraint"
    3233PASS navigator.webkitGetUserMedia({audio:{volume:{exact:1}}, video:true}, gotStream5, 0); threw exception TypeError: Argument 3 ('errorCallback') to Navigator.webkitGetUserMedia must be a function.
    3334PASS navigator.webkitGetUserMedia({audio:{volume:{exact:1}}, video:true}, gotStream5, error); did not throw exception.

  • trunk/LayoutTests/fast/mediastream/getusermedia.html

    r204516 r207463  
    4545                errorArg = e;
    4646                testPassed('Error callback called.');
    47                 shouldBeEqualToString('errorArg.name', 'OverConstrainedError');
     47                shouldBeEqualToString('errorArg.name', 'OverconstrainedError');
     48                shouldBeEqualToString('errorArg.message', 'Invalid constraint');
    4849
    4950                shouldThrow("navigator.webkitGetUserMedia({audio:{volume:{exact:1}}, video:true}, gotStream5, 0);");

  • trunk/LayoutTests/fast/mediastream/mock-media-source-expected.txt

    r201080 r207463  
    1111*** Disable mock capture devices
    1212internals.setMockMediaCaptureDevicesEnabled(false)
    13 PASS mediaDevices.getUserMedia() failed with NotAllowedError
     13PASS mediaDevices.getUserMedia() failed with NotReadableError
    1414
    1515*** Enable mock capture devices

  • trunk/Source/WebCore/CMakeLists.txt

    r207438 r207463  
    886886    Modules/mediastream/MediaDeviceInfo.cpp
    887887    Modules/mediastream/MediaDevices.cpp
     888    Modules/mediastream/MediaDevicesEnumerationRequest.cpp
    888889    Modules/mediastream/MediaDevicesRequest.cpp
    889890    Modules/mediastream/MediaEndpointPeerConnection.cpp
    … …  
    917918    Modules/mediastream/SDPProcessor.cpp
    918919    Modules/mediastream/UserMediaController.cpp
    919     Modules/mediastream/UserMediaPermissionCheck.cpp
    920920    Modules/mediastream/UserMediaRequest.cpp
    921921

  • trunk/Source/WebCore/ChangeLog

    r207462 r207463  
     12016-10-18  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Resolve constraints and enumerate devices in the UI process
     4        https://bugs.webkit.org/show_bug.cgi?id=162147
     5        <rdar://problem/28803569>
     6
     7        Reviewed by Darin Adler.
     8
     9        Restructure gUM constraint validation and MediaDevices.enumerateDevices so all media device
     10        access happens in the UI process.
     11
     12        No new tests, updated results of existing tests.
     13
     14        * CMakeLists.txt: Add MediaDevicesEnumerationRequest.cpp, delete UserMediaPermissionCheck.cpp.
     15
     16        * Modules/mediastream/MediaConstraintsImpl.cpp:
     17        (WebCore::MediaConstraintsImpl::create): Only create from MediaConstraintsData.
     18        (WebCore::MediaConstraintsImpl::initialize): Deleted.
     19        * Modules/mediastream/MediaConstraintsImpl.h:
     20
     21        * Modules/mediastream/MediaDevicesEnumerationRequest.cpp: Added.
     22        (WebCore::MediaDevicesEnumerationRequest::create):
     23        (WebCore::MediaDevicesEnumerationRequest::MediaDevicesEnumerationRequest):
     24        (WebCore::MediaDevicesEnumerationRequest::~MediaDevicesEnumerationRequest):
     25        (WebCore::MediaDevicesEnumerationRequest::userMediaDocumentOrigin):
     26        (WebCore::MediaDevicesEnumerationRequest::topLevelDocumentOrigin):
     27        (WebCore::MediaDevicesEnumerationRequest::contextDestroyed):
     28        (WebCore::MediaDevicesEnumerationRequest::start):
     29        (WebCore::MediaDevicesEnumerationRequest::cancel):
     30        (WebCore::MediaDevicesEnumerationRequest::setDeviceInfo):
     31        (WebCore::MediaDevicesEnumerationRequest::finish):
     32        * Modules/mediastream/MediaDevicesEnumerationRequest.h: Added.
     33
     34        * Modules/mediastream/MediaDevicesRequest.cpp:
     35        (WebCore::MediaDevicesRequest::~MediaDevicesRequest): Clear the enumeration request.
     36        (WebCore::MediaDevicesRequest::contextDestroyed): Ditto.
     37        (WebCore::MediaDevicesRequest::start): Create and use a MediaDevicesEnumerationRequest.
     38        (WebCore::MediaDevicesRequest::didCompletePermissionCheck): Deleted.
     39        * Modules/mediastream/MediaDevicesRequest.h:
     40
     41        * Modules/mediastream/UserMediaClient.h:
     42        * Modules/mediastream/UserMediaController.h:
     43        (WebCore::UserMediaController::enumerateMediaDevices): New.
     44        (WebCore::UserMediaController::cancelMediaDevicesEnumerationRequest): New.
     45        (WebCore::UserMediaController::checkUserMediaPermission): Deleted.
     46        (WebCore::UserMediaController::cancelUserMediaPermissionCheck): Deleted.
     47
     48        * Modules/mediastream/UserMediaPermissionCheck.h: Deleted.
     49        * Modules/mediastream/UserMediaPermissionCheck.cpp: Deleted.
     50
     51        * Modules/mediastream/UserMediaRequest.cpp:
     52        (WebCore::UserMediaRequest::UserMediaRequest):
     53        (WebCore::UserMediaRequest::start):
     54        (WebCore::UserMediaRequest::allow):
     55        (WebCore::UserMediaRequest::deny):
     56        (WebCore::UserMediaRequest::constraintsValidated): Deleted.
     57        (WebCore::UserMediaRequest::userMediaAccessGranted): Deleted.
     58        (WebCore::UserMediaRequest::userMediaAccessDenied): Deleted.
     59        (WebCore::UserMediaRequest::constraintsInvalid): Deleted.
     60        (WebCore::UserMediaRequest::didCreateStream): Deleted.
     61        (WebCore::UserMediaRequest::failedToCreateStreamWithConstraintsError): Deleted.
     62        (WebCore::UserMediaRequest::failedToCreateStreamWithPermissionError): Deleted.
     63        * Modules/mediastream/UserMediaRequest.h:
     64
     65        * WebCore.xcodeproj/project.pbxproj: Add MediaDevicesEnumerationRequest.*.
     66
     67        * platform/mediastream/CaptureDevice.h:
     68        (WebCore::CaptureDevice::CaptureDevice):
     69        (WebCore::CaptureDevice::setPersistentId): Add setter for argument decoder.
     70        (WebCore::CaptureDevice::setLabel): Ditto.
     71        (WebCore::CaptureDevice::setGroupId): Ditto.
     72        (WebCore::CaptureDevice::setKind): Ditto.
     73
     74        * platform/mediastream/CaptureDeviceManager.h: Remove unnecessary include.
     75
     76        * platform/mediastream/MediaConstraints.h:
     77        (WebCore::MediaConstraint::encode): New.
     78        (WebCore::MediaConstraint::decode): Ditto.
     79        (WebCore::NumericConstraint::encode): Ditto.
     80        (WebCore::NumericConstraint::decode): Ditto.
     81
     82        * platform/mediastream/MediaStreamCreationClient.h: Deleted.
     83
     84        * platform/mediastream/RealtimeMediaSourceCenter.h: Use completion handlers instead of client interface.
     85
     86        * platform/mediastream/mac/AVCaptureDeviceManager.mm:
     87        (WebCore::AVCaptureDeviceManager::refreshCaptureDeviceList): Drive-by fix: don't initialize
     88        group id, we don't support it.
     89
     90        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
     91        (WebCore::RealtimeMediaSourceCenterMac::validateRequestConstraints): Update for interface change.
     92        (WebCore::RealtimeMediaSourceCenterMac::createMediaStream): Ditto.
     93        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.h:
     94
     95        * platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.cpp:
     96        (WebCore::RealtimeMediaSourceCenterOwr::validateRequestConstraints): Ditto.
     97        (WebCore::RealtimeMediaSourceCenterOwr::createMediaStream): Ditto.
     98        (WebCore::RealtimeMediaSourceCenterOwr::mediaSourcesAvailable): Ditto.
     99        * platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.h:
     100
     101        * platform/mock/MockRealtimeMediaSourceCenter.cpp:
     102        (WebCore::MockRealtimeMediaSourceCenter::validateRequestConstraints): Ditto.
     103        (WebCore::MockRealtimeMediaSourceCenter::createMediaStream): Ditto.
     104        * platform/mock/MockRealtimeMediaSourceCenter.h:
     105
    11062016-10-18  Zan Dobersek  <zdobersek@igalia.com>
    2107

  • trunk/Source/WebCore/Modules/mediastream/MediaConstraintsImpl.cpp

    r206445 r207463  
    11/*
    22 * Copyright (C) 2012 Google Inc. All rights reserved.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3637
    3738#include "ArrayValue.h"
    38 #include "Dictionary.h"
    3939#include "ExceptionCode.h"
    4040#include "Logging.h"
    4141
    4242namespace WebCore {
    43 
    44 Ref<MediaConstraintsImpl> MediaConstraintsImpl::create()
    45 {
    46     return adoptRef(*new MediaConstraintsImpl());
    47 }
    4843
    4944Ref<MediaConstraintsImpl> MediaConstraintsImpl::create(MediaTrackConstraintSetMap&& mandatoryConstraints, Vector<MediaTrackConstraintSetMap>&& advancedConstraints, bool isValid)
    … …  
    5247}
    5348
    54 MediaConstraintsImpl::~MediaConstraintsImpl()
     49Ref<MediaConstraintsImpl> MediaConstraintsImpl::create(const MediaConstraintsData& data)
    5550{
     51    return adoptRef(*new MediaConstraintsImpl(data));
    5652}
    5753

  • trunk/Source/WebCore/Modules/mediastream/MediaConstraintsImpl.h

    r206445 r207463  
    4040namespace WebCore {
    4141
    42 class ArrayValue;
    43 class Dictionary;
     42struct MediaConstraintsData {
     43    MediaTrackConstraintSetMap mandatoryConstraints;
     44    Vector<MediaTrackConstraintSetMap> advancedConstraints;
     45    bool isValid { false };
     46};
    4447
    4548class MediaConstraintsImpl final : public MediaConstraints {
    4649public:
    47     static Ref<MediaConstraintsImpl> create();
    4850    static Ref<MediaConstraintsImpl> create(MediaTrackConstraintSetMap&& mandatoryConstraints, Vector<MediaTrackConstraintSetMap>&& advancedConstraints, bool isValid);
     51    WEBCORE_EXPORT static Ref<MediaConstraintsImpl> create(const MediaConstraintsData&);
    4952
    50     virtual ~MediaConstraintsImpl();
     53    MediaConstraintsImpl() = default;
     54    virtual ~MediaConstraintsImpl() = default;
    5155
    52     const MediaTrackConstraintSetMap& mandatoryConstraints() const final { return m_mandatoryConstraints; }
    53     const Vector<MediaTrackConstraintSetMap>& advancedConstraints() const final { return m_advancedConstraints; }
    54     bool isValid() const final { return m_isValid; }
     56    const MediaTrackConstraintSetMap& mandatoryConstraints() const final { return m_data.mandatoryConstraints; }
     57    const Vector<MediaTrackConstraintSetMap>& advancedConstraints() const final { return m_data.advancedConstraints; }
     58    bool isValid() const final { return m_data.isValid; }
     59    const MediaConstraintsData& data() const { return m_data; }
    5560
    5661private:
    57     MediaConstraintsImpl() { }
    5862    MediaConstraintsImpl(MediaTrackConstraintSetMap&& mandatoryConstraints, Vector<MediaTrackConstraintSetMap>&& advancedConstraints, bool isValid)
    59         : m_mandatoryConstraints(WTFMove(mandatoryConstraints))
    60         , m_advancedConstraints(WTFMove(advancedConstraints))
    61         , m_isValid(isValid)
     63        : m_data({ WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), isValid })
     64    {
     65    }
     66    explicit MediaConstraintsImpl(const MediaConstraintsData& data)
     67        : m_data(data)
    6268    {
    6369    }
    6470
    65     MediaTrackConstraintSetMap m_mandatoryConstraints;
    66     Vector<MediaTrackConstraintSetMap> m_advancedConstraints;
    67     bool m_isValid;
     71    MediaConstraintsData m_data;
    6872};
    6973

  • trunk/Source/WebCore/Modules/mediastream/MediaDevicesRequest.cpp

    r205929 r207463  
    3535#include "Frame.h"
    3636#include "JSMediaDeviceInfo.h"
    37 #include "RealtimeMediaSourceCenter.h"
     37#include "MediaDevicesEnumerationRequest.h"
    3838#include "SecurityOrigin.h"
    3939#include "UserMediaController.h"
    … …  
    5656MediaDevicesRequest::~MediaDevicesRequest()
    5757{
    58     if (m_permissionCheck)
    59         m_permissionCheck->setClient(nullptr);
     58    if (m_enumerationRequest)
     59        m_enumerationRequest->cancel();
    6060}
    6161
    … …  
    7070void MediaDevicesRequest::contextDestroyed()
    7171{
     72    if (m_enumerationRequest) {
     73        m_enumerationRequest->cancel();
     74        m_enumerationRequest = nullptr;
     75    }
    7276    ContextDestructionObserver::contextDestroyed();
    73     if (m_permissionCheck) {
    74         m_permissionCheck->setClient(nullptr);
    75         m_permissionCheck = nullptr;
    76     }
    77     m_protector = nullptr;
    7877}
    7978
    8079void MediaDevicesRequest::start()
    8180{
    82     m_protector = this;
    83     m_permissionCheck = UserMediaPermissionCheck::create(*downcast<Document>(scriptExecutionContext()), *this);
    84     m_permissionCheck->start();
     81    RefPtr<MediaDevicesRequest> protectedThis = this;
     82    auto completion = [this, protectedThis = WTFMove(protectedThis)] (const Vector<CaptureDevice>& captureDevices, const String& deviceIdentifierHashSalt, bool originHasPersistentAccess) mutable {
     83
     84        m_enumerationRequest = nullptr;
     85
     86        if (!scriptExecutionContext())
     87            return;
     88
     89        Document& document = downcast<Document>(*scriptExecutionContext());
     90        UserMediaController* controller = UserMediaController::from(document.page());
     91        if (!controller)
     92            return;
     93
     94        m_idHashSalt = deviceIdentifierHashSalt;
     95
     96        Vector<RefPtr<MediaDeviceInfo>> devices;
     97        for (auto& deviceInfo : captureDevices) {
     98            auto label = emptyString();
     99            if (originHasPersistentAccess || document.hasHadActiveMediaStreamTrack())
     100                label = deviceInfo.label();
     101
     102            auto id = hashID(deviceInfo.persistentId());
     103            if (id.isEmpty())
     104                continue;
     105
     106            auto groupId = hashID(deviceInfo.groupId());
     107            auto deviceType = deviceInfo.kind() == CaptureDevice::SourceKind::Audio ? MediaDeviceInfo::Kind::Audioinput : MediaDeviceInfo::Kind::Videoinput;
     108            devices.append(MediaDeviceInfo::create(scriptExecutionContext(), label, id, groupId, deviceType));
     109        }
     110
     111        callOnMainThread([protectedThis = makeRef(*this), devices = WTFMove(devices)]() mutable {
     112            protectedThis->m_promise.resolve(devices);
     113        });
     114    };
     115
     116    m_enumerationRequest = MediaDevicesEnumerationRequest::create(*downcast<Document>(scriptExecutionContext()), WTFMove(completion));
     117    m_enumerationRequest->start();
    85118}
    86119
    … …  
    117150}
    118151
    119 void MediaDevicesRequest::didCompletePermissionCheck(const String& salt, bool canAccess)
    120 {
    121     m_permissionCheck->setClient(nullptr);
    122     m_permissionCheck = nullptr;
    123 
    124     m_idHashSalt = salt;
    125     m_havePersistentPermission = canAccess;
    126 
    127     if (!scriptExecutionContext()) {
    128         m_protector = nullptr;
    129         return;
    130     }
    131 
    132     Document& document = downcast<Document>(*scriptExecutionContext());
    133     UserMediaController* controller = UserMediaController::from(document.page());
    134     if (!controller) {
    135         m_protector = nullptr;
    136         return;
    137     }
    138 
    139     Vector<RefPtr<MediaDeviceInfo>> devices;
    140     auto captureDevices = RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
    141     for (auto& deviceInfo : captureDevices) {
    142         auto label = emptyString();
    143         if (m_havePersistentPermission || document.hasHadActiveMediaStreamTrack())
    144             label = deviceInfo.label();
    145 
    146         auto id = hashID(deviceInfo.persistentId());
    147         if (id.isEmpty())
    148             continue;
    149 
    150         auto groupId = hashID(deviceInfo.groupId());
    151         auto deviceType = deviceInfo.kind() == CaptureDevice::SourceKind::Audio ? MediaDeviceInfo::Kind::Audioinput : MediaDeviceInfo::Kind::Videoinput;
    152         devices.append(MediaDeviceInfo::create(scriptExecutionContext(), label, id, groupId, deviceType));
    153     }
    154 
    155     callOnMainThread([protectedThis = makeRef(*this), devices = WTFMove(devices)]() mutable {
    156         protectedThis->m_promise.resolve(devices);
    157     });
    158     m_protector = nullptr;
    159 }
    160 
    161152} // namespace WebCore
    162153

  • trunk/Source/WebCore/Modules/mediastream/MediaDevicesRequest.h

    r205929 r207463  
    3232#include "ActiveDOMObject.h"
    3333#include "MediaDevices.h"
    34 #include "MediaStreamCreationClient.h"
    35 #include "UserMediaPermissionCheck.h"
    3634#include <wtf/RefCounted.h>
    3735#include <wtf/text/WTFString.h>
    … …  
    4139class Document;
    4240class Frame;
     41class MediaDevicesEnumerationRequest;
    4342class SecurityOrigin;
    4443
    4544typedef int ExceptionCode;
    4645
    47 class MediaDevicesRequest : public RefCounted<MediaDevicesRequest>, public UserMediaPermissionCheckClient, public ContextDestructionObserver {
     46class MediaDevicesRequest : public RefCounted<MediaDevicesRequest>, private ContextDestructionObserver {
    4847public:
    4948    static RefPtr<MediaDevicesRequest> create(Document*, MediaDevices::EnumerateDevicesPromise&&, ExceptionCode&);
    … …  
    6160    void contextDestroyed() final;
    6261
    63     // UserMediaPermissionCheckClient
    64     void didCompletePermissionCheck(const String&, bool) final;
    65 
    6662    String hashID(const String&);
    6763
    6864    MediaDevices::EnumerateDevicesPromise m_promise;
    6965    RefPtr<MediaDevicesRequest> m_protector;
    70     RefPtr<UserMediaPermissionCheck> m_permissionCheck;
     66    RefPtr<MediaDevicesEnumerationRequest> m_enumerationRequest;
    7167
    7268    String m_idHashSalt;
    73     bool m_havePersistentPermission { false };
    7469};
    7570

  • trunk/Source/WebCore/Modules/mediastream/UserMediaClient.h

    r204239 r207463  
    11/*
    22 * Copyright (C) 2011 Ericsson AB. All rights reserved.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3435#if ENABLE(MEDIA_STREAM)
    3536
     37#include <functional>
     38#include <wtf/Vector.h>
     39#include <wtf/text/WTFString.h>
     40
    3641namespace WebCore {
    3742
     43class MediaDevicesEnumerationRequest;
     44class MediaConstraints;
    3845class Page;
    39 class UserMediaPermissionCheck;
     46class RealtimeMediaSource;
    4047class UserMediaRequest;
    4148
    … …  
    4754    virtual void cancelUserMediaAccessRequest(UserMediaRequest&) = 0;
    4855
    49     virtual void checkUserMediaPermission(UserMediaPermissionCheck&) = 0;
    50     virtual void cancelUserMediaPermissionCheck(UserMediaPermissionCheck&) = 0;
     56    virtual void enumerateMediaDevices(MediaDevicesEnumerationRequest&) = 0;
     57    virtual void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&) = 0;
    5158
    5259protected:

  • trunk/Source/WebCore/Modules/mediastream/UserMediaController.h

    r193944 r207463  
    11/*
    22 * Copyright (C) 2012 Google Inc. All rights reserved.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 * Redistribution and use in source and binary forms, with or without
    … …  
    3031#include "Page.h"
    3132#include "UserMediaClient.h"
    32 #include "UserMediaPermissionCheck.h"
    3333#include "UserMediaRequest.h"
    3434
    … …  
    4545    void cancelUserMediaAccessRequest(UserMediaRequest&);
    4646
    47     void checkUserMediaPermission(UserMediaPermissionCheck&);
    48     void cancelUserMediaPermissionCheck(UserMediaPermissionCheck&);
     47    void enumerateMediaDevices(MediaDevicesEnumerationRequest&);
     48    void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&);
    4949
    5050    WEBCORE_EXPORT static const char* supplementName();
    … …  
    6565}
    6666
    67 inline void UserMediaController::checkUserMediaPermission(UserMediaPermissionCheck& request)
     67inline void UserMediaController::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
    6868{
    69     m_client->checkUserMediaPermission(request);
     69    m_client->enumerateMediaDevices(request);
    7070}
    7171
    72 inline void UserMediaController::cancelUserMediaPermissionCheck(UserMediaPermissionCheck& request)
     72inline void UserMediaController::cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest& request)
    7373{
    74     m_client->cancelUserMediaPermissionCheck(request);
     74    m_client->cancelMediaDevicesEnumerationRequest(request);
    7575}
    7676

  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.cpp

    r204516 r207463  
    3838#include "UserMediaRequest.h"
    3939
    40 #include "Dictionary.h"
    4140#include "Document.h"
    4241#include "ExceptionCode.h"
    4342#include "Frame.h"
    44 #include "JSMediaDeviceInfo.h"
    4543#include "JSMediaStream.h"
     44#include "JSOverconstrainedError.h"
    4645#include "MainFrame.h"
    47 #include "MediaConstraintsImpl.h"
    4846#include "MediaStream.h"
    4947#include "MediaStreamPrivate.h"
     48#include "OverconstrainedError.h"
    5049#include "RealtimeMediaSourceCenter.h"
    5150#include "SecurityOrigin.h"
    … …  
    7271}
    7372
    74 UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, Ref<MediaConstraints>&& audioConstraints, Ref<MediaConstraints>&& videoConstraints, MediaDevices::Promise&& promise)
     73UserMediaRequest::UserMediaRequest(ScriptExecutionContext* context, UserMediaController* controller, Ref<MediaConstraintsImpl>&& audioConstraints, Ref<MediaConstraintsImpl>&& videoConstraints, MediaDevices::Promise&& promise)
    7574    : ContextDestructionObserver(context)
    7675    , m_audioConstraints(WTFMove(audioConstraints))
    … …  
    103102void UserMediaRequest::start()
    104103{
    105     // 1 - make sure the system is capable of supporting the audio and video constraints. We don't want to ask for
    106     // user permission if the constraints can not be suported.
    107     RealtimeMediaSourceCenter::singleton().validateRequestConstraints(this, m_audioConstraints, m_videoConstraints);
     104    if (m_controller)
     105        m_controller->requestUserMediaAccess(*this);
     106    else
     107        deny(MediaAccessDenialReason::OtherFailure, emptyString());
    108108}
    109109
    110 void UserMediaRequest::constraintsValidated(const Vector<RefPtr<RealtimeMediaSource>>& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>& videoTracks)
     110void UserMediaRequest::allow(const String& audioDeviceUID, const String& videoDeviceUID)
    111111{
    112     for (auto& audioTrack : audioTracks)
    113         m_audioDeviceUIDs.append(audioTrack->persistentID());
    114     for (auto& videoTrack : videoTracks)
    115         m_videoDeviceUIDs.append(videoTrack->persistentID());
     112    m_allowedAudioDeviceUID = audioDeviceUID;
     113    m_allowedVideoDeviceUID = videoDeviceUID;
    116114
    117     callOnMainThread([protectedThis = makeRef(*this)]() mutable {
    118         // 2 - The constraints are valid, ask the user for access to media.
    119         if (UserMediaController* controller = protectedThis->m_controller)
    120             controller->requestUserMediaAccess(protectedThis.get());
    121     });
     115    RefPtr<UserMediaRequest> protectedThis = this;
     116    RealtimeMediaSourceCenter::NewMediaStreamHandler callback = [this, protectedThis = WTFMove(protectedThis)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
     117        if (!m_scriptExecutionContext)
     118            return;
     119
     120        if (!privateStream) {
     121            deny(MediaAccessDenialReason::HardwareError, emptyString());
     122            return;
     123        }
     124
     125        auto stream = MediaStream::create(*m_scriptExecutionContext, WTFMove(privateStream));
     126        if (stream->getTracks().isEmpty()) {
     127            deny(MediaAccessDenialReason::HardwareError, emptyString());
     128            return;
     129        }
     130
     131        for (auto& track : stream->getAudioTracks()) {
     132            track->applyConstraints(m_audioConstraints);
     133            track->source().startProducingData();
     134        }
     135
     136        for (auto& track : stream->getVideoTracks()) {
     137            track->applyConstraints(m_videoConstraints);
     138            track->source().startProducingData();
     139        }
     140       
     141        m_promise.resolve(stream);
     142    };
     143
     144    RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), m_allowedAudioDeviceUID, m_allowedVideoDeviceUID);
    122145}
    123146
    124 void UserMediaRequest::userMediaAccessGranted(const String& audioDeviceUID, const String& videoDeviceUID)
    125 {
    126     m_allowedVideoDeviceUID = videoDeviceUID;
    127     m_audioDeviceUIDAllowed = audioDeviceUID;
    128 
    129     callOnMainThread([protectedThis = makeRef(*this), audioDeviceUID, videoDeviceUID]() mutable {
    130         // 3 - the user granted access, ask platform to create the media stream descriptors.
    131         RealtimeMediaSourceCenter::singleton().createMediaStream(protectedThis.ptr(), audioDeviceUID, videoDeviceUID);
    132     });
    133 }
    134 
    135 void UserMediaRequest::userMediaAccessDenied()
    136 {
    137     failedToCreateStreamWithPermissionError();
    138 }
    139 
    140 void UserMediaRequest::constraintsInvalid(const String& constraintName)
    141 {
    142     failedToCreateStreamWithConstraintsError(constraintName);
    143 }
    144 
    145 void UserMediaRequest::didCreateStream(RefPtr<MediaStreamPrivate>&& privateStream)
     147void UserMediaRequest::deny(MediaAccessDenialReason reason, const String& invalidConstraint)
    146148{
    147149    if (!m_scriptExecutionContext)
    148150        return;
    149151
    150     // 4 - Create the MediaStream and pass it to the success callback.
    151     Ref<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, WTFMove(privateStream));
    152 
    153     for (auto& track : stream->getAudioTracks()) {
    154         track->applyConstraints(m_audioConstraints);
    155         track->source().startProducingData();
     152    switch (reason) {
     153    case MediaAccessDenialReason::NoConstraints:
     154        m_promise.reject(TypeError);
     155        break;
     156    case MediaAccessDenialReason::UserMediaDisabled:
     157        m_promise.reject(SECURITY_ERR);
     158        break;
     159    case MediaAccessDenialReason::NoCaptureDevices:
     160        m_promise.reject(NOT_FOUND_ERR);
     161        break;
     162    case MediaAccessDenialReason::InvalidConstraint:
     163        m_promise.reject(OverconstrainedError::create(invalidConstraint, ASCIILiteral("Invalid constraint")).get());
     164        break;
     165    case MediaAccessDenialReason::HardwareError:
     166        m_promise.reject(NotReadableError);
     167        break;
     168    case MediaAccessDenialReason::OtherFailure:
     169        m_promise.reject(ABORT_ERR);
     170        break;
     171    case MediaAccessDenialReason::PermissionDenied:
     172        m_promise.reject(NotAllowedError);
     173        break;
    156174    }
    157 
    158     for (auto& track : stream->getVideoTracks()) {
    159         track->applyConstraints(m_videoConstraints);
    160         track->source().startProducingData();
    161     }
    162 
    163     m_promise.resolve(stream);
    164 }
    165 
    166 void UserMediaRequest::failedToCreateStreamWithConstraintsError(const String& constraintName)
    167 {
    168     UNUSED_PARAM(constraintName);
    169     ASSERT(!constraintName.isEmpty());
    170     if (!m_scriptExecutionContext)
    171         return;
    172 
    173     // FIXME: The promise should be rejected with an OverconstrainedError, https://bugs.webkit.org/show_bug.cgi?id=157839.
    174     m_promise.reject(DataError);
    175 }
    176 
    177 void UserMediaRequest::failedToCreateStreamWithPermissionError()
    178 {
    179     if (!m_scriptExecutionContext)
    180         return;
    181 
    182     m_promise.reject(NotAllowedError);
    183175}
    184176

  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.h

    r204516 r207463  
    3737
    3838#include "ActiveDOMObject.h"
     39#include "Document.h"
     40#include "MediaConstraintsImpl.h"
    3941#include "MediaDevices.h"
    40 #include "MediaStreamCreationClient.h"
    4142#include <wtf/RefCounted.h>
    4243#include <wtf/text/WTFString.h>
    … …  
    5455typedef int ExceptionCode;
    5556
    56 class UserMediaRequest : public MediaStreamCreationClient, public ContextDestructionObserver {
     57class UserMediaRequest : public RefCounted<UserMediaRequest>, private ContextDestructionObserver {
    5758public:
    5859    static void start(Document*, Ref<MediaConstraintsImpl>&& audioConstraints, Ref<MediaConstraintsImpl>&& videoConstraints, MediaDevices::Promise&&, ExceptionCode&);
    … …  
    6061    ~UserMediaRequest();
    6162
    62     WEBCORE_EXPORT SecurityOrigin* userMediaDocumentOrigin() const;
    63     WEBCORE_EXPORT SecurityOrigin* topLevelDocumentOrigin() const;
     63    void start();
    6464
    65     void start();
    66     WEBCORE_EXPORT void userMediaAccessGranted(const String& audioDeviceUID, const String& videoDeviceUID);
    67     WEBCORE_EXPORT void userMediaAccessDenied();
     65    WEBCORE_EXPORT void setAllowedMediaDeviceUIDs(const String& audioDeviceUID, const String& videoDeviceUID);
     66    WEBCORE_EXPORT void allow(const String& audioDeviceUID, const String& videoDeviceUID);
     67
     68    enum MediaAccessDenialReason { NoConstraints, UserMediaDisabled, NoCaptureDevices, InvalidConstraint, HardwareError, PermissionDenied, OtherFailure };
     69    WEBCORE_EXPORT void deny(MediaAccessDenialReason, const String& invalidConstraint);
    6870
    6971    const Vector<String>& audioDeviceUIDs() const { return m_audioDeviceUIDs; }
    7072    const Vector<String>& videoDeviceUIDs() const { return m_videoDeviceUIDs; }
    7173
    72     const String& allowedAudioDeviceUID() const { return m_audioDeviceUIDAllowed; }
     74    const MediaConstraintsImpl& audioConstraints() const { return m_audioConstraints; }
     75    const MediaConstraintsImpl& videoConstraints() const { return m_videoConstraints; }
     76
     77    const String& allowedAudioDeviceUID() const { return m_allowedAudioDeviceUID; }
    7378    const String& allowedVideoDeviceUID() const { return m_allowedVideoDeviceUID; }
    7479
     80    WEBCORE_EXPORT SecurityOrigin* userMediaDocumentOrigin() const;
     81    WEBCORE_EXPORT SecurityOrigin* topLevelDocumentOrigin() const;
     82    WEBCORE_EXPORT Document* document() const { return downcast<Document>(scriptExecutionContext()); }
     83
    7584private:
    76     UserMediaRequest(ScriptExecutionContext*, UserMediaController*, Ref<MediaConstraints>&& audioConstraints, Ref<MediaConstraints>&& videoConstraints, MediaDevices::Promise&&);
    77 
    78     // MediaStreamCreationClient
    79     void constraintsValidated(const Vector<RefPtr<RealtimeMediaSource>>& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>& videoTracks) final;
    80     void constraintsInvalid(const String& constraintName) final;
    81     void didCreateStream(RefPtr<MediaStreamPrivate>&&) final;
    82     void failedToCreateStreamWithConstraintsError(const String& constraintName) final;
    83     void failedToCreateStreamWithPermissionError() final;
     85    UserMediaRequest(ScriptExecutionContext*, UserMediaController*, Ref<MediaConstraintsImpl>&& audioConstraints, Ref<MediaConstraintsImpl>&& videoConstraints, MediaDevices::Promise&&);
    8486
    8587    // ContextDestructionObserver
    8688    void contextDestroyed() final;
    8789   
    88     Ref<MediaConstraints> m_audioConstraints;
    89     Ref<MediaConstraints> m_videoConstraints;
     90    Ref<MediaConstraintsImpl> m_audioConstraints;
     91    Ref<MediaConstraintsImpl> m_videoConstraints;
    9092
    9193    Vector<String> m_videoDeviceUIDs;
    … …  
    9395
    9496    String m_allowedVideoDeviceUID;
    95     String m_audioDeviceUIDAllowed;
     97    String m_allowedAudioDeviceUID;
    9698
    9799    UserMediaController* m_controller;
    98100    MediaDevices::Promise m_promise;
     101    RefPtr<UserMediaRequest> m_protector;
    99102};
    100103

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r207462 r207463  
    137137                07277E5417D018CC0015534D /* JSMediaStreamTrackEvent.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07277E4817D018CC0015534D /* JSMediaStreamTrackEvent.cpp */; };
    138138                07277E5517D018CC0015534D /* JSMediaStreamTrackEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 07277E4917D018CC0015534D /* JSMediaStreamTrackEvent.h */; };
    139                 07297FA71C1881C5003F0735 /* UserMediaPermissionCheck.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07297FA51C1881C5003F0735 /* UserMediaPermissionCheck.cpp */; };
    140                 07297FA81C1881C5003F0735 /* UserMediaPermissionCheck.h in Headers */ = {isa = PBXBuildFile; fileRef = 07297FA61C1881C5003F0735 /* UserMediaPermissionCheck.h */; settings = {ATTRIBUTES = (Private, ); }; };
    141139                072A70401D6E8F6200DF0AFC /* OverconstrainedErrorEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = 072A703E1D6E8F6200DF0AFC /* OverconstrainedErrorEvent.h */; };
    142140                072A70431D7396B300DF0AFC /* JSMediaDevicesCustom.h in Headers */ = {isa = PBXBuildFile; fileRef = 072A70421D7396B200DF0AFC /* JSMediaDevicesCustom.h */; };
    … …  
    236234                078E093017D14D1C00420AA1 /* UserMediaRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221B9117CEC32700848E51 /* UserMediaRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    237235                078E093717D16B2C00420AA1 /* MediaStreamPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221B9D17CF0AD400848E51 /* MediaStreamPrivate.h */; };
    238                 078E093917D16B2C00420AA1 /* MediaStreamCreationClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221BA017CF0AD400848E51 /* MediaStreamCreationClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    239236                078E093A17D16E1C00420AA1 /* MediaConstraints.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221B9917CF0AD400848E51 /* MediaConstraints.h */; settings = {ATTRIBUTES = (Private, ); }; };
    240237                078E093C17D16E1C00420AA1 /* RTCDataChannelHandler.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221BA217CF0AD400848E51 /* RTCDataChannelHandler.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    291288                07AB996F18DA3C740018771E /* RTCConfigurationPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AB996D18DA3C740018771E /* RTCConfigurationPrivate.h */; };
    292289                07AB997018DA3C740018771E /* RTCIceServerPrivate.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AB996E18DA3C740018771E /* RTCIceServerPrivate.h */; };
     290                07ABEF6C1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07ABEF6B1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp */; };
     291                07ABEF6E1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    293292                07AC47011952102100EE9723 /* ISOVTTCue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07AC46FF1952102100EE9723 /* ISOVTTCue.cpp */; };
    294293                07AC47021952102100EE9723 /* ISOVTTCue.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AC47001952102100EE9723 /* ISOVTTCue.h */; };
    … …  
    300299                07B5A2DC1464320A00A81ECE /* JSTextTrackList.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B5A2DA1464320A00A81ECE /* JSTextTrackList.h */; };
    301300                07B5A30D14687D7100A81ECE /* JSTextTrackListCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07B5A30C14687D7100A81ECE /* JSTextTrackListCustom.cpp */; };
    302                 07B7116D1D899E63009F0FFB /* CaptureDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B7116A1D899E63009F0FFB /* CaptureDevice.h */; };
     301                07B7116D1D899E63009F0FFB /* CaptureDevice.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B7116A1D899E63009F0FFB /* CaptureDevice.h */; settings = {ATTRIBUTES = (Private, ); }; };
    303302                07B7116E1D899E63009F0FFB /* CaptureDeviceManager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07B7116B1D899E63009F0FFB /* CaptureDeviceManager.cpp */; };
    304303                07B7116F1D899E63009F0FFB /* CaptureDeviceManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 07B7116C1D899E63009F0FFB /* CaptureDeviceManager.h */; };
    … …  
    18891888                4A0DA2FF129B241900AB61E1 /* FormAssociatedElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A0DA2FD129B241900AB61E1 /* FormAssociatedElement.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18901889                4A0FFA9D1AAF5E750062803B /* MockRealtimeMediaSourceCenter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A0FFA9B1AAF5E6C0062803B /* MockRealtimeMediaSourceCenter.cpp */; };
    1891                 4A0FFA9E1AAF5E7E0062803B /* MockRealtimeMediaSourceCenter.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A0FFA9C1AAF5E6C0062803B /* MockRealtimeMediaSourceCenter.h */; };
     1890                4A0FFA9E1AAF5E7E0062803B /* MockRealtimeMediaSourceCenter.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A0FFA9C1AAF5E6C0062803B /* MockRealtimeMediaSourceCenter.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18921891                4A0FFAA11AAF5EA20062803B /* RealtimeMediaSourceCenter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4A0FFA9F1AAF5EA20062803B /* RealtimeMediaSourceCenter.cpp */; };
    18931892                4A0FFAA21AAF5EA20062803B /* RealtimeMediaSourceCenter.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A0FFAA01AAF5EA20062803B /* RealtimeMediaSourceCenter.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    69916990                07221B9917CF0AD400848E51 /* MediaConstraints.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaConstraints.h; sourceTree = "<group>"; };
    69926991                07221B9D17CF0AD400848E51 /* MediaStreamPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamPrivate.h; sourceTree = "<group>"; };
    6993                 07221BA017CF0AD400848E51 /* MediaStreamCreationClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamCreationClient.h; sourceTree = "<group>"; };
    69946992                07221BA217CF0AD400848E51 /* RTCDataChannelHandler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCDataChannelHandler.h; sourceTree = "<group>"; };
    69956993                07221BA317CF0AD400848E51 /* RTCDataChannelHandlerClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCDataChannelHandlerClient.h; sourceTree = "<group>"; };
    … …  
    70187016                07277E4917D018CC0015534D /* JSMediaStreamTrackEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSMediaStreamTrackEvent.h; sourceTree = "<group>"; };
    70197017                072847E216EBC5B00043CFA4 /* PlatformTextTrack.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = PlatformTextTrack.h; sourceTree = "<group>"; };
    7020                 07297FA51C1881C5003F0735 /* UserMediaPermissionCheck.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = UserMediaPermissionCheck.cpp; sourceTree = "<group>"; };
    7021                 07297FA61C1881C5003F0735 /* UserMediaPermissionCheck.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UserMediaPermissionCheck.h; sourceTree = "<group>"; };
    70227018                072A703E1D6E8F6200DF0AFC /* OverconstrainedErrorEvent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OverconstrainedErrorEvent.h; sourceTree = "<group>"; };
    70237019                072A703F1D6E8F6200DF0AFC /* OverconstrainedErrorEvent.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = OverconstrainedErrorEvent.idl; sourceTree = "<group>"; };
    … …  
    71287124                07AB996D18DA3C740018771E /* RTCConfigurationPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCConfigurationPrivate.h; sourceTree = "<group>"; };
    71297125                07AB996E18DA3C740018771E /* RTCIceServerPrivate.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCIceServerPrivate.h; sourceTree = "<group>"; };
     7126                07ABEF6B1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaDevicesEnumerationRequest.cpp; sourceTree = "<group>"; };
     7127                07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaDevicesEnumerationRequest.h; sourceTree = "<group>"; };
    71307128                07AC46FF1952102100EE9723 /* ISOVTTCue.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ISOVTTCue.cpp; sourceTree = "<group>"; };
    71317129                07AC47001952102100EE9723 /* ISOVTTCue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ISOVTTCue.h; sourceTree = "<group>"; };
    … …  
    1469514693                                5EA725CE1ACABCD900EAD17B /* MediaDevices.h */,
    1469614694                                5EA725CF1ACABCD900EAD17B /* MediaDevices.idl */,
     14695                                07ABEF6B1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp */,
     14696                                07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */,
    1469714697                                07394EC71BAB2CCD00BE99CD /* MediaDevicesRequest.cpp */,
    1469814698                                07394EC91BAB2CD700BE99CD /* MediaDevicesRequest.h */,
    … …  
    1479714797                                07221B8E17CEC32700848E51 /* UserMediaController.cpp */,
    1479814798                                07221B8F17CEC32700848E51 /* UserMediaController.h */,
    14799                                 07297FA51C1881C5003F0735 /* UserMediaPermissionCheck.cpp */,
    14800                                 07297FA61C1881C5003F0735 /* UserMediaPermissionCheck.h */,
    1480114799                                07221B9017CEC32700848E51 /* UserMediaRequest.cpp */,
    1480214800                                07221B9117CEC32700848E51 /* UserMediaRequest.h */,
    … …  
    1482314821                                5EBB892F1C7777D000C65D41 /* MediaPayload.h */,
    1482414822                                070F549717F12F6B00169E04 /* MediaStreamConstraintsValidationClient.h */,
    14825                                 07221BA017CF0AD400848E51 /* MediaStreamCreationClient.h */,
    1482614823                                0711588F17DF633700EDFE2B /* MediaStreamPrivate.cpp */,
    1482714824                                07221B9D17CF0AD400848E51 /* MediaStreamPrivate.h */,
    … …  
    2550225499                                2E37E00612DBC5A400A6B233 /* JSDOMURL.h in Headers */,
    2550325500                                BC6932740D7E293900AE44D1 /* JSDOMWindowBase.h in Headers */,
     25501                                07ABEF6E1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h in Headers */,
    2550425502                                652FBBBC0DE27CB60001D386 /* JSDOMWindowCustom.h in Headers */,
    2550525503                                460CBF361D4BCD0E0092E88E /* JSDOMWindowProperties.h in Headers */,
    … …  
    2617026168                                FD671A78159BB07000197559 /* MediaStreamAudioSourceNode.h in Headers */,
    2617126169                                070F549817F12F6B00169E04 /* MediaStreamConstraintsValidationClient.h in Headers */,
    26172                                 078E093917D16B2C00420AA1 /* MediaStreamCreationClient.h in Headers */,
    2617326170                                078E091617D14D1C00420AA1 /* MediaStreamEvent.h in Headers */,
    2617426171                                078E093717D16B2C00420AA1 /* MediaStreamPrivate.h in Headers */,
    … …  
    2741727414                                078E092E17D14D1C00420AA1 /* UserMediaClient.h in Headers */,
    2741827415                                078E092F17D14D1C00420AA1 /* UserMediaController.h in Headers */,
    27419                                 07297FA81C1881C5003F0735 /* UserMediaPermissionCheck.h in Headers */,
    2742027416                                078E093017D14D1C00420AA1 /* UserMediaRequest.h in Headers */,
    2742127417                                7C3B79721908757B00B47A2D /* UserMessageHandler.h in Headers */,
    … …  
    2986829864                                159AE82B1B3A402F0037478B /* MediaDeviceInfo.cpp in Sources */,
    2986929865                                5EA725D21ACABD4700EAD17B /* MediaDevices.cpp in Sources */,
     29866                                07ABEF6C1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp in Sources */,
    2987029867                                07394EC81BAB2CCD00BE99CD /* MediaDevicesRequest.cpp in Sources */,
    2987129868                                97205AB71239291000B17380 /* MediaDocument.cpp in Sources */,
    … …  
    3088130878                                9920398218B95BC600B39AF9 /* UserInputBridge.cpp in Sources */,
    3088230879                                078E091217D14CEE00420AA1 /* UserMediaController.cpp in Sources */,
    30883                                 07297FA71C1881C5003F0735 /* UserMediaPermissionCheck.cpp in Sources */,
    3088430880                                078E091317D14CEE00420AA1 /* UserMediaRequest.cpp in Sources */,
    3088530881                                7C3B79711908757B00B47A2D /* UserMessageHandler.cpp in Sources */,

  • trunk/Source/WebCore/platform/mediastream/CaptureDevice.h

    r205929 r207463  
    2828#if ENABLE(MEDIA_STREAM)
    2929
    30 #include <RealtimeMediaSource.h>
    3130#include <wtf/text/WTFString.h>
    3231
    … …  
    3534class CaptureDevice {
    3635public:
    37     enum class SourceKind { Audio, Video };
     36    enum class SourceKind { Unknown, Audio, Video };
    3837
    3938    CaptureDevice(const String& persistentId, SourceKind kind, const String& label, const String& groupId)
    … …  
    4544    }
    4645
     46    CaptureDevice() = default;
     47
    4748    const String& persistentId() const { return m_persistentId; }
     49    void setPersistentId(const String& id) { m_persistentId = id; }
     50
    4851    const String& label() const { return m_label; }
     52    void setLabel(const String& label) { m_label = label; }
     53
    4954    const String& groupId() const { return m_groupId; }
     55    void setGroupId(const String& id) { m_groupId = id; }
     56
    5057    SourceKind kind() const { return m_kind; }
     58    void setKind(SourceKind kind) { m_kind = kind; }
    5159
    5260private:
    5361    String m_persistentId;
    54     SourceKind m_kind;
     62    SourceKind m_kind { SourceKind::Unknown };
    5563    String m_label;
    5664    String m_groupId;

  • trunk/Source/WebCore/platform/mediastream/CaptureDeviceManager.h

    r205929 r207463  
    2929
    3030#include "CaptureDevice.h"
     31#include "RealtimeMediaSource.h"
    3132
    3233namespace WebCore {

  • trunk/Source/WebCore/platform/mediastream/MediaConstraints.cpp

    r206445 r207463  
    3939namespace WebCore {
    4040
    41 bool BooleanConstraint::getExact(bool& exact) const
    42 {
    43     if (!m_exact)
    44         return false;
    45    
    46     exact = m_exact.value();
    47     return true;
    48 }
    49 
    50 bool BooleanConstraint::getIdeal(bool& ideal) const
    51 {
    52     if (!m_ideal)
    53         return false;
    54    
    55     ideal = m_ideal.value();
    56     return true;
    57 }
    58 
    59 void StringConstraint::setExact(const String& value)
    60 {
    61     m_exact.clear();
    62     m_exact.append(value);
    63 }
    64 
    65 void StringConstraint::appendExact(const String& value)
    66 {
    67     m_exact.clear();
    68     m_exact.append(value);
    69 }
    70 
    71 void StringConstraint::setIdeal(const String& value)
    72 {
    73     m_ideal.clear();
    74     m_ideal.append(value);
    75 }
    76 
    77 void StringConstraint::appendIdeal(const String& value)
    78 {
    79     m_ideal.append(value);
    80 }
    81 
    82 bool StringConstraint::getExact(Vector<String>& exact) const
    83 {
    84     if (!m_exact.isEmpty())
    85         return false;
    86 
    87     exact = m_exact;
    88     return true;
    89 }
    90 
    91 bool StringConstraint::getIdeal(Vector<String>& ideal) const
    92 {
    93     if (!m_ideal.isEmpty())
    94         return false;
    95 
    96     ideal = m_ideal;
    97     return true;
    98 }
    99 
    10041const String& StringConstraint::find(std::function<bool(const String&)> filter) const
    10142{
    … …  
    15495    const StringConstraint& typedOther = downcast<StringConstraint>(other);
    15596
    156     if (other.isEmpty())
     97    if (typedOther.isEmpty())
    15798        return;
    15899
    … …  
    230171
    231172    m_variants.append(ConstraintHolder::create(constraint));
    232 
    233173}
    234174
    235175void MediaTrackConstraintSetMap::forEach(std::function<void(const MediaConstraint&)> callback) const
    236176{
    237     if (m_width && !m_width->isEmpty())
    238         callback(*m_width);
    239     if (m_height && !m_height->isEmpty())
    240         callback(*m_height);
    241     if (m_sampleRate && !m_sampleRate->isEmpty())
    242         callback(*m_sampleRate);
    243     if (m_sampleSize && !m_sampleSize->isEmpty())
    244         callback(*m_sampleSize);
    245 
    246     if (m_aspectRatio && !m_aspectRatio->isEmpty())
    247         callback(*m_aspectRatio);
    248     if (m_frameRate && !m_frameRate->isEmpty())
    249         callback(*m_frameRate);
    250     if (m_volume && !m_volume->isEmpty())
    251         callback(*m_volume);
    252 
    253     if (m_echoCancellation && !m_echoCancellation->isEmpty())
    254         callback(*m_echoCancellation);
    255 
    256     if (m_facingMode && !m_facingMode->isEmpty())
    257         callback(*m_facingMode);
    258     if (m_deviceId && !m_deviceId->isEmpty())
    259         callback(*m_deviceId);
    260     if (m_groupId && !m_groupId->isEmpty())
    261         callback(*m_groupId);
     177    filter([callback] (const MediaConstraint& constraint) mutable {
     178        callback(constraint);
     179        return false;
     180    });
    262181}
    263182
    … …  
    289208    if (m_groupId && !m_groupId->isEmpty() && callback(*m_groupId))
    290209        return;
    291 }
    292 
    293 bool MediaTrackConstraintSetMap::isEmpty() const
    294 {
    295     return (!m_width || m_width->isEmpty())
    296         && (!m_height || m_height->isEmpty())
    297         && (!m_sampleRate || m_sampleRate->isEmpty())
    298         && (!m_sampleSize || m_sampleSize->isEmpty())
    299         && (!m_aspectRatio || m_aspectRatio->isEmpty())
    300         && (!m_frameRate || m_frameRate->isEmpty())
    301         && (!m_volume || m_volume->isEmpty())
    302         && (!m_echoCancellation || m_echoCancellation->isEmpty())
    303         && (!m_facingMode || m_facingMode->isEmpty())
    304         && (!m_deviceId || m_deviceId->isEmpty())
    305         && (!m_groupId || m_groupId->isEmpty());
    306210}
    307211
    … …  
    412316}
    413317
     318size_t MediaTrackConstraintSetMap::size() const
     319{
     320    size_t count = 0;
     321    forEach([&count] (const MediaConstraint&) mutable {
     322        ++count;
     323    });
     324
     325    return count;
     326}
     327
     328bool MediaTrackConstraintSetMap::isEmpty() const
     329{
     330    return !size();
     331}
     332
    414333}
    415334

  • trunk/Source/WebCore/platform/mediastream/MediaConstraints.h

    r206445 r207463  
    4949    enum class DataType { None, Integer, Double, Boolean, String };
    5050
    51     virtual ~MediaConstraint() { };
    52 
    53     virtual bool isEmpty() const { return true; }
    54     virtual bool isMandatory() const { return false; }
    55     virtual void merge(const MediaConstraint&) { }
    56 
    5751    bool isInt() const { return m_dataType == DataType::Integer; }
    5852    bool isDouble() const { return m_dataType == DataType::Double; }
    … …  
    6458    const String& name() const { return m_name; }
    6559
     60    template <class Encoder> void encode(Encoder& encoder) const
     61    {
     62        encoder.encodeEnum(m_constraintType);
     63        encoder << m_name;
     64        encoder.encodeEnum(m_dataType);
     65    }
     66
     67    template <class Decoder> static bool decode(Decoder& decoder, MediaConstraint& constraint)
     68    {
     69        if (!decoder.decodeEnum(constraint.m_constraintType))
     70            return false;
     71
     72        if (!decoder.decode(constraint.m_name))
     73            return false;
     74
     75        if (!decoder.decodeEnum(constraint.m_dataType))
     76            return false;
     77
     78        return true;
     79    }
     80
    6681protected:
    67     explicit MediaConstraint(const AtomicString& name, MediaConstraintType constraintType, DataType dataType)
     82    MediaConstraint(const String& name, MediaConstraintType constraintType, DataType dataType)
    6883        : m_name(name)
    6984        , m_constraintType(constraintType)
    … …  
    7287    }
    7388
     89    MediaConstraint() = default;
     90    ~MediaConstraint() = default;
    7491
    7592private:
    76     AtomicString m_name;
    77     MediaConstraintType m_constraintType;
    78     DataType m_dataType;
     93    String m_name;
     94    MediaConstraintType m_constraintType { MediaConstraintType::Unknown };
     95    DataType m_dataType { DataType::None };
    7996};
    8097
    … …  
    213230    }
    214231
    215     bool isEmpty() const override { return !m_min && !m_max && !m_exact && !m_ideal; }
    216     bool isMandatory() const override { return m_min || m_max || m_exact; }
     232    bool isEmpty() const { return !m_min && !m_max && !m_exact && !m_ideal; }
     233    bool isMandatory() const { return m_min || m_max || m_exact; }
     234
     235    template <class Encoder> void encode(Encoder& encoder) const
     236    {
     237        MediaConstraint::encode(encoder);
     238
     239        encoder << m_min;
     240        encoder << m_max;
     241        encoder << m_exact;
     242        encoder << m_ideal;
     243    }
     244
     245    template <class Decoder> static bool decode(Decoder& decoder, NumericConstraint& constraint)
     246    {
     247        if (!MediaConstraint::decode(decoder, constraint))
     248            return false;
     249
     250        if (!decoder.decode(constraint.m_min))
     251            return false;
     252        if (!decoder.decode(constraint.m_max))
     253            return false;
     254        if (!decoder.decode(constraint.m_exact))
     255            return false;
     256        if (!decoder.decode(constraint.m_ideal))
     257            return false;
     258   
     259        return true;
     260    }
    217261
    218262protected:
    219     explicit NumericConstraint(const AtomicString& name, MediaConstraintType type, DataType dataType)
     263    NumericConstraint(const String& name, MediaConstraintType type, DataType dataType)
    220264        : MediaConstraint(name, type, dataType)
    221265    {
    222266    }
     267
     268    NumericConstraint() = default;
    223269
    224270    void innerMerge(const NumericConstraint& other)
    … …  
    256302class IntConstraint final : public NumericConstraint<int> {
    257303public:
    258     explicit IntConstraint(const AtomicString& name, MediaConstraintType type)
     304    IntConstraint(const String& name, MediaConstraintType type)
    259305        : NumericConstraint<int>(name, type, DataType::Integer)
    260306    {
    261307    }
    262308
    263     void merge(const MediaConstraint& other) final {
     309    IntConstraint() = default;
     310
     311    void merge(const MediaConstraint& other)
     312    {
    264313        ASSERT(other.isInt());
    265314        NumericConstraint::innerMerge(downcast<const IntConstraint>(other));
    … …  
    269318class DoubleConstraint final : public NumericConstraint<double> {
    270319public:
    271     explicit DoubleConstraint(const AtomicString& name, MediaConstraintType type)
     320    DoubleConstraint(const String& name, MediaConstraintType type)
    272321        : NumericConstraint<double>(name, type, DataType::Double)
    273322    {
    274323    }
    275324
    276     void merge(const MediaConstraint& other) final {
     325    DoubleConstraint() = default;
     326
     327    void merge(const MediaConstraint& other)
     328    {
    277329        ASSERT(other.isDouble());
    278330        NumericConstraint::innerMerge(downcast<DoubleConstraint>(other));
    … …  
    282334class BooleanConstraint final : public MediaConstraint {
    283335public:
    284     explicit BooleanConstraint(const AtomicString& name, MediaConstraintType type)
     336    BooleanConstraint(const String& name, MediaConstraintType type)
    285337        : MediaConstraint(name, type, DataType::Boolean)
    286338    {
    287339    }
     340
     341    BooleanConstraint() = default;
    288342
    289343    void setExact(bool value) { m_exact = value; }
    290344    void setIdeal(bool value) { m_ideal = value; }
    291345
    292     bool getExact(bool&) const;
    293     bool getIdeal(bool&) const;
     346    bool getExact(bool& exact) const
     347    {
     348        if (!m_exact)
     349            return false;
     350
     351        exact = m_exact.value();
     352        return true;
     353    }
     354
     355    bool getIdeal(bool& ideal) const
     356    {
     357        if (!m_ideal)
     358            return false;
     359
     360        ideal = m_ideal.value();
     361        return true;
     362    }
    294363
    295364    double fitnessDistance(bool value) const
    … …  
    316385    }
    317386
    318     void merge(const MediaConstraint& other) final {
     387    void merge(const MediaConstraint& other)
     388    {
    319389        ASSERT(other.isBoolean());
    320390        const BooleanConstraint& typedOther = downcast<BooleanConstraint>(other);
    … …  
    333403    }
    334404
    335     bool isEmpty() const final { return !m_exact && !m_ideal; };
    336     bool isMandatory() const final { return bool(m_exact); }
     405    bool isEmpty() const { return !m_exact && !m_ideal; };
     406    bool isMandatory() const { return bool(m_exact); }
     407
     408    template <class Encoder> void encode(Encoder& encoder) const
     409    {
     410        MediaConstraint::encode(encoder);
     411        encoder << m_exact;
     412        encoder << m_ideal;
     413    }
     414
     415    template <class Decoder> static bool decode(Decoder& decoder, BooleanConstraint& constraint)
     416    {
     417        if (!MediaConstraint::decode(decoder, constraint))
     418            return false;
     419
     420        if (!decoder.decode(constraint.m_exact))
     421            return false;
     422        if (!decoder.decode(constraint.m_ideal))
     423            return false;
     424
     425        return true;
     426    }
    337427
    338428private:
    … …  
    341431};
    342432
    343 class StringConstraint final : public MediaConstraint {
    344 public:
    345     explicit StringConstraint(const AtomicString& name, MediaConstraintType type)
     433class StringConstraint : public MediaConstraint {
     434public:
     435    StringConstraint(const String& name, MediaConstraintType type)
    346436        : MediaConstraint(name, type, DataType::String)
    347437    {
    348438    }
    349439
    350     void setExact(const String&);
    351     void appendExact(const String&);
    352     void setIdeal(const String&);
    353     void appendIdeal(const String&);
    354 
    355     bool getExact(Vector<String>&) const;
    356     bool getIdeal(Vector<String>&) const;
     440    StringConstraint() = default;
     441
     442    void setExact(const String& value)
     443    {
     444        m_exact.clear();
     445        m_exact.append(value);
     446    }
     447
     448    void appendExact(const String& value)
     449    {
     450        m_exact.clear();
     451        m_exact.append(value);
     452    }
     453
     454    void setIdeal(const String& value)
     455    {
     456        m_ideal.clear();
     457        m_ideal.append(value);
     458    }
     459
     460    void appendIdeal(const String& value)
     461    {
     462        m_ideal.append(value);
     463    }
     464
     465    bool getExact(Vector<String>& exact) const
     466    {
     467        if (!m_exact.isEmpty())
     468            return false;
     469
     470        exact = m_exact;
     471        return true;
     472    }
     473
     474    bool getIdeal(Vector<String>& ideal) const
     475    {
     476        if (!m_ideal.isEmpty())
     477            return false;
     478
     479        ideal = m_ideal;
     480        return true;
     481    }
    357482
    358483    double fitnessDistance(const String&) const;
    … …  
    360485
    361486    const String& find(std::function<bool(const String&)>) const;
    362     void merge(const MediaConstraint&) final;
    363 
    364     bool isEmpty() const final { return m_exact.isEmpty() && m_ideal.isEmpty(); }
    365     bool isMandatory() const final { return !m_exact.isEmpty(); }
     487
     488    bool isEmpty() const { return m_exact.isEmpty() && m_ideal.isEmpty(); }
     489    bool isMandatory() const { return !m_exact.isEmpty(); }
     490    WEBCORE_EXPORT void merge(const MediaConstraint&);
     491
     492    template <class Encoder> void encode(Encoder& encoder) const
     493    {
     494        MediaConstraint::encode(encoder);
     495
     496        encoder << m_exact;
     497        encoder << m_ideal;
     498    }
     499
     500    template <class Decoder> static bool decode(Decoder& decoder, StringConstraint& constraint)
     501    {
     502        if (!MediaConstraint::decode(decoder, constraint))
     503            return false;
     504
     505        if (!decoder.decode(constraint.m_exact))
     506            return false;
     507        if (!decoder.decode(constraint.m_ideal))
     508            return false;
     509
     510        return true;
     511    }
    366512
    367513private:
    … …  
    372518class UnknownConstraint final : public MediaConstraint {
    373519public:
    374     explicit UnknownConstraint(const AtomicString& name, MediaConstraintType type)
     520    UnknownConstraint(const String& name, MediaConstraintType type)
    375521        : MediaConstraint(name, type, DataType::None)
    376522    {
    … …  
    378524
    379525private:
    380     bool isEmpty() const final { return true; }
    381     bool isMandatory() const final { return false; }
    382     void merge(const MediaConstraint&) final { }
     526    bool isEmpty() const { return true; }
     527    bool isMandatory() const { return false; }
     528    void merge(const MediaConstraint&) { }
    383529};
    384530
    385531class MediaTrackConstraintSetMap {
    386532public:
    387     void forEach(std::function<void(const MediaConstraint&)>) const;
     533    WEBCORE_EXPORT void forEach(std::function<void(const MediaConstraint&)>) const;
    388534    void filter(std::function<bool(const MediaConstraint&)>) const;
    389535    bool isEmpty() const;
    390 
    391     void set(MediaConstraintType, Optional<IntConstraint>&&);
    392     void set(MediaConstraintType, Optional<DoubleConstraint>&&);
    393     void set(MediaConstraintType, Optional<BooleanConstraint>&&);
    394     void set(MediaConstraintType, Optional<StringConstraint>&&);
     536    WEBCORE_EXPORT size_t size() const;
     537
     538    WEBCORE_EXPORT void set(MediaConstraintType, Optional<IntConstraint>&&);
     539    WEBCORE_EXPORT void set(MediaConstraintType, Optional<DoubleConstraint>&&);
     540    WEBCORE_EXPORT void set(MediaConstraintType, Optional<BooleanConstraint>&&);
     541    WEBCORE_EXPORT void set(MediaConstraintType, Optional<StringConstraint>&&);
     542
     543    template <class Encoder> void encode(Encoder& encoder) const
     544    {
     545        encoder << m_width;
     546        encoder << m_height;
     547        encoder << m_sampleRate;
     548        encoder << m_sampleSize;
     549
     550        encoder << m_aspectRatio;
     551        encoder << m_frameRate;
     552        encoder << m_volume;
     553
     554        encoder << m_echoCancellation;
     555
     556        encoder << m_facingMode;
     557        encoder << m_deviceId;
     558        encoder << m_groupId;
     559    }
     560
     561    template <class Decoder> static bool decode(Decoder& decoder, MediaTrackConstraintSetMap& map)
     562    {
     563        if (!decoder.decode(map.m_width))
     564            return false;
     565        if (!decoder.decode(map.m_height))
     566            return false;
     567        if (!decoder.decode(map.m_sampleRate))
     568            return false;
     569        if (!decoder.decode(map.m_sampleSize))
     570            return false;
     571
     572        if (!decoder.decode(map.m_aspectRatio))
     573            return false;
     574        if (!decoder.decode(map.m_frameRate))
     575            return false;
     576        if (!decoder.decode(map.m_volume))
     577            return false;
     578
     579        if (!decoder.decode(map.m_echoCancellation))
     580            return false;
     581
     582        if (!decoder.decode(map.m_facingMode))
     583            return false;
     584        if (!decoder.decode(map.m_deviceId))
     585            return false;
     586        if (!decoder.decode(map.m_groupId))
     587            return false;
     588
     589        return true;
     590    }
    395591
    396592private:

  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h

    r205929 r207463  
    4444class CaptureDevice;
    4545class MediaConstraints;
    46 class MediaStreamCreationClient;
    4746class RealtimeMediaSourceSettings;
    4847class RealtimeMediaSourceSupportedConstraints;
    … …  
    5655    static void setSharedStreamCenterOverride(RealtimeMediaSourceCenter*);
    5756
    58     virtual void validateRequestConstraints(MediaStreamCreationClient*, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) = 0;
     57    using ValidConstraintsHandler = std::function<void(const Vector<RefPtr<RealtimeMediaSource>>&& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>&& videoTracks)>;
     58    using InvalidConstraintsHandler = std::function<void(const String& invalidConstraint)>;
     59    virtual void validateRequestConstraints(ValidConstraintsHandler, InvalidConstraintsHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) = 0;
    5960
    60     virtual void createMediaStream(MediaStreamCreationClient*, const String& audioDeviceID, const String& videoDeviceID) = 0;
    61 
    62     virtual void createMediaStream(PassRefPtr<MediaStreamCreationClient>, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) = 0;
     61    using NewMediaStreamHandler = std::function<void(RefPtr<MediaStreamPrivate>&&)>;
     62    virtual void createMediaStream(NewMediaStreamHandler, const String& audioDeviceID, const String& videoDeviceID) = 0;
    6363
    6464    virtual Vector<CaptureDevice> getMediaStreamDevices() = 0;

  • trunk/Source/WebCore/platform/mediastream/mac/AVCaptureDeviceManager.mm

    r206445 r207463  
    175175            captureDevice.m_persistentDeviceID = platformDevice.uniqueID;
    176176            captureDevice.m_enabled = true;
    177             captureDevice.m_groupID = createCanonicalUUIDString();
    178177            captureDevice.m_localizedName = platformDevice.localizedName;
    179178            if ([platformDevice position] == AVCaptureDevicePositionFront)

  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp

    r205929 r207463  
    11/*
    2  * Copyright (C) 2013 Apple, Inc. All rights reserved.
     2 * Copyright (C) 2013-2016 Apple, Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3535
    3636#include "AVCaptureDeviceManager.h"
    37 #include "MediaStreamCreationClient.h"
    3837#include "MediaStreamPrivate.h"
    3938#include <wtf/MainThread.h>
    … …  
    6766}
    6867
    69 void RealtimeMediaSourceCenterMac::validateRequestConstraints(MediaStreamCreationClient* client, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     68void RealtimeMediaSourceCenterMac::validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
    7069{
    71     ASSERT(client);
    72 
    7370    Vector<RefPtr<RealtimeMediaSource>> audioSources;
    7471    Vector<RefPtr<RealtimeMediaSource>> videoSources;
    … …  
    7875        AVCaptureDeviceManager::singleton().verifyConstraintsForMediaType(RealtimeMediaSource::Audio, audioConstraints, nullptr, invalidConstraint);
    7976        if (!invalidConstraint.isEmpty()) {
    80             client->constraintsInvalid(invalidConstraint);
     77            invalidHandler(invalidConstraint);
    8178            return;
    8279        }
    … …  
    8986        AVCaptureDeviceManager::singleton().verifyConstraintsForMediaType(RealtimeMediaSource::Video, videoConstraints, nullptr, invalidConstraint);
    9087        if (!invalidConstraint.isEmpty()) {
    91             client->constraintsInvalid(invalidConstraint);
     88            invalidHandler(invalidConstraint);
    9289            return;
    9390        }
    … …  
    9592        videoSources = AVCaptureDeviceManager::singleton().bestSourcesForTypeAndConstraints(RealtimeMediaSource::Type::Video, videoConstraints);
    9693    }
    97     client->constraintsValidated(audioSources, videoSources);
     94
     95    validHandler(WTFMove(audioSources), WTFMove(videoSources));
    9896}
    9997
    100 void RealtimeMediaSourceCenterMac::createMediaStream(PassRefPtr<MediaStreamCreationClient> prpQueryClient, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     98void RealtimeMediaSourceCenterMac::createMediaStream(NewMediaStreamHandler completionHandler, const String& audioDeviceID, const String& videoDeviceID)
    10199{
    102     RefPtr<MediaStreamCreationClient> client = prpQueryClient;
    103    
    104     ASSERT(client);
    105    
    106     Vector<RefPtr<RealtimeMediaSource>> audioSources;
    107     Vector<RefPtr<RealtimeMediaSource>> videoSources;
    108    
    109     if (audioConstraints.isValid()) {
    110         String invalidConstraint;
    111         AVCaptureDeviceManager::singleton().verifyConstraintsForMediaType(RealtimeMediaSource::Audio, audioConstraints, nullptr, invalidConstraint);
    112         if (!invalidConstraint.isEmpty()) {
    113             client->failedToCreateStreamWithConstraintsError(invalidConstraint);
    114             return;
    115         }
    116         // FIXME: Consider the constraints when choosing among multiple devices. For now just select the first available
    117         // device of the appropriate type.
    118         auto audioSource = AVCaptureDeviceManager::singleton().bestSourcesForTypeAndConstraints(RealtimeMediaSource::Audio, audioConstraints).at(0);
    119         ASSERT(audioSource);
    120        
    121         audioSources.append(WTFMove(audioSource));
    122     }
    123    
    124     if (videoConstraints.isValid()) {
    125         String invalidConstraint;
    126         AVCaptureDeviceManager::singleton().verifyConstraintsForMediaType(RealtimeMediaSource::Video, videoConstraints, nullptr, invalidConstraint);
    127         if (!invalidConstraint.isEmpty()) {
    128             client->failedToCreateStreamWithConstraintsError(invalidConstraint);
    129             return;
    130         }
    131         // FIXME: Consider the constraints when choosing among multiple devices. For now just select the first available
    132         // device of the appropriate type.
    133         auto videoSource = AVCaptureDeviceManager::singleton().bestSourcesForTypeAndConstraints(RealtimeMediaSource::Video, videoConstraints).at(0);
    134         ASSERT(videoSource);
    135        
    136         videoSources.append(WTFMove(videoSource));
    137     }
    138    
    139     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
    140 }
    141 
    142 void RealtimeMediaSourceCenterMac::createMediaStream(MediaStreamCreationClient* client, const String& audioDeviceID, const String& videoDeviceID)
    143 {
    144     ASSERT(client);
    145100    Vector<RefPtr<RealtimeMediaSource>> audioSources;
    146101    Vector<RefPtr<RealtimeMediaSource>> videoSources;
    … …  
    157112    }
    158113
    159     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
     114    if (videoSources.isEmpty() && audioSources.isEmpty())
     115        completionHandler(nullptr);
     116    else
     117        completionHandler(MediaStreamPrivate::create(audioSources, videoSources));
    160118}
    161119

  • trunk/Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.h

    r205929 r207463  
    11/*
    2  * Copyright (C) 2013 Apple, Inc. All rights reserved.
     2 * Copyright (C) 2013-2016 Apple, Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4848    ~RealtimeMediaSourceCenterMac();
    4949
    50     void validateRequestConstraints(MediaStreamCreationClient*, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
    51     void createMediaStream(PassRefPtr<MediaStreamCreationClient>, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
    52     void createMediaStream(MediaStreamCreationClient*, const String& audioDeviceID, const String& videoDeviceID) final;
     50    void validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
     51    void createMediaStream(NewMediaStreamHandler, const String& audioDeviceID, const String& videoDeviceID) final;
    5352    Vector<CaptureDevice> getMediaStreamDevices() final;
    5453};

  • trunk/Source/WebCore/platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.cpp

    r206204 r207463  
    3838
    3939#include "CaptureDevice.h"
    40 #include "MediaStreamCreationClient.h"
    4140#include "MediaStreamPrivate.h"
    4241#include "NotImplemented.h"
    … …  
    7877}
    7978
    80 void RealtimeMediaSourceCenterOwr::validateRequestConstraints(MediaStreamCreationClient* client, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     79void RealtimeMediaSourceCenterOwr::validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
    8180{
    82     m_client = client;
     81    m_validConstraintsHandler = WTFMove(validHandler);
     82    m_invalidConstraintsHandler = WTFMove(invalidHandler);
    8383
    8484    // FIXME: Actually do constraints validation. The MediaConstraints
    … …  
    9494}
    9595
    96 void RealtimeMediaSourceCenterOwr::createMediaStream(PassRefPtr<MediaStreamCreationClient> prpQueryClient, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     96void RealtimeMediaSourceCenterOwr::createMediaStream(NewMediaStreamHandler completionHandler, const String& audioDeviceID, const String& videoDeviceID)
    9797{
    98     RefPtr<MediaStreamCreationClient> client = prpQueryClient;
    99     ASSERT(client);
    100 
    101     UNUSED_PARAM(audioConstraints);
    102     UNUSED_PARAM(videoConstraints);
    103 
    104     Vector<RefPtr<RealtimeMediaSource>> audioSources;
    105     Vector<RefPtr<RealtimeMediaSource>> videoSources;
    106 
    107     if (audioConstraints.isValid()) {
    108         // TODO: verify constraints according to registered
    109         // sources. For now, unconditionally pick the first source, see bug #123345.
    110         RefPtr<RealtimeMediaSource> audioSource = firstSource(RealtimeMediaSource::Audio);
    111         if (audioSource) {
    112             audioSource->reset();
    113             audioSources.append(audioSource.release());
    114         }
    115     }
    116 
    117     if (videoConstraints.isValid()) {
    118         // TODO: verify constraints according to registered
    119         // sources. For now, unconditionally pick the first source, see bug #123345.
    120         RefPtr<RealtimeMediaSource> videoSource = firstSource(RealtimeMediaSource::Video);
    121         if (videoSource) {
    122             videoSource->reset();
    123             videoSources.append(videoSource.release());
    124         }
    125     }
    126 
    127     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
    128 }
    129 
    130 void RealtimeMediaSourceCenterOwr::createMediaStream(MediaStreamCreationClient* client, const String& audioDeviceID, const String& videoDeviceID)
    131 {
    132     ASSERT(client);
    13398    Vector<RefPtr<RealtimeMediaSource>> audioSources;
    13499    Vector<RefPtr<RealtimeMediaSource>> videoSources;
    … …  
    151116    }
    152117
    153     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
     118    if (videoSources.isEmpty() && audioSources.isEmpty())
     119        completionHandler(nullptr);
     120    else
     121        completionHandler(MediaStreamPrivate::create(audioSources, videoSources));
    154122}
    155123
    … …  
    197165
    198166    // TODO: Make sure contraints are actually validated by checking source types.
    199     m_client->constraintsValidated(audioSources, videoSources);
     167    m_validConstraintsHandler(WTFMove(audioSources), WTFMove(videoSources));
     168    m_validConstraintsHandler = nullptr;
     169    m_invalidConstraintsHandler = nullptr;
    200170}
    201171

  • trunk/Source/WebCore/platform/mediastream/openwebrtc/RealtimeMediaSourceCenterOwr.h

    r205929 r207463  
    5555    ~RealtimeMediaSourceCenterOwr();
    5656
    57     void validateRequestConstraints(MediaStreamCreationClient*, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
     57    void validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
    5858
    59     void createMediaStream(PassRefPtr<MediaStreamCreationClient>, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) final;
    60     void createMediaStream(MediaStreamCreationClient*, const String& audioDeviceID, const String& videoDeviceID) final;
     59    void createMediaStream(NewMediaStreamHandler, const String& audioDeviceID, const String& videoDeviceID) final;
    6160
    6261    Vector<CaptureDevice> getMediaStreamDevices() final;
    … …  
    6766    PassRefPtr<RealtimeMediaSource> firstSource(RealtimeMediaSource::Type);
    6867    RealtimeMediaSourceOwrMap m_sourceMap;
    69     RefPtr<MediaStreamCreationClient> m_client;
     68    ValidConstraintsHandler m_validConstraintsHandler;
     69    InvalidConstraintsHandler m_invalidConstraintsHandler;
    7070};
    7171

  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp

    r206445 r207463  
    3434#include "MediaConstraintsMock.h"
    3535#include "MediaStream.h"
    36 #include "MediaStreamCreationClient.h"
    3736#include "MediaStreamPrivate.h"
    3837#include "MediaStreamTrack.h"
    … …  
    6867}
    6968
    70 void MockRealtimeMediaSourceCenter::validateRequestConstraints(MediaStreamCreationClient* client, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     69void MockRealtimeMediaSourceCenter::validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
    7170{
    72     ASSERT(client);
    73 
    7471    Vector<RefPtr<RealtimeMediaSource>> audioSources;
    7572    Vector<RefPtr<RealtimeMediaSource>> videoSources;
    … …  
    7875        String invalidQuery = MediaConstraintsMock::verifyConstraints(RealtimeMediaSource::Audio, audioConstraints);
    7976        if (!invalidQuery.isEmpty()) {
    80             client->constraintsInvalid(invalidQuery);
     77            invalidHandler(invalidQuery);
    8178            return;
    8279        }
    … …  
    8986        String invalidQuery = MediaConstraintsMock::verifyConstraints(RealtimeMediaSource::Video, videoConstraints);
    9087        if (!invalidQuery.isEmpty()) {
    91             client->constraintsInvalid(invalidQuery);
     88            invalidHandler(invalidQuery);
    9289            return;
    9390        }
    … …  
    9794    }
    9895
    99     client->constraintsValidated(audioSources, videoSources);
     96    validHandler(WTFMove(audioSources), WTFMove(videoSources));
    10097}
    10198
    102 void MockRealtimeMediaSourceCenter::createMediaStream(PassRefPtr<MediaStreamCreationClient> prpQueryClient, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints)
     99void MockRealtimeMediaSourceCenter::createMediaStream(NewMediaStreamHandler completionHandler, const String& audioDeviceID, const String& videoDeviceID)
    103100{
    104     RefPtr<MediaStreamCreationClient> client = prpQueryClient;
    105 
    106     ASSERT(client);
    107    
    108101    Vector<RefPtr<RealtimeMediaSource>> audioSources;
    109102    Vector<RefPtr<RealtimeMediaSource>> videoSources;
    110103
    111     if (audioConstraints.isValid()) {
    112         const String invalidQuery = MediaConstraintsMock::verifyConstraints(RealtimeMediaSource::Audio, audioConstraints);
    113         if (!invalidQuery.isEmpty()) {
    114             client->failedToCreateStreamWithConstraintsError(invalidQuery);
    115             return;
    116         }
     104    if (audioDeviceID == MockRealtimeMediaSource::mockAudioSourcePersistentID())
     105        audioSources.append(MockRealtimeAudioSource::create());
    117106
    118         auto audioSource = MockRealtimeAudioSource::create();
    119         audioSources.append(WTFMove(audioSource));
    120     }
     107    if (videoDeviceID == MockRealtimeMediaSource::mockVideoSourcePersistentID())
     108        videoSources.append(MockRealtimeVideoSource::create());
    121109
    122     if (videoConstraints.isValid()) {
    123         const String invalidQuery = MediaConstraintsMock::verifyConstraints(RealtimeMediaSource::Video, videoConstraints);
    124         if (!invalidQuery.isEmpty()) {
    125             client->failedToCreateStreamWithConstraintsError(invalidQuery);
    126             return;
    127         }
    128 
    129         auto videoSource = MockRealtimeVideoSource::create();
    130         videoSources.append(WTFMove(videoSource));
    131     }
    132    
    133     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
    134 }
    135 
    136 void MockRealtimeMediaSourceCenter::createMediaStream(MediaStreamCreationClient* client, const String& audioDeviceID, const String& videoDeviceID)
    137 {
    138     ASSERT(client);
    139     Vector<RefPtr<RealtimeMediaSource>> audioSources;
    140     Vector<RefPtr<RealtimeMediaSource>> videoSources;
    141 
    142     if (!audioDeviceID.isEmpty() && audioDeviceID == MockRealtimeMediaSource::mockAudioSourcePersistentID()) {
    143         auto audioSource = MockRealtimeAudioSource::create();
    144         audioSources.append(WTFMove(audioSource));
    145     }
    146     if (!videoDeviceID.isEmpty() && videoDeviceID == MockRealtimeMediaSource::mockVideoSourcePersistentID()) {
    147         auto videoSource = MockRealtimeVideoSource::create();
    148         videoSources.append(WTFMove(videoSource));
    149     }
    150 
    151     client->didCreateStream(MediaStreamPrivate::create(audioSources, videoSources));
     110    if (videoSources.isEmpty() && audioSources.isEmpty())
     111        completionHandler(nullptr);
     112    else
     113        completionHandler(MediaStreamPrivate::create(audioSources, videoSources));
    152114}
    153115

  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h

    r205929 r207463  
    4242    MockRealtimeMediaSourceCenter();
    4343
    44     void validateRequestConstraints(MediaStreamCreationClient*, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) override;
    45     void createMediaStream(PassRefPtr<MediaStreamCreationClient>, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) override;
     44    void validateRequestConstraints(ValidConstraintsHandler validHandler, InvalidConstraintsHandler invalidHandler, MediaConstraints& audioConstraints, MediaConstraints& videoConstraints) override;
    4645    Vector<CaptureDevice> getMediaStreamDevices() override;
    47     void createMediaStream(MediaStreamCreationClient*, const String& audioDeviceID, const String& videoDeviceID) override;
     46    void createMediaStream(NewMediaStreamHandler, const String& audioDeviceID, const String& videoDeviceID) override;
    4847};
    4948

  • trunk/Source/WebKit/mac/ChangeLog

    r207458 r207463  
     12016-10-18  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Resolve constraints and enumerate devices in the UI process
     4        https://bugs.webkit.org/show_bug.cgi?id=162147
     5        <rdar://problem/28803569>
     6
     7        Reviewed by Darin Adler.
     8
     9        * WebCoreSupport/WebUserMediaClient.h:
     10        * WebCoreSupport/WebUserMediaClient.mm:
     11        (AddPermissionCheckToMap):
     12        (RemovePermissionCheckFromMap):
     13        (WebUserMediaClient::pageDestroyed):
     14        (WebUserMediaClient::requestUserMediaAccess):
     15        (WebUserMediaClient::enumerateMediaDevices):
     16        (WebUserMediaClient::cancelMediaDevicesEnumerationRequest):
     17        (-[WebUserMediaPolicyListener allow]):
     18        (-[WebUserMediaPolicyListener deny]):
     19        (-[WebUserMediaPolicyCheckerListener initWithMediaDevicesEnumerationRequest:]):
     20        (-[WebUserMediaPolicyCheckerListener cancelMediaDevicesEnumerationRequest]):
     21        (-[WebUserMediaPolicyCheckerListener allow]):
     22        (-[WebUserMediaPolicyCheckerListener deny]):
     23        (WebUserMediaClient::checkUserMediaPermission): Deleted.
     24        (WebUserMediaClient::cancelUserMediaPermissionCheck): Deleted.
     25        (-[WebUserMediaPolicyCheckerListener initWithUserMediaPermissionCheck:]): Deleted.
     26        (-[WebUserMediaPolicyCheckerListener cancelUserMediaPermissionCheck]): Deleted.
     27
    1282016-10-17  Antti Koivisto  <antti@apple.com>
    229

  • trunk/Source/WebKit/mac/WebCoreSupport/WebUserMediaClient.h

    r204466 r207463  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    3131#import <WebCore/UserMediaClient.h>
    3232
    33 namespace WebCore {
    34 class UserMediaClient;
    35 class UserMediaPermissionCheck;
    36 class UserMediaRequest;
    37 }
    38 
    3933@class WebView;
    4034
    … …  
    4539
    4640    // UserMediaClient
    47     void requestUserMediaAccess(WebCore::UserMediaRequest&) override;
    48     void cancelUserMediaAccessRequest(WebCore::UserMediaRequest&) override;
     41    void requestUserMediaAccess(WebCore::UserMediaRequest&) final;
     42    void cancelUserMediaAccessRequest(WebCore::UserMediaRequest&) final;
    4943
    50     void checkUserMediaPermission(WebCore::UserMediaPermissionCheck&) override;
    51     void cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck&) override;
     44    void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&) final;
     45    void cancelMediaDevicesEnumerationRequest(WebCore::MediaDevicesEnumerationRequest&) final;
    5246
    53     void pageDestroyed() override;
     47    void pageDestroyed() final;
    5448
    5549private:

  • trunk/Source/WebKit/mac/WebCoreSupport/WebUserMediaClient.mm

    r201038 r207463  
    3232#import "WebUIDelegatePrivate.h"
    3333#import "WebViewInternal.h"
     34#import <WebCore/CaptureDevice.h>
     35#import <WebCore/MediaDevicesEnumerationRequest.h>
    3436#import <WebCore/Page.h>
     37#import <WebCore/RealtimeMediaSourceCenter.h>
    3538#import <WebCore/ScriptExecutionContext.h>
    36 #import <WebCore/UserMediaPermissionCheck.h>
    3739#import <WebCore/UserMediaRequest.h>
    3840#import <wtf/BlockObjCExceptions.h>
    … …  
    5456
    5557@interface WebUserMediaPolicyCheckerListener : NSObject <WebAllowDenyPolicyListener> {
    56     RefPtr<UserMediaPermissionCheck> _request;
    57 }
    58 - (id)initWithUserMediaPermissionCheck:(PassRefPtr<UserMediaPermissionCheck>)request;
    59 - (void)cancelUserMediaPermissionCheck;
     58    RefPtr<MediaDevicesEnumerationRequest> _request;
     59}
     60- (id)initWithMediaDevicesEnumerationRequest:(PassRefPtr<MediaDevicesEnumerationRequest>)request;
     61- (void)cancelMediaDevicesEnumerationRequest;
    6062- (void)deny;
    6163@end
    … …  
    7981}
    8082
    81 typedef HashMap<RefPtr<UserMediaPermissionCheck>, RetainPtr<WebUserMediaPolicyCheckerListener>> UserMediaCheckMap;
     83typedef HashMap<RefPtr<MediaDevicesEnumerationRequest>, RetainPtr<WebUserMediaPolicyCheckerListener>> UserMediaCheckMap;
    8284
    8385static UserMediaCheckMap& userMediaCheckMap()
    … …  
    8789}
    8890
    89 static void AddPermissionCheckToMap(UserMediaPermissionCheck* request, RetainPtr<WebUserMediaPolicyCheckerListener> listener)
     91static void AddPermissionCheckToMap(MediaDevicesEnumerationRequest* request, RetainPtr<WebUserMediaPolicyCheckerListener> listener)
    9092{
    9193    userMediaCheckMap().set(request, listener);
    9294}
    9395
    94 static void RemovePermissionCheckFromMap(UserMediaPermissionCheck* request)
     96static void RemovePermissionCheckFromMap(MediaDevicesEnumerationRequest* request)
    9597{
    9698    userMediaCheckMap().remove(request);
    … …  
    124126
    125127    for (auto& check : pendingChecks)
    126         [check cancelUserMediaPermissionCheck];
     128        [check cancelMediaDevicesEnumerationRequest];
    127129
    128130    ASSERT(userMediaCheckMap().isEmpty());
    … …  
    137139    SEL selector = @selector(webView:decidePolicyForUserMediaRequestFromOrigin:listener:);
    138140    if (![[m_webView UIDelegate] respondsToSelector:selector]) {
    139         request.userMediaAccessDenied();
     141        request.deny(UserMediaRequest::MediaAccessDenialReason::UserMediaDisabled, "");
    140142        return;
    141143    }
    … …  
    164166}
    165167
    166 void WebUserMediaClient::checkUserMediaPermission(UserMediaPermissionCheck& request)
     168void WebUserMediaClient::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
    167169{
    168170    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    170172    SEL selector = @selector(webView:checkPolicyForUserMediaRequestFromOrigin:listener:);
    171173    if (![[m_webView UIDelegate] respondsToSelector:selector]) {
    172         request.setUserMediaAccessInfo(emptyString(), false);
     174        request.setDeviceInfo(Vector<CaptureDevice>(), emptyString(), false);
    173175        return;
    174176    }
    175177
    176     WebUserMediaPolicyCheckerListener *listener = [[WebUserMediaPolicyCheckerListener alloc] initWithUserMediaPermissionCheck:&request];
     178    WebUserMediaPolicyCheckerListener *listener = [[WebUserMediaPolicyCheckerListener alloc] initWithMediaDevicesEnumerationRequest:&request];
    177179    WebSecurityOrigin *webOrigin = [[WebSecurityOrigin alloc] _initWithWebCoreSecurityOrigin:request.userMediaDocumentOrigin()];
    178180
    … …  
    186188}
    187189
    188 void WebUserMediaClient::cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck& request)
     190void WebUserMediaClient::cancelMediaDevicesEnumerationRequest(WebCore::MediaDevicesEnumerationRequest& request)
    189191{
    190192    UserMediaCheckMap& requestsMap = userMediaCheckMap();
    … …  
    193195        return;
    194196
    195     [it->value cancelUserMediaPermissionCheck];
     197    [it->value cancelMediaDevicesEnumerationRequest];
    196198    requestsMap.remove(it);
    197199}
    … …  
    227229        return;
    228230   
    229     _request->userMediaAccessGranted(_request->allowedAudioDeviceUID(), _request->allowedVideoDeviceUID());
     231    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=162154
    230232    RemoveRequestFromRequestMap(_request.get());
    231233#endif
    … …  
    238240        return;
    239241   
    240     _request->userMediaAccessDenied();
     242    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=162154
    241243    RemoveRequestFromRequestMap(_request.get());
    242244#endif
    … …  
    261263@implementation WebUserMediaPolicyCheckerListener
    262264
    263 - (id)initWithUserMediaPermissionCheck:(PassRefPtr<UserMediaPermissionCheck>)request
     265- (id)initWithMediaDevicesEnumerationRequest:(PassRefPtr<MediaDevicesEnumerationRequest>)request
    264266{
    265267#if ENABLE(MEDIA_STREAM)
    … …  
    272274}
    273275
    274 - (void)cancelUserMediaPermissionCheck
     276- (void)cancelMediaDevicesEnumerationRequest
    275277{
    276278#if ENABLE(MEDIA_STREAM)
    … …  
    289291        return;
    290292
    291     _request->setUserMediaAccessInfo(_request->mediaDeviceIdentifierHashSalt(), true);
     293    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=162154
    292294    RemovePermissionCheckFromMap(_request.get());
    293295#endif
    … …  
    300302        return;
    301303
    302     _request->setUserMediaAccessInfo(emptyString(), true);
     304    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=162154
    303305    RemovePermissionCheckFromMap(_request.get());
    304306#endif

  • trunk/Source/WebKit2/ChangeLog

    r207458 r207463  
     12016-10-18  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Resolve constraints and enumerate devices in the UI process
     4        https://bugs.webkit.org/show_bug.cgi?id=162147
     5        <rdar://problem/28803569>
     6
     7        Reviewed by Darin Adler.
     8       
     9        Restructure gUM constraint validation and MediaDevices.enumerateDevices so all media device
     10        access happens in the UI process.
     11
     12        * Scripts/webkit/messages.py:
     13        (headers_for_type): Special case MediaConstraintsData.
     14
     15        * Shared/WebCoreArgumentCoders.cpp:
     16        (IPC::encodeMediaTrackConstraintSetMap): MediaTrackConstraintSetMap encoder.
     17        (IPC::ArgumentCoder<MediaConstraintsData>::encode): MediaConstraintsData encoder.
     18        (IPC::decodeMediaTrackConstraintSetMap): MediaTrackConstraintSetMap decoder.
     19        (IPC::ArgumentCoder<MediaConstraintsData>::decode): MediaConstraintsData decoder.
     20        (IPC::ArgumentCoder<CaptureDevice>::encode): CaptureDevice enoder.
     21        (IPC::ArgumentCoder<CaptureDevice>::decode): CaptureDevice decoder.
     22        * Shared/WebCoreArgumentCoders.h:
     23
     24        * UIProcess/API/APIUIClient.h:  Remove UserMediaPermissionCheckProxy forward declaration.
     25
     26        * UIProcess/API/C/WKUserMediaPermissionRequest.cpp:
     27        (toWK): Translate UserMediaPermissionRequestDenialReason to UserMediaAccessDenialReason.
     28        (WKUserMediaPermissionRequestDeny): Add "reason" parameter.
     29        * UIProcess/API/C/WKUserMediaPermissionRequest.h:
     30
     31        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
     32        (WebKit::UserMediaPermissionRequestManagerProxy::invalidateRequests): Invalidate pending device requests.
     33        (WebKit::UserMediaPermissionRequestManagerProxy::createRequest): Make private.
     34        (WebKit::toWebCore): Map from UserMediaAccessDenialReason to MediaAccessDenialReason, cast to
     35          uint64_t to pass to web process.
     36        (WebKit::UserMediaPermissionRequestManagerProxy::denyRequest): Send to web process.
     37        (WebKit::UserMediaPermissionRequestManagerProxy::userMediaAccessWasGranted): Ditto.
     38        (WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame): Validate
     39          constraints and make sure gUM is enabled before prompting user.
     40        (WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame): New.
     41        (WebKit::UserMediaPermissionRequestManagerProxy::didCompleteUserMediaPermissionCheck): Send
     42          results of device enumeration to web process.
     43        (WebKit::UserMediaPermissionRequestManagerProxy::didReceiveUserMediaPermissionDecision): Deleted.
     44        (WebKit::UserMediaPermissionRequestManagerProxy::createUserMediaPermissionCheck): Deleted.
     45        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
     46
     47        * UIProcess/UserMediaPermissionRequestProxy.cpp:
     48        (WebKit::UserMediaPermissionRequestProxy::allow):
     49        (WebKit::UserMediaPermissionRequestProxy::deny): Take "reason" parameter.
     50        * UIProcess/UserMediaPermissionRequestProxy.h:
     51
     52        * UIProcess/WebPageProxy.cpp:
     53        (WebKit::WebPageProxy::requestUserMediaPermissionForFrame):
     54        (WebKit::WebPageProxy::enumerateMediaDevicesForFrame):
     55        (WebKit::WebPageProxy::checkUserMediaPermissionForFrame): Deleted.
     56        * UIProcess/WebPageProxy.h:
     57        * UIProcess/WebPageProxy.messages.in:
     58
     59        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
     60        (WebKit::UserMediaPermissionRequestManager::startUserMediaRequest): userMediaAccessDenied -> deny.
     61          Pass the audio and video constraints to the UI process.
     62        (WebKit::UserMediaPermissionRequestManager::userMediaAccessWasGranted):
     63        (WebKit::UserMediaPermissionRequestManager::userMediaAccessWasDenied):
     64        (WebKit::UserMediaPermissionRequestManager::enumerateMediaDevices): Send the enumeration request
     65          to the UI process.
     66        (WebKit::UserMediaPermissionRequestManager::cancelMediaDevicesEnumeration):
     67        (WebKit::UserMediaPermissionRequestManager::didCompleteMediaDeviceEnumeration):
     68        (WebKit::UserMediaPermissionRequestManager::didReceiveUserMediaPermissionDecision): Deleted.
     69        (WebKit::UserMediaPermissionRequestManager::startUserMediaPermissionCheck): Deleted.
     70        (WebKit::UserMediaPermissionRequestManager::cancelUserMediaPermissionCheck): Deleted.
     71        (WebKit::UserMediaPermissionRequestManager::didCompleteUserMediaPermissionCheck): Deleted.
     72        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
     73
     74        * WebProcess/WebCoreSupport/WebUserMediaClient.cpp:
     75        (WebKit::WebUserMediaClient::enumerateMediaDevices): New.
     76        (WebKit::WebUserMediaClient::cancelMediaDevicesEnumerationRequest): New.
     77        (WebKit::WebUserMediaClient::checkUserMediaPermission): Deleted.
     78        (WebKit::WebUserMediaClient::cancelUserMediaPermissionCheck): Deleted.
     79        * WebProcess/WebCoreSupport/WebUserMediaClient.h:
     80
     81        * WebProcess/WebPage/WebPage.cpp:
     82        (WebKit::WebPage::userMediaAccessWasGranted): New.
     83        (WebKit::WebPage::userMediaAccessWasDenied): Ditto.
     84        (WebKit::WebPage::didCompleteMediaDeviceEnumeration):
     85        (WebKit::WebPage::didReceiveUserMediaPermissionDecision): Deleted.
     86        (WebKit::WebPage::didCompleteUserMediaPermissionCheck): Deleted.
     87        * WebProcess/WebPage/WebPage.h:
     88        * WebProcess/WebPage/WebPage.messages.in:
     89
    1902016-10-17  Antti Koivisto  <antti@apple.com>
    291

  • trunk/Source/WebKit2/Scripts/webkit/messages.py

    r206030 r207463  
    356356        'WebCore::KeyframeValueList': ['<WebCore/GraphicsLayer.h>'],
    357357        'WebCore::KeypressCommand': ['<WebCore/KeyboardEvent.h>'],
     358        'WebCore::MediaConstraintsData': ['<WebCore/MediaConstraintsImpl.h>'],
    358359        'WebCore::PasteboardImage': ['<WebCore/Pasteboard.h>'],
    359360        'WebCore::PasteboardWebContent': ['<WebCore/Pasteboard.h>'],

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.cpp

    r204668 r207463  
    9494#endif
    9595
     96#if ENABLE(MEDIA_STREAM)
     97#include <WebCore/CaptureDevice.h>
     98#include <WebCore/MediaConstraintsImpl.h>
     99#endif
     100
    96101using namespace WebCore;
    97102using namespace WebKit;
    … …  
    22202225}
    22212226
     2227#if ENABLE(MEDIA_STREAM)
     2228void ArgumentCoder<MediaConstraintsData>::encode(Encoder& encoder, const WebCore::MediaConstraintsData& constraint)
     2229{
     2230    encoder << constraint.mandatoryConstraints;
     2231
     2232    auto& advancedConstraints = constraint.advancedConstraints;
     2233    encoder << static_cast<uint64_t>(advancedConstraints.size());
     2234    for (const auto& advancedConstraint : advancedConstraints)
     2235        encoder << advancedConstraint;
     2236
     2237    encoder << constraint.isValid;
     2238}
     2239
     2240bool ArgumentCoder<MediaConstraintsData>::decode(Decoder& decoder, WebCore::MediaConstraintsData& constraints)
     2241{
     2242    MediaTrackConstraintSetMap mandatoryConstraints;
     2243    if (!decoder.decode(mandatoryConstraints))
     2244        return false;
     2245
     2246    uint64_t advancedCount;
     2247    if (!decoder.decode(advancedCount))
     2248        return false;
     2249
     2250    Vector<MediaTrackConstraintSetMap> advancedConstraints;
     2251    advancedConstraints.reserveInitialCapacity(advancedCount);
     2252    for (size_t i = 0; i < advancedCount; ++i) {
     2253        MediaTrackConstraintSetMap map;
     2254        if (!decoder.decode(map))
     2255            return false;
     2256
     2257        advancedConstraints.uncheckedAppend(WTFMove(map));
     2258    }
     2259
     2260    bool isValid;
     2261    if (!decoder.decode(isValid))
     2262        return false;
     2263
     2264    constraints.mandatoryConstraints = WTFMove(mandatoryConstraints);
     2265    constraints.advancedConstraints = WTFMove(advancedConstraints);
     2266    constraints.isValid = isValid;
     2267
     2268    return true;
     2269}
     2270
     2271void ArgumentCoder<CaptureDevice>::encode(Encoder& encoder, const WebCore::CaptureDevice& device)
     2272{
     2273    encoder << device.persistentId();
     2274    encoder << device.label();
     2275    encoder << device.groupId();
     2276    encoder.encodeEnum(device.kind());
     2277}
     2278
     2279bool ArgumentCoder<CaptureDevice>::decode(Decoder& decoder, WebCore::CaptureDevice& device)
     2280{
     2281    String persistentId;
     2282    if (!decoder.decode(persistentId))
     2283        return false;
     2284
     2285    String label;
     2286    if (!decoder.decode(label))
     2287        return false;
     2288
     2289    String groupId;
     2290    if (!decoder.decode(groupId))
     2291        return false;
     2292
     2293    CaptureDevice::SourceKind kind;
     2294    if (!decoder.decodeEnum(kind))
     2295        return false;
     2296
     2297    device.setPersistentId(persistentId);
     2298    device.setLabel(label);
     2299    device.setGroupId(groupId);
     2300    device.setKind(kind);
     2301
     2302    return true;
     2303}
     2304#endif
     2305
    22222306
    22232307} // namespace IPC

  • trunk/Source/WebKit2/Shared/WebCoreArgumentCoders.h

    r206006 r207463  
    128128#endif
    129129
     130#if ENABLE(MEDIA_STREAM)
     131namespace WebCore {
     132class CaptureDevice;
     133struct MediaConstraintsData;
     134}
     135#endif
     136
    130137namespace IPC {
    131138
    … …  
    529536#endif
    530537
     538#if ENABLE(MEDIA_STREAM)
     539template<> struct ArgumentCoder<WebCore::MediaConstraintsData> {
     540    static void encode(Encoder&, const WebCore::MediaConstraintsData&);
     541    static bool decode(Decoder&, WebCore::MediaConstraintsData&);
     542};
     543
     544template<> struct ArgumentCoder<WebCore::CaptureDevice> {
     545    static void encode(Encoder&, const WebCore::CaptureDevice&);
     546    static bool decode(Decoder&, WebCore::CaptureDevice&);
     547};
     548#endif
     549
    531550} // namespace IPC
    532551

  • trunk/Source/WebKit2/UIProcess/API/APIUIClient.h

    r205327 r207463  
    5252class NativeWebWheelEvent;
    5353class NotificationPermissionRequest;
    54 class UserMediaPermissionCheckProxy;
    5554class UserMediaPermissionRequestProxy;
    5655class WebColorPickerResultListenerProxy;

  • trunk/Source/WebKit2/UIProcess/API/C/WKUserMediaPermissionRequest.cpp

    r190262 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    3940}
    4041
    41 void WKUserMediaPermissionRequestDeny(WKUserMediaPermissionRequestRef userMediaPermissionRequestRef)
     42static UserMediaPermissionRequestProxy::UserMediaAccessDenialReason toWK(UserMediaPermissionRequestDenialReason reason)
    4243{
    43     toImpl(userMediaPermissionRequestRef)->deny();
     44    switch (reason) {
     45    case kWKNoConstraints:
     46        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints;
     47        break;
     48    case kWKUserMediaDisabled:
     49        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled;
     50        break;
     51    case kWKNoCaptureDevices:
     52        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoCaptureDevices;
     53        break;
     54    case kWKInvalidConstraint:
     55        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::InvalidConstraint;
     56        break;
     57    case kWKHardwareError:
     58        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::HardwareError;
     59        break;
     60    case kWKPermissionDenied:
     61        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::PermissionDenied;
     62        break;
     63    case kWKOtherFailure:
     64        return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::OtherFailure;
     65        break;
     66    }
     67
     68    ASSERT_NOT_REACHED();
     69    return UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::OtherFailure;
     70   
     71}
     72
     73void WKUserMediaPermissionRequestDeny(WKUserMediaPermissionRequestRef userMediaPermissionRequestRef, UserMediaPermissionRequestDenialReason reason)
     74{
     75    toImpl(userMediaPermissionRequestRef)->deny(toWK(reason));
    4476}
    4577

  • trunk/Source/WebKit2/UIProcess/API/C/WKUserMediaPermissionRequest.h

    r190262 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2829WK_EXPORT WKTypeID WKUserMediaPermissionRequestGetTypeID();
    2930
     31enum {
     32    kWKNoConstraints = 0,
     33    kWKUserMediaDisabled,
     34    kWKNoCaptureDevices,
     35    kWKInvalidConstraint,
     36    kWKHardwareError,
     37    kWKPermissionDenied,
     38    kWKOtherFailure
     39};
     40typedef uint32_t UserMediaPermissionRequestDenialReason;
     41
    3042WK_EXPORT void WKUserMediaPermissionRequestAllow(WKUserMediaPermissionRequestRef, WKStringRef audioDeviceUID, WKStringRef videoDeviceUID);
    31 WK_EXPORT void WKUserMediaPermissionRequestDeny(WKUserMediaPermissionRequestRef);
     43WK_EXPORT void WKUserMediaPermissionRequestDeny(WKUserMediaPermissionRequestRef, UserMediaPermissionRequestDenialReason);
    3244
    3345WK_EXPORT WKArrayRef WKUserMediaPermissionRequestVideoDeviceUIDs(WKUserMediaPermissionRequestRef);

  • trunk/Source/WebKit2/UIProcess/API/gtk/WebKitUserMediaPermissionRequest.cpp

    r198527 r207463  
    9292
    9393    priv->madeDecision = true;
    94     priv->request->deny();
     94    priv->request->deny(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::PermissionDenied);
    9595}
    9696

  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.cpp

    r197114 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2021#include "UserMediaPermissionRequestManagerProxy.h"
    2122
     23#include "APISecurityOrigin.h"
     24#include "APIUIClient.h"
    2225#include "WebPageMessages.h"
    2326#include "WebPageProxy.h"
    2427#include "WebProcessProxy.h"
     28#include <WebCore/MediaConstraintsImpl.h>
     29#include <WebCore/MockRealtimeMediaSourceCenter.h>
     30#include <WebCore/RealtimeMediaSource.h>
     31
     32using namespace WebCore;
    2533
    2634namespace WebKit {
    … …  
    3543    for (auto& request : m_pendingUserMediaRequests.values())
    3644        request->invalidate();
    37 
    3845    m_pendingUserMediaRequests.clear();
     46
     47    for (auto& request : m_pendingDeviceRequests.values())
     48        request->invalidate();
     49    m_pendingDeviceRequests.clear();
    3950}
    4051
    … …  
    4657}
    4758
    48 void UserMediaPermissionRequestManagerProxy::didReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed, const String& audioDeviceUID, const String& videoDeviceUID)
     59Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID)
     60{
     61    Ref<UserMediaPermissionRequestProxy> request = UserMediaPermissionRequestProxy::create(*this, userMediaID, Vector<String>(), Vector<String>());
     62    m_pendingUserMediaRequests.add(userMediaID, request.ptr());
     63    return request;
     64}
     65
     66#if ENABLE(MEDIA_STREAM)
     67static uint64_t toWebCore(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason reason)
     68{
     69    switch (reason) {
     70    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints:
     71        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::NoConstraints);
     72        break;
     73    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled:
     74        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::UserMediaDisabled);
     75        break;
     76    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoCaptureDevices:
     77        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::NoCaptureDevices);
     78        break;
     79    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::InvalidConstraint:
     80        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::InvalidConstraint);
     81        break;
     82    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::HardwareError:
     83        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::HardwareError);
     84        break;
     85    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::PermissionDenied:
     86        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::PermissionDenied);
     87        break;
     88    case UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::OtherFailure:
     89        return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::OtherFailure);
     90        break;
     91    }
     92   
     93    ASSERT_NOT_REACHED();
     94    return static_cast<uint64_t>(UserMediaRequest::MediaAccessDenialReason::OtherFailure);
     95}
     96#endif
     97
     98void UserMediaPermissionRequestManagerProxy::userMediaAccessWasDenied(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason reason)
    4999{
    50100    if (!m_page.isValid())
    … …  
    54104        return;
    55105
    56 #if ENABLE(MEDIA_STREAM)
    57     m_page.process().send(Messages::WebPage::DidReceiveUserMediaPermissionDecision(userMediaID, allowed, audioDeviceUID, videoDeviceUID), m_page.pageID());
    58 #else
    59     UNUSED_PARAM(allowed);
    60 #endif
    61 }
    62 
    63 Ref<UserMediaPermissionCheckProxy> UserMediaPermissionRequestManagerProxy::createUserMediaPermissionCheck(uint64_t userMediaID)
    64 {
    65     Ref<UserMediaPermissionCheckProxy> request = UserMediaPermissionCheckProxy::create(*this, userMediaID);
     106    denyRequest(userMediaID, reason, "");
     107}
     108
     109void UserMediaPermissionRequestManagerProxy::denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason reason, const String& invalidConstraint)
     110{
     111    ASSERT(m_page.isValid());
     112
     113#if ENABLE(MEDIA_STREAM)
     114    m_page.process().send(Messages::WebPage::UserMediaAccessWasDenied(userMediaID, toWebCore(reason), invalidConstraint), m_page.pageID());
     115#else
     116    UNUSED_PARAM(reason);
     117    UNUSED_PARAM(invalidConstraint);
     118#endif
     119}
     120
     121void UserMediaPermissionRequestManagerProxy::userMediaAccessWasGranted(uint64_t userMediaID, const String& audioDeviceUID, const String& videoDeviceUID)
     122{
     123    if (!m_page.isValid())
     124        return;
     125
     126    if (!m_pendingUserMediaRequests.take(userMediaID))
     127        return;
     128
     129#if ENABLE(MEDIA_STREAM)
     130    m_page.process().send(Messages::WebPage::UserMediaAccessWasGranted(userMediaID, audioDeviceUID, videoDeviceUID), m_page.pageID());
     131#else
     132    UNUSED_PARAM(audioDeviceUID);
     133    UNUSED_PARAM(videoDeviceUID);
     134#endif
     135}
     136
     137void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const WebCore::MediaConstraintsData& audioConstraintsData, const WebCore::MediaConstraintsData& videoConstraintsData)
     138{
     139#if ENABLE(MEDIA_STREAM)
     140    RealtimeMediaSourceCenter::InvalidConstraintsHandler invalidHandler = [this, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier](const String& invalidConstraint) {
     141        if (!m_page.isValid())
     142            return;
     143
     144        denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::InvalidConstraint, invalidConstraint);
     145    };
     146
     147    RealtimeMediaSourceCenter::ValidConstraintsHandler validHandler = [this, userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier](const Vector<RefPtr<RealtimeMediaSource>>&& audioTracks, const Vector<RefPtr<RealtimeMediaSource>>&& videoTracks) {
     148        if (!m_page.isValid())
     149            return;
     150
     151        Vector<String> videoDeviceUIDs;
     152        Vector<String> audioDeviceUIDs;
     153        for (auto& audioTrack : audioTracks)
     154            audioDeviceUIDs.append(audioTrack->persistentID());
     155        for (auto& videoTrack : videoTracks)
     156            videoDeviceUIDs.append(videoTrack->persistentID());
     157
     158        if (videoDeviceUIDs.isEmpty() && audioDeviceUIDs.isEmpty()) {
     159            denyRequest(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::NoConstraints, "");
     160            return;
     161        }
     162
     163        auto userMediaOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(userMediaDocumentOriginIdentifier));
     164        auto topLevelOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(topLevelDocumentOriginIdentifier));
     165        auto request = createRequest(userMediaID, audioDeviceUIDs, videoDeviceUIDs);
     166
     167        if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get())) {
     168            m_pendingUserMediaRequests.take(userMediaID);
     169            request->deny(UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
     170        }
     171    };
     172
     173    auto audioConstraints = MediaConstraintsImpl::create(audioConstraintsData);
     174    auto videoConstraints = MediaConstraintsImpl::create(videoConstraintsData);
     175
     176    syncWithWebCorePrefs();
     177    RealtimeMediaSourceCenter::singleton().validateRequestConstraints(validHandler, invalidHandler, audioConstraints, videoConstraints);
     178#else
     179    UNUSED_PARAM(userMediaID);
     180    UNUSED_PARAM(frameID);
     181    UNUSED_PARAM(userMediaDocumentOriginIdentifier);
     182    UNUSED_PARAM(topLevelDocumentOriginIdentifier);
     183    UNUSED_PARAM(audioConstraintsData);
     184    UNUSED_PARAM(videoConstraintsData);
     185#endif
     186}
     187
     188void UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier)
     189{
     190#if ENABLE(MEDIA_STREAM)
     191    auto request = UserMediaPermissionCheckProxy::create(*this, userMediaID);
    66192    m_pendingDeviceRequests.add(userMediaID, request.ptr());
    67     return request;
    68 }
    69 
    70 void UserMediaPermissionRequestManagerProxy::didCompleteUserMediaPermissionCheck(uint64_t userMediaID, const String& mediaDeviceIdentifierHashSalt, bool allowed)
     193
     194    auto userMediaOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(userMediaDocumentOriginIdentifier));
     195    auto topLevelOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(topLevelDocumentOriginIdentifier));
     196
     197    if (!m_page.uiClient().checkUserMediaPermissionForOrigin(m_page, *m_page.process().webFrame(frameID), *userMediaOrigin.get(), *topLevelOrigin.get(), request.get())) {
     198        m_pendingDeviceRequests.take(userMediaID);
     199        m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration(userMediaID, Vector<WebCore::CaptureDevice>(), emptyString(), false), m_page.pageID());
     200    }
     201#else
     202    UNUSED_PARAM(userMediaID);
     203    UNUSED_PARAM(frameID);
     204    UNUSED_PARAM(userMediaDocumentOriginIdentifier);
     205    UNUSED_PARAM(topLevelDocumentOriginIdentifier);
     206#endif
     207}
     208
     209void UserMediaPermissionRequestManagerProxy::didCompleteUserMediaPermissionCheck(uint64_t userMediaID, const String& deviceIdentifierHashSalt, bool originHasPersistentAccess)
    71210{
    72211    if (!m_page.isValid())
    … …  
    77216
    78217#if ENABLE(MEDIA_STREAM)
    79     m_page.process().send(Messages::WebPage::DidCompleteUserMediaPermissionCheck(userMediaID, mediaDeviceIdentifierHashSalt, allowed), m_page.pageID());
    80 #else
    81     UNUSED_PARAM(allowed);
     218    syncWithWebCorePrefs();
     219    auto deviceInfo = RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
     220    m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration(userMediaID, deviceInfo, deviceIdentifierHashSalt, originHasPersistentAccess), m_page.pageID());
     221#else
     222    UNUSED_PARAM(deviceIdentifierHashSalt);
     223    UNUSED_PARAM(originHasPersistentAccess);
     224#endif
     225}
     226
     227void UserMediaPermissionRequestManagerProxy::syncWithWebCorePrefs() const
     228{
     229#if ENABLE(MEDIA_STREAM)
     230    // Enable/disable the mock capture devices for the UI process as per the WebCore preferences. Note that
     231    // this is a noop if the preference hasn't changed since the last time this was called.
     232    bool mockDevicesEnabled = m_page.preferences().mockCaptureDevicesEnabled();
     233    WebCore::MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled(mockDevicesEnabled);
    82234#endif
    83235}

  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestManagerProxy.h

    r197114 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2223#include "UserMediaPermissionCheckProxy.h"
    2324#include "UserMediaPermissionRequestProxy.h"
     25#include <WebCore/UserMediaRequest.h>
    2426#include <wtf/HashMap.h>
     27
     28namespace WebCore {
     29class CaptureDevice;
     30struct MediaConstraintsData;
     31};
    2532
    2633namespace WebKit {
    … …  
    3441    void invalidateRequests();
    3542
    36     Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
    37     void didReceiveUserMediaPermissionDecision(uint64_t, bool allow, const String& audioDeviceUID, const String& videoDeviceUID);
     43    void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const WebCore::MediaConstraintsData& audioConstraintsData, const WebCore::MediaConstraintsData& videoConstraintsData);
    3844
     45    void userMediaAccessWasGranted(uint64_t, const String& audioDeviceUID, const String& videoDeviceUID);
     46    void userMediaAccessWasDenied(uint64_t, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason);
    3947
    40     Ref<UserMediaPermissionCheckProxy> createUserMediaPermissionCheck(uint64_t userMediaID);
     48    void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier);
     49
    4150    void didCompleteUserMediaPermissionCheck(uint64_t, const String&, bool allow);
    4251
    4352private:
     53    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
     54    Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID);
     55    void denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason, const String& invalidConstraint);
     56    Ref<UserMediaPermissionCheckProxy> createUserMediaPermissionCheck(uint64_t userMediaID);
     57    void syncWithWebCorePrefs() const;
     58
    4459    HashMap<uint64_t, RefPtr<UserMediaPermissionRequestProxy>> m_pendingUserMediaRequests;
    4560    HashMap<uint64_t, RefPtr<UserMediaPermissionCheckProxy>> m_pendingDeviceRequests;
     61
    4662    WebPageProxy& m_page;
    4763};

  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.cpp

    r205929 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    4041        return;
    4142
    42     m_manager->didReceiveUserMediaPermissionDecision(m_userMediaID, true, audioDeviceUID, videoDeviceUID);
    43     m_manager = nullptr;
     43    m_manager->userMediaAccessWasGranted(m_userMediaID, audioDeviceUID, videoDeviceUID);
     44    invalidate();
    4445}
    4546
    46 void UserMediaPermissionRequestProxy::deny()
     47void UserMediaPermissionRequestProxy::deny(UserMediaAccessDenialReason reason)
    4748{
    4849    ASSERT(m_manager);
    … …  
    5051        return;
    5152
    52     m_manager->didReceiveUserMediaPermissionDecision(m_userMediaID, false, emptyString(), emptyString());
    53     m_manager = nullptr;
     53    m_manager->userMediaAccessWasDenied(m_userMediaID, reason);
     54    invalidate();
    5455}
    5556

  • trunk/Source/WebKit2/UIProcess/UserMediaPermissionRequestProxy.h

    r197114 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2122
    2223#include "APIObject.h"
    23 #include <WebCore/RealtimeMediaSource.h>
     24#include <WebCore/UserMediaRequest.h>
    2425#include <wtf/Vector.h>
    2526#include <wtf/text/WTFString.h>
    … …  
    3738
    3839    void allow(const String& videoDeviceUID, const String& audioDeviceUID);
    39     void deny();
     40
     41    enum class UserMediaAccessDenialReason { NoConstraints, UserMediaDisabled, NoCaptureDevices, InvalidConstraint, HardwareError, PermissionDenied, OtherFailure };
     42    void deny(UserMediaAccessDenialReason);
    4043
    4144    void invalidate();

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r207445 r207463  
    179179#endif
    180180
     181#if ENABLE(MEDIA_STREAM)
     182#include <WebCore/MediaConstraintsImpl.h>
     183#endif
     184
    181185// This controls what strategy we use for mouse wheel coalescing.
    182186#define MERGE_WHEEL_EVENTS 1
    … …  
    56315635}
    56325636
    5633 void WebPageProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs)
     5637void WebPageProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const WebCore::MediaConstraintsData& audioConstraintsData, const WebCore::MediaConstraintsData& videoConstraintsData)
    56345638{
    56355639#if ENABLE(MEDIA_STREAM)
    5636     WebFrameProxy* frame = m_process->webFrame(frameID);
    5637     MESSAGE_CHECK(frame);
    5638 
    5639     RefPtr<API::SecurityOrigin> userMediaOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(userMediaDocumentOriginIdentifier));
    5640     RefPtr<API::SecurityOrigin> topLevelOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(topLevelDocumentOriginIdentifier));
    5641     RefPtr<UserMediaPermissionRequestProxy> request = m_userMediaPermissionRequestManager.createRequest(userMediaID, audioDeviceUIDs, videoDeviceUIDs);
    5642 
    5643     if (!m_uiClient->decidePolicyForUserMediaPermissionRequest(*this, *frame, *userMediaOrigin.get(), *topLevelOrigin.get(), *request.get()))
    5644         request->deny();
     5640    MESSAGE_CHECK(m_process->webFrame(frameID));
     5641
     5642    m_userMediaPermissionRequestManager.requestUserMediaPermissionForFrame(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier, audioConstraintsData, videoConstraintsData);
    56455643#else
    56465644    UNUSED_PARAM(userMediaID);
    … …  
    56485646    UNUSED_PARAM(userMediaDocumentOriginIdentifier);
    56495647    UNUSED_PARAM(topLevelDocumentOriginIdentifier);
    5650     UNUSED_PARAM(audioDeviceUIDs);
    5651     UNUSED_PARAM(videoDeviceUIDs);
    5652 #endif
    5653 }
    5654 
    5655 void WebPageProxy::checkUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier)
     5648    UNUSED_PARAM(audioConstraintsData);
     5649    UNUSED_PARAM(videoConstraintsData);
     5650#endif
     5651}
     5652
     5653void WebPageProxy::enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier)
    56565654{
    56575655#if ENABLE(MEDIA_STREAM)
    … …  
    56595657    MESSAGE_CHECK(frame);
    56605658
    5661     RefPtr<UserMediaPermissionCheckProxy> request = m_userMediaPermissionRequestManager.createUserMediaPermissionCheck(userMediaID);
    5662     RefPtr<API::SecurityOrigin> userMediaOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(userMediaDocumentOriginIdentifier));
    5663     RefPtr<API::SecurityOrigin> topLevelOrigin = API::SecurityOrigin::create(SecurityOrigin::createFromDatabaseIdentifier(topLevelDocumentOriginIdentifier));
    5664     if (!m_uiClient->checkUserMediaPermissionForOrigin(*this, *frame, *userMediaOrigin.get(), *topLevelOrigin.get(), *request.get()))
    5665         request->setUserMediaAccessInfo(emptyString(), false);
     5659    m_userMediaPermissionRequestManager.enumerateMediaDevicesForFrame(userMediaID, frameID, userMediaDocumentOriginIdentifier, topLevelDocumentOriginIdentifier);
    56665660#else
    56675661    UNUSED_PARAM(userMediaID);
    … …  
    56715665#endif
    56725666}
     5667
    56735668
    56745669void WebPageProxy::requestNotificationPermission(uint64_t requestID, const String& originString)

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r207424 r207463  
    157157struct ExceptionDetails;
    158158struct FileChooserSettings;
     159struct MediaConstraintsData;
    159160struct SecurityOriginData;
    160161struct TextAlternativeWithRange;
    … …  
    12501251    void requestGeolocationPermissionForFrame(uint64_t geolocationID, uint64_t frameID, String originIdentifier);
    12511252
    1252     void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const Vector<String>& audioDeviceUIDs, const Vector<String>& videoDeviceUIDs);
    1253     void checkUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier);
     1253    void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, const WebCore::MediaConstraintsData& audioConstraints, const WebCore::MediaConstraintsData& videoConstraints);
     1254    void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier);
    12541255
    12551256    void runModal();

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.messages.in

    r207424 r207463  
    272272#if ENABLE(MEDIA_STREAM)
    273273    # MediaSteam messages
    274     RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, Vector<String> audioDeviceUIDs, Vector<String> videoDeviceUIDs)
    275     CheckUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier)
     274    RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier, struct WebCore::MediaConstraintsData audioConstraintsData, struct WebCore::MediaConstraintsData videoConstraintsData)
     275    EnumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, String userMediaDocumentOriginIdentifier, String topLevelDocumentOriginIdentifier)
    276276#endif
    277277

  • trunk/Source/WebKit2/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp

    r197114 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2223#if ENABLE(MEDIA_STREAM)
    2324
    24 #include "WebCoreArgumentCoders.h"
    2525#include "WebFrame.h"
    2626#include "WebPage.h"
    2727#include "WebPageProxyMessages.h"
     28#include <WebCore/CaptureDevice.h>
    2829#include <WebCore/Document.h>
    2930#include <WebCore/Frame.h>
    … …  
    3435
    3536namespace WebKit {
     37
     38using namespace WebCore;
    3639
    3740static uint64_t generateRequestID()
    … …  
    4649}
    4750
     51UserMediaPermissionRequestManager::~UserMediaPermissionRequestManager()
     52{
     53}
     54
    4855void UserMediaPermissionRequestManager::startUserMediaRequest(UserMediaRequest& request)
    4956{
    50     Document* document = downcast<Document>(request.scriptExecutionContext());
     57    Document* document = request.document();
    5158    Frame* frame = document ? document->frame() : nullptr;
    5259
    5360    if (!frame) {
    54         request.userMediaAccessDenied();
     61        request.deny(UserMediaRequest::OtherFailure, emptyString());
    5562        return;
    5663    }
    … …  
    6572    SecurityOrigin* topLevelDocumentOrigin = request.topLevelDocumentOrigin();
    6673    String topLevelDocumentOriginString = topLevelDocumentOrigin ? topLevelDocumentOrigin->databaseIdentifier() : emptyString();
    67     m_page.send(Messages::WebPageProxy::RequestUserMediaPermissionForFrame(requestID, webFrame->frameID(), request.userMediaDocumentOrigin()->databaseIdentifier(), topLevelDocumentOriginString, request.audioDeviceUIDs(), request.videoDeviceUIDs()));
     74    m_page.send(Messages::WebPageProxy::RequestUserMediaPermissionForFrame(requestID, webFrame->frameID(), request.userMediaDocumentOrigin()->databaseIdentifier(), topLevelDocumentOriginString, request.audioConstraints().data(), request.videoConstraints().data()));
    6875}
    6976
    … …  
    7683}
    7784
    78 void UserMediaPermissionRequestManager::didReceiveUserMediaPermissionDecision(uint64_t requestID, bool allowed, const String& audioDeviceUID, const String& videoDeviceUID)
     85void UserMediaPermissionRequestManager::userMediaAccessWasGranted(uint64_t requestID, const String& audioDeviceUID, const String& videoDeviceUID)
    7986{
    80     RefPtr<UserMediaRequest> request = m_idToUserMediaRequestMap.take(requestID);
     87    auto request = m_idToUserMediaRequestMap.take(requestID);
    8188    if (!request)
    8289        return;
    8390    m_userMediaRequestToIDMap.remove(request);
    8491
    85     if (allowed)
    86         request->userMediaAccessGranted(audioDeviceUID, videoDeviceUID);
    87     else
    88         request->userMediaAccessDenied();
     92    request->allow(audioDeviceUID, videoDeviceUID);
    8993}
    9094
    91 void UserMediaPermissionRequestManager::startUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck& request)
     95void UserMediaPermissionRequestManager::userMediaAccessWasDenied(uint64_t requestID, WebCore::UserMediaRequest::MediaAccessDenialReason reason, const String& invalidConstraint)
    9296{
    93     Document* document = downcast<Document>(request.scriptExecutionContext());
    94     Frame* frame = document ? document->frame() : nullptr;
     97    auto request = m_idToUserMediaRequestMap.take(requestID);
     98    if (!request)
     99        return;
     100    m_userMediaRequestToIDMap.remove(request);
     101
     102    request->deny(reason, invalidConstraint);
     103}
     104
     105void UserMediaPermissionRequestManager::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
     106{
     107    auto* document = downcast<Document>(request.scriptExecutionContext());
     108    auto* frame = document ? document->frame() : nullptr;
    95109
    96110    if (!frame) {
    97         request.setUserMediaAccessInfo(emptyString(), false);
     111        request.setDeviceInfo(Vector<CaptureDevice>(), emptyString(), false);
    98112        return;
    99113    }
    100114
    101115    uint64_t requestID = generateRequestID();
    102     m_idToUserMediaPermissionCheckMap.add(requestID, &request);
    103     m_userMediaPermissionCheckToIDMap.add(&request, requestID);
     116    m_idToMediaDevicesEnumerationRequestMap.add(requestID, &request);
     117    m_mediaDevicesEnumerationRequestToIDMap.add(&request, requestID);
    104118
    105119    WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
    … …  
    108122    SecurityOrigin* topLevelDocumentOrigin = request.topLevelDocumentOrigin();
    109123    String topLevelDocumentOriginString = topLevelDocumentOrigin ? topLevelDocumentOrigin->databaseIdentifier() : emptyString();
    110     m_page.send(Messages::WebPageProxy::CheckUserMediaPermissionForFrame(requestID, webFrame->frameID(), request.userMediaDocumentOrigin()->databaseIdentifier(), topLevelDocumentOriginString));
     124    m_page.send(Messages::WebPageProxy::EnumerateMediaDevicesForFrame(requestID, webFrame->frameID(), request.userMediaDocumentOrigin()->databaseIdentifier(), topLevelDocumentOriginString));
    111125}
    112126
    113 void UserMediaPermissionRequestManager::cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck& request)
     127void UserMediaPermissionRequestManager::cancelMediaDevicesEnumeration(WebCore::MediaDevicesEnumerationRequest& request)
    114128{
    115     uint64_t requestID = m_userMediaPermissionCheckToIDMap.take(&request);
     129    uint64_t requestID = m_mediaDevicesEnumerationRequestToIDMap.take(&request);
    116130    if (!requestID)
    117131        return;
    118     m_idToUserMediaPermissionCheckMap.remove(requestID);
     132    m_idToMediaDevicesEnumerationRequestMap.remove(requestID);
    119133}
    120134
    121 void UserMediaPermissionRequestManager::didCompleteUserMediaPermissionCheck(uint64_t requestID, const String& mediaDeviceIdentifierHashSalt, bool allowed)
     135void UserMediaPermissionRequestManager::didCompleteMediaDeviceEnumeration(uint64_t requestID, const Vector<CaptureDevice>& deviceList, const String& mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
    122136{
    123     RefPtr<UserMediaPermissionCheck> request = m_idToUserMediaPermissionCheckMap.take(requestID);
     137    RefPtr<MediaDevicesEnumerationRequest> request = m_idToMediaDevicesEnumerationRequestMap.take(requestID);
    124138    if (!request)
    125139        return;
    126     m_userMediaPermissionCheckToIDMap.remove(request);
     140    m_mediaDevicesEnumerationRequestToIDMap.remove(request);
    127141   
    128     request->setUserMediaAccessInfo(mediaDeviceIdentifierHashSalt, allowed);
     142    request->setDeviceInfo(deviceList, mediaDeviceIdentifierHashSalt, hasPersistentAccess);
    129143}
    130144

  • trunk/Source/WebKit2/WebProcess/MediaStream/UserMediaPermissionRequestManager.h

    r197114 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    2223#if ENABLE(MEDIA_STREAM)
    2324
    24 #include <WebCore/UserMediaPermissionCheck.h>
     25#include <WebCore/MediaConstraints.h>
     26#include <WebCore/MediaDevicesEnumerationRequest.h>
     27#include <WebCore/UserMediaClient.h>
    2528#include <WebCore/UserMediaRequest.h>
    2629#include <wtf/HashMap.h>
    … …  
    3538public:
    3639    explicit UserMediaPermissionRequestManager(WebPage&);
     40    ~UserMediaPermissionRequestManager();
    3741
    3842    void startUserMediaRequest(WebCore::UserMediaRequest&);
    3943    void cancelUserMediaRequest(WebCore::UserMediaRequest&);
    40     void didReceiveUserMediaPermissionDecision(uint64_t requestID, bool allowed, const String& audioDeviceUID, const String& videoDeviceUID);
     44    void userMediaAccessWasGranted(uint64_t, const String& audioDeviceUID, const String& videoDeviceUID);
     45    void userMediaAccessWasDenied(uint64_t, WebCore::UserMediaRequest::MediaAccessDenialReason, const String&);
    4146
    42     void startUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck&);
    43     void cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck&);
    44     void didCompleteUserMediaPermissionCheck(uint64_t requestID, const String&, bool allowed);
     47    void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&);
     48    void cancelMediaDevicesEnumeration(WebCore::MediaDevicesEnumerationRequest&);
     49    void didCompleteMediaDeviceEnumeration(uint64_t, const Vector<WebCore::CaptureDevice>& deviceList, const String& deviceIdentifierHashSalt, bool originHasPersistentAccess);
    4550
    4651private:
    … …  
    5055    HashMap<RefPtr<WebCore::UserMediaRequest>, uint64_t> m_userMediaRequestToIDMap;
    5156
    52     HashMap<uint64_t, RefPtr<WebCore::UserMediaPermissionCheck>> m_idToUserMediaPermissionCheckMap;
    53     HashMap<RefPtr<WebCore::UserMediaPermissionCheck>, uint64_t> m_userMediaPermissionCheckToIDMap;
     57    HashMap<uint64_t, RefPtr<WebCore::MediaDevicesEnumerationRequest>> m_idToMediaDevicesEnumerationRequestMap;
     58    HashMap<RefPtr<WebCore::MediaDevicesEnumerationRequest>, uint64_t> m_mediaDevicesEnumerationRequestToIDMap;
    5459};
    5560

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebUserMediaClient.cpp

    r193944 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    5051}
    5152
    52 void WebUserMediaClient::checkUserMediaPermission(WebCore::UserMediaPermissionCheck& request)
     53void WebUserMediaClient::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
    5354{
    54     m_page.userMediaPermissionRequestManager().startUserMediaPermissionCheck(request);
     55    m_page.userMediaPermissionRequestManager().enumerateMediaDevices(request);
    5556}
    5657
    57 void WebUserMediaClient::cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck& request)
     58void WebUserMediaClient::cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest& request)
    5859{
    59     m_page.userMediaPermissionRequestManager().cancelUserMediaPermissionCheck(request);
     60    m_page.userMediaPermissionRequestManager().cancelMediaDevicesEnumeration(request);
    6061}
    6162

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebUserMediaClient.h

    r204466 r207463  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
     3 * Copyright (C) 2016 Apple Inc. All rights reserved.
    34 *
    45 *  This library is free software; you can redistribute it and/or
    … …  
    3132public:
    3233    WebUserMediaClient(WebPage&);
     34    ~WebUserMediaClient() { }
    3335
    3436private:
    … …  
    3840    void cancelUserMediaAccessRequest(WebCore::UserMediaRequest&) override;
    3941
    40     void checkUserMediaPermission(WebCore::UserMediaPermissionCheck&) override;
    41     void cancelUserMediaPermissionCheck(WebCore::UserMediaPermissionCheck&) override;
     42    void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&) final;
     43    void cancelMediaDevicesEnumerationRequest(WebCore::MediaDevicesEnumerationRequest&) final;
    4244
    4345    WebPage& m_page;

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

    r207443 r207463  
    36823682
    36833683#if ENABLE(MEDIA_STREAM)
    3684 void WebPage::didReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed, const String& audioDeviceUID, const String& videoDeviceUID)
    3685 {
    3686     m_userMediaPermissionRequestManager.didReceiveUserMediaPermissionDecision(userMediaID, allowed, audioDeviceUID, videoDeviceUID);
    3687 }
    3688 
    3689 void WebPage::didCompleteUserMediaPermissionCheck(uint64_t userMediaID, const String& mediaDeviceIdentifierHashSalt, bool allowed)
    3690 {
    3691     m_userMediaPermissionRequestManager.didCompleteUserMediaPermissionCheck(userMediaID, mediaDeviceIdentifierHashSalt, allowed);
     3684void WebPage::userMediaAccessWasGranted(uint64_t userMediaID, const String& audioDeviceUID, const String& videoDeviceUID)
     3685{
     3686    m_userMediaPermissionRequestManager.userMediaAccessWasGranted(userMediaID, audioDeviceUID, videoDeviceUID);
     3687}
     3688
     3689void WebPage::userMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
     3690{
     3691    m_userMediaPermissionRequestManager.userMediaAccessWasDenied(userMediaID, static_cast<UserMediaRequest::MediaAccessDenialReason>(reason), invalidConstraint);
     3692}
     3693
     3694void WebPage::didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vector<CaptureDevice>& devices, const String& deviceIdentifierHashSalt, bool originHasPersistentAccess)
     3695{
     3696    m_userMediaPermissionRequestManager.didCompleteMediaDeviceEnumeration(userMediaID, devices, deviceIdentifierHashSalt, originHasPersistentAccess);
    36923697}
    36933698#endif

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h

    r207443 r207463  
    11601160
    11611161#if ENABLE(MEDIA_STREAM)
    1162     void didReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed, const String& audioDeviceUID, const String& videoDeviceUID);
    1163     void didCompleteUserMediaPermissionCheck(uint64_t userMediaID, const String&, bool allowed);
     1162    void userMediaAccessWasGranted(uint64_t userMediaID, const String& audioDeviceUID, const String& videoDeviceUID);
     1163    void userMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint);
     1164
     1165    void didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vector<WebCore::CaptureDevice>& devices, const String& deviceIdentifierHashSalt, bool originHasPersistentAccess);
    11641166#endif
    11651167

  • trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in

    r207424 r207463  
    289289#if ENABLE(MEDIA_STREAM)
    290290    # MediaSteam
    291     DidReceiveUserMediaPermissionDecision(uint64_t userMediaID, bool allowed, String audioDeviceUID, String videoDeviceUID)
    292     DidCompleteUserMediaPermissionCheck(uint64_t userMediaID, String mediaDeviceIdentifierHashSalt, bool allowed)
     291    UserMediaAccessWasGranted(uint64_t userMediaID, String audioDeviceUID, String videoDeviceUID)
     292    UserMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
     293    DidCompleteMediaDeviceEnumeration(uint64_t userMediaID, Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
    293294#endif
    294295

  • trunk/Tools/ChangeLog

    r207447 r207463  
     12016-10-18  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Resolve constraints and enumerate devices in the UI process
     4        https://bugs.webkit.org/show_bug.cgi?id=162147
     5        <rdar://problem/28803569>
     6
     7        Reviewed by Darin Adler.
     8
     9        * WebKitTestRunner/TestController.cpp:
     10        (WTR::TestController::resetPreferencesToConsistentValues): Enable mock capture devices.
     11        (WTR::TestController::decidePolicyForUserMediaPermissionRequestIfPossible): Update for API changes.
     12
    1132016-10-17  Megan Gardner  <megan_gardner@apple.com>
    214

  • trunk/Tools/WebKitTestRunner/TestController.cpp

    r207305 r207463  
    687687    WKCookieManagerDeleteAllCookies(WKContextGetCookieManager(m_context.get()));
    688688
     689    WKPreferencesSetMockCaptureDevicesEnabled(preferences, true);
     690
    689691    platformResetPreferencesToConsistentValues();
    690692}
    … …  
    19571959            persistentPermission = settings->persistentPermission();
    19581960
     1961        if (!m_isUserMediaPermissionAllowed && !persistentPermission) {
     1962            WKUserMediaPermissionRequestDeny(request, kWKPermissionDenied);
     1963            continue;
     1964        }
     1965
    19591966        WKRetainPtr<WKArrayRef> audioDeviceUIDs = WKUserMediaPermissionRequestAudioDeviceUIDs(request);
    19601967        WKRetainPtr<WKArrayRef> videoDeviceUIDs = WKUserMediaPermissionRequestVideoDeviceUIDs(request);
    19611968
    1962         if ((m_isUserMediaPermissionAllowed || persistentPermission) && (WKArrayGetSize(videoDeviceUIDs.get()) || WKArrayGetSize(audioDeviceUIDs.get()))) {
    1963             WKRetainPtr<WKStringRef> videoDeviceUID;
    1964             if (WKArrayGetSize(videoDeviceUIDs.get()))
    1965                 videoDeviceUID = reinterpret_cast<WKStringRef>(WKArrayGetItemAtIndex(videoDeviceUIDs.get(), 0));
    1966             else
    1967                 videoDeviceUID = WKStringCreateWithUTF8CString("");
    1968 
    1969             WKRetainPtr<WKStringRef> audioDeviceUID;
    1970             if (WKArrayGetSize(audioDeviceUIDs.get()))
    1971                 audioDeviceUID = reinterpret_cast<WKStringRef>(WKArrayGetItemAtIndex(audioDeviceUIDs.get(), 0));
    1972             else
    1973                 audioDeviceUID = WKStringCreateWithUTF8CString("");
    1974 
    1975             WKUserMediaPermissionRequestAllow(request, audioDeviceUID.get(), videoDeviceUID.get());
    1976 
    1977         } else
    1978             WKUserMediaPermissionRequestDeny(request);
     1969        if (!WKArrayGetSize(videoDeviceUIDs.get()) && !WKArrayGetSize(audioDeviceUIDs.get())) {
     1970            WKUserMediaPermissionRequestDeny(request, kWKNoConstraints);
     1971            continue;
     1972        }
     1973
     1974        WKRetainPtr<WKStringRef> videoDeviceUID;
     1975        if (WKArrayGetSize(videoDeviceUIDs.get()))
     1976            videoDeviceUID = reinterpret_cast<WKStringRef>(WKArrayGetItemAtIndex(videoDeviceUIDs.get(), 0));
     1977        else
     1978            videoDeviceUID = WKStringCreateWithUTF8CString("");
     1979
     1980        WKRetainPtr<WKStringRef> audioDeviceUID;
     1981        if (WKArrayGetSize(audioDeviceUIDs.get()))
     1982            audioDeviceUID = reinterpret_cast<WKStringRef>(WKArrayGetItemAtIndex(audioDeviceUIDs.get(), 0));
     1983        else
     1984            audioDeviceUID = WKStringCreateWithUTF8CString("");
     1985
     1986        WKUserMediaPermissionRequestAllow(request, audioDeviceUID.get(), videoDeviceUID.get());
    19791987    }
    19801988    m_userMediaPermissionRequests.clear();
Note: See TracChangeset for help on using the changeset viewer.