#pragma once
#if ENABLE(MEDIA_STREAM)
#include "ActiveDOMObject.h"
#include "EventTarget.h"
#include "ExceptionOr.h"
#include "MediaRecorderPrivateOptions.h"
#include "MediaStream.h"
#include "MediaStreamTrackPrivate.h"
#include "Timer.h"
#include <wtf/UniqueRef.h>
namespace WebCore {
class Blob;
class Document;
class MediaRecorderPrivate;
class MediaRecorder final
: public ActiveDOMObject
, public RefCounted<MediaRecorder>
, public EventTargetWithInlineData
, private MediaStreamPrivate::Observer
, private MediaStreamTrackPrivate::Observer {
WTF_MAKE_ISO_ALLOCATED(MediaRecorder);
public:
enum class RecordingState { Inactive, Recording, Paused };
~MediaRecorder();
static bool isTypeSupported(Document&, const String&);
using Options = MediaRecorderPrivateOptions;
static ExceptionOr<Ref<MediaRecorder>> create(Document&, Ref<MediaStream>&&, Options&& = { });
using CreatorFunction = ExceptionOr<std::unique_ptr<MediaRecorderPrivate>> (*)(MediaStreamPrivate&, const Options&);
WEBCORE_EXPORT static void setCustomPrivateRecorderCreator(CreatorFunction);
RecordingState state() const { return m_state; }
const String& mimeType() const { return m_options.mimeType; }
using RefCounted::ref;
using RefCounted::deref;
ExceptionOr<void> startRecording(Optional<unsigned>);
ExceptionOr<void> stopRecording();
ExceptionOr<void> requestData();
MediaStream& stream() { return m_stream.get(); }
private:
MediaRecorder(Document&, Ref<MediaStream>&&, Options&&);
static ExceptionOr<std::unique_ptr<MediaRecorderPrivate>> createMediaRecorderPrivate(Document&, MediaStreamPrivate&, const Options&);
Document* document() const;
void refEventTarget() final { ref(); }
void derefEventTarget() final { deref(); }
EventTargetInterface eventTargetInterface() const final { return MediaRecorderEventTargetInterfaceType; }
ScriptExecutionContext* scriptExecutionContext() const final { return ActiveDOMObject::scriptExecutionContext(); }
void suspend(ReasonForSuspension) final;
void stop() final;
const char* activeDOMObjectName() const final;
bool virtualHasPendingActivity() const final;
void stopRecordingInternal();
void dispatchError(Exception&&);
enum class TakePrivateRecorder { No, Yes };
using FetchDataCallback = Function<void(RefPtr<SharedBuffer>&&, const String& mimeType)>;
void fetchData(FetchDataCallback&&, TakePrivateRecorder);
void didAddTrack(MediaStreamTrackPrivate&) final { handleTrackChange(); }
void didRemoveTrack(MediaStreamTrackPrivate&) final { handleTrackChange(); }
void handleTrackChange();
void trackEnded(MediaStreamTrackPrivate&) final;
void trackMutedChanged(MediaStreamTrackPrivate&) final;
void trackEnabledChanged(MediaStreamTrackPrivate&) final;
void trackSettingsChanged(MediaStreamTrackPrivate&) final { };
static CreatorFunction m_customCreator;
Options m_options;
Ref<MediaStream> m_stream;
std::unique_ptr<MediaRecorderPrivate> m_private;
RecordingState m_state { RecordingState::Inactive };
Vector<Ref<MediaStreamTrackPrivate>> m_tracks;
Optional<unsigned> m_timeSlice;
Timer m_timeSliceTimer;
bool m_isActive { true };
bool m_isFetchingData { false };
Deque<FetchDataCallback> m_pendingFetchDataTasks;
};
}
#endif // ENABLE(MEDIA_STREAM)