Title: [271049] trunk/Source
Revision
271049
Author
[email protected]
Date
2020-12-22 02:11:23 -0800 (Tue, 22 Dec 2020)

Log Message

[iOS] Do extensive search for microphone devices when trying to capture
https://bugs.webkit.org/show_bug.cgi?id=220010
<rdar://problem/72036034>

Reviewed by Eric Carlson.

Source/WebCore:

It is not possible to discover some audio input devices without an active audio
session, so WebKit allocates an auxiliary audio session when it needs to build
a list of audio capture devices. The full list of devices is only needed when
evaluating getUserMedia audio constraints, or for enumerateDevices *after* capture
is active (we return a truncated list before capture is active), so don't activate
the session until we need to validate audio constraints or after the user gives
permission to capture.

Manually tested on device with built-in, BT, and USB audio inputs.

* platform/mediastream/RealtimeMediaSourceFactory.h:
(WebCore::AudioCaptureFactory::addExtensiveObserver):
(WebCore::AudioCaptureFactory::removeExtensiveObserver):
* platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h:
* platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:
(WebCore::AVAudioSessionCaptureDeviceManager::refreshAudioCaptureDevices):
(WebCore::AVAudioSessionCaptureDeviceManager::enableAllDevicesQuery):
(WebCore::AVAudioSessionCaptureDeviceManager::disableAllDevicesQuery):
* platform/mediastream/ios/CoreAudioCaptureSourceIOS.h:
* platform/mediastream/ios/CoreAudioCaptureSourceIOS.mm:
(WebCore::CoreAudioCaptureSourceFactoryIOS::addExtensiveObserver):
(WebCore::CoreAudioCaptureSourceFactoryIOS::removeExtensiveObserver):
(WebCore::CoreAudioCaptureSourceFactoryIOS::createAudioCaptureSource):
In UIProcess, UserMediaPermissionRequestManagerProxy makes sure to enable the extensive audio device query.
In WebProcess, we also need this when starting the audio capture.
We enable it when there is no observer to handle the WebProcess side.
* platform/mediastream/mac/CoreAudioCaptureSource.h:
(WebCore::CoreAudioCaptureSourceFactory::createAudioCaptureSource):

Source/WebKit:

Enable exhaustive audio device query in case getUserMedia is called for audio capture.
In case the manager is destroyed or reset after some time without capturing, make sure to disable
exhaustive audio device query if no other page need it.

* UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
(WebKit::UserMediaPermissionRequestManagerProxy::invalidatePendingRequests):
(WebKit::UserMediaPermissionRequestManagerProxy::denyRequest):
(WebKit::UserMediaPermissionRequestManagerProxy::resetAccess):
(WebKit::UserMediaPermissionRequestManagerProxy::startProcessingUserMediaPermissionRequest):
* UIProcess/UserMediaPermissionRequestManagerProxy.h:

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (271048 => 271049)


--- trunk/Source/WebCore/ChangeLog	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/ChangeLog	2020-12-22 10:11:23 UTC (rev 271049)
@@ -1,3 +1,40 @@
+2020-12-22  Youenn Fablet  <[email protected]>
+
+        [iOS] Do extensive search for microphone devices when trying to capture
+        https://bugs.webkit.org/show_bug.cgi?id=220010
+        <rdar://problem/72036034>
+
+        Reviewed by Eric Carlson.
+
+        It is not possible to discover some audio input devices without an active audio
+        session, so WebKit allocates an auxiliary audio session when it needs to build
+        a list of audio capture devices. The full list of devices is only needed when
+        evaluating getUserMedia audio constraints, or for enumerateDevices *after* capture
+        is active (we return a truncated list before capture is active), so don't activate
+        the session until we need to validate audio constraints or after the user gives
+        permission to capture.
+
+        Manually tested on device with built-in, BT, and USB audio inputs.
+
+        * platform/mediastream/RealtimeMediaSourceFactory.h:
+        (WebCore::AudioCaptureFactory::addExtensiveObserver):
+        (WebCore::AudioCaptureFactory::removeExtensiveObserver):
+        * platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h:
+        * platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm:
+        (WebCore::AVAudioSessionCaptureDeviceManager::refreshAudioCaptureDevices):
+        (WebCore::AVAudioSessionCaptureDeviceManager::enableAllDevicesQuery):
+        (WebCore::AVAudioSessionCaptureDeviceManager::disableAllDevicesQuery):
+        * platform/mediastream/ios/CoreAudioCaptureSourceIOS.h:
+        * platform/mediastream/ios/CoreAudioCaptureSourceIOS.mm:
+        (WebCore::CoreAudioCaptureSourceFactoryIOS::addExtensiveObserver):
+        (WebCore::CoreAudioCaptureSourceFactoryIOS::removeExtensiveObserver):
+        (WebCore::CoreAudioCaptureSourceFactoryIOS::createAudioCaptureSource):
+        In UIProcess, UserMediaPermissionRequestManagerProxy makes sure to enable the extensive audio device query.
+        In WebProcess, we also need this when starting the audio capture.
+        We enable it when there is no observer to handle the WebProcess side.
+        * platform/mediastream/mac/CoreAudioCaptureSource.h:
+        (WebCore::CoreAudioCaptureSourceFactory::createAudioCaptureSource):
+
 2020-12-21  Zalan Bujtas  <[email protected]>
 
         [LFC][Integration] Reserve both the line and the run vector sizes

