Changeset 251691 in webkit


Ignore:
Timestamp:
Oct 28, 2019 6:37:12 PM (4 years ago)
Author:
ysuzuki@apple.com
Message:

[JSC] Remove JSPromiseDeferred
​https://bugs.webkit.org/show_bug.cgi?id=203400

Reviewed by Keith Miller.

Source/JavaScriptCore:

This patch optimizes the existing Promise usage in C++. We remove JSPromiseDeferred and JSInternalPromiseDeferred, use JSPromise and JSInternalPromise directly.
JSC now offers first resolve and reject operations to JSPromise without separating resolve and reject function from JSPromise. Then, we do not need
to have a tuple of these functions and promise, and we can just use JSPromise::resolve and JSPromise::reject. This removes unnecessary function allocations
and cell allocation for JSPromiseDeferred and makes API simple.

  • API/JSAPIGlobalObject.mm:

(JSC::JSAPIGlobalObject::moduleLoaderImportModule):
(JSC::JSAPIGlobalObject::moduleLoaderFetch):
(JSC::JSAPIGlobalObject::loadAndEvaluateJSScriptModule):

  • API/JSObjectRef.cpp:

(JSObjectMakeDeferredPromise):

  • CMakeLists.txt:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Sources.txt:
  • jsc.cpp:

(GlobalObject::moduleLoaderImportModule):
(GlobalObject::moduleLoaderFetch):
(runJSC):

  • runtime/Completion.cpp:

(JSC::rejectPromise):

  • runtime/JSGlobalObject.cpp:

(JSC::JSGlobalObject::init):
(JSC::JSGlobalObject::visitChildren):

  • runtime/JSGlobalObject.h:

(JSC::JSGlobalObject::newPromiseCapabilityFunction const):
(JSC::JSGlobalObject::resolvePromiseFunction const):
(JSC::JSGlobalObject::rejectPromiseFunction const):
(JSC::JSGlobalObject::numberProtoToStringFunction const):

  • runtime/JSGlobalObjectFunctions.cpp:

(JSC::globalFuncImportModule):

  • runtime/JSInternalPromise.h:
  • runtime/JSInternalPromiseDeferred.cpp: Removed.
  • runtime/JSInternalPromiseDeferred.h: Removed.
  • runtime/JSModuleLoader.cpp:

(JSC::JSModuleLoader::importModule):
(JSC::JSModuleLoader::resolve):
(JSC::JSModuleLoader::fetch):
(JSC::moduleLoaderParseModule):

  • runtime/JSPromise.cpp:

(JSC::JSPromise::flags const):
(JSC::JSPromise::isHandled const):
(JSC::JSPromise::createDeferredData):
(JSC::JSPromise::resolvedPromise):
(JSC::callFunction):
(JSC::JSPromise::resolve):
(JSC::JSPromise::reject):

  • runtime/JSPromise.h:
  • runtime/JSPromiseDeferred.cpp: Removed.
  • runtime/JSPromiseDeferred.h: Removed.
  • runtime/PromiseTimer.cpp: Renamed from Source/JavaScriptCore/runtime/PromiseDeferredTimer.cpp.

(JSC::PromiseTimer::PromiseTimer):
(JSC::PromiseTimer::doWork):
(JSC::PromiseTimer::runRunLoop):
(JSC::PromiseTimer::addPendingPromise):
(JSC::PromiseTimer::hasPendingPromise):
(JSC::PromiseTimer::hasDependancyInPendingPromise):
(JSC::PromiseTimer::cancelPendingPromise):
(JSC::PromiseTimer::scheduleWorkSoon):

  • runtime/PromiseTimer.h: Renamed from Source/JavaScriptCore/runtime/PromiseDeferredTimer.h.

(JSC::PromiseTimer::create):

  • runtime/StringRecursionChecker.h:
  • runtime/VM.cpp:

(JSC::VM::VM):
(JSC::VM::~VM):

  • runtime/VM.h:
  • wasm/js/JSWebAssembly.cpp:

(JSC::reject):
(JSC::webAssemblyModuleValidateAsyncInternal):
(JSC::webAssemblyCompileFunc):
(JSC::resolve):
(JSC::JSWebAssembly::webAssemblyModuleValidateAsync):
(JSC::instantiate):
(JSC::compileAndInstantiate):
(JSC::JSWebAssembly::instantiate):
(JSC::webAssemblyModuleInstantinateAsyncInternal):
(JSC::JSWebAssembly::webAssemblyModuleInstantinateAsync):
(JSC::webAssemblyInstantiateFunc):
(JSC::webAssemblyCompileStreamingInternal):
(JSC::webAssemblyInstantiateStreamingInternal):

  • wasm/js/JSWebAssembly.h:
  • wasm/js/JSWebAssemblyCodeBlock.h:

Source/WebCore:

This patch removes PromiseExecutionScope. This assumed that promise operation cannot fail in main thread. But this is
wrong since any JS call can fail due to stack-overflow error. This patch makes things more robust by handling errors correctly.
And we remove JSPromiseDeferred and use JSPromise instead.

  • bindings/js/JSCustomElementRegistryCustom.cpp:

(WebCore::whenDefinedPromise):
(WebCore::JSCustomElementRegistry::whenDefined):

  • bindings/js/JSDOMConvertPromise.h:

(WebCore::Converter<IDLPromise<T>>::convert):

  • bindings/js/JSDOMGlobalObject.cpp:
  • bindings/js/JSDOMOperationReturningPromise.h:

(WebCore::IDLOperationReturningPromise::call):
(WebCore::IDLOperationReturningPromise::callStatic):

  • bindings/js/JSDOMPromiseDeferred.cpp:

(WebCore::DeferredPromise::promise const):
(WebCore::DeferredPromise::callFunction):
(WebCore::DeferredPromise::whenSettled):
(WebCore::rejectPromiseWithExceptionIfAny):
(WebCore::createDeferredPromise):

  • bindings/js/JSDOMPromiseDeferred.h:

(WebCore::DeferredPromise::create):
(WebCore::DeferredPromise::DeferredPromise):
(WebCore::DeferredPromise::deferred const):
(WebCore::DeferredPromise::resolve):
(WebCore::DeferredPromise::reject):
(WebCore::DOMPromiseDeferredBase::DOMPromiseDeferredBase):
(WebCore::DOMPromiseDeferredBase::operator=):
(WebCore::DOMPromiseDeferredBase::reject):
(WebCore::DOMPromiseDeferredBase::rejectType):
(WebCore::DOMPromiseDeferredBase::promise const):
(WebCore::DOMPromiseDeferredBase::whenSettled):
(WebCore::DOMPromiseDeferred::resolve):
(WebCore::DOMPromiseDeferred<void>::resolve):
(WebCore::callPromiseFunction):

  • bindings/js/JSDOMWindowBase.cpp:

(WebCore::JSDOMWindowBase::moduleLoaderFetch):
(WebCore::JSDOMWindowBase::moduleLoaderImportModule):
(WebCore::tryAllocate):
(WebCore::isResponseCorrect):
(WebCore::handleResponseOnStreamingAction):
(WebCore::JSDOMWindowBase::compileStreaming):
(WebCore::JSDOMWindowBase::instantiateStreaming):

  • bindings/js/JSDOMWindowBase.h:
  • bindings/js/ScriptModuleLoader.cpp:

(WebCore::ScriptModuleLoader::fetch):
(WebCore::rejectPromise):

  • bindings/js/WorkerScriptController.cpp:

(WebCore::WorkerScriptController::addTimerSetNotification):
(WebCore::WorkerScriptController::removeTimerSetNotification):

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateOperationTrampolineDefinition):

  • bindings/scripts/test/JS/JSTestGlobalObject.cpp:

(WebCore::jsTestGlobalObjectInstanceFunctionCalculateSecretResult):

  • bindings/scripts/test/JS/JSTestNode.cpp:

(WebCore::jsTestNodePrototypeFunctionTestWorkerPromise):
(WebCore::jsTestNodePrototypeFunctionCalculateSecretResult):

  • bindings/scripts/test/JS/JSTestObj.cpp:

(WebCore::jsTestObjPrototypeFunctionCalculateSecretResult):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunction):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithException):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument):
(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction):
(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunction):
(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException):
(WebCore::jsTestObjPrototypeFunctionTestCustomPromiseFunction):
(WebCore::jsTestObjConstructorFunctionTestStaticCustomPromiseFunction):

  • workers/WorkerRunLoop.cpp:
  • worklets/WorkletScriptController.cpp:

LayoutTests:

  • js/dom/promise-stack-overflow-expected.txt: Added.
  • js/dom/promise-stack-overflow.html: Added.
