Changeset 257039 in webkit


Ignore:
Timestamp:
Feb 19, 2020 7:51:21 PM (4 years ago)
Author:
youenn@apple.com
Message:

Add support for AudioSession handling in GPUProcess for capture
https://bugs.webkit.org/show_bug.cgi?id=207950

Reviewed by Eric Carlson.

Source/WebCore:

Add a dedicated interface for handling audio capture in session manager.
This was previoulsy PlatformMediaSessionClient, but this one is more related to audio/video rendering.
Use this new interface for MediaStreamTrack capture sources.
The session manager now owns a WeakHashSet of capture sources to compute the correct AudioSession category.

Modernize the code, for instance use an enum class for MediaType to remove some debug asserts.
Add a new PlatformMediaSessionManager::create that is used for sharedManager.

Remove the direct use of PlatformMediaSessionManager::sharedManager from classes that can be used outside of WebProcess.
This includes BaseAudioSharedUnit, for which we add a audioUnitWillStart callback
so that we compute the right AudioSession category before starting the capture.

Covered by existing tests and debug assertions to check for AudioSession category computation.

  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::MediaStreamTrack):
(WebCore::MediaStreamTrack::~MediaStreamTrack):
(WebCore::MediaStreamTrack::configureTrackRendering):
(WebCore::MediaStreamTrack::isCapturingAudio const):

  • Modules/mediastream/MediaStreamTrack.h:
  • Modules/webaudio/AudioContext.h:
  • html/HTMLAudioElement.h:
  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::shouldDisableSleep const):
(WebCore::HTMLMediaElement::mediaType const):
(WebCore::HTMLMediaElement::presentationType const):

  • html/HTMLVideoElement.h:
  • html/MediaElementSession.cpp:

(WebCore::MediaElementSession::canShowControlsManager const):

  • html/MediaElementSession.h:
  • platform/audio/PlatformMediaSession.cpp:

(WebCore::PlatformMediaSession::PlatformMediaSession):
(WebCore::PlatformMediaSession::activeAudioSessionRequired const):

  • platform/audio/PlatformMediaSession.h:
  • platform/audio/PlatformMediaSessionManager.cpp:

(WebCore::sharedPlatformMediaSessionManager):
(WebCore::PlatformMediaSessionManager::sharedManager):
(WebCore::PlatformMediaSessionManager::sharedManagerIfExists):
(WebCore::PlatformMediaSessionManager::create):
(WebCore::indexFromMediaType):
(WebCore::PlatformMediaSessionManager::resetRestrictions):
(WebCore::PlatformMediaSessionManager::has const):
(WebCore::PlatformMediaSessionManager::count const):
(WebCore::PlatformMediaSessionManager::countActiveAudioCaptureSources):
(WebCore::PlatformMediaSessionManager::addRestriction):
(WebCore::PlatformMediaSessionManager::removeRestriction):
(WebCore::PlatformMediaSessionManager::restrictions):
(WebCore::PlatformMediaSessionManager::sessionWillBeginPlayback):
(WebCore::PlatformMediaSessionManager::applicationWillBecomeInactive):
(WebCore::PlatformMediaSessionManager::applicationDidBecomeActive):
(WebCore::PlatformMediaSessionManager::applicationDidEnterBackground):
(WebCore::PlatformMediaSessionManager::applicationWillEnterForeground):
(WebCore::PlatformMediaSessionManager::sessionIsPlayingToWirelessPlaybackTargetChanged):
(WebCore::PlatformMediaSessionManager::addAudioCaptureSource):
(WebCore::PlatformMediaSessionManager::removeAudioCaptureSource):

  • platform/audio/PlatformMediaSessionManager.h:
  • platform/audio/cocoa/MediaSessionManagerCocoa.mm:

(PlatformMediaSessionManager::create):
(MediaSessionManagerCocoa::updateSessionState):

  • platform/audio/ios/MediaSessionManagerIOS.mm:

(WebCore::PlatformMediaSessionManager::create):
(WebCore::MediaSessionManageriOS::resetRestrictions):

  • platform/mediastream/MediaStreamTrackPrivate.cpp:

(WebCore::MediaStreamTrackPrivate::audioUnitWillStart):

  • platform/mediastream/MediaStreamTrackPrivate.h:
  • platform/mediastream/RealtimeMediaSource.h:
  • platform/mediastream/mac/BaseAudioSharedUnit.cpp:

(WebCore::BaseAudioSharedUnit::startUnit):

  • platform/mediastream/mac/BaseAudioSharedUnit.h:
  • platform/mediastream/mac/CoreAudioCaptureSource.cpp:

(WebCore::CoreAudioCaptureSource::audioUnitWillStart):

  • platform/mediastream/mac/CoreAudioCaptureSource.h:
  • testing/Internals.cpp:

(WebCore::mediaTypeFromString):
(WebCore::Internals::setMediaSessionRestrictions):
(WebCore::Internals::mediaSessionRestrictions const):

Source/WebKit:

Create a session manager for the GPUConnectionToWebProcess.
Pass it to any audio capture source proxy.
For UIProcesss audio capture, we still use the shared manager.

  • GPUProcess/GPUConnectionToWebProcess.cpp:

(WebKit::GPUConnectionToWebProcess::sessionManager):

  • GPUProcess/GPUConnectionToWebProcess.h:
  • GPUProcess/GPUProcess.cpp:

(WebKit::GPUProcess::setMockCaptureDevicesEnabled):

  • UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp:

(WebKit::UserMediaCaptureManagerProxy::SourceProxy::SourceProxy):
(WebKit::UserMediaCaptureManagerProxy::SourceProxy::~SourceProxy):
(WebKit::UserMediaCaptureManagerProxy::createMediaSourceForCaptureDeviceWithConstraints):
(WebKit::UserMediaCaptureManagerProxy::clone):

  • UIProcess/Cocoa/UserMediaCaptureManagerProxy.h:
  • UIProcess/WebProcessProxy.cpp:

LayoutTests:

  • platform/ios/TestExpectations:
Location:
trunk
Files:
32 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r257036 r257039  
     12020-02-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Add support for AudioSession handling in GPUProcess for capture
     4        https://bugs.webkit.org/show_bug.cgi?id=207950
     5
     6        Reviewed by Eric Carlson.
     7
     8        * platform/ios/TestExpectations:
     9
    1102020-02-19  Sunny He  <sunny_he@apple.com>
    211
  • trunk/LayoutTests/platform/ios/TestExpectations

    r256897 r257039  
    107107fast/mediastream [ Skip ]
    108108fast/mediastream/getUserMedia-default.html [ Pass ]
     109fast/mediastream/captureInGPUProcess.html [ Pass ]
    109110
    110111# ENABLE(MEDIA_CAPTURE) is not enabled
  • trunk/Source/WebCore/ChangeLog

    r257036 r257039  
     12020-02-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Add support for AudioSession handling in GPUProcess for capture
     4        https://bugs.webkit.org/show_bug.cgi?id=207950
     5
     6        Reviewed by Eric Carlson.
     7
     8        Add a dedicated interface for handling audio capture in session manager.
     9        This was previoulsy PlatformMediaSessionClient, but this one is more related to audio/video rendering.
     10        Use this new interface for MediaStreamTrack capture sources.
     11        The session manager now owns a WeakHashSet of capture sources to compute the correct AudioSession category.
     12
     13        Modernize the code, for instance use an enum class for MediaType to remove some debug asserts.
     14        Add a new PlatformMediaSessionManager::create that is used for sharedManager.
     15
     16        Remove the direct use of PlatformMediaSessionManager::sharedManager from classes that can be used outside of WebProcess.
     17        This includes BaseAudioSharedUnit, for which we add a audioUnitWillStart callback
     18        so that we compute the right AudioSession category before starting the capture.
     19
     20        Covered by existing tests and debug assertions to check for AudioSession category computation.
     21
     22        * Modules/mediastream/MediaStreamTrack.cpp:
     23        (WebCore::MediaStreamTrack::MediaStreamTrack):
     24        (WebCore::MediaStreamTrack::~MediaStreamTrack):
     25        (WebCore::MediaStreamTrack::configureTrackRendering):
     26        (WebCore::MediaStreamTrack::isCapturingAudio const):
     27        * Modules/mediastream/MediaStreamTrack.h:
     28        * Modules/webaudio/AudioContext.h:
     29        * html/HTMLAudioElement.h:
     30        * html/HTMLMediaElement.cpp:
     31        (WebCore::HTMLMediaElement::shouldDisableSleep const):
     32        (WebCore::HTMLMediaElement::mediaType const):
     33        (WebCore::HTMLMediaElement::presentationType const):
     34        * html/HTMLVideoElement.h:
     35        * html/MediaElementSession.cpp:
     36        (WebCore::MediaElementSession::canShowControlsManager const):
     37        * html/MediaElementSession.h:
     38        * platform/audio/PlatformMediaSession.cpp:
     39        (WebCore::PlatformMediaSession::PlatformMediaSession):
     40        (WebCore::PlatformMediaSession::activeAudioSessionRequired const):
     41        * platform/audio/PlatformMediaSession.h:
     42        * platform/audio/PlatformMediaSessionManager.cpp:
     43        (WebCore::sharedPlatformMediaSessionManager):
     44        (WebCore::PlatformMediaSessionManager::sharedManager):
     45        (WebCore::PlatformMediaSessionManager::sharedManagerIfExists):
     46        (WebCore::PlatformMediaSessionManager::create):
     47        (WebCore::indexFromMediaType):
     48        (WebCore::PlatformMediaSessionManager::resetRestrictions):
     49        (WebCore::PlatformMediaSessionManager::has const):
     50        (WebCore::PlatformMediaSessionManager::count const):
     51        (WebCore::PlatformMediaSessionManager::countActiveAudioCaptureSources):
     52        (WebCore::PlatformMediaSessionManager::addRestriction):
     53        (WebCore::PlatformMediaSessionManager::removeRestriction):
     54        (WebCore::PlatformMediaSessionManager::restrictions):
     55        (WebCore::PlatformMediaSessionManager::sessionWillBeginPlayback):
     56        (WebCore::PlatformMediaSessionManager::applicationWillBecomeInactive):
     57        (WebCore::PlatformMediaSessionManager::applicationDidBecomeActive):
     58        (WebCore::PlatformMediaSessionManager::applicationDidEnterBackground):
     59        (WebCore::PlatformMediaSessionManager::applicationWillEnterForeground):
     60        (WebCore::PlatformMediaSessionManager::sessionIsPlayingToWirelessPlaybackTargetChanged):
     61        (WebCore::PlatformMediaSessionManager::addAudioCaptureSource):
     62        (WebCore::PlatformMediaSessionManager::removeAudioCaptureSource):
     63        * platform/audio/PlatformMediaSessionManager.h:
     64        * platform/audio/cocoa/MediaSessionManagerCocoa.mm:
     65        (PlatformMediaSessionManager::create):
     66        (MediaSessionManagerCocoa::updateSessionState):
     67        * platform/audio/ios/MediaSessionManagerIOS.mm:
     68        (WebCore::PlatformMediaSessionManager::create):
     69        (WebCore::MediaSessionManageriOS::resetRestrictions):
     70        * platform/mediastream/MediaStreamTrackPrivate.cpp:
     71        (WebCore::MediaStreamTrackPrivate::audioUnitWillStart):
     72        * platform/mediastream/MediaStreamTrackPrivate.h:
     73        * platform/mediastream/RealtimeMediaSource.h:
     74        * platform/mediastream/mac/BaseAudioSharedUnit.cpp:
     75        (WebCore::BaseAudioSharedUnit::startUnit):
     76        * platform/mediastream/mac/BaseAudioSharedUnit.h:
     77        * platform/mediastream/mac/CoreAudioCaptureSource.cpp:
     78        (WebCore::CoreAudioCaptureSource::audioUnitWillStart):
     79        * platform/mediastream/mac/CoreAudioCaptureSource.h:
     80        * testing/Internals.cpp:
     81        (WebCore::mediaTypeFromString):
     82        (WebCore::Internals::setMediaSessionRestrictions):
     83        (WebCore::Internals::mediaSessionRestrictions const):
     84
    1852020-02-19  Sunny He  <sunny_he@apple.com>
    286
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

    r256936 r257039  
    7676    , m_private(WTFMove(privateTrack))
    7777    , m_isCaptureTrack(m_private->isCaptureTrack())
    78     , m_mediaSession(PlatformMediaSession::create(PlatformMediaSessionManager::sharedManager(), *this))
    7978{
    8079    ALWAYS_LOG(LOGIDENTIFIER);
     
    8685
    8786    allCaptureTracks().add(this);
     87
     88    if (m_private->type() == RealtimeMediaSource::Type::Audio)
     89        PlatformMediaSessionManager::sharedManager().addAudioCaptureSource(*this);
    8890
    8991    if (auto document = this->document()) {
     
    101103
    102104    allCaptureTracks().remove(this);
     105
     106    if (m_private->type() == RealtimeMediaSource::Type::Audio)
     107        PlatformMediaSessionManager::sharedManager().removeAudioCaptureSource(*this);
    103108}
    104109
     
    537542void MediaStreamTrack::configureTrackRendering()
    538543{
    539     if (m_mediaSession && m_private->type() == RealtimeMediaSource::Type::Audio)
    540         m_mediaSession->canProduceAudioChanged();
    541 
    542544    if (auto document = this->document())
    543545        document->updateIsPlayingMedia();
     
    581583}
    582584
    583 PlatformMediaSession::MediaType MediaStreamTrack::mediaType() const
    584 {
    585     return (isCaptureTrack() && canProduceAudio()) ? PlatformMediaSession::MediaStreamCapturingAudio : PlatformMediaSession::None;
    586 }
    587 
    588 PlatformMediaSession::MediaType MediaStreamTrack::presentationType() const
    589 {
    590     return mediaType();
    591 }
    592 
    593 void MediaStreamTrack::mayResumePlayback(bool)
    594 {
    595     // FIXME: should a media stream track pay attention to this directly, or only when attached to a media element?
    596 }
    597 
    598 void MediaStreamTrack::suspendPlayback()
    599 {
    600     // FIXME: should a media stream track pay attention to this directly, or only when attached to a media element?
    601 }
    602 
    603 String MediaStreamTrack::sourceApplicationIdentifier() const
    604 {
    605     auto* document = this->document();
    606     if (document && document->frame()) {
    607         if (auto* networkingContext = document->frame()->loader().networkingContext())
    608             return networkingContext->sourceApplicationIdentifier();
    609     }
    610 
    611     return emptyString();
    612 }
    613 
    614 bool MediaStreamTrack::canProduceAudio() const
    615 {
    616     return m_private->type() == RealtimeMediaSource::Type::Audio && !ended() && !muted();
    617 }
    618 
    619 DocumentIdentifier MediaStreamTrack::hostingDocumentIdentifier() const
    620 {
    621     auto* document = downcast<Document>(m_scriptExecutionContext);
    622     return document ? document->identifier() : DocumentIdentifier { };
     585bool MediaStreamTrack::isCapturingAudio() const
     586{
     587    ASSERT(isCaptureTrack() && m_private->type() == RealtimeMediaSource::Type::Audio);
     588    return !ended() && !muted();
    623589}
    624590
  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.h

    r256936 r257039  
    5454    , public EventTargetWithInlineData
    5555    , private MediaStreamTrackPrivate::Observer
    56     , private PlatformMediaSessionClient
     56    , private PlatformMediaSession::AudioCaptureSource
    5757#if !RELEASE_LOG_DISABLED
    5858    , private LoggerHelper
     
    191191    void trackEnabledChanged(MediaStreamTrackPrivate&) final;
    192192
    193     // PlatformMediaSessionClient
    194     PlatformMediaSession::MediaType mediaType() const final;
    195     PlatformMediaSession::MediaType presentationType() const final;
    196     void mayResumePlayback(bool shouldResume) final;
    197     void suspendPlayback() final;
    198     bool canReceiveRemoteControlCommands() const final { return false; }
    199     void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) final { }
    200     bool supportsSeeking() const final { return false; }
    201     bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const final { return false; }
    202     String sourceApplicationIdentifier() const final;
    203     bool canProduceAudio() const final;
    204     DocumentIdentifier hostingDocumentIdentifier() const final;
    205     bool shouldOverridePauseDuringRouteChange() const final { return true; }
     193    // PlatformMediaSession::AudioCaptureSource
     194    bool isCapturingAudio() const final;
    206195
    207196#if !RELEASE_LOG_DISABLED
     
    217206    bool m_ended { false };
    218207    const bool m_isCaptureTrack { false };
    219     std::unique_ptr<PlatformMediaSession> m_mediaSession;
    220208};
    221209
  • trunk/Source/WebCore/Modules/webaudio/AudioContext.h

    r256936 r257039  
    348348
    349349    // PlatformMediaSessionClient
    350     PlatformMediaSession::MediaType mediaType() const override { return PlatformMediaSession::WebAudio; }
    351     PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::WebAudio; }
     350    PlatformMediaSession::MediaType mediaType() const override { return PlatformMediaSession::MediaType::WebAudio; }
     351    PlatformMediaSession::MediaType presentationType() const override { return PlatformMediaSession::MediaType::WebAudio; }
    352352    void mayResumePlayback(bool shouldResume) override;
    353353    void suspendPlayback() override;
  • trunk/Source/WebCore/html/HTMLAudioElement.h

    r246490 r257039  
    4444    HTMLAudioElement(const QualifiedName&, Document&, bool);
    4545
    46     PlatformMediaSession::MediaType presentationType() const final { return PlatformMediaSession::Audio; }
     46    PlatformMediaSession::MediaType presentationType() const final { return PlatformMediaSession::MediaType::Audio; }
    4747};
    4848
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r256936 r257039  
    69176917        return SleepType::None;
    69186918
    6919     bool shouldBeAbleToSleep = mediaType() != PlatformMediaSession::VideoAudio;
     6919    bool shouldBeAbleToSleep = mediaType() != PlatformMediaSession::MediaType::VideoAudio;
    69206920#if ENABLE(MEDIA_STREAM)
    69216921    // Remote media stream video tracks may have their corresponding audio tracks being played outside of the media element. Let's ensure to not IDLE the screen in that case.
     
    75187518    if (m_player && m_readyState >= HAVE_METADATA) {
    75197519        if (hasVideo() && hasAudio() && !muted())
    7520             return PlatformMediaSession::VideoAudio;
    7521         return hasVideo() ? PlatformMediaSession::Video : PlatformMediaSession::Audio;
     7520            return PlatformMediaSession::MediaType::VideoAudio;
     7521        return hasVideo() ? PlatformMediaSession::MediaType::Video : PlatformMediaSession::MediaType::Audio;
    75227522    }
    75237523
     
    75287528{
    75297529    if (hasTagName(HTMLNames::videoTag))
    7530         return muted() ? PlatformMediaSession::Video : PlatformMediaSession::VideoAudio;
    7531 
    7532     return PlatformMediaSession::Audio;
     7530        return muted() ? PlatformMediaSession::MediaType::Video : PlatformMediaSession::MediaType::VideoAudio;
     7531
     7532    return PlatformMediaSession::MediaType::Audio;
    75337533}
    75347534
  • trunk/Source/WebCore/html/HTMLVideoElement.h

    r254214 r257039  
    128128    void setDisplayMode(DisplayMode) final;
    129129
    130     PlatformMediaSession::MediaType presentationType() const final { return PlatformMediaSession::Video; }
     130    PlatformMediaSession::MediaType presentationType() const final { return PlatformMediaSession::MediaType::Video; }
    131131
    132132    std::unique_ptr<HTMLImageLoader> m_imageLoader;
  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r256904 r257039  
    437437    }
    438438
    439     if (client().presentationType() == Audio && purpose == PlaybackControlsPurpose::ControlsManager) {
     439    if (client().presentationType() == MediaType::Audio && purpose == PlaybackControlsPurpose::ControlsManager) {
    440440        if (!hasBehaviorRestriction(RequireUserGestureToControlControlsManager) || m_element.document().processingUserGestureForMedia()) {
    441441            INFO_LOG(LOGIDENTIFIER, "returning TRUE: audio element with user gesture");
  • trunk/Source/WebCore/html/MediaElementSession.h

    r251737 r257039  
    154154    static bool isMediaElementSessionMediaType(MediaType type)
    155155    {
    156         return type == Video
    157             || type == Audio
    158             || type == VideoAudio;
     156        return type == MediaType::Video
     157            || type == MediaType::Audio
     158            || type == MediaType::VideoAudio;
    159159    }
    160160
  • trunk/Source/WebCore/platform/audio/PlatformMediaSession.cpp

    r256936 r257039  
    124124#endif
    125125{
    126     ASSERT(m_client.mediaType() >= None && m_client.mediaType() <= MediaStreamCapturingAudio);
    127126    manager.addSession(*this);
    128127}
     
    352351bool PlatformMediaSession::activeAudioSessionRequired() const
    353352{
    354     if (mediaType() == PlatformMediaSession::None)
     353    if (mediaType() == PlatformMediaSession::MediaType::None)
    355354        return false;
    356355    if (state() != PlatformMediaSession::State::Playing)
  • trunk/Source/WebCore/platform/audio/PlatformMediaSession.h

    r256936 r257039  
    6060    virtual ~PlatformMediaSession();
    6161
    62     enum MediaType {
     62    enum class MediaType {
    6363        None = 0,
    6464        Video,
     
    6666        Audio,
    6767        WebAudio,
    68         MediaStreamCapturingAudio,
    6968    };
    7069    MediaType mediaType() const;
     
    191190    bool shouldOverridePauseDuringRouteChange() const;
    192191
     192    class AudioCaptureSource : public CanMakeWeakPtr<AudioCaptureSource> {
     193    public:
     194        virtual ~AudioCaptureSource() = default;
     195        virtual bool isCapturingAudio() const = 0;
     196    };
     197
    193198protected:
    194199    PlatformMediaSession(PlatformMediaSessionManager&, PlatformMediaSessionClient&);
  • trunk/Source/WebCore/platform/audio/PlatformMediaSessionManager.cpp

    r256844 r257039  
    3636#if ENABLE(VIDEO) || ENABLE(WEB_AUDIO)
    3737
     38static std::unique_ptr<PlatformMediaSessionManager>& sharedPlatformMediaSessionManager()
     39{
     40    static NeverDestroyed<std::unique_ptr<PlatformMediaSessionManager>> platformMediaSessionManager;
     41    return platformMediaSessionManager.get();
     42}
     43
     44PlatformMediaSessionManager& PlatformMediaSessionManager::sharedManager()
     45{
     46    auto& manager = sharedPlatformMediaSessionManager();
     47    if (!manager)
     48        manager = PlatformMediaSessionManager::create();
     49    return *manager;
     50}
     51
     52PlatformMediaSessionManager* PlatformMediaSessionManager::sharedManagerIfExists()
     53{
     54    return sharedPlatformMediaSessionManager().get();
     55}
     56
    3857#if !PLATFORM(COCOA)
    39 static PlatformMediaSessionManager* platformMediaSessionManager = nullptr;
    40 
    41 PlatformMediaSessionManager& PlatformMediaSessionManager::sharedManager()
    42 {
    43     if (!platformMediaSessionManager)
    44         platformMediaSessionManager = new PlatformMediaSessionManager;
    45     return *platformMediaSessionManager;
    46 }
    47 
    48 PlatformMediaSessionManager* PlatformMediaSessionManager::sharedManagerIfExists()
    49 {
    50     return platformMediaSessionManager;
     58std::unique_ptr<PlatformMediaSessionManager> PlatformMediaSessionManager::create()
     59{
     60    return std::unique_ptr<PlatformMediaSessionManager>(new PlatformMediaSessionManager);
    5161}
    5262#endif // !PLATFORM(COCOA)
     
    6777}
    6878
     79static inline unsigned indexFromMediaType(PlatformMediaSession::MediaType type)
     80{
     81    return static_cast<unsigned>(type);
     82}
     83
    6984void PlatformMediaSessionManager::resetRestrictions()
    7085{
    71     m_restrictions[PlatformMediaSession::Video] = NoRestrictions;
    72     m_restrictions[PlatformMediaSession::Audio] = NoRestrictions;
    73     m_restrictions[PlatformMediaSession::VideoAudio] = NoRestrictions;
    74     m_restrictions[PlatformMediaSession::WebAudio] = NoRestrictions;
    75     m_restrictions[PlatformMediaSession::MediaStreamCapturingAudio] = NoRestrictions;
     86    m_restrictions[indexFromMediaType(PlatformMediaSession::MediaType::Video)] = NoRestrictions;
     87    m_restrictions[indexFromMediaType(PlatformMediaSession::MediaType::Audio)] = NoRestrictions;
     88    m_restrictions[indexFromMediaType(PlatformMediaSession::MediaType::VideoAudio)] = NoRestrictions;
     89    m_restrictions[indexFromMediaType(PlatformMediaSession::MediaType::WebAudio)] = NoRestrictions;
    7690}
    7791
    7892bool PlatformMediaSessionManager::has(PlatformMediaSession::MediaType type) const
    7993{
    80     ASSERT(type >= PlatformMediaSession::None && type <= PlatformMediaSession::MediaStreamCapturingAudio);
    81 
    8294    return anyOfSessions([type] (auto& session) {
    8395        return session.mediaType() == type;
     
    101113int PlatformMediaSessionManager::count(PlatformMediaSession::MediaType type) const
    102114{
    103     ASSERT(type >= PlatformMediaSession::None && type <= PlatformMediaSession::MediaStreamCapturingAudio);
    104 
    105115    int count = 0;
    106116    for (const auto& session : m_sessions) {
     
    109119    }
    110120
     121    return count;
     122}
     123
     124int PlatformMediaSessionManager::countActiveAudioCaptureSources()
     125{
     126    int count = 0;
     127    for (const auto& source : m_audioCaptureSources) {
     128        if (source.isCapturingAudio())
     129            ++count;
     130    }
    111131    return count;
    112132}
     
    180200void PlatformMediaSessionManager::addRestriction(PlatformMediaSession::MediaType type, SessionRestrictions restriction)
    181201{
    182     ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::MediaStreamCapturingAudio);
    183     m_restrictions[type] |= restriction;
     202    m_restrictions[indexFromMediaType(type)] |= restriction;
    184203}
    185204
    186205void PlatformMediaSessionManager::removeRestriction(PlatformMediaSession::MediaType type, SessionRestrictions restriction)
    187206{
    188     ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::MediaStreamCapturingAudio);
    189     m_restrictions[type] &= ~restriction;
     207    m_restrictions[indexFromMediaType(type)] &= ~restriction;
    190208}
    191209
    192210PlatformMediaSessionManager::SessionRestrictions PlatformMediaSessionManager::restrictions(PlatformMediaSession::MediaType type)
    193211{
    194     ASSERT(type > PlatformMediaSession::None && type <= PlatformMediaSession::MediaStreamCapturingAudio);
    195     return m_restrictions[type];
     212    return m_restrictions[indexFromMediaType(type)];
    196213}
    197214
     
    200217    setCurrentSession(session);
    201218
    202     PlatformMediaSession::MediaType sessionType = session.mediaType();
    203     SessionRestrictions restrictions = m_restrictions[sessionType];
     219    auto sessionType = session.mediaType();
     220    auto restrictions = this->restrictions(sessionType);
    204221    if (session.state() == PlatformMediaSession::Interrupted && restrictions & InterruptedPlaybackNotPermitted) {
    205222        ALWAYS_LOG(LOGIDENTIFIER, session.logIdentifier(), " returning false because session.state() is Interrupted, and InterruptedPlaybackNotPermitted");
     
    305322
    306323    forEachMatchingSession([&](auto& session) {
    307         return m_restrictions[session.mediaType()] & InactiveProcessPlaybackRestricted;
     324        return restrictions(session.mediaType()) & InactiveProcessPlaybackRestricted;
    308325    }, [](auto& session) {
    309326        session.beginInterruption(PlatformMediaSession::ProcessInactive);
     
    316333
    317334    forEachMatchingSession([&](auto& session) {
    318         return m_restrictions[session.mediaType()] & InactiveProcessPlaybackRestricted;
     335        return restrictions(session.mediaType()) & InactiveProcessPlaybackRestricted;
    319336    }, [](auto& session) {
    320337        session.endInterruption(PlatformMediaSession::MayResumePlaying);
     
    332349
    333350    forEachSession([&] (auto& session) {
    334         if (suspendedUnderLock && m_restrictions[session.mediaType()] & SuspendedUnderLockPlaybackRestricted)
     351        if (suspendedUnderLock && restrictions(session.mediaType()) & SuspendedUnderLockPlaybackRestricted)
    335352            session.beginInterruption(PlatformMediaSession::SuspendedUnderLock);
    336         else if (m_restrictions[session.mediaType()] & BackgroundProcessPlaybackRestricted)
     353        else if (restrictions(session.mediaType()) & BackgroundProcessPlaybackRestricted)
    337354            session.beginInterruption(PlatformMediaSession::EnteringBackground);
    338355    });
     
    349366
    350367    forEachMatchingSession([&](auto& session) {
    351         return (suspendedUnderLock && m_restrictions[session.mediaType()] & SuspendedUnderLockPlaybackRestricted) || m_restrictions[session.mediaType()] & BackgroundProcessPlaybackRestricted;
     368        return (suspendedUnderLock && restrictions(session.mediaType()) & SuspendedUnderLockPlaybackRestricted) || restrictions(session.mediaType()) & BackgroundProcessPlaybackRestricted;
    352369    }, [](auto& session) {
    353370        session.endInterruption(PlatformMediaSession::MayResumePlaying);
     
    401418void PlatformMediaSessionManager::sessionIsPlayingToWirelessPlaybackTargetChanged(PlatformMediaSession& session)
    402419{
    403     if (!m_isApplicationInBackground || !(m_restrictions[session.mediaType()] & BackgroundProcessPlaybackRestricted))
     420    if (!m_isApplicationInBackground || !(restrictions(session.mediaType()) & BackgroundProcessPlaybackRestricted))
    404421        return;
    405422
     
    541558}
    542559
     560void PlatformMediaSessionManager::addAudioCaptureSource(PlatformMediaSession::AudioCaptureSource& source)
     561{
     562    ASSERT(!m_audioCaptureSources.contains(source));
     563    m_audioCaptureSources.add(source);
     564    updateSessionState();
     565}
     566
     567
     568void PlatformMediaSessionManager::removeAudioCaptureSource(PlatformMediaSession::AudioCaptureSource& source)
     569{
     570    ASSERT(m_audioCaptureSources.contains(source));
     571    m_audioCaptureSources.remove(source);
     572    updateSessionState();
     573}
     574
    543575#if USE(AUDIO_SESSION)
    544576void PlatformMediaSessionManager::maybeDeactivateAudioSession()
  • trunk/Source/WebCore/platform/audio/PlatformMediaSessionManager.h

    r256904 r257039  
    3535#include <wtf/AggregateLogger.h>
    3636#include <wtf/Vector.h>
     37#include <wtf/WeakHashSet.h>
    3738#include <wtf/WeakPtr.h>
    3839
     
    5556    WEBCORE_EXPORT static PlatformMediaSessionManager* sharedManagerIfExists();
    5657    WEBCORE_EXPORT static PlatformMediaSessionManager& sharedManager();
     58    WEBCORE_EXPORT static std::unique_ptr<PlatformMediaSessionManager> create();
    5759
    5860    static void updateNowPlayingInfoIfNecessary();
     
    139141    bool processIsSuspended() const { return m_processIsSuspended; }
    140142
     143    WEBCORE_EXPORT void addAudioCaptureSource(PlatformMediaSession::AudioCaptureSource&);
     144    WEBCORE_EXPORT void removeAudioCaptureSource(PlatformMediaSession::AudioCaptureSource&);
     145
    141146protected:
    142147    friend class PlatformMediaSession;
     
    164169#endif
    165170
     171    int countActiveAudioCaptureSources();
     172
    166173private:
    167174    friend class Internals;
     
    184191    Vector<WeakPtr<PlatformMediaSession>> sessionsMatching(const Function<bool(const PlatformMediaSession&)>&) const;
    185192
    186     SessionRestrictions m_restrictions[PlatformMediaSession::MediaStreamCapturingAudio + 1];
     193    SessionRestrictions m_restrictions[static_cast<unsigned>(PlatformMediaSession::MediaType::WebAudio) + 1];
    187194    mutable Vector<WeakPtr<PlatformMediaSession>> m_sessions;
    188195    std::unique_ptr<RemoteCommandListener> m_remoteCommandListener;
     
    205212#endif
    206213
     214    WeakHashSet<PlatformMediaSession::AudioCaptureSource> m_audioCaptureSources;
     215
    207216#if !RELEASE_LOG_DISABLED
    208217    Ref<AggregateLogger> m_logger;
  • trunk/Source/WebCore/platform/audio/cocoa/MediaSessionManagerCocoa.mm

    r255116 r257039  
    4646
    4747#if PLATFORM(MAC)
    48 static MediaSessionManagerCocoa* platformMediaSessionManager = nullptr;
    49 
    50 PlatformMediaSessionManager& PlatformMediaSessionManager::sharedManager()
    51 {
    52     if (!platformMediaSessionManager)
    53         platformMediaSessionManager = new MediaSessionManagerCocoa;
    54     return *platformMediaSessionManager;
    55 }
    56 
    57 PlatformMediaSessionManager* PlatformMediaSessionManager::sharedManagerIfExists()
    58 {
    59     return platformMediaSessionManager;
    60 }
    61 #endif
     48std::unique_ptr<PlatformMediaSessionManager> PlatformMediaSessionManager::create()
     49{
     50    return makeUnique<MediaSessionManagerCocoa>();
     51}
     52#endif // !PLATFORM(MAC)
    6253
    6354void MediaSessionManagerCocoa::updateSessionState()
    6455{
    65     int videoCount = count(PlatformMediaSession::Video);
    66     int videoAudioCount = count(PlatformMediaSession::VideoAudio);
    67     int audioCount = count(PlatformMediaSession::Audio);
    68     int webAudioCount = count(PlatformMediaSession::WebAudio);
    69     int captureCount = count(PlatformMediaSession::MediaStreamCapturingAudio);
     56    int videoCount = count(PlatformMediaSession::MediaType::Video);
     57    int videoAudioCount = count(PlatformMediaSession::MediaType::VideoAudio);
     58    int audioCount = count(PlatformMediaSession::MediaType::Audio);
     59    int webAudioCount = count(PlatformMediaSession::MediaType::WebAudio);
     60    int captureCount = countActiveAudioCaptureSources();
    7061    ALWAYS_LOG(LOGIDENTIFIER, "types: "
    7162        "AudioCapture(", captureCount, "), "
     
    10091    forEachSession([&hasAudibleAudioOrVideoMediaType] (auto& session) mutable {
    10192        auto type = session.mediaType();
    102         if ((type == PlatformMediaSession::VideoAudio || type == PlatformMediaSession::Audio) && session.canProduceAudio() && session.hasPlayedSinceLastInterruption())
     93        if ((type == PlatformMediaSession::MediaType::VideoAudio || type == PlatformMediaSession::MediaType::Audio) && session.canProduceAudio() && session.hasPlayedSinceLastInterruption())
    10394            hasAudibleAudioOrVideoMediaType = true;
    10495        if (session.isPlayingToWirelessPlaybackTarget())
  • trunk/Source/WebCore/platform/audio/ios/MediaSessionManagerIOS.mm

    r256770 r257039  
    9999namespace WebCore {
    100100
    101 static MediaSessionManageriOS* platformMediaSessionManager = nullptr;
    102 
    103 PlatformMediaSessionManager& PlatformMediaSessionManager::sharedManager()
    104 {
    105     if (!platformMediaSessionManager)
    106         platformMediaSessionManager = new MediaSessionManageriOS;
    107     return *platformMediaSessionManager;
    108 }
    109 
    110 PlatformMediaSessionManager* PlatformMediaSessionManager::sharedManagerIfExists()
    111 {
    112     return platformMediaSessionManager;
     101std::unique_ptr<PlatformMediaSessionManager> PlatformMediaSessionManager::create()
     102{
     103    return std::unique_ptr<MediaSessionManageriOS>(new MediaSessionManageriOS);
    113104}
    114105
     
    144135    if (ramSize() < systemMemoryRequiredForVideoInBackgroundTabs) {
    145136        ALWAYS_LOG(LOGIDENTIFIER, "restricting video in background tabs because system memory = ", ramSize());
    146         addRestriction(PlatformMediaSession::Video, BackgroundTabPlaybackRestricted);
    147     }
    148 
    149     addRestriction(PlatformMediaSession::Video, BackgroundProcessPlaybackRestricted);
    150     addRestriction(PlatformMediaSession::VideoAudio, ConcurrentPlaybackNotPermitted | BackgroundProcessPlaybackRestricted | SuspendedUnderLockPlaybackRestricted);
     137        addRestriction(PlatformMediaSession::MediaType::Video, BackgroundTabPlaybackRestricted);
     138    }
     139
     140    addRestriction(PlatformMediaSession::MediaType::Video, BackgroundProcessPlaybackRestricted);
     141    addRestriction(PlatformMediaSession::MediaType::VideoAudio, ConcurrentPlaybackNotPermitted | BackgroundProcessPlaybackRestricted | SuspendedUnderLockPlaybackRestricted);
    151142}
    152143
  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp

    r249018 r257039  
    3434#include "IntRect.h"
    3535#include "Logging.h"
     36#include "PlatformMediaSessionManager.h"
    3637#include <wtf/UUID.h>
    3738
     
    303304}
    304305
     306void MediaStreamTrackPrivate::audioUnitWillStart()
     307{
     308    if (!m_isEnded)
     309        PlatformMediaSessionManager::sharedManager().sessionCanProduceAudioChanged();
     310}
     311
    305312#if !RELEASE_LOG_DISABLED
    306313WTFLogChannel& MediaStreamTrackPrivate::logChannel() const
  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.h

    r254446 r257039  
    141141    void videoSampleAvailable(MediaSample&) final;
    142142    void audioSamplesAvailable(const MediaTime&, const PlatformAudioData&, const AudioStreamDescription&, size_t) final;
     143    void audioUnitWillStart() final;
    143144
    144145    void updateReadyState();
  • trunk/Source/WebCore/platform/mediastream/RealtimeMediaSource.h

    r253275 r257039  
    8484        virtual void sourceMutedChanged() { }
    8585        virtual void sourceSettingsChanged() { }
     86        virtual void audioUnitWillStart() { }
    8687
    8788        // Observer state queries.
  • trunk/Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.cpp

    r253953 r257039  
    3131#include "AudioSession.h"
    3232#include "CoreAudioCaptureSource.h"
     33#include "DeprecatedGlobalSettings.h"
    3334#include "Logging.h"
    3435#include "PlatformMediaSessionManager.h"
     
    9495OSStatus BaseAudioSharedUnit::startUnit()
    9596{
    96 #if PLATFORM(IOS_FAMILY)
    97     if (!m_disableAudioSessionCheck) {
    98         PlatformMediaSessionManager::sharedManager().sessionCanProduceAudioChanged();
    99         ASSERT(AudioSession::sharedSession().category() == AudioSession::PlayAndRecord);
    100     }
    101 #endif
     97    forEachClient([](auto& client) {
     98        client.audioUnitWillStart();
     99    });
     100    ASSERT(!DeprecatedGlobalSettings::shouldManageAudioSessionCategory() || AudioSession::sharedSession().category() == AudioSession::PlayAndRecord);
    102101
    103102    if (auto error = startInternal()) {
  • trunk/Source/WebCore/platform/mediastream/mac/BaseAudioSharedUnit.h

    r253705 r257039  
    7777    virtual CapabilityValueOrRange sampleRateCapacities() const = 0;
    7878
    79     void setDisableAudioSessionCheck(bool value) { m_disableAudioSessionCheck = value; };
    80 
    8179protected:
    8280    void forEachClient(const Function<void(CoreAudioCaptureSource&)>&) const;
     
    106104    HashSet<CoreAudioCaptureSource*> m_clients;
    107105    mutable RecursiveLock m_clientsLock;
    108     bool m_disableAudioSessionCheck { false };
    109106};
    110107
  • trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.cpp

    r254259 r257039  
    804804}
    805805
     806void CoreAudioCaptureSource::audioUnitWillStart()
     807{
     808    forEachObserver([](auto& observer) {
     809        observer.audioUnitWillStart();
     810    });
     811}
     812
    806813} // namespace WebCore
    807814
  • trunk/Source/WebCore/platform/mediastream/mac/CoreAudioCaptureSource.h

    r252961 r257039  
    9090
    9191    void initializeToStartProducingData();
     92    void audioUnitWillStart();
    9293
    9394#if !RELEASE_LOG_DISABLED
  • trunk/Source/WebCore/testing/Internals.cpp

    r256918 r257039  
    39153915{
    39163916    if (equalLettersIgnoringASCIICase(mediaTypeString, "video"))
    3917         return PlatformMediaSession::Video;
     3917        return PlatformMediaSession::MediaType::Video;
    39183918    if (equalLettersIgnoringASCIICase(mediaTypeString, "audio"))
    3919         return PlatformMediaSession::Audio;
     3919        return PlatformMediaSession::MediaType::Audio;
    39203920    if (equalLettersIgnoringASCIICase(mediaTypeString, "videoaudio"))
    3921         return PlatformMediaSession::VideoAudio;
     3921        return PlatformMediaSession::MediaType::VideoAudio;
    39223922    if (equalLettersIgnoringASCIICase(mediaTypeString, "webaudio"))
    3923         return PlatformMediaSession::WebAudio;
    3924     if (equalLettersIgnoringASCIICase(mediaTypeString, "mediastreamcapturingaudio"))
    3925         return PlatformMediaSession::MediaStreamCapturingAudio;
    3926 
    3927     return PlatformMediaSession::None;
     3923        return PlatformMediaSession::MediaType::WebAudio;
     3924
     3925    return PlatformMediaSession::MediaType::None;
    39283926}
    39293927
    39303928ExceptionOr<void> Internals::setMediaSessionRestrictions(const String& mediaTypeString, StringView restrictionsString)
    39313929{
    3932     PlatformMediaSession::MediaType mediaType = mediaTypeFromString(mediaTypeString);
    3933     if (mediaType == PlatformMediaSession::None)
    3934         return Exception { InvalidAccessError };
    3935 
    3936     PlatformMediaSessionManager::SessionRestrictions restrictions = PlatformMediaSessionManager::sharedManager().restrictions(mediaType);
     3930    auto mediaType = mediaTypeFromString(mediaTypeString);
     3931    if (mediaType == PlatformMediaSession::MediaType::None)
     3932        return Exception { InvalidAccessError };
     3933
     3934    auto restrictions = PlatformMediaSessionManager::sharedManager().restrictions(mediaType);
    39373935    PlatformMediaSessionManager::sharedManager().removeRestriction(mediaType, restrictions);
    39383936
     
    39603958{
    39613959    PlatformMediaSession::MediaType mediaType = mediaTypeFromString(mediaTypeString);
    3962     if (mediaType == PlatformMediaSession::None)
     3960    if (mediaType == PlatformMediaSession::MediaType::None)
    39633961        return Exception { InvalidAccessError };
    39643962
  • trunk/Source/WebKit/ChangeLog

    r257029 r257039  
     12020-02-19  Youenn Fablet  <youenn@apple.com>
     2
     3        Add support for AudioSession handling in GPUProcess for capture
     4        https://bugs.webkit.org/show_bug.cgi?id=207950
     5
     6        Reviewed by Eric Carlson.
     7
     8        Create a session manager for the GPUConnectionToWebProcess.
     9        Pass it to any audio capture source proxy.
     10        For UIProcesss audio capture, we still use the shared manager.
     11
     12        * GPUProcess/GPUConnectionToWebProcess.cpp:
     13        (WebKit::GPUConnectionToWebProcess::sessionManager):
     14        * GPUProcess/GPUConnectionToWebProcess.h:
     15        * GPUProcess/GPUProcess.cpp:
     16        (WebKit::GPUProcess::setMockCaptureDevicesEnabled):
     17        * UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp:
     18        (WebKit::UserMediaCaptureManagerProxy::SourceProxy::SourceProxy):
     19        (WebKit::UserMediaCaptureManagerProxy::SourceProxy::~SourceProxy):
     20        (WebKit::UserMediaCaptureManagerProxy::createMediaSourceForCaptureDeviceWithConstraints):
     21        (WebKit::UserMediaCaptureManagerProxy::clone):
     22        * UIProcess/Cocoa/UserMediaCaptureManagerProxy.h:
     23        * UIProcess/WebProcessProxy.cpp:
     24
    1252020-02-19  Per Arne Vollan  <pvollan@apple.com>
    226
  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.cpp

    r256493 r257039  
    6161
    6262#include <WebCore/MockRealtimeMediaSourceCenter.h>
     63#include <WebCore/PlatformMediaSessionManager.h>
    6364
    6465namespace WebKit {
     
    7879    void removeMessageReceiver(IPC::StringReference messageReceiverName) final { }
    7980    IPC::Connection& connection() final { return m_process.connection(); }
     81    PlatformMediaSessionManager& sessionManager() final { return m_process.sessionManager(); }
    8082
    8183    GPUConnectionToWebProcess& m_process;
     
    274276#endif
    275277
     278PlatformMediaSessionManager& GPUConnectionToWebProcess::sessionManager()
     279{
     280    if (!m_sessionManager)
     281        m_sessionManager = PlatformMediaSessionManager::create();
     282    return *m_sessionManager;
     283}
     284
    276285} // namespace WebKit
    277286
  • trunk/Source/WebKit/GPUProcess/GPUConnectionToWebProcess.h

    r256493 r257039  
    3737#include <wtf/UniqueRef.h>
    3838
     39namespace WebCore {
     40class PlatformMediaSessionManager;
     41}
     42
    3943namespace WebKit {
    4044
     
    7074    const String& mediaKeysStorageDirectory() const;
    7175#endif
     76
     77    WebCore::PlatformMediaSessionManager& sessionManager();
    7278
    7379private:
     
    112118    std::unique_ptr<LibWebRTCCodecsProxy> m_libWebRTCCodecsProxy;
    113119#endif
     120    std::unique_ptr<WebCore::PlatformMediaSessionManager> m_sessionManager;
    114121};
    115122
  • trunk/Source/WebKit/GPUProcess/GPUProcess.cpp

    r255346 r257039  
    152152{
    153153#if ENABLE(MEDIA_STREAM)
    154     // FIXME: Enable the audio session check by implementing an AudioSession for the GPUProcess.
    155     MockAudioSharedUnit::singleton().setDisableAudioSessionCheck(isEnabled);
    156154    MockRealtimeMediaSourceCenter::setMockRealtimeMediaSourceCenterEnabled(isEnabled);
    157155#endif
  • trunk/Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.cpp

    r255211 r257039  
    3636#include <WebCore/CARingBuffer.h>
    3737#include <WebCore/MediaConstraints.h>
     38#include <WebCore/PlatformMediaSessionManager.h>
    3839#include <WebCore/RealtimeMediaSourceCenter.h>
    3940#include <WebCore/RemoteVideoSample.h>
     
    4445using namespace WebCore;
    4546
    46 class UserMediaCaptureManagerProxy::SourceProxy : public RealtimeMediaSource::Observer, public SharedRingBufferStorage::Client {
     47class UserMediaCaptureManagerProxy::SourceProxy
     48    : public RealtimeMediaSource::Observer
     49    , public SharedRingBufferStorage::Client
     50    , public PlatformMediaSession::AudioCaptureSource {
    4751    WTF_MAKE_FAST_ALLOCATED;
    4852public:
    49     SourceProxy(RealtimeMediaSourceIdentifier id, Ref<IPC::Connection>&& connection, Ref<RealtimeMediaSource>&& source)
     53    SourceProxy(RealtimeMediaSourceIdentifier id, PlatformMediaSessionManager& sessionManager, Ref<IPC::Connection>&& connection, Ref<RealtimeMediaSource>&& source)
    5054        : m_id(id)
     55        , m_sessionManager(makeWeakPtr(sessionManager))
    5156        , m_connection(WTFMove(connection))
    5257        , m_source(WTFMove(source))
     
    5459    {
    5560        m_source->addObserver(*this);
     61
     62        if (m_source->type() == RealtimeMediaSource::Type::Audio)
     63            sessionManager.addAudioCaptureSource(*this);
    5664    }
    5765
     
    6068        storage().invalidate();
    6169        m_source->removeObserver(*this);
     70
     71        if (m_source->type() == RealtimeMediaSource::Type::Audio && m_sessionManager)
     72            m_sessionManager->removeAudioCaptureSource(*this);
    6273    }
    6374
     
    6677    CAAudioStreamDescription& description() { return m_description; }
    6778    int64_t numberOfFrames() { return m_numberOfFrames; }
     79
     80    bool isCapturingAudio() const final { return !m_isEnded && m_source->isProducingData(); }
     81
     82    void audioUnitWillStart() final
     83    {
     84        if (!m_isEnded && m_sessionManager)
     85            m_sessionManager->sessionCanProduceAudioChanged();
     86    }
    6887
    6988    void start()
     
    146165
    147166    RealtimeMediaSourceIdentifier m_id;
     167    WeakPtr<PlatformMediaSessionManager> m_sessionManager;
    148168    Ref<IPC::Connection> m_connection;
    149169    Ref<RealtimeMediaSource> m_source;
     
    193213        settings = source->settings();
    194214        ASSERT(!m_proxies.contains(id));
    195         m_proxies.add(id, makeUnique<SourceProxy>(id, m_connectionProxy->connection(), WTFMove(source)));
     215        m_proxies.add(id, makeUnique<SourceProxy>(id, m_connectionProxy->sessionManager(), m_connectionProxy->connection(), WTFMove(source)));
    196216    } else
    197217        invalidConstraints = WTFMove(sourceOrError.errorMessage);
     
    249269    ASSERT(!m_proxies.contains(newSourceID));
    250270    if (auto* proxy = m_proxies.get(clonedID))
    251         m_proxies.add(newSourceID, makeUnique<SourceProxy>(newSourceID, m_connectionProxy->connection(), proxy->source().clone()));
     271        m_proxies.add(newSourceID, makeUnique<SourceProxy>(newSourceID, m_connectionProxy->sessionManager(), m_connectionProxy->connection(), proxy->source().clone()));
    252272}
    253273
  • trunk/Source/WebKit/UIProcess/Cocoa/UserMediaCaptureManagerProxy.h

    r255133 r257039  
    3636#include <wtf/UniqueRef.h>
    3737
     38namespace WebCore {
     39class PlatformMediaSessionManager;
     40}
     41
    3842namespace WebKit {
    3943
     
    5054        virtual void removeMessageReceiver(IPC::StringReference) = 0;
    5155        virtual IPC::Connection& connection() = 0;
     56        virtual WebCore::PlatformMediaSessionManager& sessionManager() = 0;
    5257    };
    5358    explicit UserMediaCaptureManagerProxy(UniqueRef<ConnectionProxy>&&);
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r256742 r257039  
    6060#include "WebsiteDataFetchOption.h"
    6161#include <WebCore/DiagnosticLoggingKeys.h>
     62#include <WebCore/PlatformMediaSessionManager.h>
    6263#include <WebCore/PrewarmInformation.h>
    6364#include <WebCore/PublicSuffix.h>
     
    160161    void removeMessageReceiver(IPC::StringReference messageReceiverName) final { m_process.removeMessageReceiver(messageReceiverName); }
    161162    IPC::Connection& connection() final { return *m_process.connection(); }
     163    PlatformMediaSessionManager& sessionManager() final { return PlatformMediaSessionManager::sharedManager(); }
    162164
    163165    WebProcessProxy& m_process;
Note: See TracChangeset for help on using the changeset viewer.