Modified: trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceFactory.h (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceFactory.h	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/RealtimeMediaSourceFactory.h	2020-12-22 10:11:23 UTC (rev 271049)
@@ -27,6 +27,7 @@
 
 #if ENABLE(MEDIA_STREAM)
 
+#include <wtf/WeakPtr.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -62,6 +63,10 @@
     virtual CaptureDeviceManager& audioCaptureDeviceManager() = 0;
     virtual const Vector<CaptureDevice>& speakerDevices() const = 0;
 
+    class ExtensiveObserver : public CanMakeWeakPtr<ExtensiveObserver> { };
+    virtual void addExtensiveObserver(ExtensiveObserver&) { };
+    virtual void removeExtensiveObserver(ExtensiveObserver&) { };
+
 protected:
     AudioCaptureFactory() = default;
 };

Modified: trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.h	2020-12-22 10:11:23 UTC (rev 271049)
@@ -31,6 +31,7 @@
 #include "GenericTaskQueue.h"
 #include <wtf/Forward.h>
 #include <wtf/HashSet.h>
+#include <wtf/Lock.h>
 #include <wtf/RetainPtr.h>
 
 OBJC_CLASS AVAudioSession;
@@ -54,13 +55,19 @@
     
     void scheduleUpdateCaptureDevices();
 
+    void enableAllDevicesQuery();
+    void disableAllDevicesQuery();
+
 private:
     AVAudioSessionCaptureDeviceManager();
     ~AVAudioSessionCaptureDeviceManager();
 
+    void createAudioSession();
     void refreshAudioCaptureDevices();
     Vector<AVAudioSessionCaptureDevice>& audioSessionCaptureDevices();
 
+    enum class AudioSessionState { NotNeeded, Inactive, Active };
+
     Optional<Vector<CaptureDevice>> m_devices;
     Vector<CaptureDevice> m_speakerDevices;
     Optional<Vector<AVAudioSessionCaptureDevice>> m_audioSessionCaptureDevices;
@@ -67,6 +74,9 @@
     RetainPtr<WebAVAudioSessionAvailableInputsListener> m_listener;
     RetainPtr<AVAudioSession> m_audioSession;
     GenericTaskQueue<Timer> m_updateDeviceStateQueue;
+    dispatch_queue_t m_dispatchQueue { nullptr };
+    Lock m_lock;
+    AudioSessionState m_audioSessionState { AudioSessionState::NotNeeded };
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/ios/AVAudioSessionCaptureDeviceManager.mm	2020-12-22 10:11:23 UTC (rev 271049)
@@ -34,6 +34,7 @@
 #import <AVFoundation/AVAudioSession.h>
 #import <pal/spi/cocoa/AVFoundationSPI.h>
 #import <wtf/Assertions.h>
+#import <wtf/BlockPtr.h>
 #import <wtf/MainThread.h>
 #import <wtf/Vector.h>
 
@@ -73,7 +74,6 @@
         if (auto* callback = protectedSelf->_callback)
             callback->scheduleUpdateCaptureDevices();
     });
-
 }
 
 @end
@@ -87,7 +87,17 @@
 }
 
 AVAudioSessionCaptureDeviceManager::AVAudioSessionCaptureDeviceManager()
