Changeset 226160 in webkit


Ignore:
Timestamp:
Dec 19, 2017 5:08:40 PM (6 years ago)
Author:
eric.carlson@apple.com
Message:

[MediaStream] Clean up RealtimeMediaSource interfaces
​https://bugs.webkit.org/show_bug.cgi?id=180934
<rdar://problem/36108648>

Reviewed by Youenn Fablet.

Source/WebCore:

No new tests, updated http/tests/media/media-stream/disconnected-frame.html.

Wrap video and audio constraints in a struct instead of passing both around as separate
parameters. Cleanup up the interface to RealTimeMediaSourceCenter.

  • Modules/mediastream/MediaDevices.cpp:

(WebCore::MediaDevices::getUserMedia const):

  • Modules/mediastream/MediaDevicesRequest.cpp:

(WebCore::MediaDevicesRequest::start):

  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::create):
(WebCore::UserMediaRequest::UserMediaRequest):
(WebCore::UserMediaRequest::start):
(WebCore::UserMediaRequest::allow):
(WebCore::UserMediaRequest::contextDestroyed):

  • Modules/mediastream/UserMediaRequest.h:

(WebCore::UserMediaRequest::request const):

  • WebCore.xcodeproj/project.pbxproj:
  • platform/mediastream/CaptureDevice.h:

(WebCore::CaptureDevice::persistentId const):
(WebCore::CaptureDevice::label const):
(WebCore::CaptureDevice::groupId const):
(WebCore::CaptureDevice::type const):
(WebCore::CaptureDevice::setPersistentId): Deleted.
(WebCore::CaptureDevice::setLabel): Deleted.
(WebCore::CaptureDevice::setGroupId): Deleted.
(WebCore::CaptureDevice::setType): Deleted.

  • platform/mediastream/CaptureDeviceManager.cpp:

(CaptureDeviceManager::getAudioSourcesInfo): Deleted.
(CaptureDeviceManager::getVideoSourcesInfo): Deleted.
(CaptureDeviceManager::deviceWithUID): Deleted.

  • platform/mediastream/CaptureDeviceManager.h:

(WebCore::CaptureDeviceManager::captureDeviceWithPersistentID):
(WebCore::CaptureDeviceManager::refreshCaptureDevices):

  • platform/mediastream/MediaStreamRequest.h: Copied from Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDevice.mm.

(WebCore::MediaStreamRequest::encode const):
(WebCore::MediaStreamRequest::decode):

  • platform/mediastream/RealtimeMediaSourceCenter.cpp:

(WebCore::RealtimeMediaSourceCenter::createMediaStream):
(WebCore::RealtimeMediaSourceCenter::getMediaStreamDevices):
(WebCore::RealtimeMediaSourceCenter::validateRequestConstraints):
(WebCore::RealtimeMediaSourceCenter::captureDeviceWithPersistentID):

  • platform/mediastream/RealtimeMediaSourceCenter.h:
  • platform/mediastream/RealtimeMediaSourceSettings.h:
  • platform/mediastream/ios/AVAudioSessionCaptureDevice.mm:

(WebCore::AVAudioSessionCaptureDevice::AVAudioSessionCaptureDevice):

  • platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h:
  • platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:

(WebCore::AVAudioSessionCaptureDeviceManager::captureDevices):
(WebCore::AVAudioSessionCaptureDeviceManager::captureDeviceWithPersistentID):

  • platform/mediastream/mac/AVCaptureDeviceManager.h:
  • platform/mediastream/mac/AVCaptureDeviceManager.mm:

(WebCore::AVCaptureDeviceManager::captureDevicesInternal):
(WebCore::AVCaptureDeviceManager::captureDevices):
(WebCore::AVCaptureDeviceManager::refreshAVCaptureDevicesOfType):
(WebCore::AVCaptureDeviceManager::refreshCaptureDevices):
(WebCore::AVCaptureDeviceManager::deviceDisconnected):
(WebCore::AVCaptureDeviceManager::getAudioSourcesInfo): Deleted.
(WebCore::AVCaptureDeviceManager::getVideoSourcesInfo): Deleted.

  • platform/mediastream/mac/CoreAudioCaptureDevice.cpp:

(WebCore::CoreAudioCaptureDevice::CoreAudioCaptureDevice):

  • platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp:

(WebCore::CoreAudioCaptureDeviceManager::captureDevices):
(WebCore::CoreAudioCaptureDeviceManager::captureDeviceWithPersistentID):
(WebCore::CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices):

  • platform/mediastream/mac/CoreAudioCaptureDeviceManager.h:
  • platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
  • platform/mock/MockRealtimeAudioSource.cpp:

(WebCore::MockRealtimeAudioSource::startProducingData):
(WebCore::MockRealtimeAudioSource::createMuted): Deleted.

  • platform/mock/MockRealtimeAudioSource.h:
  • platform/mock/MockRealtimeMediaSource.cpp:

(WebCore::deviceMap):
(WebCore::MockRealtimeMediaSource::captureDeviceWithPersistentID):
(WebCore::MockRealtimeMediaSource::audioDevices):
(WebCore::MockRealtimeMediaSource::videoDevices):
(WebCore::MockRealtimeMediaSource::MockRealtimeMediaSource):

  • platform/mock/MockRealtimeMediaSource.h:

(WebCore::MockRealtimeMediaSource::device const):
(WebCore::MockRealtimeMediaSource::deviceIndex): Deleted.

  • platform/mock/MockRealtimeMediaSourceCenter.h:
  • platform/mock/MockRealtimeVideoSource.cpp:

(WebCore::MockRealtimeVideoSource::MockRealtimeVideoSource):
(WebCore::MockRealtimeVideoSource::initializeCapabilities):
(WebCore::MockRealtimeVideoSource::generateFrame):
(WebCore::MockRealtimeVideoSource::createMuted): Deleted.

  • platform/mock/MockRealtimeVideoSource.h:

Source/WebKit:

  • Shared/WebCoreArgumentCoders.h: Update CaptureDevice encoder.
  • UIProcess/UserMediaPermissionRequestManagerProxy.cpp:

(WebKit::UserMediaPermissionRequestManagerProxy::createPermissionRequest): Renamed from createRequest.
(WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame): Update for
API change.
(WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame): Filter the
vector returned by getMediaStreamDevices.
(WebKit::UserMediaPermissionRequestManagerProxy::createRequest): Deleted.

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

(WebKit::UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy): Update for API change.
(WebKit::UserMediaPermissionRequestProxy::allow): Ditto.

  • UIProcess/UserMediaPermissionRequestProxy.h:

(WebKit::UserMediaPermissionRequestProxy::create):
(WebKit::UserMediaPermissionRequestProxy::requestType const):

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::requestUserMediaPermissionForFrame): Ditto.

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

(WebKit::UserMediaPermissionRequestManager::startUserMediaRequest): m_blockedRequests -> m_blockedUserMediaRequests.
(WebKit::UserMediaPermissionRequestManager::sendUserMediaRequest): Ditto.
(WebKit::UserMediaPermissionRequestManager::mediaCanStart): Ditto.
(WebKit::UserMediaPermissionRequestManager::removeMediaRequestFromMaps): Ditto.

  • WebProcess/MediaStream/UserMediaPermissionRequestManager.h:

LayoutTests:

  • http/tests/media/media-stream/disconnected-frame-expected.txt:
  • http/tests/media/media-stream/disconnected-frame.html:
