#pragma once
#if ENABLE(MEDIA_SOURCE)
#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 GenericEventQueue;
class MediaSource : public MediaSourcePrivateClient, public ActiveDOMObject, public EventTargetWithInlineData, 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 Ref<MediaSource> create(ScriptExecutionContext&);
virtual ~MediaSource();
void addedToRegistry();
void removedFromRegistry();
void openIfInEndedState();
bool isOpen() const;
bool isClosed() const;
bool isEnded() const;
void sourceBufferDidChangeActiveState(SourceBuffer&, bool);
enum class EndOfStreamError { Network, Decode };
void streamEndedWithError(Optional<EndOfStreamError>);
void setPrivateAndOpen(Ref<MediaSourcePrivate>&&) override;
MediaTime duration() const override;
std::unique_ptr<PlatformTimeRanges> buffered() const override;
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(Optional<EndOfStreamError>, ExceptionCode&);
HTMLMediaElement* mediaElement() const { return m_mediaElement; }
SourceBufferList* sourceBuffers() { return m_sourceBuffers.get(); }
SourceBufferList* activeSourceBuffers() { return m_activeSourceBuffers.get(); }
SourceBuffer* addSourceBuffer(const String& type, ExceptionCode&);
void removeSourceBuffer(SourceBuffer&, ExceptionCode&);
static bool isTypeSupported(const String& type);
ScriptExecutionContext* scriptExecutionContext() const final;
void refEventTarget() final { ref(); }
void derefEventTarget() final { deref(); }
EventTargetInterface eventTargetInterface() const override;
URLRegistry& registry() const override;
using RefCounted<MediaSourcePrivateClient>::ref;
using RefCounted<MediaSourcePrivateClient>::deref;
bool hasPendingActivity() const override;
protected:
explicit MediaSource(ScriptExecutionContext&);
void stop() override;
bool canSuspendForDocumentSuspension() const override;
const char* activeDOMObjectName() const override;
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;
mutable std::unique_ptr<PlatformTimeRanges> m_buffered;
HTMLMediaElement* m_mediaElement;
MediaTime m_duration;
MediaTime m_pendingSeekTime;
AtomicString m_readyState;
GenericEventQueue m_asyncEventQueue;
};
}
#endif