#ifndef ReadableStream_h
#define ReadableStream_h
#if ENABLE(STREAMS_API)
#include "ActiveDOMObject.h"
#include "JSDOMPromise.h"
#include "ScriptWrappable.h"
#include <functional>
#include <wtf/Deque.h>
#include <wtf/Optional.h>
#include <wtf/Ref.h>
#include <wtf/RefCounted.h>
namespace JSC {
class JSValue;
}
namespace WebCore {
class Dictionary;
class ReadableStreamReader;
class ScriptExecutionContext;
typedef int ExceptionCode;
class ReadableStream : public ActiveDOMObject, public ScriptWrappable, public RefCounted<ReadableStream> {
public:
enum class State {
Readable,
Closed,
Errored
};
static RefPtr<ReadableStream> create(JSC::ExecState&, JSC::JSValue, const Dictionary&);
virtual ~ReadableStream();
ReadableStreamReader* getReader(ExceptionCode&);
const ReadableStreamReader* reader() const { return m_reader.get(); }
bool locked() const { return !!m_reader; }
void releaseReader();
bool hasReadPendingRequests() { return !m_readRequests.isEmpty(); }
bool isErrored() const { return m_state == State::Errored; }
bool isReadable() const { return m_state == State::Readable; }
bool isCloseRequested() const { return m_closeRequested; }
virtual JSC::JSValue error() = 0;
void start();
void changeStateToClosed();
void changeStateToErrored();
void finishPulling();
void notifyCancelSucceeded();
void notifyCancelFailed();
typedef DOMPromise<std::nullptr_t, JSC::JSValue> CancelPromise;
void cancel(JSC::JSValue, CancelPromise&&, ExceptionCode&);
void cancelNoCheck(JSC::JSValue, CancelPromise&&);
typedef DOMPromise<std::nullptr_t, JSC::JSValue> ClosedPromise;
void closed(ClosedPromise&&);
typedef DOMPromiseIteratorWithCallback<JSC::JSValue, JSC::JSValue> ReadPromise;
void read(ReadPromise&&);
protected:
explicit ReadableStream(ScriptExecutionContext&);
bool resolveReadCallback(JSC::JSValue);
void pull();
private:
const char* activeDOMObjectName() const override;
bool canSuspendForPageCache() const override;
void clearCallbacks();
void close();
virtual bool hasEnoughValues() const = 0;
virtual bool hasValue() const = 0;
virtual JSC::JSValue read() = 0;
virtual bool doPull() = 0;
virtual bool doCancel(JSC::JSValue) = 0;
std::unique_ptr<ReadableStreamReader> m_reader;
Vector<std::unique_ptr<ReadableStreamReader>> m_releasedReaders;
Optional<CancelPromise> m_cancelPromise;
Optional<ClosedPromise> m_closedPromise;
Deque<ReadPromise> m_readRequests;
bool m_isStarted { false };
bool m_isPulling { false };
bool m_shouldPullAgain { false };
bool m_closeRequested { false };
State m_state { State::Readable };
};
}
#endif
#endif // ReadableStream_h