Location:
trunk
Files:
2 added
4 deleted
38 edited
2 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r251689 r251691  
     12019-10-28  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Remove JSPromiseDeferred
     4        https://bugs.webkit.org/show_bug.cgi?id=203400
     5
     6        Reviewed by Keith Miller.
     7
     8        * js/dom/promise-stack-overflow-expected.txt: Added.
     9        * js/dom/promise-stack-overflow.html: Added.
     10
    1112019-10-28  Simon Fraser  <simon.fraser@apple.com>
    212

  • trunk/Source/JavaScriptCore/API/JSAPIGlobalObject.mm

    r251584 r251691  
    3737#import "JSContextInternal.h"
    3838#import "JSInternalPromise.h"
    39 #import "JSInternalPromiseDeferred.h"
    4039#import "JSModuleLoader.h"
    4140#import "JSNativeStdFunction.h"
    42 #import "JSPromiseDeferred.h"
     41#import "JSPromise.h"
    4342#import "JSScriptInternal.h"
    4443#import "JSSourceCode.h"
    … …  
    130129    auto reject = [&] (JSValue exception) -> JSInternalPromise* {
    131130        scope.clearException();
    132         auto* promise = JSInternalPromiseDeferred::tryCreate(globalObject);
    133         scope.clearException();
    134         return promise->reject(globalObject, exception);
     131        auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
     132        // FIXME: We could have error since any JS call can throw stack-overflow errors.
     133        // https://bugs.webkit.org/show_bug.cgi?id=203402
     134        promise->reject(globalObject, exception);
     135        scope.clearException();
     136        return promise;
    135137    };
    136138
    … …  
    165167    JSContext *context = [JSContext contextWithJSGlobalContextRef:toGlobalRef(globalObject)];
    166168
    167     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    168     RETURN_IF_EXCEPTION(scope, nullptr);
     169    JSInternalPromise* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    169170
    170171    Identifier moduleKey = key.toPropertyKey(globalObject);
    … …  
    172173        JSValue exception = scope.exception();
    173174        scope.clearException();
    174         return deferred->reject(globalObject, exception);
    175     }
    176 
    177     if (UNLIKELY(![context moduleLoaderDelegate]))
    178         return deferred->reject(globalObject, createError(globalObject, "No module loader provided."));
    179 
    180     auto deferredPromise = Strong<JSInternalPromiseDeferred>(vm, deferred);
     175        promise->reject(globalObject, exception);
     176        scope.clearException();
     177        return promise;
     178    }
     179
     180    if (UNLIKELY(![context moduleLoaderDelegate])) {
     181        promise->reject(globalObject, createError(globalObject, "No module loader provided."));
     182        return promise;
     183    }
     184
     185    auto strongPromise = Strong<JSInternalPromise>(vm, promise);
    181186    auto* resolve = JSNativeStdFunction::create(vm, globalObject, 1, "resolve", [=] (JSGlobalObject* globalObject, CallFrame* callFrame) {
    182187        // This captures the globalObject but that's ok because our structure keeps it alive anyway.
    … …  
    188193
    189194        auto rejectPromise = [&] (String message) {
    190             args.append(createTypeError(globalObject, message));
    191             call(globalObject, deferredPromise->JSPromiseDeferred::reject(), args, "This should never be seen...");
     195            strongPromise.get()->reject(globalObject, createTypeError(globalObject, message));
    192196            return encodedJSUndefined();
    193197        };
    … …  
    207211            return rejectPromise(makeString("The same JSScript was provided for two different identifiers, previously: ", oldModuleKey, " and now: ", moduleKey.string()));
    208212
    209         args.append(source);
    210         call(globalObject, deferredPromise->JSPromiseDeferred::resolve(), args, "This should never be seen...");
     213        strongPromise.get()->resolve(globalObject, source);
    211214        return encodedJSUndefined();
    212215    });
    213216
    214217    auto* reject = JSNativeStdFunction::create(vm, globalObject, 1, "reject", [=] (JSGlobalObject*, CallFrame* callFrame) {
    215         MarkedArgumentBuffer args;
    216         args.append(callFrame->argument(0));
    217 
    218         call(globalObject, deferredPromise->JSPromiseDeferred::reject(), args, "This should never be seen...");
     218        strongPromise.get()->reject(globalObject, callFrame->argument(0));
    219219        return encodedJSUndefined();
    220220    });
    … …  
    222222    [[context moduleLoaderDelegate] context:context fetchModuleForIdentifier:[::JSValue valueWithJSValueRef:toRef(globalObject, key) inContext:context] withResolveHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, resolve) inContext:context] andRejectHandler:[::JSValue valueWithJSValueRef:toRef(globalObject, reject) inContext:context]];
    223223    if (context.exception) {
    224         deferred->reject(globalObject, toJS(globalObject, [context.exception JSValueRef]));
     224        promise->reject(globalObject, toJS(globalObject, [context.exception JSValueRef]));
    225225        context.exception = nil;
    226226    }
    227     return deferred->promise();
     227    return promise;
    228228}
    229229
    … …  
    278278    JSInternalPromise* promise = importModule(this, key, jsUndefined(), jsUndefined());
    279279    RETURN_IF_EXCEPTION(scope, { });
    280     auto result = JSPromiseDeferred::tryCreate(this);
     280    auto* result = JSPromise::create(vm, this->promiseStructure());
     281    result->resolve(this, promise);
    281282    RETURN_IF_EXCEPTION(scope, { });
    282     result->resolve(this, promise);
    283     return result->promise();
     283    return result;
    284284}
    285285

  • trunk/Source/JavaScriptCore/API/JSObjectRef.cpp

    r251425 r251691  
    4848#include "JSObject.h"
    4949#include "JSPromise.h"
    50 #include "JSPromiseDeferred.h"
    5150#include "JSRetainPtr.h"
    5251#include "JSString.h"
    … …  
    290289    auto scope = DECLARE_CATCH_SCOPE(vm);
    291290
    292     JSPromiseDeferred::DeferredData data = JSPromiseDeferred::createDeferredData(globalObject, globalObject->promiseConstructor());
     291    JSPromise::DeferredData data = JSPromise::createDeferredData(globalObject, globalObject->promiseConstructor());
    293292    if (handleExceptionIfNeeded(scope, ctx, exception) == ExceptionStatus::DidThrow)
    294293        return nullptr;

  • trunk/Source/JavaScriptCore/CMakeLists.txt

    r251584 r251691  
    875875    runtime/JSInternalFieldObjectImpl.h
    876876    runtime/JSInternalPromise.h
    877     runtime/JSInternalPromiseDeferred.h
    878877    runtime/JSMicrotask.h
    879878    runtime/JSLock.h
    … …  
    889888    runtime/JSPromise.h
    890889    runtime/JSPromiseConstructor.h
    891     runtime/JSPromiseDeferred.h
    892890    runtime/JSPropertyNameEnumerator.h
    893891    runtime/JSProxy.h
    … …  
    932930    runtime/PrivateName.h
    933931    runtime/ProgramExecutable.h
    934     runtime/PromiseDeferredTimer.h
     932    runtime/PromiseTimer.h
    935933    runtime/PropertyDescriptor.h
    936934    runtime/PropertyMapHashTable.h

  • trunk/Source/JavaScriptCore/ChangeLog

    r251690 r251691  
     12019-10-28  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Remove JSPromiseDeferred
     4        https://bugs.webkit.org/show_bug.cgi?id=203400
     5
     6        Reviewed by Keith Miller.
     7
     8        This patch optimizes the existing Promise usage in C++. We remove JSPromiseDeferred and JSInternalPromiseDeferred, use JSPromise and JSInternalPromise directly.
     9        JSC now offers first `resolve` and `reject` operations to `JSPromise` without separating `resolve` and `reject` function from `JSPromise`. Then, we do not need
     10        to have a tuple of these functions and promise, and we can just use `JSPromise::resolve` and `JSPromise::reject`. This removes unnecessary function allocations
     11        and cell allocation for JSPromiseDeferred and makes API simple.
     12
     13        * API/JSAPIGlobalObject.mm:
     14        (JSC::JSAPIGlobalObject::moduleLoaderImportModule):
     15        (JSC::JSAPIGlobalObject::moduleLoaderFetch):
     16        (JSC::JSAPIGlobalObject::loadAndEvaluateJSScriptModule):
     17        * API/JSObjectRef.cpp:
     18        (JSObjectMakeDeferredPromise):
     19        * CMakeLists.txt:
     20        * JavaScriptCore.xcodeproj/project.pbxproj:
     21        * Sources.txt:
     22        * jsc.cpp:
     23        (GlobalObject::moduleLoaderImportModule):
     24        (GlobalObject::moduleLoaderFetch):
     25        (runJSC):
     26        * runtime/Completion.cpp:
     27        (JSC::rejectPromise):
     28        * runtime/JSGlobalObject.cpp:
     29        (JSC::JSGlobalObject::init):
     30        (JSC::JSGlobalObject::visitChildren):
     31        * runtime/JSGlobalObject.h:
     32        (JSC::JSGlobalObject::newPromiseCapabilityFunction const):
     33        (JSC::JSGlobalObject::resolvePromiseFunction const):
     34        (JSC::JSGlobalObject::rejectPromiseFunction const):
     35        (JSC::JSGlobalObject::numberProtoToStringFunction const):
     36        * runtime/JSGlobalObjectFunctions.cpp:
     37        (JSC::globalFuncImportModule):
     38        * runtime/JSInternalPromise.h:
     39        * runtime/JSInternalPromiseDeferred.cpp: Removed.
     40        * runtime/JSInternalPromiseDeferred.h: Removed.
     41        * runtime/JSModuleLoader.cpp:
     42        (JSC::JSModuleLoader::importModule):
     43        (JSC::JSModuleLoader::resolve):
     44        (JSC::JSModuleLoader::fetch):
     45        (JSC::moduleLoaderParseModule):
     46        * runtime/JSPromise.cpp:
     47        (JSC::JSPromise::flags const):
     48        (JSC::JSPromise::isHandled const):
     49        (JSC::JSPromise::createDeferredData):
     50        (JSC::JSPromise::resolvedPromise):
     51        (JSC::callFunction):
     52        (JSC::JSPromise::resolve):
     53        (JSC::JSPromise::reject):
     54        * runtime/JSPromise.h:
     55        * runtime/JSPromiseDeferred.cpp: Removed.
     56        * runtime/JSPromiseDeferred.h: Removed.
     57        * runtime/PromiseTimer.cpp: Renamed from Source/JavaScriptCore/runtime/PromiseDeferredTimer.cpp.
     58        (JSC::PromiseTimer::PromiseTimer):
     59        (JSC::PromiseTimer::doWork):
     60        (JSC::PromiseTimer::runRunLoop):
     61        (JSC::PromiseTimer::addPendingPromise):
     62        (JSC::PromiseTimer::hasPendingPromise):
     63        (JSC::PromiseTimer::hasDependancyInPendingPromise):
     64        (JSC::PromiseTimer::cancelPendingPromise):
     65        (JSC::PromiseTimer::scheduleWorkSoon):
     66        * runtime/PromiseTimer.h: Renamed from Source/JavaScriptCore/runtime/PromiseDeferredTimer.h.
     67        (JSC::PromiseTimer::create):
     68        * runtime/StringRecursionChecker.h:
     69        * runtime/VM.cpp:
     70        (JSC::VM::VM):
     71        (JSC::VM::~VM):
     72        * runtime/VM.h:
     73        * wasm/js/JSWebAssembly.cpp:
     74        (JSC::reject):
     75        (JSC::webAssemblyModuleValidateAsyncInternal):
     76        (JSC::webAssemblyCompileFunc):
     77        (JSC::resolve):
     78        (JSC::JSWebAssembly::webAssemblyModuleValidateAsync):
     79        (JSC::instantiate):
     80        (JSC::compileAndInstantiate):
     81        (JSC::JSWebAssembly::instantiate):
     82        (JSC::webAssemblyModuleInstantinateAsyncInternal):
     83        (JSC::JSWebAssembly::webAssemblyModuleInstantinateAsync):
     84        (JSC::webAssemblyInstantiateFunc):
     85        (JSC::webAssemblyCompileStreamingInternal):
     86        (JSC::webAssemblyInstantiateStreamingInternal):
     87        * wasm/js/JSWebAssembly.h:
     88        * wasm/js/JSWebAssemblyCodeBlock.h:
     89
    1902019-10-28  Adrian Perez de Castro  <aperez@igalia.com>
    291

  • trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

    r251584 r251691  
    933933                5341FC721DAC343C00E7E4D7 /* B3WasmBoundsCheckValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 5341FC711DAC343C00E7E4D7 /* B3WasmBoundsCheckValue.h */; };
    934934                534638711E70CF3D00F12AC1 /* JSRunLoopTimer.h in Headers */ = {isa = PBXBuildFile; fileRef = 534638701E70CF3D00F12AC1 /* JSRunLoopTimer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    935                 534638751E70DDEC00F12AC1 /* PromiseDeferredTimer.h in Headers */ = {isa = PBXBuildFile; fileRef = 534638741E70DDEC00F12AC1 /* PromiseDeferredTimer.h */; settings = {ATTRIBUTES = (Private, ); }; };
     935                534638751E70DDEC00F12AC1 /* PromiseTimer.h in Headers */ = {isa = PBXBuildFile; fileRef = 534638741E70DDEC00F12AC1 /* PromiseTimer.h */; settings = {ATTRIBUTES = (Private, ); }; };
    936936                53486BB71C1795C300F6F3AF /* JSTypedArray.h in Headers */ = {isa = PBXBuildFile; fileRef = 53486BB61C1795C300F6F3AF /* JSTypedArray.h */; settings = {ATTRIBUTES = (Public, ); }; };
    937937                534902851C7276B70012BCB8 /* TypedArrayCTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 534902821C7242C80012BCB8 /* TypedArrayCTest.cpp */; };
    … …  
    12191219                7A9774A8206B82E4008D03D0 /* JSWeakValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 7A9774A7206B82C9008D03D0 /* JSWeakValue.h */; settings = {ATTRIBUTES = (Private, ); }; };
    12201220                7BC547D31B6959A100959B58 /* WasmFormat.h in Headers */ = {isa = PBXBuildFile; fileRef = 7BC547D21B69599B00959B58 /* WasmFormat.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1221                 7C008CDB187124BB00955C24 /* JSPromiseDeferred.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C008CD9187124BB00955C24 /* JSPromiseDeferred.h */; settings = {ATTRIBUTES = (Private, ); }; };
    12221221                7C008CE7187631B600955C24 /* Microtask.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C008CE5187631B600955C24 /* Microtask.h */; settings = {ATTRIBUTES = (Private, ); }; };
    12231222                7C184E1B17BEDBD3007CB63A /* JSPromise.h in Headers */ = {isa = PBXBuildFile; fileRef = 7C184E1917BEDBD3007CB63A /* JSPromise.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    17991798                E33F50791B84225700413856 /* JSInternalPromiseConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = E33F50771B84225700413856 /* JSInternalPromiseConstructor.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18001799                E33F50811B8429A400413856 /* JSInternalPromise.h in Headers */ = {isa = PBXBuildFile; fileRef = E33F507F1B8429A400413856 /* JSInternalPromise.h */; settings = {ATTRIBUTES = (Private, ); }; };
    1801                 E33F50851B8437A000413856 /* JSInternalPromiseDeferred.h in Headers */ = {isa = PBXBuildFile; fileRef = E33F50831B8437A000413856 /* JSInternalPromiseDeferred.h */; settings = {ATTRIBUTES = (Private, ); }; };
    18021800                E33F50871B8449EF00413856 /* JSInternalPromiseConstructor.lut.h in Headers */ = {isa = PBXBuildFile; fileRef = E33F50861B8449EF00413856 /* JSInternalPromiseConstructor.lut.h */; };
    18031801                E3400EC122A1CC7B009DED54 /* FunctionExecutableInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = E3400EC022A1CC78009DED54 /* FunctionExecutableInlines.h */; };
    … …  
    35893587                534638701E70CF3D00F12AC1 /* JSRunLoopTimer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSRunLoopTimer.h; sourceTree = "<group>"; };
    35903588                534638721E70D01500F12AC1 /* JSRunLoopTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSRunLoopTimer.cpp; sourceTree = "<group>"; };
    3591                 534638741E70DDEC00F12AC1 /* PromiseDeferredTimer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PromiseDeferredTimer.h; sourceTree = "<group>"; };
    3592                 534638761E71E06E00F12AC1 /* PromiseDeferredTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PromiseDeferredTimer.cpp; sourceTree = "<group>"; };
     3589                534638741E70DDEC00F12AC1 /* PromiseTimer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PromiseTimer.h; sourceTree = "<group>"; };
     3590                534638761E71E06E00F12AC1 /* PromiseTimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PromiseTimer.cpp; sourceTree = "<group>"; };
    35933591                53486BB61C1795C300F6F3AF /* JSTypedArray.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTypedArray.h; sourceTree = "<group>"; };
    35943592                53486BBA1C18E84500F6F3AF /* JSTypedArray.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSTypedArray.cpp; sourceTree = "<group>"; };
    … …  
    40114009                7A9774A7206B82C9008D03D0 /* JSWeakValue.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSWeakValue.h; sourceTree = "<group>"; };
    40124010                7BC547D21B69599B00959B58 /* WasmFormat.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmFormat.h; sourceTree = "<group>"; };
    4013                 7C008CD8187124BB00955C24 /* JSPromiseDeferred.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPromiseDeferred.cpp; sourceTree = "<group>"; };
    4014                 7C008CD9187124BB00955C24 /* JSPromiseDeferred.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSPromiseDeferred.h; sourceTree = "<group>"; };
    40154011                7C008CE5187631B600955C24 /* Microtask.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Microtask.h; sourceTree = "<group>"; };
    40164012                7C184E1817BEDBD3007CB63A /* JSPromise.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSPromise.cpp; sourceTree = "<group>"; };
    … …  
    49034899                E33F507E1B8429A400413856 /* JSInternalPromise.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSInternalPromise.cpp; sourceTree = "<group>"; };
    49044900                E33F507F1B8429A400413856 /* JSInternalPromise.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSInternalPromise.h; sourceTree = "<group>"; };
    4905                 E33F50821B8437A000413856 /* JSInternalPromiseDeferred.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSInternalPromiseDeferred.cpp; sourceTree = "<group>"; };
    4906                 E33F50831B8437A000413856 /* JSInternalPromiseDeferred.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSInternalPromiseDeferred.h; sourceTree = "<group>"; };
    49074901                E33F50861B8449EF00413856 /* JSInternalPromiseConstructor.lut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSInternalPromiseConstructor.lut.h; sourceTree = "<group>"; };
    49084902                E33F50881B844A1A00413856 /* InternalPromiseConstructor.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = InternalPromiseConstructor.js; sourceTree = "<group>"; };
    … …  
    70897083                                14788EE521501B2900A561C8 /* GetPutInfo.cpp */,
    70907084                                796465681B952FF0003059EE /* GetPutInfo.h */,
    7091                                 FE1D6D6E236258FE007A5C26 /* GetVM.h */,
    70927085                                BC02E9B80E184545000F9297 /* GetterSetter.cpp */,
    70937086                                BC337BDE0E1AF0B80076918A /* GetterSetter.h */,
     7087                                FE1D6D6E236258FE007A5C26 /* GetVM.h */,
    70947088                                E355D38E2244686C008F1AD6 /* GlobalExecutable.cpp */,
    70957089                                E355D38D2244686B008F1AD6 /* GlobalExecutable.h */,
    … …  
    72387232                                E33F50761B84225700413856 /* JSInternalPromiseConstructor.cpp */,
    72397233                                E33F50771B84225700413856 /* JSInternalPromiseConstructor.h */,
    7240                                 E33F50821B8437A000413856 /* JSInternalPromiseDeferred.cpp */,
    7241                                 E33F50831B8437A000413856 /* JSInternalPromiseDeferred.h */,
    72427234                                E33F50721B8421C000413856 /* JSInternalPromisePrototype.cpp */,
    72437235                                E33F50731B8421C000413856 /* JSInternalPromisePrototype.h */,
    … …  
    72737265                                7C184E2017BEE240007CB63A /* JSPromiseConstructor.cpp */,
    72747266                                7C184E2117BEE240007CB63A /* JSPromiseConstructor.h */,
    7275                                 7C008CD8187124BB00955C24 /* JSPromiseDeferred.cpp */,
    7276                                 7C008CD9187124BB00955C24 /* JSPromiseDeferred.h */,
    72777267                                7C184E1C17BEE22E007CB63A /* JSPromisePrototype.cpp */,
    72787268                                7C184E1D17BEE22E007CB63A /* JSPromisePrototype.h */,
    … …  
    74067396                                147341DF1DC2CE9600AA29BA /* ProgramExecutable.cpp */,
    74077397                                147341D31DC02E6D00AA29BA /* ProgramExecutable.h */,
    7408                                 534638761E71E06E00F12AC1 /* PromiseDeferredTimer.cpp */,
    7409                                 534638741E70DDEC00F12AC1 /* PromiseDeferredTimer.h */,
     7398                                534638761E71E06E00F12AC1 /* PromiseTimer.cpp */,
     7399                                534638741E70DDEC00F12AC1 /* PromiseTimer.h */,
    74107400                                A7FB60A3103F7DC20017A286 /* PropertyDescriptor.cpp */,
    74117401                                A7FB604B103F5EAB0017A286 /* PropertyDescriptor.h */,
    … …  
    88518841                                BC18C3E70E16F5CD00B34460 /* ArrayPrototype.h in Headers */,
    88528842                                0FB7F39615ED8E4600F167B2 /* ArrayStorage.h in Headers */,
     8843                                FE1D6D7123625AB1007A5C26 /* ArrayStorageInlines.h in Headers */,
    88538844                                9688CB150ED12B4E001D649F /* AssemblerBuffer.h in Headers */,
    88548845                                86D3B2C510156BDE002865E7 /* AssemblerBufferWithConstantPool.h in Headers */,
    … …  
    88848875                                DCFDFBD91D1F5D9B00FE3D72 /* B3BottomProvider.h in Headers */,
    88858876                                0F6B8AE31C4EFE1700969052 /* B3BreakCriticalEdges.h in Headers */,
    8886                                 FE1D6D752362649F007A5C26 /* ProtoCallFrameInlines.h in Headers */,
    88878877                                DC9A0C201D2D9CB30085124E /* B3CaseCollection.h in Headers */,
    88888878                                DC9A0C1F1D2D9CB10085124E /* B3CaseCollectionInlines.h in Headers */,
    … …  
    89288918                                4319DA041C1BE40D001D260B /* B3LowerMacrosAfterOptimizations.h in Headers */,
    89298919                                0FEC851E1BDACDAC0080FF74 /* B3LowerToAir.h in Headers */,
    8930                                 FE1D6D6D2362544B007A5C26 /* RegisterInlines.h in Headers */,
    89318920                                43AB26C61C1A535900D82AE6 /* B3MathExtras.h in Headers */,
    89328921                                0FEC85201BDACDAC0080FF74 /* B3MemoryValue.h in Headers */,
    … …  
    94729461                                7964656A1B952FF0003059EE /* GetPutInfo.h in Headers */,
    94739462                                534E03581E53BF2F00213F64 /* GetterSetterAccessCase.h in Headers */,
     9463                                FE1D6D6F236258FE007A5C26 /* GetVM.h in Headers */,
    94749464                                0FEC3C5B1F33A48900F59B6C /* GigacageAlignedMemoryAllocator.h in Headers */,
    94759465                                14AD910E1DCA92940014F9FE /* GlobalCodeBlock.h in Headers */,
    … …  
    94939483                                C2DA778318E259990066FCB6 /* HeapInlines.h in Headers */,
    94949484                                2AD8932B17E3868F00668276 /* HeapIterationScope.h in Headers */,
    9495                                 FE1D6D7123625AB1007A5C26 /* ArrayStorageInlines.h in Headers */,
    94969485                                A5339EC91BB4B4600054F005 /* HeapObserver.h in Headers */,
    94979486                                A5398FAB1C750DA40060A963 /* HeapProfiler.h in Headers */,
    … …  
    97149703                                E33F50791B84225700413856 /* JSInternalPromiseConstructor.h in Headers */,
    97159704                                E33F50871B8449EF00413856 /* JSInternalPromiseConstructor.lut.h in Headers */,
    9716                                 E33F50851B8437A000413856 /* JSInternalPromiseDeferred.h in Headers */,
    97179705                                E33F50751B8421C000413856 /* JSInternalPromisePrototype.h in Headers */,
    97189706                                A503FA1E188E0FB000110F14 /* JSJavaScriptCallFramePrototype.h in Headers */,
    … …  
    97429730                                7C184E2317BEE240007CB63A /* JSPromiseConstructor.h in Headers */,
    97439731                                996B731E1BDA08EF00331B84 /* JSPromiseConstructor.lut.h in Headers */,
    9744                                 7C008CDB187124BB00955C24 /* JSPromiseDeferred.h in Headers */,
    97459732                                7C184E1F17BEE22E007CB63A /* JSPromisePrototype.h in Headers */,
    97469733                                996B731F1BDA08EF00331B84 /* JSPromisePrototype.lut.h in Headers */,
    … …  
    99699956                                14AD91101DCA92940014F9FE /* ProgramCodeBlock.h in Headers */,
    99709957                                147341D41DC02E6D00AA29BA /* ProgramExecutable.h in Headers */,
    9971                                 534638751E70DDEC00F12AC1 /* PromiseDeferredTimer.h in Headers */,
     9958                                534638751E70DDEC00F12AC1 /* PromiseTimer.h in Headers */,
    99729959                                0FD3E40E1B618B6600C80E1E /* PropertyCondition.h in Headers */,
    99739960                                A7FB61001040C38B0017A286 /* PropertyDescriptor.h in Headers */,
    … …  
    99799966                                0FB7F39C15ED8E4600F167B2 /* PropertyStorage.h in Headers */,
    99809967                                BC18C4560E16F5CD00B34460 /* Protect.h in Headers */,
     9968                                FE1D6D752362649F007A5C26 /* ProtoCallFrameInlines.h in Headers */,
    99819969                                0F74B93B1F89614800B935D3 /* PrototypeKey.h in Headers */,
    99829970                                534E03561E53BEDE00213F64 /* ProxyableAccessCase.h in Headers */,
    … …  
    100119999                                BC18C45D0E16F5CD00B34460 /* Register.h in Headers */,
    1001210000                                E328C6C91DA432F900D255FD /* RegisterAtOffset.h in Headers */,
    10013                                 FE1D6D6F236258FE007A5C26 /* GetVM.h in Headers */,
    1001410001                                E328C6C81DA4306100D255FD /* RegisterAtOffsetList.h in Headers */,
    1001510002                                969A072B0ED1CE6900F1F681 /* RegisterID.h in Headers */,
    1001610003                                9688CB160ED12B4E001D6499 /* RegisterInfo.h in Headers */,
     10004                                FE1D6D6D2362544B007A5C26 /* RegisterInlines.h in Headers */,
    1001710005                                623A37EC1B87A7C000754209 /* RegisterMap.h in Headers */,
    1001810006                                0FC314121814559100033232 /* RegisterSet.h in Headers */,

  • trunk/Source/JavaScriptCore/Sources.txt

    r251468 r251691  
    834834runtime/JSInternalPromise.cpp
    835835runtime/JSInternalPromiseConstructor.cpp
    836 runtime/JSInternalPromiseDeferred.cpp
    837836runtime/JSInternalPromisePrototype.cpp
    838837runtime/JSLexicalEnvironment.cpp
    … …  
    851850runtime/JSPromise.cpp
    852851runtime/JSPromiseConstructor.cpp
    853 runtime/JSPromiseDeferred.cpp
    854852runtime/JSPromisePrototype.cpp
    855853runtime/JSPropertyNameEnumerator.cpp
    … …  
    908906runtime/Options.cpp
    909907runtime/ProgramExecutable.cpp
    910 runtime/PromiseDeferredTimer.cpp
     908runtime/PromiseTimer.cpp
    911909runtime/PropertyDescriptor.cpp
    912910runtime/PropertySlot.cpp

  • trunk/Source/JavaScriptCore/jsc.cpp

    r251457 r251691  
    4848#include "JSFunction.h"
    4949#include "JSInternalPromise.h"
    50 #include "JSInternalPromiseDeferred.h"
    5150#include "JSLock.h"
    5251#include "JSModuleLoader.h"
    … …  
    6261#include "ParserError.h"
    6362#include "ProfilerDatabase.h"
    64 #include "PromiseDeferredTimer.h"
     63#include "PromiseTimer.h"
    6564#include "ProtoCallFrame.h"
    6665#include "ReleaseHeapAccessScope.h"
    … …  
    827826    auto throwScope = DECLARE_THROW_SCOPE(vm);
    828827
    829     auto* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    830     RETURN_IF_EXCEPTION(throwScope, nullptr);
     828    auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    831829
    832830    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    833831    auto reject = [&] (JSValue rejectionReason) {
    834832        catchScope.clearException();
    835         auto result = deferred->reject(globalObject, rejectionReason);
     833        promise->reject(globalObject, rejectionReason);
    836834        catchScope.clearException();
    837         return result;
     835        return promise;
    838836    };
    839837
    … …  
    11621160{
    11631161    VM& vm = globalObject->vm();
    1164     auto throwScope = DECLARE_THROW_SCOPE(vm);
    1165     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    1166     RETURN_IF_EXCEPTION(throwScope, nullptr);
     1162    JSInternalPromise* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    11671163
    11681164    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    11691165    auto reject = [&] (JSValue rejectionReason) {
    11701166        catchScope.clearException();
    1171         auto result = deferred->reject(globalObject, rejectionReason);
     1167        promise->reject(globalObject, rejectionReason);
    11721168        catchScope.clearException();
    1173         return result;
     1169        return promise;
    11741170    };
    11751171
    … …  
    11931189            auto sourceCode = JSSourceCode::create(vm, WTFMove(source));
    11941190            catchScope.releaseAssertNoException();
    1195             auto result = deferred->resolve(globalObject, sourceCode);
     1191            promise->resolve(globalObject, sourceCode);
    11961192            catchScope.clearException();
    1197             return result;
     1193            return promise;
    11981194        }
    11991195    }
    … …  
    12021198    auto sourceCode = JSSourceCode::create(vm, jscSource(stringFromUTF(buffer), SourceOrigin { moduleKey }, WTFMove(moduleURL), TextPosition(), SourceProviderSourceType::Module));
    12031199    catchScope.releaseAssertNoException();
    1204     auto result = deferred->resolve(globalObject, sourceCode);
     1200    promise->resolve(globalObject, sourceCode);
    12051201    catchScope.clearException();
    1206     return result;
     1202    return promise;
    12071203}
    12081204
    … …  
    30043000        vm.drainMicrotasks();
    30053001    }
    3006     vm.promiseDeferredTimer->runRunLoop();
     3002    vm.promiseTimer->runRunLoop();
    30073003    {
    30083004        JSLockHolder locker(vm);

  • trunk/Source/JavaScriptCore/runtime/Completion.cpp

    r251425 r251691  
    3535#include "JSGlobalObject.h"
    3636#include "JSInternalPromise.h"
    37 #include "JSInternalPromiseDeferred.h"
    3837#include "JSLock.h"
    3938#include "JSModuleLoader.h"
    … …  
    194193    JSValue exception = scope.exception()->value();
    195194    scope.clearException();
    196     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    197     scope.releaseAssertNoException();
    198     deferred->reject(globalObject, exception);
    199     scope.releaseAssertNoException();
    200     return deferred->promise();
     195    JSInternalPromise* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
     196    promise->reject(globalObject, exception);
     197    return promise;
    201198}
    202199

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.cpp

    r251671 r251691  
    544544        });
    545545
    546     m_newPromiseCapabilityFunction.set(vm, this, JSFunction::create(vm, promiseOperationsNewPromiseCapabilityCodeGenerator(vm), this));
    547546    m_functionProtoHasInstanceSymbolFunction.set(vm, this, hasInstanceSymbolFunction);
    548547    m_throwTypeErrorGetterSetter.initLater(
    … …  
    980979    JSObject* setIteratorPrototype = SetIteratorPrototype::create(vm, this, SetIteratorPrototype::createStructure(vm, this, m_iteratorPrototype.get()));
    981980    setIteratorConstructorPrivateFunction->putDirect(vm, vm.propertyNames->prototype, setIteratorPrototype);
     981
     982    m_newPromiseCapabilityFunction.set(vm, this, newPromiseCapabilityPrivateFunction);
     983    m_resolvePromiseFunction.set(vm, this, resolvePromisePrivateFunction);
     984    m_rejectPromiseFunction.set(vm, this, rejectPromisePrivateFunction);
    982985
    983986    GlobalPropertyInfo staticGlobals[] = {
    … …  
    17071710    thisObject->m_iteratorProtocolFunction.visit(visitor);
    17081711    thisObject->m_promiseResolveFunction.visit(visitor);
     1712    visitor.append(thisObject->m_newPromiseCapabilityFunction);
     1713    visitor.append(thisObject->m_resolvePromiseFunction);
     1714    visitor.append(thisObject->m_rejectPromiseFunction);
    17091715    visitor.append(thisObject->m_promiseProtoThenFunction);
    17101716    visitor.append(thisObject->m_objectProtoValueOfFunction);
    17111717    visitor.append(thisObject->m_numberProtoToStringFunction);
    1712     visitor.append(thisObject->m_newPromiseCapabilityFunction);
    17131718    visitor.append(thisObject->m_functionProtoHasInstanceSymbolFunction);
    17141719    thisObject->m_throwTypeErrorGetterSetter.visit(visitor);

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

    r251584 r251691  
    3434#include "JSClassRef.h"
    3535#include "JSGlobalLexicalEnvironment.h"
    36 #include "JSPromiseDeferred.h"
     36#include "JSPromise.h"
    3737#include "JSSegmentedVariableObject.h"
    3838#include "JSWeakObjectMapRefInternal.h"
    … …  
    227227    DefaultLanguageFunctionPtr defaultLanguage;
    228228
    229     typedef void (*CompileStreamingPtr)(JSGlobalObject*, JSPromiseDeferred*, JSValue);
     229    typedef void (*CompileStreamingPtr)(JSGlobalObject*, JSPromise*, JSValue);
    230230    CompileStreamingPtr compileStreaming;
    231231
    232     typedef void (*InstantiateStreamingPtr)(JSGlobalObject*, JSPromiseDeferred*, JSValue, JSObject*);
     232    typedef void (*InstantiateStreamingPtr)(JSGlobalObject*, JSPromise*, JSValue, JSObject*);
    233233    InstantiateStreamingPtr instantiateStreaming;
    234234};
    … …  
    306306    LazyProperty<JSGlobalObject, JSFunction> m_iteratorProtocolFunction;
    307307    LazyProperty<JSGlobalObject, JSFunction> m_promiseResolveFunction;
     308    WriteBarrier<JSFunction> m_newPromiseCapabilityFunction;
     309    WriteBarrier<JSFunction> m_resolvePromiseFunction;
     310    WriteBarrier<JSFunction> m_rejectPromiseFunction;
    308311    WriteBarrier<JSFunction> m_promiseProtoThenFunction;
    309312    WriteBarrier<JSFunction> m_objectProtoValueOfFunction;
    310313    WriteBarrier<JSFunction> m_numberProtoToStringFunction;
    311     WriteBarrier<JSFunction> m_newPromiseCapabilityFunction;
    312314    WriteBarrier<JSFunction> m_functionProtoHasInstanceSymbolFunction;
    313315    LazyProperty<JSGlobalObject, GetterSetter> m_throwTypeErrorGetterSetter;
    … …  
    621623    JSFunction* arrayProtoValuesFunction() const { return m_arrayProtoValuesFunction.get(this); }
    622624    JSFunction* iteratorProtocolFunction() const { return m_iteratorProtocolFunction.get(this); }
     625    JSFunction* newPromiseCapabilityFunction() const { return m_newPromiseCapabilityFunction.get(); }
    623626    JSFunction* promiseResolveFunction() const { return m_promiseResolveFunction.get(this); }
     627    JSFunction* resolvePromiseFunction() const { return m_resolvePromiseFunction.get(); }
     628    JSFunction* rejectPromiseFunction() const { return m_rejectPromiseFunction.get(); }
    624629    JSFunction* promiseProtoThenFunction() const { return m_promiseProtoThenFunction.get(); }
    625630    JSFunction* objectProtoValueOfFunction() const { return m_objectProtoValueOfFunction.get(); }
    626631    JSFunction* numberProtoToStringFunction() const { return m_numberProtoToStringFunction.get(); }
    627     JSFunction* newPromiseCapabilityFunction() const { return m_newPromiseCapabilityFunction.get(); }
    628632    JSFunction* functionProtoHasInstanceSymbolFunction() const { return m_functionProtoHasInstanceSymbolFunction.get(); }
    629633    JSObject* regExpProtoExecFunction() const { return m_regExpProtoExec.get(); }

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp

    r251457 r251691  
    4040#include "JSModuleLoader.h"
    4141#include "JSPromise.h"
    42 #include "JSPromiseDeferred.h"
    4342#include "JSString.h"
    4443#include "Lexer.h"
    … …  
    808807{
    809808    VM& vm = globalObject->vm();
    810     auto throwScope = DECLARE_THROW_SCOPE(vm);
    811 
    812     auto* promise = JSPromiseDeferred::tryCreate(globalObject);
    813     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
     809
     810    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    814811
    815812    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    818815        promise->reject(globalObject, rejectionReason);
    819816        catchScope.clearException();
    820         return JSValue::encode(promise->promise());
     817        return JSValue::encode(promise);
    821818    };
    822819
    … …  
    836833
    837834    catchScope.clearException();
    838     return JSValue::encode(promise->promise());
     835    return JSValue::encode(promise);
    839836}
    840837

  • trunk/Source/JavaScriptCore/runtime/JSInternalPromise.h

    r251425 r251691  
    4444    typedef JSPromise Base;
    4545
    46     static JSInternalPromise* create(VM&, Structure*);
     46    JS_EXPORT_PRIVATE static JSInternalPromise* create(VM&, Structure*);
    4747    static Structure* createStructure(VM&, JSGlobalObject*, JSValue);
    4848

  • trunk/Source/JavaScriptCore/runtime/JSModuleLoader.cpp

    r251425 r251691  
    3636#include "JSGlobalObjectFunctions.h"
    3737#include "JSInternalPromise.h"
    38 #include "JSInternalPromiseDeferred.h"
    3938#include "JSMap.h"
    4039#include "JSModuleEnvironment.h"
    … …  
    263262        RELEASE_AND_RETURN(throwScope, globalObject->globalObjectMethodTable()->moduleLoaderImportModule(globalObject, this, moduleName, parameters, referrer));
    264263
    265     auto* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    266     RETURN_IF_EXCEPTION(throwScope, nullptr);
     264    auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    267265
    268266    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    271269        JSValue exception = catchScope.exception()->value();
    272270        catchScope.clearException();
    273         deferred->reject(globalObject, exception);
    274         catchScope.clearException();
    275         return deferred->promise();
     271        promise->reject(globalObject, exception);
     272        catchScope.clearException();
     273        return promise;
    276274    }
    277     deferred->reject(globalObject, createError(globalObject, makeString("Could not import the module '", moduleNameString, "'.")));
     275    promise->reject(globalObject, createError(globalObject, makeString("Could not import the module '", moduleNameString, "'.")));
    278276    catchScope.clearException();
    279     return deferred->promise();
     277    return promise;
    280278}
    281279
    … …  
    293291{
    294292    VM& vm = globalObject->vm();
    295     auto throwScope = DECLARE_THROW_SCOPE(vm);
    296 
    297     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    298     RETURN_IF_EXCEPTION(throwScope, nullptr);
     293
     294    auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    299295
    300296    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    304300        JSValue exception = catchScope.exception();
    305301        catchScope.clearException();
    306         auto result = deferred->reject(globalObject, exception);
    307         catchScope.clearException();
    308         return result;
     302        promise->reject(globalObject, exception);
     303        catchScope.clearException();
     304        return promise;
    309305    }
    310     auto result = deferred->resolve(globalObject, identifierToJSValue(vm, moduleKey));
     306    promise->resolve(globalObject, identifierToJSValue(vm, moduleKey));
    311307    catchScope.clearException();
    312     return result;
     308    return promise;
    313309}
    314310
    … …  
    324320        RELEASE_AND_RETURN(throwScope, globalObject->globalObjectMethodTable()->moduleLoaderFetch(globalObject, this, key, parameters, scriptFetcher));
    325321
    326     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    327     RETURN_IF_EXCEPTION(throwScope, nullptr);
     322    auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    328323
    329324    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    333328        JSValue exception = catchScope.exception()->value();
    334329        catchScope.clearException();
    335         deferred->reject(globalObject, exception);
    336         catchScope.clearException();
    337         return deferred->promise();
     330        promise->reject(globalObject, exception);
     331        catchScope.clearException();
     332        return promise;
    338333    }
    339     deferred->reject(globalObject, createError(globalObject, makeString("Could not open the module '", moduleKey, "'.")));
     334    promise->reject(globalObject, createError(globalObject, makeString("Could not open the module '", moduleKey, "'.")));
    340335    catchScope.clearException();
    341     return deferred->promise();
     336    return promise;
    342337}
    343338
    … …  
    386381{
    387382    VM& vm = globalObject->vm();
    388     auto throwScope = DECLARE_THROW_SCOPE(vm);
    389 
    390     JSInternalPromiseDeferred* deferred = JSInternalPromiseDeferred::tryCreate(globalObject);
    391     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
     383
     384    auto* promise = JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
    392385
    393386    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    394387    auto reject = [&] (JSValue rejectionReason) {
    395388        catchScope.clearException();
    396         auto result = deferred->reject(globalObject, rejectionReason);
    397         catchScope.clearException();
    398         return JSValue::encode(result);
     389        promise->reject(globalObject, rejectionReason);
     390        catchScope.clearException();
     391        return JSValue::encode(promise);
    399392    };
    400393
    … …  
    409402#if ENABLE(WEBASSEMBLY)
    410403    if (sourceCode.provider()->sourceType() == SourceProviderSourceType::WebAssembly)
    411         return JSValue::encode(JSWebAssembly::instantiate(globalObject, deferred, moduleKey, jsSourceCode));
     404        return JSValue::encode(JSWebAssembly::instantiate(globalObject, promise, moduleKey, jsSourceCode));
    412405#endif
    413406
    … …  
    426419        return reject(catchScope.exception());
    427420
    428     auto result = deferred->resolve(globalObject, moduleAnalyzer.analyze(*moduleProgramNode));
     421    promise->resolve(globalObject, moduleAnalyzer.analyze(*moduleProgramNode));
    429422    catchScope.clearException();
    430     return JSValue::encode(result);
     423    return JSValue::encode(promise);
    431424}
    432425

  • trunk/Source/JavaScriptCore/runtime/JSPromise.cpp

    r251425 r251691  
    3333#include "JSPromiseConstructor.h"
    3434#include "Microtask.h"
     35#include "PromiseTimer.h"
    3536
    3637namespace JSC {
    … …  
    8485}
    8586
     87uint32_t JSPromise::flags() const
     88{
     89    JSValue value = internalField(static_cast<unsigned>(Field::Flags)).get();
     90    return value.asUInt32AsAnyInt();
     91}
     92
    8693bool JSPromise::isHandled(VM&) const
    8794{
    88     JSValue value = internalField(static_cast<unsigned>(Field::Flags)).get();
    89     uint32_t flags = value.asUInt32AsAnyInt();
    90     return flags & isHandledFlag;
     95    return flags() & isHandledFlag;
    9196}
    9297
    93 JSPromise* JSPromise::resolve(JSGlobalObject* globalObject, JSValue value)
     98JSPromise::DeferredData JSPromise::createDeferredData(JSGlobalObject* globalObject, JSPromiseConstructor* promiseConstructor)
    9499{
    95     auto& vm = globalObject->vm();
     100    VM& vm = globalObject->vm();
    96101    auto scope = DECLARE_THROW_SCOPE(vm);
    97102
    98     auto* promiseResolveFunction = globalObject->promiseResolveFunction();
     103    JSFunction* newPromiseCapabilityFunction = globalObject->newPromiseCapabilityFunction();
    99104    CallData callData;
    100     auto callType = JSC::getCallData(vm, promiseResolveFunction, callData);
     105    CallType callType = JSC::getCallData(globalObject->vm(), newPromiseCapabilityFunction, callData);
     106    ASSERT(callType != CallType::None);
     107
     108    MarkedArgumentBuffer arguments;
     109    arguments.append(promiseConstructor);
     110    ASSERT(!arguments.hasOverflowed());
     111    JSValue deferred = call(globalObject, newPromiseCapabilityFunction, callType, callData, jsUndefined(), arguments);
     112    RETURN_IF_EXCEPTION(scope, { });
     113
     114    DeferredData result;
     115    result.promise = jsCast<JSPromise*>(deferred.get(globalObject, vm.propertyNames->builtinNames().promisePrivateName()));
     116    RETURN_IF_EXCEPTION(scope, { });
     117    result.resolve = jsCast<JSFunction*>(deferred.get(globalObject, vm.propertyNames->builtinNames().resolvePrivateName()));
     118    RETURN_IF_EXCEPTION(scope, { });
     119    result.reject = jsCast<JSFunction*>(deferred.get(globalObject, vm.propertyNames->builtinNames().rejectPrivateName()));
     120    RETURN_IF_EXCEPTION(scope, { });
     121
     122    return result;
     123}
     124
     125JSPromise* JSPromise::resolvedPromise(JSGlobalObject* globalObject, JSValue value)
     126{
     127    VM& vm = globalObject->vm();
     128    auto scope = DECLARE_THROW_SCOPE(vm);
     129
     130    JSFunction* function = globalObject->promiseResolveFunction();
     131    CallData callData;
     132    CallType callType = JSC::getCallData(vm, function, callData);
    101133    ASSERT(callType != CallType::None);
    102134
    103135    MarkedArgumentBuffer arguments;
    104136    arguments.append(value);
    105     ASSERT(!arguments.hasOverflowed());
    106     auto result = call(globalObject, promiseResolveFunction, callType, callData, globalObject->promiseConstructor(), arguments);
     137    auto result = call(globalObject, function, callType, callData, globalObject->promiseConstructor(), arguments);
    107138    RETURN_IF_EXCEPTION(scope, nullptr);
    108139    ASSERT(result.inherits<JSPromise>(vm));
    … …  
    110141}
    111142
     143static inline void callFunction(JSGlobalObject* globalObject, JSValue function, JSPromise* promise, JSValue value)
     144{
     145    CallData callData;
     146    CallType callType = getCallData(globalObject->vm(), function, callData);
     147    ASSERT(callType != CallType::None);
     148
     149    MarkedArgumentBuffer arguments;
     150    arguments.append(promise);
     151    arguments.append(value);
     152    ASSERT(!arguments.hasOverflowed());
     153
     154    call(globalObject, function, callType, callData, jsUndefined(), arguments);
     155}
     156
     157void JSPromise::resolve(JSGlobalObject* lexicalGlobalObject, JSValue value)
     158{
     159    VM& vm = lexicalGlobalObject->vm();
     160    auto scope = DECLARE_THROW_SCOPE(vm);
     161    uint32_t flags = this->flags();
     162    if (!(flags & isFirstResolvingFunctionCalledFlag)) {
     163        internalField(static_cast<unsigned>(Field::Flags)).set(vm, this, jsNumber(flags | isFirstResolvingFunctionCalledFlag));
     164        JSGlobalObject* globalObject = this->globalObject(vm);
     165        callFunction(lexicalGlobalObject, globalObject->resolvePromiseFunction(), this, value);
     166        RETURN_IF_EXCEPTION(scope, void());
     167    }
     168    vm.promiseTimer->cancelPendingPromise(this);
     169}
     170
     171void JSPromise::reject(JSGlobalObject* lexicalGlobalObject, JSValue value)
     172{
     173    VM& vm = lexicalGlobalObject->vm();
     174    auto scope = DECLARE_THROW_SCOPE(vm);
     175    uint32_t flags = this->flags();
     176    if (!(flags & isFirstResolvingFunctionCalledFlag)) {
     177        internalField(static_cast<unsigned>(Field::Flags)).set(vm, this, jsNumber(flags | isFirstResolvingFunctionCalledFlag));
     178        JSGlobalObject* globalObject = this->globalObject(vm);
     179        callFunction(lexicalGlobalObject, globalObject->rejectPromiseFunction(), this, value);
     180        RETURN_IF_EXCEPTION(scope, void());
     181    }
     182    vm.promiseTimer->cancelPendingPromise(this);
     183}
     184
     185void JSPromise::reject(JSGlobalObject* lexicalGlobalObject, Exception* reason)
     186{
     187    reject(lexicalGlobalObject, reason->value());
     188}
     189
    112190} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/JSPromise.h

    r251425 r251691  
    3030namespace JSC {
    3131
     32class JSPromiseConstructor;
    3233class JSPromise : public JSInternalFieldObjectImpl<2> {
    3334public:
    3435    using Base = JSInternalFieldObjectImpl<2>;
    3536
    36     static JSPromise* create(VM&, Structure*);
     37    JS_EXPORT_PRIVATE static JSPromise* create(VM&, Structure*);
    3738    static Structure* createStructure(VM&, JSGlobalObject*, JSValue);
    3839
    … …  
    5859    JS_EXPORT_PRIVATE bool isHandled(VM&) const;
    5960
    60     JS_EXPORT_PRIVATE static JSPromise* resolve(JSGlobalObject*, JSValue);
     61    JS_EXPORT_PRIVATE static JSPromise* resolvedPromise(JSGlobalObject*, JSValue);
     62
     63    JS_EXPORT_PRIVATE void resolve(JSGlobalObject*, JSValue);
     64    JS_EXPORT_PRIVATE void reject(JSGlobalObject*, JSValue);
     65    JS_EXPORT_PRIVATE void reject(JSGlobalObject*, Exception*);
     66
     67    struct DeferredData {
     68        WTF_FORBID_HEAP_ALLOCATION;
     69    public:
     70        JSPromise* promise { nullptr };
     71        JSFunction* resolve { nullptr };
     72        JSFunction* reject { nullptr };
     73    };
     74    static DeferredData createDeferredData(JSGlobalObject*, JSPromiseConstructor*);
    6175
    6276    static void visitChildren(JSCell*, SlotVisitor&);
    … …  
    6579    JSPromise(VM&, Structure*);
    6680    void finishCreation(VM&);
     81
     82    uint32_t flags() const;
    6783};
    6884

  • trunk/Source/JavaScriptCore/runtime/PromiseTimer.cpp

    r251690 r251691  
    2525
    2626#include "config.h"
    27 #include "PromiseDeferredTimer.h"
     27#include "PromiseTimer.h"
    2828
    29 #include "JSPromiseDeferred.h"
     29#include "JSPromise.h"
    3030#include "StrongInlines.h"
    3131#include "VM.h"
    … …  
    3535namespace JSC {
    3636
    37 namespace PromiseDeferredTimerInternal {
     37namespace PromiseTimerInternal {
    3838static constexpr bool verbose = false;
    3939}
    4040
    41 PromiseDeferredTimer::PromiseDeferredTimer(VM& vm)
     41PromiseTimer::PromiseTimer(VM& vm)
    4242    : Base(vm)
    4343{
    4444}
    4545
    46 void PromiseDeferredTimer::doWork(VM& vm)
     46void PromiseTimer::doWork(VM& vm)
    4747{
    4848    ASSERT(vm.currentThreadIsHoldingAPILock());
    … …  
    5656    while (!m_tasks.isEmpty()) {
    5757        auto [ticket, task] = m_tasks.takeLast();
    58         dataLogLnIf(PromiseDeferredTimerInternal::verbose, "Doing work on promise: ", RawPointer(ticket));
     58        dataLogLnIf(PromiseTimerInternal::verbose, "Doing work on promise: ", RawPointer(ticket));
    5959
    6060        // We may have already canceled these promises.
    … …  
    8383}
    8484
    85 void PromiseDeferredTimer::runRunLoop()
     85void PromiseTimer::runRunLoop()
    8686{
    8787    ASSERT(!m_apiLock->vm()->currentThreadIsHoldingAPILock());
    … …  
    9999}
    100100
    101 void PromiseDeferredTimer::addPendingPromise(VM& vm, JSPromiseDeferred* ticket, Vector<Strong<JSCell>>&& dependencies)
     101void PromiseTimer::addPendingPromise(VM& vm, JSPromise* ticket, Vector<Strong<JSCell>>&& dependencies)
    102102{
    103103    ASSERT(vm.currentThreadIsHoldingAPILock());
    … …  
    107107    auto result = m_pendingPromises.add(ticket, Vector<Strong<JSCell>>());
    108108    if (result.isNewEntry) {
    109         dataLogLnIf(PromiseDeferredTimerInternal::verbose, "Adding new pending promise: ", RawPointer(ticket));
     109        dataLogLnIf(PromiseTimerInternal::verbose, "Adding new pending promise: ", RawPointer(ticket));
    110110        dependencies.append(Strong<JSCell>(vm, ticket));
    111111        result.iterator->value = WTFMove(dependencies);
    112112    } else {
    113         dataLogLnIf(PromiseDeferredTimerInternal::verbose, "Adding new dependencies for promise: ", RawPointer(ticket));
     113        dataLogLnIf(PromiseTimerInternal::verbose, "Adding new dependencies for promise: ", RawPointer(ticket));
    114114        result.iterator->value.appendVector(dependencies);
    115115    }
    116 
    117 #ifndef NDEBUG
    118     ticket->promiseAsyncPending();
    119 #endif
    120116}
    121117
    122 bool PromiseDeferredTimer::hasPendingPromise(JSPromiseDeferred* ticket)
     118bool PromiseTimer::hasPendingPromise(JSPromise* ticket)
    123119{
    124120    ASSERT(ticket->vm().currentThreadIsHoldingAPILock());
    … …  
    126122}
    127123
    128 bool PromiseDeferredTimer::hasDependancyInPendingPromise(JSPromiseDeferred* ticket, JSCell* dependency)
     124bool PromiseTimer::hasDependancyInPendingPromise(JSPromise* ticket, JSCell* dependency)
    129125{
    130126    ASSERT(ticket->vm().currentThreadIsHoldingAPILock());
    … …  
    135131}
    136132
    137 bool PromiseDeferredTimer::cancelPendingPromise(JSPromiseDeferred* ticket)
     133bool PromiseTimer::cancelPendingPromise(JSPromise* ticket)
    138134{
    139135    ASSERT(ticket->vm().currentThreadIsHoldingAPILock());
    … …  
    141137
    142138    if (result)
    143         dataLogLnIf(PromiseDeferredTimerInternal::verbose, "Canceling promise: ", RawPointer(ticket));
     139        dataLogLnIf(PromiseTimerInternal::verbose, "Canceling promise: ", RawPointer(ticket));
    144140
    145141    return result;
    146142}
    147143
    148 void PromiseDeferredTimer::scheduleWorkSoon(JSPromiseDeferred* ticket, Task&& task)
     144void PromiseTimer::scheduleWorkSoon(JSPromise* ticket, Task&& task)
    149145{
    150146    LockHolder locker(m_taskLock);

  • trunk/Source/JavaScriptCore/runtime/PromiseTimer.h

    r251690 r251691  
    3535namespace JSC {
    3636
    37 class JSPromiseDeferred;
     37class JSPromise;
    3838class VM;
    3939class JSCell;
    4040
    41 class PromiseDeferredTimer : public JSRunLoopTimer {
     41class PromiseTimer : public JSRunLoopTimer {
    4242public:
    4343    using Base = JSRunLoopTimer;
    … …  
    4545    void doWork(VM&) override;
    4646
    47     void addPendingPromise(VM&, JSPromiseDeferred*, Vector<Strong<JSCell>>&& dependencies);
    48     JS_EXPORT_PRIVATE bool hasPendingPromise(JSPromiseDeferred* ticket);
    49     JS_EXPORT_PRIVATE bool hasDependancyInPendingPromise(JSPromiseDeferred* ticket, JSCell* dependency);
    50     // JSPromiseDeferred should handle canceling when the promise is resolved or rejected.
    51     bool cancelPendingPromise(JSPromiseDeferred*);
     47    void addPendingPromise(VM&, JSPromise*, Vector<Strong<JSCell>>&& dependencies);
     48    JS_EXPORT_PRIVATE bool hasPendingPromise(JSPromise* ticket);
     49    JS_EXPORT_PRIVATE bool hasDependancyInPendingPromise(JSPromise* ticket, JSCell* dependency);
     50    // JSPromise should handle canceling when the promise is resolved or rejected.
     51    bool cancelPendingPromise(JSPromise*);
    5252
    5353    using Task = Function<void()>;
    54     void scheduleWorkSoon(JSPromiseDeferred*, Task&&);
     54    void scheduleWorkSoon(JSPromise*, Task&&);
    5555
    5656    void stopRunningTasks() { m_runTasks = false; }
    … …  
    5858    JS_EXPORT_PRIVATE void runRunLoop();
    5959
    60     static Ref<PromiseDeferredTimer> create(VM& vm)
     60    static Ref<PromiseTimer> create(VM& vm)
    6161    {
    62         return adoptRef(*new PromiseDeferredTimer(vm));
     62        return adoptRef(*new PromiseTimer(vm));
    6363    }
    6464
    6565private:
    66     PromiseDeferredTimer(VM&);
     66    PromiseTimer(VM&);
    6767
    68     HashMap<JSPromiseDeferred*, Vector<Strong<JSCell>>> m_pendingPromises;
     68    HashMap<JSPromise*, Vector<Strong<JSCell>>> m_pendingPromises;
    6969    Lock m_taskLock;
    7070    bool m_runTasks { true };
    7171    bool m_shouldStopRunLoopWhenAllPromisesFinish { false };
    7272    bool m_currentlyRunningTask { false };
    73     Vector<std::tuple<JSPromiseDeferred*, Task>> m_tasks;
     73    Vector<std::tuple<JSPromise*, Task>> m_tasks;
    7474};
    7575

  • trunk/Source/JavaScriptCore/runtime/VM.cpp

    r251425 r251691  
    8686#include "JSGlobalObjectFunctions.h"
    8787#include "JSImmutableButterfly.h"
    88 #include "JSInternalPromiseDeferred.h"
     88#include "JSInternalPromise.h"
    8989#include "JSLock.h"
    9090#include "JSMap.h"
    9191#include "JSMapIterator.h"
    92 #include "JSPromiseDeferred.h"
     92#include "JSPromise.h"
    9393#include "JSPropertyNameEnumerator.h"
    9494#include "JSScriptFetchParameters.h"
    … …  
    121121#include "ProgramCodeBlock.h"
    122122#include "ProgramExecutable.h"
    123 #include "PromiseDeferredTimer.h"
     123#include "PromiseTimer.h"
    124124#include "PropertyMapHashTable.h"
    125125#include "ProxyRevoke.h"
    … …  
    295295    , topEntryFrame(nullptr)
    296296    , topCallFrame(CallFrame::noCaller())
    297     , promiseDeferredTimer(PromiseDeferredTimer::create(*this))
     297    , promiseTimer(PromiseTimer::create(*this))
    298298    , m_atomStringTable(vmType == Default ? Thread::current().atomStringTable() : new AtomStringTable)
    299299    , propertyNames(nullptr)
    … …  
    380380    functionRareDataStructure.set(*this, FunctionRareData::createStructure(*this, 0, jsNull()));
    381381    exceptionStructure.set(*this, Exception::createStructure(*this, 0, jsNull()));
    382     promiseDeferredStructure.set(*this, JSPromiseDeferred::createStructure(*this, 0, jsNull()));
    383     internalPromiseDeferredStructure.set(*this, JSInternalPromiseDeferred::createStructure(*this, 0, jsNull()));
    384382    nativeStdFunctionCellStructure.set(*this, NativeStdFunctionCell::createStructure(*this, 0, jsNull()));
    385383    programCodeBlockStructure.set(*this, ProgramCodeBlock::createStructure(*this, 0, jsNull()));
    … …  
    491489   
    492490    Gigacage::removePrimitiveDisableCallback(primitiveGigacageDisabledCallback, this);
    493     promiseDeferredTimer->stopRunningTasks();
     491    promiseTimer->stopRunningTasks();
    494492#if ENABLE(WEBASSEMBLY)
    495493    if (Wasm::Worklist* worklist = Wasm::existingWorklistOrNull())

  • trunk/Source/JavaScriptCore/runtime/VM.h

    r251556 r251691  
    133133class LLIntOffsetsExtractor;
    134134class NativeExecutable;
    135 class PromiseDeferredTimer;
     135class PromiseTimer;
    136136class RegExp;
    137137class RegExpCache;
    … …  
    537537    Strong<Structure> functionRareDataStructure;
    538538    Strong<Structure> exceptionStructure;
    539     Strong<Structure> promiseDeferredStructure;
    540     Strong<Structure> internalPromiseDeferredStructure;
    541539    Strong<Structure> nativeStdFunctionCellStructure;
    542540    Strong<Structure> programCodeBlockStructure;
    … …  
    557555    Strong<JSCell> m_sentinelMapBucket;
    558556
    559     Ref<PromiseDeferredTimer> promiseDeferredTimer;
     557    Ref<PromiseTimer> promiseTimer;
    560558   
    561559    JSCell* currentlyDestructingCallbackObject;

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssembly.cpp

    r251690 r251691  
    3535#include "JSCInlines.h"
    3636#include "JSModuleNamespaceObject.h"
    37 #include "JSPromiseDeferred.h"
     37#include "JSPromise.h"
    3838#include "JSToWasm.h"
    3939#include "JSWebAssemblyHelpers.h"
    … …  
    4242#include "ObjectConstructor.h"
    4343#include "Options.h"
    44 #include "PromiseDeferredTimer.h"
     44#include "PromiseTimer.h"
    4545#include "StrongInlines.h"
    4646#include "ThrowScope.h"
    … …  
    125125}
    126126
    127 static void reject(JSGlobalObject* globalObject, CatchScope& catchScope, JSPromiseDeferred* promise)
     127static void reject(JSGlobalObject* globalObject, CatchScope& catchScope, JSPromise* promise)
    128128{
    129129    Exception* exception = catchScope.exception();
    … …  
    134134}
    135135
    136 static void webAssemblyModuleValidateAsyncInternal(JSGlobalObject* globalObject, JSPromiseDeferred* promise, Vector<uint8_t>&& source)
     136static void webAssemblyModuleValidateAsyncInternal(JSGlobalObject* globalObject, JSPromise* promise, Vector<uint8_t>&& source)
    137137{
    138138    VM& vm = globalObject->vm();
    … …  
    141141    dependencies.append(Strong<JSCell>(vm, globalObject));
    142142
    143     vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     143    vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    144144
    145145    Wasm::Module::validateAsync(&vm.wasmContext, WTFMove(source), createSharedTask<Wasm::Module::CallbackType>([promise, globalObject, &vm] (Wasm::Module::ValidationResult&& result) mutable {
    146         vm.promiseDeferredTimer->scheduleWorkSoon(promise, [promise, globalObject, result = WTFMove(result), &vm] () mutable {
     146        vm.promiseTimer->scheduleWorkSoon(promise, [promise, globalObject, result = WTFMove(result), &vm] () mutable {
    147147            auto scope = DECLARE_CATCH_SCOPE(vm);
    148148            JSValue module = JSWebAssemblyModule::createStub(vm, globalObject, globalObject->webAssemblyModuleStructure(), WTFMove(result));
    … …  
    163163    auto throwScope = DECLARE_THROW_SCOPE(vm);
    164164
    165     JSPromiseDeferred* promise = JSPromiseDeferred::tryCreate(globalObject);
     165    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    166166    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    167167
    … …  
    175175            webAssemblyModuleValidateAsyncInternal(globalObject, promise, WTFMove(source));
    176176
    177         return JSValue::encode(promise->promise());
     177        return JSValue::encode(promise);
    178178    }
    179179}
    180180
    181181enum class Resolve { WithInstance, WithModuleRecord, WithModuleAndInstance };
    182 static void resolve(VM& vm, JSGlobalObject* globalObject, JSPromiseDeferred* promise, JSWebAssemblyInstance* instance, JSWebAssemblyModule* module, JSObject* importObject, Ref<Wasm::CodeBlock>&& codeBlock, Resolve resolveKind, Wasm::CreationMode creationMode)
     182static void resolve(VM& vm, JSGlobalObject* globalObject, JSPromise* promise, JSWebAssemblyInstance* instance, JSWebAssemblyModule* module, JSObject* importObject, Ref<Wasm::CodeBlock>&& codeBlock, Resolve resolveKind, Wasm::CreationMode creationMode)
    183183{
    184184    auto scope = DECLARE_CATCH_SCOPE(vm);
    … …  
    202202}
    203203
    204 void JSWebAssembly::webAssemblyModuleValidateAsync(JSGlobalObject* globalObject, JSPromiseDeferred* promise, Vector<uint8_t>&& source)
     204void JSWebAssembly::webAssemblyModuleValidateAsync(JSGlobalObject* globalObject, JSPromise* promise, Vector<uint8_t>&& source)
    205205{
    206206    VM& vm = globalObject->vm();
    … …  
    210210}
    211211
    212 static void instantiate(VM& vm, JSGlobalObject* globalObject, JSPromiseDeferred* promise, JSWebAssemblyModule* module, JSObject* importObject, const Identifier& moduleKey, Resolve resolveKind, Wasm::CreationMode creationMode)
     212static void instantiate(VM& vm, JSGlobalObject* globalObject, JSPromise* promise, JSWebAssemblyModule* module, JSObject* importObject, const Identifier& moduleKey, Resolve resolveKind, Wasm::CreationMode creationMode)
    213213{
    214214    auto scope = DECLARE_CATCH_SCOPE(vm);
    … …  
    221221    dependencies.append(Strong<JSCell>(vm, instance));
    222222    dependencies.append(Strong<JSCell>(vm, importObject));
    223     vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     223    vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    224224    // Note: This completion task may or may not get called immediately.
    225225    module->module().compileAsync(&vm.wasmContext, instance->memoryMode(), createSharedTask<Wasm::CodeBlock::CallbackType>([promise, instance, module, importObject, resolveKind, creationMode, &vm] (Ref<Wasm::CodeBlock>&& refCodeBlock) mutable {
    226226        RefPtr<Wasm::CodeBlock> codeBlock = WTFMove(refCodeBlock);
    227         vm.promiseDeferredTimer->scheduleWorkSoon(promise, [promise, instance, module, importObject, resolveKind, creationMode, &vm, codeBlock = WTFMove(codeBlock)] () mutable {
     227        vm.promiseTimer->scheduleWorkSoon(promise, [promise, instance, module, importObject, resolveKind, creationMode, &vm, codeBlock = WTFMove(codeBlock)] () mutable {
    228228            JSGlobalObject* globalObject = instance->globalObject();
    229229            resolve(vm, globalObject, promise, instance, module, importObject, codeBlock.releaseNonNull(), resolveKind, creationMode);
    … …  
    232232}
    233233
    234 static void compileAndInstantiate(VM& vm, JSGlobalObject* globalObject, JSPromiseDeferred* promise, const Identifier& moduleKey, JSValue buffer, JSObject* importObject, Resolve resolveKind, Wasm::CreationMode creationMode)
     234static void compileAndInstantiate(VM& vm, JSGlobalObject* globalObject, JSPromise* promise, const Identifier& moduleKey, JSValue buffer, JSObject* importObject, Resolve resolveKind, Wasm::CreationMode creationMode)
    235235{
    236236    auto scope = DECLARE_CATCH_SCOPE(vm);
    … …  
    240240    dependencies.append(Strong<JSCell>(vm, importObject));
    241241    dependencies.append(Strong<JSCell>(vm, moduleKeyCell));
    242     vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     242    vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    243243
    244244    Vector<uint8_t> source = createSourceBufferFromValue(vm, globalObject, buffer);
    … …  
    246246
    247247    Wasm::Module::validateAsync(&vm.wasmContext, WTFMove(source), createSharedTask<Wasm::Module::CallbackType>([promise, importObject, moduleKeyCell, globalObject, resolveKind, creationMode, &vm] (Wasm::Module::ValidationResult&& result) mutable {
    248         vm.promiseDeferredTimer->scheduleWorkSoon(promise, [promise, importObject, moduleKeyCell, globalObject, result = WTFMove(result), resolveKind, creationMode, &vm] () mutable {
     248        vm.promiseTimer->scheduleWorkSoon(promise, [promise, importObject, moduleKeyCell, globalObject, result = WTFMove(result), resolveKind, creationMode, &vm] () mutable {
    249249            auto scope = DECLARE_CATCH_SCOPE(vm);
    250250            JSWebAssemblyModule* module = JSWebAssemblyModule::createStub(vm, globalObject, globalObject->webAssemblyModuleStructure(), WTFMove(result));
    … …  
    261261}
    262262
    263 JSValue JSWebAssembly::instantiate(JSGlobalObject* globalObject, JSPromiseDeferred* promise, const Identifier& moduleKey, JSValue argument)
     263JSValue JSWebAssembly::instantiate(JSGlobalObject* globalObject, JSPromise* promise, const Identifier& moduleKey, JSValue argument)
    264264{
    265265    VM& vm = globalObject->vm();
    266266    compileAndInstantiate(vm, globalObject, promise, moduleKey, argument, nullptr, Resolve::WithModuleRecord, Wasm::CreationMode::FromModuleLoader);
    267     return promise->promise();
    268 }
    269 
    270 static void webAssemblyModuleInstantinateAsyncInternal(JSGlobalObject* globalObject, JSPromiseDeferred* promise, Vector<uint8_t>&& source, JSObject* importObject)
     267    return promise;
     268}
     269
     270static void webAssemblyModuleInstantinateAsyncInternal(JSGlobalObject* globalObject, JSPromise* promise, Vector<uint8_t>&& source, JSObject* importObject)
    271271{
    272272    VM& vm = globalObject->vm();
    … …  
    275275    dependencies.append(Strong<JSCell>(vm, importObject));
    276276    dependencies.append(Strong<JSCell>(vm, globalObject));
    277     vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     277    vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    278278
    279279    Wasm::Module::validateAsync(&vm.wasmContext, WTFMove(source), createSharedTask<Wasm::Module::CallbackType>([promise, importObject, globalObject, &vm] (Wasm::Module::ValidationResult&& result) mutable {
    280         vm.promiseDeferredTimer->scheduleWorkSoon(promise, [promise, importObject, globalObject, result = WTFMove(result), &vm] () mutable {
     280        vm.promiseTimer->scheduleWorkSoon(promise, [promise, importObject, globalObject, result = WTFMove(result), &vm] () mutable {
    281281            auto scope = DECLARE_CATCH_SCOPE(vm);
    282282            JSWebAssemblyModule* module = JSWebAssemblyModule::createStub(vm, globalObject, globalObject->webAssemblyModuleStructure(), WTFMove(result));
    … …  
    290290}
    291291
    292 void JSWebAssembly::webAssemblyModuleInstantinateAsync(JSGlobalObject* globalObject, JSPromiseDeferred* promise, Vector<uint8_t>&& source, JSObject* importedObject)
     292void JSWebAssembly::webAssemblyModuleInstantinateAsync(JSGlobalObject* globalObject, JSPromise* promise, Vector<uint8_t>&& source, JSObject* importedObject)
    293293{
    294294    VM& vm = globalObject->vm();
    … …  
    301301{
    302302    VM& vm = globalObject->vm();
    303     auto throwScope = DECLARE_THROW_SCOPE(vm);
    304 
    305     JSPromiseDeferred* promise = JSPromiseDeferred::tryCreate(globalObject);
    306     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    307 
     303
     304    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    308305    {
    309306        auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    314311            promise->reject(globalObject, createTypeError(globalObject,
    315312                "second argument to WebAssembly.instantiate must be undefined or an Object"_s, defaultSourceAppender, runtimeTypeForValue(vm, importArgument)));
    316             CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise->promise()));
     313            CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise));
    317314        } else {
    318315            JSValue firstArgument = callFrame->argument(0);
    … …  
    323320        }
    324321
    325         return JSValue::encode(promise->promise());
     322        return JSValue::encode(promise);
    326323    }
    327324}
    … …  
    345342    auto catchScope = DECLARE_CATCH_SCOPE(vm);
    346343
    347     JSPromiseDeferred* promise = JSPromiseDeferred::tryCreate(globalObject);
     344    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    348345
    349346    Vector<Strong<JSCell>> dependencies;
    350347    dependencies.append(Strong<JSCell>(vm, globalObject));
    351     vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     348    vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    352349
    353350    if (globalObject->globalObjectMethodTable()->compileStreaming)
    … …  
    358355    }
    359356
    360     CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise->promise()));
    361 
    362     return JSValue::encode(promise->promise());
     357    CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise));
     358
     359    return JSValue::encode(promise);
    363360}
    364361
    … …  
    366363{
    367364    VM& vm = globalObject->vm();
    368     auto throwScope = DECLARE_THROW_SCOPE(vm);
    369 
    370     JSPromiseDeferred* promise = JSPromiseDeferred::tryCreate(globalObject);
    371     RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
     365
     366    auto* promise = JSPromise::create(vm, globalObject->promiseStructure());
    372367    {
    373368        auto catchScope = DECLARE_CATCH_SCOPE(vm);
    … …  
    378373            promise->reject(globalObject, createTypeError(globalObject,
    379374                "second argument to WebAssembly.instantiateStreaming must be undefined or an Object"_s, defaultSourceAppender, runtimeTypeForValue(vm, importArgument)));
    380             CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise->promise()));
     375            CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise));
    381376        } else {
    382377            if (globalObject->globalObjectMethodTable()->instantiateStreaming) {
    … …  
    384379                dependencies.append(Strong<JSCell>(vm, globalObject));
    385380                dependencies.append(Strong<JSCell>(vm, importObject));
    386                 vm.promiseDeferredTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
     381                vm.promiseTimer->addPendingPromise(vm, promise, WTFMove(dependencies));
    387382
    388383                // FIXME: <http://webkit.org/b/184888> if there's an importObject and it contains a Memory, then we can compile the module with the right memory type (fast or not) by looking at the memory's type.
    … …  
    393388            }
    394389        }
    395         CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise->promise()));
    396 
    397         return JSValue::encode(promise->promise());
     390        CLEAR_AND_RETURN_IF_EXCEPTION(catchScope, JSValue::encode(promise));
     391
     392        return JSValue::encode(promise);
    398393    }
    399394}

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssembly.h

    r251425 r251691  
    2929
    3030#include "JSObject.h"
    31 #include "JSPromiseDeferred.h"
     31#include "JSPromise.h"
    3232
    3333namespace JSC {
    … …  
    4343    DECLARE_INFO;
    4444
    45     JS_EXPORT_PRIVATE static void webAssemblyModuleValidateAsync(JSGlobalObject*, JSPromiseDeferred*, Vector<uint8_t>&&);
    46     JS_EXPORT_PRIVATE static void webAssemblyModuleInstantinateAsync(JSGlobalObject*, JSPromiseDeferred*, Vector<uint8_t>&&, JSObject*);
    47     static JSValue instantiate(JSGlobalObject*, JSPromiseDeferred*, const Identifier&, JSValue);
     45    JS_EXPORT_PRIVATE static void webAssemblyModuleValidateAsync(JSGlobalObject*, JSPromise*, Vector<uint8_t>&&);
     46    JS_EXPORT_PRIVATE static void webAssemblyModuleInstantinateAsync(JSGlobalObject*, JSPromise*, Vector<uint8_t>&&, JSObject*);
     47    static JSValue instantiate(JSGlobalObject*, JSPromise*, const Identifier&, JSValue);
    4848
    4949protected:

  • trunk/Source/JavaScriptCore/wasm/js/JSWebAssemblyCodeBlock.h

    r250005 r251691  
    3030#include "CallLinkInfo.h"
    3131#include "JSCast.h"
    32 #include "PromiseDeferredTimer.h"
     32#include "PromiseTimer.h"
    3333#include "Structure.h"
    3434#include "WasmCallee.h"

  • trunk/Source/WebCore/ChangeLog

    r251690 r251691  
     12019-10-28  Yusuke Suzuki  <ysuzuki@apple.com>
     2
     3        [JSC] Remove JSPromiseDeferred
     4        https://bugs.webkit.org/show_bug.cgi?id=203400
     5
     6        Reviewed by Keith Miller.
     7
     8        This patch removes PromiseExecutionScope. This assumed that promise operation cannot fail in main thread. But this is
     9        wrong since any JS call can fail due to stack-overflow error. This patch makes things more robust by handling errors correctly.
     10        And we remove JSPromiseDeferred and use JSPromise instead.
     11
     12        * bindings/js/JSCustomElementRegistryCustom.cpp:
     13        (WebCore::whenDefinedPromise):
     14        (WebCore::JSCustomElementRegistry::whenDefined):
     15        * bindings/js/JSDOMConvertPromise.h:
     16        (WebCore::Converter<IDLPromise<T>>::convert):
     17        * bindings/js/JSDOMGlobalObject.cpp:
     18        * bindings/js/JSDOMOperationReturningPromise.h:
     19        (WebCore::IDLOperationReturningPromise::call):
     20        (WebCore::IDLOperationReturningPromise::callStatic):
     21        * bindings/js/JSDOMPromiseDeferred.cpp:
     22        (WebCore::DeferredPromise::promise const):
     23        (WebCore::DeferredPromise::callFunction):
     24        (WebCore::DeferredPromise::whenSettled):
     25        (WebCore::rejectPromiseWithExceptionIfAny):
     26        (WebCore::createDeferredPromise):
     27        * bindings/js/JSDOMPromiseDeferred.h:
     28        (WebCore::DeferredPromise::create):
     29        (WebCore::DeferredPromise::DeferredPromise):
     30        (WebCore::DeferredPromise::deferred const):
     31        (WebCore::DeferredPromise::resolve):
     32        (WebCore::DeferredPromise::reject):
     33        (WebCore::DOMPromiseDeferredBase::DOMPromiseDeferredBase):
     34        (WebCore::DOMPromiseDeferredBase::operator=):
     35        (WebCore::DOMPromiseDeferredBase::reject):
     36        (WebCore::DOMPromiseDeferredBase::rejectType):
     37        (WebCore::DOMPromiseDeferredBase::promise const):
     38        (WebCore::DOMPromiseDeferredBase::whenSettled):
     39        (WebCore::DOMPromiseDeferred::resolve):
     40        (WebCore::DOMPromiseDeferred<void>::resolve):
     41        (WebCore::callPromiseFunction):
     42        * bindings/js/JSDOMWindowBase.cpp:
     43        (WebCore::JSDOMWindowBase::moduleLoaderFetch):
     44        (WebCore::JSDOMWindowBase::moduleLoaderImportModule):
     45        (WebCore::tryAllocate):
     46        (WebCore::isResponseCorrect):
     47        (WebCore::handleResponseOnStreamingAction):
     48        (WebCore::JSDOMWindowBase::compileStreaming):
     49        (WebCore::JSDOMWindowBase::instantiateStreaming):
     50        * bindings/js/JSDOMWindowBase.h:
     51        * bindings/js/ScriptModuleLoader.cpp:
     52        (WebCore::ScriptModuleLoader::fetch):
     53        (WebCore::rejectPromise):
     54        * bindings/js/WorkerScriptController.cpp:
     55        (WebCore::WorkerScriptController::addTimerSetNotification):
     56        (WebCore::WorkerScriptController::removeTimerSetNotification):
     57        * bindings/scripts/CodeGeneratorJS.pm:
     58        (GenerateOperationTrampolineDefinition):
     59        * bindings/scripts/test/JS/JSTestGlobalObject.cpp:
     60        (WebCore::jsTestGlobalObjectInstanceFunctionCalculateSecretResult):
     61        * bindings/scripts/test/JS/JSTestNode.cpp:
     62        (WebCore::jsTestNodePrototypeFunctionTestWorkerPromise):
     63        (WebCore::jsTestNodePrototypeFunctionCalculateSecretResult):
     64        * bindings/scripts/test/JS/JSTestObj.cpp:
     65        (WebCore::jsTestObjPrototypeFunctionCalculateSecretResult):
     66        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunction):
     67        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument):
     68        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithException):
     69        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument):
     70        (WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction):
     71        (WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunction):
     72        (WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException):
     73        (WebCore::jsTestObjPrototypeFunctionTestCustomPromiseFunction):
     74        (WebCore::jsTestObjConstructorFunctionTestStaticCustomPromiseFunction):
     75        * workers/WorkerRunLoop.cpp:
     76        * worklets/WorkletScriptController.cpp:
     77
    1782019-10-28  Adrian Perez de Castro  <aperez@igalia.com>
    279

  • trunk/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp

    r251425 r251691  
    176176
    177177// https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
    178 static JSValue whenDefinedPromise(JSGlobalObject& lexicalGlobalObject, CallFrame& callFrame, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry, JSPromiseDeferred& promiseDeferred)
     178static JSValue whenDefinedPromise(JSGlobalObject& lexicalGlobalObject, CallFrame& callFrame, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry, JSPromise& promise)
    179179{
    180180    auto scope = DECLARE_THROW_SCOPE(lexicalGlobalObject.vm());
    … …  
    192192
    193193    if (registry.findInterface(localName)) {
    194         DeferredPromise::create(globalObject, promiseDeferred)->resolve();
    195         return promiseDeferred.promise();
     194        DeferredPromise::create(globalObject, promise)->resolve();
     195        return &promise;
    196196    }
    197197
    198198    auto result = registry.promiseMap().ensure(localName, [&] {
    199         return DeferredPromise::create(globalObject, promiseDeferred);
     199        return DeferredPromise::create(globalObject, promise);
    200200    });
    201201
    … …  
    208208
    209209    ASSERT(globalObject());
    210     auto promiseDeferred = JSPromiseDeferred::tryCreate(globalObject());
    211     RELEASE_ASSERT(promiseDeferred);
    212     JSValue promise = whenDefinedPromise(lexicalGlobalObject, callFrame, *globalObject(), wrapped(), *promiseDeferred);
     210    auto* result = JSPromise::create(lexicalGlobalObject.vm(), lexicalGlobalObject.promiseStructure());
     211    JSValue promise = whenDefinedPromise(lexicalGlobalObject, callFrame, *globalObject(), wrapped(), *result);
    213212
    214213    if (UNLIKELY(scope.exception())) {
    215         rejectPromiseWithExceptionIfAny(lexicalGlobalObject, *globalObject(), *promiseDeferred);
     214        rejectPromiseWithExceptionIfAny(lexicalGlobalObject, *globalObject(), *result);
    216215        scope.assertNoException();
    217         return promiseDeferred->promise();
     216        return result;
    218217    }
    219218

  • trunk/Source/WebCore/bindings/js/JSDOMConvertPromise.h

    r251425 r251691  
    4747        // 1. Let resolve be the original value of %Promise%.resolve.
    4848        // 2. Let promise be the result of calling resolve with %Promise% as the this value and V as the single argument value.
    49         auto* promise = JSC::JSPromise::resolve(globalObject, value);
     49        auto* promise = JSC::JSPromise::resolvedPromise(globalObject, value);
    5050        if (scope.exception()) {
    5151            exceptionThrower(lexicalGlobalObject, scope);

  • trunk/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp

    r251457 r251691  
    4949#include <JavaScriptCore/CodeBlock.h>
    5050#include <JavaScriptCore/JSInternalPromise.h>
    51 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
    5251#include <JavaScriptCore/StructureInlines.h>
    5352

  • trunk/Source/WebCore/bindings/js/JSDOMOperationReturningPromise.h

    r251425 r251691  
    3636    using StaticOperation = JSC::EncodedJSValue(JSC::JSGlobalObject*, JSC::CallFrame*, Ref<DeferredPromise>&&, JSC::ThrowScope&);
    3737
    38     template<Operation operation, PromiseExecutionScope executionScope, CastedThisErrorBehavior shouldThrow = CastedThisErrorBehavior::RejectPromise>
     38    template<Operation operation, CastedThisErrorBehavior shouldThrow = CastedThisErrorBehavior::RejectPromise>
    3939    static JSC::EncodedJSValue call(JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, const char* operationName)
    4040    {
    41         return JSC::JSValue::encode(callPromiseFunction<executionScope>(lexicalGlobalObject, callFrame, [&operationName] (JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, Ref<DeferredPromise>&& promise) {
     41        return JSC::JSValue::encode(callPromiseFunction(lexicalGlobalObject, callFrame, [&operationName] (JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, Ref<DeferredPromise>&& promise) {
    4242            auto throwScope = DECLARE_THROW_SCOPE(JSC::getVM(&lexicalGlobalObject));
    4343           
    … …  
    7272    }
    7373
    74     template<StaticOperation operation, PromiseExecutionScope executionScope, CastedThisErrorBehavior shouldThrow = CastedThisErrorBehavior::RejectPromise>
     74    template<StaticOperation operation, CastedThisErrorBehavior shouldThrow = CastedThisErrorBehavior::RejectPromise>
    7575    static JSC::EncodedJSValue callStatic(JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, const char*)
    7676    {
    77         return JSC::JSValue::encode(callPromiseFunction<executionScope>(lexicalGlobalObject, callFrame, [] (JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, Ref<DeferredPromise>&& promise) {
     77        return JSC::JSValue::encode(callPromiseFunction(lexicalGlobalObject, callFrame, [] (JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, Ref<DeferredPromise>&& promise) {
    7878            auto throwScope = DECLARE_THROW_SCOPE(JSC::getVM(&lexicalGlobalObject));
    7979           

  • trunk/Source/WebCore/bindings/js/JSDOMPromiseDeferred.cpp

    r251425 r251691  
    4141{
    4242    ASSERT(deferred());
    43     return deferred()->promise();
    44 }
    45 
    46 void DeferredPromise::callFunction(JSGlobalObject& lexicalGlobalObject, JSValue function, JSValue resolution)
     43    return deferred();
     44}
     45
     46void DeferredPromise::callFunction(JSGlobalObject& lexicalGlobalObject, ResolveMode mode, JSValue resolution)
    4747{
    4848    if (!canInvokeCallback())
    4949        return;
    5050
    51     VM& vm = lexicalGlobalObject.vm();
    52     auto scope = DECLARE_THROW_SCOPE(vm);
    53 
    54     CallData callData;
    55     CallType callType = getCallData(vm, function, callData);
    56     ASSERT(callType != CallType::None);
    57 
    58     MarkedArgumentBuffer arguments;
    59     arguments.append(resolution);
    60     ASSERT(!arguments.hasOverflowed());
    61 
    62     call(&lexicalGlobalObject, function, callType, callData, jsUndefined(), arguments);
    63 
    64     // DeferredPromise should only be used by internal implementations that are well behaved.
    65     // In practice, the only exception we should ever see here is the TerminatedExecutionException.
    66     EXCEPTION_ASSERT_UNUSED(scope, !scope.exception() || isTerminatedExecutionException(vm, scope.exception()));
     51    // FIXME: We could have error since any JS call can throw stack-overflow errors.
     52    // https://bugs.webkit.org/show_bug.cgi?id=203402
     53    switch (mode) {
     54    case ResolveMode::Resolve:
     55        deferred()->resolve(&lexicalGlobalObject, resolution);
     56        break;
     57    case ResolveMode::Reject:
     58        deferred()->reject(&lexicalGlobalObject, resolution);
     59        break;
     60    }
    6761
    6862    if (m_mode == Mode::ClearPromiseOnResolve)
    … …  
    7266void DeferredPromise::whenSettled(Function<void()>&& callback)
    7367{
    74     DOMPromise::whenPromiseIsSettled(globalObject(), deferred()->promise(), WTFMove(callback));
     68    DOMPromise::whenPromiseIsSettled(globalObject(), deferred(), WTFMove(callback));
    7569}
    7670
    … …  
    176170}
    177171
    178 void rejectPromiseWithExceptionIfAny(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
     172void rejectPromiseWithExceptionIfAny(JSC::JSGlobalObject& lexicalGlobalObject, JSDOMGlobalObject& globalObject, JSPromise& promise)
    179173{
    180174    VM& vm = lexicalGlobalObject.vm();
    … …  
    187181    scope.clearException();
    188182
    189     DeferredPromise::create(globalObject, promiseDeferred)->reject<IDLAny>(error);
     183    DeferredPromise::create(globalObject, promise)->reject<IDLAny>(error);
    190184}
    191185
    192186Ref<DeferredPromise> createDeferredPromise(JSC::JSGlobalObject&, JSDOMWindow& domWindow)
    193187{
    194     JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::tryCreate(&domWindow);
    195     // deferred can only be null in workers.
    196     RELEASE_ASSERT(deferred);
    197     return DeferredPromise::create(domWindow, *deferred);
     188    auto* promise = JSPromise::create(domWindow.vm(), domWindow.promiseStructure());
     189    RELEASE_ASSERT(promise);
     190    return DeferredPromise::create(domWindow, *promise);
    198191}
    199192

  • trunk/Source/WebCore/bindings/js/JSDOMPromiseDeferred.h

    r251425 r251691  
    3030#include "JSDOMGuardedObject.h"
    3131#include <JavaScriptCore/CatchScope.h>
    32 #include <JavaScriptCore/JSPromiseDeferred.h>
     32#include <JavaScriptCore/JSPromise.h>
    3333
    3434namespace WebCore {
    … …  
    3636class JSDOMWindow;
    3737
    38 class DeferredPromise : public DOMGuarded<JSC::JSPromiseDeferred> {
     38class DeferredPromise : public DOMGuarded<JSC::JSPromise> {
    3939public:
    4040    enum class Mode {
    … …  
    4545    static RefPtr<DeferredPromise> create(JSDOMGlobalObject& globalObject, Mode mode = Mode::ClearPromiseOnResolve)
    4646    {
    47         auto* promiseDeferred = JSC::JSPromiseDeferred::tryCreate(&globalObject);
    48         if (!promiseDeferred)
    49             return nullptr;
    50         return adoptRef(new DeferredPromise(globalObject, *promiseDeferred, mode));
    51     }
    52 
    53     static Ref<DeferredPromise> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred, Mode mode = Mode::ClearPromiseOnResolve)
     47        JSC::VM& vm = JSC::getVM(&globalObject);
     48        auto* promise = JSC::JSPromise::create(vm, globalObject.promiseStructure());
     49        ASSERT(promise);
     50        return adoptRef(new DeferredPromise(globalObject, *promise, mode));
     51    }
     52
     53    static Ref<DeferredPromise> create(JSDOMGlobalObject& globalObject, JSC::JSPromise& deferred, Mode mode = Mode::ClearPromiseOnResolve)
    5454    {
    5555        return adoptRef(*new DeferredPromise(globalObject, deferred, mode));
    … …  
    150150
    151151private:
    152     DeferredPromise(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred, Mode mode)
    153         : DOMGuarded<JSC::JSPromiseDeferred>(globalObject, deferred)
     152    DeferredPromise(JSDOMGlobalObject& globalObject, JSC::JSPromise& deferred, Mode mode)
     153        : DOMGuarded<JSC::JSPromise>(globalObject, deferred)
    154154        , m_mode(mode)
    155155    {
    156156    }
    157157
    158     JSC::JSPromiseDeferred* deferred() const { return guarded(); }
    159 
    160     WEBCORE_EXPORT void callFunction(JSC::JSGlobalObject&, JSC::JSValue function, JSC::JSValue resolution);
    161 
    162     void resolve(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSValue resolution) { callFunction(lexicalGlobalObject, deferred()->resolve(), resolution); }
    163     void reject(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSValue resolution) { callFunction(lexicalGlobalObject, deferred()->reject(), resolution); }
     158    JSC::JSPromise* deferred() const { return guarded(); }
     159
     160    enum class ResolveMode { Resolve, Reject };
     161    WEBCORE_EXPORT void callFunction(JSC::JSGlobalObject&, ResolveMode, JSC::JSValue resolution);
     162
     163    void resolve(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSValue resolution) { callFunction(lexicalGlobalObject, ResolveMode::Resolve, resolution); }
     164    void reject(JSC::JSGlobalObject& lexicalGlobalObject, JSC::JSValue resolution) { callFunction(lexicalGlobalObject, ResolveMode::Reject, resolution); }
    164165
    165166    Mode m_mode;
    … …  
    170171public:
    171172    DOMPromiseDeferredBase(Ref<DeferredPromise>&& genericPromise)
    172         : m_promiseDeferred(WTFMove(genericPromise))
     173        : m_promise(WTFMove(genericPromise))
    173174    {
    174175    }
    175176
    176177    DOMPromiseDeferredBase(DOMPromiseDeferredBase&& promise)
    177         : m_promiseDeferred(WTFMove(promise.m_promiseDeferred))
     178        : m_promise(WTFMove(promise.m_promise))
    178179    {
    179180    }
    180181
    181182    DOMPromiseDeferredBase(const DOMPromiseDeferredBase& other)
    182         : m_promiseDeferred(other.m_promiseDeferred.copyRef())
     183        : m_promise(other.m_promise.copyRef())
    183184    {
    184185    }
    … …  
    186187    DOMPromiseDeferredBase& operator=(const DOMPromiseDeferredBase& other)
    187188    {
    188         m_promiseDeferred = other.m_promiseDeferred.copyRef();
     189        m_promise = other.m_promise.copyRef();
    189190        return *this;
    190191    }
    … …  
    192193    DOMPromiseDeferredBase& operator=(DOMPromiseDeferredBase&& other)
    193194    {
    194         m_promiseDeferred = WTFMove(other.m_promiseDeferred);
     195        m_promise = WTFMove(other.m_promise);
    195196        return *this;
    196197    }
    … …  
    198199    void reject()
    199200    {
    200         m_promiseDeferred->reject();
     201        m_promise->reject();
    201202    }
    202203
    … …  
    204205    void reject(ErrorType&&... error)
    205206    {
    206         m_promiseDeferred->reject(std::forward<ErrorType>(error)...);
     207        m_promise->reject(std::forward<ErrorType>(error)...);
    207208    }
    208209
    … …  
    210211    void rejectType(typename IDLType::ParameterType value)
    211212    {
    212         m_promiseDeferred->reject<IDLType>(std::forward<typename IDLType::ParameterType>(value));
    213     }
    214 
    215     JSC::JSValue promise() const { return m_promiseDeferred->promise(); };
     213        m_promise->reject<IDLType>(std::forward<typename IDLType::ParameterType>(value));
     214    }
     215
     216    JSC::JSValue promise() const { return m_promise->promise(); };
    216217
    217218    void whenSettled(Function<void()>&& function)
    218219    {
    219         m_promiseDeferred->whenSettled(WTFMove(function));
     220        m_promise->whenSettled(WTFMove(function));
    220221    }
    221222
    222223protected:
    223     Ref<DeferredPromise> m_promiseDeferred;
     224    Ref<DeferredPromise> m_promise;
    224225};
    225226
    … …  
    234235    void resolve(typename IDLType::ParameterType value)
    235236    {
    236         m_promiseDeferred->resolve<IDLType>(std::forward<typename IDLType::ParameterType>(value));
     237        m_promise->resolve<IDLType>(std::forward<typename IDLType::ParameterType>(value));
    237238    }
    238239
    … …  
    256257    void resolve()
    257258    {
    258         m_promiseDeferred->resolve();
     259        m_promise->resolve();
    259260    }
    260261
    … …  
    275276void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&&, ArrayBuffer*);
    276277void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&&, const void*, size_t);
    277 WEBCORE_EXPORT void rejectPromiseWithExceptionIfAny(JSC::JSGlobalObject&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
     278WEBCORE_EXPORT void rejectPromiseWithExceptionIfAny(JSC::JSGlobalObject&, JSDOMGlobalObject&, JSC::JSPromise&);
    278279
    279280enum class RejectedPromiseWithTypeErrorCause { NativeGetter, InvalidThis };
    … …  
    282283using PromiseFunction = void(JSC::JSGlobalObject&, JSC::CallFrame&, Ref<DeferredPromise>&&);
    283284
    284 enum class PromiseExecutionScope { WindowOnly, WindowOrWorker };
    285 
    286 template<PromiseFunction promiseFunction, PromiseExecutionScope executionScope>
     285template<PromiseFunction promiseFunction>
    287286inline JSC::JSValue callPromiseFunction(JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame)
    288287{
    … …  
    291290
    292291    auto& globalObject = callerGlobalObject(lexicalGlobalObject, callFrame);
    293     JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::tryCreate(&globalObject);
    294 
    295     // promiseDeferred can be null when terminating a Worker abruptly.
    296     if (executionScope == PromiseExecutionScope::WindowOrWorker && !promiseDeferred)
    297         return JSC::jsUndefined();
    298 
    299     promiseFunction(lexicalGlobalObject, callFrame, DeferredPromise::create(globalObject, *promiseDeferred));
    300 
    301     rejectPromiseWithExceptionIfAny(lexicalGlobalObject, globalObject, *promiseDeferred);
    302     EXCEPTION_ASSERT_UNUSED(scope, !scope.exception());
    303     return promiseDeferred->promise();
     292    auto* promise = JSC::JSPromise::create(vm, globalObject.promiseStructure());
     293    ASSERT(promise);
     294
     295    promiseFunction(lexicalGlobalObject, callFrame, DeferredPromise::create(globalObject, *promise));
     296
     297    rejectPromiseWithExceptionIfAny(lexicalGlobalObject, globalObject, *promise);
     298    // FIXME: We could have error since any JS call can throw stack-overflow errors.
     299    // https://bugs.webkit.org/show_bug.cgi?id=203402
     300    RETURN_IF_EXCEPTION(scope, JSC::jsUndefined());
     301    return promise;
    304302}
    305303
    306 template<PromiseExecutionScope executionScope, typename PromiseFunctor>
     304template<typename PromiseFunctor>
    307305inline JSC::JSValue callPromiseFunction(JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame, PromiseFunctor functor)
    308306{
    … …  
    311309
    312310    auto& globalObject = callerGlobalObject(lexicalGlobalObject, callFrame);
    313     JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::tryCreate(&globalObject);
    314 
    315     // promiseDeferred can be null when terminating a Worker abruptly.
    316     if (executionScope == PromiseExecutionScope::WindowOrWorker && !promiseDeferred)
    317         return JSC::jsUndefined();
    318 
    319     functor(lexicalGlobalObject, callFrame, DeferredPromise::create(globalObject, *promiseDeferred));
    320 
    321     rejectPromiseWithExceptionIfAny(lexicalGlobalObject, globalObject, *promiseDeferred);
    322     EXCEPTION_ASSERT_UNUSED(scope, !scope.exception());
    323     return promiseDeferred->promise();
     311    auto* promise = JSC::JSPromise::create(vm, globalObject.promiseStructure());
     312    ASSERT(promise);
     313
     314    functor(lexicalGlobalObject, callFrame, DeferredPromise::create(globalObject, *promise));
     315
     316    rejectPromiseWithExceptionIfAny(lexicalGlobalObject, globalObject, *promise);
     317    // FIXME: We could have error since any JS call can throw stack-overflow errors.
     318    // https://bugs.webkit.org/show_bug.cgi?id=203402
     319    RETURN_IF_EXCEPTION(scope, JSC::jsUndefined());
     320    return promise;
    324321}
    325322
    … …  
    331328}
    332329
    333 template<BindingPromiseFunction bindingPromiseFunction, PromiseExecutionScope executionScope>
     330template<BindingPromiseFunction bindingPromiseFunction>
    334331inline JSC::JSValue callPromiseFunction(JSC::JSGlobalObject& lexicalGlobalObject, JSC::CallFrame& callFrame)
    335332{
    336     return callPromiseFunction<bindingPromiseFunctionAdapter<bindingPromiseFunction>, executionScope>(lexicalGlobalObject, callFrame);
     333    return callPromiseFunction<bindingPromiseFunctionAdapter<bindingPromiseFunction>>(lexicalGlobalObject, callFrame);
    337334}
    338335

  • trunk/Source/WebCore/bindings/js/JSDOMWindowBase.cpp

    r251529 r251691  
    5050#include <JavaScriptCore/CodeBlock.h>
    5151#include <JavaScriptCore/JSInternalPromise.h>
    52 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
    5352#include <JavaScriptCore/JSWebAssembly.h>
    5453#include <JavaScriptCore/Microtask.h>
    55 #include <JavaScriptCore/PromiseDeferredTimer.h>
     54#include <JavaScriptCore/PromiseTimer.h>
    5655#include <JavaScriptCore/StrongInlines.h>
    5756#include <wtf/Language.h>
    … …  
    318317    if (RefPtr<Document> document = thisObject->wrapped().document())
    319318        RELEASE_AND_RETURN(scope, document->moduleLoader().fetch(globalObject, moduleLoader, moduleKey, parameters, scriptFetcher));
    320     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::tryCreate(globalObject);
    321     RETURN_IF_EXCEPTION(scope, nullptr);
    322     RELEASE_AND_RETURN(scope, deferred->reject(globalObject, jsUndefined()));
     319    JSC::JSInternalPromise* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
     320    scope.release();
     321    promise->reject(globalObject, jsUndefined());
     322    return promise;
    323323}
    324324
    … …  
    338338    if (RefPtr<Document> document = thisObject->wrapped().document())
    339339        RELEASE_AND_RETURN(scope, document->moduleLoader().importModule(globalObject, moduleLoader, moduleName, parameters, sourceOrigin));
    340     JSC::JSInternalPromiseDeferred* deferred = JSC::JSInternalPromiseDeferred::tryCreate(globalObject);
    341     RETURN_IF_EXCEPTION(scope, nullptr);
    342     RELEASE_AND_RETURN(scope, deferred->reject(globalObject, jsUndefined()));
     340    JSC::JSInternalPromise* promise = JSC::JSInternalPromise::create(vm, globalObject->internalPromiseStructure());
     341    scope.release();
     342    promise->reject(globalObject, jsUndefined());
     343    return promise;
    343344}
    344345
    … …  
    352353
    353354#if ENABLE(WEBASSEMBLY)
    354 static Optional<Vector<uint8_t>> tryAllocate(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSPromiseDeferred* promise, const char* data, size_t byteSize)
     355static Optional<Vector<uint8_t>> tryAllocate(JSC::JSGlobalObject* lexicalGlobalObject, JSC::JSPromise* promise, const char* data, size_t byteSize)
    355356{
    356357    Vector<uint8_t> arrayBuffer;
    … …  
    366367}
    367368
    368 static bool isResponseCorrect(JSC::JSGlobalObject* lexicalGlobalObject, FetchResponse* inputResponse, JSC::JSPromiseDeferred* promise)
     369static bool isResponseCorrect(JSC::JSGlobalObject* lexicalGlobalObject, FetchResponse* inputResponse, JSC::JSPromise* promise)
    369370{
    370371    bool isResponseCorsSameOrigin = inputResponse->type() == ResourceResponse::Type::Basic || inputResponse->type() == ResourceResponse::Type::Cors || inputResponse->type() == ResourceResponse::Type::Default;
    … …  
    389390}
    390391
    391 static void handleResponseOnStreamingAction(JSC::JSGlobalObject* globalObject, FetchResponse* inputResponse, JSC::JSPromiseDeferred* promise, Function<void(JSC::JSGlobalObject* lexicalGlobalObject, const char* data, size_t byteSize)>&& actionCallback)
     392static void handleResponseOnStreamingAction(JSC::JSGlobalObject* globalObject, FetchResponse* inputResponse, JSC::JSPromise* promise, Function<void(JSC::JSGlobalObject* lexicalGlobalObject, const char* data, size_t byteSize)>&& actionCallback)
    392393{
    393394    if (!isResponseCorrect(globalObject, inputResponse, promise))
    … …  
    434435}
    435436
    436 void JSDOMWindowBase::compileStreaming(JSC::JSGlobalObject* globalObject, JSC::JSPromiseDeferred* promise, JSC::JSValue source)
     437void JSDOMWindowBase::compileStreaming(JSC::JSGlobalObject* globalObject, JSC::JSPromise* promise, JSC::JSValue source)
    437438{
    438439    ASSERT(source);
    … …  
    440441    VM& vm = globalObject->vm();
    441442
    442     ASSERT(vm.promiseDeferredTimer->hasPendingPromise(promise));
    443     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, globalObject));
     443    ASSERT(vm.promiseTimer->hasPendingPromise(promise));
     444    ASSERT(vm.promiseTimer->hasDependancyInPendingPromise(promise, globalObject));
    444445
    445446    if (auto inputResponse = JSFetchResponse::toWrapped(vm, source)) {
    … …  
    452453}
    453454
    454 void JSDOMWindowBase::instantiateStreaming(JSC::JSGlobalObject* globalObject, JSC::JSPromiseDeferred* promise, JSC::JSValue source, JSC::JSObject* importedObject)
     455void JSDOMWindowBase::instantiateStreaming(JSC::JSGlobalObject* globalObject, JSC::JSPromise* promise, JSC::JSValue source, JSC::JSObject* importedObject)
    455456{
    456457    ASSERT(source);
    … …  
    458459    VM& vm = globalObject->vm();
    459460
    460     ASSERT(vm.promiseDeferredTimer->hasPendingPromise(promise));
    461     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, globalObject));
    462     ASSERT(vm.promiseDeferredTimer->hasDependancyInPendingPromise(promise, importedObject));
     461    ASSERT(vm.promiseTimer->hasPendingPromise(promise));
     462    ASSERT(vm.promiseTimer->hasDependancyInPendingPromise(promise, globalObject));
     463    ASSERT(vm.promiseTimer->hasDependancyInPendingPromise(promise, importedObject));
    463464
    464465    if (auto inputResponse = JSFetchResponse::toWrapped(vm, source)) {

  • trunk/Source/WebCore/bindings/js/JSDOMWindowBase.h

    r251457 r251691  
    9999
    100100#if ENABLE(WEBASSEMBLY)
    101     static void compileStreaming(JSC::JSGlobalObject*, JSC::JSPromiseDeferred*, JSC::JSValue);
    102     static void instantiateStreaming(JSC::JSGlobalObject*, JSC::JSPromiseDeferred*, JSC::JSValue, JSC::JSObject*);
     101    static void compileStreaming(JSC::JSGlobalObject*, JSC::JSPromise*, JSC::JSValue);
     102    static void instantiateStreaming(JSC::JSGlobalObject*, JSC::JSPromise*, JSC::JSValue, JSC::JSObject*);
    103103#endif
    104104

  • trunk/Source/WebCore/bindings/js/ScriptModuleLoader.cpp

    r251582 r251691  
    4444#include <JavaScriptCore/Completion.h>
    4545#include <JavaScriptCore/JSInternalPromise.h>
    46 #include <JavaScriptCore/JSInternalPromiseDeferred.h>
    4746#include <JavaScriptCore/JSModuleRecord.h>
    4847#include <JavaScriptCore/JSScriptFetchParameters.h>
    … …  
    148147
    149148    auto& globalObject = *JSC::jsCast<JSDOMGlobalObject*>(jsGlobalObject);
    150     auto* jsPromise = JSC::JSInternalPromiseDeferred::tryCreate(&globalObject);
     149    auto* jsPromise = JSC::JSInternalPromise::create(vm, globalObject.internalPromiseStructure());
    151150    RELEASE_ASSERT(jsPromise);
    152151    auto deferred = DeferredPromise::create(globalObject, *jsPromise);
    153152    if (moduleKeyValue.isSymbol()) {
    154153        deferred->reject(TypeError, "Symbol module key should be already fulfilled with the inlined resource."_s);
    155         return jsPromise->promise();
     154        return jsPromise;
    156155    }
    157156
    158157    if (!moduleKeyValue.isString()) {
    159158        deferred->reject(TypeError, "Module key is not Symbol or String."_s);
    160         return jsPromise->promise();
     159        return jsPromise;
    161160    }
    162161
    … …  
    166165    if (!completedURL.isValid()) {
    167166        deferred->reject(TypeError, "Module key is a valid URL."_s);
    168         return jsPromise->promise();
     167        return jsPromise;
    169168    }
    170169
    … …  
    179178        m_loaders.remove(WTFMove(loader));
    180179        rejectToPropagateNetworkError(deferred.get(), ModuleFetchFailureKind::WasErrored, "Importing a module script failed."_s);
    181         return jsPromise->promise();
    182     }
    183 
    184     return jsPromise->promise();
     180        return jsPromise;
     181    }
     182
     183    return jsPromise;
    185184}
    186185
    … …  
    217216static JSC::JSInternalPromise* rejectPromise(JSDOMGlobalObject& globalObject, ExceptionCode ec, ASCIILiteral message)
    218217{
    219     auto* jsPromise = JSC::JSInternalPromiseDeferred::tryCreate(&globalObject);
     218    auto* jsPromise = JSInternalPromise::create(globalObject.vm(), globalObject.internalPromiseStructure());
    220219    RELEASE_ASSERT(jsPromise);
    221220    auto deferred = DeferredPromise::create(globalObject, *jsPromise);
    222221    deferred->reject(ec, WTFMove(message));
    223     return jsPromise->promise();
     222    return jsPromise;
    224223}
    225224

  • trunk/Source/WebCore/bindings/js/WorkerScriptController.cpp

    r251425 r251691  
    4343#include <JavaScriptCore/JSCInlines.h>
    4444#include <JavaScriptCore/JSLock.h>
    45 #include <JavaScriptCore/PromiseDeferredTimer.h>
     45#include <JavaScriptCore/PromiseTimer.h>
    4646#include <JavaScriptCore/StrongInlines.h>
    4747
    … …  
    251251    processTimer(m_vm->heap.fullActivityCallback());
    252252    processTimer(m_vm->heap.edenActivityCallback());
    253     processTimer(m_vm->promiseDeferredTimer.ptr());
     253    processTimer(m_vm->promiseTimer.ptr());
    254254}
    255255
    … …  
    264264    processTimer(m_vm->heap.fullActivityCallback());
    265265    processTimer(m_vm->heap.edenActivityCallback());
    266     processTimer(m_vm->promiseDeferredTimer.ptr());
     266    processTimer(m_vm->promiseTimer.ptr());
    267267}
    268268

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r251518 r251691  
    51985198    my @callFunctionTemplateArguments = ();
    51995199    push(@callFunctionTemplateArguments, $functionBodyName);
    5200     push(@callFunctionTemplateArguments, "PromiseExecutionScope::${exposureScope}") if $hasPromiseReturnType && !$operation->extendedAttributes->{ReturnsOwnPromise};
    52015200    push(@callFunctionTemplateArguments, "CastedThisErrorBehavior::Assert") if ($operation->extendedAttributes->{PrivateIdentifier} and not $operation->extendedAttributes->{PublicIdentifier});
    52025201

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestGlobalObject.cpp

    r251425 r251691  
    26862686EncodedJSValue JSC_HOST_CALL jsTestGlobalObjectInstanceFunctionCalculateSecretResult(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    26872687{
    2688     return IDLOperationReturningPromise<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionCalculateSecretResultBody, PromiseExecutionScope::WindowOnly>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
     2688    return IDLOperationReturningPromise<JSTestGlobalObject>::call<jsTestGlobalObjectInstanceFunctionCalculateSecretResultBody>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
    26892689}
    26902690

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp

    r251425 r251691  
    307307EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    308308{
    309     return IDLOperationReturningPromise<JSTestNode>::call<jsTestNodePrototypeFunctionTestWorkerPromiseBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testWorkerPromise");
     309    return IDLOperationReturningPromise<JSTestNode>::call<jsTestNodePrototypeFunctionTestWorkerPromiseBody>(*lexicalGlobalObject, *callFrame, "testWorkerPromise");
    310310}
    311311
    … …  
    322322EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionCalculateSecretResult(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    323323{
    324     return IDLOperationReturningPromise<JSTestNode>::call<jsTestNodePrototypeFunctionCalculateSecretResultBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
     324    return IDLOperationReturningPromise<JSTestNode>::call<jsTestNodePrototypeFunctionCalculateSecretResultBody>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
    325325}
    326326

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r251425 r251691  
    56305630EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionCalculateSecretResult(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    56315631{
    5632     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionCalculateSecretResultBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
     5632    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionCalculateSecretResultBody>(*lexicalGlobalObject, *callFrame, "calculateSecretResult");
    56335633}
    56345634
    … …  
    83808380EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    83818381{
    8382     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testPromiseFunction");
     8382    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionBody>(*lexicalGlobalObject, *callFrame, "testPromiseFunction");
    83838383}
    83848384
    … …  
    83998399EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    84008400{
    8401     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithFloatArgument");
     8401    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentBody>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithFloatArgument");
    84028402}
    84038403
    … …  
    84148414EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    84158415{
    8416     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithException");
     8416    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionBody>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithException");
    84178417}
    84188418
    … …  
    84318431EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    84328432{
    8433     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithOptionalIntArgument");
     8433    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentBody>(*lexicalGlobalObject, *callFrame, "testPromiseFunctionWithOptionalIntArgument");
    84348434}
    84358435
    … …  
    84798479EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    84808480{
    8481     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseOverloadedFunctionOverloadDispatcher, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testPromiseOverloadedFunction");
     8481    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestPromiseOverloadedFunctionOverloadDispatcher>(*lexicalGlobalObject, *callFrame, "testPromiseOverloadedFunction");
    84828482}
    84838483
    … …  
    84938493EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    84948494{
    8495     return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticPromiseFunctionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testStaticPromiseFunction");
     8495    return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticPromiseFunctionBody>(*lexicalGlobalObject, *callFrame, "testStaticPromiseFunction");
    84968496}
    84978497
    … …  
    85078507EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    85088508{
    8509     return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testStaticPromiseFunctionWithException");
     8509    return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionBody>(*lexicalGlobalObject, *callFrame, "testStaticPromiseFunctionWithException");
    85108510}
    85118511
    … …  
    85208520EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestCustomPromiseFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    85218521{
    8522     return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestCustomPromiseFunctionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testCustomPromiseFunction");
     8522    return IDLOperationReturningPromise<JSTestObj>::call<jsTestObjPrototypeFunctionTestCustomPromiseFunctionBody>(*lexicalGlobalObject, *callFrame, "testCustomPromiseFunction");
    85238523}
    85248524
    … …  
    85338533EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticCustomPromiseFunction(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame)
    85348534{
    8535     return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticCustomPromiseFunctionBody, PromiseExecutionScope::WindowOrWorker>(*lexicalGlobalObject, *callFrame, "testStaticCustomPromiseFunction");
     8535    return IDLOperationReturningPromise<JSTestObj>::callStatic<jsTestObjConstructorFunctionTestStaticCustomPromiseFunctionBody>(*lexicalGlobalObject, *callFrame, "testStaticCustomPromiseFunction");
    85368536}
    85378537

  • trunk/Source/WebCore/workers/WorkerRunLoop.cpp

    r248846 r251691  
    3939#include "WorkerGlobalScope.h"
    4040#include "WorkerThread.h"
    41 #include <JavaScriptCore/PromiseDeferredTimer.h>
     41#include <JavaScriptCore/PromiseTimer.h>
    4242
    4343#if USE(GLIB)

  • trunk/Source/WebCore/worklets/WorkletScriptController.cpp

    r251425 r251691  
    4242#include <JavaScriptCore/GCActivityCallback.h>
    4343#include <JavaScriptCore/JSLock.h>
    44 #include <JavaScriptCore/PromiseDeferredTimer.h>
     44#include <JavaScriptCore/PromiseTimer.h>
    4545#include <JavaScriptCore/StrongInlines.h>
    4646
Note: See TracChangeset for help on using the changeset viewer.