Cherry-pick 78a2a01. rdar://problem/100335624

    [iOS] Fire configurationchange event in case of switching automatically to another microphone while capturing
    https://bugs.webkit.org/show_bug.cgi?id=244535
    rdar://problem/99331061

    Reviewed by Eric Carlson.

    On iOS, the user may change of audio device through control center, while capturing.
    In that case, the microphone automatically switches to the new device.
    To expose this to the WebPage, we can use configurationchange event.
    The flow is:
    - AVAudioSessionCaptureDeviceManager detects microphone change
    - CoreAudioSharedUnit notifies CoreAudioCaptureSource in GPUProcess.
    - UserMediaCaptureManagerProxy is notified by CoreAudioCaptureSource and notifies UserMediaCaptureManager through IPC.
    - UserMediaCaptureManager in WebProcess notifies its source which notifies its MediaStreamTrack(s).
    - At the same time, settings and capabilities are updated.

    We add a mock API to test this code path.

    Covered by LayoutTests/fast/mediastream/mediastreamtrack-configurationchange.html.

    * LayoutTests/fast/mediastream/mediastreamtrack-configurationchange-expected.txt: Added.
    * LayoutTests/fast/mediastream/mediastreamtrack-configurationchange.html: Added.
    * Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp:
    (WebCore::MediaStreamTrack::trackConfigurationChanged):
    * Source/WebCore/Modules/mediastream/MediaStreamTrack.h:
    * Source/WebCore/Modules/mediastream/MediaStreamTrack.idl:
    * Source/WebCore/dom/EventNames.h:
    * Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp:
    (WebCore::MediaStreamTrackPrivate::sourceConfigurationChanged):
    * Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.h:
    * Source/WebCore/platform/mediastream/RealtimeMediaSource.cpp:
    (WebCore::RealtimeMediaSource::RealtimeMediaSource):
    (WebCore::RealtimeMediaSource::setPersistentId):
    (WebCore::RealtimeMediaSource::initializePersistentId):
    * Source/WebCore/platform/mediastream/RealtimeMediaSource.h:
    * Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h:
    * Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:
    (WebCore::AVAudioSessionCaptureDeviceManager::retrieveAudioSessionCaptureDevices const):
    * Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.cpp:
    (WebCore::BaseAudioSharedUnit::handleNewCurrentMicrophoneDevice):
    * Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.h:
    * Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.cpp:
    (WebCore::CoreAudioCaptureSource::handleNewCurrentMicrophoneDevice):
    * Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h:
    * Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.mm:
    (WebCore::RealtimeMediaSourceCenter::shouldInterruptAudioOnPageVisibilityChange):
    * Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp:
    (WebCore::MockRealtimeMediaSourceCenter::triggerMockMicrophoneConfigurationChange):
    * Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h:
    * Source/WebKit/GPUProcess/GPUProcess.cpp:
    (WebKit::GPUProcess::triggerMockMicrophoneConfigurationChange):
    * Source/WebKit/GPUProcess/GPUProcess.h:
    * Source/WebKit/GPUProcess/GPUProcess.messages.in:
    * Source/WebKit/UIProcess/API/C/WKPage.cpp:
    (WKPageTriggerMockMicrophoneConfigurationChange):
    * Source/WebKit/UIProcess/API/C/WKPagePrivate.h:
    * Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp:
    * Source/WebKit/UIProcess/GPU/GPUProcessProxy.cpp:
    (WebKit::GPUProcessProxy::triggerMockMicrophoneConfigurationChange):
    * Source/WebKit/UIProcess/GPU/GPUProcessProxy.h:
    * Source/WebKit/WebProcess/cocoa/RemoteRealtimeMediaSource.cpp:
    (WebKit::RemoteRealtimeMediaSource::configurationChanged):
    * Source/WebKit/WebProcess/cocoa/RemoteRealtimeMediaSource.h:
    * Source/WebKit/WebProcess/cocoa/UserMediaCaptureManager.cpp:
    (WebKit::UserMediaCaptureManager::sourceConfigurationChanged):
    * Source/WebKit/WebProcess/cocoa/UserMediaCaptureManager.h:
    * Source/WebKit/WebProcess/cocoa/UserMediaCaptureManager.messages.in:
    * Tools/WebKitTestRunner/InjectedBundle/Bindings/TestRunner.idl:
    * Tools/WebKitTestRunner/InjectedBundle/TestRunner.cpp:
    (WTR::TestRunner::triggerMockMicrophoneConfigurationChange):
    * Tools/WebKitTestRunner/InjectedBundle/TestRunner.h:
    * Tools/WebKitTestRunner/TestController.cpp:
    (WTR::TestController::triggerMockMicrophoneConfigurationChange):
    * Tools/WebKitTestRunner/TestController.h:
    * Tools/WebKitTestRunner/TestInvocation.cpp:
    (WTR::TestInvocation::didReceiveSynchronousMessageFromInjectedBundle):

    Canonical link: https://commits.webkit.org/254035@main

