Changeset 189941 in webkit for trunk/Source/JavaScriptCore/runtime/Completion.cpp

Timestamp:

Sep 17, 2015, 3:26:18 PM (10 years ago)

Author:

Yusuke Suzuki

Message:

[ES6] Add more fine-grained APIs and additional hooks to control module loader from WebCore
​https://bugs.webkit.org/show_bug.cgi?id=149129

Reviewed by Saam Barati.

No behavior change.

Source/JavaScriptCore:

Module tag <script type="module> will be executed asynchronously.
But we would like to fetch the resources before when the postTask-ed task is performed.
So instead of 1 API that fetch, instantiate and execute the module,
we need 2 fine-grained APIs.

1. Fetch and initialize a module, but not execute it yet.
2. Link and execute a module specified by the key (this will be invoked asynchronously).

And to instrument the script execution (like reporting the execution time of the module to
the inspector), we need a hook to inject code around an execution of a module body.

• builtins/ModuleLoaderObject.js:

(moduleEvaluation):
(loadAndEvaluateModule):
(loadModule):
(linkAndEvaluateModule):

• jsc.cpp:

(functionLoadModule):
(runWithScripts):

• runtime/Completion.cpp:

(JSC::identifierToJSValue):
(JSC::createSymbolForEntryPointModule):
(JSC::rejectPromise):
(JSC::loadAndEvaluateModule):
(JSC::loadModule):
(JSC::linkAndEvaluateModule):
(JSC::evaluateModule): Deleted.

• runtime/Completion.h:
• runtime/JSGlobalObject.cpp:
• runtime/JSGlobalObject.h:
• runtime/JSModuleRecord.cpp:

(JSC::JSModuleRecord::evaluate):
(JSC::JSModuleRecord::execute): Deleted.

• runtime/JSModuleRecord.h:
• runtime/ModuleLoaderObject.cpp:

(JSC::ModuleLoaderObject::loadAndEvaluateModule):
(JSC::ModuleLoaderObject::linkAndEvaluateModule):
(JSC::ModuleLoaderObject::evaluate):
(JSC::moduleLoaderObjectEvaluate):

• runtime/ModuleLoaderObject.h:

Source/WebCore:

• bindings/js/JSDOMWindowBase.cpp:
• bindings/js/JSWorkerGlobalScopeBase.cpp:

File:

• trunk/Source/JavaScriptCore/runtime/Completion.cpp (modified) (1 diff)

trunk/Source/JavaScriptCore/runtime/Completion.cpp

@@ -114 +114 @@
 }
 
