Changeset 158018 in webkit


Ignore:
Timestamp:
Oct 25, 2013 10:35:20 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Adding platform implementation of MediaStreamTrack
​https://bugs.webkit.org/show_bug.cgi?id=123301

Patch by Thiago de Barros Lacerda <​thiago.lacerda@openbossa.org> on 2013-10-25
Reviewed by Eric Carlson.

No new tests needed.

  • CMakeLists.txt:
  • Modules/mediastream/AudioStreamTrack.cpp:

(WebCore::AudioStreamTrack::create): Create method now receives a MediaStreamTrackPrivate as parameter.

(WebCore::AudioStreamTrack::AudioStreamTrack):

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

(WebCore::MediaStream::MediaStream): Constructor now iterates through a set of MediaStreamTrackPrivate
instances to create each MediaStreamTrack of MediaStream.

(WebCore::MediaStream::addRemoteSource): Calling AudioStreamTrack and VideoStreamTrack with
MediaStreamTrackPrivate as parameter.

  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::MediaStreamTrack): Constructor now receives a MediaStreamTrackPrivate, instead of a
MediaStreamSource.

(WebCore::MediaStreamTrack::~MediaStreamTrack):
(WebCore::MediaStreamTrack::kind): Calling method from MediaStreamTrackPrivate.

(WebCore::MediaStreamTrack::setSource): Ditto.

(WebCore::MediaStreamTrack::id): Ditto.

(WebCore::MediaStreamTrack::label): Ditto.

(WebCore::MediaStreamTrack::enabled): Ditto.

(WebCore::MediaStreamTrack::setEnabled): Ditto.

(WebCore::MediaStreamTrack::muted): Ditto.

(WebCore::MediaStreamTrack::readonly): Ditto.

(WebCore::MediaStreamTrack::remote): Ditto.

(WebCore::MediaStreamTrack::readyState): Ditto.

(WebCore::MediaStreamTrack::states):
(WebCore::MediaStreamTrack::capabilities):
(WebCore::MediaStreamTrack::clone):
(WebCore::MediaStreamTrack::stopProducingData):
(WebCore::MediaStreamTrack::ended): Ditto.

(WebCore::MediaStreamTrack::sourceStateChanged): Ditto.

(WebCore::MediaStreamTrack::sourceMutedChanged): Ditto.

(WebCore::MediaStreamTrack::sourceEnabledChanged): Ditto.
(WebCore::MediaStreamTrack::configureTrackRendering):
(WebCore::MediaStreamTrack::stopped): Ditto.

(WebCore::MediaStreamTrack::trackDidEnd): Setting Ended ready state in MediaStreamTrackPrivate.

(WebCore::MediaStreamTrack::trackReadyStateChanged): Dispatches Live or Ended event.

(WebCore::MediaStreamTrack::trackMutedChanged): Dispatches Muted event.

  • Modules/mediastream/MediaStreamTrack.h: Now inheriting from MediaStreamTrackPrivateClient.

(WebCore::MediaStreamTrack::source): Calling method from MediaStreamTrackPrivate.
(WebCore::MediaStreamTrack::privateTrack):

  • Modules/mediastream/VideoStreamTrack.cpp:

(WebCore::VideoStreamTrack::create):
(WebCore::VideoStreamTrack::VideoStreamTrack): Create method now receives a MediaStreamTrackPrivate as parameter.

  • Modules/mediastream/VideoStreamTrack.h:
  • platform/mediastream/MediaStreamDescriptor.cpp:

(WebCore::MediaStreamDescriptor::MediaStreamDescriptor): Stores the private tracks in a Vector (property of
MediaStreamDescriptor class).

(WebCore::MediaStreamDescriptor::addTrack): Adds a private track to the tracks' Vector

(WebCore::MediaStreamDescriptor::removeTrack): Removes a private track from the tracks' Vector

  • platform/mediastream/MediaStreamDescriptor.h:

(WebCore::MediaStreamDescriptor::numberOfAudioSources): Renamed from numberOfAudioStreams.

(WebCore::MediaStreamDescriptor::audioSources): Renamed from audioStreams.

(WebCore::MediaStreamDescriptor::numberOfVideoSources): Renamed from numberOfVideoStreams.

(WebCore::MediaStreamDescriptor::videoSources): Renamed from videoStreams.

(WebCore::MediaStreamDescriptor::numberOfAudioTracks): Returns the number of audio tracks this MediaStreamDescriptor
has.

