bool WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, RefPtrWillBeRawPtr<ErrorEvent>* errorEvent, CachedMetadataHandler* cacheHandler, V8CacheOptions v8CacheOptions)
{
if (isExecutionForbidden())
return false;
WorkerGlobalScopeExecutionState state(this);
evaluate(sourceCode.source(), sourceCode.url().string(), sourceCode.startPosition(), cacheHandler, v8CacheOptions);
if (isExecutionForbidden())
return false;
if (state.hadException) {
if (errorEvent) {
if (state.m_errorEventFromImportedScript) {
// Propagate inner error event outwards.
*errorEvent = state.m_errorEventFromImportedScript.release();
return false;
}
if (m_workerGlobalScope.shouldSanitizeScriptError(state.sourceURL, NotSharableCrossOrigin))
*errorEvent = ErrorEvent::createSanitizedError(m_world.get());
else
*errorEvent = ErrorEvent::create(state.errorMessage, state.sourceURL, state.lineNumber, state.columnNumber, m_world.get());
V8ErrorHandler::storeExceptionOnErrorEventWrapper(isolate(), errorEvent->get(), state.exception.v8Value(), m_scriptState->context()->Global());
} else {
ASSERT(!m_workerGlobalScope.shouldSanitizeScriptError(state.sourceURL, NotSharableCrossOrigin));
RefPtrWillBeRawPtr<ErrorEvent> event = nullptr;
if (state.m_errorEventFromImportedScript)
event = state.m_errorEventFromImportedScript.release();
else
event = ErrorEvent::create(state.errorMessage, state.sourceURL, state.lineNumber, state.columnNumber, m_world.get());
m_workerGlobalScope.reportException(event, 0, nullptr, NotSharableCrossOrigin);
}
return false;
}
return true;
}
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)) || isTerminatingExecution()) {
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::evaluate(const ScriptSourceCode& sourceCode, Deprecated::ScriptValue* exception)
{
if (isExecutionForbidden())
return;
initScriptIfNeeded();
ExecState* exec = m_workerGlobalScopeWrapper->globalExec();
JSLockHolder lock(exec);
JSValue evaluationException;
JSC::evaluate(exec, sourceCode.jsSourceCode(), m_workerGlobalScopeWrapper.get(), &evaluationException);
if ((evaluationException && isTerminatedExecutionException(evaluationException)) || m_workerGlobalScopeWrapper->vm().watchdog.didFire()) {
forbidExecution();
return;
}
if (evaluationException) {
String errorMessage;
int lineNumber = 0;
int columnNumber = 0;
String sourceURL = sourceCode.url().string();
if (m_workerGlobalScope->sanitizeScriptError(errorMessage, lineNumber, columnNumber, sourceURL, sourceCode.cachedScript()))
*exception = Deprecated::ScriptValue(*m_vm, exec->vm().throwException(exec, createError(exec, errorMessage.impl())));
else
*exception = Deprecated::ScriptValue(*m_vm, evaluationException);
}
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, ScriptValue* exception)
{
if (isExecutionForbidden())
return;
initScriptIfNeeded();
ExecState* exec = m_workerContextWrapper->globalExec();
JSLockHolder lock(exec);
m_workerContextWrapper->globalData().timeoutChecker.start();
JSValue evaluationException;
JSC::evaluate(exec, sourceCode.jsSourceCode(), m_workerContextWrapper.get(), &evaluationException);
m_workerContextWrapper->globalData().timeoutChecker.stop();
if ((evaluationException && isTerminatedExecutionException(evaluationException)) || m_workerContextWrapper->globalData().terminator.shouldTerminate()) {
forbidExecution();
return;
}
if (evaluationException) {
String errorMessage;
int lineNumber = 0;
String sourceURL = sourceCode.url().string();
if (m_workerContext->sanitizeScriptError(errorMessage, lineNumber, sourceURL))
*exception = ScriptValue(*m_globalData, throwError(exec, createError(exec, errorMessage.impl())));
else
*exception = ScriptValue(*m_globalData, evaluationException);
}
}
ScriptValue WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, ScriptValue* exception)
{
if (isExecutionForbidden())
return ScriptValue();
initScriptIfNeeded();
JSLock lock(SilenceAssertionsOnly);
ExecState* exec = m_workerContextWrapper->globalExec();
m_workerContextWrapper->globalData().timeoutChecker.start();
Completion comp = JSC::evaluate(exec, exec->dynamicGlobalObject()->globalScopeChain(), sourceCode.jsSourceCode(), m_workerContextWrapper.get());
m_workerContextWrapper->globalData().timeoutChecker.stop();
ComplType completionType = comp.complType();
if (completionType == Terminated || m_workerContextWrapper->globalData().terminator.shouldTerminate()) {
forbidExecution();
return ScriptValue();
}
if (completionType == JSC::Normal || completionType == ReturnValue)
return ScriptValue(*m_globalData, comp.value());
if (completionType == Throw) {
String errorMessage;
int lineNumber = 0;
String sourceURL = sourceCode.url().string();
if (m_workerContext->sanitizeScriptError(errorMessage, lineNumber, sourceURL))
*exception = ScriptValue(*m_globalData, throwError(exec, createError(exec, errorMessage.impl())));
else
*exception = ScriptValue(*m_globalData, comp.value());
}
return ScriptValue();
}
bool WorkerOrWorkletScriptController::evaluate(
const ScriptSourceCode& sourceCode,
ErrorEvent** errorEvent,
CachedMetadataHandler* cacheHandler,
V8CacheOptions v8CacheOptions) {
if (isExecutionForbidden())
return false;
ExecutionState state(this);
evaluate(sourceCode.source(), sourceCode.url().getString(),
sourceCode.startPosition(), cacheHandler, v8CacheOptions);
if (isExecutionForbidden())
return false;
if (state.hadException) {
if (errorEvent) {
if (state.m_errorEventFromImportedScript) {
// Propagate inner error event outwards.
*errorEvent = state.m_errorEventFromImportedScript.release();
return false;
}
if (m_globalScope->shouldSanitizeScriptError(state.m_location->url(),
NotSharableCrossOrigin))
*errorEvent = ErrorEvent::createSanitizedError(m_world.get());
else
*errorEvent = ErrorEvent::create(
state.errorMessage, state.m_location->clone(), m_world.get());
V8ErrorHandler::storeExceptionOnErrorEventWrapper(
m_scriptState.get(), *errorEvent, state.exception.v8Value(),
m_scriptState->context()->Global());
} else {
DCHECK(!m_globalScope->shouldSanitizeScriptError(state.m_location->url(),
NotSharableCrossOrigin));
ErrorEvent* event = nullptr;
if (state.m_errorEventFromImportedScript)
event = state.m_errorEventFromImportedScript.release();
else
event = ErrorEvent::create(state.errorMessage,
state.m_location->clone(), m_world.get());
m_globalScope->dispatchErrorEvent(event, NotSharableCrossOrigin);
}
return false;
}
return true;
}
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)
{
if (isExecutionForbidden())
return;
Deprecated::ScriptValue exception;
evaluate(sourceCode, &exception);
if (exception.jsValue()) {
JSLockHolder lock(vm());
reportException(m_workerGlobalScopeWrapper->globalExec(), exception.jsValue());
}
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode)
{
if (isExecutionForbidden())
return;
ScriptValue exception;
evaluate(sourceCode, &exception);
if (exception.jsValue()) {
JSLock lock(SilenceAssertionsOnly);
reportException(m_workerContextWrapper->globalExec(), exception.jsValue());
}
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, ScriptValue* exception)
{
if (isExecutionForbidden())
return;
WorkerContextExecutionState state;
m_proxy->evaluate(sourceCode.source(), sourceCode.url().string(), sourceCode.startPosition(), &state);
if (state.hadException) {
if (exception)
*exception = state.exception;
else
m_workerContext->reportException(state.errorMessage, state.lineNumber, state.sourceURL, 0);
}
}
void WorkerScriptController::evaluate(const ScriptSourceCode& sourceCode, RefPtr<ErrorEvent>* errorEvent)
{
if (isExecutionForbidden())
return;
WorkerGlobalScopeExecutionState state;
evaluate(sourceCode.source(), sourceCode.url().string(), sourceCode.startPosition(), &state);
if (state.hadException) {
if (errorEvent) {
*errorEvent = m_workerGlobalScope.shouldSanitizeScriptError(state.sourceURL, NotSharableCrossOrigin) ?
ErrorEvent::createSanitizedError(nullptr) : ErrorEvent::create(state.errorMessage, state.sourceURL, state.lineNumber, state.columnNumber, nullptr);
V8ErrorHandler::storeExceptionOnErrorEventWrapper(errorEvent->get(), state.exception.v8Value(), isolate());
} else {
ASSERT(!m_workerGlobalScope.shouldSanitizeScriptError(state.sourceURL, NotSharableCrossOrigin));
RefPtr<ErrorEvent> event = m_errorEventFromImportedScript ? m_errorEventFromImportedScript.release() : ErrorEvent::create(state.errorMessage, state.sourceURL, state.lineNumber, state.columnNumber, nullptr);
m_workerGlobalScope.reportException(event, nullptr, NotSharableCrossOrigin);
}
}
}
