webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 79 insertions, 55 deletions

diff --git a/Source/WebCore/Modules/mediasource/MediaSource.h b/Source/WebCore/Modules/mediasource/MediaSource.h
index 131b549d0..549319f12 100644
--- a/Source/WebCore/Modules/mediasource/MediaSource.h
+++ b/Source/WebCore/Modules/mediasource/MediaSource.h
@@ -28,99 +28,125 @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef MediaSource_h
-#define MediaSource_h
+#pragma once
 
 #if ENABLE(MEDIA_SOURCE)
 
 #include "ActiveDOMObject.h"
 #include "EventTarget.h"
+#include "ExceptionOr.h"
 #include "GenericEventQueue.h"
-#include "HTMLMediaSource.h"
-#include "MediaSourcePrivate.h"
-#include "ScriptWrappable.h"
-#include "SourceBuffer.h"
-#include "SourceBufferList.h"
+#include "MediaSourcePrivateClient.h"
 #include "URLRegistry.h"
-#include <wtf/PassOwnPtr.h>
-#include <wtf/RefCounted.h>
-#include <wtf/Vector.h>
 
 namespace WebCore {
 
-class GenericEventQueue;
+class ContentType;
+class HTMLMediaElement;
+class SourceBuffer;
+class SourceBufferList;
+class SourceBufferPrivate;
+class TimeRanges;
 
-class MediaSource : public RefCounted<MediaSource>, public HTMLMediaSource, public ActiveDOMObject, public EventTargetWithInlineData, public ScriptWrappable {
+class MediaSource final : public MediaSourcePrivateClient, public ActiveDOMObject, public EventTargetWithInlineData, public URLRegistrable {
 public:
-    static const AtomicString& openKeyword();
-    static const AtomicString& closedKeyword();
-    static const AtomicString& endedKeyword();
+    static void setRegistry(URLRegistry*);
+    static MediaSource* lookup(const String& url) { return s_registry ? static_cast<MediaSource*>(s_registry->lookup(url)) : nullptr; }
 
-    static PassRefPtr<MediaSource> create(ScriptExecutionContext&);
+    static Ref<MediaSource> create(ScriptExecutionContext&);
     virtual ~MediaSource();
 
     void addedToRegistry();
     void removedFromRegistry();
     void openIfInEndedState();
     bool isOpen() const;
-    void sourceBufferDidChangeAcitveState(SourceBuffer*, bool);
-    void streamEndedWithError(const AtomicString& error, ExceptionCode&);
-
-    // HTMLMediaSource
-    virtual bool attachToElement(HTMLMediaElement*) override;
-    virtual void setPrivateAndOpen(PassRef<MediaSourcePrivate>) override;
-    virtual void close() override;
-    virtual bool isClosed() const override;
-    virtual double duration() const override;
-    virtual PassRefPtr<TimeRanges> buffered() const override;
-    virtual void refHTMLMediaSource() override { ref(); }
-    virtual void derefHTMLMediaSource() override { deref(); }
-    virtual void monitorSourceBuffers() override;
-
-    void setDuration(double, ExceptionCode&);
+    bool isClosed() const;
+    bool isEnded() const;
+    void sourceBufferDidChangeActiveState(SourceBuffer&, bool);
+
+    enum class EndOfStreamError { Network, Decode };
+    void streamEndedWithError(std::optional<EndOfStreamError>);
+
+    MediaTime duration() const final;
+    void durationChanged(const MediaTime&) final;
+    std::unique_ptr<PlatformTimeRanges> buffered() const final;
+
+    bool attachToElement(HTMLMediaElement&);
+    void detachFromElement(HTMLMediaElement&);
+    void monitorSourceBuffers() override;
+    bool isSeeking() const { return m_pendingSeekTime.isValid(); }
+    Ref<TimeRanges> seekable();
+    ExceptionOr<void> setLiveSeekableRange(double start, double end);
+    ExceptionOr<void> clearLiveSeekableRange();
+
+    ExceptionOr<void> setDuration(double);
+    ExceptionOr<void> setDurationInternal(const MediaTime&);
+    MediaTime currentTime() const;
     const AtomicString& readyState() const { return m_readyState; }
-    void setReadyState(const AtomicString&);
-    void endOfStream(const AtomicString& error, ExceptionCode&);
+    ExceptionOr<void> endOfStream(std::optional<EndOfStreamError>);
 
     HTMLMediaElement* mediaElement() const { return m_mediaElement; }
 
-    // MediaSource.idl methods
     SourceBufferList* sourceBuffers() { return m_sourceBuffers.get(); }
     SourceBufferList* activeSourceBuffers() { return m_activeSourceBuffers.get(); }
-    SourceBuffer* addSourceBuffer(const String& type, ExceptionCode&);
-    void removeSourceBuffer(SourceBuffer*, ExceptionCode&);
+    ExceptionOr<SourceBuffer&> addSourceBuffer(const String& type);
+    ExceptionOr<void> removeSourceBuffer(SourceBuffer&);
     static bool isTypeSupported(const String& type);
 
-    // ActiveDOMObject interface
-    virtual bool hasPendingActivity() const override;
-    virtual void stop() override;
+    ScriptExecutionContext* scriptExecutionContext() const final;
 
-    // EventTarget interface
-    virtual ScriptExecutionContext* scriptExecutionContext() const override final;
-    virtual void refEventTarget() override final { ref(); }
-    virtual void derefEventTarget() override final { deref(); }
-    virtual EventTargetInterface eventTargetInterface() const override;
+    using RefCounted::ref;
+    using RefCounted::deref;
 
-    // URLRegistrable interface
-    virtual URLRegistry& registry() const override;
+    bool hasPendingActivity() const final;
 
-    using RefCounted<MediaSource>::ref;
-    using RefCounted<MediaSource>::deref;
+    static const MediaTime& currentTimeFudgeFactor();
 
-protected:
+private:
     explicit MediaSource(ScriptExecutionContext&);
 
+    void stop() final;
+    bool canSuspendForDocumentSuspension() const final;
+    const char* activeDOMObjectName() const final;
+
+    void setPrivateAndOpen(Ref<MediaSourcePrivate>&&) final;
+    void seekToTime(const MediaTime&) final;
+
+    void refEventTarget() final { ref(); }
+    void derefEventTarget() final { deref(); }
+    EventTargetInterface eventTargetInterface() const final;
+
+    URLRegistry& registry() const final;
+
+    static const AtomicString& openKeyword();
+    static const AtomicString& closedKeyword();
+    static const AtomicString& endedKeyword();
+    void setReadyState(const AtomicString&);
     void onReadyStateChange(const AtomicString& oldState, const AtomicString& newState);
-    Vector<RefPtr<TimeRanges>> activeRanges() const;
 
-    RefPtr<SourceBufferPrivate> createSourceBufferPrivate(const ContentType&, ExceptionCode&);
+    Vector<PlatformTimeRanges> activeRanges() const;
+
+    ExceptionOr<Ref<SourceBufferPrivate>> createSourceBufferPrivate(const ContentType&);
     void scheduleEvent(const AtomicString& eventName);
-    GenericEventQueue& asyncEventQueue() { return m_asyncEventQueue; }
+
+    bool hasBufferedTime(const MediaTime&);
+    bool hasCurrentTime();
+    bool hasFutureTime();
+
+    void regenerateActiveSourceBuffers();
+
+    void completeSeek();
+
+    static URLRegistry* s_registry;
 
     RefPtr<MediaSourcePrivate> m_private;
     RefPtr<SourceBufferList> m_sourceBuffers;
     RefPtr<SourceBufferList> m_activeSourceBuffers;
-    HTMLMediaElement* m_mediaElement;
+    mutable std::unique_ptr<PlatformTimeRanges> m_buffered;
+    std::unique_ptr<PlatformTimeRanges> m_liveSeekable;
+    HTMLMediaElement* m_mediaElement { nullptr };
+    MediaTime m_duration;
+    MediaTime m_pendingSeekTime;
     AtomicString m_readyState;
     GenericEventQueue m_asyncEventQueue;
 };
@@ -128,5 +154,3 @@ protected:
 }
 
 #endif
-
-#endif