SWServerWorker.cpp [plain text]
#include "config.h"
#include "SWServerWorker.h"
#if ENABLE(SERVICE_WORKER)
#include "SWServerToContextConnection.h"
#include <wtf/NeverDestroyed.h>
namespace WebCore {
HashMap<ServiceWorkerIdentifier, SWServerWorker*>& SWServerWorker::allWorkers()
{
static NeverDestroyed<HashMap<ServiceWorkerIdentifier, SWServerWorker*>> workers;
return workers;
}
SWServerWorker* SWServerWorker::existingWorkerForIdentifier(ServiceWorkerIdentifier identifier)
{
return allWorkers().get(identifier);
}
SWServerWorker::SWServerWorker(SWServer& server, SWServerRegistration& registration, const URL& scriptURL, const String& script, const ContentSecurityPolicyResponseHeaders& contentSecurityPolicy, String&& referrerPolicy, WorkerType type, ServiceWorkerIdentifier identifier, HashMap<URL, ServiceWorkerContextData::ImportedScript>&& scriptResourceMap)
: m_server(server)
, m_registrationKey(registration.key())
, m_data { identifier, scriptURL, ServiceWorkerState::Redundant, type, registration.identifier() }
, m_script(script)
, m_contentSecurityPolicy(contentSecurityPolicy)
, m_referrerPolicy(WTFMove(referrerPolicy))
, m_scriptResourceMap(WTFMove(scriptResourceMap))
{
m_data.scriptURL.removeFragmentIdentifier();
auto result = allWorkers().add(identifier, this);
ASSERT_UNUSED(result, result.isNewEntry);
ASSERT(m_server.getRegistration(m_registrationKey));
}
SWServerWorker::~SWServerWorker()
{
callWhenActivatedHandler(false);
auto taken = allWorkers().take(identifier());
ASSERT_UNUSED(taken, taken == this);
}
ServiceWorkerContextData SWServerWorker::contextData() const
{
auto* registration = m_server.getRegistration(m_registrationKey);
ASSERT(registration);
return { WTF::nullopt, registration->data(), m_data.identifier, m_script, m_contentSecurityPolicy, m_referrerPolicy, m_data.scriptURL, m_data.type, m_server.sessionID(), false, m_scriptResourceMap };
}
void SWServerWorker::terminate()
{
if (isRunning())
m_server.terminateWorker(*this);
}
const ClientOrigin& SWServerWorker::origin() const
{
if (!m_origin)
m_origin = ClientOrigin { m_registrationKey.topOrigin(), SecurityOriginData::fromURL(m_data.scriptURL) };
return *m_origin;
}
const SecurityOriginData& SWServerWorker::securityOrigin() const
{
return origin().clientOrigin;
}
SWServerToContextConnection* SWServerWorker::contextConnection()
{
return SWServerToContextConnection::connectionForOrigin(securityOrigin());
}
void SWServerWorker::scriptContextFailedToStart(const Optional<ServiceWorkerJobDataIdentifier>& jobDataIdentifier, const String& message)
{
m_server.scriptContextFailedToStart(jobDataIdentifier, *this, message);
}
void SWServerWorker::scriptContextStarted(const Optional<ServiceWorkerJobDataIdentifier>& jobDataIdentifier)
{
m_server.scriptContextStarted(jobDataIdentifier, *this);
}
void SWServerWorker::didFinishInstall(const Optional<ServiceWorkerJobDataIdentifier>& jobDataIdentifier, bool wasSuccessful)
{
m_server.didFinishInstall(jobDataIdentifier, *this, wasSuccessful);
}
void SWServerWorker::didFinishActivation()
{
m_server.didFinishActivation(*this);
}
void SWServerWorker::contextTerminated()
{
m_server.workerContextTerminated(*this);
}
Optional<ServiceWorkerClientData> SWServerWorker::findClientByIdentifier(const ServiceWorkerClientIdentifier& clientId) const
{
return m_server.serviceWorkerClientWithOriginByID(origin(), clientId);
}
void SWServerWorker::matchAll(const ServiceWorkerClientQueryOptions& options, ServiceWorkerClientsMatchAllCallback&& callback)
{
return m_server.matchAll(*this, options, WTFMove(callback));
}
String SWServerWorker::userAgent() const
{
return m_server.serviceWorkerClientUserAgent(origin());
}
void SWServerWorker::claim()
{
return m_server.claim(*this);
}
void SWServerWorker::setScriptResource(URL&& url, ServiceWorkerContextData::ImportedScript&& script)
{
m_scriptResourceMap.set(WTFMove(url), WTFMove(script));
}
void SWServerWorker::skipWaiting()
{
m_isSkipWaitingFlagSet = true;
auto* registration = m_server.getRegistration(m_registrationKey);
ASSERT(registration || isTerminating());
if (registration)
registration->tryActivate();
}
void SWServerWorker::setHasPendingEvents(bool hasPendingEvents)
{
if (m_hasPendingEvents == hasPendingEvents)
return;
m_hasPendingEvents = hasPendingEvents;
if (m_hasPendingEvents)
return;
auto* registration = m_server.getRegistration(m_registrationKey);
if (!registration)
return;
if (registration->isUninstalling() && registration->tryClear())
return;
registration->tryActivate();
}
void SWServerWorker::whenActivated(WTF::Function<void(bool)>&& handler)
{
if (state() == ServiceWorkerState::Activated) {
handler(true);
return;
}
m_whenActivatedHandlers.append(WTFMove(handler));
}
void SWServerWorker::setState(ServiceWorkerState state)
{
if (state == ServiceWorkerState::Redundant)
terminate();
m_data.state = state;
auto* registration = m_server.getRegistration(m_registrationKey);
ASSERT(registration || state == ServiceWorkerState::Redundant);
if (registration) {
registration->forEachConnection([&](auto& connection) {
connection.updateWorkerStateInClient(this->identifier(), state);
});
}
if (state == ServiceWorkerState::Activated || state == ServiceWorkerState::Redundant)
callWhenActivatedHandler(state == ServiceWorkerState::Activated);
}
void SWServerWorker::callWhenActivatedHandler(bool success)
{
auto whenActivatedHandlers = WTFMove(m_whenActivatedHandlers);
for (auto& handler : whenActivatedHandlers)
handler(success);
}
void SWServerWorker::setState(State state)
{
ASSERT(state != State::Running || m_server.getRegistration(m_registrationKey));
m_state = state;
}
}
#endif // ENABLE(SERVICE_WORKER)