+    : m_dispatchQueue(dispatch_queue_create("com.apple.WebKit.AVAudioSessionCaptureDeviceManager", DISPATCH_QUEUE_SERIAL))
 {
+    dispatch_async(m_dispatchQueue, makeBlockPtr([this, locker = holdLock(m_lock)] {
+        createAudioSession();
+    }).get());
+}
+
+void AVAudioSessionCaptureDeviceManager::createAudioSession()
+{
+    ASSERT(m_lock.isLocked());
+
 #if !PLATFORM(MACCATALYST)
     m_audioSession = adoptNS([[PAL::getAVAudioSessionClass() alloc] initAuxiliarySession]);
 #else
@@ -94,18 +104,17 @@
     // FIXME: Figure out if this is correct for Catalyst, where auxiliary session isn't available.
     m_audioSession = [PAL::getAVAudioSessionClass() sharedInstance];
 #endif
-    
+
     NSError *error = nil;
     auto options = AVAudioSessionCategoryOptionAllowBluetooth | AVAudioSessionCategoryOptionMixWithOthers;
     [m_audioSession setCategory:AVAudioSessionCategoryPlayAndRecord mode:AVAudioSessionModeVideoChat options:options error:&error];
-    if (error) {
+    if (error)
         RELEASE_LOG_ERROR(WebRTC, "Failed to set audio session category with error: %@.", error.localizedDescription);
-        return;
-    }
 }
 
 AVAudioSessionCaptureDeviceManager::~AVAudioSessionCaptureDeviceManager()
 {
+    dispatch_release(m_dispatchQueue);
     [m_listener invalidate];
     m_listener = nullptr;
 }
@@ -155,14 +164,23 @@
 
 void AVAudioSessionCaptureDeviceManager::refreshAudioCaptureDevices()
 {
-    if (!m_listener)
-        m_listener = adoptNS([[WebAVAudioSessionAvailableInputsListener alloc] initWithCallback:this audioSession:m_audioSession.get()]);
+    {
+        // Make sure we have created the audio session.
+        auto locker = holdLock(m_lock);
+    }
+    bool firstTime = !m_devices;
+    if (m_audioSessionState == AudioSessionState::Inactive) {
+        m_audioSessionState = AudioSessionState::Active;
 
-    NSError *error = nil;
-    [m_audioSession setActive:YES withOptions:0 error:&error];
-    if (error)
-        RELEASE_LOG_ERROR(WebRTC, "Failed to activate audio session with error: %@.", error.localizedDescription);
+        if (!m_listener)
+            m_listener = adoptNS([[WebAVAudioSessionAvailableInputsListener alloc] initWithCallback:this audioSession:m_audioSession.get()]);
 
+        NSError *error = nil;
+        [m_audioSession setActive:YES withOptions:0 error:&error];
+        if (error)
+            RELEASE_LOG_ERROR(WebRTC, "Failed to activate audio session with error: %@.", error.localizedDescription);
+    }
+
     Vector<AVAudioSessionCaptureDevice> newAudioDevices;
     Vector<CaptureDevice> newDevices;
     auto *defaultInput = [m_audioSession currentRoute].inputs.firstObject;
@@ -172,7 +190,6 @@
         newAudioDevices.append(WTFMove(audioDevice));
     }
 
-    bool firstTime = !m_devices;
     bool haveDeviceChanges = !m_devices || newAudioDevices.size() != m_devices->size();
     if (!haveDeviceChanges) {
         for (size_t i = 0; i < newAudioDevices.size(); ++i) {
@@ -196,6 +213,30 @@
         deviceChanged();
 }
 
+void AVAudioSessionCaptureDeviceManager::enableAllDevicesQuery()
+{
+    if (m_audioSessionState != AudioSessionState::NotNeeded)
+        return;
+
+    m_audioSessionState = AudioSessionState::Inactive;
+    refreshAudioCaptureDevices();
+}
+
+void AVAudioSessionCaptureDeviceManager::disableAllDevicesQuery()
+{
+    if (m_audioSessionState == AudioSessionState::NotNeeded)
+        return;
+
+    if (m_audioSessionState == AudioSessionState::Active) {
+        NSError *error = nil;
+        [m_audioSession setActive:NO withOptions:0 error:&error];
+        if (error)
+            RELEASE_LOG_ERROR(WebRTC, "Failed to disactivate audio session with error: %@.", error.localizedDescription);
+    }
+
+    m_audioSessionState = AudioSessionState::NotNeeded;
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM) && PLATFORM(IOS_FAMILY)

Modified: trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.h (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.h	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.h	2020-12-22 10:11:23 UTC (rev 271049)
@@ -29,6 +29,7 @@
 
 #include "AudioSession.h"
 #include "CoreAudioCaptureSource.h"
+#include <wtf/WeakHashSet.h>
 
 OBJC_CLASS WebCoreAudioCaptureSourceIOSListener;
 
@@ -44,7 +45,12 @@
     void beginAudioSessionInterruption() { beginInterruption(); }
     void endAudioSessionInterruption(AudioSession::MayResume) { endInterruption(); }
 
+    CaptureSourceOrError createAudioCaptureSource(const CaptureDevice&, String&&, const MediaConstraints*) final;
+    void addExtensiveObserver(ExtensiveObserver&) final;
+    void removeExtensiveObserver(ExtensiveObserver&) final;
+
     RetainPtr<WebCoreAudioCaptureSourceIOSListener> m_listener;
+    WeakHashSet<ExtensiveObserver> m_observers;
 };
 
 } // namespace WebCore