Canonical link: https://commits.webkit.org/252432.808@safari-7614.3.7.1-branch

LayoutTests/fast/mediastream/mediastreamtrack-configurationchange-expected.txt

@@ -0,0 +1,4 @@
+
+
+PASS Trigger configurationchange event in case OS changes microphone on its own
+

LayoutTests/fast/mediastream/mediastreamtrack-configurationchange.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="utf-8">
+    <title>configurationchange event.</title>
+    <script src="../../resources/testharness.js"></script>
+    <script src="../../resources/testharnessreport.js"></script>
+</head>
+<body>
+    <video id=video playsInline autoplay></video>
+    <script>
+    promise_test(async (t) => {
+        if (!window.testRunner)
+            return;
+
+        const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        const track = stream.getAudioTracks()[0];
+
+        video.srcObject = stream;
+        await video.play();
+
+        assert_equals(track.label, "Mock audio device 1");
+
+        testRunner.triggerMockMicrophoneConfigurationChange();
+
+        await new Promise((resolve, reject) => {
+            track.onconfigurationchange = resolve;
+            setTimeout(()=> reject("waited too long for configurationchange"), 5000);
+        });
+
+        assert_equals(track.label, "Mock audio device 2");
+    }, "Trigger configurationchange event in case OS changes microphone on its own");
+    </script>
+</body>
+</html>

LayoutTests/platform/glib/TestExpectations

@@ -809,6 +809,8 @@ webkit.org/b/230415 fast/mediastream/RTCPeerConnection-iceconnectionstatechange-
 webkit.org/b/79203 fast/mediastream/RTCRtpSender-replaceTrack.html [ Failure ]
 webkit.org/b/187603 fast/mediastream/media-stream-track-source-failure.html [ Timeout Failure Pass ]
 
+fast/mediastream/mediastreamtrack-configurationchange.html [ Failure ]
+
 webkit.org/b/223508 imported/w3c/web-platform-tests/mediacapture-streams/MediaStream-MediaElement-srcObject.https.html [ Failure Pass ]
 
 webkit.org/b/218317 media/media-source/media-source-trackid-change.html [ Failure ]

Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

@@ -618,6 +618,16 @@ void MediaStreamTrack::trackSettingsChanged(MediaStreamTrackPrivate&)
     configureTrackRendering();
 }
 
+void MediaStreamTrack::trackConfigurationChanged(MediaStreamTrackPrivate&)
+{
+    queueTaskKeepingObjectAlive(*this, TaskSource::Networking, [this] {
+        if (!scriptExecutionContext() || scriptExecutionContext()->activeDOMObjectsAreStopped() || m_private->muted() || ended())
+            return;
+
+        dispatchEvent(Event::create(eventNames().configurationchangeEvent, Event::CanBubble::No, Event::IsCancelable::No));
+    });
+}
+
 void MediaStreamTrack::trackEnabledChanged(MediaStreamTrackPrivate&)
 {
     configureTrackRendering();

Source/WebCore/Modules/mediastream/MediaStreamTrack.h

@@ -192,6 +192,7 @@ class MediaStreamTrack
     void trackMutedChanged(MediaStreamTrackPrivate&) final;
     void trackSettingsChanged(MediaStreamTrackPrivate&) final;
     void trackEnabledChanged(MediaStreamTrackPrivate&) final;
+    void trackConfigurationChanged(MediaStreamTrackPrivate&) final;
 
     // PlatformMediaSession::AudioCaptureSource
     bool isCapturingAudio() const final;

Source/WebCore/Modules/mediastream/MediaStreamTrack.idl

@@ -42,6 +42,7 @@ enum MediaStreamTrackState { "live", "ended" };
     [ImplementedAs=mutedForBindings] readonly attribute boolean muted;
     attribute EventHandler onmute;
     attribute EventHandler onunmute;
+    attribute EventHandler onconfigurationchange;
     readonly attribute MediaStreamTrackState readyState;
     attribute EventHandler onended;
 

Source/WebCore/dom/EventNames.h

@@ -88,6 +88,7 @@ namespace WebCore {
     macro(compositionend) \
     macro(compositionstart) \
     macro(compositionupdate) \
+    macro(configurationchange) \
     macro(connect) \
     macro(connectionstatechange) \
     macro(connecting) \

Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp

@@ -243,6 +243,15 @@ void MediaStreamTrackPrivate::sourceSettingsChanged()
     });
 }
 
