Changeset 248847 in webkit


Ignore:
Timestamp:
Aug 19, 2019 12:40:52 AM (5 years ago)
Author:
youenn@apple.com
Message:

enumerateDevices should return the same JS objects if called twice
https://bugs.webkit.org/show_bug.cgi?id=200767

Reviewed by Eric Carlson.

Source/WebCore:

Make MediaDevices store the last list of enumerated MediaDeviceInfo objects.
Reuse them for the next enumerateDevices call if needed.
In case of a device change event, make sure the next enumerateDevices call will fetch the new list of devices.
When constructing the new list of devices, reuse any preexisting device in the old list as specified by
https://w3c.github.io/mediacapture-main/#dom-mediadevices-enumeratedevices.

Update enumerateDevices to use a completion handler.
Remove MediaDevicesRequest and MediaDevicesEnumerationRequest.
Covered by updated test and existing tests.

  • Modules/mediastream/MediaDeviceInfo.cpp:

(WebCore::MediaDeviceInfo::MediaDeviceInfo):
(WebCore::MediaDeviceInfo::create):

  • Modules/mediastream/MediaDeviceInfo.h:
  • Modules/mediastream/MediaDeviceInfo.idl:
  • Modules/mediastream/MediaDevices.cpp:

(WebCore::MediaDevices::MediaDevices):
(WebCore::MediaDevices::stop):
(WebCore::MediaDevices::refreshDevices):
(WebCore::MediaDevices::enumerateDevices):
(WebCore::MediaDevices::scheduledEventTimerFired):
(WebCore::MediaDevices::listenForDeviceChanges):
(WebCore::MediaDevices::addEventListener):

  • Modules/mediastream/MediaDevices.h:
  • Modules/mediastream/MediaDevices.idl:
  • Modules/mediastream/MediaDevicesEnumerationRequest.cpp: Removed.
  • Modules/mediastream/MediaDevicesEnumerationRequest.h: Removed.
  • Modules/mediastream/MediaDevicesRequest.cpp: Removed.
  • Modules/mediastream/MediaDevicesRequest.h: Removed.
  • Modules/mediastream/RTCRtpSender.cpp:
  • Modules/mediastream/UserMediaClient.h:
  • Modules/mediastream/UserMediaController.cpp:

(WebCore::isAllowedToUse):
(WebCore::UserMediaController::canCallGetUserMedia const):

  • Modules/mediastream/UserMediaController.h:

(WebCore::UserMediaController::enumerateMediaDevices):

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:

Source/WebKit:

Update code as enumerate device request is now gone.
Make use of async IPC to simplify code since we are now passing a completion handler directly.

  • UIProcess/UserMediaPermissionRequestManagerProxy.cpp:

(WebKit::UserMediaPermissionRequestManagerProxy::captureDevicesChanged):
(WebKit::UserMediaPermissionRequestManagerProxy::finishGrantingRequest):
(WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame):

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

(WebKit::WebPageProxy::maybeInitializeSandboxExtensionHandle):

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

(WebKit::UserMediaPermissionRequestManager::enumerateMediaDevices):

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

(WebKit::WebUserMediaClient::enumerateMediaDevices):

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

LayoutTests:

  • fast/mediastream/device-change-event-2.html:
