webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 90 insertions, 160 deletions

diff --git a/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp b/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp
index 6a86181b8..736c6f4c5 100644
--- a/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp
+++ b/Source/WebCore/platform/mediastream/MediaStreamTrackPrivate.cpp
@@ -1,5 +1,6 @@
 /*
  *  Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
+ *  Copyright (C) 2015 Ericsson AB. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -24,263 +25,192 @@
  */
 
 #include "config.h"
+#include "MediaStreamTrackPrivate.h"
 
 #if ENABLE(MEDIA_STREAM)
 
-#include "MediaStreamTrackPrivate.h"
-
-#include "MediaSourceStates.h"
-#include "MediaStreamCapabilities.h"
-#include "NotImplemented.h"
+#include "AudioSourceProvider.h"
+#include "GraphicsContext.h"
+#include "IntRect.h"
 #include "UUID.h"
-#include <wtf/NeverDestroyed.h>
 
 namespace WebCore {
 
-PassRefPtr<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(PassRefPtr<MediaStreamSource> source)
+Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<RealtimeMediaSource>&& source)
 {
-    return adoptRef(new MediaStreamTrackPrivate(source));
+    return adoptRef(*new MediaStreamTrackPrivate(WTFMove(source), createCanonicalUUIDString()));
 }
 
-MediaStreamTrackPrivate::MediaStreamTrackPrivate(const MediaStreamTrackPrivate& other)
-    : RefCounted()
-    , m_client(nullptr)
+Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::create(Ref<RealtimeMediaSource>&& source, String&& id)
 {
-    m_ignoreMutations = true;
-    m_id = createCanonicalUUIDString();
-    setSource(other.source());
-    m_readyState = other.readyState();
-    m_muted = other.muted();
-    m_enabled = other.enabled();
-    m_stopped = other.stopped();
-    m_ignoreMutations = false;
+    return adoptRef(*new MediaStreamTrackPrivate(WTFMove(source), WTFMove(id)));
 }
 
-MediaStreamTrackPrivate::MediaStreamTrackPrivate(PassRefPtr<MediaStreamSource> source)
-    : m_source(nullptr)
-    , m_client(nullptr)
-    , m_readyState(MediaStreamSource::New)
-    , m_muted(false)
-    , m_enabled(true)
-    , m_stopped(false)
+MediaStreamTrackPrivate::MediaStreamTrackPrivate(Ref<RealtimeMediaSource>&& source, String&& id)
+    : m_source(WTFMove(source))
+    , m_id(WTFMove(id))
+    , m_isEnabled(true)
+    , m_isEnded(false)
 {
-    m_ignoreMutations = true;
-    setSource(source);
-    m_ignoreMutations = false;
+    m_source->addObserver(*this);
 }
 
 MediaStreamTrackPrivate::~MediaStreamTrackPrivate()
 {
-    if (m_source)
-        m_source->removeObserver(this);
+    m_source->removeObserver(*this);
 }
 
-void MediaStreamTrackPrivate::setSource(PassRefPtr<MediaStreamSource> source)
+void MediaStreamTrackPrivate::addObserver(MediaStreamTrackPrivate::Observer& observer)
 {
-    if (m_source)
-        m_source->removeObserver(this);
-
-    m_source = source;
-
-    if (!m_source)
-        return;
-
-    setMuted(m_source->muted());
-    setReadyState(m_source->readyState());
-    if (m_source)
-        m_source->addObserver(this);
+    m_observers.append(&observer);
 }
 
-const String& MediaStreamTrackPrivate::id() const
+void MediaStreamTrackPrivate::removeObserver(MediaStreamTrackPrivate::Observer& observer)
 {
-    if (!m_id.isEmpty())
-        return m_id;
-
-    // The spec says:
-    //   Unless a MediaStreamTrack object is created as a part a of special purpose algorithm that
-    //   specifies how the track id must be initialized, the user agent must generate a globally
-    //   unique identifier string and initialize the object's id attribute to that string.
-    if (m_source && m_source->useIDForTrackID())
-        return m_source->id();
-
-    m_id = createCanonicalUUIDString();
-    return m_id;
+    size_t pos = m_observers.find(&observer);
+    if (pos != notFound)
+        m_observers.remove(pos);
 }
 
 const String& MediaStreamTrackPrivate::label() const
 {
-    if (m_source)
-        return m_source->name();
-
-    return emptyString();
-}
-
-bool MediaStreamTrackPrivate::ended() const
-{
-    return m_stopped || (m_source && m_source->readyState() == MediaStreamSource::Ended);
+    return m_source->name();
 }
 
 bool MediaStreamTrackPrivate::muted() const
 {
-    if (m_stopped || !m_source)
-        return false;
-
     return m_source->muted();
 }
 