Modified: trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.mm (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.mm	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/ios/CoreAudioCaptureSourceIOS.mm	2020-12-22 10:11:23 UTC (rev 271049)
@@ -28,6 +28,7 @@
 
 #if ENABLE(MEDIA_STREAM) && PLATFORM(IOS_FAMILY)
 
+#import "AVAudioSessionCaptureDeviceManager.h"
 #import "Logging.h"
 #import <AVFoundation/AVAudioSession.h>
 #import <wtf/MainThread.h>
@@ -102,6 +103,28 @@
     return factory.get();
 }
 
+void CoreAudioCaptureSourceFactoryIOS::addExtensiveObserver(ExtensiveObserver& observer)
+{
+    m_observers.add(observer);
+    AVAudioSessionCaptureDeviceManager::singleton().enableAllDevicesQuery();
 }
 
+void CoreAudioCaptureSourceFactoryIOS::removeExtensiveObserver(ExtensiveObserver& observer)
+{
+    m_observers.remove(observer);
+    if (m_observers.computesEmpty())
+        AVAudioSessionCaptureDeviceManager::singleton().disableAllDevicesQuery();
+}
+
+CaptureSourceOrError CoreAudioCaptureSourceFactoryIOS::createAudioCaptureSource(const CaptureDevice& device, String&& hashSalt, const MediaConstraints* constraints)
+{
+    // We enable exhaustive query to be sure to start capture with the right device.
+    // FIXME: We should stop the auxiliary session after starting capture.
+    if (m_observers.computesEmpty())
+        AVAudioSessionCaptureDeviceManager::singleton().enableAllDevicesQuery();
+    return CoreAudioCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
+}
+
+}
+
 #endif // ENABLE(MEDIA_STREAM) && PLATFORM(IOS_FAMILY)

Modified: trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h (271048 => 271049)


--- trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h	2020-12-22 10:11:23 UTC (rev 271049)
@@ -117,15 +117,16 @@
     void devicesChanged(const Vector<CaptureDevice>&);
 
 private:
-    CaptureSourceOrError createAudioCaptureSource(const CaptureDevice& device, String&& hashSalt, const MediaConstraints* constraints) final
-    {
-        return CoreAudioCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
-    }
-
+    CaptureSourceOrError createAudioCaptureSource(const CaptureDevice&, String&&, const MediaConstraints*) override;
     CaptureDeviceManager& audioCaptureDeviceManager() final;
     const Vector<CaptureDevice>& speakerDevices() const final;
 };
 
+inline CaptureSourceOrError CoreAudioCaptureSourceFactory::createAudioCaptureSource(const CaptureDevice& device, String&& hashSalt, const MediaConstraints* constraints)
+{
+    return CoreAudioCaptureSource::create(String { device.persistentId() }, WTFMove(hashSalt), constraints);
+}
+
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)

Modified: trunk/Source/WebKit/ChangeLog (271048 => 271049)


--- trunk/Source/WebKit/ChangeLog	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebKit/ChangeLog	2020-12-22 10:11:23 UTC (rev 271049)
@@ -1,3 +1,22 @@
+2020-12-22  Youenn Fablet  <[email protected]>
+
+        [iOS] Do extensive search for microphone devices when trying to capture
+        https://bugs.webkit.org/show_bug.cgi?id=220010
+        <rdar://problem/72036034>
+
+        Reviewed by Eric Carlson.
+
+        Enable exhaustive audio device query in case getUserMedia is called for audio capture.
+        In case the manager is destroyed or reset after some time without capturing, make sure to disable
+        exhaustive audio device query if no other page need it.
+
+        * UIProcess/UserMediaPermissionRequestManagerProxy.cpp:
+        (WebKit::UserMediaPermissionRequestManagerProxy::invalidatePendingRequests):
+        (WebKit::UserMediaPermissionRequestManagerProxy::denyRequest):
+        (WebKit::UserMediaPermissionRequestManagerProxy::resetAccess):
+        (WebKit::UserMediaPermissionRequestManagerProxy::startProcessingUserMediaPermissionRequest):
+        * UIProcess/UserMediaPermissionRequestManagerProxy.h:
+
 2020-12-21  Wenson Hsieh  <[email protected]>
 
         REGRESSION (iOS 14): Bad access crash in ShareableBitmap::makeCGImageCopy() under assignLegacyDataForContextMenuInteraction()

