ServiceWorkerJob.h [plain text]
#pragma once
#if ENABLE(SERVICE_WORKER)
#include "ResourceResponse.h"
#include "ServiceWorkerJobClient.h"
#include "ServiceWorkerJobData.h"
#include "ServiceWorkerTypes.h"
#include "WorkerScriptLoader.h"
#include "WorkerScriptLoaderClient.h"
#include <wtf/RefPtr.h>
#include <wtf/RunLoop.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/Threading.h>
namespace WebCore {
class DeferredPromise;
class Exception;
class ScriptExecutionContext;
enum class ServiceWorkerJobType;
struct ServiceWorkerRegistrationData;
class ServiceWorkerJob : public ThreadSafeRefCounted<ServiceWorkerJob>, public WorkerScriptLoaderClient {
public:
static Ref<ServiceWorkerJob> create(ServiceWorkerJobClient& client, RefPtr<DeferredPromise>&& promise, ServiceWorkerJobData&& jobData)
{
return adoptRef(*new ServiceWorkerJob(client, WTFMove(promise), WTFMove(jobData)));
}
WEBCORE_EXPORT ~ServiceWorkerJob();
void failedWithException(const Exception&);
void resolvedWithRegistration(ServiceWorkerRegistrationData&&, ShouldNotifyWhenResolved);
void resolvedWithUnregistrationResult(bool);
void startScriptFetch(FetchOptions::Cache);
using Identifier = ServiceWorkerJobIdentifier;
Identifier identifier() const { return m_jobData.identifier().jobIdentifier; }
const ServiceWorkerJobData& data() const { return m_jobData; }
DeferredPromise* promise() { return m_promise.get(); }
void fetchScriptWithContext(ScriptExecutionContext&, FetchOptions::Cache);
const DocumentOrWorkerIdentifier& contextIdentifier() { return m_contextIdentifier; }
void cancelPendingLoad();
private:
ServiceWorkerJob(ServiceWorkerJobClient&, RefPtr<DeferredPromise>&&, ServiceWorkerJobData&&);
void didReceiveResponse(unsigned long identifier, const ResourceResponse&) final;
void notifyFinished() final;
Ref<ServiceWorkerJobClient> m_client;
ServiceWorkerJobData m_jobData;
RefPtr<DeferredPromise> m_promise;
bool m_completed { false };
DocumentOrWorkerIdentifier m_contextIdentifier;
RefPtr<WorkerScriptLoader> m_scriptLoader;
#if !ASSERT_DISABLED
Ref<Thread> m_creationThread { Thread::current() };
#endif
};
}
#endif // ENABLE(SERVICE_WORKER)