-void MediaStreamTrackPrivate::setMuted(bool muted)
-{
-    if (m_muted == muted)
-        return;
-
-    m_muted = muted;
-
-    if (!m_client || m_ignoreMutations)
-        return;
-
-    m_client->trackMutedChanged();
-}
-
 bool MediaStreamTrackPrivate::readonly() const
 {
-    if (m_stopped || !m_source)
-        return true;
-
     return m_source->readonly();
 }
 
 bool MediaStreamTrackPrivate::remote() const
 {
-    if (!m_source)
-        return false;
-
     return m_source->remote();
 }
 
 void MediaStreamTrackPrivate::setEnabled(bool enabled)
 {
-    if (m_stopped || m_enabled == enabled)
+    if (m_isEnabled == enabled)
         return;
 
-    // 4.3.3.1
-    // ... after a MediaStreamTrack is disassociated from its track, its enabled attribute still
-    // changes value when set; it just doesn't do anything with that new value.
-    m_enabled = enabled;
-
-    if (m_source)
-        m_source->setEnabled(enabled);
+    // Always update the enabled state regardless of the track being ended.
+    m_isEnabled = enabled;
 
-    if (!m_client || m_ignoreMutations)
-        return;
+    m_source->setEnabled(enabled);
 
-    m_client->trackEnabledChanged();
+    for (auto& observer : m_observers)
+        observer->trackEnabledChanged(*this);
 }
 
-void MediaStreamTrackPrivate::stop(StopBehavior stopSource)
+void MediaStreamTrackPrivate::endTrack()
 {
-    if (m_stopped)
+    if (m_isEnded)
         return;
 
-    if (stopSource == StopTrackAndStopSource && m_source)
-        m_source->stop();
+    // Set m_isEnded to true before telling the source it can stop, so if this is the
+    // only track using the source and it does stop, we will only call each observer's
+    // trackEnded method once.
+    m_isEnded = true;
 
-    setReadyState(MediaStreamSource::Ended);
-    m_stopped = true;
+    m_source->requestStop(this);
+
+    for (auto& observer : m_observers)
+        observer->trackEnded(*this);
 }
 
-MediaStreamSource::ReadyState MediaStreamTrackPrivate::readyState() const
+Ref<MediaStreamTrackPrivate> MediaStreamTrackPrivate::clone()
 {
-    if (m_stopped)
-        return MediaStreamSource::Ended;
+    auto clonedMediaStreamTrackPrivate = create(m_source.copyRef());
+    clonedMediaStreamTrackPrivate->m_isEnabled = this->m_isEnabled;
+    clonedMediaStreamTrackPrivate->m_isEnded = this->m_isEnded;
 
-    return m_readyState;
+    return clonedMediaStreamTrackPrivate;
 }
 
-void MediaStreamTrackPrivate::setReadyState(MediaStreamSource::ReadyState state)
+RealtimeMediaSource::Type MediaStreamTrackPrivate::type() const
 {
-    if (m_readyState == MediaStreamSource::Ended || m_readyState == state)
-        return;
-
-    MediaStreamSource::ReadyState oldState = m_readyState;
-    m_readyState = state;
-
-    if (!m_client || m_ignoreMutations)
-        return;
-
-    if ((m_readyState == MediaStreamSource::Live && oldState == MediaStreamSource::New) || m_readyState == MediaStreamSource::Ended)
-        m_client->trackReadyStateChanged();
+    return m_source->type();
 }
 
-RefPtr<MediaStreamTrackPrivate> MediaStreamTrackPrivate::clone()
+const RealtimeMediaSourceSettings& MediaStreamTrackPrivate::settings() const
 {
-    return adoptRef(new MediaStreamTrackPrivate(*this));
+    return m_source->settings();
 }
 
