1 files changed, 78 insertions, 69 deletions

diff --git a/Source/WebCore/Modules/mediastream/MediaStreamTrack.h b/Source/WebCore/Modules/mediastream/MediaStreamTrack.h
index 64ea32d3f..118728758 100644
--- a/Source/WebCore/Modules/mediastream/MediaStreamTrack.h
+++ b/Source/WebCore/Modules/mediastream/MediaStreamTrack.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-2016 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,31 +25,25 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef MediaStreamTrack_h
-#define MediaStreamTrack_h
+#pragma once
 
 #if ENABLE(MEDIA_STREAM)
 
 #include "ActiveDOMObject.h"
+#include "DoubleRange.h"
 #include "EventTarget.h"
-#include "MediaStreamSource.h"
+#include "JSDOMPromise.h"
+#include "LongRange.h"
 #include "MediaStreamTrackPrivate.h"
-#include "ScriptWrappable.h"
-#include <wtf/RefCounted.h>
-#include <wtf/RefPtr.h>
-#include <wtf/Vector.h>
-#include <wtf/text/WTFString.h>
+#include "MediaTrackConstraints.h"
 
 namespace WebCore {
 
-class Dictionary;
-class MediaConstraintsImpl;
-class MediaSourceStates;
-class MediaStreamTrackSourcesCallback;
-class MediaStreamCapabilities;
-class MediaTrackConstraints;
+class AudioSourceProvider;
 
-class MediaStreamTrack : public RefCounted<MediaStreamTrack>, public ScriptWrappable, public ActiveDOMObject, public EventTargetWithInlineData, public MediaStreamTrackPrivateClient {
+struct MediaTrackConstraints;
+
+class MediaStreamTrack final : public RefCounted<MediaStreamTrack>, public ActiveDOMObject, public EventTargetWithInlineData, private MediaStreamTrackPrivate::Observer {
 public:
     class Observer {
     public:
@@ -57,9 +51,10 @@ public:
         virtual void trackDidEnd() = 0;
     };
 
+    static Ref<MediaStreamTrack> create(ScriptExecutionContext&, Ref<MediaStreamTrackPrivate>&&);
     virtual ~MediaStreamTrack();
 
-    virtual const AtomicString& kind() const = 0;
+    const AtomicString& kind() const;
     const String& id() const;
     const String& label() const;
 
@@ -69,82 +64,96 @@ public:
     bool muted() const;
     bool readonly() const;
     bool remote() const;
-    bool stopped() const;
-
-    const AtomicString& readyState() const;
 
-    static void getSources(ScriptExecutionContext*, PassRefPtr<MediaStreamTrackSourcesCallback>, ExceptionCode&);
+    enum class State { New, Live, Ended };
+    State readyState() const;
 
-    RefPtr<MediaTrackConstraints> constraints() const;
-    RefPtr<MediaSourceStates> states() const;
-    RefPtr<MediaStreamCapabilities> capabilities() const;
-    void applyConstraints(const Dictionary&);
-    void applyConstraints(PassRefPtr<MediaConstraints>);
+    bool ended() const;
 
-    RefPtr<MediaStreamTrack> clone();
+    Ref<MediaStreamTrack> clone();
     void stopProducingData();
 
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(mute);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(unmute);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(started);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
-    DEFINE_ATTRIBUTE_EVENT_LISTENER(overconstrained);
-
-    MediaStreamSource* source() const { return m_privateTrack->source(); }
-    MediaStreamTrackPrivate& privateTrack() { return m_privateTrack.get(); }
-
-    bool ended() const;
+    struct TrackSettings {
+        std::optional<int> width;
+        std::optional<int> height;
+        std::optional<double> aspectRatio;
+        std::optional<double> frameRate;
+        String facingMode;
+        std::optional<double> volume;
+        std::optional<int> sampleRate;
+        std::optional<int> sampleSize;
+        std::optional<bool> echoCancellation;
+        String deviceId;
+        String groupId;
+    };
+    TrackSettings getSettings() const;
+
+    struct TrackCapabilities {
+        std::optional<LongRange> width;
+        std::optional<LongRange> height;
+        std::optional<DoubleRange> aspectRatio;
+        std::optional<DoubleRange> frameRate;
+        std::optional<Vector<String>> facingMode;
+        std::optional<DoubleRange> volume;
+        std::optional<LongRange> sampleRate;
+        std::optional<LongRange> sampleSize;
+        std::optional<Vector<bool>> echoCancellation;
+        String deviceId;
+        String groupId;
+    };
+    TrackCapabilities getCapabilities() const;
 
-    void addObserver(Observer*);
-    void removeObserver(Observer*);
+    const MediaTrackConstraints& getConstraints() const { return m_constraints; }
+    void applyConstraints(const std::optional<MediaTrackConstraints>&, DOMPromise<void>&&);
 
-    // EventTarget
-    virtual EventTargetInterface eventTargetInterface() const override final { return MediaStreamTrackEventTargetInterfaceType; }
-    virtual ScriptExecutionContext* scriptExecutionContext() const override final { return ActiveDOMObject::scriptExecutionContext(); }
+    RealtimeMediaSource& source() { return m_private->source(); }
+    MediaStreamTrackPrivate& privateTrack() { return m_private.get(); }
 
-    using RefCounted<MediaStreamTrack>::ref;
-    using RefCounted<MediaStreamTrack>::deref;
+    AudioSourceProvider* audioSourceProvider();
 
-protected:
-    explicit MediaStreamTrack(MediaStreamTrack&);
-    MediaStreamTrack(ScriptExecutionContext&, MediaStreamTrackPrivate&, const Dictionary*);
+    void addObserver(Observer&);
+    void removeObserver(Observer&);
 
-    void setSource(PassRefPtr<MediaStreamSource>);
+    using RefCounted::ref;
+    using RefCounted::deref;
 
 private:
+    MediaStreamTrack(ScriptExecutionContext&, Ref<MediaStreamTrackPrivate>&&);
+    explicit MediaStreamTrack(MediaStreamTrack&);
 
     void configureTrackRendering();
-    void trackDidEnd();
-    void scheduleEventDispatch(PassRefPtr<Event>);
-    void dispatchQueuedEvents();
 
-    // ActiveDOMObject
-    virtual void stop() override final;
+    // ActiveDOMObject API.
+    void stop() final;
+    const char* activeDOMObjectName() const final;
+    bool canSuspendForDocumentSuspension() const final;
 
     // EventTarget
-    virtual void refEventTarget() override final { ref(); }
-    virtual void derefEventTarget() override final { deref(); }
+    void refEventTarget() final { ref(); }
+    void derefEventTarget() final { deref(); }
+    EventTargetInterface eventTargetInterface() const final { return MediaStreamTrackEventTargetInterfaceType; }
+    ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
 
-    // MediaStreamTrackPrivateClient
-    void trackReadyStateChanged();
-    void trackMutedChanged();
-    void trackEnabledChanged();
+    // MediaStreamTrackPrivate::Observer
+    void trackEnded(MediaStreamTrackPrivate&) override;
+    void trackMutedChanged(MediaStreamTrackPrivate&) override;
+    void trackSettingsChanged(MediaStreamTrackPrivate&) override;
+    void trackEnabledChanged(MediaStreamTrackPrivate&) override;
 
-    Vector<RefPtr<Event>> m_scheduledEvents;
-
-    RefPtr<MediaConstraintsImpl> m_constraints;
-    Mutex m_mutex;
+    WeakPtr<MediaStreamTrack> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
 
     Vector<Observer*> m_observers;
+    Ref<MediaStreamTrackPrivate> m_private;
 
-    Ref<MediaStreamTrackPrivate> m_privateTrack;
-    bool m_eventDispatchScheduled;
+    MediaTrackConstraints m_constraints;
+    std::optional<DOMPromise<void>> m_promise;
+    WeakPtrFactory<MediaStreamTrack> m_weakPtrFactory;
 
-    bool m_stoppingTrack;
+    bool m_ended { false };
 };
 
+typedef Vector<RefPtr<MediaStreamTrack>> MediaStreamTrackVector;
+
 } // namespace WebCore
 
 #endif // ENABLE(MEDIA_STREAM)
-
-#endif // MediaStreamTrack_h