Changeset 245335 in webkit


Ignore:
Timestamp:
May 15, 2019 11:44:36 AM (5 years ago)
Author:
youenn@apple.com
Message:

getUserMedia sandbox extensions should not be revoked when a getUserMedia allowed request is being processed
https://bugs.webkit.org/show_bug.cgi?id=197851

Reviewed by Alex Christensen.

Source/WebCore:

Add a completion handler to create a new capture stream.
This is used by WK2 layer to acknowledge the pending capture request is completed.
Just after the completion handler, make sure to update the document media state.
This is done to ensure that, should capture failing, the UIProcess
knows about it and can manage proper sandbox extension revocation.

Test: fast/mediastream/gum-stop-track.html

  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::allow):
(WebCore::UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream):
(WebCore::UserMediaRequest::PendingActivationMediaStream::~PendingActivationMediaStream):

  • Modules/mediastream/UserMediaRequest.h:

(WebCore::UserMediaRequest::PendingActivationMediaStream::create):

  • platform/mock/MockRealtimeMediaSourceCenter.cpp:

(WebCore::MockRealtimeMediaSourceCenter::mockRealtimeMediaSourceCenterEnabled):

  • platform/mock/MockRealtimeMediaSourceCenter.h:

Source/WebKit:

Before the patch, stopping capture in a document and quickly triggering a new capture
might fail as the UIProcess would grant access and revoke sandbox access based on the fact
the page is no longer capturing.
To fix that issue, keep a state in the UIProcess to not revoke sandbox extensions in case of
capture being started.
Add an IPC message back to tell UIProcess when an allowed capture is finished.
Just after doing that, make sure the document is updating the media state to UIProcess, which will trigger proper sandbox extension handling.

This should also trigger the case of an allowed getUserMedia call that fails to start for some reason.
In that case, the patch will automatically trigger a document media state refresh which will trigger a sandbox revokation.

Covered by added test that exercise a newly added debug assertion.
This assertion ensures that we revoke extensions while a document is not capturing.

  • UIProcess/UserMediaPermissionRequestManagerProxy.cpp:

(WebKit::UserMediaPermissionRequestManagerProxy::~UserMediaPermissionRequestManagerProxy):
(WebKit::UserMediaPermissionRequestManagerProxy::grantAccess):
(WebKit::UserMediaPermissionRequestManagerProxy::captureStateChanged):

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

(WebKit::UserMediaProcessManager::willCreateMediaStream):
(WebKit::UserMediaProcessManager::revokeSandboxExtensionsIfNeeded):

  • UIProcess/UserMediaProcessManager.h:
  • UIProcess/WebPageProxy.h:

(WebKit::WebPageProxy::isCapturingAudio const):
(WebKit::WebPageProxy::isCapturingVideo const):

  • WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:

(WebKit::UserMediaPermissionRequestManager::userMediaAccessWasGranted):

  • WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::userMediaAccessWasGranted):

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

(WebKit::checkDocumentsCaptureStateConsistency):
(WebKit::WebProcess::revokeUserMediaDeviceSandboxExtensions):

LayoutTests:

  • fast/mediastream/gum-stop-track-expected.txt: Added.
  • fast/mediastream/gum-stop-track.html: Added.
