#pragma once
#if ENABLE(SERVICE_WORKER)
#include "ExtendableEvent.h"
#include "FetchRequest.h"
#include <wtf/CompletionHandler.h>
#include <wtf/Expected.h>
namespace WebCore {
class FetchResponse;
class ResourceError;
class FetchEvent final : public ExtendableEvent {
WTF_MAKE_ISO_ALLOCATED(FetchEvent);
public:
struct Init : ExtendableEventInit {
RefPtr<FetchRequest> request;
String clientId;
String reservedClientId;
String targetClientId;
};
WEBCORE_EXPORT static Ref<FetchEvent> createForTesting(ScriptExecutionContext&);
static Ref<FetchEvent> create(const AtomString& type, Init&& initializer, IsTrusted isTrusted = IsTrusted::No)
{
return adoptRef(*new FetchEvent(type, WTFMove(initializer), isTrusted));
}
~FetchEvent();
EventInterface eventInterface() const final { return FetchEventInterfaceType; }
ExceptionOr<void> respondWith(Ref<DOMPromise>&&);
using ResponseCallback = CompletionHandler<void(Expected<Ref<FetchResponse>, ResourceError>&&)>;
WEBCORE_EXPORT void onResponse(ResponseCallback&&);
FetchRequest& request() { return m_request.get(); }
const String& clientId() const { return m_clientId; }
const String& reservedClientId() const { return m_reservedClientId; }
const String& targetClientId() const { return m_targetClientId; }
bool respondWithEntered() const { return m_respondWithEntered; }
static ResourceError createResponseError(const URL&, const String&);
private:
WEBCORE_EXPORT FetchEvent(const AtomString&, Init&&, IsTrusted);
void promiseIsSettled();
void processResponse(Expected<Ref<FetchResponse>, ResourceError>&&);
void respondWithError(ResourceError&&);
Ref<FetchRequest> m_request;
String m_clientId;
String m_reservedClientId;
String m_targetClientId;
bool m_respondWithEntered { false };
bool m_waitToRespond { false };
bool m_respondWithError { false };
RefPtr<DOMPromise> m_respondPromise;
ResponseCallback m_onResponse;
};
}
#endif // ENABLE(SERVICE_WORKER)