Rename pageCache() to PageCache::shared() and return a reference
[WebKit-https.git] / Source / WebCore / Modules / mediasource / MediaSource.h
index 066db6d..bec2c1b 100644 (file)
 
 #if ENABLE(MEDIA_SOURCE)
 
-#include "MediaSourceBase.h"
+#include "ActiveDOMObject.h"
+#include "EventTarget.h"
+#include "GenericEventQueue.h"
+#include "MediaSourcePrivate.h"
+#include "MediaSourcePrivateClient.h"
 #include "ScriptWrappable.h"
 #include "SourceBuffer.h"
 #include "SourceBufferList.h"
+#include "URLRegistry.h"
 #include <wtf/RefCounted.h>
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
-class MediaSource : public MediaSourceBase, public ScriptWrappable {
+class GenericEventQueue;
+
+class MediaSource : public MediaSourcePrivateClient, public ActiveDOMObject, public EventTargetWithInlineData, public ScriptWrappable, public URLRegistrable {
 public:
+    static void setRegistry(URLRegistry*);
+    static MediaSource* lookup(const String& url) { return s_registry ? static_cast<MediaSource*>(s_registry->lookup(url)) : 0; }
+
+    static const AtomicString& openKeyword();
+    static const AtomicString& closedKeyword();
+    static const AtomicString& endedKeyword();
+
     static PassRefPtr<MediaSource> create(ScriptExecutionContext&);
     virtual ~MediaSource();
 
+    void addedToRegistry();
+    void removedFromRegistry();
+    void openIfInEndedState();
+    bool isOpen() const;
+    bool isClosed() const;
+    bool isEnded() const;
+    void sourceBufferDidChangeAcitveState(SourceBuffer*, bool);
+    void streamEndedWithError(const AtomicString& error, ExceptionCode&);
+
+    // MediaSourcePrivateClient
+    virtual void setPrivateAndOpen(Ref<MediaSourcePrivate>&&) override;
+    virtual MediaTime duration() const override;
+    virtual std::unique_ptr<PlatformTimeRanges> buffered() const override;
+    virtual void seekToTime(const MediaTime&) override;
+
+    bool attachToElement(HTMLMediaElement*);
+    void close();
+    void monitorSourceBuffers();
+    bool isSeeking() const { return m_pendingSeekTime.isValid(); }
+    void completeSeek();
+
+    void setDuration(double, ExceptionCode&);
+    void setDurationInternal(const MediaTime&);
+    MediaTime currentTime() const;
+    const AtomicString& readyState() const { return m_readyState; }
+    void setReadyState(const AtomicString&);
+    void endOfStream(ExceptionCode&);
+    void endOfStream(const AtomicString& error, ExceptionCode&);
+
+    HTMLMediaElement* mediaElement() const { return m_mediaElement; }
+
     // MediaSource.idl methods
     SourceBufferList* sourceBuffers() { return m_sourceBuffers.get(); }
     SourceBufferList* activeSourceBuffers() { return m_activeSourceBuffers.get(); }
@@ -53,24 +99,49 @@ public:
     void removeSourceBuffer(SourceBuffer*, ExceptionCode&);
     static bool isTypeSupported(const String& type);
 
+    // ActiveDOMObject interface
+    virtual bool hasPendingActivity() const override;
+    virtual void stop() override;
+
     // EventTarget interface
-    virtual EventTargetInterface eventTargetInterface() const OVERRIDE;
+    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<MediaSourceBase>::ref;
-    using RefCounted<MediaSourceBase>::deref;
+    // URLRegistrable interface
+    virtual URLRegistry& registry() const override;
 
-private:
+    using RefCounted<MediaSourcePrivateClient>::ref;
+    using RefCounted<MediaSourcePrivateClient>::deref;
+
+protected:
     explicit MediaSource(ScriptExecutionContext&);
 
-    // MediaSourceBase interface
-    virtual void onReadyStateChange(const AtomicString&, const AtomicString&) OVERRIDE;
-    virtual Vector<RefPtr<TimeRanges>> activeRanges() const OVERRIDE;
+    virtual const char* activeDOMObjectName() const override { return "MediaSource"; }
+
+    void onReadyStateChange(const AtomicString& oldState, const AtomicString& newState);
+    Vector<PlatformTimeRanges> activeRanges() const;
+
+    RefPtr<SourceBufferPrivate> createSourceBufferPrivate(const ContentType&, ExceptionCode&);
+    void scheduleEvent(const AtomicString& eventName);
+    GenericEventQueue& asyncEventQueue() { return m_asyncEventQueue; }
+
+    void regenerateActiveSourceBuffers();
+
+    static URLRegistry* s_registry;
 
+    RefPtr<MediaSourcePrivate> m_private;
     RefPtr<SourceBufferList> m_sourceBuffers;
     RefPtr<SourceBufferList> m_activeSourceBuffers;
+    HTMLMediaElement* m_mediaElement;
+    MediaTime m_duration;
+    MediaTime m_pendingSeekTime;
+    AtomicString m_readyState;
+    GenericEventQueue m_asyncEventQueue;
 };
 
-} // namespace WebCore
+}
 
 #endif