1 files changed, 74 insertions, 50 deletions

diff --git a/Source/WebCore/Modules/mediastream/MediaStream.h b/Source/WebCore/Modules/mediastream/MediaStream.h
index 1791c2490..816d706a3 100644
--- a/Source/WebCore/Modules/mediastream/MediaStream.h
+++ b/Source/WebCore/Modules/mediastream/MediaStream.h
@@ -1,7 +1,7 @@
 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
- * Copyright (C) 2011 Ericsson AB. All rights reserved.
- * Copyright (C) 2013 Apple Inc. All rights reserved.
+ * Copyright (C) 2011, 2015 Ericsson AB. All rights reserved.
+ * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies).
  *
  * Redistribution and use in source and binary forms, with or without
@@ -25,116 +25,140 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef MediaStream_h
-#define MediaStream_h
+#pragma once
 
 #if ENABLE(MEDIA_STREAM)
 
 #include "ContextDestructionObserver.h"
 #include "EventTarget.h"
 #include "ExceptionBase.h"
+#include "MediaCanStartListener.h"
+#include "MediaProducer.h"
 #include "MediaStreamPrivate.h"
 #include "MediaStreamTrack.h"
 #include "ScriptWrappable.h"
 #include "Timer.h"
 #include "URLRegistry.h"