(WebCore::MediaStreamDescriptor::audioTracks): Returns a audio track, given an index

(WebCore::MediaStreamDescriptor::numberOfVideoTracks): Returns the number of video tracks this MediaStreamDescriptor
has.
(WebCore::MediaStreamDescriptor::videoTracks): Returns a video track, given an index

  • platform/mediastream/MediaStreamTrackPrivate.cpp: Added.
  • platform/mediastream/MediaStreamTrackPrivate.h: Added.
Location:
trunk/Source/WebCore
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/CMakeLists.txt

    r157950 r158018  
    19891989    platform/mediastream/MediaStreamCenter.cpp
    19901990    platform/mediastream/MediaStreamDescriptor.cpp
     1991    platform/mediastream/MediaStreamTrackPrivate.cpp
    19911992    platform/mediastream/MediaStreamSource.cpp
    19921993    platform/mediastream/RTCIceCandidateDescriptor.cpp

  • trunk/Source/WebCore/ChangeLog

    r158016 r158018  
     12013-10-25  Thiago de Barros Lacerda  <thiago.lacerda@openbossa.org>
     2
     3        Adding platform implementation of MediaStreamTrack
     4        https://bugs.webkit.org/show_bug.cgi?id=123301
     5
     6        Reviewed by Eric Carlson.
     7
     8        No new tests needed.
     9
     10        * CMakeLists.txt:
     11        * Modules/mediastream/AudioStreamTrack.cpp:
     12        (WebCore::AudioStreamTrack::create): Create method now receives a MediaStreamTrackPrivate as parameter.
     13
     14        (WebCore::AudioStreamTrack::AudioStreamTrack):
     15        * Modules/mediastream/AudioStreamTrack.h:
     16        * Modules/mediastream/MediaStream.cpp:
     17        (WebCore::MediaStream::MediaStream): Constructor now iterates through a set of MediaStreamTrackPrivate
     18        instances to create each MediaStreamTrack of MediaStream.
     19
     20        (WebCore::MediaStream::addRemoteSource): Calling AudioStreamTrack and VideoStreamTrack with
     21        MediaStreamTrackPrivate as parameter.
     22
     23        * Modules/mediastream/MediaStreamTrack.cpp:
     24        (WebCore::MediaStreamTrack::MediaStreamTrack): Constructor now receives a MediaStreamTrackPrivate, instead of a
     25        MediaStreamSource.
     26
     27        (WebCore::MediaStreamTrack::~MediaStreamTrack):
     28        (WebCore::MediaStreamTrack::kind): Calling method from MediaStreamTrackPrivate.
     29
     30        (WebCore::MediaStreamTrack::setSource): Ditto.
     31
     32        (WebCore::MediaStreamTrack::id): Ditto.
     33
     34        (WebCore::MediaStreamTrack::label): Ditto.
     35
     36        (WebCore::MediaStreamTrack::enabled): Ditto.
     37
     38        (WebCore::MediaStreamTrack::setEnabled): Ditto.
     39
     40        (WebCore::MediaStreamTrack::muted): Ditto.
     41
     42        (WebCore::MediaStreamTrack::readonly): Ditto.
     43
     44        (WebCore::MediaStreamTrack::remote): Ditto.
     45
     46        (WebCore::MediaStreamTrack::readyState): Ditto.
     47
     48        (WebCore::MediaStreamTrack::states):
     49        (WebCore::MediaStreamTrack::capabilities):
     50        (WebCore::MediaStreamTrack::clone):
     51        (WebCore::MediaStreamTrack::stopProducingData):
     52        (WebCore::MediaStreamTrack::ended): Ditto.
     53
     54        (WebCore::MediaStreamTrack::sourceStateChanged): Ditto.
     55
     56        (WebCore::MediaStreamTrack::sourceMutedChanged): Ditto.
     57
     58        (WebCore::MediaStreamTrack::sourceEnabledChanged): Ditto.
     59        (WebCore::MediaStreamTrack::configureTrackRendering):
     60        (WebCore::MediaStreamTrack::stopped): Ditto.
     61
     62        (WebCore::MediaStreamTrack::trackDidEnd): Setting Ended ready state in MediaStreamTrackPrivate.
     63
     64        (WebCore::MediaStreamTrack::trackReadyStateChanged): Dispatches Live or Ended event.
     65
     66        (WebCore::MediaStreamTrack::trackMutedChanged): Dispatches Muted event.
     67
     68        * Modules/mediastream/MediaStreamTrack.h: Now inheriting from MediaStreamTrackPrivateClient.
     69
     70        (WebCore::MediaStreamTrack::source): Calling method from MediaStreamTrackPrivate.
     71        (WebCore::MediaStreamTrack::privateTrack):
     72        * Modules/mediastream/VideoStreamTrack.cpp:
     73        (WebCore::VideoStreamTrack::create):
     74        (WebCore::VideoStreamTrack::VideoStreamTrack): Create method now receives a MediaStreamTrackPrivate as parameter.
     75        * Modules/mediastream/VideoStreamTrack.h:
     76        * platform/mediastream/MediaStreamDescriptor.cpp:
     77        (WebCore::MediaStreamDescriptor::MediaStreamDescriptor): Stores the private tracks in a Vector (property of
     78        MediaStreamDescriptor class).
     79
     80        (WebCore::MediaStreamDescriptor::addTrack): Adds a private track to the tracks' Vector
     81
     82        (WebCore::MediaStreamDescriptor::removeTrack): Removes a private track from the tracks' Vector
     83
     84        * platform/mediastream/MediaStreamDescriptor.h:
     85        (WebCore::MediaStreamDescriptor::numberOfAudioSources): Renamed from numberOfAudioStreams.
     86
     87        (WebCore::MediaStreamDescriptor::audioSources): Renamed from audioStreams.
     88
     89        (WebCore::MediaStreamDescriptor::numberOfVideoSources): Renamed from numberOfVideoStreams.
     90
     91        (WebCore::MediaStreamDescriptor::videoSources): Renamed from videoStreams.
     92
     93        (WebCore::MediaStreamDescriptor::numberOfAudioTracks): Returns the number of audio tracks this MediaStreamDescriptor
     94        has.
     95
     96        (WebCore::MediaStreamDescriptor::audioTracks): Returns a audio track, given an index
     97
     98        (WebCore::MediaStreamDescriptor::numberOfVideoTracks): Returns the number of video tracks this MediaStreamDescriptor
     99        has.
     100        (WebCore::MediaStreamDescriptor::videoTracks): Returns a video track, given an index
     101        * platform/mediastream/MediaStreamTrackPrivate.cpp: Added.
     102        * platform/mediastream/MediaStreamTrackPrivate.h: Added.
     103
    11042013-10-25  Zoltan Horvath  <zoltan@webkit.org>
    2105

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

    r157068 r158018  
    3838RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, const Dictionary& audioConstraints)
    3939{
    40     return adoptRef(new AudioStreamTrack(context, 0, &audioConstraints));
     40    return adoptRef(new AudioStreamTrack(context, MediaStreamTrackPrivate::create(0), &audioConstraints));
    4141}
    4242
    43 RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, MediaStreamSource* source)
     43RefPtr<AudioStreamTrack> AudioStreamTrack::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack)
    4444{
    45     return adoptRef(new AudioStreamTrack(context, source, 0));
     45    return adoptRef(new AudioStreamTrack(context, privateTrack, 0));
    4646}
    4747
    … …  
    5151}
    5252
    53 AudioStreamTrack::AudioStreamTrack(ScriptExecutionContext* context, MediaStreamSource* source, const Dictionary* audioConstraints)
    54     : MediaStreamTrack(context, source, audioConstraints)
     53AudioStreamTrack::AudioStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary* audioConstraints)
     54    : MediaStreamTrack(context, privateTrack, audioConstraints)
    5555{
    5656}

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

    r157068 r158018  
    4141public:
    4242    static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, const Dictionary&);
    43     static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, MediaStreamSource*);
     43    static RefPtr<AudioStreamTrack> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>);
    4444    static RefPtr<AudioStreamTrack> create(MediaStreamTrack*);
    4545
    … …  
    4949
    5050private:
    51     AudioStreamTrack(ScriptExecutionContext*, MediaStreamSource*, const Dictionary*);
     51    AudioStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
    5252    explicit AudioStreamTrack(MediaStreamTrack*);
    5353};

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

    r157958 r158018  
    120120
    121121    RefPtr<MediaStreamTrack> track;
    122     size_t numberOfAudioTracks = m_descriptor->numberOfAudioStreams();
     122    size_t numberOfAudioTracks = m_descriptor->numberOfAudioTracks();
    123123    m_audioTracks.reserveCapacity(numberOfAudioTracks);
    124124    for (size_t i = 0; i < numberOfAudioTracks; i++) {
    125         track = AudioStreamTrack::create(context, m_descriptor->audioStreams(i));
     125        track = AudioStreamTrack::create(context, m_descriptor->audioTracks(i));
    126126        track->addObserver(this);
    127127        m_audioTracks.append(track.release());
    128128    }
    129129
    130     size_t numberOfVideoTracks = m_descriptor->numberOfVideoStreams();
     130    size_t numberOfVideoTracks = m_descriptor->numberOfVideoTracks();
    131131    m_videoTracks.reserveCapacity(numberOfVideoTracks);
    132132    for (size_t i = 0; i < numberOfVideoTracks; i++) {
    133         track = VideoStreamTrack::create(context, m_descriptor->videoStreams(i));
     133        track = VideoStreamTrack::create(context, m_descriptor->videoTracks(i));
    134134        track->addObserver(this);
    135135        m_videoTracks.append(track.release());
    … …  
    309309    switch (source->type()) {
    310310    case MediaStreamSource::Audio:
    311         track = AudioStreamTrack::create(scriptExecutionContext(), source);
     311        track = AudioStreamTrack::create(scriptExecutionContext(), MediaStreamTrackPrivate::create(source));
    312312        m_audioTracks.append(track);
    313313        break;
    314314    case MediaStreamSource::Video:
    315         track = VideoStreamTrack::create(scriptExecutionContext(), source);
     315        track = VideoStreamTrack::create(scriptExecutionContext(), MediaStreamTrackPrivate::create(source));
    316316        m_videoTracks.append(track);
    317317        break;

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

    r157958 r158018  
    5252namespace WebCore {
    5353
    54 MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext* context, MediaStreamSource* source, const Dictionary*)
     54MediaStreamTrack::MediaStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary*)
    5555    : ActiveDOMObject(context)
    56     , m_source(0)
    57     , m_readyState(MediaStreamSource::New)
    58     , m_stopped(false)
    59     , m_enabled(true)
    60     , m_muted(false)
     56    , m_privateTrack(privateTrack)
    6157    , m_eventDispatchScheduled(false)
    6258{
    6359    suspendIfNeeded();
    64     if (source)
    65         setSource(source);
     60
     61    if (m_privateTrack->source())
     62        m_privateTrack->source()->addObserver(this);
    6663}
    6764
    … …  
    7168    suspendIfNeeded();
    7269
    73     // When the clone() method is invoked, the user agent must run the following steps:
    74     // 1. Let trackClone be a newly constructed MediaStreamTrack object.
    75     // 2. Initialize trackClone's id attribute to a newly generated value.
    76     m_id = createCanonicalUUIDString();
    77 
    78     // 3. Let trackClone inherit this track's underlying source, kind, label and enabled attributes.
    79     setSource(other->source());
    80     m_readyState = m_source ? m_source->readyState() : MediaStreamSource::New;
    81     m_enabled = other->enabled();
    82 
    83     // Note: the "clone" steps don't say anything about 'muted', but 4.3.1 says:
    84     // For a newly created MediaStreamTrack object, the following applies. The track is always enabled
    85     // unless stated otherwise (for examlpe when cloned) and the muted state reflects the state of the
    86     // source at the time the track is created.
    87     m_muted = other->muted();
    88 
    89     m_eventDispatchScheduled =false;
    90     m_stopped = other->stopped();
     70    m_privateTrack = other->privateTrack()->clone();
     71
     72    if (m_privateTrack->source())
     73        m_privateTrack->source()->addObserver(this);
     74
     75    m_eventDispatchScheduled = false;
    9176}
    9277
    9378MediaStreamTrack::~MediaStreamTrack()
    9479{
    95     if (m_source)
    96         m_source->removeObserver(this);
    9780}
    9881
    9982const AtomicString& MediaStreamTrack::kind() const
    10083{
    101     if (!m_source)
    102         return emptyAtom;
    103 
    104     static NeverDestroyed<AtomicString> audioKind("audio", AtomicString::ConstructFromLiteral);
    105     static NeverDestroyed<AtomicString> videoKind("video", AtomicString::ConstructFromLiteral);
    106 
    107     switch (m_source->type()) {
    108     case MediaStreamSource::Audio:
    109         return audioKind;
    110     case MediaStreamSource::Video:
    111         return videoKind;
    112     }
    113 
    114     ASSERT_NOT_REACHED();
    115     return emptyAtom;
    116 }
    117 
    118 void MediaStreamTrack::setSource(MediaStreamSource* source)
    119 {
    120     ASSERT(!source || !m_source);
    121 
    122     if (m_source)
    123         m_source->removeObserver(this);
    124 
    125     if (source) {
    126         source->addObserver(this);
    127         m_muted = source->muted();
    128     }
    129 
    130     m_source = source;
     84    return m_privateTrack->kind();
     85}
     86
     87void MediaStreamTrack::setSource(MediaStreamSource* newSource)
     88{
     89    MediaStreamSource* trackSource = source();
     90
     91    if (trackSource)
     92        trackSource->removeObserver(this);
     93
     94    if (newSource)
     95        newSource->addObserver(this);
     96
     97    m_privateTrack->setSource(newSource);
    13198}
    13299
    133100const String& MediaStreamTrack::id() const
    134101{
    135     if (!m_id.isEmpty())
    136         return m_id;
    137 
    138     // The spec says:
    139     //   Unless a MediaStreamTrack object is created as a part a of special purpose algorithm that
    140     //   specifies how the track id must be initialized, the user agent must generate a globally
    141     //   unique identifier string and initialize the object's id attribute to that string.
    142     if (m_source && m_source->useIDForTrackID())
    143         return m_source->id();
    144 
    145     m_id = createCanonicalUUIDString();
    146     return m_id;
     102    return m_privateTrack->id();
    147103}
    148104
    149105const String& MediaStreamTrack::label() const
    150106{
    151     if (m_source)
    152         return m_source->name();
    153     return emptyString();
     107    return m_privateTrack->label();
    154108}
    155109
    156110bool MediaStreamTrack::enabled() const
    157111{
    158     return m_enabled;
     112    return m_privateTrack->enabled();
    159113}
    160114
    161115void MediaStreamTrack::setEnabled(bool enabled)
    162116{
    163     if (m_stopped)
    164         return;
    165 
    166     // 4.3.3.1
    167     // ... after a MediaStreamTrack is disassociated from its track, its enabled attribute still
    168     // changes value when set; it just doesn't do anything with that new value.
    169     m_enabled = enabled;
    170 
    171     if (!m_source)
    172         return;
    173 
    174     m_source->setEnabled(enabled);
     117    m_privateTrack->setEnabled(enabled);
    175118}
    176119
    177120bool MediaStreamTrack::muted() const
    178121{
    179     if (m_stopped || !m_source)
    180         return false;
    181 
    182     return m_source->muted();
     122    return m_privateTrack->muted();
    183123}
    184124
    185125bool MediaStreamTrack::readonly() const
    186126{
    187     if (m_stopped || !m_source)
    188         return true;
    189 
    190     return m_source->readonly();
     127    return m_privateTrack->readonly();
    191128}
    192129
    193130bool MediaStreamTrack::remote() const
    194131{
    195     if (!m_source)
    196         return false;
    197 
    198     return m_source->remote();
     132    return m_privateTrack->remote();
    199133}
    200134
    … …  
    205139    static NeverDestroyed<AtomicString> newState("new", AtomicString::ConstructFromLiteral);
    206140
    207     if (m_stopped)
    208         return ended;
    209 
    210     switch (m_readyState) {
     141    switch (m_privateTrack->readyState()) {
    211142    case MediaStreamSource::Live:
    212143        return live;
    … …  
    221152}
    222153
    223 void MediaStreamTrack::setState(MediaStreamSource::ReadyState state)
    224 {
    225     if (m_readyState == MediaStreamSource::Ended || m_readyState == state)
    226         return;
    227 
    228     MediaStreamSource::ReadyState oldState = m_readyState;
    229     m_readyState = state;
    230 
    231     if (m_readyState == MediaStreamSource::Live && oldState == MediaStreamSource::New)
    232         scheduleEventDispatch(Event::create(eventNames().startedEvent, false, false));
    233     if (m_readyState == MediaStreamSource::Ended && oldState != MediaStreamSource::Ended)
    234         scheduleEventDispatch(Event::create(eventNames().endedEvent, false, false));
    235 }
    236 
    237154void MediaStreamTrack::getSources(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackSourcesCallback> callback, ExceptionCode& ec)
    238155{
    … …  
    251168RefPtr<MediaSourceStates> MediaStreamTrack::states() const
    252169{
    253     if (!m_source)
     170    if (!source())
    254171        return 0;
    255    
    256     return MediaSourceStates::create(m_source->states());
     172
     173    return MediaSourceStates::create(source()->states());
    257174}
    258175
    259176RefPtr<MediaStreamCapabilities> MediaStreamTrack::capabilities() const
    260177{
    261     if (!m_source)
     178    if (!source())
    262179        return 0;
    263180
    264     return MediaStreamCapabilities::create(m_source->capabilities());
     181    return MediaStreamCapabilities::create(source()->capabilities());
    265182}
    266183
    … …  
    274191RefPtr<MediaStreamTrack> MediaStreamTrack::clone()
    275192{
    276     if (m_source && m_source->type() == MediaStreamSource::Audio)
     193    if (source() && source()->type() == MediaStreamSource::Audio)
    277194        return AudioStreamTrack::create(this);
    278195
    … …  
    282199void MediaStreamTrack::stopProducingData()
    283200{
    284     if (m_stopped || !m_source)
    285         return;
    286 
    287     // Set m_stopped before stopping the source because that may result in a call to sourceChangedState
    288     // and we only want to dispatch the 'ended' event if necessary.
    289     setState(MediaStreamSource::Ended);
    290     m_stopped = true;
    291     m_source->stop();
     201    if (stopped() || !source())
     202        return;
     203
     204    m_privateTrack->setReadyState(MediaStreamSource::Ended);
     205    m_privateTrack->stop();
    292206}
    293207
    294208bool MediaStreamTrack::ended() const
    295209{
    296     return m_stopped || m_readyState == MediaStreamSource::Ended;
     210    return m_privateTrack->ended();
    297211}
    298212
    … …  
    311225void MediaStreamTrack::sourceStateChanged()
    312226{
    313     if (m_stopped)
    314         return;
    315 
    316     setState(m_source->readyState());
     227    if (stopped())
     228        return;
     229
     230    m_privateTrack->setReadyState(source()->readyState());
    317231}
    318232   
    319233void MediaStreamTrack::sourceMutedChanged()
    320234{
    321     if (m_stopped)
    322         return;
    323 
    324     bool muted = m_source->muted();
    325     if (m_muted == muted)
    326         return;
    327 
    328     m_muted = muted;
    329     if (m_muted)
    330         scheduleEventDispatch(Event::create(eventNames().muteEvent, false, false));
    331     else
    332         scheduleEventDispatch(Event::create(eventNames().unmuteEvent, false, false));
     235    if (stopped())
     236        return;
     237
     238    m_privateTrack->setMuted(source()->muted());
    333239
    334240    configureTrackRendering();
    … …  
    337243void MediaStreamTrack::sourceEnabledChanged()
    338244{
    339     if (m_stopped)
    340         return;
    341    
     245    if (stopped())
     246        return;
     247
     248    setEnabled(source()->enabled());
    342249    // media from the source only flows when a MediaStreamTrack object is both unmuted and enabled
    343250    configureTrackRendering();
    … …  
    346253void MediaStreamTrack::configureTrackRendering()
    347254{
    348     if (m_stopped)
     255    if (stopped())
    349256        return;
    350257
    … …  
    355262bool MediaStreamTrack::stopped()
    356263{
    357     return m_stopped;
     264    return m_privateTrack->stopped();
    358265}
    359266
    360267void MediaStreamTrack::trackDidEnd()
    361268{
     269    m_privateTrack->setReadyState(MediaStreamSource::Ended);
     270
    362271    for (Vector<Observer*>::iterator i = m_observers.begin(); i != m_observers.end(); ++i)
    363272        (*i)->trackDidEnd();
    … …  
    399308}
    400309
     310void MediaStreamTrack::trackReadyStateChanged()
     311{
     312    if (m_privateTrack->readyState() == MediaStreamSource::Live)
     313        scheduleEventDispatch(Event::create(eventNames().startedEvent, false, false));
     314    else if (m_privateTrack->readyState() == MediaStreamSource::Ended)
     315        scheduleEventDispatch(Event::create(eventNames().endedEvent, false, false));
     316}
     317
     318void MediaStreamTrack::trackMutedChanged()
     319{
     320    if (muted())
     321        scheduleEventDispatch(Event::create(eventNames().muteEvent, false, false));
     322    else
     323        scheduleEventDispatch(Event::create(eventNames().unmuteEvent, false, false));
     324}
     325
    401326} // namespace WebCore
    402327

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

    r157958 r158018  
    3333#include "EventTarget.h"
    3434#include "MediaStreamSource.h"
     35#include "MediaStreamTrackPrivate.h"
    3536#include "ScriptWrappable.h"
    3637#include <wtf/RefCounted.h>
    … …  
    4849class MediaTrackConstraints;
    4950
    50 class MediaStreamTrack : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamSource::Observer {
     51class MediaStreamTrack : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamSource::Observer, public MediaStreamTrackPrivateClient {
    5152public:
    5253    class Observer {
    … …  
    6970
    7071    const AtomicString& readyState() const;
    71     void setState(MediaStreamSource::ReadyState);
    7272
    7373    static void getSources(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackSourcesCallback>, ExceptionCode&);
    … …  
    8787    DEFINE_ATTRIBUTE_EVENT_LISTENER(overconstrained);
    8888
    89     MediaStreamSource* source() const { return m_source.get(); }
     89    MediaStreamSource* source() const { return m_privateTrack->source(); }
    9090    void setSource(MediaStreamSource*);
    9191
    … …  
    9494    void addObserver(Observer*);
    9595    void removeObserver(Observer*);
     96    MediaStreamTrackPrivate* privateTrack() const { return m_privateTrack.get(); }
     97
     98    // MediaStreamTrackPrivateClient
     99    void trackReadyStateChanged();
     100    void trackMutedChanged();
    96101
    97102    // EventTarget
    … …  
    104109protected:
    105110    explicit MediaStreamTrack(MediaStreamTrack*);
    106     MediaStreamTrack(ScriptExecutionContext*, MediaStreamSource*, const Dictionary*);
     111    MediaStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
    107112
    108113private:
    … …  
    128133    Vector<RefPtr<Event>> m_scheduledEvents;
    129134
    130     RefPtr<MediaStreamSource> m_source;
    131135    RefPtr<MediaConstraintsImpl> m_constraints;
    132     MediaStreamSource::ReadyState m_readyState;
    133     mutable String m_id;
    134136    Mutex m_mutex;
    135137
    136138    Vector<Observer*> m_observers;
    137139
    138     bool m_stopped;
    139     bool m_enabled;
    140     bool m_muted;
     140    RefPtr<MediaStreamTrackPrivate> m_privateTrack;
    141141    bool m_eventDispatchScheduled;
    142142};

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

    r157068 r158018  
    3838RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, const Dictionary& videoConstraints)
    3939{
    40     RefPtr<VideoStreamTrack> track = adoptRef(new VideoStreamTrack(context, 0, &videoConstraints));
    41     return track.release();
     40    return adoptRef(new VideoStreamTrack(context, MediaStreamTrackPrivate::create(0), &videoConstraints));
    4241}
    4342
    44 RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, MediaStreamSource* source)
     43RefPtr<VideoStreamTrack> VideoStreamTrack::create(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack)
    4544{
    46     RefPtr<VideoStreamTrack> track = adoptRef(new VideoStreamTrack(context, source, 0));
    47     return track.release();
     45    return adoptRef(new VideoStreamTrack(context, privateTrack, 0));
    4846}
    4947
    … …  
    5351}
    5452
    55 VideoStreamTrack::VideoStreamTrack(ScriptExecutionContext* context, MediaStreamSource* source, const Dictionary* videoConstraints)
    56     : MediaStreamTrack(context, source, videoConstraints)
     53VideoStreamTrack::VideoStreamTrack(ScriptExecutionContext* context, PassRefPtr<MediaStreamTrackPrivate> privateTrack, const Dictionary* videoConstraints)
     54    : MediaStreamTrack(context, privateTrack, videoConstraints)
    5755{
    5856}

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

    r157068 r158018  
    3737class MediaStreamSource;
    3838class ScriptExecutionContext;
     39class MediaStremTrackDescriptor;
    3940
    4041class VideoStreamTrack FINAL : public MediaStreamTrack {
    4142public:
    4243    static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, const Dictionary&);
    43     static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, MediaStreamSource*);
     44    static RefPtr<VideoStreamTrack> create(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>);
    4445    static RefPtr<VideoStreamTrack> create(MediaStreamTrack*);
    4546
    … …  
    4950
    5051private:
    51     VideoStreamTrack(ScriptExecutionContext*, MediaStreamSource*, const Dictionary*);
     52    VideoStreamTrack(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackPrivate>, const Dictionary*);
    5253    explicit VideoStreamTrack(MediaStreamTrack*);
    5354};

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

    r157958 r158018  
    3838#include "MediaStreamCenter.h"
    3939#include "MediaStreamSource.h"
     40#include "MediaStreamTrackPrivate.h"
    4041#include "UUID.h"
    4142#include <wtf/RefCounted.h>
    … …  
    104105{
    105106    ASSERT(m_id.length());
    106     for (size_t i = 0; i < audioSources.size(); i++)
     107    for (size_t i = 0; i < audioSources.size(); i++) {
    107108        m_audioStreamSources.append(audioSources[i]);
     109        m_audioTrackDescriptors.append(MediaStreamTrackPrivate::create(audioSources[i]));
     110    }
    108111
    109     for (size_t i = 0; i < videoSources.size(); i++)
     112    for (size_t i = 0; i < videoSources.size(); i++) {
    110113        m_videoStreamSources.append(videoSources[i]);
     114        m_videoTrackDescriptors.append(MediaStreamTrackPrivate::create(videoSources[i]));
     115    }
    111116}
    112117
    … …  
    119124}
    120125
     126void MediaStreamDescriptor::addTrack(PassRefPtr<MediaStreamTrackPrivate> track)
     127{
     128    Vector<RefPtr<MediaStreamTrackPrivate>>& tracks = track->type() == MediaStreamSource::Audio ? m_audioTrackDescriptors : m_videoTrackDescriptors;
     129
     130    size_t pos = tracks.find(track);
     131    if (pos != notFound)
     132        return;
     133
     134    tracks.append(track);
     135}
     136
     137void MediaStreamDescriptor::removeTrack(PassRefPtr<MediaStreamTrackPrivate> track)
     138{
     139    Vector<RefPtr<MediaStreamTrackPrivate>>& tracks = track->type() == MediaStreamSource::Audio ? m_audioTrackDescriptors : m_videoTrackDescriptors;
     140
     141    size_t pos = tracks.find(track);
     142    if (pos == notFound)
     143        return;
     144
     145    tracks.remove(pos);
     146}
     147
    121148} // namespace WebCore
    122149

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

    r157958 r158018  
    4242namespace WebCore {
    4343
     44class MediaStreamTrackPrivate;
     45
    4446class MediaStreamDescriptorClient : public MediaStreamTrack::Observer {
    4547public:
    … …  
    6466    String id() const { return m_id; }
    6567
    66     unsigned numberOfAudioStreams() const { return m_audioStreamSources.size(); }
    67     MediaStreamSource* audioStreams(unsigned index) const { return m_audioStreamSources[index].get(); }
     68    unsigned numberOfAudioSources() const { return m_audioStreamSources.size(); }
     69    MediaStreamSource* audioSources(unsigned index) const { return m_audioStreamSources[index].get(); }
    6870
    69     unsigned numberOfVideoStreams() const { return m_videoStreamSources.size(); }
    70     MediaStreamSource* videoStreams(unsigned index) const { return m_videoStreamSources[index].get(); }
     71    unsigned numberOfVideoSources() const { return m_videoStreamSources.size(); }
     72    MediaStreamSource* videoSources(unsigned index) const { return m_videoStreamSources[index].get(); }
     73
     74    unsigned numberOfAudioTracks() const { return m_audioTrackDescriptors.size(); }
     75    MediaStreamTrackPrivate* audioTracks(unsigned index) const { return m_audioTrackDescriptors[index].get(); }
     76
     77    unsigned numberOfVideoTracks() const { return m_videoTrackDescriptors.size(); }
     78    MediaStreamTrackPrivate* videoTracks(unsigned index) const { return m_videoTrackDescriptors[index].get(); }
    7179
    7280    void addSource(PassRefPtr<MediaStreamSource>);
    … …  
    7987    void setEnded();
    8088
     89    void addTrack(PassRefPtr<MediaStreamTrackPrivate>);
     90    void removeTrack(PassRefPtr<MediaStreamTrackPrivate>);
     91
    8192private:
    8293    MediaStreamDescriptor(const String& id, const MediaStreamSourceVector& audioSources, const MediaStreamSourceVector& videoSources, bool ended);
    … …  
    8697    Vector<RefPtr<MediaStreamSource>> m_audioStreamSources;
    8798    Vector<RefPtr<MediaStreamSource>> m_videoStreamSources;
     99
     100    Vector<RefPtr<MediaStreamTrackPrivate>> m_audioTrackDescriptors;
     101    Vector<RefPtr<MediaStreamTrackPrivate>> m_videoTrackDescriptors;
    88102    bool m_ended;
    89103};
Note: See TracChangeset for help on using the changeset viewer.