-    
-RefPtr<MediaConstraints> MediaStreamTrackPrivate::constraints() const
+RefPtr<RealtimeMediaSourceCapabilities> MediaStreamTrackPrivate::capabilities() const
 {
-    return m_constraints;
+    return m_source->capabilities();
 }
 
-const MediaStreamSourceStates& MediaStreamTrackPrivate::states() const
+void MediaStreamTrackPrivate::paintCurrentFrameInContext(GraphicsContext& context, const FloatRect& rect)
 {
-    if (!m_source) {
-        DEFINE_STATIC_LOCAL(const MediaStreamSourceStates, noState, ());
-        return noState;
+    if (context.paintingDisabled() || m_source->type() != RealtimeMediaSource::Type::Video || ended())
+        return;
+
+    if (!m_source->muted())
+        m_source->paintCurrentFrameInContext(context, rect);
+    else {
+        GraphicsContextStateSaver stateSaver(context);
+        context.translate(rect.x(), rect.y() + rect.height());
+        IntRect paintRect(IntPoint(0, 0), IntSize(rect.width(), rect.height()));
+        context.fillRect(paintRect, Color::black);
     }
-    
-    return m_source->states();
 }
 
-MediaStreamSource::Type MediaStreamTrackPrivate::type() const
+void MediaStreamTrackPrivate::applyConstraints(const MediaConstraints& constraints, RealtimeMediaSource::SuccessHandler successHandler, RealtimeMediaSource::FailureHandler failureHandler)
 {
-    if (!m_source)
-        return MediaStreamSource::None;
+    m_source->applyConstraints(constraints, successHandler, failureHandler);
+}
 
-    return m_source->type();
+AudioSourceProvider* MediaStreamTrackPrivate::audioSourceProvider()
+{
+    return m_source->audioSourceProvider();
 }
 
-RefPtr<MediaStreamSourceCapabilities> MediaStreamTrackPrivate::capabilities() const
+void MediaStreamTrackPrivate::sourceStopped()
 {
-    if (!m_source)
-        return 0;
+    if (m_isEnded)
+        return;
 
-    return m_source->capabilities();
+    m_isEnded = true;
+
+    for (auto& observer : m_observers)
+        observer->trackEnded(*this);
 }
 
-void MediaStreamTrackPrivate::applyConstraints(PassRefPtr<MediaConstraints>)
+void MediaStreamTrackPrivate::sourceMutedChanged()
 {
-    // FIXME: apply the new constraints to the track
-    // https://bugs.webkit.org/show_bug.cgi?id=122428
+    for (auto& observer : m_observers)
+        observer->trackMutedChanged(*this);
 }
 
-void MediaStreamTrackPrivate::sourceReadyStateChanged()
+void MediaStreamTrackPrivate::sourceEnabledChanged()
 {
-    if (stopped())
-        return;
-    
-    setReadyState(m_source->readyState());
+    for (auto& observer : m_observers)
+        observer->trackEnabledChanged(*this);
 }
 
-void MediaStreamTrackPrivate::sourceMutedChanged()
+void MediaStreamTrackPrivate::sourceSettingsChanged()
 {
-    if (stopped())
-        return;
-    
-    setMuted(m_source->muted());
+    for (auto& observer : m_observers)
+        observer->trackSettingsChanged(*this);
 }
 
-void MediaStreamTrackPrivate::sourceEnabledChanged()
+bool MediaStreamTrackPrivate::preventSourceFromStopping()
 {
-    if (stopped())
-        return;
-    
-    setEnabled(m_source->enabled());
+    // Do not allow the source to stop if we are still using it.
+    return !m_isEnded;
 }
 
-bool MediaStreamTrackPrivate::observerIsEnabled()
+void MediaStreamTrackPrivate::videoSampleAvailable(MediaSample& mediaSample)
 {
-    return enabled();
+    mediaSample.setTrackID(id());
+    for (auto& observer : m_observers)
+        observer->sampleBufferUpdated(*this, mediaSample);
 }
 
 } // namespace WebCore