+void MediaStreamTrackPrivate::sourceConfigurationChanged()
+{
+    ALWAYS_LOG(LOGIDENTIFIER);
+
+    forEachObserver([this](auto& observer) {
+        observer.trackConfigurationChanged(*this);
+    });
+}
+
 bool MediaStreamTrackPrivate::preventSourceFromStopping()
 {
     ALWAYS_LOG(LOGIDENTIFIER, m_isEnded);

Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.h

@@ -57,6 +57,7 @@ class MediaStreamTrackPrivate final
         virtual void trackEnded(MediaStreamTrackPrivate&) = 0;
         virtual void trackMutedChanged(MediaStreamTrackPrivate&) = 0;
         virtual void trackSettingsChanged(MediaStreamTrackPrivate&) = 0;
+        virtual void trackConfigurationChanged(MediaStreamTrackPrivate&) { };
         virtual void trackEnabledChanged(MediaStreamTrackPrivate&) = 0;
         virtual void readyStateChanged(MediaStreamTrackPrivate&) { };
     };
@@ -133,6 +134,7 @@ class MediaStreamTrackPrivate final
     void sourceStopped() final;
     void sourceMutedChanged() final;
     void sourceSettingsChanged() final;
+    void sourceConfigurationChanged() final;
     bool preventSourceFromStopping() final;
     void audioUnitWillStart() final;
     void hasStartedProducingData() final;

Source/WebCore/platform/mediastream/RealtimeMediaSource.cpp