Modified: trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp (271048 => 271049)


--- trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.cpp	2020-12-22 10:11:23 UTC (rev 271049)
@@ -125,6 +125,10 @@
         request->invalidate();
 
     m_pendingDeviceRequests.clear();
+
+#if ENABLE(MEDIA_STREAM)
+    RealtimeMediaSourceCenter::singleton().audioCaptureFactory().removeExtensiveObserver(*this);
+#endif
 }
 
 void UserMediaPermissionRequestManagerProxy::stopCapture()
@@ -210,6 +214,9 @@
         m_deniedRequests.append(DeniedRequest { request.mainFrameID(), request.userMediaDocumentSecurityOrigin(), request.topLevelDocumentSecurityOrigin(), request.requiresAudioCapture(), request.requiresVideoCapture(), request.requiresDisplayCapture() });
 
 #if ENABLE(MEDIA_STREAM)
+    if (m_pregrantedRequests.isEmpty() && request.userRequest().audioConstraints.isValid)
+        RealtimeMediaSourceCenter::singleton().audioCaptureFactory().removeExtensiveObserver(*this);
+
     m_page.send(Messages::WebPage::UserMediaAccessWasDenied(request.userMediaID(), toWebCore(reason), invalidConstraint));
 #else
     UNUSED_PARAM(reason);
@@ -295,6 +302,9 @@
     m_pregrantedRequests.clear();
     m_deniedRequests.clear();
     m_hasFilteredDeviceList = false;
+#if ENABLE(MEDIA_STREAM)
+    RealtimeMediaSourceCenter::singleton().audioCaptureFactory().removeExtensiveObserver(*this);
+#endif
 }
 
 const UserMediaPermissionRequestProxy* UserMediaPermissionRequestManagerProxy::searchForGrantedRequest(FrameIdentifier frameID, const SecurityOrigin& userMediaDocumentOrigin, const SecurityOrigin& topLevelDocumentOrigin, bool needsAudio, bool needsVideo) const
@@ -437,6 +447,9 @@
 #if ENABLE(MEDIA_STREAM)
 void UserMediaPermissionRequestManagerProxy::startProcessingUserMediaPermissionRequest(Ref<UserMediaPermissionRequestProxy>&& request)
 {
+    if (request->userRequest().audioConstraints.isValid)
+        RealtimeMediaSourceCenter::singleton().audioCaptureFactory().addExtensiveObserver(*this);
+
     m_currentUserMediaRequest = WTFMove(request);
 
     auto& userMediaDocumentSecurityOrigin = m_currentUserMediaRequest->userMediaDocumentSecurityOrigin();

Modified: trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h (271048 => 271049)


--- trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h	2020-12-22 05:20:03 UTC (rev 271048)
+++ trunk/Source/WebKit/UIProcess/UserMediaPermissionRequestManagerProxy.h	2020-12-22 10:11:23 UTC (rev 271049)
@@ -22,6 +22,7 @@
 #include "UserMediaPermissionCheckProxy.h"
 #include "UserMediaPermissionRequestProxy.h"
 #include <WebCore/MediaProducer.h>
+#include <WebCore/RealtimeMediaSourceFactory.h>
 #include <WebCore/SecurityOrigin.h>
 #include <wtf/CompletionHandler.h>
 #include <wtf/Deque.h>
@@ -43,7 +44,11 @@
 class WebPageProxy;
 
 class UserMediaPermissionRequestManagerProxy
+#if ENABLE(MEDIA_STREAM)
+    : public WebCore::AudioCaptureFactory::ExtensiveObserver
+#else
     : public CanMakeWeakPtr<UserMediaPermissionRequestManagerProxy>
+#endif
 #if !RELEASE_LOG_DISABLED
     , private LoggerHelper
 #endif
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to