Location:
trunk
Files:
2 added
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r245321 r245335  
     12019-05-15  Youenn Fablet  <youenn@apple.com>
     2
     3        getUserMedia sandbox extensions should not be revoked when a getUserMedia allowed request is being processed
     4        https://bugs.webkit.org/show_bug.cgi?id=197851
     5
     6        Reviewed by Alex Christensen.
     7
     8        * fast/mediastream/gum-stop-track-expected.txt: Added.
     9        * fast/mediastream/gum-stop-track.html: Added.
     10
    1112019-05-15  Fujii Hironori  <Hironori.Fujii@sony.com>
    212
  • trunk/Source/WebCore/ChangeLog

    r245326 r245335  
     12019-05-15  Youenn Fablet  <youenn@apple.com>
     2
     3        getUserMedia sandbox extensions should not be revoked when a getUserMedia allowed request is being processed
     4        https://bugs.webkit.org/show_bug.cgi?id=197851
     5
     6        Reviewed by Alex Christensen.
     7
     8        Add a completion handler to create a new capture stream.
     9        This is used by WK2 layer to acknowledge the pending capture request is completed.
     10        Just after the completion handler, make sure to update the document media state.
     11        This is done to ensure that, should capture failing, the UIProcess
     12        knows about it and can manage proper sandbox extension revocation.
     13
     14        Test: fast/mediastream/gum-stop-track.html
     15
     16        * Modules/mediastream/UserMediaRequest.cpp:
     17        (WebCore::UserMediaRequest::allow):
     18        (WebCore::UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream):
     19        (WebCore::UserMediaRequest::PendingActivationMediaStream::~PendingActivationMediaStream):
     20        * Modules/mediastream/UserMediaRequest.h:
     21        (WebCore::UserMediaRequest::PendingActivationMediaStream::create):
     22        * platform/mock/MockRealtimeMediaSourceCenter.cpp:
     23        (WebCore::MockRealtimeMediaSourceCenter::mockRealtimeMediaSourceCenterEnabled):
     24        * platform/mock/MockRealtimeMediaSourceCenter.h:
     25
    1262019-05-15  Simon Fraser  <simon.fraser@apple.com>
    227
  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.cpp

    r241281 r245335  
    4848#include "Settings.h"
    4949#include "UserMediaController.h"
     50#include <wtf/Scope.h>
    5051
    5152namespace WebCore {
     
    215216}
    216217
    217 void UserMediaRequest::allow(CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt)
     218void UserMediaRequest::allow(CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt, CompletionHandler<void()>&& completionHandler)
    218219{
    219220    RELEASE_LOG(MediaStream, "UserMediaRequest::allow %s %s", audioDevice ? audioDevice.persistentId().utf8().data() : "", videoDevice ? videoDevice.persistentId().utf8().data() : "");
    220221
    221     auto callback = [this, protector = makePendingActivity(*this)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
     222    auto callback = [this, protector = makePendingActivity(*this), completionHandler = WTFMove(completionHandler)](RefPtr<MediaStreamPrivate>&& privateStream) mutable {
     223        auto scopeExit = makeScopeExit([&] {
     224            completionHandler();
     225        });
    222226        if (!m_scriptExecutionContext)
    223227            return;
     
    236240        }
    237241
    238         m_pendingActivationMediaStream = PendingActivationMediaStream::create(WTFMove(protector), *this, WTFMove(stream));
     242        scopeExit.release();
     243        m_pendingActivationMediaStream = PendingActivationMediaStream::create(WTFMove(protector), *this, WTFMove(stream), WTFMove(completionHandler));
    239244    };
    240245
     
    331336}
    332337
    333 UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream(Ref<PendingActivity<UserMediaRequest>>&& protectingUserMediaRequest, UserMediaRequest& userMediaRequest, Ref<MediaStream>&& stream)
     338UserMediaRequest::PendingActivationMediaStream::PendingActivationMediaStream(Ref<PendingActivity<UserMediaRequest>>&& protectingUserMediaRequest, UserMediaRequest& userMediaRequest, Ref<MediaStream>&& stream, CompletionHandler<void()>&& completionHandler)
    334339    : m_protectingUserMediaRequest(WTFMove(protectingUserMediaRequest))
    335340    , m_userMediaRequest(userMediaRequest)
    336341    , m_mediaStream(WTFMove(stream))
     342    , m_completionHandler(WTFMove(completionHandler))
    337343{
    338344    m_mediaStream->privateStream().addObserver(*this);
     
    343349{
    344350    m_mediaStream->privateStream().removeObserver(*this);
     351    m_completionHandler();
     352    if (auto* document = m_mediaStream->document())
     353        document->updateIsPlayingMedia();
    345354}
    346355
  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.h

    r239535 r245335  
    4141#include "MediaStreamPrivate.h"
    4242#include "MediaStreamRequest.h"
     43#include <wtf/CompletionHandler.h>
    4344
    4445namespace WebCore {
     
    5556
    5657    WEBCORE_EXPORT void setAllowedMediaDeviceUIDs(const String& audioDeviceUID, const String& videoDeviceUID);
    57     WEBCORE_EXPORT void allow(CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt);
     58    WEBCORE_EXPORT void allow(CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt, CompletionHandler<void()>&&);
    5859
    5960    enum MediaAccessDenialReason { NoConstraints, UserMediaDisabled, NoCaptureDevices, InvalidConstraint, HardwareError, PermissionDenied, InvalidAccess, IllegalConstraint, OtherFailure };
     
    8485    class PendingActivationMediaStream : public RefCounted<PendingActivationMediaStream>, private MediaStreamPrivate::Observer {
    8586    public:
    86         static Ref<PendingActivationMediaStream> create(Ref<PendingActivity<UserMediaRequest>>&& protectingUserMediaRequest, UserMediaRequest& userMediaRequest, Ref<MediaStream>&& stream)
     87        static Ref<PendingActivationMediaStream> create(Ref<PendingActivity<UserMediaRequest>>&& protectingUserMediaRequest, UserMediaRequest& userMediaRequest, Ref<MediaStream>&& stream, CompletionHandler<void()>&& completionHandler)
    8788        {
    88             return adoptRef(*new PendingActivationMediaStream { WTFMove(protectingUserMediaRequest), userMediaRequest, WTFMove(stream) });
     89            return adoptRef(*new PendingActivationMediaStream { WTFMove(protectingUserMediaRequest), userMediaRequest, WTFMove(stream), WTFMove(completionHandler) });
    8990        }
    9091        ~PendingActivationMediaStream();
    9192
    9293    private:
    93         PendingActivationMediaStream(Ref<PendingActivity<UserMediaRequest>>&&, UserMediaRequest&, Ref<MediaStream>&&);
     94        PendingActivationMediaStream(Ref<PendingActivity<UserMediaRequest>>&&, UserMediaRequest&, Ref<MediaStream>&&, CompletionHandler<void()>&&);
    9495
    9596        void characteristicsChanged() final;
     
    9899        UserMediaRequest& m_userMediaRequest;
    99100        Ref<MediaStream> m_mediaStream;
     101        CompletionHandler<void()> m_completionHandler;
    100102    };
    101103
  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp

    r243163 r245335  
    209209}
    210210
     211bool MockRealtimeMediaSourceCenter::mockRealtimeMediaSourceCenterEnabled()
     212{
     213    MockRealtimeMediaSourceCenter& mock = singleton();
     214    RealtimeMediaSourceCenter& center = RealtimeMediaSourceCenter::singleton();
     215
     216    return &center.audioCaptureFactory() == &mock.audioCaptureFactory() || &center.videoCaptureFactory() == &mock.videoCaptureFactory() || &center.displayCaptureFactory() == &mock.displayCaptureFactory();
     217}
     218
    211219static void createCaptureDevice(const MockMediaDevice& device)
    212220{
  • trunk/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h

    r239427 r245335  
    4242
    4343    WEBCORE_EXPORT static void setMockRealtimeMediaSourceCenterEnabled(bool);
     44    WEBCORE_EXPORT static bool mockRealtimeMediaSourceCenterEnabled();
    4445
    4546    WEBCORE_EXPORT static void setDevices(Vector<MockMediaDevice>&&);
  • trunk/Source/WebKit/ChangeLog

    r245334 r245335  
     12019-05-15  Youenn Fablet  <youenn@apple.com>
     2
     3        getUserMedia sandbox extensions should not be revoked when a getUserMedia allowed request is being processed
     4        https://bugs.webkit.org/show_bug.cgi?id=197851
     5
     6        Reviewed by Alex Christensen.
     7
     8        Before the patch, stopping capture in a document and quickly triggering a new capture
     9        might fail as the UIProcess would grant access and revoke sandbox access based on the fact
     10        the page is no longer capturing.
     11        To fix that issue, keep a state in the UIProcess to not revoke sandbox extensions in case of
     12        capture being started.
     13        Add an IPC message back to tell UIProcess when an allowed capture is finished.
     14        Just after doing that, make sure the document is updating the media state to UIProcess, which will trigger proper sandbox extension handling.
     15
     16        This should also trigger the case of an allowed getUserMedia call that fails to start for some reason.
     17        In that case, the patch will automatically trigger a document media state refresh which will trigger a sandbox revokation.
     18
     19        Covered by added test that exercise a newly added debug assertion.
     20        This assertion ensures that we revoke extensions while a document is not capturing.
     21
     22        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
     23        (WebKit::UserMediaPermissionRequestManagerProxy::~UserMediaPermissionRequestManagerProxy):
     24        (WebKit::UserMediaPermissionRequestManagerProxy::grantAccess):
     25        (WebKit::UserMediaPermissionRequestManagerProxy::captureStateChanged):
     26        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
     27        * UIProcess/UserMediaProcessManager.cpp:
     28        (WebKit::UserMediaProcessManager::willCreateMediaStream):
     29        (WebKit::UserMediaProcessManager::revokeSandboxExtensionsIfNeeded):
     30        * UIProcess/UserMediaProcessManager.h:
     31        * UIProcess/WebPageProxy.h:
     32        (WebKit::WebPageProxy::isCapturingAudio const):
     33        (WebKit::WebPageProxy::isCapturingVideo const):
     34        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
     35        (WebKit::UserMediaPermissionRequestManager::userMediaAccessWasGranted):
     36        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
     37        * WebProcess/WebPage/WebPage.cpp:
     38        (WebKit::WebPage::userMediaAccessWasGranted):
     39        * WebProcess/WebPage/WebPage.h:
     40        * WebProcess/WebPage/WebPage.messages.in:
     41        * WebProcess/WebProcess.cpp:
     42        (WebKit::checkDocumentsCaptureStateConsistency):
     43        (WebKit::WebProcess::revokeUserMediaDeviceSandboxExtensions):
     44
    1452019-05-15  Chris Dumez  <cdumez@apple.com>
    246
  • trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp

    r244935 r245335  
    8484{
    8585#if ENABLE(MEDIA_STREAM)
    86     UserMediaProcessManager::singleton().endedCaptureSession(*this);
     86    UserMediaProcessManager::singleton().revokeSandboxExtensionsIfNeeded(page().process());
    8787    proxies().remove(this);
    8888#endif
     
    296296    }
    297297
    298     m_page.process().send(Messages::WebPage::UserMediaAccessWasGranted(request.userMediaID(), request.audioDevice(), request.videoDevice(), request.deviceIdentifierHashSalt()), m_page.pageID());
     298    ++m_hasPendingCapture;
     299    m_page.process().connection()->sendWithAsyncReply(Messages::WebPage::UserMediaAccessWasGranted { request.userMediaID(), request.audioDevice(), request.videoDevice(), request.deviceIdentifierHashSalt() }, [this, weakThis = makeWeakPtr(this)] {
     300        if (!weakThis)
     301            return;
     302        --m_hasPendingCapture;
     303    }, m_page.pageID());
    299304    return true;
    300305}
     
    633638
    634639#if ENABLE(MEDIA_STREAM)
    635     bool wasCapturingAudio = oldState & MediaProducer::AudioCaptureMask;
    636     bool wasCapturingVideo = oldState & MediaProducer::VideoCaptureMask;
    637     bool isCapturingAudio = newState & MediaProducer::AudioCaptureMask;
    638     bool isCapturingVideo = newState & MediaProducer::VideoCaptureMask;
    639 
    640     if ((wasCapturingAudio && !isCapturingAudio) || (wasCapturingVideo && !isCapturingVideo))
    641         UserMediaProcessManager::singleton().endedCaptureSession(*this);
     640    if (!m_hasPendingCapture)
     641        UserMediaProcessManager::singleton().revokeSandboxExtensionsIfNeeded(page().process());
    642642
    643643    if (m_captureState == (newState & activeCaptureMask))
  • trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h

    r243328 r245335  
    145145#endif
    146146    bool m_hasFilteredDeviceList { false };
     147    uint64_t m_hasPendingCapture { 0 };
    147148};
    148149
  • trunk/Source/WebKit/UIProcess/UserMediaProcessManager.cpp

    r242142 r245335  
    7373   
    7474#if ENABLE(SANDBOX_EXTENSIONS) && USE(APPLE_INTERNAL_SDK)
    75     if (!proxy.page().preferences().mockCaptureDevicesEnabled()) {
    76         auto& process = proxy.page().process();
    77         size_t extensionCount = 0;
    78 
    79         if (withAudio && !process.hasAudioCaptureExtension())
    80             extensionCount++;
    81         else
    82             withAudio = false;
    83 
    84         if (withVideo && !process.hasVideoCaptureExtension())
    85             extensionCount++;
    86         else
    87             withVideo = false;
    88 
    89         if (extensionCount) {
    90             SandboxExtension::HandleArray handles;
     75    auto& process = proxy.page().process();
     76    size_t extensionCount = 0;
     77
     78    if (withAudio && !process.hasAudioCaptureExtension())
     79        extensionCount++;
     80    else
     81        withAudio = false;
     82
     83    if (withVideo && !process.hasVideoCaptureExtension())
     84        extensionCount++;
     85    else
     86        withVideo = false;
     87
     88    if (extensionCount) {
     89        SandboxExtension::HandleArray handles;
     90        Vector<String> ids;
     91
     92        if (!proxy.page().preferences().mockCaptureDevicesEnabled()) {
    9193            handles.allocate(extensionCount);
    92 
    93             Vector<String> ids;
    94             ids.reserveCapacity(extensionCount);
     94            ids.reserveInitialCapacity(extensionCount);
    9595
    9696            if (withAudio && SandboxExtension::createHandleForGenericExtension(audioExtensionPath, handles[--extensionCount]))
     
    104104                return false;
    105105            }
    106 
    107             for (const auto& id : ids)
    108                 RELEASE_LOG(WebRTC, "UserMediaProcessManager::willCreateMediaStream - granting extension %s", id.utf8().data());
    109 
    110             if (withAudio)
    111                 process.grantAudioCaptureExtension();
    112             if (withVideo)
    113                 process.grantVideoCaptureExtension();
    114             process.send(Messages::WebProcess::GrantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions(ids, WTFMove(handles))), proxy.page().pageID());
    115106        }
     107
     108        for (const auto& id : ids)
     109            RELEASE_LOG(WebRTC, "UserMediaProcessManager::willCreateMediaStream - granting extension %s", id.utf8().data());
     110
     111        if (withAudio)
     112            process.grantAudioCaptureExtension();
     113        if (withVideo)
     114            process.grantVideoCaptureExtension();
     115        process.send(Messages::WebProcess::GrantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions(ids, WTFMove(handles))), 0);
    116116    }
    117117#else
     
    126126}
    127127
    128 void UserMediaProcessManager::endedCaptureSession(UserMediaPermissionRequestManagerProxy& proxy)
     128void UserMediaProcessManager::revokeSandboxExtensionsIfNeeded(WebProcessProxy& process)
    129129{
    130130#if ENABLE(SANDBOX_EXTENSIONS)
     
    132132    bool hasVideoCapture = false;
    133133
    134     auto& process = proxy.page().process();
    135     UserMediaPermissionRequestManagerProxy::forEach([&hasAudioCapture, &hasVideoCapture, &proxy, &process](auto& managerProxy) {
    136         if (&proxy == &managerProxy || &process != &managerProxy.page().process())
     134    UserMediaPermissionRequestManagerProxy::forEach([&hasAudioCapture, &hasVideoCapture, &process](auto& managerProxy) {
     135        if (&process != &managerProxy.page().process())
    137136            return;
    138         if (managerProxy.page().hasActiveAudioStream())
    139             hasAudioCapture = true;
    140         if (managerProxy.page().hasActiveVideoStream())
    141             hasVideoCapture = true;
     137        hasAudioCapture |= managerProxy.page().isCapturingAudio();
     138        hasVideoCapture |= managerProxy.page().isCapturingVideo();
    142139    });
    143140
     
    161158        RELEASE_LOG(WebRTC, "UserMediaProcessManager::endedCaptureSession - revoking extension %s", id.utf8().data());
    162159
    163     process.send(Messages::WebProcess::RevokeUserMediaDeviceSandboxExtensions(params), proxy.page().pageID());
     160    process.send(Messages::WebProcess::RevokeUserMediaDeviceSandboxExtensions(params), 0);
    164161#endif
    165162}
  • trunk/Source/WebKit/UIProcess/UserMediaProcessManager.h

    r242142 r245335  
    3939    void muteCaptureMediaStreamsExceptIn(WebPageProxy&);
    4040
    41     void endedCaptureSession(UserMediaPermissionRequestManagerProxy&);
     41    void revokeSandboxExtensionsIfNeeded(WebProcessProxy&);
    4242
    4343    void setCaptureEnabled(bool);
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r245328 r245335  
    12981298    void isPlayingMediaDidChange(WebCore::MediaProducer::MediaStateFlags, uint64_t);
    12991299    void updatePlayingMediaDidChange(WebCore::MediaProducer::MediaStateFlags);
     1300    bool isCapturingAudio() const { return m_mediaState & WebCore::MediaProducer::AudioCaptureMask; }
     1301    bool isCapturingVideo() const { return m_mediaState & WebCore::MediaProducer::VideoCaptureMask; }
    13001302    bool hasActiveAudioStream() const { return m_mediaState & WebCore::MediaProducer::HasActiveAudioCaptureDevice; }
    13011303    bool hasActiveVideoStream() const { return m_mediaState & WebCore::MediaProducer::HasActiveVideoCaptureDevice; }
  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp

    r242142 r245335  
    138138}
    139139
    140 void UserMediaPermissionRequestManager::userMediaAccessWasGranted(uint64_t requestID, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt)
     140void UserMediaPermissionRequestManager::userMediaAccessWasGranted(uint64_t requestID, CaptureDevice&& audioDevice, CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt, CompletionHandler<void()>&& completionHandler)
    141141{
    142142    auto request = m_idToUserMediaRequestMap.take(requestID);
     
    145145    removeMediaRequestFromMaps(*request);
    146146
    147     request->allow(WTFMove(audioDevice), WTFMove(videoDevice), WTFMove(deviceIdentifierHashSalt));
     147    request->allow(WTFMove(audioDevice), WTFMove(videoDevice), WTFMove(deviceIdentifierHashSalt), WTFMove(completionHandler));
    148148}
    149149
  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h

    r242142 r245335  
    4343    void startUserMediaRequest(WebCore::UserMediaRequest&);
    4444    void cancelUserMediaRequest(WebCore::UserMediaRequest&);
    45     void userMediaAccessWasGranted(uint64_t, WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt);
     45    void userMediaAccessWasGranted(uint64_t, WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice, String&& deviceIdentifierHashSalt, CompletionHandler<void()>&&);
    4646    void userMediaAccessWasDenied(uint64_t, WebCore::UserMediaRequest::MediaAccessDenialReason, String&&);
    4747
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r245327 r245335  
    41544154#if ENABLE(MEDIA_STREAM)
    41554155
    4156 void WebPage::userMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice, String&& mediaDeviceIdentifierHashSalt)
    4157 {
    4158     m_userMediaPermissionRequestManager->userMediaAccessWasGranted(userMediaID, WTFMove(audioDevice), WTFMove(videoDevice), WTFMove(mediaDeviceIdentifierHashSalt));
     4156void WebPage::userMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice, String&& mediaDeviceIdentifierHashSalt, CompletionHandler<void()>&& completionHandler)
     4157{
     4158    m_userMediaPermissionRequestManager->userMediaAccessWasGranted(userMediaID, WTFMove(audioDevice), WTFMove(videoDevice), WTFMove(mediaDeviceIdentifierHashSalt), WTFMove(completionHandler));
    41594159}
    41604160
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r245299 r245335  
    14461446
    14471447#if ENABLE(MEDIA_STREAM)
    1448     void userMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice&& audioDeviceUID, WebCore::CaptureDevice&& videoDeviceUID, String&& mediaDeviceIdentifierHashSalt);
     1448    void userMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice&& audioDeviceUID, WebCore::CaptureDevice&& videoDeviceUID, String&& mediaDeviceIdentifierHashSalt, CompletionHandler<void()>&&);
    14491449    void userMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String&& invalidConstraint);
    14501450
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

    r245079 r245335  
    352352#if ENABLE(MEDIA_STREAM)
    353353    # MediaSteam
    354     UserMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt)
     354    UserMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt) -> () Async
    355355    UserMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
    356356    DidCompleteMediaDeviceEnumeration(uint64_t userMediaID, Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
  • trunk/Source/WebKit/WebProcess/WebProcess.cpp

    r245334 r245335  
    18581858}
    18591859
     1860static inline void checkDocumentsCaptureStateConsistency(const Vector<String>& extensionIDs)
     1861{
     1862#if !ASSERT_DISABLED
     1863    bool isCapturingAudio = WTF::anyOf(Document::allDocumentsMap().values(), [](auto* document) {
     1864        return document->mediaState() & MediaProducer::AudioCaptureMask;
     1865    });
     1866    bool isCapturingVideo = WTF::anyOf(Document::allDocumentsMap().values(), [](auto* document) {
     1867        return document->mediaState() & MediaProducer::VideoCaptureMask;
     1868    });
     1869
     1870    if (isCapturingAudio)
     1871        ASSERT(extensionIDs.findMatching([](auto& id) { return id.contains("microphone"); }) == notFound);
     1872    if (isCapturingVideo)
     1873        ASSERT(extensionIDs.findMatching([](auto& id) { return id.contains("camera"); }) == notFound);
     1874#endif
     1875}
     1876
    18601877void WebProcess::revokeUserMediaDeviceSandboxExtensions(const Vector<String>& extensionIDs)
    18611878{
     1879    checkDocumentsCaptureStateConsistency(extensionIDs);
     1880
    18621881    for (const auto& extensionID : extensionIDs) {
    18631882        auto extension = m_mediaCaptureSandboxExtensions.take(extensionID);
    1864         ASSERT(extension);
     1883        ASSERT(extension || MockRealtimeMediaSourceCenter::mockRealtimeMediaSourceCenterEnabled());
    18651884        if (extension) {
    18661885            extension->revoke();
Note: See TracChangeset for help on using the changeset viewer.