Location:
trunk
Files:
1 added
42 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r226159 r226160  
     12017-12-19  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Clean up RealtimeMediaSource interfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=180934
     5        <rdar://problem/36108648>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * http/tests/media/media-stream/disconnected-frame-expected.txt:
     10        * http/tests/media/media-stream/disconnected-frame.html:
     11
    1122017-12-19  Matt Lewis  <jlewis3@apple.com>
    213

  • trunk/LayoutTests/http/tests/media/media-stream/disconnected-frame-expected.txt

    r225577 r226160  
    44
    55
    6 PASS No callbacks invoked
     6PASS Promise rejected as expected.
    77PASS successfullyParsed is true
    88

  • trunk/LayoutTests/http/tests/media/media-stream/disconnected-frame.html

    r225577 r226160  
    2222    iframeNavigator.mediaDevices.getUserMedia(options)
    2323        .then(stream => {
    24             testFailed('Success callback invoked unexpectedly');
     24            testFailed('Promise resolved unexpectedly.');
    2525            finishJSTest();
    2626        })
    2727        .catch(err => {
    28             testFailed('Error callback invoked unexpectedly');
     28            testPassed('Promise rejected as expected.');
    2929            finishJSTest();
    3030        });
    3131
    3232    setTimeout(function() {
    33         testPassed('No callbacks invoked');
     33        testFailed('Timeout: promise resolve and reject functions not called.');
    3434        finishJSTest();
    3535    }, 100);

  • trunk/Source/WebCore/ChangeLog

    r226156 r226160  
     12017-12-19  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Clean up RealtimeMediaSource interfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=180934
     5        <rdar://problem/36108648>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        No new tests, updated http/tests/media/media-stream/disconnected-frame.html.
     10       
     11        Wrap video and audio constraints in a struct instead of passing both around as separate
     12        parameters. Cleanup up the interface to RealTimeMediaSourceCenter.
     13
     14        * Modules/mediastream/MediaDevices.cpp:
     15        (WebCore::MediaDevices::getUserMedia const):
     16        * Modules/mediastream/MediaDevicesRequest.cpp:
     17        (WebCore::MediaDevicesRequest::start):
     18        * Modules/mediastream/UserMediaRequest.cpp:
     19        (WebCore::UserMediaRequest::create):
     20        (WebCore::UserMediaRequest::UserMediaRequest):
     21        (WebCore::UserMediaRequest::start):
     22        (WebCore::UserMediaRequest::allow):
     23        (WebCore::UserMediaRequest::contextDestroyed):
     24        * Modules/mediastream/UserMediaRequest.h:
     25        (WebCore::UserMediaRequest::request const):
     26        * WebCore.xcodeproj/project.pbxproj:
     27        * platform/mediastream/CaptureDevice.h:
     28        (WebCore::CaptureDevice::persistentId const):
     29        (WebCore::CaptureDevice::label const):
     30        (WebCore::CaptureDevice::groupId const):
     31        (WebCore::CaptureDevice::type const):
     32        (WebCore::CaptureDevice::setPersistentId): Deleted.
     33        (WebCore::CaptureDevice::setLabel): Deleted.
     34        (WebCore::CaptureDevice::setGroupId): Deleted.
     35        (WebCore::CaptureDevice::setType): Deleted.
     36        * platform/mediastream/CaptureDeviceManager.cpp:
     37        (CaptureDeviceManager::getAudioSourcesInfo): Deleted.
     38        (CaptureDeviceManager::getVideoSourcesInfo): Deleted.
     39        (CaptureDeviceManager::deviceWithUID): Deleted.
     40        * platform/mediastream/CaptureDeviceManager.h:
     41        (WebCore::CaptureDeviceManager::captureDeviceWithPersistentID):
     42        (WebCore::CaptureDeviceManager::refreshCaptureDevices):
     43        * platform/mediastream/MediaStreamRequest.h: Copied from Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDevice.mm.
     44        (WebCore::MediaStreamRequest::encode const):
     45        (WebCore::MediaStreamRequest::decode):
     46        * platform/mediastream/RealtimeMediaSourceCenter.cpp:
     47        (WebCore::RealtimeMediaSourceCenter::createMediaStream):
     48        (WebCore::RealtimeMediaSourceCenter::getMediaStreamDevices):
     49        (WebCore::RealtimeMediaSourceCenter::validateRequestConstraints):
     50        (WebCore::RealtimeMediaSourceCenter::captureDeviceWithPersistentID):
     51        * platform/mediastream/RealtimeMediaSourceCenter.h:
     52        * platform/mediastream/RealtimeMediaSourceSettings.h:
     53        * platform/mediastream/ios/AVAudioSessionCaptureDevice.mm:
     54        (WebCore::AVAudioSessionCaptureDevice::AVAudioSessionCaptureDevice):
     55        * platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h:
     56        * platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:
     57        (WebCore::AVAudioSessionCaptureDeviceManager::captureDevices):
     58        (WebCore::AVAudioSessionCaptureDeviceManager::captureDeviceWithPersistentID):
     59        * platform/mediastream/mac/AVCaptureDeviceManager.h:
     60        * platform/mediastream/mac/AVCaptureDeviceManager.mm:
     61        (WebCore::AVCaptureDeviceManager::captureDevicesInternal):
     62        (WebCore::AVCaptureDeviceManager::captureDevices):
     63        (WebCore::AVCaptureDeviceManager::refreshAVCaptureDevicesOfType):
     64        (WebCore::AVCaptureDeviceManager::refreshCaptureDevices):
     65        (WebCore::AVCaptureDeviceManager::deviceDisconnected):
     66        (WebCore::AVCaptureDeviceManager::getAudioSourcesInfo): Deleted.
     67        (WebCore::AVCaptureDeviceManager::getVideoSourcesInfo): Deleted.
     68        * platform/mediastream/mac/CoreAudioCaptureDevice.cpp:
     69        (WebCore::CoreAudioCaptureDevice::CoreAudioCaptureDevice):
     70        * platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp:
     71        (WebCore::CoreAudioCaptureDeviceManager::captureDevices):
     72        (WebCore::CoreAudioCaptureDeviceManager::captureDeviceWithPersistentID):
     73        (WebCore::CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices):
     74        * platform/mediastream/mac/CoreAudioCaptureDeviceManager.h:
     75        * platform/mediastream/mac/RealtimeMediaSourceCenterMac.cpp:
     76        * platform/mock/MockRealtimeAudioSource.cpp:
     77        (WebCore::MockRealtimeAudioSource::startProducingData):
     78        (WebCore::MockRealtimeAudioSource::createMuted): Deleted.
     79        * platform/mock/MockRealtimeAudioSource.h:
     80        * platform/mock/MockRealtimeMediaSource.cpp:
     81        (WebCore::deviceMap):
     82        (WebCore::MockRealtimeMediaSource::captureDeviceWithPersistentID):
     83        (WebCore::MockRealtimeMediaSource::audioDevices):
     84        (WebCore::MockRealtimeMediaSource::videoDevices):
     85        (WebCore::MockRealtimeMediaSource::MockRealtimeMediaSource):
     86        * platform/mock/MockRealtimeMediaSource.h:
     87        (WebCore::MockRealtimeMediaSource::device const):
     88        (WebCore::MockRealtimeMediaSource::deviceIndex): Deleted.
     89        * platform/mock/MockRealtimeMediaSourceCenter.h:
     90        * platform/mock/MockRealtimeVideoSource.cpp:
     91        (WebCore::MockRealtimeVideoSource::MockRealtimeVideoSource):
     92        (WebCore::MockRealtimeVideoSource::initializeCapabilities):
     93        (WebCore::MockRealtimeVideoSource::generateFrame):
     94        (WebCore::MockRealtimeVideoSource::createMuted): Deleted.
     95        * platform/mock/MockRealtimeVideoSource.h:
     96
    1972017-12-19  Ryosuke Niwa  <rniwa@webkit.org>
    298

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

    r222422 r226160  
    101101    if (videoConstraints.isValid)
    102102        videoConstraints.setDefaultVideoConstraints();
    103     return UserMediaRequest::start(*document, WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(promise));
     103
     104    auto request = UserMediaRequest::create(*document, { MediaStreamRequest::Type::UserMedia, WTFMove(audioConstraints), WTFMove(videoConstraints) }, WTFMove(promise));
     105    if (request)
     106        request->start();
     107
     108    return { };
    104109}
    105110

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

    r220210 r226160  
    132132
    133133            auto groupId = RealtimeMediaSourceCenter::singleton().hashStringWithSalt(deviceInfo.groupId(), deviceIdentifierHashSalt);
    134             auto deviceType = deviceInfo.type() == CaptureDevice::DeviceType::Audio ? MediaDeviceInfo::Kind::Audioinput : MediaDeviceInfo::Kind::Videoinput;
     134            auto deviceType = deviceInfo.type() == CaptureDevice::DeviceType::Microphone ? MediaDeviceInfo::Kind::Audioinput : MediaDeviceInfo::Kind::Videoinput;
    135135            devices.append(MediaDeviceInfo::create(scriptExecutionContext(), label, id, groupId, deviceType));
    136136        }

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

    r225963 r226160  
    5555namespace WebCore {
    5656
    57 ExceptionOr<void> UserMediaRequest::start(Document& document, MediaConstraints&& audioConstraints, MediaConstraints&& videoConstraints, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
    58 {
    59     auto* userMedia = UserMediaController::from(document.page());
    60     if (!userMedia)
    61         return Exception { NotSupportedError }; // FIXME: Why is it better to return an exception here instead of rejecting the promise as we do just below?
    62 
    63     if (!audioConstraints.isValid && !videoConstraints.isValid) {
    64         promise.reject(TypeError);
    65         return { };
    66     }
    67 
    68     adoptRef(*new UserMediaRequest(document, *userMedia, WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(promise)))->start();
    69     return { };
    70 }
    71 
    72 UserMediaRequest::UserMediaRequest(Document& document, UserMediaController& controller, MediaConstraints&& audioConstraints, MediaConstraints&& videoConstraints, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
     57RefPtr<UserMediaRequest> UserMediaRequest::create(Document& document, MediaStreamRequest&& request, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
     58{
     59    return adoptRef(*new UserMediaRequest(document, WTFMove(request), WTFMove(promise)));
     60}
     61
     62UserMediaRequest::UserMediaRequest(Document& document, MediaStreamRequest&& request, DOMPromiseDeferred<IDLInterface<MediaStream>>&& promise)
    7363    : ContextDestructionObserver(&document)
    74     , m_audioConstraints(WTFMove(audioConstraints))
    75     , m_videoConstraints(WTFMove(videoConstraints))
    76     , m_controller(&controller)
    7764    , m_promise(WTFMove(promise))
     65    , m_request(WTFMove(request))
    7866{
    7967}
    … …  
    140128static bool canCallGetUserMedia(Document& document, bool wantsAudio, bool wantsVideo, String& errorMessage)
    141129{
     130    ASSERT(wantsAudio || wantsVideo);
     131
    142132    bool requiresSecureConnection = DeprecatedGlobalSettings::mediaCaptureRequiresSecureConnection();
    143133    auto& documentLoader = *document.loader();
    … …  
    167157void UserMediaRequest::start()
    168158{
    169     if (!m_scriptExecutionContext || !m_controller) {
    170         deny(MediaAccessDenialReason::OtherFailure, emptyString());
    171         return;
    172     }
    173 
    174     Document& document = downcast<Document>(*m_scriptExecutionContext);
    175 
    176     // 10.2 - 6.3 Optionally, e.g., based on a previously-established user preference, for security reasons,
    177     // or due to platform limitations, jump to the step labeled Permission Failure below.
     159    ASSERT(m_scriptExecutionContext);
     160    if (!m_scriptExecutionContext) {
     161        deny(MediaAccessDenialReason::UserMediaDisabled, emptyString());
     162        return;
     163    }
     164
     165    // https://w3c.github.io/mediacapture-main/getusermedia.html#dom-mediadevices-getusermedia()
     166    // 1. Let constraints be the method's first argument.
     167    // 2. Let requestedMediaTypes be the set of media types in constraints with either a dictionary
     168    //    value or a value of "true".
     169    // 3. If requestedMediaTypes is the empty set, return a promise rejected with a TypeError. The word
     170    //    "optional" occurs in the WebIDL due to WebIDL rules, but the argument must be supplied in order
     171    //    for the call to succeed.
     172    if (!m_request.audioConstraints.isValid && !m_request.videoConstraints.isValid) {
     173        deny(MediaAccessDenialReason::NoConstraints, emptyString());
     174        return;
     175    }
     176
     177    // 4. If the current settings object's responsible document is NOT allowed to use the feature indicated by
     178    //    attribute name allowusermedia, return a promise rejected with a DOMException object whose name
     179    //    attribute has the value SecurityError.
     180    auto& document = downcast<Document>(*m_scriptExecutionContext);
     181    auto* controller = UserMediaController::from(document.page());
     182    if (!controller) {
     183        deny(MediaAccessDenialReason::UserMediaDisabled, emptyString());
     184        return;
     185    }
     186
     187    // 6.3 Optionally, e.g., based on a previously-established user preference, for security reasons,
     188    //     or due to platform limitations, jump to the step labeled Permission Failure below.
     189    // ...
     190    // 6.10 Permission Failure: Reject p with a new DOMException object whose name attribute has
     191    //      the value NotAllowedError.
    178192    String errorMessage;
    179     if (!canCallGetUserMedia(document, m_audioConstraints.isValid, m_videoConstraints.isValid, errorMessage)) {
     193    if (!canCallGetUserMedia(document, m_request.audioConstraints.isValid, m_request.videoConstraints.isValid, errorMessage)) {
    180194        deny(MediaAccessDenialReason::PermissionDenied, emptyString());
    181195        document.domWindow()->printErrorMessage(errorMessage);
    … …  
    183197    }
    184198
    185     m_controller->requestUserMediaAccess(*this);
     199    controller->requestUserMediaAccess(*this);
    186200}
    187201
    … …  
    189203{
    190204    RELEASE_LOG(MediaStream, "UserMediaRequest::allow %s %s", audioDevice ? audioDevice.persistentId().utf8().data() : "", videoDevice ? videoDevice.persistentId().utf8().data() : "");
    191     m_allowedAudioDevice = audioDevice;
    192     m_allowedVideoDevice = videoDevice;
    193205
    194206    auto callback = [this, protectedThis = makeRef(*this)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
    … …  
    211223    };
    212224
    213     m_audioConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
    214     m_videoConstraints.deviceIDHashSalt = WTFMove(deviceIdentifierHashSalt);
    215 
    216     RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), WTFMove(audioDevice), WTFMove(videoDevice), &m_audioConstraints, &m_videoConstraints);
     225    m_request.audioConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
     226    m_request.videoConstraints.deviceIDHashSalt = WTFMove(deviceIdentifierHashSalt);
     227
     228    RealtimeMediaSourceCenter::singleton().createMediaStream(WTFMove(callback), WTFMove(audioDevice), WTFMove(videoDevice), m_request);
    217229
    218230    if (!m_scriptExecutionContext)
    … …  
    265277void UserMediaRequest::contextDestroyed()
    266278{
    267     ContextDestructionObserver::contextDestroyed();
     279    if (!m_scriptExecutionContext)
     280        return;
     281
     282    auto& document = downcast<Document>(*m_scriptExecutionContext);
     283    auto* controller = UserMediaController::from(document.page());
     284
     285    m_pendingActivationMediaStream = nullptr;
     286    if (!controller)
     287        return;
     288
    268289    Ref<UserMediaRequest> protectedThis(*this);
    269     if (m_controller) {
    270         m_controller->cancelUserMediaAccessRequest(*this);
    271         m_controller = nullptr;
    272     }
    273     m_pendingActivationMediaStream = nullptr;
     290    controller->cancelUserMediaAccessRequest(*this);
    274291}
    275292
    … …  
    280297
    281298UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream(Ref<UserMediaRequest>&& request, Ref<MediaStream>&& stream)
    282     : m_request(WTFMove(request))
     299    : m_userMediaRequest(WTFMove(request))
    283300    , m_mediaStream(WTFMove(stream))
    284301{
    … …  
    295312{
    296313    if (m_mediaStream->privateStream().hasVideo() || m_mediaStream->privateStream().hasAudio())
    297         m_request->mediaStreamIsReady(m_mediaStream.copyRef());
     314        m_userMediaRequest->mediaStreamIsReady(m_mediaStream.copyRef());
    298315}
    299316

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

    r225828 r226160  
    4040#include "MediaConstraints.h"
    4141#include "MediaStreamPrivate.h"
     42#include "MediaStreamRequest.h"
    4243
    4344namespace WebCore {
    … …  
    4546class MediaStream;
    4647class SecurityOrigin;
    47 class UserMediaController;
    4848
    4949class UserMediaRequest : public RefCounted<UserMediaRequest>, private ContextDestructionObserver {
    5050public:
    51     static ExceptionOr<void> start(Document&, MediaConstraints&& audioConstraints, MediaConstraints&& videoConstraints, DOMPromiseDeferred<IDLInterface<MediaStream>>&&);
    52 
     51    static RefPtr<UserMediaRequest> create(Document&, MediaStreamRequest&&, DOMPromiseDeferred<IDLInterface<MediaStream>>&&);
    5352    virtual ~UserMediaRequest();
    5453
    … …  
    6463    const Vector<String>& videoDeviceUIDs() const { return m_videoDeviceUIDs; }
    6564
    66     const MediaConstraints& audioConstraints() const { return m_audioConstraints; }
    67     const MediaConstraints& videoConstraints() const { return m_videoConstraints; }
     65    const MediaConstraints& audioConstraints() const { return m_request.audioConstraints; }
     66    const MediaConstraints& videoConstraints() const { return m_request.videoConstraints; }
    6867
    6968    WEBCORE_EXPORT SecurityOrigin* userMediaDocumentOrigin() const;
    … …  
    7170    WEBCORE_EXPORT Document* document() const;
    7271
     72    const MediaStreamRequest& request() const { return m_request; }
     73
    7374private:
    74     UserMediaRequest(Document&, UserMediaController&, MediaConstraints&& audioConstraints, MediaConstraints&& videoConstraints, DOMPromiseDeferred<IDLInterface<MediaStream>>&&);
     75    UserMediaRequest(Document&, MediaStreamRequest&&, DOMPromiseDeferred<IDLInterface<MediaStream>>&&);
    7576
    7677    void contextDestroyed() final;
    … …  
    9192        void characteristicsChanged() final;
    9293
    93         Ref<UserMediaRequest> m_request;
     94        Ref<UserMediaRequest> m_userMediaRequest;
    9495        Ref<MediaStream> m_mediaStream;
    9596    };
    96 
    97     MediaConstraints m_audioConstraints;
    98     MediaConstraints m_videoConstraints;
    9997
    10098    Vector<String> m_videoDeviceUIDs;
    10199    Vector<String> m_audioDeviceUIDs;
    102100
    103     CaptureDevice m_allowedVideoDevice;
    104     CaptureDevice m_allowedAudioDevice;
    105 
    106     UserMediaController* m_controller;
    107101    DOMPromiseDeferred<IDLInterface<MediaStream>> m_promise;
    108     RefPtr<UserMediaRequest> m_protector;
    109102    RefPtr<PendingActivationMediaStream> m_pendingActivationMediaStream;
     103    MediaStreamRequest m_request;
    110104};
    111105

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

    r226127 r226160  
    170170                078E094717D16E1C00420AA1 /* RTCVoidRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 07221BB017CF0AD400848E51 /* RTCVoidRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    171171                078E094C17D1709600420AA1 /* MediaStreamAudioDestinationNode.h in Headers */ = {isa = PBXBuildFile; fileRef = 078E094917D1709600420AA1 /* MediaStreamAudioDestinationNode.h */; };
     172                078E3CC01FE1C73C00483C1D /* MediaStreamRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 078E3CBE1FE19F3000483C1D /* MediaStreamRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    172173                078E43DA1ABB6C7E001C2FA6 /* MediaPlaybackTargetPicker.h in Headers */ = {isa = PBXBuildFile; fileRef = 078E43D81ABB6C7E001C2FA6 /* MediaPlaybackTargetPicker.h */; settings = {ATTRIBUTES = (Private, ); }; };
    173174                078E43DD1ABB6F6F001C2FA6 /* MediaPlaybackTargetPickerMac.h in Headers */ = {isa = PBXBuildFile; fileRef = 078E43DB1ABB6F6F001C2FA6 /* MediaPlaybackTargetPickerMac.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    51755176                078E094917D1709600420AA1 /* MediaStreamAudioDestinationNode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamAudioDestinationNode.h; sourceTree = "<group>"; };
    51765177                078E094A17D1709600420AA1 /* MediaStreamAudioDestinationNode.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = MediaStreamAudioDestinationNode.idl; sourceTree = "<group>"; };
     5178                078E3CBE1FE19F3000483C1D /* MediaStreamRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaStreamRequest.h; sourceTree = "<group>"; };
    51775179                078E43D71ABB6C7E001C2FA6 /* MediaPlaybackTargetPicker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaPlaybackTargetPicker.cpp; sourceTree = "<group>"; };
    51785180                078E43D81ABB6C7E001C2FA6 /* MediaPlaybackTargetPicker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaPlaybackTargetPicker.h; sourceTree = "<group>"; };
    … …  
    1471814720                                0711588F17DF633700EDFE2B /* MediaStreamPrivate.cpp */,
    1471914721                                07221B9D17CF0AD400848E51 /* MediaStreamPrivate.h */,
     14722                                078E3CBE1FE19F3000483C1D /* MediaStreamRequest.h */,
    1472014723                                07FFDE66181AED420072D409 /* MediaStreamTrackPrivate.cpp */,
    1472114724                                07FFDE67181AED420072D409 /* MediaStreamTrackPrivate.h */,
    … …  
    2692926932                                4129C9971F59B963009D7403 /* FetchBodySource.h in Headers */,
    2693026933                                41D129DB1F3D143800D15E47 /* FetchHeaders.h in Headers */,
     26934                                4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */,
    2693126935                                517A53581F5889E800DCDC0A /* FetchLoaderClient.h in Headers */,
    2693226936                                41AD753A1CEF6BD100A31486 /* FetchOptions.h in Headers */,
    … …  
    2739027394                                A5B81CAE1FAA44620037D1E6 /* InspectorIndexedDBAgent.h in Headers */,
    2739127395                                20D629271253690B00081543 /* InspectorInstrumentation.h in Headers */,
    27392                                 4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */,
    2739327396                                A5840E1D187B74D500843B10 /* InspectorInstrumentationCookie.h in Headers */,
    2739427397                                A5B81CAF1FAA44620037D1E6 /* InspectorLayerTreeAgent.h in Headers */,
    … …  
    2842128424                                078E093717D16B2C00420AA1 /* MediaStreamPrivate.h in Headers */,
    2842228425                                078E091717D14D1C00420AA1 /* MediaStreamRegistry.h in Headers */,
     28426                                078E3CC01FE1C73C00483C1D /* MediaStreamRequest.h in Headers */,
    2842328427                                078E091817D14D1C00420AA1 /* MediaStreamTrack.h in Headers */,
    2842428428                                078E091917D14D1C00420AA1 /* MediaStreamTrackEvent.h in Headers */,

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

    r225395 r226160  
    3232class CaptureDevice {
    3333public:
    34     enum class DeviceType { Unknown, Audio, Video };
     34    enum class DeviceType { Unknown, Microphone, Camera };
    3535
    3636    CaptureDevice(const String& persistentId, DeviceType type, const String& label, const String& groupId = emptyString())
    … …  
    4545
    4646    const String& persistentId() const { return m_persistentId; }
    47     void setPersistentId(const String& id) { m_persistentId = id; }
    4847
    4948    const String& label() const { return m_label; }
    50     void setLabel(const String& label) { m_label = label; }
    5149
    5250    const String& groupId() const { return m_groupId; }
    53     void setGroupId(const String& id) { m_groupId = id; }
    5451
    5552    DeviceType type() const { return m_type; }
    56     void setType(DeviceType type) { m_type = type; }
    5753
    5854    bool enabled() const { return m_enabled; }

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

    r225395 r226160  
    4141CaptureDeviceManager::~CaptureDeviceManager() = default;
    4242
    43 Vector<CaptureDevice> CaptureDeviceManager::getAudioSourcesInfo()
    44 {
    45     Vector<CaptureDevice> sourcesInfo;
    46     for (auto& captureDevice : captureDevices()) {
    47         if (!captureDevice.enabled() || captureDevice.type() != CaptureDevice::DeviceType::Audio)
    48             continue;
    49 
    50         sourcesInfo.append(captureDevice);
    51     }
    52     LOG(Media, "CaptureDeviceManager::getSourcesInfo(%p), found %zu active devices", this, sourcesInfo.size());
    53     return sourcesInfo;
    54 }
    55 
    56 Vector<CaptureDevice> CaptureDeviceManager::getVideoSourcesInfo()
    57 {
    58     Vector<CaptureDevice> sourcesInfo;
    59     for (auto& captureDevice : captureDevices()) {
    60         if (!captureDevice.enabled() || captureDevice.type() != CaptureDevice::DeviceType::Video)
    61             continue;
    62 
    63         sourcesInfo.append(captureDevice);
    64     }
    65     LOG(Media, "CaptureDeviceManager::getSourcesInfo(%p), found %zu active devices", this, sourcesInfo.size());
    66     return sourcesInfo;
    67 }
    68 
    6943CaptureDevice CaptureDeviceManager::captureDeviceFromPersistentID(const String& captureDeviceID)
    7044{
    … …  
    7246        if (device.persistentId() == captureDeviceID)
    7347            return device;
    74     }
    75 
    76     return { };
    77 }
    78 
    79 CaptureDevice CaptureDeviceManager::deviceWithUID(const String& deviceUID, RealtimeMediaSource::Type type)
    80 {
    81     for (auto& captureDevice : captureDevices()) {
    82         CaptureDevice::DeviceType deviceType;
    83 
    84         switch (type) {
    85         case RealtimeMediaSource::Type::None:
    86             continue;
    87         case RealtimeMediaSource::Type::Audio:
    88             deviceType = CaptureDevice::DeviceType::Audio;
    89             break;
    90         case RealtimeMediaSource::Type::Video:
    91             deviceType = CaptureDevice::DeviceType::Video;
    92             break;
    93         }
    94 
    95         if (captureDevice.persistentId() != deviceUID || captureDevice.type() != deviceType)
    96             continue;
    97 
    98         if (!captureDevice.enabled())
    99             continue;
    100 
    101         return captureDevice;
    10248    }
    10349

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

    r225395 r226160  
    4040    virtual void removeCaptureDeviceChangedObserver(ObserverToken);
    4141
    42     virtual Vector<CaptureDevice>& captureDevices() = 0;
     42    virtual const Vector<CaptureDevice>& captureDevices() = 0;
     43    virtual std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&) { return std::nullopt; }
     44
    4345    virtual void refreshCaptureDevices() { }
    44     virtual Vector<CaptureDevice> getAudioSourcesInfo();
    45     virtual Vector<CaptureDevice> getVideoSourcesInfo();
    46     virtual CaptureDevice deviceWithUID(const String&, RealtimeMediaSource::Type);
    4746
    4847protected:

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

    r226159 r226160  
    2626#pragma once
    2727
    28 #if ENABLE(MEDIA_STREAM) && PLATFORM(IOS)
     28#if ENABLE(MEDIA_STREAM)
    2929
    30 #include "CaptureDeviceManager.h"
    31 #include <wtf/Forward.h>
    32 #include <wtf/HashSet.h>
    33 #include <wtf/RetainPtr.h>
    34 
    35 OBJC_CLASS WebAVAudioSessionAvailableInputsListener;
     30#include "MediaConstraints.h"
     31#include <wtf/EnumTraits.h>
    3632
    3733namespace WebCore {
    3834
    39 class AVAudioSessionCaptureDevice;
    40 class CaptureDevice;
     35struct MediaStreamRequest {
     36    enum class Type { UserMedia };
     37    Type type;
     38    MediaConstraints audioConstraints;
     39    MediaConstraints videoConstraints;
    4140
    42 class AVAudioSessionCaptureDeviceManager final : public CaptureDeviceManager {
    43     friend class NeverDestroyed<AVAudioSessionCaptureDeviceManager>;
    44 public:
    45     static AVAudioSessionCaptureDeviceManager& singleton();
     41    template<class Encoder>
     42    void encode(Encoder& encoder) const
     43    {
     44        encoder.encodeEnum(type);
     45        encoder << audioConstraints;
     46        encoder << videoConstraints;
     47    }
    4648
    47     Vector<CaptureDevice>& captureDevices() final;
     49    template <class Decoder> static std::optional<MediaStreamRequest> decode(Decoder& decoder)
     50    {
     51        MediaStreamRequest request;
     52        if (decoder.decodeEnum(request.type) && decoder.decode(request.audioConstraints) && decoder.decode(request.videoConstraints))
     53            return WTFMove(request);
    4854
    49     Vector<AVAudioSessionCaptureDevice>& audioSessionCaptureDevices();
    50     std::optional<AVAudioSessionCaptureDevice> audioSessionDeviceWithUID(const String&);
    51 
    52 private:
    53     AVAudioSessionCaptureDeviceManager() = default;
    54     ~AVAudioSessionCaptureDeviceManager();
    55 
    56     void refreshAudioCaptureDevices();
    57 
    58     std::optional<Vector<CaptureDevice>> m_devices;
    59     std::optional<Vector<AVAudioSessionCaptureDevice>> m_audioSessionCaptureDevices;
    60     RetainPtr<WebAVAudioSessionAvailableInputsListener> m_listener;
     55        return std::nullopt;
     56    }
    6157};
    6258
    6359} // namespace WebCore
    6460
    65 #endif // ENABLE(MEDIA_STREAM) && PLATFORM(IOS)
     61#else
     62
     63struct MediaStreamRequest {
     64    enum class Type { UserMedia };
     65    Type type;
     66};
     67
     68#endif // ENABLE(MEDIA_STREAM)
     69
     70namespace WTF {
     71
     72template<> struct EnumTraits<WebCore::MediaStreamRequest> {
     73    using values = EnumValues<
     74        WebCore::MediaStreamRequest::Type,
     75        WebCore::MediaStreamRequest::Type::UserMedia
     76    >;
     77};
     78
     79} // namespace WTF
     80
     81

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

    r225783 r226160  
    9393RealtimeMediaSourceCenter::~RealtimeMediaSourceCenter() = default;
    9494
    95 void RealtimeMediaSourceCenter::createMediaStream(NewMediaStreamHandler&& completionHandler, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaConstraints* audioConstraints, const MediaConstraints* videoConstraints)
     95void RealtimeMediaSourceCenter::createMediaStream(NewMediaStreamHandler&& completionHandler, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest& request)
    9696{
    9797    Vector<Ref<RealtimeMediaSource>> audioSources;
    … …  
    100100
    101101    if (audioDevice) {
    102         auto audioSource = audioFactory().createAudioCaptureSource(WTFMove(audioDevice), audioConstraints);
     102        auto audioSource = audioFactory().createAudioCaptureSource(WTFMove(audioDevice), &request.audioConstraints);
    103103        if (audioSource)
    104104            audioSources.append(audioSource.source());
    … …  
    114114
    115115    if (videoDevice) {
    116         auto videoSource = videoFactory().createVideoCaptureSource(WTFMove(videoDevice), videoConstraints);
     116        auto videoSource = videoFactory().createVideoCaptureSource(WTFMove(videoDevice), &request.videoConstraints);
    117117        if (videoSource)
    118118            videoSources.append(videoSource.source());
    … …  
    133133{
    134134    Vector<CaptureDevice> result;
    135 
    136     result.appendVector(audioCaptureDeviceManager().getAudioSourcesInfo());
    137     result.appendVector(videoCaptureDeviceManager().getVideoSourcesInfo());
     135    for (auto& device : audioCaptureDeviceManager().captureDevices()) {
     136        if (device.enabled())
     137            result.append(device);
     138    }
     139    for (auto& device : videoCaptureDeviceManager().captureDevices()) {
     140        if (device.enabled())
     141            result.append(device);
     142    }
    138143
    139144    return result;
    … …  
    219224}
    220225
    221 void RealtimeMediaSourceCenter::validateRequestConstraints(ValidConstraintsHandler&& validHandler, InvalidConstraintsHandler&& invalidHandler, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints, String&& deviceIdentifierHashSalt)
     226void RealtimeMediaSourceCenter::validateRequestConstraints(ValidConstraintsHandler&& validHandler, InvalidConstraintsHandler&& invalidHandler, const MediaStreamRequest& request, String&& deviceIdentifierHashSalt)
    222227{
    223228    struct DeviceInfo {
    … …  
    243248        String invalidConstraint;
    244249        CaptureSourceOrError sourceOrError;
    245         if (device.type() == CaptureDevice::DeviceType::Video && videoConstraints.isValid) {
    246             auto sourceOrError = videoFactory().createVideoCaptureSource(device, nullptr);
    247             if (sourceOrError && sourceOrError.captureSource->supportsConstraints(videoConstraints, invalidConstraint))
    248                 videoDeviceInfo.append({sourceOrError.captureSource->fitnessScore(), device});
    249         } else if (device.type() == CaptureDevice::DeviceType::Audio && audioConstraints.isValid) {
    250             auto sourceOrError = audioFactory().createAudioCaptureSource(device, nullptr);
    251             if (sourceOrError && sourceOrError.captureSource->supportsConstraints(audioConstraints, invalidConstraint))
    252                 audioDeviceInfo.append({sourceOrError.captureSource->fitnessScore(), device});
     250        switch (device.type()) {
     251        case CaptureDevice::DeviceType::Camera:
     252            if (request.type == MediaStreamRequest::Type::UserMedia && request.videoConstraints.isValid) {
     253                auto sourceOrError = videoFactory().createVideoCaptureSource(device, { });
     254                if (sourceOrError && sourceOrError.captureSource->supportsConstraints(request.videoConstraints, invalidConstraint))
     255                    videoDeviceInfo.append({sourceOrError.captureSource->fitnessScore(), device});
     256            }
     257            break;
     258        case CaptureDevice::DeviceType::Microphone:
     259            if (request.audioConstraints.isValid) {
     260                auto sourceOrError = audioFactory().createAudioCaptureSource(device, { });
     261                if (sourceOrError && sourceOrError.captureSource->supportsConstraints(request.audioConstraints, invalidConstraint))
     262                    audioDeviceInfo.append({sourceOrError.captureSource->fitnessScore(), device});
     263            }
     264            break;
     265        case CaptureDevice::DeviceType::Unknown:
     266            ASSERT_NOT_REACHED();
     267            break;
    253268        }
    254269
    … …  
    257272    }
    258273
    259     if ((audioConstraints.isValid && audioDeviceInfo.isEmpty()) || (videoConstraints.isValid && videoDeviceInfo.isEmpty())) {
     274    if ((request.audioConstraints.isValid && audioDeviceInfo.isEmpty()) || (request.videoConstraints.isValid && videoDeviceInfo.isEmpty())) {
    260275        invalidHandler(firstInvalidConstraint);
    261276        return;
    … …  
    286301}
    287302
     303std::optional<CaptureDevice> RealtimeMediaSourceCenter::captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& id)
     304{
     305    switch (type) {
     306    case CaptureDevice::DeviceType::Camera:
     307        return videoCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
     308        break;
     309    case CaptureDevice::DeviceType::Microphone:
     310        return audioCaptureDeviceManager().captureDeviceWithPersistentID(type, id);
     311        break;
     312    case CaptureDevice::DeviceType::Unknown:
     313        ASSERT_NOT_REACHED();
     314        break;
     315    }
     316
     317    return std::nullopt;
     318}
     319
    288320} // namespace WebCore
    289321

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

    r225828 r226160  
    3636
    3737#include "ExceptionOr.h"
     38#include "MediaStreamRequest.h"
    3839#include "RealtimeMediaSource.h"
    3940#include "RealtimeMediaSourceSupportedConstraints.h"
    … …  
    6162    using ValidConstraintsHandler = WTF::Function<void(Vector<CaptureDevice>&& audioDeviceUIDs, Vector<CaptureDevice>&& videoDeviceUIDs, String&&)>;
    6263    using InvalidConstraintsHandler = WTF::Function<void(const String& invalidConstraint)>;
    63     virtual void validateRequestConstraints(ValidConstraintsHandler&&, InvalidConstraintsHandler&&, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints, String&&);
     64    virtual void validateRequestConstraints(ValidConstraintsHandler&&, InvalidConstraintsHandler&&, const MediaStreamRequest&, String&&);
    6465
    6566    using NewMediaStreamHandler = WTF::Function<void(RefPtr<MediaStreamPrivate>&&)>;
    66     virtual void createMediaStream(NewMediaStreamHandler&&, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaConstraints* audioConstraints, const MediaConstraints* videoConstraints);
     67    virtual void createMediaStream(NewMediaStreamHandler&&, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, const MediaStreamRequest&);
    6768
    6869    WEBCORE_EXPORT virtual Vector<CaptureDevice> getMediaStreamDevices();
     70    WEBCORE_EXPORT std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
    6971   
    7072    const RealtimeMediaSourceSupportedConstraints& supportedConstraints() { return m_supportedConstraints; }

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

    r225313 r226160  
    3939class RealtimeMediaSourceSettings {
    4040public:
    41     enum SourceType { None, Camera, Microphone };
    4241    enum VideoFacingMode { Unknown, User, Environment, Left, Right };
    4342

  • trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDevice.mm

    r216155 r226160  
    4343
    4444AVAudioSessionCaptureDevice::AVAudioSessionCaptureDevice(AVAudioSessionPortDescription* portDescription, const String& persistentID, const String& label)
    45     : CaptureDevice(persistentID, CaptureDevice::DeviceType::Audio, label)
     45    : CaptureDevice(persistentID, CaptureDevice::DeviceType::Microphone, label)
    4646    , m_portDescription(portDescription)
    4747{

  • trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h

    r225028 r226160  
    4545    static AVAudioSessionCaptureDeviceManager& singleton();
    4646
    47     Vector<CaptureDevice>& captureDevices() final;
     47    const Vector<CaptureDevice>& captureDevices() final;
     48    std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
    4849
    4950    Vector<AVAudioSessionCaptureDevice>& audioSessionCaptureDevices();

  • trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm

    r219191 r226160  
    8585}
    8686
    87 Vector<CaptureDevice>& AVAudioSessionCaptureDeviceManager::captureDevices()
     87const Vector<CaptureDevice>& AVAudioSessionCaptureDeviceManager::captureDevices()
    8888{
    8989    if (!m_devices)
    9090        refreshAudioCaptureDevices();
    9191    return m_devices.value();
     92}
     93
     94std::optional<CaptureDevice> AVAudioSessionCaptureDeviceManager::captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& deviceID)
     95{
     96    ASSERT_UNUSED(type, type == CaptureDevice::DeviceType::Microphone);
     97    for (auto& device : captureDevices()) {
     98        if (device.persistentId() == deviceID)
     99            return device;
     100    }
     101    return std::nullopt;
    92102}
    93103

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

    r217251 r226160  
    4646    friend class NeverDestroyed<AVCaptureDeviceManager>;
    4747public:
    48     Vector<CaptureDevice>& captureDevices() final;
     48    const Vector<CaptureDevice>& captureDevices() final;
    4949
    5050    static AVCaptureDeviceManager& singleton();
    … …  
    5252    void deviceConnected();
    5353    void deviceDisconnected(AVCaptureDevice*);
    54 
    55     Vector<CaptureDevice> getAudioSourcesInfo() final;
    56     Vector<CaptureDevice> getVideoSourcesInfo() final;
    5754
    5855protected:
    … …  
    6562    void registerForDeviceNotifications();
    6663    void refreshAVCaptureDevicesOfType(CaptureDevice::DeviceType);
     64    Vector<CaptureDevice>& captureDevicesInternal();
    6765
    6866    RetainPtr<WebCoreAVCaptureDeviceManagerObserver> m_objcObserver;

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

    r225395 r226160  
    8888namespace WebCore {
    8989
    90 Vector<CaptureDevice>& AVCaptureDeviceManager::captureDevices()
     90
     91Vector<CaptureDevice>& AVCaptureDeviceManager::captureDevicesInternal()
    9192{
    9293    if (!isAvailable())
    … …  
    103104}
    104105
     106const Vector<CaptureDevice>& AVCaptureDeviceManager::captureDevices()
     107{
     108    return captureDevicesInternal();
     109}
     110
    105111inline static bool deviceIsAvailable(AVCaptureDeviceTypedef *device)
    106112{
    … …  
    118124void AVCaptureDeviceManager::refreshAVCaptureDevicesOfType(CaptureDevice::DeviceType type)
    119125{
    120     ASSERT(type == CaptureDevice::DeviceType::Video || type == CaptureDevice::DeviceType::Audio);
    121 
    122     NSString *platformType = (type == CaptureDevice::DeviceType::Video) ? AVMediaTypeVideo : AVMediaTypeAudio;
     126    ASSERT(type == CaptureDevice::DeviceType::Camera || type == CaptureDevice::DeviceType::Microphone);
     127
     128    NSString *platformType = (type == CaptureDevice::DeviceType::Camera) ? AVMediaTypeVideo : AVMediaTypeAudio;
    123129
    124130    for (AVCaptureDeviceTypedef *platformDevice in [getAVCaptureDeviceClass() devices]) {
    … …  
    140146void AVCaptureDeviceManager::refreshCaptureDevices()
    141147{
    142     refreshAVCaptureDevicesOfType(CaptureDevice::DeviceType::Video);
    143     refreshAVCaptureDevicesOfType(CaptureDevice::DeviceType::Audio);
     148    refreshAVCaptureDevicesOfType(CaptureDevice::DeviceType::Camera);
    144149}
    145150
    … …  
    166171}
    167172
    168 Vector<CaptureDevice> AVCaptureDeviceManager::getAudioSourcesInfo()
    169 {
    170     if (!isAvailable())
    171         return Vector<CaptureDevice>();
    172 
    173     return CaptureDeviceManager::getAudioSourcesInfo();
    174 }
    175 
    176 Vector<CaptureDevice> AVCaptureDeviceManager::getVideoSourcesInfo()
    177 {
    178     if (!isAvailable())
    179         return Vector<CaptureDevice>();
    180 
    181     return CaptureDeviceManager::getVideoSourcesInfo();
    182 }
    183 
    184173void AVCaptureDeviceManager::registerForDeviceNotifications()
    185174{
    … …  
    198187void AVCaptureDeviceManager::deviceDisconnected(AVCaptureDeviceTypedef* device)
    199188{
    200     Vector<CaptureDevice>& devices = captureDevices();
     189    auto& devices = captureDevicesInternal();
    201190
    202191    size_t count = devices.size();

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

    r223476 r226160  
    7777
    7878CoreAudioCaptureDevice::CoreAudioCaptureDevice(uint32_t deviceID, const String& persistentID, const String& label)
    79     : CaptureDevice(persistentID, CaptureDevice::DeviceType::Audio, label)
     79    : CaptureDevice(persistentID, CaptureDevice::DeviceType::Microphone, label)
    8080    , m_deviceID(deviceID)
    8181{

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

    r223476 r226160  
    3333#include <AudioUnit/AudioUnit.h>
    3434#include <CoreMedia/CMSync.h>
     35#include <wtf/Assertions.h>
    3536#include <wtf/NeverDestroyed.h>
    3637
    … …  
    4546}
    4647
    47 Vector<CaptureDevice>& CoreAudioCaptureDeviceManager::captureDevices()
     48const Vector<CaptureDevice>& CoreAudioCaptureDeviceManager::captureDevices()
    4849{
    4950    coreAudioCaptureDevices();
    5051    return m_devices;
     52}
     53
     54std::optional<CaptureDevice> CoreAudioCaptureDeviceManager::captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& deviceID)
     55{
     56    ASSERT_UNUSED(type, type == CaptureDevice::DeviceType::Microphone);
     57    for (auto& device : captureDevices()) {
     58        if (device.persistentId() == deviceID)
     59            return device;
     60    }
     61    return std::nullopt;
    5162}
    5263
    … …  
    141152
    142153    for (auto &device : m_coreAudioCaptureDevices) {
    143         CaptureDevice captureDevice(device.persistentId(), CaptureDevice::DeviceType::Audio, device.label());
     154        CaptureDevice captureDevice(device.persistentId(), CaptureDevice::DeviceType::Microphone, device.label());
    144155        captureDevice.setEnabled(device.enabled());
    145156        m_devices.append(captureDevice);

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

    r225028 r226160  
    4444    static CoreAudioCaptureDeviceManager& singleton();
    4545
    46     Vector<CaptureDevice>& captureDevices() final;
     46    const Vector<CaptureDevice>& captureDevices() final;
     47    std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
    4748
    48     Vector<CoreAudioCaptureDevice>& coreAudioCaptureDevices();
    4949    std::optional<CoreAudioCaptureDevice> coreAudioDeviceWithUID(const String&);
    5050
    … …  
    5454   
    5555    static OSStatus devicesChanged(AudioObjectID, UInt32, const AudioObjectPropertyAddress*, void*);
     56    Vector<CoreAudioCaptureDevice>& coreAudioCaptureDevices();
    5657
    5758    void refreshAudioCaptureDevices();

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

    r225395 r226160  
    5050    CaptureSourceOrError createVideoCaptureSource(const CaptureDevice& device, const MediaConstraints* constraints) final
    5151    {
    52         return AVVideoCaptureSource::create(device.persistentId(), constraints);
     52        switch (device.type()) {
     53        case CaptureDevice::DeviceType::Camera:
     54            return AVVideoCaptureSource::create(device.persistentId(), constraints);
     55            break;
     56        case CaptureDevice::DeviceType::Microphone:
     57        case CaptureDevice::DeviceType::Unknown:
     58            ASSERT_NOT_REACHED();
     59            break;
     60        }
     61
     62        return { };
    5363    }
    5464

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

    r225395 r226160  
    6767#endif
    6868
    69 Ref<MockRealtimeAudioSource> MockRealtimeAudioSource::createMuted(const String& name)
    70 {
    71     auto source = adoptRef(*new MockRealtimeAudioSource(String { }, name));
    72     source->notifyMutedChange(true);
    73     return source;
    74 }
    75 
    7669static MockRealtimeAudioSourceFactory& mockAudioCaptureSourceFactory()
    7770{
    … …  
    126119
    127120    if (!sampleRate())
    128         setSampleRate(!deviceIndex() ? 44100 : 48000);
     121        setSampleRate(device() == MockRealtimeMediaSource::MockDevice::Microphone1 ? 44100 : 48000);
    129122
    130123    m_startTime = monotonicallyIncreasingTime();

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

    r222471 r226160  
    4343
    4444    static CaptureSourceOrError create(const String& deviceID, const String& name, const MediaConstraints*);
    45     static Ref<MockRealtimeAudioSource> createMuted(const String& name);
    4645
    4746    static AudioCaptureFactory& factory();

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

    r224338 r226160  
    4646namespace WebCore {
    4747
     48struct MockDeviceInfo {
     49    const char* id;
     50    CaptureDevice::DeviceType type;
     51    const char* name;
     52    MockRealtimeMediaSource::MockDevice device;
     53};
     54
     55static const HashMap<String, MockDeviceInfo>& deviceMap()
     56{
     57    static const auto infoMap = makeNeverDestroyed([] {
     58        static const MockDeviceInfo devices[] = {
     59            { "239c24b0-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Microphone, "Mock audio device 1", MockRealtimeMediaSource::MockDevice::Microphone1 },
     60            { "239c24b1-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Microphone, "Mock audio device 2", MockRealtimeMediaSource::MockDevice::Microphone2 },
     61
     62            { "239c24b2-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Camera, "Mock video device 1", MockRealtimeMediaSource::MockDevice::Camera1 },
     63            { "239c24b3-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Camera, "Mock video device 2", MockRealtimeMediaSource::MockDevice::Camera2 },
     64        };
     65
     66        HashMap<String, MockDeviceInfo> map;
     67        for (auto& info : devices)
     68            map.add(ASCIILiteral(info.id), info);
     69        return map;
     70    }());
     71
     72    return infoMap;
     73}
     74
     75std::optional<CaptureDevice> MockRealtimeMediaSource::captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& id)
     76{
     77    ASSERT(!id.isEmpty());
     78
     79    auto map = deviceMap();
     80    auto it = map.find(id);
     81    if (it != map.end() && it->value.type == type) {
     82        auto device = CaptureDevice(it->value.id, it->value.type, it->value.name);
     83        device.setEnabled(true);
     84        return WTFMove(device);
     85    }
     86
     87    return std::nullopt;
     88}
     89
    4890Vector<CaptureDevice>& MockRealtimeMediaSource::audioDevices()
    4991{
    … …  
    5193        Vector<CaptureDevice> vector;
    5294
    53         auto captureDevice = CaptureDevice("239c24b0-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Audio, "Mock audio device 1");
    54         captureDevice.setEnabled(true);
    55         vector.append(WTFMove(captureDevice));
     95        auto captureDevice = captureDeviceWithPersistentID(CaptureDevice::DeviceType::Microphone, ASCIILiteral("239c24b0-2b15-11e3-8224-0800200c9a66"));
     96        ASSERT(captureDevice);
     97        vector.append(WTFMove(captureDevice.value()));
    5698
    57         captureDevice = CaptureDevice("239c24b1-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Audio, "Mock audio device 2");
    58         captureDevice.setEnabled(true);
    59         vector.append(WTFMove(captureDevice));
     99        captureDevice = captureDeviceWithPersistentID(CaptureDevice::DeviceType::Microphone, ASCIILiteral("239c24b1-2b15-11e3-8224-0800200c9a66"));
     100        ASSERT(captureDevice);
     101        vector.append(WTFMove(captureDevice.value()));
    60102
    61103        return vector;
    … …  
    69111        Vector<CaptureDevice> vector;
    70112
    71         auto captureDevice = CaptureDevice("239c24b2-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Video, "Mock video device 1");
    72         captureDevice.setEnabled(true);
    73         vector.append(WTFMove(captureDevice));
     113        auto captureDevice = captureDeviceWithPersistentID(CaptureDevice::DeviceType::Camera, ASCIILiteral("239c24b2-2b15-11e3-8224-0800200c9a66"));
     114        ASSERT(captureDevice);
     115        vector.append(WTFMove(captureDevice.value()));
    74116
    75         captureDevice = CaptureDevice("239c24b3-2b15-11e3-8224-0800200c9a66", CaptureDevice::DeviceType::Video, "Mock video device 2");
    76         captureDevice.setEnabled(true);
    77         vector.append(WTFMove(captureDevice));
     117        captureDevice = captureDeviceWithPersistentID(CaptureDevice::DeviceType::Camera, ASCIILiteral("239c24b3-2b15-11e3-8224-0800200c9a66"));
     118        ASSERT(captureDevice);
     119        vector.append(WTFMove(captureDevice.value()));
    78120
    79121        return vector;
    … …  
    85127    : RealtimeMediaSource(id, type, name)
    86128{
    87     switch (type) {
    88     case RealtimeMediaSource::Type::Audio:
    89         m_deviceIndex = name == audioDevices()[0].label() ? 0 : 1;
    90         setPersistentID(String(audioDevices()[m_deviceIndex].persistentId()));
    91         return;
    92     case RealtimeMediaSource::Type::Video:
    93         m_deviceIndex = name == videoDevices()[0].label() ? 0 : 1;
    94         setPersistentID(String(videoDevices()[m_deviceIndex].persistentId()));
    95         return;
    96     case RealtimeMediaSource::Type::None:
    97         ASSERT_NOT_REACHED();
    98     }
     129    ASSERT(type != RealtimeMediaSource::Type::None);
     130
     131    auto map = deviceMap();
     132    auto it = map.find(id);
     133    ASSERT(it != map.end());
     134
     135    m_device = it->value.device;
     136    setPersistentID(String(id));
    99137}
    100138

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

    r223728 r226160  
    4646    static Vector<CaptureDevice>& videoDevices();
    4747
     48    static std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
     49
     50    enum class MockDevice { Invalid, Microphone1, Microphone2, Camera1, Camera2 };
     51
    4852protected:
    4953    MockRealtimeMediaSource(const String& id, Type, const String& name);
    … …  
    5862    RealtimeMediaSourceSupportedConstraints& supportedConstraints();
    5963
    60     unsigned deviceIndex() { return m_deviceIndex; }
     64    MockDevice device() const { return m_device; }
     65    MockDevice m_device { MockDevice::Invalid };
    6166
    6267private:
    … …  
    6772    RealtimeMediaSourceSupportedConstraints m_supportedConstraints;
    6873    std::unique_ptr<RealtimeMediaSourceCapabilities> m_capabilities;
    69     unsigned m_deviceIndex { 0 };
    7074};
    7175

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

    r225313 r226160  
    5353    CaptureDeviceManager& videoCaptureDeviceManager() final { return m_videoCaptureDeviceManager; }
    5454
     55    static std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&);
     56
    5557    class MockAudioCaptureDeviceManager final : public CaptureDeviceManager {
    5658    private:
    57         Vector<CaptureDevice>& captureDevices() final { return MockRealtimeMediaSource::audioDevices(); }
     59        const Vector<CaptureDevice>& captureDevices() final { return MockRealtimeMediaSource::audioDevices(); }
     60        std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& id) final { return MockRealtimeMediaSource::captureDeviceWithPersistentID(type, id); }
    5861    };
    5962    class MockVideoCaptureDeviceManager final : public CaptureDeviceManager {
    6063    private:
    61         Vector<CaptureDevice>& captureDevices() final { return MockRealtimeMediaSource::videoDevices(); }
     64        const Vector<CaptureDevice>& captureDevices() final { return MockRealtimeMediaSource::videoDevices(); }
     65        std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType type, const String& id) final { return MockRealtimeMediaSource::captureDeviceWithPersistentID(type, id); }
    6266    };
    6367

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

    r225395 r226160  
    5555    CaptureSourceOrError createVideoCaptureSource(const CaptureDevice& device, const MediaConstraints* constraints) final
    5656    {
    57         for (auto& mockDevice : MockRealtimeMediaSource::videoDevices()) {
    58             if (mockDevice.persistentId() == device.persistentId())
    59                 return MockRealtimeVideoSource::create(mockDevice.persistentId(), mockDevice.label(), constraints);
     57        ASSERT(MockRealtimeMediaSource::captureDeviceWithPersistentID(device.type(), device.persistentId()));
     58
     59        switch (device.type()) {
     60        case CaptureDevice::DeviceType::Camera:
     61            return MockRealtimeVideoSource::create(device.persistentId(), device.label(), constraints);
     62            break;
     63        case CaptureDevice::DeviceType::Microphone:
     64        case CaptureDevice::DeviceType::Unknown:
     65            ASSERT_NOT_REACHED();
     66            break;
    6067        }
     68
    6169        return { };
    6270    }
    … …  
    8391#endif
    8492
    85 Ref<MockRealtimeVideoSource> MockRealtimeVideoSource::createMuted(const String& name)
    86 {
    87     auto source = adoptRef(*new MockRealtimeVideoSource(String { }, name));
    88     source->notifyMutedChange(true);
    89     return source;
    90 }
    91 
    9293static MockRealtimeVideoSourceFactory& mockVideoCaptureSourceFactory()
    9394{
    … …  
    105106    , m_timer(RunLoop::current(), this, &MockRealtimeVideoSource::generateFrame)
    106107{
    107     setFrameRate(!deviceIndex() ? 30 : 15);
    108     setFacingMode(!deviceIndex() ? RealtimeMediaSourceSettings::User : RealtimeMediaSourceSettings::Environment);
     108    switch (device()) {
     109    case MockDevice::Camera1:
     110        setFrameRate(30);
     111        setFacingMode(RealtimeMediaSourceSettings::User);
     112        break;
     113    case MockDevice::Camera2:
     114        setFrameRate(15);
     115        setFacingMode(RealtimeMediaSourceSettings::Environment);
     116        break;
     117    case MockDevice::Microphone1:
     118    case MockDevice::Microphone2:
     119    case MockDevice::Invalid:
     120        ASSERT_NOT_REACHED();
     121        break;
     122    }
     123
    109124    m_dashWidths.reserveInitialCapacity(2);
    110125    m_dashWidths.uncheckedAppend(6);
    … …  
    162177void MockRealtimeVideoSource::initializeCapabilities(RealtimeMediaSourceCapabilities& capabilities)
    163178{
    164     if (!deviceIndex())
     179    if (device() == MockDevice::Camera1)
    165180        capabilities.addFacingMode(RealtimeMediaSourceSettings::User);
    166181    else
    167182        capabilities.addFacingMode(RealtimeMediaSourceSettings::Environment);
     183
    168184    capabilities.setWidth(CapabilityValueOrRange(320, 1920));
    169185    capabilities.setHeight(CapabilityValueOrRange(240, 1080));
    … …  
    387403    GraphicsContextStateSaver stateSaver(context);
    388404
    389     IntSize size = this->size();
     405    auto& size = this->size();
    390406    FloatRect frameRect(FloatPoint(), size);
    391     context.fillRect(FloatRect(FloatPoint(), size), !deviceIndex() ? Color::black : Color::darkGray);
     407
     408    Color fillColor;
     409    switch (device()) {
     410    case MockDevice::Camera1:
     411        fillColor = Color::black;
     412        break;
     413    case MockDevice::Camera2:
     414        fillColor = Color::darkGray;
     415        break;
     416    case MockDevice::Microphone1:
     417    case MockDevice::Microphone2:
     418    case MockDevice::Invalid:
     419        ASSERT_NOT_REACHED();
     420        break;
     421    }
     422
     423    context.fillRect(FloatRect(FloatPoint(), size), fillColor);
    392424
    393425    if (!muted()) {

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

    r225313 r226160  
    4848
    4949    static CaptureSourceOrError create(const String& deviceID, const String& name, const MediaConstraints*);
    50     static Ref<MockRealtimeVideoSource> createMuted(const String& name);
    5150
    5251    static VideoCaptureFactory& factory();

  • trunk/Source/WebKit/ChangeLog

    r226150 r226160  
     12017-12-19  Eric Carlson  <eric.carlson@apple.com>
     2
     3        [MediaStream] Clean up RealtimeMediaSource interfaces
     4        https://bugs.webkit.org/show_bug.cgi?id=180934
     5        <rdar://problem/36108648>
     6
     7        Reviewed by Youenn Fablet.
     8
     9        * Shared/WebCoreArgumentCoders.h: Update CaptureDevice encoder.
     10
     11        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
     12        (WebKit::UserMediaPermissionRequestManagerProxy::createPermissionRequest): Renamed from createRequest.
     13        (WebKit::UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame): Update for
     14        API change.
     15        (WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame): Filter the
     16        vector returned by getMediaStreamDevices.
     17        (WebKit::UserMediaPermissionRequestManagerProxy::createRequest): Deleted.
     18        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
     19
     20        * UIProcess/UserMediaPermissionRequestProxy.cpp:
     21        (WebKit::UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy): Update for API change.
     22        (WebKit::UserMediaPermissionRequestProxy::allow): Ditto.
     23        * UIProcess/UserMediaPermissionRequestProxy.h:
     24        (WebKit::UserMediaPermissionRequestProxy::create):
     25        (WebKit::UserMediaPermissionRequestProxy::requestType const):
     26
     27        * UIProcess/WebPageProxy.cpp:
     28        (WebKit::WebPageProxy::requestUserMediaPermissionForFrame): Ditto.
     29        * UIProcess/WebPageProxy.h:
     30        * UIProcess/WebPageProxy.messages.in:
     31
     32        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
     33        (WebKit::UserMediaPermissionRequestManager::startUserMediaRequest): m_blockedRequests -> m_blockedUserMediaRequests.
     34        (WebKit::UserMediaPermissionRequestManager::sendUserMediaRequest): Ditto.
     35        (WebKit::UserMediaPermissionRequestManager::mediaCanStart): Ditto.
     36        (WebKit::UserMediaPermissionRequestManager::removeMediaRequestFromMaps): Ditto.
     37        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
     38
    1392017-12-19  Jer Noble  <jer.noble@apple.com>
    240

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

    r225797 r226160  
    769769        WebCore::CaptureDevice::DeviceType,
    770770        WebCore::CaptureDevice::DeviceType::Unknown,
    771         WebCore::CaptureDevice::DeviceType::Audio,
    772         WebCore::CaptureDevice::DeviceType::Video
     771        WebCore::CaptureDevice::DeviceType::Microphone,
     772        WebCore::CaptureDevice::DeviceType::Camera
    773773    >;
    774774};

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

    r225395 r226160  
    11/*
    22 * Copyright (C) 2014 Igalia S.L.
    3  * Copyright (C) 2016 Apple Inc. All rights reserved.
     3 * Copyright (C) 2016-2017 Apple Inc. All rights reserved.
    44 *
    55 *  This library is free software; you can redistribute it and/or
    … …  
    8181}
    8282
    83 Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createRequest(uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin, Vector<CaptureDevice>&& audioDevices, Vector<CaptureDevice>&& videoDevices, String&& deviceIDHashSalt)
    84 {
    85     auto request = UserMediaPermissionRequestProxy::create(*this, userMediaID, mainFrameID, frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), WTFMove(deviceIDHashSalt));
    86     m_pendingUserMediaRequests.add(userMediaID, request.ptr());
    87     return request;
     83Ref<UserMediaPermissionRequestProxy> UserMediaPermissionRequestManagerProxy::createPermissionRequest(uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin, Vector<CaptureDevice>&& audioDevices, Vector<CaptureDevice>&& videoDevices, String&& deviceIDHashSalt, MediaStreamRequest&& request)
     84{
     85    auto permissionRequest = UserMediaPermissionRequestProxy::create(*this, userMediaID, mainFrameID, frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), WTFMove(deviceIDHashSalt), WTFMove(request));
     86    m_pendingUserMediaRequests.add(userMediaID, permissionRequest.ptr());
     87    return permissionRequest;
    8888}
    8989
    … …  
    241241}
    242242
    243 void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin, const MediaConstraints& audioConstraints, const MediaConstraints& videoConstraints)
     243void UserMediaPermissionRequestManagerProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin, const MediaStreamRequest& userRequest)
    244244{
    245245#if ENABLE(MEDIA_STREAM)
    … …  
    257257    };
    258258
    259     RealtimeMediaSourceCenter::ValidConstraintsHandler validHandler = [this, userMediaID, frameID, userMediaDocumentOrigin = userMediaDocumentOrigin.copyRef(), topLevelDocumentOrigin = topLevelDocumentOrigin.copyRef()](Vector<CaptureDevice>&& audioDevices, Vector<CaptureDevice>&& videoDevices, String&& deviceIdentifierHashSalt) mutable {
     259    auto validHandler = [this, userMediaID, frameID, userMediaDocumentOrigin = userMediaDocumentOrigin.copyRef(), topLevelDocumentOrigin = topLevelDocumentOrigin.copyRef(), localUserRequest = userRequest](Vector<CaptureDevice>&& audioDevices, Vector<CaptureDevice>&& videoDevices, String&& deviceIdentifierHashSalt) mutable {
    260260        if (!m_page.isValid() || !m_page.mainFrame())
    261261            return;
    … …  
    280280                grantAccess(userMediaID, WTFMove(audioDevice), WTFMove(videoDevice), grantedRequest->deviceIdentifierHashSalt());
    281281            } else
    282                 m_pregrantedRequests.append(createRequest(userMediaID, m_page.mainFrame()->frameID(), frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), String(grantedRequest->deviceIdentifierHashSalt())));
     282                m_pregrantedRequests.append(createPermissionRequest(userMediaID, m_page.mainFrame()->frameID(), frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), String(grantedRequest->deviceIdentifierHashSalt()), WTFMove(localUserRequest)));
    283283
    284284            return;
    … …  
    287287        auto topLevelOrigin = API::SecurityOrigin::create(topLevelDocumentOrigin.get());
    288288
    289         auto request = createRequest(userMediaID, m_page.mainFrame()->frameID(), frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), WTFMove(deviceIdentifierHashSalt));
     289        auto pendingRequest = createPermissionRequest(userMediaID, m_page.mainFrame()->frameID(), frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), WTFMove(deviceIdentifierHashSalt), WTFMove(localUserRequest));
    290290
    291291        if (m_page.isControlledByAutomation()) {
    292292            if (WebAutomationSession* automationSession = m_page.process().processPool().automationSession()) {
    293293                if (automationSession->shouldAllowGetUserMediaForPage(m_page))
    294                     request->allow();
     294                    pendingRequest->allow();
    295295                else
    296296                    userMediaAccessWasDenied(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::PermissionDenied);
    … …  
    301301
    302302        if (m_page.preferences().mockCaptureDevicesEnabled() && !m_page.preferences().mockCaptureDevicesPromptEnabled()) {
    303             request->allow();
     303            pendingRequest->allow();
    304304            return;
    305305        }
    306306
    307         if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), WTFMove(userMediaOrigin), WTFMove(topLevelOrigin), request.get()))
     307        if (!m_page.uiClient().decidePolicyForUserMediaPermissionRequest(m_page, *m_page.process().webFrame(frameID), WTFMove(userMediaOrigin), WTFMove(topLevelOrigin), pendingRequest.get()))
    308308            userMediaAccessWasDenied(userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason::UserMediaDisabled);
    309309    };
    310310
    311     auto haveDeviceSaltHandler = [this, validHandler = WTFMove(validHandler), invalidHandler = WTFMove(invalidHandler), audioConstraints = MediaConstraints(audioConstraints), videoConstraints = MediaConstraints(videoConstraints)](uint64_t userMediaID, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess) mutable {
    312 
    313         auto request = m_pendingDeviceRequests.take(userMediaID);
    314         if (!request)
     311    auto haveDeviceSaltHandler = [this, validHandler = WTFMove(validHandler), invalidHandler = WTFMove(invalidHandler), localUserRequest = userRequest](uint64_t userMediaID, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess) mutable {
     312
     313        auto pendingRequest = m_pendingDeviceRequests.take(userMediaID);
     314        if (!pendingRequest)
    315315            return;
    316316
    … …  
    318318            return;
    319319       
    320         audioConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
    321         videoConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
     320        localUserRequest.audioConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
     321        localUserRequest.videoConstraints.deviceIDHashSalt = deviceIdentifierHashSalt;
    322322
    323323        syncWithWebCorePrefs();
    324324       
    325         RealtimeMediaSourceCenter::singleton().validateRequestConstraints(WTFMove(validHandler), WTFMove(invalidHandler), audioConstraints, videoConstraints, WTFMove(deviceIdentifierHashSalt));
     325        RealtimeMediaSourceCenter::singleton().validateRequestConstraints(WTFMove(validHandler), WTFMove(invalidHandler), WTFMove(localUserRequest), WTFMove(deviceIdentifierHashSalt));
    326326    };
    327327
    … …  
    334334    UNUSED_PARAM(audioConstraints);
    335335    UNUSED_PARAM(videoConstraints);
     336    UNUSED_PARAM(userRequest);
    336337#endif
    337338}
    … …  
    363364
    364365        syncWithWebCorePrefs();
    365         auto deviceInfo = RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
    366         m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration(userMediaID, deviceInfo, deviceIdentifierHashSalt, originHasPersistentAccess), m_page.pageID());
     366
     367        auto devices = RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
     368        devices.removeAllMatching([&](auto& device) -> bool {
     369            return !device.enabled() || (device.type() != WebCore::CaptureDevice::DeviceType::Camera && device.type() != WebCore::CaptureDevice::DeviceType::Microphone);
     370        });
     371
     372        m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration(userMediaID, devices, deviceIdentifierHashSalt, originHasPersistentAccess), m_page.pageID());
    367373    };
    368374

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

    r225395 r226160  
    3131class CaptureDevice;
    3232struct MediaConstraints;
     33struct MediaStreamRequest;
    3334class SecurityOrigin;
    3435};
    … …  
    4748    void invalidatePendingRequests();
    4849
    49     void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&&  userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, const WebCore::MediaConstraints& audioConstraints, const WebCore::MediaConstraints& videoConstraints);
     50    void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&&  userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, const WebCore::MediaStreamRequest&);
    5051
    5152    void resetAccess(uint64_t mainFrameID);
    … …  
    6566
    6667private:
    67     Ref<UserMediaPermissionRequestProxy> createRequest(uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&&);
     68    Ref<UserMediaPermissionRequestProxy> createPermissionRequest(uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&&, WebCore::MediaStreamRequest&&);
    6869    void denyRequest(uint64_t userMediaID, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason, const String& invalidConstraint);
    6970#if ENABLE(MEDIA_STREAM)

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

    r225395 r226160  
    3232namespace WebKit {
    3333
    34 UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&& deviceIDHashSalt)
     34UserMediaPermissionRequestProxy::UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&& deviceIDHashSalt, WebCore::MediaStreamRequest&& request)
    3535    : m_manager(&manager)
    3636    , m_userMediaID(userMediaID)
    … …  
    4242    , m_eligibleAudioDevices(WTFMove(audioDevices))
    4343    , m_deviceIdentifierHashSalt(WTFMove(deviceIDHashSalt))
     44    , m_request(WTFMove(request))
    4445{
    4546}
    … …  
    5253
    5354#if ENABLE(MEDIA_STREAM)
     55
     56    auto& sourceCenter = RealtimeMediaSourceCenter::singleton();
    5457    CaptureDevice audioDevice;
    5558    if (!audioDeviceUID.isEmpty()) {
    56         audioDevice = RealtimeMediaSourceCenter::singleton().audioCaptureDeviceManager().deviceWithUID(audioDeviceUID, RealtimeMediaSource::Type::Audio);
    57         ASSERT(audioDevice);
     59        auto device = sourceCenter.captureDeviceWithPersistentID(WebCore::CaptureDevice::DeviceType::Microphone, audioDeviceUID);
     60        ASSERT(device && device.value().enabled());
     61        if (device)
     62            audioDevice = device.value();
    5863    }
    5964
    6065    CaptureDevice videoDevice;
    6166    if (!videoDeviceUID.isEmpty()) {
    62         videoDevice = RealtimeMediaSourceCenter::singleton().videoCaptureDeviceManager().deviceWithUID(videoDeviceUID, RealtimeMediaSource::Type::Video);
    63         ASSERT(videoDevice);
     67        auto device = sourceCenter.captureDeviceWithPersistentID(WebCore::CaptureDevice::DeviceType::Camera, videoDeviceUID);
     68
     69        ASSERT(device && device.value().enabled());
     70        if (device)
     71            videoDevice = device.value();
    6472    }
    6573
    … …  
    7078#endif
    7179
     80    invalidate();
     81}
     82
     83void UserMediaPermissionRequestProxy::allow(WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice)
     84{
     85    ASSERT(m_manager);
     86    if (!m_manager)
     87        return;
     88
     89    m_manager->userMediaAccessWasGranted(m_userMediaID, WTFMove(audioDevice), WTFMove(videoDevice));
    7290    invalidate();
    7391}

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

    r225395 r226160  
    2222#include "APIObject.h"
    2323#include <WebCore/CaptureDevice.h>
     24#include <WebCore/MediaStreamRequest.h>
    2425#include <wtf/Vector.h>
    2526#include <wtf/text/WTFString.h>
    … …  
    3536class UserMediaPermissionRequestProxy : public API::ObjectImpl<API::Object::Type::UserMediaPermissionRequest> {
    3637public:
    37     static Ref<UserMediaPermissionRequestProxy> create(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& videoDevices, Vector<WebCore::CaptureDevice>&& audioDevices, String&& deviceIDHashSalt)
     38    static Ref<UserMediaPermissionRequestProxy> create(UserMediaPermissionRequestManagerProxy& manager, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&& deviceIDHashSalt, WebCore::MediaStreamRequest&& request)
    3839    {
    39         return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, mainFrameID, frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(videoDevices), WTFMove(audioDevices), WTFMove(deviceIDHashSalt)));
     40        return adoptRef(*new UserMediaPermissionRequestProxy(manager, userMediaID, mainFrameID, frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(audioDevices), WTFMove(videoDevices), WTFMove(deviceIDHashSalt), WTFMove(request)));
    4041    }
    4142
    42     void allow(const String& videoDeviceUID, const String& audioDeviceUID);
     43    void allow(const String& audioDeviceUID, const String& videoDeviceUID);
     44    void allow(WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice);
    4345    void allow();
    4446
    … …  
    6163    const String& deviceIdentifierHashSalt() const { return m_deviceIdentifierHashSalt; }
    6264
     65    WebCore::MediaStreamRequest::Type requestType() const { return m_request.type; }
     66
    6367private:
    64     UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& videoDevices, Vector<WebCore::CaptureDevice>&& audioDevices, String&&);
     68    UserMediaPermissionRequestProxy(UserMediaPermissionRequestManagerProxy&, uint64_t userMediaID, uint64_t mainFrameID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, Vector<WebCore::CaptureDevice>&& audioDevices, Vector<WebCore::CaptureDevice>&& videoDevices, String&&, WebCore::MediaStreamRequest&&);
    6569
    6670    UserMediaPermissionRequestManagerProxy* m_manager;
    … …  
    7377    Vector<WebCore::CaptureDevice> m_eligibleAudioDevices;
    7478    String m_deviceIdentifierHashSalt;
     79    WebCore::MediaStreamRequest m_request;
    7580};
    7681

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

    r226123 r226160  
    129129#include <WebCore/LengthBox.h>
    130130#include <WebCore/MIMETypeRegistry.h>
     131#include <WebCore/MediaStreamRequest.h>
    131132#include <WebCore/PerformanceLoggingClient.h>
    132133#include <WebCore/PublicSuffix.h>
    … …  
    191192#if PLATFORM(IOS) || (PLATFORM(MAC) && ENABLE(VIDEO_PRESENTATION_MODE))
    192193#include "PlaybackSessionManagerProxy.h"
    193 #endif
    194 
    195 #if ENABLE(MEDIA_STREAM)
    196 #include <WebCore/MediaConstraints.h>
    197194#endif
    198195
    … …  
    59915988#endif
    59925989
    5993     void WebPageProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData&  userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData, const WebCore::MediaConstraints& audioConstraints, const WebCore::MediaConstraints& videoConstraints)
     5990void WebPageProxy::requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData&  userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData, const WebCore::MediaStreamRequest& request)
    59945991{
    59955992#if ENABLE(MEDIA_STREAM)
    59965993    MESSAGE_CHECK(m_process->webFrame(frameID));
    59975994
    5998     userMediaPermissionRequestManager().requestUserMediaPermissionForFrame(userMediaID, frameID, userMediaDocumentOriginData.securityOrigin(), topLevelDocumentOriginData.securityOrigin(), audioConstraints, videoConstraints);
     5995    userMediaPermissionRequestManager().requestUserMediaPermissionForFrame(userMediaID, frameID, userMediaDocumentOriginData.securityOrigin(), topLevelDocumentOriginData.securityOrigin(), request);
    59995996#else
    60005997    UNUSED_PARAM(userMediaID);
    … …  
    60025999    UNUSED_PARAM(userMediaDocumentOriginData);
    60036000    UNUSED_PARAM(topLevelDocumentOriginData);
    6004     UNUSED_PARAM(audioConstraints);
    6005     UNUSED_PARAM(videoConstraints);
     6001    UNUSED_PARAM(request);
    60066002#endif
    60076003}

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

    r226067 r226160  
    163163struct ExceptionDetails;
    164164struct FileChooserSettings;
    165 struct MediaConstraints;
     165struct MediaStreamRequest;
    166166struct SecurityOriginData;
    167167struct TextAlternativeWithRange;
    … …  
    13911391    UserMediaPermissionRequestManagerProxy& userMediaPermissionRequestManager();
    13921392#endif
    1393     void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier, const WebCore::MediaConstraints& audioConstraints, const WebCore::MediaConstraints& videoConstraints);
     1393    void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier, const WebCore::MediaStreamRequest&);
    13941394    void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData);
    13951395

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

    r226016 r226160  
    277277#if ENABLE(MEDIA_STREAM)
    278278    # MediaSteam messages
    279     RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier, struct WebCore::MediaConstraints audioConstraints, struct WebCore::MediaConstraints videoConstraints)
     279    RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier, struct WebCore::MediaStreamRequest request)
    280280    EnumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier)
    281281#endif

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

    r225926 r226160  
    7373    }
    7474
    75     auto& pendingRequests = m_blockedRequests.add(document, Vector<RefPtr<UserMediaRequest>>()).iterator->value;
     75    auto& pendingRequests = m_blockedUserMediaRequests.add(document, Vector<RefPtr<UserMediaRequest>>()).iterator->value;
    7676    if (pendingRequests.isEmpty())
    7777        document->addMediaCanStartListener(this);
    … …  
    7979}
    8080
    81 void UserMediaPermissionRequestManager::sendUserMediaRequest(UserMediaRequest& request)
    82 {
    83     Document* document = request.document();
    84     Frame* frame = document ? document->frame() : nullptr;
    85 
     81void UserMediaPermissionRequestManager::sendUserMediaRequest(UserMediaRequest& userRequest)
     82{
     83    auto* frame = userRequest.document() ? userRequest.document()->frame() : nullptr;
    8684    if (!frame) {
    87         request.deny(UserMediaRequest::OtherFailure, emptyString());
     85        userRequest.deny(UserMediaRequest::OtherFailure, emptyString());
    8886        return;
    8987    }
    9088
    9189    uint64_t requestID = generateRequestID();
    92     m_idToUserMediaRequestMap.add(requestID, &request);
    93     m_userMediaRequestToIDMap.add(&request, requestID);
     90    m_idToUserMediaRequestMap.add(requestID, &userRequest);
     91    m_userMediaRequestToIDMap.add(&userRequest, requestID);
    9492
    9593    WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
    9694    ASSERT(webFrame);
    9795
    98     SecurityOrigin* topLevelDocumentOrigin = request.topLevelDocumentOrigin();
    99     ASSERT(topLevelDocumentOrigin);
    100     m_page.send(Messages::WebPageProxy::RequestUserMediaPermissionForFrame(requestID, webFrame->frameID(), SecurityOriginData::fromSecurityOrigin(*request.userMediaDocumentOrigin()), SecurityOriginData::fromSecurityOrigin(*topLevelDocumentOrigin), request.audioConstraints(), request.videoConstraints()));
     96    auto* topLevelDocumentOrigin = userRequest.topLevelDocumentOrigin();
     97    m_page.send(Messages::WebPageProxy::RequestUserMediaPermissionForFrame(requestID, webFrame->frameID(), SecurityOriginData::fromSecurityOrigin(*userRequest.userMediaDocumentOrigin()), SecurityOriginData::fromSecurityOrigin(*topLevelDocumentOrigin), userRequest.request()));
    10198}
    10299
    … …  
    114111void UserMediaPermissionRequestManager::mediaCanStart(Document& document)
    115112{
    116     auto pendingRequests = m_blockedRequests.take(&document);
     113    auto pendingRequests = m_blockedUserMediaRequests.take(&document);
    117114    while (!pendingRequests.isEmpty()) {
    118115        if (!document.page()->canStartMedia()) {
    119             m_blockedRequests.add(&document, pendingRequests);
     116            m_blockedUserMediaRequests.add(&document, pendingRequests);
    120117            document.addMediaCanStartListener(this);
    121118            break;
    … …  
    132129        return;
    133130
    134     auto pendingRequests = m_blockedRequests.take(document);
     131    auto pendingRequests = m_blockedUserMediaRequests.take(document);
    135132    for (auto& pendingRequest : pendingRequests) {
    136133        if (&request != pendingRequest.get())
    … …  
    140137            request.document()->removeMediaCanStartListener(this);
    141138        else
    142             m_blockedRequests.add(request.document(), pendingRequests);
     139            m_blockedUserMediaRequests.add(document, pendingRequests);
    143140        break;
    144141    }

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

    r225926 r226160  
    6868    HashMap<uint64_t, RefPtr<WebCore::UserMediaRequest>> m_idToUserMediaRequestMap;
    6969    HashMap<RefPtr<WebCore::UserMediaRequest>, uint64_t> m_userMediaRequestToIDMap;
     70    HashMap<RefPtr<WebCore::Document>, Vector<RefPtr<WebCore::UserMediaRequest>>> m_blockedUserMediaRequests;
    7071
    7172    HashMap<uint64_t, RefPtr<WebCore::MediaDevicesEnumerationRequest>> m_idToMediaDevicesEnumerationRequestMap;
    … …  
    7374
    7475    HashMap<String, RefPtr<SandboxExtension>> m_userMediaDeviceSandboxExtensions;
    75 
    76     HashMap<RefPtr<WebCore::Document>, Vector<RefPtr<WebCore::UserMediaRequest>>> m_blockedRequests;
    7776};
    7877
Note: See TracChangeset for help on using the changeset viewer.