Location:
trunk
Files:
4 deleted
29 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r248830 r248847  
     12019-08-19  Youenn Fablet  <youenn@apple.com>
     2
     3        enumerateDevices should return the same JS objects if called twice
     4        https://bugs.webkit.org/show_bug.cgi?id=200767
     5
     6        Reviewed by Eric Carlson.
     7
     8        * fast/mediastream/device-change-event-2.html:
     9
    1102019-08-18  Cathie Chen  <cathiechen@igalia.com>
    211
  • trunk/LayoutTests/fast/mediastream/device-change-event-2.html

    r238796 r248847  
    2828
    2929        let devices = await navigator.mediaDevices.enumerateDevices();
     30        let devices2 = await navigator.mediaDevices.enumerateDevices();
    3031
    3132        assert_true(!!devices.length, "check there are some devices");
     33        assert_array_equals(devices, devices2);
    3234
    3335        testRunner.clearMockMediaDevices();
    34 
     36        await new Promise((resolve, reject) => {
     37            navigator.mediaDevices.ondevicechange = resolve;
     38            setTimeout(() => {
     39                reject("event 1 took too long");
     40            }, 5000);
     41        });
    3542        devices = await navigator.mediaDevices.enumerateDevices();
    3643        assert_false(!!devices.length, "check there are no more devices");
    3744
     45        testRunner.addMockCameraDevice("id1", "my camera");
    3846        await new Promise((resolve, reject) => {
    3947            navigator.mediaDevices.ondevicechange = resolve;
    4048            setTimeout(() => {
    41                 console.log("event 1 took too long");
    42                 resolve();
     49                reject("event 2 took too long");
    4350            }, 5000);
    44             testRunner.addMockCameraDevice("id1", "my camera");
    4551        });
     52
    4653        devices = await navigator.mediaDevices.enumerateDevices();
    4754        assert_equals(devices[0].kind, "videoinput");
    4855        assert_equals(devices[0].label, "my camera");
    4956
     57        testRunner.addMockMicrophoneDevice("id2", "my mic");
    5058        await new Promise((resolve, reject) => {
    5159            navigator.mediaDevices.ondevicechange = resolve;
    5260            setTimeout(() => {
    53                 console.log("event 2 took too long");
    54                 resolve();
     61                reject("event 3 took too long");
    5562            }, 5000);
    56             testRunner.addMockMicrophoneDevice("id2", "my mic");
    5763        });
    5864        devices = await navigator.mediaDevices.enumerateDevices();
  • trunk/Source/WebCore/ChangeLog

    r248846 r248847  
     12019-08-19  Youenn Fablet  <youenn@apple.com>
     2
     3        enumerateDevices should return the same JS objects if called twice
     4        https://bugs.webkit.org/show_bug.cgi?id=200767
     5
     6        Reviewed by Eric Carlson.
     7
     8        Make MediaDevices store the last list of enumerated MediaDeviceInfo objects.
     9        Reuse them for the next enumerateDevices call if needed.
     10        In case of a device change event, make sure the next enumerateDevices call will fetch the new list of devices.
     11        When constructing the new list of devices, reuse any preexisting device in the old list as specified by
     12        https://w3c.github.io/mediacapture-main/#dom-mediadevices-enumeratedevices.
     13
     14        Update enumerateDevices to use a completion handler.
     15        Remove MediaDevicesRequest and MediaDevicesEnumerationRequest.
     16        Covered by updated test and existing tests.
     17
     18        * Modules/mediastream/MediaDeviceInfo.cpp:
     19        (WebCore::MediaDeviceInfo::MediaDeviceInfo):
     20        (WebCore::MediaDeviceInfo::create):
     21        * Modules/mediastream/MediaDeviceInfo.h:
     22        * Modules/mediastream/MediaDeviceInfo.idl:
     23        * Modules/mediastream/MediaDevices.cpp:
     24        (WebCore::MediaDevices::MediaDevices):
     25        (WebCore::MediaDevices::stop):
     26        (WebCore::MediaDevices::refreshDevices):
     27        (WebCore::MediaDevices::enumerateDevices):
     28        (WebCore::MediaDevices::scheduledEventTimerFired):
     29        (WebCore::MediaDevices::listenForDeviceChanges):
     30        (WebCore::MediaDevices::addEventListener):
     31        * Modules/mediastream/MediaDevices.h:
     32        * Modules/mediastream/MediaDevices.idl:
     33        * Modules/mediastream/MediaDevicesEnumerationRequest.cpp: Removed.
     34        * Modules/mediastream/MediaDevicesEnumerationRequest.h: Removed.
     35        * Modules/mediastream/MediaDevicesRequest.cpp: Removed.
     36        * Modules/mediastream/MediaDevicesRequest.h: Removed.
     37        * Modules/mediastream/RTCRtpSender.cpp:
     38        * Modules/mediastream/UserMediaClient.h:
     39        * Modules/mediastream/UserMediaController.cpp:
     40        (WebCore::isAllowedToUse):
     41        (WebCore::UserMediaController::canCallGetUserMedia const):
     42        * Modules/mediastream/UserMediaController.h:
     43        (WebCore::UserMediaController::enumerateMediaDevices):
     44        * Sources.txt:
     45        * WebCore.xcodeproj/project.pbxproj:
     46
    1472019-08-18  Yusuke Suzuki  <ysuzuki@apple.com>
    248
  • trunk/Source/WebCore/Headers.cmake

    r248713 r248847  
    9191    Modules/mediastream/DoubleRange.h
    9292    Modules/mediastream/LongRange.h
    93     Modules/mediastream/MediaDevicesEnumerationRequest.h
    9493    Modules/mediastream/MediaStreamTrack.h
    9594    Modules/mediastream/MediaTrackConstraints.h
  • trunk/Source/WebCore/Modules/mediastream/MediaDeviceInfo.cpp

    r243887 r248847  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3535WTF_MAKE_ISO_ALLOCATED_IMPL(MediaDeviceInfo);
    3636
    37 inline MediaDeviceInfo::MediaDeviceInfo(ScriptExecutionContext* context, const String& label, const String& deviceId, const String& groupId, Kind kind)
    38     : ContextDestructionObserver(context)
    39     , m_label(label)
     37Ref<MediaDeviceInfo> MediaDeviceInfo::create(const String& label, const String& deviceId, const String& groupId, Kind kind)
     38{
     39    return adoptRef(*new MediaDeviceInfo(label, deviceId, groupId, kind));
     40}
     41
     42MediaDeviceInfo::MediaDeviceInfo(const String& label, const String& deviceId, const String& groupId, Kind kind)
     43    : m_label(label)
    4044    , m_deviceId(deviceId)
    4145    , m_groupId(groupId)
     
    4448}
    4549
    46 Ref<MediaDeviceInfo> MediaDeviceInfo::create(ScriptExecutionContext* context, const String& label, const String& deviceId, const String& groupId, Kind kind)
    47 {
    48     return adoptRef(*new MediaDeviceInfo(context, label, deviceId, groupId, kind));
    49 }
    50 
    5150} // namespace WebCore
    5251
  • trunk/Source/WebCore/Modules/mediastream/MediaDeviceInfo.h

    r243887 r248847  
    11/*
    2  * Copyright (C) 2015 Apple Inc. All rights reserved.
     2 * Copyright (C) 2015-2019 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
     
    3434namespace WebCore {
    3535
    36 class MediaDeviceInfo final : public RefCounted<MediaDeviceInfo>, public ScriptWrappable, private ContextDestructionObserver {
     36class MediaDeviceInfo final : public RefCounted<MediaDeviceInfo>, public ScriptWrappable {
    3737    WTF_MAKE_ISO_ALLOCATED(MediaDeviceInfo);
    3838public:
    3939    enum class Kind { Audioinput, Audiooutput, Videoinput };
    4040
    41     static Ref<MediaDeviceInfo> create(ScriptExecutionContext*, const String&, const String&, const String&, Kind);
     41    static Ref<MediaDeviceInfo> create(const String&, const String&, const String&, Kind);
    4242
    4343    const String& label() const { return m_label; }
     
    4747
    4848private:
    49     MediaDeviceInfo(ScriptExecutionContext*, const String&, const String&, const String&, Kind);
     49    MediaDeviceInfo(const String&, const String&, const String&, Kind);
    5050
    5151    const String m_label;
  • trunk/Source/WebCore/Modules/mediastream/MediaDeviceInfo.idl

    r218601 r248847  
    2727    Conditional=MEDIA_STREAM,
    2828    JSGenerateToJSObject,
     29    SkipVTableValidation,
    2930] interface MediaDeviceInfo {
    3031    readonly attribute DOMString deviceId;
  • trunk/Source/WebCore/Modules/mediastream/MediaDevices.cpp

    r246490 r248847  
    11/*
    22 * Copyright (C) 2015 Ericsson AB. All rights reserved.
    3  * Copyright (C) 2015-2018 Apple Inc. All rights reserved.
     3 * Copyright (C) 2015-2019 Apple Inc. All rights reserved.
    44 *
    55 * Redistribution and use in source and binary forms, with or without
     
    3838#include "Event.h"
    3939#include "EventNames.h"
    40 #include "MediaDevicesRequest.h"
     40#include "JSMediaDeviceInfo.h"
    4141#include "MediaTrackSupportedConstraints.h"
    4242#include "RealtimeMediaSourceSettings.h"
     
    6262    static_assert(static_cast<size_t>(MediaDevices::DisplayCaptureSurfaceType::Application) == static_cast<size_t>(RealtimeMediaSourceSettings::DisplaySurfaceType::Application), "MediaDevices::DisplayCaptureSurfaceType::Application is not RealtimeMediaSourceSettings::DisplaySurfaceType::Application as expected");
    6363    static_assert(static_cast<size_t>(MediaDevices::DisplayCaptureSurfaceType::Browser) == static_cast<size_t>(RealtimeMediaSourceSettings::DisplaySurfaceType::Browser), "MediaDevices::DisplayCaptureSurfaceType::Browser is not RealtimeMediaSourceSettings::DisplaySurfaceType::Browser as expected");
     64
     65    if (auto* controller = UserMediaController::from(document.page())) {
     66        m_canAccessCamera = controller->canCallGetUserMedia(document, { UserMediaController::CaptureType::Camera }) == UserMediaController::GetUserMediaAccess::CanCall;
     67        m_canAccessMicrophone = controller->canCallGetUserMedia(document, { UserMediaController::CaptureType::Microphone }) == UserMediaController::GetUserMediaAccess::CanCall;
     68    }
    6469}
    6570
     
    7479            controller->removeDeviceChangeObserver(m_deviceChangeToken);
    7580    }
     81    m_devices.clear();
    7682}
    7783
     
    130136}
    131137
    132 void MediaDevices::enumerateDevices(EnumerateDevicesPromise&& promise) const
     138void MediaDevices::refreshDevices(const Vector<CaptureDevice>& newDevices)
     139{
     140    Vector<Ref<MediaDeviceInfo>> devices;
     141    for (auto& newDevice : newDevices) {
     142        if (!m_canAccessMicrophone && newDevice.type() == CaptureDevice::DeviceType::Microphone)
     143            continue;
     144        if (!m_canAccessCamera && newDevice.type() == CaptureDevice::DeviceType::Camera)
     145            continue;
     146
     147        auto index = m_devices.findMatching([&newDevice](auto& oldDevice) {
     148            return oldDevice->deviceId() == newDevice.persistentId();
     149        });
     150        if (index != notFound) {
     151            devices.append(m_devices[index].copyRef());
     152            continue;
     153        }
     154
     155        auto deviceType = newDevice.type() == CaptureDevice::DeviceType::Microphone ? MediaDeviceInfo::Kind::Audioinput : MediaDeviceInfo::Kind::Videoinput;
     156        devices.append(MediaDeviceInfo::create(newDevice.label(), newDevice.persistentId(), newDevice.groupId(), deviceType));
     157    }
     158    m_devices = WTFMove(devices);
     159}
     160
     161void MediaDevices::enumerateDevices(EnumerateDevicesPromise&& promise)
    133162{
    134163    auto* document = this->document();
    135164    if (!document)
    136165        return;
    137     MediaDevicesRequest::create(*document, WTFMove(promise))->start();
     166
     167    auto* controller = UserMediaController::from(document->page());
     168    if (!controller) {
     169        promise.resolve({ });
     170        return;
     171    }
     172    if (!m_canAccessCamera && !m_canAccessMicrophone) {
     173        controller->logGetUserMediaDenial(*document, UserMediaController::GetUserMediaAccess::BlockedByFeaturePolicy, UserMediaController::BlockedCaller::EnumerateDevices);
     174        promise.resolve({ });
     175        return;
     176    }
     177
     178    controller->enumerateMediaDevices(*document, [this, weakThis = makeWeakPtr(this), promise = WTFMove(promise)](const auto& newDevices, const auto& deviceIDHashSalt) mutable {
     179        if (!weakThis || isContextStopped())
     180            return;
     181
     182        this->document()->setDeviceIDHashSalt(deviceIDHashSalt);
     183        refreshDevices(newDevices);
     184        promise.resolve(m_devices);
     185    });
    138186}
    139187
     
    159207void MediaDevices::scheduledEventTimerFired()
    160208{
    161     if (scriptExecutionContext())
    162         dispatchEvent(Event::create(eventNames().devicechangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
     209    if (isContextStopped())
     210        return;
     211
     212    dispatchEvent(Event::create(eventNames().devicechangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
    163213}
    164214
     
    178228}
    179229
     230void MediaDevices::listenForDeviceChanges()
     231{
     232    if (m_listeningForDeviceChanges || (!m_canAccessCamera && !m_canAccessMicrophone))
     233        return;
     234
     235    m_listeningForDeviceChanges = true;
     236
     237    auto* document = this->document();
     238    auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
     239    if (!controller)
     240        return;
     241
     242    m_deviceChangeToken = controller->addDeviceChangeObserver([weakThis = makeWeakPtr(*this), this]() {
     243        if (!weakThis || m_scheduledEventTimer.isActive())
     244            return;
     245
     246        m_scheduledEventTimer.startOneShot(Seconds(randomNumber() / 2));
     247    });
     248}
     249
    180250bool MediaDevices::addEventListener(const AtomString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
    181251{
    182     if (!m_listeningForDeviceChanges && eventType == eventNames().devicechangeEvent) {
    183         auto* document = this->document();
    184         auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
    185         if (document && controller) {
    186             m_listeningForDeviceChanges = true;
    187 
    188             m_deviceChangeToken = controller->addDeviceChangeObserver([weakThis = makeWeakPtr(*this), this]() {
    189 
    190                 if (!weakThis || m_scheduledEventTimer.isActive())
    191                     return;
    192 
    193                 auto* document = this->document();
    194                 auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
    195                 if (!controller)
    196                     return;
    197 
    198                 bool canAccessMicrophone = controller->canCallGetUserMedia(*document, { UserMediaController::CaptureType::Microphone }) == UserMediaController::GetUserMediaAccess::CanCall;
    199                 bool canAccessCamera = controller->canCallGetUserMedia(*document, { UserMediaController::CaptureType::Camera }) == UserMediaController::GetUserMediaAccess::CanCall;
    200                 if (!canAccessMicrophone && !canAccessCamera)
    201                     return;
    202 
    203                 m_scheduledEventTimer.startOneShot(Seconds(randomNumber() / 2));
    204             });
    205         }
    206     }
     252    if (eventType == eventNames().devicechangeEvent)
     253        listenForDeviceChanges();
    207254
    208255    return EventTargetWithInlineData::addEventListener(eventType, WTFMove(listener), options);
  • trunk/Source/WebCore/Modules/mediastream/MediaDevices.h

    r246490 r248847  
    7878    void getUserMedia(const StreamConstraints&, Promise&&) const;
    7979    void getDisplayMedia(const StreamConstraints&, Promise&&) const;
    80     void enumerateDevices(EnumerateDevicesPromise&&) const;
     80    void enumerateDevices(EnumerateDevicesPromise&&);
    8181    MediaTrackSupportedConstraints getSupportedConstraints();
    8282
     
    9191    void scheduledEventTimerFired();
    9292    bool addEventListener(const AtomString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
     93
     94    void refreshDevices(const Vector<CaptureDevice>&);
     95    void listenForDeviceChanges();
    9396
    9497    friend class JSMediaDevicesOwner;
     
    111114    bool m_listeningForDeviceChanges { false };
    112115    bool m_disableGetDisplayMediaUserGestureConstraint { false };
     116
     117    Vector<Ref<MediaDeviceInfo>> m_devices;
     118    bool m_canAccessCamera { false };
     119    bool m_canAccessMicrophone { false };
    113120};
    114121
  • trunk/Source/WebCore/Modules/mediastream/RTCRtpSender.cpp

    r248282 r248847  
    3737#include "RTCDTMFSenderBackend.h"
    3838#include "RTCRtpCapabilities.h"
     39#include "RTCRtpTransceiver.h"
    3940#include "RuntimeEnabledFeatures.h"
    4041#include <wtf/IsoMallocInlines.h>
  • trunk/Source/WebCore/Modules/mediastream/UserMediaClient.h

    r235086 r248847  
    3434#if ENABLE(MEDIA_STREAM)
    3535
     36#include <wtf/CompletionHandler.h>
    3637#include <wtf/ObjectIdentifier.h>
    3738
    3839namespace WebCore {
    3940
    40 class MediaDevicesEnumerationRequest;
     41class CaptureDevice;
    4142class Page;
    4243class UserMediaRequest;
     
    4950    virtual void cancelUserMediaAccessRequest(UserMediaRequest&) = 0;
    5051
    51     virtual void enumerateMediaDevices(MediaDevicesEnumerationRequest&) = 0;
    52     virtual void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&) = 0;
     52    virtual void enumerateMediaDevices(Document&, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&&) = 0;
    5353
    5454    enum DeviceChangeObserverTokenType { };
  • trunk/Source/WebCore/Modules/mediastream/UserMediaController.cpp

    r248846 r248847  
    8686}
    8787
    88 static UserMediaController::GetUserMediaAccess isAllowedToUse(Document& document, Document& topDocument, OptionSet<UserMediaController::CaptureType> types)
     88static UserMediaController::GetUserMediaAccess isAllowedToUse(const Document& document, const Document& topDocument, OptionSet<UserMediaController::CaptureType> types)
    8989{
    9090    if (&document == &topDocument)
     
    107107}
    108108
    109 UserMediaController::GetUserMediaAccess UserMediaController::canCallGetUserMedia(Document& document, OptionSet<UserMediaController::CaptureType> types)
     109UserMediaController::GetUserMediaAccess UserMediaController::canCallGetUserMedia(const Document& document, OptionSet<UserMediaController::CaptureType> types) const
    110110{
    111111    ASSERT(!types.isEmpty());
  • trunk/Source/WebCore/Modules/mediastream/UserMediaController.h

    r238091 r248847  
    3030#include "Page.h"
    3131#include "UserMediaClient.h"
     32#include <wtf/CompletionHandler.h>
    3233
    3334namespace WebCore {
     
    4647    void cancelUserMediaAccessRequest(UserMediaRequest&);
    4748
    48     void enumerateMediaDevices(MediaDevicesEnumerationRequest&);
    49     void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&);
     49    void enumerateMediaDevices(Document&, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&&);
    5050
    5151    UserMediaClient::DeviceChangeObserverToken addDeviceChangeObserver(WTF::Function<void()>&&);
     
    6464        Display = 1 << 3
    6565    };
    66     GetUserMediaAccess canCallGetUserMedia(Document&, OptionSet<CaptureType>);
     66    GetUserMediaAccess canCallGetUserMedia(const Document&, OptionSet<CaptureType>) const;
    6767
    6868    enum class BlockedCaller {
     
    9090}
    9191
    92 inline void UserMediaController::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
     92inline void UserMediaController::enumerateMediaDevices(Document& document, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&& completionHandler)
    9393{
    94     m_client->enumerateMediaDevices(request);
     94    m_client->enumerateMediaDevices(document, WTFMove(completionHandler));
    9595}
    9696
    97 inline void UserMediaController::cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest& request)
    98 {
    99     m_client->cancelMediaDevicesEnumerationRequest(request);
    100 }
    10197
    10298inline UserMediaClient::DeviceChangeObserverToken UserMediaController::addDeviceChangeObserver(WTF::Function<void()>&& observer)
  • trunk/Source/WebCore/Modules/webgpu/WebGPUDevice.cpp

    r248606 r248847  
    3737#include "GPUBufferDescriptor.h"
    3838#include "GPUCommandBuffer.h"
     39#include "GPUComputePipelineDescriptor.h"
    3940#include "GPUPipelineStageDescriptor.h"
    4041#include "GPURenderPipelineDescriptor.h"
  • trunk/Source/WebCore/Sources.txt

    r248751 r248847  
    161161Modules/mediastream/MediaDeviceInfo.cpp
    162162Modules/mediastream/MediaDevices.cpp
    163 Modules/mediastream/MediaDevicesEnumerationRequest.cpp
    164 Modules/mediastream/MediaDevicesRequest.cpp
    165163Modules/mediastream/MediaStream.cpp
    166164Modules/mediastream/MediaStreamTrack.cpp
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r248751 r248847  
    122122                073794FA19F5864E00E5A045 /* RTCDataChannelHandlerMock.h in Headers */ = {isa = PBXBuildFile; fileRef = 073794F419F5864E00E5A045 /* RTCDataChannelHandlerMock.h */; };
    123123                073794FE19F5864E00E5A045 /* RTCNotifiersMock.h in Headers */ = {isa = PBXBuildFile; fileRef = 073794F819F5864E00E5A045 /* RTCNotifiersMock.h */; };
    124                 07394ECA1BAB2CD700BE99CD /* MediaDevicesRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 07394EC91BAB2CD700BE99CD /* MediaDevicesRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    125124                073A15542177A42600EA08F2 /* RemoteVideoSample.h in Headers */ = {isa = PBXBuildFile; fileRef = 073A15532177A39A00EA08F2 /* RemoteVideoSample.h */; settings = {ATTRIBUTES = (Private, ); }; };
    126125                073B87671E4385AC0071C0EC /* AudioSampleBufferList.h in Headers */ = {isa = PBXBuildFile; fileRef = 073B87631E43859D0071C0EC /* AudioSampleBufferList.h */; };
     
    197196                07AB996918DA3C010018771E /* RTCConfiguration.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AB996518DA3C010018771E /* RTCConfiguration.h */; };
    198197                07AB996B18DA3C010018771E /* RTCIceServer.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AB996718DA3C010018771E /* RTCIceServer.h */; };
    199                 07ABEF6E1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h in Headers */ = {isa = PBXBuildFile; fileRef = 07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */; settings = {ATTRIBUTES = (Private, ); }; };
    200198                07AFF4221EFB144900B545B3 /* CoreAudioCaptureSourceIOS.h in Headers */ = {isa = PBXBuildFile; fileRef = 07AFF4201EFB144700B545B3 /* CoreAudioCaptureSourceIOS.h */; };
    201199                07AFF4231EFB144900B545B3 /* CoreAudioCaptureSourceIOS.mm in Sources */ = {isa = PBXBuildFile; fileRef = 07AFF4211EFB144700B545B3 /* CoreAudioCaptureSourceIOS.mm */; };
     
    53525350                073794F719F5864E00E5A045 /* RTCNotifiersMock.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RTCNotifiersMock.cpp; sourceTree = "<group>"; };
    53535351                073794F819F5864E00E5A045 /* RTCNotifiersMock.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCNotifiersMock.h; sourceTree = "<group>"; };
    5354                 07394EC71BAB2CCD00BE99CD /* MediaDevicesRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaDevicesRequest.cpp; sourceTree = "<group>"; };
    5355                 07394EC91BAB2CD700BE99CD /* MediaDevicesRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaDevicesRequest.h; sourceTree = "<group>"; };
    53565352                073A15512177A39800EA08F2 /* RemoteVideoSample.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RemoteVideoSample.cpp; sourceTree = "<group>"; };
    53575353                073A15532177A39A00EA08F2 /* RemoteVideoSample.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RemoteVideoSample.h; sourceTree = "<group>"; };
     
    54455441                07AB996718DA3C010018771E /* RTCIceServer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RTCIceServer.h; sourceTree = "<group>"; };
    54465442                07AB996818DA3C010018771E /* RTCIceServer.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = RTCIceServer.idl; sourceTree = "<group>"; };
    5447                 07ABEF6B1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaDevicesEnumerationRequest.cpp; sourceTree = "<group>"; };
    5448                 07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaDevicesEnumerationRequest.h; sourceTree = "<group>"; };
    54495443                07AFF4201EFB144700B545B3 /* CoreAudioCaptureSourceIOS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CoreAudioCaptureSourceIOS.h; sourceTree = "<group>"; };
    54505444                07AFF4211EFB144700B545B3 /* CoreAudioCaptureSourceIOS.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = CoreAudioCaptureSourceIOS.mm; sourceTree = "<group>"; };
     
    1567415668                                5EA725CE1ACABCD900EAD17B /* MediaDevices.h */,
    1567515669                                5EA725CF1ACABCD900EAD17B /* MediaDevices.idl */,
    15676                                 07ABEF6B1D8A1C5800F21972 /* MediaDevicesEnumerationRequest.cpp */,
    15677                                 07ABEF6D1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h */,
    15678                                 07394EC71BAB2CCD00BE99CD /* MediaDevicesRequest.cpp */,
    15679                                 07394EC91BAB2CD700BE99CD /* MediaDevicesRequest.h */,
    1568015670                                07221B4C17CEC32700848E51 /* MediaStream.cpp */,
    1568115671                                07221B4D17CEC32700848E51 /* MediaStream.h */,
     
    3067530665                                15145B901B3A1CE000662BF7 /* MediaDeviceInfo.h in Headers */,
    3067630666                                5EA725D31ACABD4700EAD17B /* MediaDevices.h in Headers */,
    30677                                 07ABEF6E1D8A1C7600F21972 /* MediaDevicesEnumerationRequest.h in Headers */,
    30678                                 07394ECA1BAB2CD700BE99CD /* MediaDevicesRequest.h in Headers */,
    3067930667                                97205AB81239291000B17380 /* MediaDocument.h in Headers */,
    3068030668                                FD6F252D13F5EF0E0065165F /* MediaElementAudioSourceNode.h in Headers */,
  • trunk/Source/WebKit/ChangeLog

    r248846 r248847  
     12019-08-19  Youenn Fablet  <youenn@apple.com>
     2
     3        enumerateDevices should return the same JS objects if called twice
     4        https://bugs.webkit.org/show_bug.cgi?id=200767
     5
     6        Reviewed by Eric Carlson.
     7
     8        Update code as enumerate device request is now gone.
     9        Make use of async IPC to simplify code since we are now passing a completion handler directly.
     10
     11        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
     12        (WebKit::UserMediaPermissionRequestManagerProxy::captureDevicesChanged):
     13        (WebKit::UserMediaPermissionRequestManagerProxy::finishGrantingRequest):
     14        (WebKit::UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame):
     15        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
     16        * UIProcess/WebPageProxy.cpp:
     17        (WebKit::WebPageProxy::maybeInitializeSandboxExtensionHandle):
     18        * UIProcess/WebPageProxy.h:
     19        * UIProcess/WebPageProxy.messages.in:
     20        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
     21        (WebKit::UserMediaPermissionRequestManager::enumerateMediaDevices):
     22        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
     23        * WebProcess/WebCoreSupport/WebUserMediaClient.cpp:
     24        (WebKit::WebUserMediaClient::enumerateMediaDevices):
     25        * WebProcess/WebCoreSupport/WebUserMediaClient.h:
     26        * WebProcess/WebPage/WebPage.cpp:
     27        * WebProcess/WebPage/WebPage.h:
     28        * WebProcess/WebPage/WebPage.messages.in:
     29
    1302019-08-18  Yusuke Suzuki  <ysuzuki@apple.com>
    231
  • trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp

    r248713 r248847  
    3939#include <WebCore/SecurityOriginData.h>
    4040#include <WebCore/UserMediaRequest.h>
     41#include <wtf/Scope.h>
    4142
    4243namespace WebKit {
     
    122123        return;
    123124
    124     auto handler = [this](PermissionInfo permissionInfo) mutable {
    125         switch (permissionInfo) {
    126         case PermissionInfo::Error:
    127             return;
    128         case PermissionInfo::Unknown:
    129             if (m_grantedRequests.isEmpty())
    130                 return;
    131             break;
    132         case PermissionInfo::Granted:
    133             break;
    134         }
    135         if (!m_page.hasRunningProcess())
    136             return;
    137 
    138         m_page.process().send(Messages::WebPage::CaptureDevicesChanged(), m_page.pageID());
    139     };
    140 
    141125    auto origin = WebCore::SecurityOrigin::create(m_page.mainFrame()->url());
    142     getUserMediaPermissionInfo(m_page.mainFrame()->frameID(), origin.get(), WTFMove(origin), WTFMove(handler));
    143 #endif
    144 }
     126    getUserMediaPermissionInfo(m_page.mainFrame()->frameID(), origin.get(), WTFMove(origin), [this](PermissionInfo permissionInfo) {
     127        captureDevicesChanged(permissionInfo);
     128    });
     129#endif
     130}
     131
     132#if ENABLE(MEDIA_STREAM)
     133void UserMediaPermissionRequestManagerProxy::captureDevicesChanged(PermissionInfo permissionInfo)
     134{
     135    switch (permissionInfo) {
     136    case PermissionInfo::Error:
     137        return;
     138    case PermissionInfo::Unknown:
     139        if (m_grantedRequests.isEmpty())
     140            return;
     141        break;
     142    case PermissionInfo::Granted:
     143        break;
     144    }
     145    if (!m_page.hasRunningProcess())
     146        return;
     147
     148    m_page.process().send(Messages::WebPage::CaptureDevicesChanged(), m_page.pageID());
     149}
     150#endif
    145151
    146152void UserMediaPermissionRequestManagerProxy::clearCachedState()
     
    227233        m_grantedRequests.append(makeRef(request));
    228234
     235    // FIXME: m_hasFilteredDeviceList will trigger ondevicechange events for various documents from different origins.
    229236    if (m_hasFilteredDeviceList)
    230         captureDevicesChanged();
     237        captureDevicesChanged(PermissionInfo::Granted);
    231238    m_hasFilteredDeviceList = false;
    232239
     
    605612#endif
    606613
    607 void UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame(uint64_t userMediaID, FrameIdentifier frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin)
    608 {
    609 #if ENABLE(MEDIA_STREAM)
    610     ALWAYS_LOG(LOGIDENTIFIER, userMediaID);
    611 
    612     auto completionHandler = [this, userMediaID, frameID, userMediaDocumentOrigin = userMediaDocumentOrigin.copyRef(), topLevelDocumentOrigin = topLevelDocumentOrigin.copyRef()](PermissionInfo permissionInfo) mutable {
     614void UserMediaPermissionRequestManagerProxy::enumerateMediaDevicesForFrame(FrameIdentifier frameID, Ref<SecurityOrigin>&& userMediaDocumentOrigin, Ref<SecurityOrigin>&& topLevelDocumentOrigin, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&& completionHandler)
     615{
     616#if ENABLE(MEDIA_STREAM)
     617    ALWAYS_LOG(LOGIDENTIFIER);
     618
     619    auto callback = [this, frameID, userMediaDocumentOrigin = userMediaDocumentOrigin.copyRef(), topLevelDocumentOrigin = topLevelDocumentOrigin.copyRef(), completionHandler = WTFMove(completionHandler)](PermissionInfo permissionInfo) mutable {
     620        auto callCompletionHandler = makeScopeExit([&completionHandler] {
     621            completionHandler({ }, { });
     622        });
    613623
    614624        bool originHasPersistentAccess;
     
    632642        auto& requestOrigin = userMediaDocumentOrigin.get();
    633643        auto& topOrigin = topLevelDocumentOrigin.get();
    634         m_page.websiteDataStore().deviceIdHashSaltStorage().deviceIdHashSaltForOrigin(requestOrigin, topOrigin, [this, weakThis = makeWeakPtr(*this), requestID, frameID, userMediaID, userMediaDocumentOrigin = WTFMove(userMediaDocumentOrigin), topLevelDocumentOrigin = WTFMove(topLevelDocumentOrigin), originHasPersistentAccess] (String&& deviceIDHashSalt) {
     644
     645        callCompletionHandler.release();
     646        m_page.websiteDataStore().deviceIdHashSaltStorage().deviceIdHashSaltForOrigin(requestOrigin, topOrigin, [this, weakThis = makeWeakPtr(*this), requestID, frameID, userMediaDocumentOrigin = WTFMove(userMediaDocumentOrigin), topLevelDocumentOrigin = WTFMove(topLevelDocumentOrigin), originHasPersistentAccess, completionHandler = WTFMove(completionHandler)](String&& deviceIDHashSalt) mutable {
     647            auto callCompletionHandler = makeScopeExit([&completionHandler] {
     648                completionHandler({ }, { });
     649            });
     650
    635651            if (!weakThis || !m_pendingDeviceRequests.remove(requestID))
    636652                return;
     
    643659            bool revealIdsAndLabels = originHasPersistentAccess || wasGrantedVideoOrAudioAccess(frameID, userMediaDocumentOrigin.get(), topLevelDocumentOrigin.get());
    644660
    645             m_page.process().send(Messages::WebPage::DidCompleteMediaDeviceEnumeration { userMediaID, computeFilteredDeviceList(revealIdsAndLabels, deviceIDHashSalt), deviceIDHashSalt, originHasPersistentAccess }, m_page.pageID());
     661            callCompletionHandler.release();
     662            completionHandler(computeFilteredDeviceList(revealIdsAndLabels, deviceIDHashSalt), deviceIDHashSalt);
    646663        });
    647664    };
    648665
    649     getUserMediaPermissionInfo(frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(completionHandler));
     666    getUserMediaPermissionInfo(frameID, WTFMove(userMediaDocumentOrigin), WTFMove(topLevelDocumentOrigin), WTFMove(callback));
    650667#else
    651     UNUSED_PARAM(userMediaID);
    652668    UNUSED_PARAM(frameID);
    653669    UNUSED_PARAM(userMediaDocumentOrigin);
    654670    UNUSED_PARAM(topLevelDocumentOrigin);
     671    completionHandler({ }, { });
    655672#endif
    656673}
  • trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h

    r248762 r248847  
    7070    void denyRequest(UserMediaPermissionRequestProxy&, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason, const String& invalidConstraint = { });
    7171
    72     void enumerateMediaDevicesForFrame(uint64_t userMediaID, WebCore::FrameIdentifier, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin);
     72    void enumerateMediaDevicesForFrame(WebCore::FrameIdentifier, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, CompletionHandler<void(const Vector<WebCore::CaptureDevice>&, const String&)>&&);
    7373
    7474    void stopCapture();
     
    106106    using PermissionInfo = UserMediaPermissionCheckProxy::PermissionInfo;
    107107    void getUserMediaPermissionInfo(WebCore::FrameIdentifier, Ref<WebCore::SecurityOrigin>&& userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, CompletionHandler<void(PermissionInfo)>&&);
     108    void captureDevicesChanged(PermissionInfo);
    108109
    109110    RequestAction getRequestAction(const UserMediaPermissionRequestProxy&);
  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r248846 r248847  
    74637463}
    74647464
    7465 void WebPageProxy::enumerateMediaDevicesForFrame(uint64_t userMediaID, FrameIdentifier frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData)
     7465void WebPageProxy::enumerateMediaDevicesForFrame(FrameIdentifier frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&& completionHandler)
    74667466{
    74677467#if ENABLE(MEDIA_STREAM)
     
    74697469    MESSAGE_CHECK(m_process, frame);
    74707470
    7471     userMediaPermissionRequestManager().enumerateMediaDevicesForFrame(userMediaID, frameID, userMediaDocumentOriginData.securityOrigin(), topLevelDocumentOriginData.securityOrigin());
     7471    userMediaPermissionRequestManager().enumerateMediaDevicesForFrame(frameID, userMediaDocumentOriginData.securityOrigin(), topLevelDocumentOriginData.securityOrigin(), WTFMove(completionHandler));
    74727472#else
    74737473    UNUSED_PARAM(userMediaID);
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r248762 r248847  
    17151715#endif
    17161716    void requestUserMediaPermissionForFrame(uint64_t userMediaID, WebCore::FrameIdentifier, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier, WebCore::MediaStreamRequest&&);
    1717     void enumerateMediaDevicesForFrame(uint64_t userMediaID, WebCore::FrameIdentifier, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData);
     1717    void enumerateMediaDevicesForFrame(WebCore::FrameIdentifier, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData, CompletionHandler<void(const Vector<WebCore::CaptureDevice>&, const String&)>&&);
    17181718    void beginMonitoringCaptureDevices();
    17191719
  • trunk/Source/WebKit/UIProcess/WebPageProxy.messages.in

    r248713 r248847  
    283283    # Geolocation messages
    284284    RequestGeolocationPermissionForFrame(uint64_t geolocationID, WebCore::FrameIdentifier frameID, String originIdentifier)
    285    
     285
    286286#if ENABLE(MEDIA_STREAM)
    287287    # MediaSteam messages
    288288    RequestUserMediaPermissionForFrame(uint64_t userMediaID, WebCore::FrameIdentifier frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier, struct WebCore::MediaStreamRequest request)
    289     EnumerateMediaDevicesForFrame(uint64_t userMediaID, WebCore::FrameIdentifier frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier)
     289    EnumerateMediaDevicesForFrame(WebCore::FrameIdentifier frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier) -> (Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt) Async
    290290    BeginMonitoringCaptureDevices()
    291291#endif
     
    299299
    300300    # Spelling and grammar messages
    301 #if USE(UNIFIED_TEXT_CHECKING) 
     301#if USE(UNIFIED_TEXT_CHECKING)
    302302    CheckTextOfParagraph(String text, OptionSet<WebCore::TextCheckingType> checkingTypes, int32_t insertionPoint) -> (Vector<WebCore::TextCheckingResult> results) Synchronous
    303303#endif
  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp

    r245625 r248847  
    160160}
    161161
    162 void UserMediaPermissionRequestManager::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
    163 {
    164     auto* document = downcast<Document>(request.scriptExecutionContext());
    165     auto* frame = document ? document->frame() : nullptr;
    166 
     162void UserMediaPermissionRequestManager::enumerateMediaDevices(Document& document, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&& completionHandler)
     163{
     164    auto* frame = document.frame();
    167165    if (!frame) {
    168         request.setDeviceInfo(Vector<CaptureDevice>(), emptyString(), false);
    169         return;
    170     }
    171 
    172     uint64_t requestID = generateRequestID();
    173     m_idToMediaDevicesEnumerationRequestMap.add(requestID, &request);
    174     m_mediaDevicesEnumerationRequestToIDMap.add(&request, requestID);
    175 
    176     WebFrame* webFrame = WebFrame::fromCoreFrame(*frame);
    177     ASSERT(webFrame);
    178 
    179     SecurityOrigin* topLevelDocumentOrigin = request.topLevelDocumentOrigin();
    180     ASSERT(topLevelDocumentOrigin);
    181     m_page.send(Messages::WebPageProxy::EnumerateMediaDevicesForFrame(requestID, webFrame->frameID(), request.userMediaDocumentOrigin()->data(), topLevelDocumentOrigin->data()));
    182 }
    183 
    184 void UserMediaPermissionRequestManager::cancelMediaDevicesEnumeration(WebCore::MediaDevicesEnumerationRequest& request)
    185 {
    186     uint64_t requestID = m_mediaDevicesEnumerationRequestToIDMap.take(&request);
    187     if (!requestID)
    188         return;
    189     request.setDeviceInfo(Vector<CaptureDevice>(), emptyString(), false);
    190     m_idToMediaDevicesEnumerationRequestMap.remove(requestID);
    191 }
    192 
    193 void UserMediaPermissionRequestManager::didCompleteMediaDeviceEnumeration(uint64_t requestID, const Vector<CaptureDevice>& deviceList, String&& mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
    194 {
    195     RefPtr<MediaDevicesEnumerationRequest> request = m_idToMediaDevicesEnumerationRequestMap.take(requestID);
    196     if (!request)
    197         return;
    198     m_mediaDevicesEnumerationRequestToIDMap.remove(request);
    199    
    200     request->setDeviceInfo(deviceList, WTFMove(mediaDeviceIdentifierHashSalt), hasPersistentAccess);
     166        completionHandler({ }, emptyString());
     167        return;
     168    }
     169
     170    m_page.sendWithAsyncReply(Messages::WebPageProxy::EnumerateMediaDevicesForFrame { WebFrame::fromCoreFrame(*frame)->frameID(), document.securityOrigin().data(), document.topOrigin().data() }, WTFMove(completionHandler));
    201171}
    202172
  • trunk/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h

    r248762 r248847  
    2525#include <WebCore/MediaCanStartListener.h>
    2626#include <WebCore/MediaConstraints.h>
    27 #include <WebCore/MediaDevicesEnumerationRequest.h>
    2827#include <WebCore/UserMediaClient.h>
    2928#include <WebCore/UserMediaRequest.h>
     
    4746    void userMediaAccessWasDenied(uint64_t, WebCore::UserMediaRequest::MediaAccessDenialReason, String&&);
    4847
    49     void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&);
    50     void cancelMediaDevicesEnumeration(WebCore::MediaDevicesEnumerationRequest&);
    51     void didCompleteMediaDeviceEnumeration(uint64_t, const Vector<WebCore::CaptureDevice>& deviceList, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess);
     48    void enumerateMediaDevices(WebCore::Document&, CompletionHandler<void(const Vector<WebCore::CaptureDevice>&, const String&)>&&);
    5249
    5350    WebCore::UserMediaClient::DeviceChangeObserverToken addDeviceChangeObserver(WTF::Function<void()>&&);
     
    7067    HashMap<RefPtr<WebCore::Document>, Vector<RefPtr<WebCore::UserMediaRequest>>> m_blockedUserMediaRequests;
    7168
    72     HashMap<uint64_t, RefPtr<WebCore::MediaDevicesEnumerationRequest>> m_idToMediaDevicesEnumerationRequestMap;
    73     HashMap<RefPtr<WebCore::MediaDevicesEnumerationRequest>, uint64_t> m_mediaDevicesEnumerationRequestToIDMap;
    74 
    7569    HashMap<WebCore::UserMediaClient::DeviceChangeObserverToken, WTF::Function<void()>> m_deviceChangeObserverMap;
    7670    bool m_monitoringDeviceChange { false };
  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.cpp

    r241281 r248847  
    5151}
    5252
    53 void WebUserMediaClient::enumerateMediaDevices(MediaDevicesEnumerationRequest& request)
     53void WebUserMediaClient::enumerateMediaDevices(Document& document, CompletionHandler<void(const Vector<CaptureDevice>&, const String&)>&& completionHandler)
    5454{
    55     m_page.userMediaPermissionRequestManager().enumerateMediaDevices(request);
    56 }
    57 
    58 void WebUserMediaClient::cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest& request)
    59 {
    60     m_page.userMediaPermissionRequestManager().cancelMediaDevicesEnumeration(request);
     55    m_page.userMediaPermissionRequestManager().enumerateMediaDevices(document, WTFMove(completionHandler));
    6156}
    6257
  • trunk/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.h

    r248762 r248847  
    4141    void cancelUserMediaAccessRequest(WebCore::UserMediaRequest&) override;
    4242
    43     void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&) final;
    44     void cancelMediaDevicesEnumerationRequest(WebCore::MediaDevicesEnumerationRequest&) final;
     43    void enumerateMediaDevices(WebCore::Document&, CompletionHandler<void(const Vector<WebCore::CaptureDevice>&, const String&)>&&) final;
    4544
    4645    DeviceChangeObserverToken addDeviceChangeObserver(WTF::Function<void()>&&) final;
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r248846 r248847  
    42014201}
    42024202
    4203 void WebPage::didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vector<CaptureDevice>& devices, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess)
    4204 {
    4205     m_userMediaPermissionRequestManager->didCompleteMediaDeviceEnumeration(userMediaID, devices, WTFMove(deviceIdentifierHashSalt), originHasPersistentAccess);
    4206 }
    4207 
    42084203void WebPage::captureDevicesChanged()
    42094204{
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r248713 r248847  
    14831483    void userMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String&& invalidConstraint);
    14841484
    1485     void didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vector<WebCore::CaptureDevice>& devices, String&& deviceIdentifierHashSalt, bool originHasPersistentAccess);
    14861485#endif
    14871486
  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.messages.in

    r248713 r248847  
    360360    UserMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt) -> () Async
    361361    UserMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
    362     DidCompleteMediaDeviceEnumeration(uint64_t userMediaID, Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
    363362    CaptureDevicesChanged()
    364363#endif
Note: See TracChangeset for help on using the changeset viewer.