blob: 5afb2accfb8a19b99190ae57688f02aef330ab72 [file] [log] [blame]
/*
* Copyright (C) 2008-2021 Apple Inc. All Rights Reserved.
* Copyright (C) 2011, 2012 Google Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "WorkerOrWorkletScriptController.h"
#include "CommonVM.h"
#include "DedicatedWorkerGlobalScope.h"
#include "EventLoop.h"
#include "JSAudioWorkletGlobalScope.h"
#include "JSDOMBinding.h"
#include "JSDedicatedWorkerGlobalScope.h"
#include "JSEventTarget.h"
#include "JSExecState.h"
#include "JSPaintWorkletGlobalScope.h"
#include "JSServiceWorkerGlobalScope.h"
#include "JSSharedWorkerGlobalScope.h"
#include "ModuleFetchFailureKind.h"
#include "ModuleFetchParameters.h"
#include "ScriptSourceCode.h"
#include "WebCoreJSClientData.h"
#include "WorkerConsoleClient.h"
#include "WorkerModuleScriptLoader.h"
#include "WorkerOrWorkletThread.h"
#include "WorkerRunLoop.h"
#include "WorkerScriptFetcher.h"
#include <JavaScriptCore/AbstractModuleRecord.h>
#include <JavaScriptCore/Completion.h>
#include <JavaScriptCore/DeferTermination.h>
#include <JavaScriptCore/DeferredWorkTimer.h>
#include <JavaScriptCore/Exception.h>
#include <JavaScriptCore/ExceptionHelpers.h>
#include <JavaScriptCore/GCActivityCallback.h>
#include <JavaScriptCore/JSInternalPromise.h>
#include <JavaScriptCore/JSLock.h>
#include <JavaScriptCore/JSNativeStdFunction.h>
#include <JavaScriptCore/JSScriptFetchParameters.h>
#include <JavaScriptCore/JSScriptFetcher.h>
#include <JavaScriptCore/ScriptCallStack.h>
#include <JavaScriptCore/StrongInlines.h>
#include <JavaScriptCore/VMTrapsInlines.h>
namespace WebCore {
using namespace JSC;
WorkerOrWorkletScriptController::WorkerOrWorkletScriptController(WorkerThreadType type, Ref<VM>&& vm, WorkerOrWorkletGlobalScope* globalScope)
: m_vm(WTFMove(vm))
, m_globalScope(globalScope)
, m_globalScopeWrapper(*m_vm)
{
if (!isMainThread() || m_vm != &commonVM()) {
m_vm->heap.acquireAccess(); // It's not clear that we have good discipline for heap access, so turn it on permanently.
{
JSLockHolder lock(m_vm.get());
m_vm->ensureTerminationException();
m_vm->forbidExecutionOnTermination();
}
JSVMClientData::initNormalWorld(m_vm.get(), type);
}
}
WorkerOrWorkletScriptController::~WorkerOrWorkletScriptController()
{
JSLockHolder lock(vm());
if (m_globalScopeWrapper) {
m_globalScopeWrapper->clearDOMGuardedObjects();
m_globalScopeWrapper->setConsoleClient(nullptr);
}
m_globalScopeWrapper.clear();
m_vm = nullptr;
}
void WorkerOrWorkletScriptController::attachDebugger(JSC::Debugger* debugger)
{
initScriptIfNeeded();
debugger->attach(m_globalScopeWrapper.get());
}
void WorkerOrWorkletScriptController::detachDebugger(JSC::Debugger* debugger)
{
debugger->detach(m_globalScopeWrapper.get(), JSC::Debugger::TerminatingDebuggingSession);
}
void WorkerOrWorkletScriptController::forbidExecution()
{
ASSERT(m_globalScope->isContextThread());
m_vm->setExecutionForbidden();
}
bool WorkerOrWorkletScriptController::isExecutionForbidden() const
{
ASSERT(m_globalScope->isContextThread());
return m_vm->executionForbidden();
}
void WorkerOrWorkletScriptController::scheduleExecutionTermination()
{
{
// The mutex provides a memory barrier to ensure that once
// termination is scheduled, isTerminatingExecution() will
// accurately reflect that lexicalGlobalObject when called from another thread.
Locker locker { m_scheduledTerminationLock };
if (m_isTerminatingExecution)
return;
m_isTerminatingExecution = true;
}
if (m_vm != &commonVM())
m_vm->notifyNeedTermination();
}
bool WorkerOrWorkletScriptController::isTerminatingExecution() const
{
// See comments in scheduleExecutionTermination regarding mutex usage.
Locker locker { m_scheduledTerminationLock };
return m_isTerminatingExecution;
}
void WorkerOrWorkletScriptController::releaseHeapAccess()
{
m_vm->heap.releaseAccess();
}
void WorkerOrWorkletScriptController::acquireHeapAccess()
{
m_vm->heap.acquireAccess();
}
void WorkerOrWorkletScriptController::addTimerSetNotification(JSC::JSRunLoopTimer::TimerNotificationCallback callback)
{
auto processTimer = [&] (JSRunLoopTimer* timer) {
if (!timer)
return;
timer->addTimerSetNotification(callback);
};
processTimer(m_vm->heap.fullActivityCallback());
processTimer(m_vm->heap.edenActivityCallback());
processTimer(m_vm->deferredWorkTimer.ptr());
}
void WorkerOrWorkletScriptController::removeTimerSetNotification(JSC::JSRunLoopTimer::TimerNotificationCallback callback)
{
auto processTimer = [&] (JSRunLoopTimer* timer) {
if (!timer)
return;
timer->removeTimerSetNotification(callback);
};
processTimer(m_vm->heap.fullActivityCallback());
processTimer(m_vm->heap.edenActivityCallback());
processTimer(m_vm->deferredWorkTimer.ptr());
}
void WorkerOrWorkletScriptController::setException(JSC::Exception* exception)
{
JSC::JSGlobalObject* lexicalGlobalObject = m_globalScopeWrapper.get();
VM& vm = lexicalGlobalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
throwException(lexicalGlobalObject, scope, exception);
}
void WorkerOrWorkletScriptController::disableEval(const String& errorMessage)
{
initScriptIfNeeded();
JSLockHolder lock { vm() };
m_globalScopeWrapper->setEvalEnabled(false, errorMessage);
}
void WorkerOrWorkletScriptController::disableWebAssembly(const String& errorMessage)
{
initScriptIfNeeded();
JSLockHolder lock { vm() };
m_globalScopeWrapper->setWebAssemblyEnabled(false, errorMessage);
}
void WorkerOrWorkletScriptController::evaluate(const ScriptSourceCode& sourceCode, String* returnedExceptionMessage)
{
if (isExecutionForbidden())
return;
VM& vm = this->vm();
NakedPtr<JSC::Exception> uncaughtException;
evaluate(sourceCode, uncaughtException, returnedExceptionMessage);
if ((uncaughtException && vm.isTerminationException(uncaughtException)) || isTerminatingExecution()) {
forbidExecution();
return;
}
if (uncaughtException) {
JSLockHolder lock(vm);
reportException(m_globalScopeWrapper.get(), uncaughtException);
}
}
void WorkerOrWorkletScriptController::evaluate(const ScriptSourceCode& sourceCode, NakedPtr<JSC::Exception>& returnedException, String* returnedExceptionMessage)
{
if (isExecutionForbidden())
return;
initScriptIfNeeded();
auto& globalObject = *m_globalScopeWrapper.get();
VM& vm = globalObject.vm();
JSLockHolder lock { vm };
JSExecState::profiledEvaluate(&globalObject, JSC::ProfilingReason::Other, sourceCode.jsSourceCode(), m_globalScopeWrapper->globalThis(), returnedException);
if ((returnedException && vm.isTerminationException(returnedException)) || isTerminatingExecution()) {
forbidExecution();
return;
}
if (returnedException) {
if (m_globalScope->canIncludeErrorDetails(sourceCode.cachedScript(), sourceCode.url().string())) {
// FIXME: It's not great that this can run arbitrary code to string-ify the value of the exception.
// Do we need to do anything to handle that properly, if it, say, raises another exception?
if (returnedExceptionMessage)
*returnedExceptionMessage = returnedException->value().toWTFString(&globalObject);
} else {
// Overwrite the detailed error with a generic error.
String genericErrorMessage { "Script error."_s };
if (returnedExceptionMessage)
*returnedExceptionMessage = genericErrorMessage;
returnedException = JSC::Exception::create(vm, createError(&globalObject, genericErrorMessage));
}
}
}
static Identifier jsValueToModuleKey(JSGlobalObject* lexicalGlobalObject, JSValue value)
{
if (value.isSymbol())
return Identifier::fromUid(jsCast<Symbol*>(value)->privateName());
ASSERT(value.isString());
return asString(value)->toIdentifier(lexicalGlobalObject);
}
JSC::JSValue WorkerOrWorkletScriptController::evaluateModule(JSC::AbstractModuleRecord& moduleRecord, JSC::JSValue awaitedValue, JSC::JSValue resumeMode)
{
auto& globalObject = *m_globalScopeWrapper.get();
VM& vm = globalObject.vm();
JSLockHolder lock { vm };
return moduleRecord.evaluate(&globalObject, awaitedValue, resumeMode);
}
bool WorkerOrWorkletScriptController::loadModuleSynchronously(WorkerScriptFetcher& scriptFetcher, const ScriptSourceCode& sourceCode)
{
if (isExecutionForbidden())
return false;
initScriptIfNeeded();
auto& globalObject = *m_globalScopeWrapper.get();
VM& vm = globalObject.vm();
JSLockHolder lock { vm };
auto scope = DECLARE_THROW_SCOPE(vm);
Ref protector { scriptFetcher };
{
auto& promise = JSExecState::loadModule(globalObject, sourceCode.jsSourceCode(), JSC::JSScriptFetcher::create(vm, { &scriptFetcher }));
scope.assertNoExceptionExceptTermination();
RETURN_IF_EXCEPTION(scope, false);
auto& fulfillHandler = *JSNativeStdFunction::create(vm, &globalObject, 1, String(), [protector](JSGlobalObject* globalObject, CallFrame* callFrame) -> JSC::EncodedJSValue {
VM& vm = globalObject->vm();
JSLockHolder lock { vm };
auto scope = DECLARE_THROW_SCOPE(vm);
Identifier moduleKey = jsValueToModuleKey(globalObject, callFrame->argument(0));
RETURN_IF_EXCEPTION(scope, { });
protector->notifyLoadCompleted(*moduleKey.impl());
return JSValue::encode(jsUndefined());
});
auto& rejectHandler = *JSNativeStdFunction::create(vm, &globalObject, 1, String(), [protector](JSGlobalObject* globalObject, CallFrame* callFrame) {
VM& vm = globalObject->vm();
JSLockHolder lock { vm };
JSValue errorValue = callFrame->argument(0);
auto scope = DECLARE_CATCH_SCOPE(vm);
if (errorValue.isObject()) {
auto* object = JSC::asObject(errorValue);
if (JSValue failureKindValue = object->getDirect(vm, builtinNames(vm).failureKindPrivateName())) {
// This is host propagated error in the module loader pipeline.
switch (static_cast<ModuleFetchFailureKind>(failureKindValue.asInt32())) {
case ModuleFetchFailureKind::WasPropagatedError:
protector->notifyLoadFailed(LoadableScript::Error {
LoadableScript::ErrorType::CachedScript,
std::nullopt,
std::nullopt
});
break;
// For a fetch error that was not propagated from further in the
// pipeline, we include the console error message but do not
// include an error value as it should not be reported.
case ModuleFetchFailureKind::WasFetchError:
protector->notifyLoadFailed(LoadableScript::Error {
LoadableScript::ErrorType::CachedScript,
LoadableScript::ConsoleMessage {
MessageSource::JS,
MessageLevel::Error,
retrieveErrorMessage(*globalObject, vm, errorValue, scope),
},
std::nullopt
});
break;
case ModuleFetchFailureKind::WasCanceled:
protector->notifyLoadWasCanceled();
break;
}
return JSValue::encode(jsUndefined());
}
}
protector->notifyLoadFailed(LoadableScript::Error {
LoadableScript::ErrorType::CachedScript,
LoadableScript::ConsoleMessage {
MessageSource::JS,
MessageLevel::Error,
retrieveErrorMessage(*globalObject, vm, errorValue, scope),
},
// The error value may need to be propagated here as it is in
// ScriptController in the future.
std::nullopt
});
return JSValue::encode(jsUndefined());
});
promise.then(&globalObject, &fulfillHandler, &rejectHandler);
}
m_globalScope->eventLoop().performMicrotaskCheckpoint();
// Drive RunLoop until we get either of "Worker is terminated", "Loading is done", or "Loading is failed".
WorkerRunLoop& runLoop = m_globalScope->workerOrWorkletThread()->runLoop();
// We do not want to receive messages that are not related to asynchronous resource loading.
// Otherwise, a worker discards some messages from the main thread here in a racy way.
// For example, the main thread can postMessage just after creating a Worker. In that case, postMessage's
// task is queued in WorkerRunLoop before start running module scripts. This task should not be discarded
// in the following driving of the RunLoop which mainly attempt to collect initial load of module scripts.
String taskMode = WorkerModuleScriptLoader::taskMode();
// Allow tasks scheduled from the WorkerEventLoop.
constexpr bool allowEventLoopTasks = true;
bool success = true;
while ((!protector->isLoaded() && !protector->wasCanceled()) && success) {
success = runLoop.runInMode(m_globalScope, taskMode, allowEventLoopTasks);
if (success)
m_globalScope->eventLoop().performMicrotaskCheckpoint();
}
return success;
}
void WorkerOrWorkletScriptController::linkAndEvaluateModule(WorkerScriptFetcher& scriptFetcher, const ScriptSourceCode& sourceCode, String* returnedExceptionMessage)
{
if (isExecutionForbidden())
return;
initScriptIfNeeded();
auto& globalObject = *m_globalScopeWrapper.get();
VM& vm = globalObject.vm();
JSLockHolder lock { vm };
NakedPtr<JSC::Exception> returnedException;
JSExecState::linkAndEvaluateModule(globalObject, Identifier::fromUid(vm, scriptFetcher.moduleKey()), jsUndefined(), returnedException);
if ((returnedException && vm.isTerminationException(returnedException)) || isTerminatingExecution()) {
forbidExecution();
return;
}
if (returnedException) {
if (m_globalScope->canIncludeErrorDetails(sourceCode.cachedScript(), sourceCode.url().string())) {
// FIXME: It's not great that this can run arbitrary code to string-ify the value of the exception.
// Do we need to do anything to handle that properly, if it, say, raises another exception?
if (returnedExceptionMessage)
*returnedExceptionMessage = returnedException->value().toWTFString(&globalObject);
} else {
String genericErrorMessage { "Script error."_s };
if (returnedExceptionMessage)
*returnedExceptionMessage = genericErrorMessage;
}
JSLockHolder lock(vm);
reportException(m_globalScopeWrapper.get(), returnedException);
}
}
void WorkerOrWorkletScriptController::loadAndEvaluateModule(const URL& moduleURL, FetchOptions::Credentials credentials, CompletionHandler<void(std::optional<Exception>&&)>&& completionHandler)
{
if (isExecutionForbidden()) {
completionHandler(Exception { NotAllowedError });
return;
}
initScriptIfNeeded();
auto& globalObject = *m_globalScopeWrapper.get();
VM& vm = globalObject.vm();
JSLockHolder lock { vm };
auto scriptFetcher = WorkerScriptFetcher::create(credentials, globalScope()->destination(), globalScope()->referrerPolicy());
{
auto& promise = JSExecState::loadModule(globalObject, moduleURL.string(), JSC::JSScriptFetchParameters::create(vm, scriptFetcher->parameters()), JSC::JSScriptFetcher::create(vm, { scriptFetcher.ptr() }));
auto task = createSharedTask<void(std::optional<Exception>&&)>([completionHandler = WTFMove(completionHandler)](std::optional<Exception>&& exception) mutable {
completionHandler(WTFMove(exception));
});
auto& fulfillHandler = *JSNativeStdFunction::create(vm, &globalObject, 1, String(), [task, scriptFetcher](JSGlobalObject* globalObject, CallFrame* callFrame) -> JSC::EncodedJSValue {
// task->run(std::nullopt);
VM& vm = globalObject->vm();
JSLockHolder lock { vm };
auto scope = DECLARE_THROW_SCOPE(vm);
Identifier moduleKey = jsValueToModuleKey(globalObject, callFrame->argument(0));
RETURN_IF_EXCEPTION(scope, { });
scriptFetcher->notifyLoadCompleted(*moduleKey.impl());
auto* context = downcast<WorkerOrWorkletGlobalScope>(jsCast<JSDOMGlobalObject*>(globalObject)->scriptExecutionContext());
if (!context || !context->script()) {
task->run(std::nullopt);
return JSValue::encode(jsUndefined());
}
NakedPtr<JSC::Exception> returnedException;
JSExecState::linkAndEvaluateModule(*globalObject, moduleKey, jsUndefined(), returnedException);
if ((returnedException && vm.isTerminationException(returnedException)) || context->script()->isTerminatingExecution()) {
if (context->script())
context->script()->forbidExecution();
task->run(std::nullopt);
return JSValue::encode(jsUndefined());
}
if (returnedException) {
String message;
if (context->canIncludeErrorDetails(nullptr, moduleKey.string())) {
// FIXME: It's not great that this can run arbitrary code to string-ify the value of the exception.
// Do we need to do anything to handle that properly, if it, say, raises another exception?
message = returnedException->value().toWTFString(globalObject);
} else
message = "Script error."_s;
context->reportException(message, { }, { }, { }, { }, { });
}
task->run(std::nullopt);
return JSValue::encode(jsUndefined());
});
auto& rejectHandler = *JSNativeStdFunction::create(vm, &globalObject, 1, String(), [task](JSGlobalObject* globalObject, CallFrame* callFrame) {
VM& vm = globalObject->vm();
JSLockHolder lock { vm };
JSValue errorValue = callFrame->argument(0);
if (errorValue.isObject()) {
auto* object = JSC::asObject(errorValue);
if (JSValue failureKindValue = object->getDirect(vm, builtinNames(vm).failureKindPrivateName())) {
auto catchScope = DECLARE_CATCH_SCOPE(vm);
String message = retrieveErrorMessageWithoutName(*globalObject, vm, object, catchScope);
switch (static_cast<ModuleFetchFailureKind>(failureKindValue.asInt32())) {
case ModuleFetchFailureKind::WasFetchError:
task->run(Exception { TypeError, message });
break;
case ModuleFetchFailureKind::WasPropagatedError:
case ModuleFetchFailureKind::WasCanceled:
task->run(Exception { AbortError, message });
break;
}
return JSValue::encode(jsUndefined());
}
if (object->inherits<ErrorInstance>()) {
auto* error = jsCast<ErrorInstance*>(object);
switch (error->errorType()) {
case ErrorType::TypeError: {
auto catchScope = DECLARE_CATCH_SCOPE(vm);
String message = retrieveErrorMessageWithoutName(*globalObject, vm, error, catchScope);
task->run(Exception { TypeError, message });
return JSValue::encode(jsUndefined());
}
case ErrorType::SyntaxError: {
auto catchScope = DECLARE_CATCH_SCOPE(vm);
String message = retrieveErrorMessageWithoutName(*globalObject, vm, error, catchScope);
task->run(Exception { JSSyntaxError, message });
return JSValue::encode(jsUndefined());
}
default:
break;
}
}
}
auto catchScope = DECLARE_CATCH_SCOPE(vm);
String message = retrieveErrorMessageWithoutName(*globalObject, vm, errorValue, catchScope);
task->run(Exception { AbortError, message });
return JSValue::encode(jsUndefined());
});
promise.then(&globalObject, &fulfillHandler, &rejectHandler);
}
m_globalScope->eventLoop().performMicrotaskCheckpoint();
}
template<typename JSGlobalScopePrototype, typename JSGlobalScope, typename GlobalScope>
void WorkerOrWorkletScriptController::initScriptWithSubclass()
{
ASSERT(!m_globalScopeWrapper);
JSLockHolder lock { vm() };
// Explicitly protect the global object's prototype so it isn't collected
// when we allocate the global object. (Once the global object is fully
// constructed, it can mark its own prototype.)
Structure* contextPrototypeStructure = JSGlobalScopePrototype::createStructure(*m_vm, nullptr, jsNull());
auto* contextPrototype = JSGlobalScopePrototype::create(*m_vm, nullptr, contextPrototypeStructure);
Structure* structure = JSGlobalScope::createStructure(*m_vm, nullptr, contextPrototype);
auto* proxyStructure = JSProxy::createStructure(*m_vm, nullptr, jsNull());
auto* proxy = JSProxy::create(*m_vm, proxyStructure);
m_globalScopeWrapper.set(*m_vm, JSGlobalScope::create(*m_vm, structure, static_cast<GlobalScope&>(*m_globalScope), proxy));
contextPrototypeStructure->setGlobalObject(*m_vm, m_globalScopeWrapper.get());
ASSERT(structure->globalObject() == m_globalScopeWrapper);
ASSERT(m_globalScopeWrapper->structure()->globalObject() == m_globalScopeWrapper);
contextPrototype->structure()->setGlobalObject(*m_vm, m_globalScopeWrapper.get());
auto* globalScopePrototype = JSGlobalScope::prototype(*m_vm, *m_globalScopeWrapper.get());
globalScopePrototype->didBecomePrototype();
contextPrototype->structure()->setPrototypeWithoutTransition(*m_vm, globalScopePrototype);
proxy->setTarget(*m_vm, m_globalScopeWrapper.get());
proxy->structure()->setGlobalObject(*m_vm, m_globalScopeWrapper.get());
ASSERT(m_globalScopeWrapper->globalObject() == m_globalScopeWrapper);
ASSERT(asObject(m_globalScopeWrapper->getPrototypeDirect())->globalObject() == m_globalScopeWrapper);
m_consoleClient = makeUnique<WorkerConsoleClient>(*m_globalScope);
m_globalScopeWrapper->setConsoleClient(*m_consoleClient);
}
void WorkerOrWorkletScriptController::initScript()
{
ASSERT(m_vm.get());
JSC::DeferTermination deferTermination(*m_vm.get());
if (is<DedicatedWorkerGlobalScope>(m_globalScope)) {
initScriptWithSubclass<JSDedicatedWorkerGlobalScopePrototype, JSDedicatedWorkerGlobalScope, DedicatedWorkerGlobalScope>();
return;
}
if (is<SharedWorkerGlobalScope>(m_globalScope)) {
initScriptWithSubclass<JSSharedWorkerGlobalScopePrototype, JSSharedWorkerGlobalScope, SharedWorkerGlobalScope>();
return;
}
#if ENABLE(SERVICE_WORKER)
if (is<ServiceWorkerGlobalScope>(m_globalScope)) {
initScriptWithSubclass<JSServiceWorkerGlobalScopePrototype, JSServiceWorkerGlobalScope, ServiceWorkerGlobalScope>();
return;
}
#endif
#if ENABLE(CSS_PAINTING_API)
if (is<PaintWorkletGlobalScope>(m_globalScope)) {
initScriptWithSubclass<JSPaintWorkletGlobalScopePrototype, JSPaintWorkletGlobalScope, PaintWorkletGlobalScope>();
return;
}
#endif
#if ENABLE(WEB_AUDIO)
if (is<AudioWorkletGlobalScope>(m_globalScope)) {
initScriptWithSubclass<JSAudioWorkletGlobalScopePrototype, JSAudioWorkletGlobalScope, AudioWorkletGlobalScope>();
return;
}
#endif
ASSERT_NOT_REACHED();
}
} // namespace WebCore