#include "config.h"
#include "Worker.h"
#include "DOMWindow.h"
#include "CachedResourceLoader.h"
#include "ContentSecurityPolicy.h"
#include "Document.h"
#include "EventListener.h"
#include "EventNames.h"
#include "ExceptionCode.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "InspectorInstrumentation.h"
#include "MessageEvent.h"
#include "NetworkStateNotifier.h"
#include "SecurityOrigin.h"
#include "TextEncoding.h"
#include "WorkerGlobalScopeProxy.h"
#include "WorkerScriptLoader.h"
#include "WorkerThread.h"
#include <wtf/HashSet.h>
#include <wtf/MainThread.h>
namespace WebCore {
static HashSet<Worker*>* allWorkers;
void networkStateChanged(bool isOnLine)
{
for (auto& worker : *allWorkers)
worker->notifyNetworkStateChange(isOnLine);
}
inline Worker::Worker(ScriptExecutionContext& context)
: ActiveDOMObject(&context)
, m_contextProxy(WorkerGlobalScopeProxy::create(this))
{
if (!allWorkers) {
allWorkers = new HashSet<Worker*>;
networkStateNotifier().addNetworkStateChangeListener(networkStateChanged);
}
HashSet<Worker*>::AddResult addResult = allWorkers->add(this);
ASSERT_UNUSED(addResult, addResult.isNewEntry);
}
RefPtr<Worker> Worker::create(ScriptExecutionContext& context, const String& url, ExceptionCode& ec)
{
ASSERT(isMainThread());
ASSERT_WITH_SECURITY_IMPLICATION(context.isDocument());
Ref<Worker> worker = adoptRef(*new Worker(context));
worker->suspendIfNeeded();
bool shouldBypassMainWorldContentSecurityPolicy = context.shouldBypassMainWorldContentSecurityPolicy();
URL scriptURL = worker->resolveURL(url, shouldBypassMainWorldContentSecurityPolicy, ec);
if (scriptURL.isEmpty())
return nullptr;
worker->m_shouldBypassMainWorldContentSecurityPolicy = shouldBypassMainWorldContentSecurityPolicy;
worker->setPendingActivity(worker.ptr());
worker->m_scriptLoader = WorkerScriptLoader::create();
auto contentSecurityPolicyEnforcement = shouldBypassMainWorldContentSecurityPolicy ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceChildSrcDirective;
worker->m_scriptLoader->loadAsynchronously(&context, scriptURL, DenyCrossOriginRequests, contentSecurityPolicyEnforcement, worker.ptr());
return WTFMove(worker);
}
Worker::~Worker()
{
ASSERT(isMainThread());
ASSERT(scriptExecutionContext()); allWorkers->remove(this);
m_contextProxy->workerObjectDestroyed();
}
void Worker::postMessage(RefPtr<SerializedScriptValue>&& message, MessagePort* port, ExceptionCode& ec)
{
MessagePortArray ports;
if (port)
ports.append(port);
postMessage(WTFMove(message), &ports, ec);
}
void Worker::postMessage(RefPtr<SerializedScriptValue>&& message, const MessagePortArray* ports, ExceptionCode& ec)
{
auto channels = MessagePort::disentanglePorts(ports, ec);
if (ec)
return;
m_contextProxy->postMessageToWorkerGlobalScope(WTFMove(message), WTFMove(channels));
}
void Worker::terminate()
{
m_contextProxy->terminateWorkerGlobalScope();
}
bool Worker::canSuspendForDocumentSuspension() const
{
return false;
}
const char* Worker::activeDOMObjectName() const
{
return "Worker";
}
void Worker::stop()
{
terminate();
}
bool Worker::hasPendingActivity() const
{
return m_contextProxy->hasPendingActivity() || ActiveDOMObject::hasPendingActivity();
}
void Worker::notifyNetworkStateChange(bool isOnLine)
{
m_contextProxy->notifyNetworkStateChange(isOnLine);
}
void Worker::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
{
const URL& responseURL = response.url();
if (!responseURL.protocolIsBlob() && !responseURL.protocolIs("file") && !SecurityOrigin::create(responseURL)->isUnique())
m_contentSecurityPolicyResponseHeaders = ContentSecurityPolicyResponseHeaders(response);
InspectorInstrumentation::didReceiveScriptResponse(scriptExecutionContext(), identifier);
}
void Worker::notifyFinished()
{
if (m_scriptLoader->failed())
dispatchEvent(Event::create(eventNames().errorEvent, false, true));
else {
const ContentSecurityPolicyResponseHeaders& contentSecurityPolicyResponseHeaders = m_contentSecurityPolicyResponseHeaders ? m_contentSecurityPolicyResponseHeaders.value() : scriptExecutionContext()->contentSecurityPolicy()->responseHeaders();
m_contextProxy->startWorkerGlobalScope(m_scriptLoader->url(), scriptExecutionContext()->userAgent(m_scriptLoader->url()), m_scriptLoader->script(), contentSecurityPolicyResponseHeaders, m_shouldBypassMainWorldContentSecurityPolicy, DontPauseWorkerGlobalScopeOnStart);
InspectorInstrumentation::scriptImported(scriptExecutionContext(), m_scriptLoader->identifier(), m_scriptLoader->script());
}
m_scriptLoader = nullptr;
unsetPendingActivity(this);
}
}