+#include <wtf/HashMap.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 
 namespace WebCore {
 
-class MediaStreamCenter;
-
-class MediaStream final : public RefCounted<MediaStream>, public URLRegistrable, public ScriptWrappable, public MediaStreamPrivateClient, public EventTargetWithInlineData, public ContextDestructionObserver {
+class Document;
+
+class MediaStream final
+    : public URLRegistrable
+    , public EventTargetWithInlineData
+    , public ContextDestructionObserver
+    , public MediaStreamTrack::Observer
+    , public MediaStreamPrivate::Observer
+    , private MediaProducer
+    , private MediaCanStartListener
+    , public RefCounted<MediaStream> {
 public:
     class Observer {
     public:
+        virtual ~Observer() { }
         virtual void didAddOrRemoveTrack() = 0;
     };
 
-    static PassRefPtr<MediaStream> create(ScriptExecutionContext&);
-    static PassRefPtr<MediaStream> create(ScriptExecutionContext&, PassRefPtr<MediaStream>);
-    static PassRefPtr<MediaStream> create(ScriptExecutionContext&, const Vector<RefPtr<MediaStreamTrack>>&);
-    static PassRefPtr<MediaStream> create(ScriptExecutionContext&, PassRefPtr<MediaStreamPrivate>);
+    static Ref<MediaStream> create(ScriptExecutionContext&);
+    static Ref<MediaStream> create(ScriptExecutionContext&, MediaStream&);
+    static Ref<MediaStream> create(ScriptExecutionContext&, const MediaStreamTrackVector&);
+    static Ref<MediaStream> create(ScriptExecutionContext&, RefPtr<MediaStreamPrivate>&&);
     virtual ~MediaStream();
 
     String id() const { return m_private->id(); }
 
-    void addTrack(PassRefPtr<MediaStreamTrack>, ExceptionCode&);
-    void removeTrack(PassRefPtr<MediaStreamTrack>, ExceptionCode&);
+    void addTrack(MediaStreamTrack&);
+    void removeTrack(MediaStreamTrack&);
     MediaStreamTrack* getTrackById(String);
 
-    Vector<RefPtr<MediaStreamTrack>> getAudioTracks() const { return m_audioTracks; }
-    Vector<RefPtr<MediaStreamTrack>> getVideoTracks() const { return m_videoTracks; }
+    MediaStreamTrackVector getAudioTracks() const;
+    MediaStreamTrackVector getVideoTracks() const;
+    MediaStreamTrackVector getTracks() const;
 
-    bool ended() const;
-    void setEnded();
-    PassRefPtr<MediaStream> clone();
+    RefPtr<MediaStream> clone();
 
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(addtrack);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(removetrack);
+    bool active() const { return m_isActive; }
+    bool muted() const { return m_isMuted; }
 
     MediaStreamPrivate* privateStream() const { return m_private.get(); }
 
+    void startProducingData();
+    void stopProducingData();
+
     // EventTarget
-    virtual EventTargetInterface eventTargetInterface() const final { return MediaStreamEventTargetInterfaceType; }
-    virtual ScriptExecutionContext* scriptExecutionContext() const final { return ContextDestructionObserver::scriptExecutionContext(); }
+    EventTargetInterface eventTargetInterface() const final { return MediaStreamEventTargetInterfaceType; }
+    ScriptExecutionContext* scriptExecutionContext() const final { return ContextDestructionObserver::scriptExecutionContext(); }
 
     using RefCounted<MediaStream>::ref;
     using RefCounted<MediaStream>::deref;
 
     // URLRegistrable
-    virtual URLRegistry& registry() const override;
+    URLRegistry& registry() const override;
 
     void addObserver(Observer*);
     void removeObserver(Observer*);
 
 protected:
-    MediaStream(ScriptExecutionContext&, PassRefPtr<MediaStreamPrivate>);
+    MediaStream(ScriptExecutionContext&, const MediaStreamTrackVector&);
+    MediaStream(ScriptExecutionContext&, RefPtr<MediaStreamPrivate>&&);
 
     // ContextDestructionObserver
-    virtual void contextDestroyed() override final;
+    void contextDestroyed() final;
 
 private:
+    enum class StreamModifier { DomAPI, Platform };
+
     // EventTarget
-    virtual void refEventTarget() override final { ref(); }
-    virtual void derefEventTarget() override final { deref(); }
+    void refEventTarget() final { ref(); }
+    void derefEventTarget() final { deref(); }
+
+    // MediaStreamTrack::Observer
+    void trackDidEnd() final;
+
+    // MediaStreamPrivate::Observer
+    void activeStatusChanged() final;
+    void didAddTrack(MediaStreamTrackPrivate&) final;
+    void didRemoveTrack(MediaStreamTrackPrivate&) final;
+    void characteristicsChanged() final;
 
-    // MediaStreamPrivateClient
-    virtual void trackDidEnd() override final;
-    virtual void streamDidEnd() override final;
-    virtual void addRemoteSource(MediaStreamSource*) override final;
-    virtual void removeRemoteSource(MediaStreamSource*) override final;
-    virtual void addRemoteTrack(MediaStreamTrackPrivate*) override final;
-    virtual void removeRemoteTrack(MediaStreamTrackPrivate*) override final;
+    // MediaProducer
+    void pageMutedStateDidChange() final;
+    MediaProducer::MediaStateFlags mediaState() const final;
 
-    bool removeTrack(PassRefPtr<MediaStreamTrack>);
-    bool addTrack(PassRefPtr<MediaStreamTrack>);
+    // MediaCanStartListener
+    void mediaCanStart(Document&) final;
 
-    bool haveTrackWithSource(PassRefPtr<MediaStreamSource>);
+    bool internalAddTrack(Ref<MediaStreamTrack>&&, StreamModifier);
+    bool internalRemoveTrack(const String&, StreamModifier);
 
-    void scheduleDispatchEvent(PassRefPtr<Event>);
-    void scheduledEventTimerFired(Timer<MediaStream>*);
+    void scheduleActiveStateChange();
+    void activityEventTimerFired();
+    void setIsActive(bool);
+    void statusDidChange();
 
-    void cloneMediaStreamTrackVector(Vector<RefPtr<MediaStreamTrack>>&, const Vector<RefPtr<MediaStreamTrack>>&);
+    Document* document() const;
 
-    Vector<RefPtr<MediaStreamTrack>>* trackVectorForType(MediaStreamSource::Type);
+    MediaStreamTrackVector trackVectorForType(RealtimeMediaSource::Type) const;
 
     RefPtr<MediaStreamPrivate> m_private;
-    Vector<RefPtr<MediaStreamTrack>> m_audioTracks;
-    Vector<RefPtr<MediaStreamTrack>> m_videoTracks;
 
-    Timer<MediaStream> m_scheduledEventTimer;
-    Vector<RefPtr<Event>> m_scheduledEvents;
+    HashMap<String, RefPtr<MediaStreamTrack>> m_trackSet;
+
+    Timer m_activityEventTimer;
+    Vector<Ref<Event>> m_scheduledActivityEvents;
 
     Vector<Observer*> m_observers;
-};
 
-typedef Vector<RefPtr<MediaStream>> MediaStreamVector;
+    bool m_isActive { false };
+    bool m_isMuted { true };
+    bool m_externallyMuted { false };
+    bool m_isWaitingUntilMediaCanStart { false };
+};
 
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)
-
-#endif // MediaStream_h