WorkerScriptController.cpp [plain text]
#include "config.h"
#include "WorkerScriptController.h"
#include "JSDOMBinding.h"
#include "JSDedicatedWorkerGlobalScope.h"
#include "ScriptSourceCode.h"
#include "WebCoreJSClientData.h"
#include "WorkerGlobalScope.h"
#include "WorkerObjectProxy.h"
#include "WorkerScriptDebugServer.h"
#include "WorkerThread.h"
#include <bindings/ScriptValue.h>
#include <heap/StrongInlines.h>
#include <interpreter/Interpreter.h>
#include <runtime/Completion.h>
#include <runtime/Exception.h>
#include <runtime/ExceptionHelpers.h>
#include <runtime/Error.h>
#include <runtime/JSLock.h>
using namespace JSC;
namespace WebCore {
WorkerScriptController::WorkerScriptController(WorkerGlobalScope* workerGlobalScope)
: m_vm(VM::create())
, m_workerGlobalScope(workerGlobalScope)
, m_workerGlobalScopeWrapper(*m_vm)
, m_executionForbidden(false)
{
initNormalWorldClientData(m_vm.get());
}
WorkerScriptController::~WorkerScriptController()
{
JSLockHolder lock(vm());
m_workerGlobalScopeWrapper.clear();
m_vm = nullptr;
}
void WorkerScriptController::initScript()
{
ASSERT(!m_workerGlobalScopeWrapper);
JSLockHolder lock(m_vm.get());
Structure* workerGlobalScopePrototypeStructure = JSWorkerGlobalScopePrototype::createStructure(*m_vm, 0, jsNull());
Strong<JSWorkerGlobalScopePrototype> workerGlobalScopePrototype(*m_vm, JSWorkerGlobalScopePrototype::create(*m_vm, 0, workerGlobalScopePrototypeStructure));
if (m_workerGlobalScope->isDedicatedWorkerGlobalScope()) {
Structure* dedicatedContextPrototypeStructure = JSDedicatedWorkerGlobalScopePrototype::createStructure(*m_vm, 0, workerGlobalScopePrototype.get());
Strong<JSDedicatedWorkerGlobalScopePrototype> dedicatedContextPrototype(*m_vm, JSDedicatedWorkerGlobalScopePrototype::create(*m_vm, 0, dedicatedContextPrototypeStructure));
Structure* structure = JSDedicatedWorkerGlobalScope::createStructure(*m_vm, 0, dedicatedContextPrototype.get());
m_workerGlobalScopeWrapper.set(*m_vm, JSDedicatedWorkerGlobalScope::create(*m_vm, structure, static_cast<DedicatedWorkerGlobalScope&>(*m_workerGlobalScope)));
workerGlobalScopePrototypeStructure->setGlobalObject(*m_vm, m_workerGlobalScopeWrapper.get());
dedicatedContextPrototypeStructure->setGlobalObject(*m_vm, m_workerGlobalScopeWrapper.get());
ASSERT(structure->globalObject() == m_workerGlobalScopeWrapper);
ASSERT(m_workerGlobalScopeWrapper->structure()->globalObject() == m_workerGlobalScopeWrapper);
workerGlobalScopePrototype->structure()->setGlobalObject(*m_vm, m_workerGlobalScopeWrapper.get());
dedicatedContextPrototype->structure()->setGlobalObject(*m_vm, m_workerGlobalScopeWrapper.get());
}
ASSERT(m_workerGlobalScopeWrapper->globalObject() == m_workerGlobalScopeWrapper);
ASSERT(asObject(m_workerGlobalScopeWrapper->prototype())->globalObject() == m_workerGlobalScopeWrapper);
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode)
{
if (isExecutionForbidden())
return;
NakedPtr<Exception> exception;
evaluate(sourceCode, exception);
if (exception) {
JSLockHolder lock(vm());
reportException(m_workerGlobalScopeWrapper->globalExec(), exception);
}
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, NakedPtr<JSC::Exception>& returnedException)
{
if (isExecutionForbidden())
return;
initScriptIfNeeded();
ExecState* exec = m_workerGlobalScopeWrapper->globalExec();
JSLockHolder lock(exec);
JSC::evaluate(exec, sourceCode.jsSourceCode(), m_workerGlobalScopeWrapper->globalThis(), returnedException);
VM& vm = exec->vm();
if ((returnedException && isTerminatedExecutionException(returnedException))
|| (vm.watchdog && vm.watchdog->didFire())) {
forbidExecution();
return;
}
if (returnedException) {
String errorMessage;
int lineNumber = 0;
int columnNumber = 0;
String sourceURL = sourceCode.url().string();
if (m_workerGlobalScope->sanitizeScriptError(errorMessage, lineNumber, columnNumber, sourceURL, sourceCode.cachedScript())) {
vm.throwException(exec, createError(exec, errorMessage.impl()));
returnedException = vm.exception();
vm.clearException();
}
}
}
void WorkerScriptController::setException(JSC::Exception* exception)
{
JSC::ExecState* exec = m_workerGlobalScopeWrapper->globalExec();
exec->vm().throwException(exec, exception);
}
void WorkerScriptController::scheduleExecutionTermination()
{
MutexLocker locker(m_scheduledTerminationMutex);
if (m_vm->watchdog)
m_vm->watchdog->fire();
}
bool WorkerScriptController::isExecutionTerminating() const
{
MutexLocker locker(m_scheduledTerminationMutex);
if (m_vm->watchdog)
return m_vm->watchdog->didFire();
return false;
}
void WorkerScriptController::forbidExecution()
{
ASSERT(m_workerGlobalScope->isContextThread());
m_executionForbidden = true;
}
bool WorkerScriptController::isExecutionForbidden() const
{
ASSERT(m_workerGlobalScope->isContextThread());
return m_executionForbidden;
}
void WorkerScriptController::disableEval(const String& errorMessage)
{
initScriptIfNeeded();
JSLockHolder lock(vm());
m_workerGlobalScopeWrapper->setEvalEnabled(false, errorMessage);
}
void WorkerScriptController::attachDebugger(JSC::Debugger* debugger)
{
initScriptIfNeeded();
debugger->attach(m_workerGlobalScopeWrapper->globalObject());
}
void WorkerScriptController::detachDebugger(JSC::Debugger* debugger)
{
debugger->detach(m_workerGlobalScopeWrapper->globalObject(), JSC::Debugger::TerminatingDebuggingSession);
}
}