This source file includes following definitions.
- m_contextProxy
- create
- interfaceName
- postMessage
- terminate
- stop
- hasPendingActivity
- didReceiveResponse
- notifyFinished
- trace
#include "config.h"
#include "core/workers/Worker.h"
#include "bindings/v8/ExceptionState.h"
#include "core/dom/Document.h"
#include "core/events/MessageEvent.h"
#include "core/fetch/ResourceFetcher.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/frame/DOMWindow.h"
#include "core/frame/UseCounter.h"
#include "core/workers/WorkerGlobalScopeProxy.h"
#include "core/workers/WorkerGlobalScopeProxyProvider.h"
#include "core/workers/WorkerScriptLoader.h"
#include "core/workers/WorkerThread.h"
#include "wtf/MainThread.h"
namespace WebCore {
inline Worker::Worker(ExecutionContext* context)
: AbstractWorker(context)
, m_contextProxy(0)
{
ScriptWrappable::init(this);
}
PassRefPtrWillBeRawPtr<Worker> Worker::create(ExecutionContext* context, const String& url, ExceptionState& exceptionState)
{
ASSERT(isMainThread());
Document* document = toDocument(context);
UseCounter::count(context, UseCounter::WorkerStart);
if (!document->page()) {
exceptionState.throwDOMException(InvalidAccessError, "The context provided is invalid.");
return nullptr;
}
WorkerGlobalScopeProxyProvider* proxyProvider = WorkerGlobalScopeProxyProvider::from(*document->page());
ASSERT(proxyProvider);
RefPtrWillBeRawPtr<Worker> worker = adoptRefWillBeRefCountedGarbageCollected(new Worker(context));
worker->suspendIfNeeded();
KURL scriptURL = worker->resolveURL(url, exceptionState);
if (scriptURL.isEmpty())
return nullptr;
worker->setPendingActivity(worker.get());
worker->m_scriptLoader = WorkerScriptLoader::create();
worker->m_scriptLoader->loadAsynchronously(context, scriptURL, DenyCrossOriginRequests, worker.get());
worker->m_contextProxy = proxyProvider->createWorkerGlobalScopeProxy(worker.get());
return worker.release();
}
Worker::~Worker()
{
ASSERT(isMainThread());
ASSERT(executionContext());
if (m_contextProxy)
m_contextProxy->workerObjectDestroyed();
}
const AtomicString& Worker::interfaceName() const
{
return EventTargetNames::Worker;
}
void Worker::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, ExceptionState& exceptionState)
{
OwnPtr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, exceptionState);
if (exceptionState.hadException())
return;
m_contextProxy->postMessageToWorkerGlobalScope(message, channels.release());
}
void Worker::terminate()
{
if (m_contextProxy)
m_contextProxy->terminateWorkerGlobalScope();
}
void Worker::stop()
{
terminate();
}
bool Worker::hasPendingActivity() const
{
return m_contextProxy->hasPendingActivity() || ActiveDOMObject::hasPendingActivity();
}
void Worker::didReceiveResponse(unsigned long identifier, const ResourceResponse&)
{
InspectorInstrumentation::didReceiveScriptResponse(executionContext(), identifier);
}
void Worker::notifyFinished()
{
if (m_scriptLoader->failed()) {
dispatchEvent(Event::createCancelable(EventTypeNames::error));
} else {
WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;
if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(executionContext()))
startMode = PauseWorkerGlobalScopeOnStart;
m_contextProxy->startWorkerGlobalScope(m_scriptLoader->url(), executionContext()->userAgent(m_scriptLoader->url()), m_scriptLoader->script(), startMode);
InspectorInstrumentation::scriptImported(executionContext(), m_scriptLoader->identifier(), m_scriptLoader->script());
}
m_scriptLoader = nullptr;
unsetPendingActivity(this);
}
void Worker::trace(Visitor* visitor)
{
AbstractWorker::trace(visitor);
}
}