@@ -54,6 +54,17 @@ RealtimeMediaSource::RealtimeMediaSource(Type type, AtomString&& name, String&&
     , m_persistentID(WTFMove(deviceID))
     , m_type(type)
     , m_name(WTFMove(name))
+{
+    initializePersistentId();
+}
+
+void RealtimeMediaSource::setPersistentId(const String& persistentID)
+{
+    m_persistentID = persistentID;
+    initializePersistentId();
+}
+
+void RealtimeMediaSource::initializePersistentId()
 {
     if (m_persistentID.isEmpty())
         m_persistentID = createVersion4UUIDString();

Source/WebCore/platform/mediastream/RealtimeMediaSource.h

@@ -85,6 +85,7 @@ class WEBCORE_EXPORT RealtimeMediaSource
         virtual void sourceMutedChanged() { }
         virtual void sourceSettingsChanged() { }
         virtual void audioUnitWillStart() { }
+        virtual void sourceConfigurationChanged() { }
 
         // Observer state queries.
         virtual bool preventSourceFromStopping() { return false; }
@@ -137,7 +138,6 @@ class WEBCORE_EXPORT RealtimeMediaSource
     virtual bool interrupted() const { return false; }
 
     const AtomString& name() const { return m_name; }
-    void setName(const AtomString& name) { m_name = name; }
 
     unsigned fitnessScore() const { return m_fitnessScore; }
 
@@ -259,6 +259,9 @@ class WEBCORE_EXPORT RealtimeMediaSource
 
     void setType(Type);
 
+    void setName(const AtomString&);
+    void setPersistentId(const String&);
+
 private:
     virtual void startProducingData() { }
     virtual void stopProducingData() { }
@@ -270,6 +273,7 @@ class WEBCORE_EXPORT RealtimeMediaSource
     virtual void didEnd() { }
 
     void updateHasStartedProducingData();
+    void initializePersistentId();
 
 #if !RELEASE_LOG_DISABLED
     RefPtr<const Logger> m_logger;
@@ -327,6 +331,11 @@ struct CaptureSourceOrError {
 
 String convertEnumerationToString(RealtimeMediaSource::Type);
 
+inline void RealtimeMediaSource::setName(const AtomString& name)
+{
+    m_name = name;
+}
+
 inline void RealtimeMediaSource::whenReady(CompletionHandler<void(String)>&& callback)
 {
     callback({ });

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

@@ -72,6 +72,7 @@ class AVAudioSessionCaptureDeviceManager final : public CaptureDeviceManager {
     Vector<AVAudioSessionCaptureDevice> retrieveAudioSessionCaptureDevices() const;
     void setAudioCaptureDevices(Vector<AVAudioSessionCaptureDevice>&&);
     bool setPreferredAudioSessionDeviceUIDInternal(const String&);
+    void notifyNewCurrentMicrophoneDevice(CaptureDevice&&);
 
     enum class AudioSessionState { NotNeeded, Inactive, Active };
 

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

@@ -29,6 +29,7 @@
 #if ENABLE(MEDIA_STREAM) && PLATFORM(IOS_FAMILY)
 
 #import "AVAudioSessionCaptureDevice.h"
+#import "CoreAudioSharedUnit.h"
 #import "Logging.h"
 #import "RealtimeMediaSourceCenter.h"
 #import <AVFoundation/AVAudioSession.h>
@@ -277,15 +278,23 @@ - (void)routeDidChange:(NSNotification *)notification
 Vector<AVAudioSessionCaptureDevice> AVAudioSessionCaptureDeviceManager::retrieveAudioSessionCaptureDevices() const
 {
     auto defaultMicrophoneInformation = computeDefaultMicrophoneInformation();
-    if (!defaultMicrophoneInformation && !m_lastDefaultMicrophone)
-        m_lastDefaultMicrophone = [m_audioSession currentRoute].inputs.firstObject;
+    auto currentInput = [m_audioSession currentRoute].inputs.firstObject;
+    if (currentInput) {
+        if (currentInput != m_lastDefaultMicrophone.get()) {
+            auto device = AVAudioSessionCaptureDevice::create(currentInput, currentInput);
+            callOnWebThreadOrDispatchAsyncOnMainThread(makeBlockPtr([device = crossThreadCopy(WTFMove(device))] () mutable {
+                CoreAudioSharedUnit::singleton().handleNewCurrentMicrophoneDevice(WTFMove(device));
+            }).get());
+        }
+        m_lastDefaultMicrophone = currentInput;
+    }
 
     auto availableInputs = [m_audioSession availableInputs];
 
     Vector<AVAudioSessionCaptureDevice> newAudioDevices;
     newAudioDevices.reserveInitialCapacity(availableInputs.count);
     for (AVAudioSessionPortDescription *portDescription in availableInputs) {
-        auto device = AVAudioSessionCaptureDevice::create(portDescription, m_lastDefaultMicrophone.get());
+        auto device = AVAudioSessionCaptureDevice::create(portDescription, currentInput);
         if (defaultMicrophoneInformation)
             device.setIsDefault((defaultMicrophoneInformation->isBuiltInMicrophoneDefault && portDescription.portType == getAVAudioSessionPortBuiltInMic()) || [portDescription.UID isEqualToString: defaultMicrophoneInformation->routeUID]);
         newAudioDevices.uncheckedAppend(WTFMove(device));

Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.cpp

@@ -294,6 +294,13 @@ void BaseAudioSharedUnit::whenAudioCaptureUnitIsNotRunning(Function<void()>&& ca
     m_whenNotRunningCallbacks.append(WTFMove(callback));
 }
 
+void BaseAudioSharedUnit::handleNewCurrentMicrophoneDevice(CaptureDevice&& device)
+{
+    forEachClient([&device](auto& client) {
+        client.handleNewCurrentMicrophoneDevice(device);
+    });
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)

Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.h

@@ -85,6 +85,8 @@ class BaseAudioSharedUnit : public CanMakeWeakPtr<BaseAudioSharedUnit, WeakPtrFa
 
     const String& persistentIDForTesting() const { return m_capturingDevice ? m_capturingDevice->first : emptyString(); }
 
+    void handleNewCurrentMicrophoneDevice(CaptureDevice&&);
+
 protected:
     void forEachClient(const Function<void(CoreAudioCaptureSource&)>&) const;
     bool hasClients() const { return !m_clients.isEmpty(); }

Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.cpp

@@ -335,6 +335,24 @@ void CoreAudioCaptureSource::audioUnitWillStart()
     });
 }
 
+void CoreAudioCaptureSource::handleNewCurrentMicrophoneDevice(const CaptureDevice& device)
+{
+    if (!isProducingData() || persistentID() == device.persistentId())
+        return;
+
+    RELEASE_LOG_INFO(WebRTC, "CoreAudioCaptureSource switching from '%s' to '%s'", name().string().utf8().data(), device.label().utf8().data());
+
+    setName(AtomString { device.label() });
+    setPersistentId(device.persistentId());
+
+    m_currentSettings = { };
+    m_capabilities = { };
+
+    forEachObserver([](auto& observer) {
+        observer.sourceConfigurationChanged();
+    });
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)

Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h

@@ -59,6 +59,8 @@ class CoreAudioCaptureSource : public RealtimeMediaSource {
 
     CMClockRef timebaseClock();
 
+    void handleNewCurrentMicrophoneDevice(const CaptureDevice&);
+
 protected:
     CoreAudioCaptureSource(String&& deviceID, AtomString&& label, String&& hashSalt, uint32_t persistentID, BaseAudioSharedUnit*, PageIdentifier);
     virtual ~CoreAudioCaptureSource();

Source/WebCore/platform/mediastream/mac/RealtimeMediaSourceCenterMac.mm

@@ -42,11 +42,13 @@
     if (!modes)
         return true;
 
+    RELEASE_LOG_ERROR(WebRTC, "RealtimeMediaSourceCenter::shouldInterruptAudioOnPageVisibilityChange2");
     int modesCount = [modes count];
     for (int i = 0; i < modesCount; i++) {
         if ([[modes objectAtIndex:i] isEqual: @"audio"])
             return false;
     }
+    RELEASE_LOG_ERROR(WebRTC, "RealtimeMediaSourceCenter::shouldInterruptAudioOnPageVisibilityChange3");
     return true;
 #else
     return false;

Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.cpp

@@ -44,6 +44,7 @@
 #if PLATFORM(COCOA)
 #include "CoreAudioCaptureSource.h"
 #include "DisplayCaptureSourceCocoa.h"
+#include "MockAudioSharedUnit.h"
 #include "MockRealtimeVideoSourceMac.h"
 #endif
 
@@ -319,6 +320,16 @@ void MockRealtimeMediaSourceCenter::setMockCaptureDevicesInterrupted(bool isCame
     MockRealtimeAudioSource::setIsInterrupted(isMicrophoneInterrupted);
 }
 
+void MockRealtimeMediaSourceCenter::triggerMockMicrophoneConfigurationChange()
+{
+#if PLATFORM(COCOA)
+    auto devices = audioCaptureDeviceManager().captureDevices();
+    if (devices.size() <= 1)
+        return;
+    MockAudioSharedUnit::singleton().handleNewCurrentMicrophoneDevice(WTFMove(devices[1]));
+#endif
+}
+
 void MockRealtimeMediaSourceCenter::setDevices(Vector<MockMediaDevice>&& newMockDevices)
 {
     microphoneDevices().clear();

Source/WebCore/platform/mock/MockRealtimeMediaSourceCenter.h

@@ -49,6 +49,8 @@ class MockRealtimeMediaSourceCenter {
     WEBCORE_EXPORT static void resetDevices();
     WEBCORE_EXPORT static void setMockCaptureDevicesInterrupted(bool isCameraInterrupted, bool isMicrophoneInterrupted);
 
+    WEBCORE_EXPORT void triggerMockMicrophoneConfigurationChange();
+
     void setMockAudioCaptureEnabled(bool isEnabled) { m_isMockAudioCaptureEnabled = isEnabled; }
     void setMockVideoCaptureEnabled(bool isEnabled) { m_isMockVideoCaptureEnabled = isEnabled; }
     void setMockDisplayCaptureEnabled(bool isEnabled) { m_isMockDisplayCaptureEnabled = isEnabled; }

Source/WebKit/GPUProcess/GPUProcess.cpp

@@ -428,6 +428,11 @@ void GPUProcess::setMockCaptureDevicesInterrupted(bool isCameraInterrupted, bool
 {
     MockRealtimeMediaSourceCenter::setMockCaptureDevicesInterrupted(isCameraInterrupted, isMicrophoneInterrupted);
 }
+
+void GPUProcess::triggerMockMicrophoneConfigurationChange()
+{
+    MockRealtimeMediaSourceCenter::singleton().triggerMockMicrophoneConfigurationChange();
+}
 #endif // ENABLE(MEDIA_STREAM)
 
 #if HAVE(SC_CONTENT_SHARING_SESSION)

Source/WebKit/GPUProcess/GPUProcess.h

@@ -158,6 +158,7 @@ class GPUProcess : public AuxiliaryProcess, public ThreadSafeRefCounted<GPUProce
     void removeMockMediaDevice(const String& persistentId);
     void resetMockMediaDevices();
     void setMockCaptureDevicesInterrupted(bool isCameraInterrupted, bool isMicrophoneInterrupted);
+    void triggerMockMicrophoneConfigurationChange();
     bool setCaptureAttributionString(const String&);
 #endif
 #if HAVE(SC_CONTENT_SHARING_SESSION)

Source/WebKit/GPUProcess/GPUProcess.messages.in

@@ -46,6 +46,7 @@ messages -> GPUProcess LegacyReceiver {
     RemoveMockMediaDevice(String persistentId)
     ResetMockMediaDevices()
     SetMockCaptureDevicesInterrupted(bool isCameraInterrupted, bool isMicrophoneInterrupted)
+    TriggerMockMicrophoneConfigurationChange()
 #endif
 #if PLATFORM(MAC)
     DisplayConfigurationChanged(CGDirectDisplayID displayID, CGDisplayChangeSummaryFlags flags)

Source/WebKit/UIProcess/API/C/WKPage.cpp

@@ -3151,6 +3151,15 @@ void WKPageSetMockCaptureDevicesInterrupted(WKPageRef pageRef, bool isCameraInte
 #endif
 }
 
+void WKPageTriggerMockMicrophoneConfigurationChange(WKPageRef pageRef)
+{
+    CRASH_IF_SUSPENDED;
+#if ENABLE(MEDIA_STREAM) && ENABLE(GPU_PROCESS)
+    auto& gpuProcess = toImpl(pageRef)->process().processPool().ensureGPUProcess();
+    gpuProcess.triggerMockMicrophoneConfigurationChange();
+#endif
+}
+
 void WKPageLoadedSubresourceDomains(WKPageRef pageRef, WKPageLoadedSubresourceDomainsFunction callback, void* callbackContext)
 {
     CRASH_IF_SUSPENDED;

Source/WebKit/UIProcess/API/C/WKPagePrivate.h

@@ -202,6 +202,7 @@ WK_EXPORT void WKPageSetPrivateClickMeasurementAppBundleIDForTesting(WKPageRef p
 WK_EXPORT void WKPageSetMockCameraOrientation(WKPageRef page, uint64_t orientation);
 WK_EXPORT bool WKPageIsMockRealtimeMediaSourceCenterEnabled(WKPageRef page);
 WK_EXPORT void WKPageSetMockCaptureDevicesInterrupted(WKPageRef page, bool isCameraInterrupted, bool isMicrophoneInterrupted);
+WK_EXPORT void WKPageTriggerMockMicrophoneConfigurationChange(WKPageRef page);
 
 typedef void (*WKPageLoadedSubresourceDomainsFunction)(WKArrayRef domains, void* functionContext);
 WK_EXPORT void WKPageLoadedSubresourceDomains(WKPageRef page, WKPageLoadedSubresourceDomainsFunction callback, void* callbackContext);

Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp

@@ -136,6 +136,11 @@ class UserMediaCaptureManagerProxy::SourceProxy
         m_connection->send(Messages::UserMediaCaptureManager::SourceSettingsChanged(m_id, m_source->settings()), 0);
     }
 
+    void sourceConfigurationChanged() final
+    {
+        m_connection->send(Messages::UserMediaCaptureManager::SourceConfigurationChanged(m_id, m_source->persistentID(), m_source->settings(), m_source->capabilities()), 0);
+    }
+
     // May get called on a background thread.
     void audioSamplesAvailable(const MediaTime& time, const PlatformAudioData& audioData, const AudioStreamDescription& description, size_t numberOfFrames) final {
         if (m_description != description || m_shouldReset) {