Attachment 347035 Details for Bug 188521 – Patch

[patch] Patch

bug-188521-20180813135108.patch (text/plain), 51.34 KB, created by Eric Carlson on 2018-08-13 13:51:08 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Eric Carlson

Created: 2018-08-13 13:51:08 PDT

Size: 51.34 KB

patch

obsolete

>Subversion Revision: 234799
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 1c8c95ed86dc7ecd19fd9dedf2e0b682f46ef0a9..7c3c016f6ab8dfc9a5800b576ecac54ea5397a30 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,61 @@
>+2018-08-13  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] Move capture device monitoring to WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=188521
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No new tests, updated fast/mediastream/device-change-event-2.html for the changes.
>+
>+        * Modules/mediastream/MediaDevices.cpp:
>+        (WebCore::MediaDevices::MediaDevices): Device change listener is added in addEventListener.
>+        (WebCore::MediaDevices::stop): Device change listener is on the user media controller.
>+        (WebCore::MediaDevices::addEventListener): Add the device change listener only once the first
>+        event handler is added.
>+        * Modules/mediastream/MediaDevices.h:
>+
>+        * Modules/mediastream/UserMediaClient.h:
>+        * Modules/mediastream/UserMediaController.h:
>+        (WebCore::UserMediaController::addDeviceChangeObserver): Pass through to the client.
>+        (WebCore::UserMediaController::removeDeviceChangeObserver): Ditto.
>+
>+        * platform/mediastream/CaptureDeviceManager.cpp:
>+        (CaptureDeviceManager::deviceChanged): Notify RealtimeMediaSourceCenter.
>+        (nextObserverToken): Deleted.
>+        (CaptureDeviceManager::addCaptureDeviceChangedObserver): Deleted.
>+        (CaptureDeviceManager::removeCaptureDeviceChangedObserver): Deleted.
>+        * platform/mediastream/CaptureDeviceManager.h:
>+
>+        * platform/mediastream/RealtimeMediaSourceCenter.cpp:
>+        (WebCore::RealtimeMediaSourceCenter::setDevicesChangedObserver):
>+        (WebCore::RealtimeMediaSourceCenter::captureDevicesChanged):
>+        (WebCore::observerMap): Deleted.
>+        (WebCore::RealtimeMediaSourceCenter::addDevicesChangedObserver): Deleted.
>+        (WebCore::RealtimeMediaSourceCenter::removeDevicesChangedObserver): Deleted.
>+        * platform/mediastream/RealtimeMediaSourceCenter.h:
>+
>+        * platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:
>+        (WebCore::AVAudioSessionCaptureDeviceManager::refreshAudioCaptureDevices): Call base class.
>+
>+        * platform/mediastream/mac/AVCaptureDeviceManager.mm:
>+        (WebCore::AVCaptureDeviceManager::deviceConnected): Ditto.
>+        (WebCore::AVCaptureDeviceManager::deviceDisconnected): Ditto.
>+
>+        * platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp:
>+        (WebCore::deviceHasInputStreams): Drive-by fix, check the number of buffers to see if the
>+        device has input streams.
>+        (WebCore::CoreAudioCaptureDeviceManager::coreAudioCaptureDevices): Use new bool parameter
>+        added to refreshAudioCaptureDevices so we won't trigger a device change event on the first scan.
>+        (WebCore::CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices): Add param.
>+        (WebCore::CoreAudioCaptureDeviceManager::devicesChanged): Use new param.
>+        * platform/mediastream/mac/CoreAudioCaptureDeviceManager.h:
>+
>+        * platform/mock/MockRealtimeMediaSourceCenter.cpp:
>+        (WebCore::MockRealtimeMediaSourceCenter::setDevices): Don't need to call captureDevicesChanged,
>+        it is done in the UI process.
>+        (WebCore::MockRealtimeMediaSourceCenter::addDevice): Ditto.
>+        (WebCore::MockRealtimeMediaSourceCenter::removeDevice): Ditto.
>+
> 2018-08-13  Yusuke Suzuki  <yusukesuzuki@slowstart.org>
> 
>         Expose CloseEvent and CustomEvent to workers
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 9e11b23c708147bd72d54ac8c6440294ad449a11..7e998eaa746a075866ea5c7699d057d6c475ffef 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,56 @@
>+2018-08-13  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] Move capture device monitoring to WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=188521
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
>+        (WebKit::UserMediaPermissionRequestManagerProxy::captureDevicesChanged): Notify as appropriate.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::viewIsBecomingVisible): Change name from
>+        viewIsBecomingVisible. Call captureDevicesChanged if a change happened when not visible.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::watchdogTimerFired): Clear m_pendingDeviceChangeEvent.
>+        (WebKit::UserMediaPermissionRequestManagerProxy::processPregrantedRequests): Deleted.
>+        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
>+
>+        * UIProcess/UserMediaProcessManager.cpp:
>+        (WebKit::UserMediaProcessManager::UserMediaProcessManager): Initialize timer.
>+        (WebKit::UserMediaProcessManager::captureDevicesChanged): New, notify each manager.
>+        (WebKit::UserMediaProcessManager::beginMonitoringCaptureDevices): Cache the device list and 
>+        register device change listener the first time it is called.
>+        * UIProcess/UserMediaProcessManager.h:
>+
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::viewIsBecomingVisible):
>+        (WebKit::WebPageProxy::beginMonitoringCaptureDevices):
>+        * UIProcess/WebPageProxy.h:
>+        * UIProcess/WebPageProxy.messages.in:
>+
>+        * WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp:
>+        (WebKit::UserMediaPermissionRequestManager::addDeviceChangeObserver): Add listener, tell page
>+        to start monitoring device changes.
>+        (WebKit::UserMediaPermissionRequestManager::removeDeviceChangeObserver): Remove listener.
>+        (WebKit::UserMediaPermissionRequestManager::captureDevicesChanged): Call listeners.
>+        * WebProcess/MediaStream/UserMediaPermissionRequestManager.h:
>+
>+        * WebProcess/WebCoreSupport/WebUserMediaClient.cpp:
>+        (WebKit::WebUserMediaClient::addDeviceChangeObserver):
>+        (WebKit::WebUserMediaClient::removeDeviceChangeObserver):
>+        * WebProcess/WebCoreSupport/WebUserMediaClient.h:
>+
>+        * WebProcess/WebPage/WebPage.cpp:
>+        (WebKit::WebPage::captureDevicesChanged):
>+        * WebProcess/WebPage/WebPage.h:
>+        * WebProcess/WebPage/WebPage.messages.in:
>+
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::WebProcess::addMockMediaDevice):
>+        (WebKit::WebProcess::clearMockMediaDevices):
>+        (WebKit::WebProcess::removeMockMediaDevice):
>+        (WebKit::WebProcess::resetMockMediaDevices):
>+        (WebKit::WebProcess::captureDevicesChanged):
>+        * WebProcess/WebProcess.h:
>+
> 2018-08-12  Aditya Keerthi  <akeerthi@apple.com>
> 
>         [macOS] Color wells should appear pressed when presenting a color picker
>diff --git a/Source/WebCore/Modules/mediastream/MediaDevices.cpp b/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>index be9051c93994d5bbc10a0d8aa69419b1714aeeab..0609c29d793573c927f2bcf81d0dfbf128b4724f 100644
>--- a/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>+++ b/Source/WebCore/Modules/mediastream/MediaDevices.cpp
>@@ -41,6 +41,7 @@
> #include "MediaTrackSupportedConstraints.h"
> #include "RealtimeMediaSourceSettings.h"
> #include "RuntimeEnabledFeatures.h"
>+#include "UserMediaController.h"
> #include "UserMediaRequest.h"
> #include <wtf/RandomNumber.h>
> 
>@@ -51,17 +52,6 @@ inline MediaDevices::MediaDevices(Document& document)
>     , m_scheduledEventTimer(*this, &MediaDevices::scheduledEventTimerFired)
>     , m_eventNames(eventNames())
> {
>-    m_deviceChangedToken = RealtimeMediaSourceCenter::singleton().addDevicesChangedObserver([weakThis = makeWeakPtr(*this), this]() {
>-
>-        if (!weakThis)
>-            return;
>-
>-        // FIXME: We should only dispatch an event if the user has been granted access to the type of
>-        // device that was added or removed.
>-        if (!m_scheduledEventTimer.isActive())
>-            m_scheduledEventTimer.startOneShot(Seconds(randomNumber() / 2));
>-    });
>-
>     suspendIfNeeded();
> 
>     static_assert(static_cast<size_t>(MediaDevices::DisplayCaptureSurfaceType::Monitor) == static_cast<size_t>(RealtimeMediaSourceSettings::DisplaySurfaceType::Monitor), "MediaDevices::DisplayCaptureSurfaceType::Monitor is not equal to RealtimeMediaSourceSettings::DisplaySurfaceType::Monitor as expected");
>@@ -74,8 +64,12 @@ MediaDevices::~MediaDevices() = default;
> 
> void MediaDevices::stop()
> {
>-    if (m_deviceChangedToken)
>-        RealtimeMediaSourceCenter::singleton().removeDevicesChangedObserver(m_deviceChangedToken);
>+    if (m_deviceChangeToken) {
>+        auto* document = this->document();
>+        auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
>+        if (document && controller)
>+            controller->removeDeviceChangeObserver(m_deviceChangeToken);
>+    }
> }
> 
> Ref<MediaDevices> MediaDevices::create(Document& document)
>@@ -181,6 +175,27 @@ bool MediaDevices::canSuspendForDocumentSuspension() const
>     return true;
> }
> 
>+bool MediaDevices::addEventListener(const AtomicString& eventType, Ref<EventListener>&& listener, const AddEventListenerOptions& options)
>+{
>+    if (!m_listeningForDeviceChanges && eventType == eventNames().devicechangeEvent) {
>+        auto* document = this->document();
>+        auto* controller = document ? UserMediaController::from(document->page()) : nullptr;
>+        if (document && controller) {
>+            m_listeningForDeviceChanges = true;
>+
>+            m_deviceChangeToken = controller->addDeviceChangeObserver([weakThis = makeWeakPtr(*this), this]() {
>+
>+                if (!weakThis || m_scheduledEventTimer.isActive())
>+                    return;
>+
>+                m_scheduledEventTimer.startOneShot(Seconds(randomNumber() / 2));
>+            });
>+        }
>+    }
>+
>+    return EventTargetWithInlineData::addEventListener(eventType, WTFMove(listener), options);
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebCore/Modules/mediastream/MediaDevices.h b/Source/WebCore/Modules/mediastream/MediaDevices.h
>index 02d1aef9d6f317867a97f195be90614859549cf5..0d40209636bbc6884ce55eec2ca60c92b5f51f91 100644
>--- a/Source/WebCore/Modules/mediastream/MediaDevices.h
>+++ b/Source/WebCore/Modules/mediastream/MediaDevices.h
>@@ -41,11 +41,11 @@
> #include "MediaTrackConstraints.h"
> #include "RealtimeMediaSourceCenter.h"
> #include "Timer.h"
>+#include "UserMediaClient.h"
> #include <wtf/WeakPtr.h>
> 
> namespace WebCore {
> 
>-class Document;
> class MediaDeviceInfo;
> class MediaStream;
> 
>@@ -85,6 +85,7 @@ private:
>     explicit MediaDevices(Document&);
> 
>     void scheduledEventTimerFired();
>+    bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
> 
>     friend class JSMediaDevicesOwner;
> 
>@@ -101,8 +102,9 @@ private:
>     void derefEventTarget() final { deref(); }
> 
>     Timer m_scheduledEventTimer;
>-    RealtimeMediaSourceCenter::DevicesChangedObserverToken m_deviceChangedToken;
>+    UserMediaClient::DeviceChangeObserverToken m_deviceChangeToken;
>     const EventNames& m_eventNames; // Need to cache this so we can use it from GC threads.
>+    bool m_listeningForDeviceChanges { false };
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/mediastream/UserMediaClient.h b/Source/WebCore/Modules/mediastream/UserMediaClient.h
>index 3e3ade1a8c2bd5ea70c027632d760e3a01737dbf..b0c8684fad518ee8e6f1fb383c3a4520100711d9 100644
>--- a/Source/WebCore/Modules/mediastream/UserMediaClient.h
>+++ b/Source/WebCore/Modules/mediastream/UserMediaClient.h
>@@ -49,6 +49,10 @@ public:
>     virtual void enumerateMediaDevices(MediaDevicesEnumerationRequest&) = 0;
>     virtual void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&) = 0;
> 
>+    using DeviceChangeObserverToken = unsigned;
>+    virtual DeviceChangeObserverToken addDeviceChangeObserver(std::function<void()>&&) = 0;
>+    virtual void removeDeviceChangeObserver(DeviceChangeObserverToken) = 0;
>+
> protected:
>     virtual ~UserMediaClient() = default;
> };
>diff --git a/Source/WebCore/Modules/mediastream/UserMediaController.h b/Source/WebCore/Modules/mediastream/UserMediaController.h
>index 2249abf2786bd2235c40188c4ac44aa187d62bf5..b02fb593a945e0da5cca2ad7956e83592a72ffe9 100644
>--- a/Source/WebCore/Modules/mediastream/UserMediaController.h
>+++ b/Source/WebCore/Modules/mediastream/UserMediaController.h
>@@ -1,6 +1,6 @@
> /*
>  * Copyright (C) 2012 Google Inc. All rights reserved.
>- * Copyright (C) 2016 Apple Inc. All rights reserved.
>+ * Copyright (C) 2016-2018 Apple Inc. All rights reserved.
>  *
>  * Redistribution and use in source and binary forms, with or without
>  * modification, are permitted provided that the following conditions
>@@ -48,6 +48,9 @@ public:
>     void enumerateMediaDevices(MediaDevicesEnumerationRequest&);
>     void cancelMediaDevicesEnumerationRequest(MediaDevicesEnumerationRequest&);
> 
>+    UserMediaClient::DeviceChangeObserverToken addDeviceChangeObserver(std::function<void()>&&);
>+    void removeDeviceChangeObserver(UserMediaClient::DeviceChangeObserverToken);
>+
>     WEBCORE_EXPORT static const char* supplementName();
>     static UserMediaController* from(Page* page) { return static_cast<UserMediaController*>(Supplement<Page>::from(page, supplementName())); }
> 
>@@ -75,6 +78,16 @@ inline void UserMediaController::cancelMediaDevicesEnumerationRequest(MediaDevic
>     m_client->cancelMediaDevicesEnumerationRequest(request);
> }
> 
>+inline UserMediaClient::DeviceChangeObserverToken UserMediaController::addDeviceChangeObserver(std::function<void()>&& observer)
>+{
>+    return m_client->addDeviceChangeObserver(WTFMove(observer));
>+}
>+
>+inline void UserMediaController::removeDeviceChangeObserver(UserMediaClient::DeviceChangeObserverToken token)
>+{
>+    m_client->removeDeviceChangeObserver(token);
>+}
>+
> } // namespace WebCore
> 
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebCore/platform/mediastream/CaptureDeviceManager.cpp b/Source/WebCore/platform/mediastream/CaptureDeviceManager.cpp
>index cd147a02b4cd7c0e8127f97ac039865a4f6728ed..477c587a50aa41adb1a8ac04cdaeb391c39ee85c 100644
>--- a/Source/WebCore/platform/mediastream/CaptureDeviceManager.cpp
>+++ b/Source/WebCore/platform/mediastream/CaptureDeviceManager.cpp
>@@ -50,24 +50,14 @@ CaptureDevice CaptureDeviceManager::captureDeviceFromPersistentID(const String&
>     return { };
> }
> 
>-static CaptureDeviceManager::ObserverToken nextObserverToken()
>+void CaptureDeviceManager::deviceChanged()
> {
>-    static CaptureDeviceManager::ObserverToken nextToken = 0;
>-    return ++nextToken;
>-}
>-
>-CaptureDeviceManager::ObserverToken CaptureDeviceManager::addCaptureDeviceChangedObserver(CaptureDeviceChangedCallback&& observer)
>-{
>-    auto token = nextObserverToken();
>-    m_observers.set(token, WTFMove(observer));
>-    return token;
>-}
>+    callOnMainThread([weakThis = makeWeakPtr(*this)] {
>+        if (!weakThis)
>+            return;
> 
>-void CaptureDeviceManager::removeCaptureDeviceChangedObserver(ObserverToken token)
>-{
>-    ASSERT(m_observers.contains(token));
>-    m_observers.remove(token);
>+        RealtimeMediaSourceCenter::singleton().captureDevicesChanged();
>+    });
> }
> 
>-
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebCore/platform/mediastream/CaptureDeviceManager.h b/Source/WebCore/platform/mediastream/CaptureDeviceManager.h
>index 45edb300c3b72e877345c9f00236fd06d3549cde..db6bd681f8c01d9de35ae7bfaab459ca5f0b1941 100644
>--- a/Source/WebCore/platform/mediastream/CaptureDeviceManager.h
>+++ b/Source/WebCore/platform/mediastream/CaptureDeviceManager.h
>@@ -29,23 +29,19 @@
> 
> #include "CaptureDevice.h"
> #include "RealtimeMediaSource.h"
>+#include <wtf/WeakPtr.h>
> 
> namespace WebCore {
> 
>-class CaptureDeviceManager {
>+class CaptureDeviceManager : public CanMakeWeakPtr<CaptureDeviceManager> {
> public:
>-    using CaptureDeviceChangedCallback = WTF::Function<void()>;
>-    using ObserverToken = uint32_t;
>-    virtual ObserverToken addCaptureDeviceChangedObserver(CaptureDeviceChangedCallback&&);
>-    virtual void removeCaptureDeviceChangedObserver(ObserverToken);
>-
>     virtual const Vector<CaptureDevice>& captureDevices() = 0;
>     virtual std::optional<CaptureDevice> captureDeviceWithPersistentID(CaptureDevice::DeviceType, const String&) { return std::nullopt; }
> 
> protected:
>     virtual ~CaptureDeviceManager();
>     CaptureDevice captureDeviceFromPersistentID(const String& captureDeviceID);
>-    HashMap<ObserverToken, CaptureDeviceChangedCallback> m_observers;
>+    void deviceChanged();
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp b/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp
>index 3886ff875ce89f5c108c437bb9caa2f4d7f1602a..d8bbbece2f4943d275b69aeacc4a8cbd1de54931 100644
>--- a/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp
>+++ b/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.cpp
>@@ -53,12 +53,6 @@ static RealtimeMediaSourceCenter*& mediaStreamCenterOverride()
>     return override;
> }
> 
>-static HashMap<unsigned, std::function<void()>>& observerMap()
>-{
>-    static NeverDestroyed<HashMap<unsigned, std::function<void()>>> map;
>-    return map;
>-}
>-
> RealtimeMediaSourceCenter& RealtimeMediaSourceCenter::singleton()
> {
>     RealtimeMediaSourceCenter* override = mediaStreamCenterOverride();
>@@ -199,25 +193,17 @@ ExceptionOr<void> RealtimeMediaSourceCenter::setDeviceEnabled(const String& id,
>     return Exception { NotFoundError };
> }
> 
>-RealtimeMediaSourceCenter::DevicesChangedObserverToken RealtimeMediaSourceCenter::addDevicesChangedObserver(std::function<void()>&& observer)
>-{
>-    static DevicesChangedObserverToken nextToken = 0;
>-    observerMap().set(++nextToken, WTFMove(observer));
>-    return nextToken;
>-}
>-
>-void RealtimeMediaSourceCenter::removeDevicesChangedObserver(DevicesChangedObserverToken token)
>+void RealtimeMediaSourceCenter::setDevicesChangedObserver(std::function<void()>&& observer)
> {
>-    bool wasRemoved = observerMap().remove(token);
>-    ASSERT_UNUSED(wasRemoved, wasRemoved);
>+    ASSERT(isMainThread());
>+    m_deviceChangedObserver = WTFMove(observer);
> }
> 
> void RealtimeMediaSourceCenter::captureDevicesChanged()
> {
>-    // Copy the hash map because the observer callback may call back in and modify the map.
>-    auto callbacks = observerMap();
>-    for (auto& it : callbacks)
>-        it.value();
>+    ASSERT(isMainThread());
>+    if (m_deviceChangedObserver)
>+        m_deviceChangedObserver();
> }
> 
> void RealtimeMediaSourceCenter::validateRequestConstraints(ValidConstraintsHandler&& validHandler, InvalidConstraintsHandler&& invalidHandler, const MediaStreamRequest& request, String&& deviceIdentifierHashSalt)
>diff --git a/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h b/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h
>index ef7b3cfcd916edccae620e4421f8c0babe8fe3ec..74a90006681c361f0165043b8a3ed1e0bd7eb73d 100644
>--- a/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h
>+++ b/Source/WebCore/platform/mediastream/RealtimeMediaSourceCenter.h
>@@ -85,22 +85,22 @@ public:
>     WEBCORE_EXPORT CaptureDevice captureDeviceWithUniqueID(const String& id, const String& hashSalt);
>     WEBCORE_EXPORT ExceptionOr<void> setDeviceEnabled(const String&, bool);
> 
>-    using DevicesChangedObserverToken = unsigned;
>-    DevicesChangedObserverToken addDevicesChangedObserver(std::function<void()>&&);
>-    void removeDevicesChangedObserver(DevicesChangedObserverToken);
>+    WEBCORE_EXPORT void setDevicesChangedObserver(std::function<void()>&&);
> 
>     void setVideoCapturePageState(bool, bool);
> 
>+    void captureDevicesChanged();
>+
> protected:
>     RealtimeMediaSourceCenter();
> 
>-    void captureDevicesChanged();
>-
>     static RealtimeMediaSourceCenter& platformCenter();
>     RealtimeMediaSourceSupportedConstraints m_supportedConstraints;
> 
>     CaptureDeviceManager* m_audioCaptureDeviceManager { nullptr };
>     CaptureDeviceManager* m_videoCaptureDeviceManager { nullptr };
>+
>+    std::function<void()> m_deviceChangedObserver;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm b/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm
>index 32e70e16dca306f5fd790d2e34515781f7776f4e..1b40879ddbcdd53a6353192666f57d386102c65f 100644
>--- a/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm
>+++ b/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm
>@@ -29,6 +29,7 @@
> #if ENABLE(MEDIA_STREAM) && PLATFORM(IOS)
> 
> #include "AVAudioSessionCaptureDevice.h"
>+#include "RealtimeMediaSourceCenter.h"
> #include <AVFoundation/AVAudioSession.h>
> #include <wtf/SoftLinking.h>
> #include <wtf/Vector.h>
>@@ -141,8 +142,7 @@ void AVAudioSessionCaptureDeviceManager::refreshAudioCaptureDevices()
>     m_audioSessionCaptureDevices = WTFMove(newAudioDevices);
>     m_devices = WTFMove(newDevices);
> 
>-    for (auto& observer : m_observers.values())
>-        observer();
>+    deviceChanged();
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/mediastream/mac/AVCaptureDeviceManager.mm b/Source/WebCore/platform/mediastream/mac/AVCaptureDeviceManager.mm
>index c011b26e686b05c1fa0b69a0d91d7cf0ca63f340..239be68fb280267365922777d284af5391c7b482 100644
>--- a/Source/WebCore/platform/mediastream/mac/AVCaptureDeviceManager.mm
>+++ b/Source/WebCore/platform/mediastream/mac/AVCaptureDeviceManager.mm
>@@ -179,9 +179,7 @@ void AVCaptureDeviceManager::registerForDeviceNotifications()
> void AVCaptureDeviceManager::deviceConnected()
> {
>     refreshCaptureDevices();
>-
>-    for (auto& observer : m_observers.values())
>-        observer();
>+    deviceChanged();
> }
> 
> void AVCaptureDeviceManager::deviceDisconnected(AVCaptureDeviceTypedef* device)
>@@ -200,8 +198,7 @@ void AVCaptureDeviceManager::deviceDisconnected(AVCaptureDeviceTypedef* device)
>         }
>     }
> 
>-    for (auto& observer : m_observers.values())
>-        observer();
>+    deviceChanged();
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp b/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp
>index 5413a8f86722204e4c42fae6eedb306a52f551a8..0089ec4a13b78afe22fc9a74b13fa4a3d108aa91 100644
>--- a/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp
>+++ b/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.cpp
>@@ -30,6 +30,7 @@
> 
> #include "CoreAudioCaptureDevice.h"
> #include "Logging.h"
>+#include "RealtimeMediaSourceCenter.h"
> #include <AudioUnit/AudioUnit.h>
> #include <CoreMedia/CMSync.h>
> #include <wtf/Assertions.h>
>@@ -64,10 +65,17 @@ std::optional<CaptureDevice> CoreAudioCaptureDeviceManager::captureDeviceWithPer
> static bool deviceHasInputStreams(AudioObjectID deviceID)
> {
>     UInt32 dataSize = 0;
>-    AudioObjectPropertyAddress address = { kAudioDevicePropertyStreams, kAudioDevicePropertyScopeInput, kAudioObjectPropertyElementMaster };
>+    AudioObjectPropertyAddress address = { kAudioDevicePropertyStreamConfiguration, kAudioDevicePropertyScopeInput, kAudioObjectPropertyElementMaster };
>     auto err = AudioObjectGetPropertyDataSize(deviceID, &address, 0, nullptr, &dataSize);
> 
>-    return !err && dataSize;
>+    if (err || !dataSize)
>+        return false;
>+
>+    auto bufferList = std::unique_ptr<AudioBufferList>((AudioBufferList*) ::operator new (dataSize));
>+    memset(bufferList.get(), 0, dataSize);
>+    err = AudioObjectGetPropertyData(deviceID, &address, 0, nullptr, &dataSize, bufferList.get());
>+
>+    return !err && bufferList->mNumberBuffers;
> }
> 
> static bool isValidCaptureDevice(const CoreAudioCaptureDevice& device)
>@@ -81,7 +89,7 @@ Vector<CoreAudioCaptureDevice>& CoreAudioCaptureDeviceManager::coreAudioCaptureD
>     static bool initialized;
>     if (!initialized) {
>         initialized = true;
>-        refreshAudioCaptureDevices();
>+        refreshAudioCaptureDevices(true);
> 
>         AudioObjectPropertyAddress address = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
>         auto err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &address, devicesChanged, this);
>@@ -102,7 +110,7 @@ std::optional<CoreAudioCaptureDevice> CoreAudioCaptureDeviceManager::coreAudioDe
> }
> 
> 
>-void CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices()
>+void CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices(bool firstRefresh)
> {
>     AudioObjectPropertyAddress address = { kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster };
>     UInt32 dataSize = 0;
>@@ -156,13 +164,13 @@ void CoreAudioCaptureDeviceManager::refreshAudioCaptureDevices()
>         m_devices.append(captureDevice);
>     }
> 
>-    for (auto& observer : m_observers.values())
>-        observer();
>+    if (!firstRefresh)
>+        deviceChanged();
> }
> 
> OSStatus CoreAudioCaptureDeviceManager::devicesChanged(AudioObjectID, UInt32, const AudioObjectPropertyAddress*, void* userData)
> {
>-    static_cast<CoreAudioCaptureDeviceManager*>(userData)->refreshAudioCaptureDevices();
>+    static_cast<CoreAudioCaptureDeviceManager*>(userData)->refreshAudioCaptureDevices(false);
>     return 0;
> }
> 
>diff --git a/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.h b/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.h
>index 8c28e827984caff486a45541905510375a45902d..417da145239fcc36fe7b8d28c657776a8860289f 100644
>--- a/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.h
>+++ b/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureDeviceManager.h
>@@ -55,7 +55,7 @@ private:
>     static OSStatus devicesChanged(AudioObjectID, UInt32, const AudioObjectPropertyAddress*, void*);
>     Vector<CoreAudioCaptureDevice>& coreAudioCaptureDevices();
> 
>-    void refreshAudioCaptureDevices();
>+    void refreshAudioCaptureDevices(bool);
> 
>     Vector<CaptureDevice> m_devices;
>     Vector<CoreAudioCaptureDevice> m_coreAudioCaptureDevices;
>diff --git a/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp
>index df91ebe0fe8544114a662c76e42afca7a700edac..deb5ac5cafa19132800eda96ab5048373cafb63d 100644
>--- a/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp
>+++ b/Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp
>@@ -55,19 +55,16 @@ void MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled(bool
> void MockRealtimeMediaSourceCenter::setDevices(Vector<MockMediaDevice>&& newMockDevices)
> {
>     MockRealtimeMediaSource::setDevices(WTFMove(newMockDevices));
>-    singleton().captureDevicesChanged();
> }
> 
> void MockRealtimeMediaSourceCenter::addDevice(const MockMediaDevice& device)
> {
>     MockRealtimeMediaSource::addDevice(device);
>-    singleton().captureDevicesChanged();
> }
> 
> void MockRealtimeMediaSourceCenter::removeDevice(const String& persistentId)
> {
>     MockRealtimeMediaSource::removeDevice(persistentId);
>-    singleton().captureDevicesChanged();
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>index 3c07295f1053fc15dcc88445632905b8c3fcb96b..6e96910f39eca68936d67ad05a5758e941907793 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp
>@@ -77,6 +77,28 @@ void UserMediaPermissionRequestManagerProxy::stopCapture()
>     m_page.stopMediaCapture();
> }
> 
>+void UserMediaPermissionRequestManagerProxy::captureDevicesChanged()
>+{
>+    // When new media input and/or output devices are made available, or any available input and/or
>+    // output device becomes unavailable, the User Agent MUST run the following steps in browsing
>+    // contexts where at least one of the following criteria are met, but in no other contexts:
>+
>+    // * The permission state of the "device-info" permission is "granted",
>+    // * any of the input devices are attached to an active MediaStream in the browsing context, or
>+    // * the active document is fully active and has focus.
>+
>+    // FIXME: a page with persistent access should always get device change notifications.
>+    bool isActive = m_page.isViewVisible() && m_page.isViewFocused() && m_page.isViewWindowActive();
>+    if (!isActive && !(m_captureState & activeCaptureMask)) {
>+        if (!isActive)
>+            m_pendingDeviceChangeEvent = true;
>+        return;
>+    }
>+
>+    m_pendingDeviceChangeEvent = false;
>+    m_page.process().send(Messages::WebPage::CaptureDevicesChanged(), m_page.pageID());
>+}
>+
> void UserMediaPermissionRequestManagerProxy::clearCachedState()
> {
>     invalidatePendingRequests();
>@@ -434,11 +456,14 @@ void UserMediaPermissionRequestManagerProxy::captureStateChanged(MediaProducer::
> #endif
> }
> 
>-void UserMediaPermissionRequestManagerProxy::processPregrantedRequests()
>+void UserMediaPermissionRequestManagerProxy::viewIsBecomingVisible()
> {
>     for (auto& request : m_pregrantedRequests)
>         request->allow();
>     m_pregrantedRequests.clear();
>+
>+    if (m_pendingDeviceChangeEvent)
>+        captureDevicesChanged();
> }
> 
> void UserMediaPermissionRequestManagerProxy::watchdogTimerFired()
>@@ -446,6 +471,7 @@ void UserMediaPermissionRequestManagerProxy::watchdogTimerFired()
>     m_grantedRequests.clear();
>     m_pregrantedRequests.clear();
>     m_currentWatchdogInterval = 0_s;
>+    m_pendingDeviceChangeEvent = false;
> }
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>index 573af04d71b853957512499d92c430648bbd179f..6ef6c1e1d942111a6332f8f14c7a59669c68fc10 100644
>--- a/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>+++ b/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h
>@@ -50,7 +50,7 @@ public:
>     void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, Ref<WebCore::SecurityOrigin>&&  userMediaDocumentOrigin, Ref<WebCore::SecurityOrigin>&& topLevelDocumentOrigin, const WebCore::MediaStreamRequest&);
> 
>     void resetAccess(uint64_t mainFrameID);
>-    void processPregrantedRequests();
>+    void viewIsBecomingVisible();
> 
>     void userMediaAccessWasGranted(uint64_t, WebCore::CaptureDevice&& audioDevice, WebCore::CaptureDevice&& videoDevice);
>     void userMediaAccessWasDenied(uint64_t, UserMediaPermissionRequestProxy::UserMediaAccessDenialReason);
>@@ -61,6 +61,7 @@ public:
>     void scheduleNextRejection();
>     void rejectionTimerFired();
>     void clearCachedState();
>+    void captureDevicesChanged();
> 
>     void captureStateChanged(WebCore::MediaProducer::MediaStateFlags oldState, WebCore::MediaProducer::MediaStateFlags newState);
> 
>@@ -101,6 +102,7 @@ private:
>     WebCore::MediaProducer::MediaStateFlags m_captureState { WebCore::MediaProducer::IsNotPlaying };
>     RunLoop::Timer<UserMediaPermissionRequestManagerProxy> m_watchdogTimer;
>     Seconds m_currentWatchdogInterval;
>+    bool m_pendingDeviceChangeEvent { false };
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/UserMediaProcessManager.cpp b/Source/WebKit/UIProcess/UserMediaProcessManager.cpp
>index 7ae6909746bfd7893d1ce9f309884dd3163bc4c2..a491f561722debd50595e133645892ebfb8958b9 100644
>--- a/Source/WebKit/UIProcess/UserMediaProcessManager.cpp
>+++ b/Source/WebKit/UIProcess/UserMediaProcessManager.cpp
>@@ -25,6 +25,7 @@
> #include "WebPageMessages.h"
> #include "WebPageProxy.h"
> #include "WebProcessProxy.h"
>+#include <WebCore/RealtimeMediaSourceCenter.h>
> #include <wtf/HashMap.h>
> #include <wtf/NeverDestroyed.h>
> 
>@@ -35,6 +36,8 @@ static const ASCIILiteral audioExtensionPath { "com.apple.webkit.microphone"_s }
> static const ASCIILiteral videoExtensionPath { "com.apple.webkit.camera"_s };
> #endif
> 
>+static const Seconds deviceChangeDebounceTimer { 100_ms };
>+
> class ProcessState {
> public:
>     ProcessState() { }
>@@ -101,6 +104,11 @@ UserMediaProcessManager& UserMediaProcessManager::singleton()
>     return manager;
> }
> 
>+UserMediaProcessManager::UserMediaProcessManager()
>+    : m_debounceTimer(RunLoop::main(), this, &UserMediaProcessManager::captureDevicesChanged)
>+{
>+}
>+
> void UserMediaProcessManager::addUserMediaPermissionRequestManagerProxy(UserMediaPermissionRequestManagerProxy& proxy)
> {
>     processState(proxy.page().process()).addRequestManager(proxy);
>@@ -254,6 +262,57 @@ void UserMediaProcessManager::setCaptureEnabled(bool enabled)
>     }
> }
> 
>+void UserMediaProcessManager::captureDevicesChanged()
>+{
>+    auto& map = stateMap();
>+    for (auto& state : map) {
>+        auto* process = state.key;
>+        for (auto& manager : state.value->managers()) {
>+            if (map.find(process) == map.end())
>+                break;
>+            manager->captureDevicesChanged();
>+        }
>+    }
>+}
>+
>+void UserMediaProcessManager::beginMonitoringCaptureDevices()
>+{
>+    static std::once_flag onceFlag;
>+
>+    std::call_once(onceFlag, [this] {
>+        m_captureDevices = WebCore::RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
>+
>+        WebCore::RealtimeMediaSourceCenter::singleton().setDevicesChangedObserver([this]() {
>+            auto oldDevices = m_captureDevices;
>+            m_captureDevices = WebCore::RealtimeMediaSourceCenter::singleton().getMediaStreamDevices();
>+
>+            if (m_captureDevices.size() == oldDevices.size()) {
>+                bool haveChanges = false;
>+                for (auto &newDevice : m_captureDevices) {
>+                    if (newDevice.type() != WebCore::CaptureDevice::DeviceType::Camera && newDevice.type() != WebCore::CaptureDevice::DeviceType::Microphone)
>+                        continue;
>+
>+                    auto oldDevice = std::find_if(oldDevices.begin(), oldDevices.end(), [&newDevice] (auto& device) {
>+                        return newDevice.persistentId() == device.persistentId();
>+                    });
>+                    if (oldDevice == oldDevices.end() || newDevice.enabled() != oldDevice->enabled()) {
>+                        haveChanges = true;
>+                        break;
>+                    }
>+                }
>+
>+                if (!haveChanges)
>+                    return;
>+            }
>+
>+            // When a device with camera and microphone is attached or detached, the CaptureDevice notification for
>+            // the different devices won't arrive at the same time so delay a bit so we can coalesce the callbacks.
>+            if (!m_debounceTimer.isActive())
>+                m_debounceTimer.startOneShot(deviceChangeDebounceTimer);
>+        });
>+    });
>+}
>+
> } // namespace WebKit
> 
> #endif
>diff --git a/Source/WebKit/UIProcess/UserMediaProcessManager.h b/Source/WebKit/UIProcess/UserMediaProcessManager.h
>index 81998b4acb7ddf91d50a83c79d2e5cac3d187473..485cd98f190b01c01eca5b6f1feaa05163cf4b1b 100644
>--- a/Source/WebKit/UIProcess/UserMediaProcessManager.h
>+++ b/Source/WebKit/UIProcess/UserMediaProcessManager.h
>@@ -21,6 +21,8 @@
> #if ENABLE(MEDIA_STREAM)
> 
> #include "UserMediaPermissionRequestManagerProxy.h"
>+#include <WebCore/CaptureDevice.h>
>+#include <wtf/RunLoop.h>
> 
> namespace WebKit {
> 
>@@ -31,6 +33,8 @@ public:
> 
>     static UserMediaProcessManager& singleton();
> 
>+    UserMediaProcessManager();
>+
>     void addUserMediaPermissionRequestManagerProxy(UserMediaPermissionRequestManagerProxy&);
>     void removeUserMediaPermissionRequestManagerProxy(UserMediaPermissionRequestManagerProxy&);
> 
>@@ -45,7 +49,13 @@ public:
> 
>     void denyNextUserMediaRequest() { m_denyNextRequest = true; }
> 
>+    void beginMonitoringCaptureDevices();
>+
> private:
>+    void captureDevicesChanged();
>+
>+    Vector<WebCore::CaptureDevice> m_captureDevices;
>+    RunLoop::Timer<UserMediaProcessManager> m_debounceTimer;
>     bool m_captureEnabled { true };
>     bool m_denyNextRequest { false };
> };
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index ac17b424c3204ef9b082ba1171aa41e7ecc3c272..ba904fe4a1339b5b4e5b68b5556517b7bb9b2deb 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -3890,7 +3890,7 @@ void WebPageProxy::didChangeMainDocument(uint64_t frameID)
> void WebPageProxy::viewIsBecomingVisible()
> {
> #if ENABLE(MEDIA_STREAM)
>-    userMediaPermissionRequestManager().processPregrantedRequests();
>+    userMediaPermissionRequestManager().viewIsBecomingVisible();
> #endif
> }
> 
>@@ -6521,6 +6521,13 @@ void WebPageProxy::enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t
> #endif
> }
> 
>+void WebPageProxy::beginMonitoringCaptureDevices()
>+{
>+#if ENABLE(MEDIA_STREAM)
>+    UserMediaProcessManager::singleton().beginMonitoringCaptureDevices();
>+#endif
>+}
>+
> void WebPageProxy::clearUserMediaState()
> {
> #if ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.h b/Source/WebKit/UIProcess/WebPageProxy.h
>index 6a5b259fcaea6d8928f09889c798045eb10d8815..185ecf017938ca545b17b03bfca7b9db8faa0405 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.h
>+++ b/Source/WebKit/UIProcess/WebPageProxy.h
>@@ -1491,6 +1491,7 @@ private:
> #endif
>     void requestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginIdentifier, const WebCore::SecurityOriginData& topLevelDocumentOriginIdentifier, const WebCore::MediaStreamRequest&);
>     void enumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, const WebCore::SecurityOriginData& userMediaDocumentOriginData, const WebCore::SecurityOriginData& topLevelDocumentOriginData);
>+    void beginMonitoringCaptureDevices();
> 
>     void runModal();
>     void notifyScrollerThumbIsVisibleInRect(const WebCore::IntRect&);
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.messages.in b/Source/WebKit/UIProcess/WebPageProxy.messages.in
>index b31f5f0be34cc948927a9b136d0cc32c51bc9c2a..6d29a9fd2e463df9a0f06e0347fac6451b5c0864 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.messages.in
>+++ b/Source/WebKit/UIProcess/WebPageProxy.messages.in
>@@ -287,6 +287,7 @@ messages -> WebPageProxy {
>     # MediaSteam messages
>     RequestUserMediaPermissionForFrame(uint64_t userMediaID, uint64_t frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier, struct WebCore::MediaStreamRequest request)
>     EnumerateMediaDevicesForFrame(uint64_t userMediaID, uint64_t frameID, struct WebCore::SecurityOriginData userMediaDocumentOriginIdentifier, struct WebCore::SecurityOriginData topLevelDocumentOriginIdentifier)
>+    BeginMonitoringCaptureDevices()
> #endif
> 
>     # Notification messages
>diff --git a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>index 9ccace0577c7fbc8ff5706bdfad93e437cc6e1f3..1187cf699f85a338436438c2bd5c9eac6d0819d9 100644
>--- a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>+++ b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.cpp
>@@ -222,6 +222,31 @@ void UserMediaPermissionRequestManager::revokeUserMediaDeviceSandboxExtensions(c
>     }
> }
> 
>+UserMediaClient::DeviceChangeObserverToken UserMediaPermissionRequestManager::addDeviceChangeObserver(std::function<void()>&& observer)
>+{
>+    static UserMediaClient::DeviceChangeObserverToken nextToken = 0;
>+    m_deviceChangeObserverMap.set(++nextToken, WTFMove(observer));
>+
>+    if (!m_monitoringDeviceChange) {
>+        m_monitoringDeviceChange = true;
>+        m_page.send(Messages::WebPageProxy::BeginMonitoringCaptureDevices());
>+    }
>+    return nextToken;
>+}
>+
>+void UserMediaPermissionRequestManager::removeDeviceChangeObserver(UserMediaClient::DeviceChangeObserverToken token)
>+{
>+    bool wasRemoved = m_deviceChangeObserverMap.remove(token);
>+    ASSERT_UNUSED(wasRemoved, wasRemoved);
>+}
>+
>+void UserMediaPermissionRequestManager::captureDevicesChanged()
>+{
>+    auto callbacks = m_deviceChangeObserverMap;
>+    for (auto& it : callbacks)
>+        it.value();
>+}
>+
> } // namespace WebKit
> 
> #endif // ENABLE(MEDIA_STREAM)
>diff --git a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>index a7efc8adeaaee50905ac40a785255e8f6f8b4140..87b80ead71d3205f91572813ca0aa8e6ad04e0c9 100644
>--- a/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>+++ b/Source/WebKit/WebProcess/MediaStream/UserMediaPermissionRequestManager.h
>@@ -55,6 +55,10 @@ public:
>     void grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&&);
>     void revokeUserMediaDeviceSandboxExtensions(const Vector<String>&);
> 
>+    WebCore::UserMediaClient::DeviceChangeObserverToken addDeviceChangeObserver(std::function<void()>&&);
>+    void removeDeviceChangeObserver(WebCore::UserMediaClient::DeviceChangeObserverToken);
>+    void captureDevicesChanged();
>+
> private:
>     void sendUserMediaRequest(WebCore::UserMediaRequest&);
> 
>@@ -73,6 +77,9 @@ private:
>     HashMap<RefPtr<WebCore::MediaDevicesEnumerationRequest>, uint64_t> m_mediaDevicesEnumerationRequestToIDMap;
> 
>     HashMap<String, RefPtr<SandboxExtension>> m_userMediaDeviceSandboxExtensions;
>+
>+    HashMap<unsigned, std::function<void()>> m_deviceChangeObserverMap;
>+    bool m_monitoringDeviceChange { false };
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.cpp b/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.cpp
>index 6f605742eec304202a6404b535bca7c5559b4fd1..05566778b782d011e1f29d48477979683acb84a0 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.cpp
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.cpp
>@@ -62,6 +62,16 @@ void WebUserMediaClient::cancelMediaDevicesEnumerationRequest(MediaDevicesEnumer
>     m_page.userMediaPermissionRequestManager().cancelMediaDevicesEnumeration(request);
> }
> 
>+WebUserMediaClient::DeviceChangeObserverToken WebUserMediaClient::addDeviceChangeObserver(std::function<void()>&& observer)
>+{
>+    return m_page.userMediaPermissionRequestManager().addDeviceChangeObserver(WTFMove(observer));
>+}
>+
>+void WebUserMediaClient::removeDeviceChangeObserver(DeviceChangeObserverToken token)
>+{
>+    m_page.userMediaPermissionRequestManager().removeDeviceChangeObserver(token);
>+}
>+
> } // namespace WebKit;
> 
> #endif // MEDIA_STREAM
>diff --git a/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.h b/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.h
>index a6e313262d5ba7c4baf43bd304f3d8698094f36c..7e67fd319265fed705e72b98e05e56769004e606 100644
>--- a/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.h
>+++ b/Source/WebKit/WebProcess/WebCoreSupport/WebUserMediaClient.h
>@@ -42,6 +42,9 @@ private:
>     void enumerateMediaDevices(WebCore::MediaDevicesEnumerationRequest&) final;
>     void cancelMediaDevicesEnumerationRequest(WebCore::MediaDevicesEnumerationRequest&) final;
> 
>+    DeviceChangeObserverToken addDeviceChangeObserver(std::function<void()>&&) final;
>+    void removeDeviceChangeObserver(DeviceChangeObserverToken) final;
>+
>     void initializeFactories();
> 
>     WebPage& m_page;
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.cpp b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>index d6b96556866d98560b0b2ef4e3da85e5573933ea..058fd1d99cb353b41a61c0e80b7c27d773824fa9 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.cpp
>@@ -3757,6 +3757,12 @@ void WebPage::didCompleteMediaDeviceEnumeration(uint64_t userMediaID, const Vect
> {
>     m_userMediaPermissionRequestManager->didCompleteMediaDeviceEnumeration(userMediaID, devices, WTFMove(deviceIdentifierHashSalt), originHasPersistentAccess);
> }
>+
>+void WebPage::captureDevicesChanged()
>+{
>+    m_userMediaPermissionRequestManager->captureDevicesChanged();
>+}
>+
> #if ENABLE(SANDBOX_EXTENSIONS)
> void WebPage::grantUserMediaDeviceSandboxExtensions(MediaDeviceSandboxExtensions&& extensions)
> {
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.h b/Source/WebKit/WebProcess/WebPage/WebPage.h
>index 408addd08e3c29829625274789c9eb591171451e..39c4d6a0d09f802def8e737e2a5be38a45adb275 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.h
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.h
>@@ -565,6 +565,7 @@ public:
> #if ENABLE(MEDIA_STREAM)
>     UserMediaPermissionRequestManager& userMediaPermissionRequestManager() { return *m_userMediaPermissionRequestManager; }
>     void prepareToSendUserMediaPermissionRequest();
>+    void captureDevicesChanged();
> #endif
> 
>     void elementDidFocus(WebCore::Node*);
>diff --git a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>index 1c44d77e6524d636623e4246f256a5716b1c0379..5fbe7b8a55e0839cd9986df164ef00e96cd62d44 100644
>--- a/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>+++ b/Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>@@ -319,6 +319,7 @@ messages -> WebPage LegacyReceiver {
>     UserMediaAccessWasGranted(uint64_t userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt)
>     UserMediaAccessWasDenied(uint64_t userMediaID, uint64_t reason, String invalidConstraint)
>     DidCompleteMediaDeviceEnumeration(uint64_t userMediaID, Vector<WebCore::CaptureDevice> devices, String mediaDeviceIdentifierHashSalt, bool hasPersistentAccess)
>+    CaptureDevicesChanged()
> #if ENABLE(SANDBOX_EXTENSIONS)
>     GrantUserMediaDeviceSandboxExtensions(WebKit::MediaDeviceSandboxExtensions sandboxExtensions)
>     RevokeUserMediaDeviceSandboxExtensions(Vector<String> sandboxExtensionIDs)
>diff --git a/Source/WebKit/WebProcess/WebProcess.cpp b/Source/WebKit/WebProcess/WebProcess.cpp
>index 416df807c6fbecc5ee7fb3987e9d6feea1e75688..866b0b450f5315014e0d3213d8818ccbe4a49bc9 100644
>--- a/Source/WebKit/WebProcess/WebProcess.cpp
>+++ b/Source/WebKit/WebProcess/WebProcess.cpp
>@@ -1732,21 +1732,31 @@ void WebProcess::setScreenProperties(const WebCore::ScreenProperties& properties
> void WebProcess::addMockMediaDevice(const WebCore::MockMediaDevice& device)
> {
>     MockRealtimeMediaSourceCenter::addDevice(device);
>+    captureDevicesChanged();
> }
> 
> void WebProcess::clearMockMediaDevices()
> {
>     MockRealtimeMediaSourceCenter::setDevices({ });
>+    captureDevicesChanged();
> }
> 
> void WebProcess::removeMockMediaDevice(const String& persistentId)
> {
>     MockRealtimeMediaSourceCenter::removeDevice(persistentId);
>+    captureDevicesChanged();
> }
> 
> void WebProcess::resetMockMediaDevices()
> {
>     MockRealtimeMediaSource::resetDevices();
>+    captureDevicesChanged();
>+}
>+
>+void WebProcess::captureDevicesChanged()
>+{
>+    for (auto& page : m_pageMap.values())
>+        page->captureDevicesChanged();
> }
> #endif
> 
>diff --git a/Source/WebKit/WebProcess/WebProcess.h b/Source/WebKit/WebProcess/WebProcess.h
>index 030a718fd9843e100490ce8364e4d82b4991555e..4961114e0107fc36e42616cda15b8ddbfeb6d432 100644
>--- a/Source/WebKit/WebProcess/WebProcess.h
>+++ b/Source/WebKit/WebProcess/WebProcess.h
>@@ -366,6 +366,7 @@ private:
>     void clearMockMediaDevices();
>     void removeMockMediaDevice(const String& persistentId);
>     void resetMockMediaDevices();
>+    void captureDevicesChanged();
> #endif
> 
>     void platformInitializeProcess(const ChildProcessInitializationParameters&);
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 1a4b395fde0ae22f7321f88e0d3368cae1a5728a..8a6856dcce74772453c118ca562cff5d05170c69 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,3 +1,13 @@
>+2018-08-13  Eric Carlson  <eric.carlson@apple.com>
>+
>+        [MediaStream] Move capture device monitoring to WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=188521
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * fast/mediastream/device-change-event-2-expected.txt: Updated.
>+        * fast/mediastream/device-change-event-2.html: Updated.
>+
> 2018-08-13  Zan Dobersek  <zdobersek@igalia.com>
> 
>         Unreviewed WPE gardening. Cleaned up test expectations for tests under
>diff --git a/LayoutTests/fast/mediastream/device-change-event-2-expected.txt b/LayoutTests/fast/mediastream/device-change-event-2-expected.txt
>index 64c6b61076faaa3de4f8168f7969cf10f607a69d..9a2c76c071c5fa910f9540af4a298d14e7ddf13e 100644
>--- a/LayoutTests/fast/mediastream/device-change-event-2-expected.txt
>+++ b/LayoutTests/fast/mediastream/device-change-event-2-expected.txt
>@@ -1,3 +1,5 @@
> 
> PASS 'devicechange' event fired when device list changes 
>+PASS 'devicechange' event not fired until the document is visible 
>+PASS 'devicechange' events fired quickly are coalesced 
> 
>diff --git a/LayoutTests/fast/mediastream/device-change-event-2.html b/LayoutTests/fast/mediastream/device-change-event-2.html
>index 43d5f2bdfedd91ecbd23fc71b83571e0707b255b..36696c3771bdb7e31be8b0052eef93d5f363fe48 100644
>--- a/LayoutTests/fast/mediastream/device-change-event-2.html
>+++ b/LayoutTests/fast/mediastream/device-change-event-2.html
>@@ -7,7 +7,8 @@
>     <script src="../../resources/testharnessreport.js"></script>
>     <script>
>     let deviceIds = [];
>-    promise_test(async (test) => {
>+    
>+    let setup = async (test) => {
>         if (!window.testRunner)
>             return Promise.reject("test requires internal API");
> 
>@@ -25,11 +26,16 @@
> 
>         devices = await navigator.mediaDevices.enumerateDevices();
>         assert_false(!!devices.length, "check there are no more devices");
>+    }
>+    
>+    promise_test(async (test) => {
>+    
>+        await setup(test);
> 
>         await new Promise((resolve, reject) => {
>             navigator.mediaDevices.ondevicechange = resolve;
>             setTimeout(() => {
>-                console.log("event 1 taking a long time");
>+                console.log("event 1 took too long");
>                 resolve();
>             }, 5000);
>             testRunner.addMockCameraDevice("id1", "my camera");
>@@ -41,7 +47,7 @@
>         await new Promise((resolve, reject) => {
>             navigator.mediaDevices.ondevicechange = resolve;
>             setTimeout(() => {
>-                console.log("event 2 taking a long time");
>+                console.log("event 2 took too long");
>                 resolve();
>             }, 5000);
>             testRunner.addMockMicrophoneDevice("id2", "my mic");
>@@ -51,6 +57,56 @@
>         assert_equals(devices[0].label, "my mic");
> 
>     }, "'devicechange' event fired when device list changes");
>+
>+    promise_test(async (test) => {
>+
>+        await setup(test);
>+
>+        await new Promise((resolve, reject) => {
>+            document.onvisibilitychange = resolve;
>+            setTimeout(() => {
>+                console.log("document.onvisibilitychange took too long");
>+                resolve();
>+            }, 5000);
>+            testRunner.setPageVisibility("hidden");
>+        });
>+        
>+        await new Promise((resolve, reject) => {
>+            navigator.mediaDevices.ondevicechange = () => {
>+                assert_false(document.hidden, "devicechange should not be fired when the document is hidden");
>+                resolve();
>+            };
>+            setTimeout(() => {
>+                testRunner.setPageVisibility("visible");
>+            }, 300);
>+            testRunner.addMockMicrophoneDevice("id3", "microphone 2");
>+        });
>+
>+    }, "'devicechange' event not fired until the document is visible");
>+
>+    promise_test(async (test) => {
>+
>+        await setup(test);
>+
>+        let eventCount = 0;
>+        await new Promise((resolve, reject) => {
>+            navigator.mediaDevices.ondevicechange = () => {
>+                ++eventCount;
>+                setTimeout(() => {
>+                    resolve();
>+                }, 200);
>+            }
>+            setTimeout(() => {
>+                console.log("navigator.mediaDevices.ondevicechange took too long");
>+                resolve();
>+            }, 5000);
>+            testRunner.addMockMicrophoneDevice("id4", "microphone 3");
>+            testRunner.addMockMicrophoneDevice("id5", "microphone 4");
>+        });
>+        assert_equals(eventCount, 1, "one one event fired");
>+
>+    }, "'devicechange' events fired quickly are coalesced");
>+
>     </script>
> </head>
> <body>

Actions: View | Formatted Diff | Diff

Attachments on bug 188521: 347035 | 347229 | 347366 | 347382 | 347496 | 347501