-static JSInternalPromise* evaluateModule(const JSLockHolder&, ExecState* exec, JSGlobalObject* globalObject, JSValue moduleName, JSValue referrer)
-{
-    return globalObject->moduleLoader()->loadModule(exec, moduleName, referrer);
-}
-
-static JSInternalPromise* evaluateModule(const JSLockHolder& lock, ExecState* exec, JSGlobalObject* globalObject, const Identifier& moduleName)
-{
-    JSValue moduleNameValue;
-    if (moduleName.isSymbol())
-        moduleNameValue = Symbol::create(exec->vm(), static_cast<SymbolImpl&>(*moduleName.impl()));
-    else
-        moduleNameValue = jsString(&exec->vm(), moduleName.impl());
-
-    return evaluateModule(lock, exec, globalObject, moduleNameValue, jsUndefined());
-}
-
-JSInternalPromise* evaluateModule(ExecState* exec, const SourceCode& source)
-{
-    JSLockHolder lock(exec);
-    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
-    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
-
-    JSGlobalObject* globalObject = exec->vmEntryGlobalObject();
-
+static JSValue identifierToJSValue(VM& vm, const Identifier& identifier)
+{
+    if (identifier.isSymbol())
+        return Symbol::create(vm, static_cast<SymbolImpl&>(*identifier.impl()));
+    return jsString(&vm, identifier.impl());
+}
+
+static Symbol* createSymbolForEntryPointModule(VM& vm)
+{
     // Generate the unique key for the source-provided module.
     PrivateName privateName(PrivateName::Description, "EntryPointModule");
-    Symbol* key = Symbol::create(exec->vm(), *privateName.uid());
+    return Symbol::create(vm, *privateName.uid());
+}
+
+static JSInternalPromise* rejectPromise(ExecState* exec, JSGlobalObject* globalObject)
+{
+    ASSERT(exec->hadException());
+    JSValue exception = exec->exception()->value();
+    exec->clearException();
+    JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
+    deferred->reject(exec, exception);
+    return deferred->promise();
+}
+
+static JSInternalPromise* loadAndEvaluateModule(const JSLockHolder&, ExecState* exec, JSGlobalObject* globalObject, JSValue moduleName, JSValue referrer)
+{
+    return globalObject->moduleLoader()->loadAndEvaluateModule(exec, moduleName, referrer);
+}
+
+static JSInternalPromise* loadAndEvaluateModule(const JSLockHolder& lock, ExecState* exec, JSGlobalObject* globalObject, const Identifier& moduleName)
+{
+    return loadAndEvaluateModule(lock, exec, globalObject, identifierToJSValue(exec->vm(), moduleName), jsUndefined());
+}
+
+JSInternalPromise* loadAndEvaluateModule(ExecState* exec, const String& moduleName)
+{
+    JSLockHolder lock(exec);
+    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
+    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+
+    return loadAndEvaluateModule(lock, exec, exec->vmEntryGlobalObject(), Identifier::fromString(exec, moduleName));
+}
+
+JSInternalPromise* loadAndEvaluateModule(ExecState* exec, const SourceCode& source)
+{
+    JSLockHolder lock(exec);
+    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
+    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+
+    Symbol* key = createSymbolForEntryPointModule(exec->vm());
+
+    JSGlobalObject* globalObject = exec->vmEntryGlobalObject();
 
     // Insert the given source code to the ModuleLoader registry as the fetched registry entry.
     globalObject->moduleLoader()->provide(exec, key, ModuleLoaderObject::Status::Fetch, source.toString());
-    if (exec->hadException()) {
-        JSValue exception = exec->exception()->value();
-        exec->clearException();
-        JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::create(exec, globalObject);
-        deferred->reject(exec, exception);
-        return deferred->promise();
-    }
-
-    return evaluateModule(lock, exec, globalObject, key, jsUndefined());
-}
-
-JSInternalPromise* evaluateModule(ExecState* exec, const Identifier& moduleName)
-{
-    JSLockHolder lock(exec);
-    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
-    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
-
-    return evaluateModule(lock, exec, exec->vmEntryGlobalObject(), moduleName);
-}
-
-JSInternalPromise* evaluateModule(ExecState* exec, const String& moduleName)
-{
-    JSLockHolder lock(exec);
-    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
-    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
-
-    return evaluateModule(lock, exec, exec->vmEntryGlobalObject(), Identifier::fromString(exec, moduleName));
+    if (exec->hadException())
+        return rejectPromise(exec, globalObject);
+
+    return loadAndEvaluateModule(lock, exec, globalObject, key, jsUndefined());
+}
+
+static JSInternalPromise* loadModule(const JSLockHolder&, ExecState* exec, JSGlobalObject* globalObject, JSValue moduleName, JSValue referrer)
+{
+    return globalObject->moduleLoader()->loadModule(exec, moduleName, referrer);
+}
+
+static JSInternalPromise* loadModule(const JSLockHolder& lock, ExecState* exec, JSGlobalObject* globalObject, const Identifier& moduleName)
+{
+    return loadModule(lock, exec, globalObject, identifierToJSValue(exec->vm(), moduleName), jsUndefined());
+}
+
+JSInternalPromise* loadModule(ExecState* exec, const String& moduleName)
+{
+    JSLockHolder lock(exec);
+    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
+    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+
+    return loadModule(lock, exec, exec->vmEntryGlobalObject(), Identifier::fromString(exec, moduleName));
+}
+
+JSInternalPromise* loadModule(ExecState* exec, const SourceCode& source)
+{
+    JSLockHolder lock(exec);
+    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
+    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+
+    Symbol* key = createSymbolForEntryPointModule(exec->vm());
+
+    JSGlobalObject* globalObject = exec->vmEntryGlobalObject();
+
+    // Insert the given source code to the ModuleLoader registry as the fetched registry entry.
+    globalObject->moduleLoader()->provide(exec, key, ModuleLoaderObject::Status::Fetch, source.toString());
+    if (exec->hadException())
+        return rejectPromise(exec, globalObject);
+
+    return loadModule(lock, exec, globalObject, key, jsUndefined());
+}
+
+JSInternalPromise* linkAndEvaluateModule(ExecState* exec, const Identifier& moduleKey)
+{
+    JSLockHolder lock(exec);
+    RELEASE_ASSERT(exec->vm().atomicStringTable() == wtfThreadData().atomicStringTable());
+    RELEASE_ASSERT(!exec->vm().isCollectorBusy());
+
+    JSGlobalObject* globalObject = exec->vmEntryGlobalObject();
+    return globalObject->moduleLoader()->linkAndEvaluateModule(exec, identifierToJSValue(exec->vm(), moduleKey));
 }