Changeset 250853 in webkit


Ignore:
Timestamp:
Oct 8, 2019 12:53:56 PM (5 years ago)
Author:
youenn@apple.com
Message:

MediaStreamTrack should be a PlatformMediaSessionClient instead of MediaStream
​https://bugs.webkit.org/show_bug.cgi?id=202631

Reviewed by Eric Carlson.

Source/WebCore:

Make MediaStreamTrack a PlatformMediaSessionClient, which allows tracking tracks that are not owned by a stream.
MediaStream is no longer a PlatformMediaSessionClient so we move some of MediaStream API implementation to MediaStreamTrack.

Covered by updated test.

  • Modules/mediastream/MediaStream.cpp:

(WebCore::MediaStream::MediaStream):
(WebCore::MediaStream::startProducingData):
(WebCore::MediaStream::stopProducingData):
(WebCore::MediaStream::statusDidChange):
(WebCore::MediaStream::mediaType const): Deleted.
(WebCore::MediaStream::presentationType const): Deleted.
(WebCore::MediaStream::characteristics const): Deleted.
(WebCore::MediaStream::mayResumePlayback): Deleted.
(WebCore::MediaStream::suspendPlayback): Deleted.
(WebCore::MediaStream::sourceApplicationIdentifier const): Deleted.
(WebCore::MediaStream::canProduceAudio const): Deleted.
(WebCore::MediaStream::processingUserGestureForMedia const): Deleted.

  • Modules/mediastream/MediaStream.h:
  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::MediaStreamTrack):
(WebCore::MediaStreamTrack::configureTrackRendering):
(WebCore::MediaStreamTrack::mediaType const):
(WebCore::MediaStreamTrack::presentationType const):
(WebCore::MediaStreamTrack::characteristics const):
(WebCore::MediaStreamTrack::mayResumePlayback):
(WebCore::MediaStreamTrack::suspendPlayback):
(WebCore::MediaStreamTrack::sourceApplicationIdentifier const):
(WebCore::MediaStreamTrack::canProduceAudio const):
(WebCore::MediaStreamTrack::processingUserGestureForMedia const):

  • Modules/mediastream/MediaStreamTrack.h:
  • platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:

(WebCore::MediaPlayerPrivateGStreamer::load):

  • platform/mediastream/MediaStreamPrivate.cpp:

(WebCore::MediaStreamPrivate::hasVideo const):
(WebCore::MediaStreamPrivate::hasAudio const):
(WebCore::MediaStreamPrivate::hasCaptureVideoSource const): Deleted.
(WebCore::MediaStreamPrivate::hasCaptureAudioSource const): Deleted.

  • platform/mediastream/MediaStreamPrivate.h:
  • platform/mediastream/MediaStreamTrackPrivate.h:

LayoutTests:

  • fast/mediastream/audio-track-enabled.html:
Location:
trunk
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r250852 r250853  
     12019-10-08  youenn fablet  <youenn@apple.com>
     2
     3        MediaStreamTrack should be a PlatformMediaSessionClient instead of MediaStream
     4        https://bugs.webkit.org/show_bug.cgi?id=202631
     5
     6        Reviewed by Eric Carlson.
     7
     8        * fast/mediastream/audio-track-enabled.html:
     9
    1102019-10-08  Brady Eidson  <beidson@apple.com>
    211

  • trunk/LayoutTests/fast/mediastream/audio-track-enabled.html

    r250663 r250853  
    2424    await new Promise(resolve => setTimeout(resolve, 10));
    2525    assert_equals(internals.audioSessionCategory(), "PlayAndRecord");
     26
     27    stream.removeTrack(stream.getAudioTracks()[0]);
     28    await new Promise(resolve => setTimeout(resolve, 10));
     29    assert_equals(internals.audioSessionCategory(), "PlayAndRecord");
    2630}, "Check audio session state in case of disabled audio tracks");
    2731</script>

  • trunk/Source/WebCore/ChangeLog

    r250852 r250853  
     12019-10-08  youenn fablet  <youenn@apple.com>
     2
     3        MediaStreamTrack should be a PlatformMediaSessionClient instead of MediaStream
     4        https://bugs.webkit.org/show_bug.cgi?id=202631
     5
     6        Reviewed by Eric Carlson.
     7
     8        Make MediaStreamTrack a PlatformMediaSessionClient, which allows tracking tracks that are not owned by a stream.
     9        MediaStream is no longer a PlatformMediaSessionClient so we move some of MediaStream API implementation to MediaStreamTrack.
     10
     11        Covered by updated test.
     12
     13        * Modules/mediastream/MediaStream.cpp:
     14        (WebCore::MediaStream::MediaStream):
     15        (WebCore::MediaStream::startProducingData):
     16        (WebCore::MediaStream::stopProducingData):
     17        (WebCore::MediaStream::statusDidChange):
     18        (WebCore::MediaStream::mediaType const): Deleted.
     19        (WebCore::MediaStream::presentationType const): Deleted.
     20        (WebCore::MediaStream::characteristics const): Deleted.
     21        (WebCore::MediaStream::mayResumePlayback): Deleted.
     22        (WebCore::MediaStream::suspendPlayback): Deleted.
     23        (WebCore::MediaStream::sourceApplicationIdentifier const): Deleted.
     24        (WebCore::MediaStream::canProduceAudio const): Deleted.
     25        (WebCore::MediaStream::processingUserGestureForMedia const): Deleted.
     26        * Modules/mediastream/MediaStream.h:
     27        * Modules/mediastream/MediaStreamTrack.cpp:
     28        (WebCore::MediaStreamTrack::MediaStreamTrack):
     29        (WebCore::MediaStreamTrack::configureTrackRendering):
     30        (WebCore::MediaStreamTrack::mediaType const):
     31        (WebCore::MediaStreamTrack::presentationType const):
     32        (WebCore::MediaStreamTrack::characteristics const):
     33        (WebCore::MediaStreamTrack::mayResumePlayback):
     34        (WebCore::MediaStreamTrack::suspendPlayback):
     35        (WebCore::MediaStreamTrack::sourceApplicationIdentifier const):
     36        (WebCore::MediaStreamTrack::canProduceAudio const):
     37        (WebCore::MediaStreamTrack::processingUserGestureForMedia const):
     38        * Modules/mediastream/MediaStreamTrack.h:
     39        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp:
     40        (WebCore::MediaPlayerPrivateGStreamer::load):
     41        * platform/mediastream/MediaStreamPrivate.cpp:
     42        (WebCore::MediaStreamPrivate::hasVideo const):
     43        (WebCore::MediaStreamPrivate::hasAudio const):
     44        (WebCore::MediaStreamPrivate::hasCaptureVideoSource const): Deleted.
     45        (WebCore::MediaStreamPrivate::hasCaptureAudioSource const): Deleted.
     46        * platform/mediastream/MediaStreamPrivate.h:
     47        * platform/mediastream/MediaStreamTrackPrivate.h:
     48
    1492019-10-08  Brady Eidson  <beidson@apple.com>
    250

  • trunk/Source/WebCore/Modules/mediastream/MediaStream.cpp

    r250663 r250853  
    8080    : ActiveDOMObject(document)
    8181    , m_private(MediaStreamPrivate::create(document.logger(), createTrackPrivateVector(tracks)))
    82     , m_mediaSession(PlatformMediaSession::create(*this))
    8382{
    8483    // This constructor preserves MediaStreamTrack instances and must be used by calls originating
    … …  
    9897    : ActiveDOMObject(document)
    9998    , m_private(WTFMove(streamPrivate))
    100     , m_mediaSession(PlatformMediaSession::create(*this))
    10199{
    102100    ALWAYS_LOG(LOGIDENTIFIER);
    … …  
    303301        return;
    304302    m_isProducingData = true;
    305 
    306     m_mediaSession->canProduceAudioChanged();
    307303    m_private->startProducingData();
    308304}
    … …  
    310306void MediaStream::stopProducingData()
    311307{
     308    ALWAYS_LOG(LOGIDENTIFIER);
     309
    312310    if (!m_isProducingData)
    313311        return;
    314312
    315     ALWAYS_LOG(LOGIDENTIFIER);
    316 
    317313    m_isProducingData = false;
    318 
    319     m_mediaSession->canProduceAudioChanged();
    320 
    321314    m_private->stopProducingData();
    322315}
    … …  
    337330void MediaStream::statusDidChange()
    338331{
    339     m_mediaSession->canProduceAudioChanged();
    340 
    341     if (Document* document = this->document()) {
     332    if (auto* document = this->document()) {
    342333        if (!m_isActive)
    343334            return;
    … …  
    400391}
    401392
    402 PlatformMediaSession::MediaType MediaStream::mediaType() const
    403 {
    404     // We only need to override the type when capturing audio, HTMLMediaElement and/or WebAudio
    405     // will do the right thing when a stream is attached to a media element or an audio context.
    406     if (m_private->hasCaptureAudioSource())
    407         return PlatformMediaSession::MediaStreamCapturingAudio;
    408 
    409     return PlatformMediaSession::None;
    410 }
    411 
    412 PlatformMediaSession::MediaType MediaStream::presentationType() const
    413 {
    414     return mediaType();
    415 }
    416 
    417 PlatformMediaSession::CharacteristicsFlags MediaStream::characteristics() const
    418 {
    419     PlatformMediaSession::CharacteristicsFlags state = PlatformMediaSession::HasNothing;
    420 
    421     if (!m_isProducingData)
    422         return state;
    423 
    424     if (m_private->hasAudio())
    425         state |= PlatformMediaSession::HasAudio;
    426 
    427     if (m_private->hasVideo())
    428         state |= PlatformMediaSession::HasVideo;
    429 
    430     return state;
    431 }
    432 
    433 void MediaStream::mayResumePlayback(bool)
    434 {
    435     // FIXME: should a media stream pay attention to this directly, or only when attached to a media element?
    436 }
    437 
    438 void MediaStream::suspendPlayback()
    439 {
    440     // FIXME: should a media stream pay attention to this directly, or only when attached to a media element?
    441 }
    442 
    443 String MediaStream::sourceApplicationIdentifier() const
    444 {
    445     Document* document = this->document();
    446     if (document && document->frame()) {
    447         if (NetworkingContext* networkingContext = document->frame()->loader().networkingContext())
    448             return networkingContext->sourceApplicationIdentifier();
    449     }
    450 
    451     return emptyString();
    452 }
    453 
    454 bool MediaStream::canProduceAudio() const
    455 {
    456     return !muted() && active() && m_private->hasAudio() && m_isProducingData;
    457 }
    458 
    459 bool MediaStream::processingUserGestureForMedia() const
    460 {
    461     return document() ? document()->processingUserGestureForMedia() : false;
    462 }
    463 
    464393void MediaStream::stop()
    465394{

  • trunk/Source/WebCore/Modules/mediastream/MediaStream.h

    r248997 r250853  
    3636#include "MediaStreamPrivate.h"
    3737#include "MediaStreamTrack.h"
    38 #include "PlatformMediaSession.h"
    3938#include "ScriptWrappable.h"
    4039#include "Timer.h"
    … …  
    5554    , public MediaStreamPrivate::Observer
    5655    , private MediaCanStartListener
    57     , private PlatformMediaSessionClient
    5856#if !RELEASE_LOG_DISABLED
    5957    , private LoggerHelper
    … …  
    146144    void mediaCanStart(Document&) final;
    147145
    148     // PlatformMediaSessionClient
    149     PlatformMediaSession::MediaType mediaType() const final;
    150     PlatformMediaSession::MediaType presentationType() const final;
    151     PlatformMediaSession::CharacteristicsFlags characteristics() const final;
    152     void mayResumePlayback(bool shouldResume) final;
    153     void suspendPlayback() final;
    154     bool canReceiveRemoteControlCommands() const final { return false; }
    155     void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) final { }
    156     bool supportsSeeking() const final { return false; }
    157     bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const final { return false; }
    158     String sourceApplicationIdentifier() const final;
    159     bool canProduceAudio() const final;
    160     Document* hostingDocument() const final { return document(); }
    161     bool processingUserGestureForMedia() const final;
    162     bool shouldOverridePauseDuringRouteChange() const final { return true; }
    163 
    164146    // ActiveDOMObject API.
    165147    void stop() final;
    … …  
    179161
    180162    Vector<Observer*> m_observers;
    181     std::unique_ptr<PlatformMediaSession> m_mediaSession;
    182163
    183164    MediaProducer::MediaStateFlags m_state { MediaProducer::IsNotPlaying };

  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.cpp

    r250824 r250853  
    7171    , m_taskQueue(context)
    7272    , m_isCaptureTrack(m_private->isCaptureTrack())
     73    , m_mediaSession(PlatformMediaSession::create(*this))
    7374{
    7475    ALWAYS_LOG(LOGIDENTIFIER);
    … …  
    556557{
    557558    m_taskQueue.enqueueTask([this] {
     559        if (m_mediaSession && m_private->type() == RealtimeMediaSource::Type::Audio)
     560            m_mediaSession->canProduceAudioChanged();
     561
    558562        if (auto document = this->document())
    559563            document->updateIsPlayingMedia();
    … …  
    595599}
    596600
     601PlatformMediaSession::MediaType MediaStreamTrack::mediaType() const
     602{
     603    return (isCaptureTrack() && canProduceAudio()) ? PlatformMediaSession::MediaStreamCapturingAudio : PlatformMediaSession::None;
     604}
     605
     606PlatformMediaSession::MediaType MediaStreamTrack::presentationType() const
     607{
     608    return mediaType();
     609}
     610
     611PlatformMediaSession::CharacteristicsFlags MediaStreamTrack::characteristics() const
     612{
     613    if (!m_private->isActive())
     614        return PlatformMediaSession::HasNothing;
     615
     616    return m_private->type() == RealtimeMediaSource::Type::Audio ? PlatformMediaSession::HasAudio : PlatformMediaSession::HasVideo;
     617}
     618
     619void MediaStreamTrack::mayResumePlayback(bool)
     620{
     621    // FIXME: should a media stream track pay attention to this directly, or only when attached to a media element?
     622}
     623
     624void MediaStreamTrack::suspendPlayback()
     625{
     626    // FIXME: should a media stream track pay attention to this directly, or only when attached to a media element?
     627}
     628
     629String MediaStreamTrack::sourceApplicationIdentifier() const
     630{
     631    auto* document = this->document();
     632    if (document && document->frame()) {
     633        if (auto* networkingContext = document->frame()->loader().networkingContext())
     634            return networkingContext->sourceApplicationIdentifier();
     635    }
     636
     637    return emptyString();
     638}
     639
     640bool MediaStreamTrack::canProduceAudio() const
     641{
     642    return m_private->type() == RealtimeMediaSource::Type::Audio && !ended() && !muted();
     643}
     644
     645bool MediaStreamTrack::processingUserGestureForMedia() const
     646{
     647    return document() ? document()->processingUserGestureForMedia() : false;
     648}
     649
    597650#if !RELEASE_LOG_DISABLED
    598651WTFLogChannel& MediaStreamTrack::logChannel() const

  • trunk/Source/WebCore/Modules/mediastream/MediaStreamTrack.h

    r250774 r250853  
    3838#include "MediaStreamTrackPrivate.h"
    3939#include "MediaTrackConstraints.h"
     40#include "PlatformMediaSession.h"
    4041#include <wtf/LoggerHelper.h>
    4142
    … …  
    5556    , public MediaProducer
    5657    , private MediaStreamTrackPrivate::Observer
     58    , private PlatformMediaSessionClient
    5759#if !RELEASE_LOG_DISABLED
    5860    , private LoggerHelper
    … …  
    195197    void trackEnabledChanged(MediaStreamTrackPrivate&) final;
    196198
     199    // PlatformMediaSessionClient
     200    PlatformMediaSession::MediaType mediaType() const final;
     201    PlatformMediaSession::MediaType presentationType() const final;
     202    PlatformMediaSession::CharacteristicsFlags characteristics() const final;
     203    void mayResumePlayback(bool shouldResume) final;
     204    void suspendPlayback() final;
     205    bool canReceiveRemoteControlCommands() const final { return false; }
     206    void didReceiveRemoteControlCommand(PlatformMediaSession::RemoteControlCommandType, const PlatformMediaSession::RemoteCommandArgument*) final { }
     207    bool supportsSeeking() const final { return false; }
     208    bool shouldOverrideBackgroundPlaybackRestriction(PlatformMediaSession::InterruptionType) const final { return false; }
     209    String sourceApplicationIdentifier() const final;
     210    bool canProduceAudio() const final;
     211    Document* hostingDocument() const final { return document(); }
     212    bool processingUserGestureForMedia() const final;
     213    bool shouldOverridePauseDuringRouteChange() const final { return true; }
     214
    197215#if !RELEASE_LOG_DISABLED
    198216    const char* logClassName() const final { return "MediaStreamTrack"; }
    … …  
    209227    bool m_ended { false };
    210228    const bool m_isCaptureTrack { false };
     229    std::unique_ptr<PlatformMediaSession> m_mediaSession;
    211230};
    212231

  • trunk/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamer.cpp

    r250624 r250853  
    329329    m_streamPrivate = &stream;
    330330    static Atomic<uint32_t> pipelineId;
    331     auto pipelineName = makeString("mediastream-",
    332         (stream.hasCaptureVideoSource() || stream.hasCaptureAudioSource()) ? "local" : "remote",
    333         "-", pipelineId.exchangeAdd(1));
     331    auto pipelineName = makeString("mediastream-", pipelineId.exchangeAdd(1));
    334332
    335333    loadFull(String("mediastream://") + stream.id(), pipelineName);

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.cpp

    r250663 r250853  
    203203{
    204204    for (auto& track : m_trackSet.values()) {
    205         if (track->type() == RealtimeMediaSource::Type::Video && track->enabled() && !track->ended())
     205        if (track->type() == RealtimeMediaSource::Type::Video && track->isActive())
    206206            return true;
    207207    }
    … …  
    212212{
    213213    for (auto& track : m_trackSet.values()) {
    214         if (track->type() == RealtimeMediaSource::Type::Audio && track->enabled() && !track->ended())
    215             return true;
    216     }
    217     return false;
    218 }
    219 
    220 bool MediaStreamPrivate::hasCaptureVideoSource() const
    221 {
    222     for (auto& track : m_trackSet.values()) {
    223         if (track->type() == RealtimeMediaSource::Type::Video && track->isCaptureTrack())
    224             return true;
    225     }
    226     return false;
    227 }
    228 
    229 bool MediaStreamPrivate::hasCaptureAudioSource() const
    230 {
    231     for (auto& track : m_trackSet.values()) {
    232         if (track->type() == RealtimeMediaSource::Type::Audio && track->isCaptureTrack() && !track->ended() && !track->muted())
     214        if (track->type() == RealtimeMediaSource::Type::Audio && track->isActive())
    233215            return true;
    234216    }

  • trunk/Source/WebCore/platform/mediastream/MediaStreamPrivate.h

    r249718 r250853  
    102102    bool muted() const;
    103103
    104     bool hasCaptureVideoSource() const;
    105     bool hasCaptureAudioSource() const;
    106 
    107104    FloatSize intrinsicSize() const;
    108105

  • trunk/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.h

    r249134 r250853  
    7575    const String& id() const { return m_id; }
    7676    const String& label() const;
     77
     78    bool isActive() const { return enabled() && !ended() && !muted(); }
    7779
    7880    bool ended() const { return m_isEnded; }
Note: See TracChangeset for help on using the changeset viewer.