Attachment #289063 for bug #161787

View Details Raw Unified Return to Bug 161787

| Differences between



2016-09-16  Youenn Fablet  <youenn@apple.com>

        Improve DeferredWrapper code
        https://bugs.webkit.org/show_bug.cgi?id=161787

        Reviewed by NOBODY (OOPS!).

        No change of behavior.

        Renaming DeferredWrapper to DOMPromiseDeferred.
        Introduced DOMGenericPromise as a ref of DOMPromiseDeferred to improve readability of code.
        Adding create method that creates the underlying JSC::JSPromiseDeferred in non-worker environments.
        Updated create method to take references.
        Introducing domWindow helper accessor into JSDOMObject to ease creation of promise in non-worker environments.
        Doing some minor clean up (renaming of m_wrapper to m_promiseDeferred, accessor change).

        * Modules/applepay/ApplePaySession.cpp:
        (WebCore::ApplePaySession::canMakePaymentsWithActiveCard):
        * Modules/applepay/ApplePaySession.h:
        * Modules/fetch/DOMWindowFetch.cpp:
        (WebCore::DOMWindowFetch::fetch):
        * Modules/fetch/DOMWindowFetch.h: Updated to take a DOMPromiseDeferred to make it consistent with WorkerGlobalScopeFetch.
        * Modules/fetch/FetchBody.cpp:
        (WebCore::FetchBody::arrayBuffer):
        (WebCore::FetchBody::blob):
        (WebCore::FetchBody::json):
        (WebCore::FetchBody::text):
        (WebCore::FetchBody::consume):
        (WebCore::FetchBody::consumeArrayBuffer):
        (WebCore::FetchBody::consumeArrayBufferView):
        (WebCore::FetchBody::consumeText):
        (WebCore::FetchBody::consumeBlob):
        * Modules/fetch/FetchBody.h:
        (WebCore::FetchBody::formData):
        * Modules/fetch/FetchBodyConsumer.cpp:
        (WebCore::FetchBodyConsumer::resolveWithData):
        (WebCore::FetchBodyConsumer::resolve):
        * Modules/fetch/FetchBodyConsumer.h:
        * Modules/fetch/FetchBodyOwner.cpp:
        (WebCore::FetchBodyOwner::arrayBuffer):
        (WebCore::FetchBodyOwner::blob):
        (WebCore::FetchBodyOwner::formData):
        (WebCore::FetchBodyOwner::json):
        (WebCore::FetchBodyOwner::text):
        * Modules/fetch/FetchBodyOwner.h:
        * Modules/fetch/FetchResponse.cpp:
        (WebCore::FetchResponse::consume):
        (WebCore::FetchResponse::finishConsumingStream):
        * Modules/fetch/FetchResponse.h:
        * Modules/fetch/WorkerGlobalScopeFetch.cpp:
        (WebCore::WorkerGlobalScopeFetch::fetch):
        * Modules/fetch/WorkerGlobalScopeFetch.h:
        * bindings/js/JSCustomElementRegistryCustom.cpp:
        (WebCore::whenDefinedPromise):
        (WebCore::JSCustomElementRegistry::whenDefined):
        * bindings/js/JSDOMGlobalObject.cpp:
        (WebCore::JSDOMGlobalObject::visitChildren):
        * bindings/js/JSDOMGlobalObject.h:
        * bindings/js/JSDOMPromise.cpp:
        (WebCore::DOMDeferredPromise::DOMDeferredPromise):
        (WebCore::DOMDeferredPromise::~DOMDeferredPromise):
        (WebCore::DOMDeferredPromise::clear):
        (WebCore::DOMDeferredPromise::contextDestroyed):
        (WebCore::DOMDeferredPromise::promise):
        (WebCore::DOMDeferredPromise::callFunction):
        (WebCore::DOMDeferredPromise::reject):
        (WebCore::rejectPromiseWithExceptionIfAny):
        (WebCore::fulfillPromiseWithJSON):
        (WebCore::fulfillPromiseWithArrayBuffer):
        (WebCore::DeferredWrapper::DeferredWrapper): Deleted.
        (WebCore::DeferredWrapper::~DeferredWrapper): Deleted.
        (WebCore::DeferredWrapper::clear): Deleted.
        (WebCore::DeferredWrapper::contextDestroyed): Deleted.
        (WebCore::DeferredWrapper::promise): Deleted.
        (WebCore::DeferredWrapper::callFunction): Deleted.
        (WebCore::DeferredWrapper::reject): Deleted.
        * bindings/js/JSDOMPromise.h:
        (WebCore::DOMDeferredPromise::create):
        (WebCore::callPromiseFunction):
        (WebCore::DOMPromise::DOMPromise):
        (WebCore::DOMPromise::deferredPromise):
        (WebCore::DOMDeferredPromise::resolveWithValue):
        (WebCore::DOMDeferredPromise::resolveWithNewlyCreated):
        (WebCore::DOMDeferredPromise::rejectWithValue):
        (WebCore::DOMDeferredPromise::resolve):
        (WebCore::DOMDeferredPromise::reject):
        (WebCore::DeferredWrapper::create): Deleted.
        (WebCore::DOMPromise::deferredWrapper): Deleted.
        (WebCore::DeferredWrapper::resolveWithValue): Deleted.
        (WebCore::DeferredWrapper::resolveWithNewlyCreated): Deleted.
        (WebCore::DeferredWrapper::rejectWithValue): Deleted.
        (WebCore::DeferredWrapper::resolve): Deleted.
        (WebCore::DeferredWrapper::reject): Deleted.
        * bindings/js/JSDOMWrapper.cpp: Introducing domWindow() accessor.
        * bindings/js/JSDOMWrapper.h:
        * bindings/js/JSFontFaceCustom.cpp:
        (WebCore::JSFontFace::loaded):
        * bindings/js/JSFontFaceSetCustom.cpp:
        (WebCore::JSFontFaceSet::ready):
        * bindings/js/JSMediaDevicesCustom.cpp:
        (WebCore::JSMediaDevices::getUserMedia):
        * bindings/js/JSMediaStreamTrackCustom.cpp:
        (WebCore::JSMediaStreamTrack::applyConstraints):
        * bindings/js/JSReadableStreamSourceCustom.cpp:
        (WebCore::JSReadableStreamSource::start):
        * bindings/js/JSWebKitSubtleCryptoCustom.cpp:
        (WebCore::JSWebKitSubtleCrypto::encrypt):
        (WebCore::JSWebKitSubtleCrypto::decrypt):
        (WebCore::JSWebKitSubtleCrypto::sign):
        (WebCore::JSWebKitSubtleCrypto::verify):
        (WebCore::JSWebKitSubtleCrypto::digest):
        (WebCore::JSWebKitSubtleCrypto::generateKey):
        (WebCore::JSWebKitSubtleCrypto::importKey):
        (WebCore::JSWebKitSubtleCrypto::exportKey):
        (WebCore::JSWebKitSubtleCrypto::wrapKey):
        (WebCore::JSWebKitSubtleCrypto::unwrapKey):
        * bindings/scripts/CodeGeneratorJS.pm:
        (GenerateImplementation):
        (GenerateReturnParameters):
        * bindings/scripts/test/JS/JSTestObj.cpp:
        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionPromise):
        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise):
        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise):
        (WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise):
        (WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise):
        (WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise):
        (WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise):
        (WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise):
        * dom/CustomElementRegistry.h:
        (WebCore::CustomElementRegistry::promiseMap):

2016-09-16  Javier Fernandez  <jfernandez@igalia.com>

        [GTK] Unreviewed build fix after r206007.



    return paymentCoordinator.canMakePayments();
}

void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DOMPromiseDeferred>&& passedPromise, ExceptionCode& ec)
{
    auto& document = downcast<Document>(scriptExecutionContext);
    DOMWindow& window = *document.domWindow();

        return;
    }

    RefPtr<DOMPromiseDeferred> promise(WTFMove(passedPromise));
    if (!shouldDiscloseApplePayCapability(document)) {
        auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();
        bool canMakePayments = paymentCoordinator.canMakePayments();



namespace WebCore {

class ArrayValue;
class DOMPromiseDeferred;
class Dictionary;
class Document;
class Payment;


    static bool supportsVersion(ScriptExecutionContext&, unsigned version, ExceptionCode&);
    static bool canMakePayments(ScriptExecutionContext&, ExceptionCode&);
    static void canMakePaymentsWithActiveCard(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DOMPromiseDeferred>&&, ExceptionCode&);

    void begin(ExceptionCode&);
    void abort(ExceptionCode&);

Lines 37-43 a/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp_sec1
- a/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp -1 / +1 lines
37		37
38	namespace WebCore {	38	namespace WebCore {
39		39
40	void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, DOMPromise<FetchResponse>&& promise)	40	void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, DOMGenericPromise&& promise)
41	{	41	{
42	if (!window.scriptExecutionContext())	42	if (!window.scriptExecutionContext())
43	return;	43	return;



namespace WebCore {

class DOMWindow;
class DeferredWrapper;
class Dictionary;
class FetchRequest;
class FetchResponse;

class DOMWindowFetch {
public:
    static void fetch(DOMWindow&, FetchRequest&, DOMGenericPromise&&);
};

} // namespace WebCore



        headers.fastSet(HTTPHeaderName::ContentType, m_contentType);
}

void FetchBody::arrayBuffer(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    ASSERT(m_type != Type::None);
    m_consumer.setType(FetchBodyConsumer::Type::ArrayBuffer);
    consume(owner, WTFMove(promise));
}

void FetchBody::blob(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    ASSERT(m_type != Type::None);
    m_consumer.setType(FetchBodyConsumer::Type::Blob);

    consume(owner, WTFMove(promise));
}

void FetchBody::json(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    ASSERT(m_type != Type::None);


    consume(owner, WTFMove(promise));
}

void FetchBody::text(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    ASSERT(m_type != Type::None);


    consume(owner, WTFMove(promise));
}

void FetchBody::consume(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    // This should be handled by FetchBodyOwner
    ASSERT(m_type != Type::None);

}
#endif

void FetchBody::consumeArrayBuffer(DOMGenericPromise&& promise)
{
    ASSERT(m_data);
    m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_data->data()), m_data->byteLength());
    m_data = nullptr;
}

void FetchBody::consumeArrayBufferView(DOMGenericPromise&& promise)
{
    ASSERT(m_dataView);
    m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_dataView->baseAddress()), m_dataView->byteLength());
    m_dataView = nullptr;
}

void FetchBody::consumeText(DOMGenericPromise&& promise)
{
    Vector<uint8_t> data = extractFromText();
    m_consumer.resolveWithData(WTFMove(promise), data.data(), data.size());
    m_text = { };
}

void FetchBody::consumeBlob(FetchBodyOwner& owner, DOMGenericPromise&& promise)
{
    ASSERT(m_blob);





class FetchBody {
public:
    void arrayBuffer(FetchBodyOwner&, DOMGenericPromise&&);
    void blob(FetchBodyOwner&, DOMGenericPromise&&);
    void json(FetchBodyOwner&, DOMGenericPromise&&);
    void text(FetchBodyOwner&, DOMGenericPromise&&);
    void formData(FetchBodyOwner&, DOMGenericPromise&& promise) { promise.get().reject(0); }

#if ENABLE(READABLE_STREAM_API)
    void consumeAsStream(FetchBodyOwner&, FetchResponseSource&);

    FetchBody(String&&);
    FetchBody(Type type) : m_type(type) { }

    void consume(FetchBodyOwner&, DOMGenericPromise&&);

    Vector<uint8_t> extractFromText() const;
    void consumeArrayBuffer(DOMGenericPromise&&);
    void consumeArrayBufferView(DOMGenericPromise&&);
    void consumeText(DOMGenericPromise&&);
    void consumeBlob(FetchBodyOwner&, DOMGenericPromise&&);

    Type m_type { Type::None };
    String m_contentType;

    String m_text;

    FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };
    RefPtr<DOMPromiseDeferred> m_consumePromise;
};

} // namespace WebCore



    return decoder->decodeAndFlush(reinterpret_cast<const char*>(data), length);
}

void FetchBodyConsumer::resolveWithData(DOMGenericPromise&& promise, const unsigned char* data, unsigned length)
{
    switch (m_type) {
    case Type::ArrayBuffer:

    }
}

void FetchBodyConsumer::resolve(DOMGenericPromise&& promise)
{
    ASSERT(m_type != Type::None);
    switch (m_type) {




#if ENABLE(FETCH_API)

#include "JSDOMPromise.h"
#include "SharedBuffer.h"

namespace WebCore {

class Blob;
class DeferredWrapper;

class FetchBodyConsumer {
public:


    void clean() { m_buffer = nullptr; }

    void resolve(DOMGenericPromise&&);
    void resolveWithData(DOMGenericPromise&&, const unsigned char*, unsigned);

    bool hasData() const { return !!m_buffer; }




    return false;
}

void FetchBodyOwner::arrayBuffer(DOMGenericPromise&& promise)
{
    if (m_body.isEmpty()) {
        fulfillPromiseWithArrayBuffer(WTFMove(promise), nullptr, 0);

    m_body.arrayBuffer(*this, WTFMove(promise));
}

void FetchBodyOwner::blob(DOMGenericPromise&& promise)
{
    if (m_body.isEmpty()) {
        promise->resolve(Blob::create(Vector<uint8_t>(), Blob::normalizedContentType(extractMIMETypeFromMediaType(m_body.contentType()))));

    m_body.blob(*this, WTFMove(promise));
}

void FetchBodyOwner::formData(DOMGenericPromise&& promise)
{
    if (m_body.isEmpty()) {
        promise->reject(0);

    m_body.formData(*this, WTFMove(promise));
}

void FetchBodyOwner::json(DOMGenericPromise&& promise)
{
    if (m_body.isEmpty()) {
        promise->reject(SYNTAX_ERR);

    m_body.json(*this, WTFMove(promise));
}

void FetchBodyOwner::text(DOMGenericPromise&& promise)
{
    if (m_body.isEmpty()) {
        promise->resolve(String());



    // Exposed Body API
    bool isDisturbed() const { return m_isDisturbed; };

    void arrayBuffer(DOMGenericPromise&&);
    void blob(DOMGenericPromise&&);
    void formData(DOMGenericPromise&&);
    void json(DOMGenericPromise&&);
    void text(DOMGenericPromise&&);

    bool isDisturbedOrLocked() const;




        m_loader->stop();
}

void FetchResponse::consume(unsigned type, DOMGenericPromise&& wrapper)
{
    ASSERT(type <= static_cast<unsigned>(FetchBodyConsumer::Type::Text));


    m_consumer.append(chunk->data(), chunk->byteLength());
}

void FetchResponse::finishConsumingStream(DOMGenericPromise&& promise)
{
    m_consumer.resolve(WTFMove(promise));
}



    using FetchPromise = DOMPromise<FetchResponse>;
    static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);

    void consume(unsigned, DOMGenericPromise&&);
#if ENABLE(READABLE_STREAM_API)
    void startConsumingStream(unsigned);
    void consumeChunk(Ref<JSC::Uint8Array>&&);
    void finishConsumingStream(DOMGenericPromise&&);
#endif

    void setStatus(int, const String&, ExceptionCode&);

Lines 36-42 a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp_sec1
- a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp -1 / +1 lines
36		36
37	namespace WebCore {	37	namespace WebCore {
38		38
39	void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, Ref<DeferredWrapper>&& promise)	39	void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, DOMGenericPromise&& promise)
40	{	40	{
41	if (!scope.scriptExecutionContext())	41	if (!scope.scriptExecutionContext())
42	return;	42	return;



#if ENABLE(FETCH_API)

#include "JSDOMPromise.h"
#include <wtf/Forward.h>

namespace WebCore {

class WorkerGlobalScope;
class DeferredWrapper;
class FetchRequest;
class WorkerGlobalScope;

class WorkerGlobalScopeFetch {
public:
    static void fetch(WorkerGlobalScope&, FetchRequest&, DOMGenericPromise&&);
};

} // namespace WebCore



		416E6FE81BBD12DF000A6053 /* WritableStreamInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E9 /* WritableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
		416E6FE91BBD12E5000A6043 /* ReadableStreamBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D8 /* ReadableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
		416E6FE91BBD12E5000A6053 /* WritableStreamBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E8 /* WritableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
		4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */; };
		417253AA1354BBBC00360F2A /* MediaControlElements.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 417253A81354BBBC00360F2A /* MediaControlElements.cpp */; };
		417253AB1354BBBC00360F2A /* MediaControlElements.h in Headers */ = {isa = PBXBuildFile; fileRef = 417253A91354BBBC00360F2A /* MediaControlElements.h */; };
		417DA6D913734E6E007C57FB /* Internals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 417DA4CF13734326007C57FB /* Internals.cpp */; };

		4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };
		4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
		416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
		4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
		417253A81354BBBC00360F2A /* MediaControlElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaControlElements.cpp; sourceTree = "<group>"; };
		417253A91354BBBC00360F2A /* MediaControlElements.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaControlElements.h; sourceTree = "<group>"; };
		417DA4CE13734326007C57FB /* Internals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Internals.h; sourceTree = "<group>"; };

				460CBF341D4BCCFE0092E88E /* JSDOMWindowProperties.h */,
				BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */,
				BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */,
				4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */,
				65E0E9431133C89F00B4CB10 /* JSDOMWrapper.h */,
				F3D461461161D53200CA0D09 /* JSErrorHandler.cpp */,
				F3D461471161D53200CA0D09 /* JSErrorHandler.h */,

				314BE3A61B3103FB00141982 /* NamedImageGeneratedImage.cpp in Sources */,
				BCF34A3711A231CD00C71804 /* NamedNodeMap.cpp in Sources */,
				A81872240977D3C0005826D9 /* NameNodeList.cpp in Sources */,
				4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources */,
				8306EFF11B8BCEA50031D032 /* NativeNodeFilter.cpp in Sources */,
				E10B9B6D0B747599003ED890 /* NativeXPathNSResolver.cpp in Sources */,
				93CCF0600AF6CA7600018E89 /* NavigationAction.cpp in Sources */,



}

// https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry, JSPromiseDeferred& promiseDeferred)
{
    auto scope = DECLARE_THROW_SCOPE(state.vm());


    if (UNLIKELY(scope.exception()))
        return jsUndefined();

    if (!validateCustomElementNameAndThrowIfNeeded(state, localName)) {
        ASSERT(scope.exception());
        return jsUndefined();
    }

    if (registry.findInterface(localName)) {
        DOMPromiseDeferred::create(globalObject, promiseDeferred)->resolve(nullptr);
        return promiseDeferred.promise();
        return jsPromise.promise();
    }

    auto result = registry.promiseMap().ensure(localName, [&] {
        return DOMPromiseDeferred::create(globalObject, promiseDeferred);
    });

    return result.iterator->value->promise();

{
    auto scope = DECLARE_CATCH_SCOPE(state.vm());

    ASSERT(globalObject());
    auto promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    ASSERT(promiseDeferred);
    JSValue promise = whenDefinedPromise(state, *globalObject(), wrapped(), *promiseDeferred);

    if (UNLIKELY(scope.exception())) {
        rejectPromiseWithExceptionIfAny(state, *globalObject(), *promiseDeferred);
        ASSERT(!scope.exception());
        return promiseDeferred->promise();
    }

    return promise;



    for (auto& constructor : thisObject->constructors().values())
        visitor.append(&constructor);

    for (auto& deferredPromise : thisObject->deferredPromises())
        deferredPromise->visitAggregate(visitor);

    thisObject->m_builtinInternalFunctions.visit(visitor);
}




namespace WebCore {

    class DOMPromiseDeferred;
    class Document;
    class Event;
    class DOMWrapperWorld;


    typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::Structure>> JSDOMStructureMap;
    typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::JSObject>> JSDOMConstructorMap;
    typedef HashSet<DOMPromiseDeferred*> DOMPromiseDeferredSet;

    class WEBCORE_EXPORT JSDOMGlobalObject : public JSC::JSGlobalObject {
        typedef JSC::JSGlobalObject Base;

        JSDOMStructureMap& structures() { return m_structures; }
        JSDOMConstructorMap& constructors() { return m_constructors; }

        DOMPromiseDeferredSet& deferredPromises() { return m_deferredPromises; }

        ScriptExecutionContext* scriptExecutionContext() const;


    protected:
        JSDOMStructureMap m_structures;
        JSDOMConstructorMap m_constructors;
        DOMPromiseDeferredSet m_deferredPromises;

        Event* m_currentEvent;
        Ref<DOMWrapperWorld> m_world;




#include "ExceptionCode.h"
#include "JSDOMError.h"
#include "JSDOMWindow.h"
#include <builtins/BuiltinNames.h>
#include <runtime/Exception.h>
#include <runtime/JSONObject.h>


namespace WebCore {

DOMPromiseDeferred::DOMPromiseDeferred(JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
    : ActiveDOMCallback(globalObject.scriptExecutionContext())
    , m_deferred(&promiseDeferred)
    , m_globalObject(&globalObject)
{
    globalObject.vm().heap.writeBarrier(&globalObject, &promiseDeferred);
    globalObject.deferredPromises().add(this);
}

DOMPromiseDeferred::~DOMPromiseDeferred()
{
    clear();
}

void DOMPromiseDeferred::clear()
{
    ASSERT(!m_deferred || m_globalObject);
    if (m_deferred && m_globalObject)
        m_globalObject->deferredPromises().remove(this);
    m_deferred.clear();
}

void DOMPromiseDeferred::contextDestroyed()
{
    ActiveDOMCallback::contextDestroyed();
    clear();
}

JSC::JSValue DOMPromiseDeferred::promise() const
{
    ASSERT(m_deferred);
    return m_deferred->promise();
}

void DOMPromiseDeferred::callFunction(ExecState& exec, JSValue function, JSValue resolution)
{
    if (!canInvokeCallback())
        return;

    clear();
}

void DOMPromiseDeferred::reject(ExceptionCode ec, const String& message)
{
    if (isSuspended())
        return;

    JSValue error = scope.exception()->value();
    scope.clearException();

    DOMPromiseDeferred::create(globalObject, promiseDeferred)->reject(error);
}

DOMGenericPromise createDOMGenericPromise(JSC::ExecState& state, JSDOMWindow& domWindow)
{
    JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &domWindow);
    // deferred can only be null in workers.
    ASSERT(deferred);
    return DOMPromiseDeferred::create(domWindow, *deferred);
}

JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState& state, const String& errorMessage)

    return JSC::JSONParse(state, data);
}

void fulfillPromiseWithJSON(DOMGenericPromise&& promise, const String& data)
{
    JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);
    if (!value)

        promise->resolve(value);
}

void fulfillPromiseWithArrayBuffer(DOMGenericPromise&& promise, ArrayBuffer* arrayBuffer)
{
    if (!arrayBuffer) {
        promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));

    promise->resolve(arrayBuffer);
}

void fulfillPromiseWithArrayBuffer(DOMGenericPromise&& promise, const void* data, size_t length)
{
    fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());
}



    static constexpr bool passByConstRef = false;
};

class DOMPromiseDeferred : public RefCounted<DOMPromiseDeferred>, public ActiveDOMCallback {
public:
    static Ref<DOMPromiseDeferred> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred)
    static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
    {
        return adoptRef(*new DOMPromiseDeferred(globalObject, deferred));
    }

    ~DOMPromiseDeferred();

    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
    resolve(ResolveResultType result) { resolveWithValue(result); }

    void visitAggregate(JSC::SlotVisitor& visitor) { visitor.appendUnbarrieredWeak(&m_deferred); }

private:
    DOMPromiseDeferred(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);

    void clear();
    void contextDestroyed() override;

    JSC::Weak<JSDOMGlobalObject> m_globalObject;
};

using DOMGenericPromise = Ref<DOMPromiseDeferred>;
DOMGenericPromise createDOMGenericPromise(JSC::ExecState&, JSDOMWindow&);

void fulfillPromiseWithJSON(DOMGenericPromise&&, const String&);
void fulfillPromiseWithArrayBuffer(DOMGenericPromise&&, ArrayBuffer*);
void fulfillPromiseWithArrayBuffer(DOMGenericPromise&&, const void*, size_t);
void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState&, const String&);

using PromiseFunction = void(JSC::ExecState&, Ref<DOMPromiseDeferred>&&);

enum class PromiseExecutionScope { WindowOnly, WindowOrWorker };


    if (executionScope == PromiseExecutionScope::WindowOrWorker && !promiseDeferred)
        return JSC::jsUndefined();

    promiseFunction(state, DOMPromiseDeferred::create(globalObject, *promiseDeferred));

    rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
    ASSERT_UNUSED(scope, !scope.exception());
    return promiseDeferred->promise();
}

using BindingPromiseFunction = JSC::EncodedJSValue(JSC::ExecState*, DOMGenericPromise&&);
template<BindingPromiseFunction bindingFunction>
inline void bindingPromiseFunctionAdapter(JSC::ExecState& state, DOMGenericPromise&& promise)
{
    bindingFunction(&state, WTFMove(promise));
}

template <typename Value>
class DOMPromise {
public:
    DOMPromise(DOMGenericPromise&& genericPromise) : m_promiseDeferred(WTFMove(genericPromise)) { }
        : m_wrapper(WTFMove(wrapper))
    {
    }

    DOMPromise(DOMPromise&& promise) : m_promiseDeferred(WTFMove(promise.m_promiseDeferred)) { }

    DOMPromise(const DOMPromise&) = default;
    DOMPromise& operator=(DOMPromise const&) = default;

    void resolve(typename PromiseResultInspector<Value>::Type value) { m_promiseDeferred->resolve(value); }

    template<typename... ErrorType> void reject(ErrorType&&... error) { m_promiseDeferred->reject(std::forward<ErrorType>(error)...); }

    JSC::JSValue promise() const { return m_promiseDeferred->promise(); };

private:
    DOMGenericPromise m_promiseDeferred;
};

template<class ResolveResultType>
inline void DOMPromiseDeferred::resolveWithValue(ResolveResultType&& result)
{
    if (isSuspended())
        return;

}

template<class ResolveResultType>
inline void DOMPromiseDeferred::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
{
    if (isSuspended())
        return;

}

template<class RejectResultType>
inline void DOMPromiseDeferred::rejectWithValue(RejectResultType&& result)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::resolve(bool result)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::resolve(JSC::JSValue value)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::reject(JSC::JSValue value)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::resolve(std::nullptr_t)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::reject(std::nullptr_t)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::resolve(const String& result)
{
    if (isSuspended())
        return;

}

template<>
inline void DOMPromiseDeferred::reject(const String& result)
{
    if (isSuspended())
        return;

Lines 27-32 a/Source/WebCore/bindings/js/JSDOMWrapper.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMWrapper.cpp +8 lines
27	#include "JSDOMWrapper.h"	27	#include "JSDOMWrapper.h"
28		28
29	#include "DOMWrapperWorld.h"	29	#include "DOMWrapperWorld.h"
		30	#include "JSDOMWindow.h"
30	#include <runtime/Error.h>	31	#include <runtime/Error.h>
31		32
32	using namespace JSC;	33	using namespace JSC;
Lines 35-38 namespace WebCore { a/Source/WebCore/bindings/js/JSDOMWrapper.cpp_sec2
35		36
36	STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSDOMObject);	37	STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSDOMObject);
37		38
		39	JSDOMWindow& JSDOMObject::domWindow() const
		40	{
		41	auto* domWindow = JSC::jsCast<JSDOMWindow*>(JSC::JSNonFinalObject::globalObject());
		42	ASSERT(domWindow);
		43	return *domWindow;
		44	}
		45
38	} // namespace WebCore	46	} // namespace WebCore

Lines 27-32 a/Source/WebCore/bindings/js/JSDOMWrapper.h_sec1
- a/Source/WebCore/bindings/js/JSDOMWrapper.h -1 / +4 lines
27		27
28	namespace WebCore {	28	namespace WebCore {
29		29
		30	class JSDOMWindow;
30	class ScriptExecutionContext;	31	class ScriptExecutionContext;
31		32
32	static const uint8_t JSNodeType = JSC::LastJSCObjectType + 1;	33	static const uint8_t JSNodeType = JSC::LastJSCObjectType + 1;
Lines 41-48 public: a/Source/WebCore/bindings/js/JSDOMWrapper.h_sec2
41	JSDOMGlobalObject* globalObject() const { return JSC::jsCast<JSDOMGlobalObject*>(JSC::JSNonFinalObject::globalObject()); }	42	JSDOMGlobalObject* globalObject() const { return JSC::jsCast<JSDOMGlobalObject*>(JSC::JSNonFinalObject::globalObject()); }
42	ScriptExecutionContext* scriptExecutionContext() const { return globalObject()->scriptExecutionContext(); }	43	ScriptExecutionContext* scriptExecutionContext() const { return globalObject()->scriptExecutionContext(); }
43		44
		45	JSDOMWindow& domWindow() const;
		46
44	protected:	47	protected:
45	JSDOMObject(JSC::Structure* structure, JSC::JSGlobalObject& globalObject)	48	JSDOMObject(JSC::Structure* structure, JSC::JSGlobalObject& globalObject)
46	: Base(globalObject.vm(), structure)	49	: Base(globalObject.vm(), structure)
47	{	50	{
48	ASSERT(scriptExecutionContext());	51	ASSERT(scriptExecutionContext());



{
    if (!m_loaded) {
        if (!wrapped().promise()) {
            auto promise = createDOMGenericPromise(state, domWindow());
            m_loaded.set(state.vm(), this, promise->promise());
            wrapped().registerLoaded(WTFMove(promise));
        } else
            m_loaded.set(state.vm(), this, wrapped().promise().value().promise());
    }
    return m_loaded.get();
}

Lines 34-40 namespace WebCore { a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp -1 / +1 lines
34	JSC::JSValue JSFontFaceSet::ready(JSC::ExecState& state) const	34	JSC::JSValue JSFontFaceSet::ready(JSC::ExecState& state) const
35	{	35	{
36	if (!m_ready) {	36	if (!m_ready) {
37	Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));	37	auto promise = createDOMGenericPromise(state, domWindow());
38	m_ready.set(state.vm(), this, promise->promise());	38	m_ready.set(state.vm(), this, promise->promise());
39	wrapped().registerReady(WTFMove(promise));	39	wrapped().registerReady(WTFMove(promise));
40	}	40	}

Lines 340-346 void parseMediaConstraintsDictionary(const Dictionary& mediaTrackConstraints, Me a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp -1 / +1 lines
340	}	340	}
341	}	341	}
342		342
343	static void JSMediaDevicesGetUserMediaPromiseFunction(ExecState& state, Ref<DeferredWrapper>&& promise)	343	static void JSMediaDevicesGetUserMediaPromiseFunction(ExecState& state, DOMGenericPromise&& promise)
344	{	344	{
345	VM& vm = state.vm();	345	VM& vm = state.vm();
346	auto scope = DECLARE_THROW_SCOPE(vm);	346	auto scope = DECLARE_THROW_SCOPE(vm);

Lines 184-194 JSValue JSMediaStreamTrack::applyConstraints(ExecState& state) a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp -3 / +5 lines
184	valid = !advancedConstraints.isEmpty() \|\| !mandatoryConstraints.isEmpty();	184	valid = !advancedConstraints.isEmpty() \|\| !mandatoryConstraints.isEmpty();
185	}	185	}
186		186
187	JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());	187	auto deferredPromise = createDOMGenericPromise(state, domWindow());
		188	auto promise = deferredPromise->promise();
		189
188	auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);	190	auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);
189	wrapped().applyConstraints(WTFMove(constraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred));	191	wrapped().applyConstraints(WTFMove(constraints), WTFMove(deferredPromise));
190		192
191	return promiseDeferred->promise();	193	return promise;
192	}	194	}
193		195
194	JSValue JSMediaStreamTrack::getConstraints(ExecState& state)	196	JSValue JSMediaStreamTrack::getConstraints(ExecState& state)

Lines 43-50 JSValue JSReadableStreamSource::start(ExecState& state) a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp -1 / +4 lines
43	JSReadableStreamSource* jsSource = const_cast<JSReadableStreamSource*>(this);	43	JSReadableStreamSource* jsSource = const_cast<JSReadableStreamSource*>(this);
44	m_controller.set(state.vm(), jsSource, state.argument(0));	44	m_controller.set(state.vm(), jsSource, state.argument(0));
45		45
		46	ASSERT(globalObject());
46	JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());	47	JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
47	wrapped().start(ReadableStreamDefaultController(controller), DeferredWrapper::create(&state, globalObject(), promiseDeferred));	48	if (!promiseDeferred)
		49	return jsUndefined();
		50	wrapped().start(ReadableStreamDefaultController(controller), DOMPromiseDeferred::create(globalObject(), promiseDeferred));
48	return promiseDeferred->promise();	51	return promiseDeferred->promise();
49	}	52	}
50		53



    if (!success)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
    };

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)

    if (!success)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
    };

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::sign(ExecState& state)

    if (!success)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
    };

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::verify(ExecState& state)

    if (!success)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](bool result) mutable {
        wrapper->resolve(result);
    };

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::digest(ExecState& state)

    if (!success)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
    };

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)

            return jsUndefined();
    }

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
        ASSERT(key || keyPair);
        ASSERT(!key || !keyPair);

        return jsUndefined();
    }

    return promise;
}

static void importKey(ExecState& state, CryptoKeyFormat keyFormat, CryptoOperationData data, RefPtr<CryptoAlgorithm> algorithm, RefPtr<CryptoAlgorithmParameters> parameters, bool extractable, CryptoKeyUsage keyUsages, CryptoAlgorithm::KeyCallback callback, CryptoAlgorithm::VoidCallback failureCallback)

            return jsUndefined();
    }

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](CryptoKey& result) mutable {
        wrapper->resolve(result);
    };

    if (UNLIKELY(scope.exception()))
        return jsUndefined();

    return promise;
}

static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback)

    if (!key)
        return throwTypeError(&state, scope);

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
    };

    if (UNLIKELY(scope.exception()))
        return jsUndefined();

    return promise;
}

JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)

    if (!parameters)
        return jsUndefined();

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();

    auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {
        auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable {

        return jsUndefined();
    }

    return promise;
}

JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)

            return jsUndefined();
    }

    RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
    auto promise = wrapper->promise();
    Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());

    auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithm, unwrappedKeyAlgorithmParameters, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {

        return jsUndefined();
    }

    return promise;
}

} // namespace WebCore




                my $scope = $interface->extendedAttributes->{"Exposed"} ? "WindowOrWorker" : "WindowOnly";
                push(@implContent, <<END);
static EncodedJSValue ${functionName}Promise(ExecState*, DOMGenericPromise&&);

${functionReturn} ${functionName}(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<${functionName}Promise, PromiseExecutionScope::${scope}>(*state));
}

static inline EncodedJSValue ${functionName}Promise(ExecState* state, DOMGenericPromise&& promise)
END
            }
            else {

    my @arguments;

    if (IsReturningPromise($function)) {
        push(@arguments, "WTFMove(promise)");
    }
    push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} || $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};
    return @arguments;



    return getDOMConstructor<JSTestNodeConstructor>(vm, *jsCast<const JSDOMGlobalObject*>(globalObject));
}

static EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestNodePrototypeFunctionTestWorkerPromisePromise, PromiseExecutionScope::WindowOrWorker>(*state));
}

static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

        return throwThisTypeError(*state, throwScope, "TestNode", "testWorkerPromise");
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestNode::info());
    auto& impl = castedThis->wrapped();
    impl.testWorkerPromise(WTFMove(promise));
    return JSValue::encode(jsUndefined());
}




    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

        return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");
    ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
    auto& impl = castedThis->wrapped();
    impl.testPromiseFunction(WTFMove(promise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
    if (UNLIKELY(throwScope.exception()))
        return JSValue::encode(jsUndefined());
    impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(promise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
    auto& impl = castedThis->wrapped();
    ExceptionCode ec = 0;
    impl.testPromiseFunctionWithException(WTFMove(promise), ec);
    setDOMException(state, ec);
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    auto a = state->argument(0).isUndefined() ? Optional<int32_t>() : convert<int32_t>(*state, state->uncheckedArgument(0), NormalConversion);
    if (UNLIKELY(throwScope.exception()))
        return JSValue::encode(jsUndefined());
    impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(promise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, DOMGenericPromise&&);

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
    if (UNLIKELY(throwScope.exception()))
        return JSValue::encode(jsUndefined());
    impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(promise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, DOMGenericPromise&&);

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);

    auto request = JSFetchRequest::toWrapped(state->argument(0));
    if (UNLIKELY(!request))
        return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");
    impl.testPromiseOverloadedFunction(*request, WTFMove(promise));
    return JSValue::encode(jsUndefined());
}


    return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);
}

static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    TestObj::testStaticPromiseFunction(WTFMove(promise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, DOMGenericPromise&&);

EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)
{

    return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));
}

static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, DOMGenericPromise&& promise)
{
    VM& vm = state->vm();
    auto throwScope = DECLARE_THROW_SCOPE(vm);
    UNUSED_PARAM(throwScope);
    ExceptionCode ec = 0;
    TestObj::testStaticPromiseFunctionWithException(WTFMove(promise), ec);
    setDOMException(state, ec);
    return JSValue::encode(jsUndefined());
}

Lines 34-40 a/Source/WebCore/dom/CustomElementRegistry.cpp_sec1
- a/Source/WebCore/dom/CustomElementRegistry.cpp -1 lines
34	#include "Element.h"	34	#include "Element.h"
35	#include "ElementTraversal.h"	35	#include "ElementTraversal.h"
36	#include "JSCustomElementInterface.h"	36	#include "JSCustomElementInterface.h"
37	#include "JSDOMPromise.h"
38	#include "MathMLNames.h"	37	#include "MathMLNames.h"
39	#include "QualifiedName.h"	38	#include "QualifiedName.h"
40	#include "SVGNames.h"	39	#include "SVGNames.h"




#if ENABLE(CUSTOM_ELEMENTS)

#include "JSDOMPromise.h"
#include "QualifiedName.h"
#include <wtf/HashMap.h>
#include <wtf/TemporaryChange.h>


class CustomElementRegistry;
class DOMWindow;
class DeferredWrapper;
class Element;
class JSCustomElementInterface;
class QualifiedName;


    JSC::JSValue get(const AtomicString&);

    HashMap<AtomicString, DOMGenericPromise>& promiseMap() { return m_promiseMap; }

private:
    CustomElementRegistry(DOMWindow&);

    DOMWindow& m_window;
    HashMap<AtomicString, Ref<JSCustomElementInterface>> m_nameMap;
    HashMap<const JSC::JSObject*, JSCustomElementInterface*> m_constructorMap;
    HashMap<AtomicString, DOMGenericPromise> m_promiseMap;

    bool m_elementDefinitionIsRunning { false };


Return to Bug 161787

Lines 733-739 bool ApplePaySession::canMakePayments(ScriptExecutionContext& scriptExecutionCon a/Source/WebCore/Modules/applepay/ApplePaySession.cpp_sec1
- a/Source/WebCore/Modules/applepay/ApplePaySession.cpp -2 / +2 lines
733	return paymentCoordinator.canMakePayments();	733	return paymentCoordinator.canMakePayments();
734	}	734	}
735		735
736	void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredWrapper>&& passedPromise, ExceptionCode& ec)	736	void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DOMPromiseDeferred>&& passedPromise, ExceptionCode& ec)
737	{	737	{
738	auto& document = downcast<Document>(scriptExecutionContext);	738	auto& document = downcast<Document>(scriptExecutionContext);
739	DOMWindow& window = *document.domWindow();	739	DOMWindow& window = *document.domWindow();
Lines 745-751 void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scri a/Source/WebCore/Modules/applepay/ApplePaySession.cpp_sec2
745	return;	745	return;
746	}	746	}
747		747
748	RefPtr<DeferredWrapper> promise(WTFMove(passedPromise));	748	RefPtr<DOMPromiseDeferred> promise(WTFMove(passedPromise));
749	if (!shouldDiscloseApplePayCapability(document)) {	749	if (!shouldDiscloseApplePayCapability(document)) {
750	auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();	750	auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();
751	bool canMakePayments = paymentCoordinator.canMakePayments();	751	bool canMakePayments = paymentCoordinator.canMakePayments();

Lines 124-137 void FetchBody::updateContentType(FetchHeaders& headers) a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchBody.cpp -9 / +9 lines
124	headers.fastSet(HTTPHeaderName::ContentType, m_contentType);	124	headers.fastSet(HTTPHeaderName::ContentType, m_contentType);
125	}	125	}
126		126
127	void FetchBody::arrayBuffer(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	127	void FetchBody::arrayBuffer(FetchBodyOwner& owner, DOMGenericPromise&& promise)
128	{	128	{
129	ASSERT(m_type != Type::None);	129	ASSERT(m_type != Type::None);
130	m_consumer.setType(FetchBodyConsumer::Type::ArrayBuffer);	130	m_consumer.setType(FetchBodyConsumer::Type::ArrayBuffer);
131	consume(owner, WTFMove(promise));	131	consume(owner, WTFMove(promise));
132	}	132	}
133		133
134	void FetchBody::blob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	134	void FetchBody::blob(FetchBodyOwner& owner, DOMGenericPromise&& promise)
135	{	135	{
136	ASSERT(m_type != Type::None);	136	ASSERT(m_type != Type::None);
137	m_consumer.setType(FetchBodyConsumer::Type::Blob);	137	m_consumer.setType(FetchBodyConsumer::Type::Blob);
Lines 139-145 void FetchBody::blob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec2
139	consume(owner, WTFMove(promise));	139	consume(owner, WTFMove(promise));
140	}	140	}
141		141
142	void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	142	void FetchBody::json(FetchBodyOwner& owner, DOMGenericPromise&& promise)
143	{	143	{
144	ASSERT(m_type != Type::None);	144	ASSERT(m_type != Type::None);
145		145
Lines 151-157 void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec3
151	consume(owner, WTFMove(promise));	151	consume(owner, WTFMove(promise));
152	}	152	}
153		153
154	void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	154	void FetchBody::text(FetchBodyOwner& owner, DOMGenericPromise&& promise)
155	{	155	{
156	ASSERT(m_type != Type::None);	156	ASSERT(m_type != Type::None);
157		157
Lines 163-169 void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec4
163	consume(owner, WTFMove(promise));	163	consume(owner, WTFMove(promise));
164	}	164	}
165		165
166	void FetchBody::consume(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	166	void FetchBody::consume(FetchBodyOwner& owner, DOMGenericPromise&& promise)
167	{	167	{
168	// This should be handled by FetchBodyOwner	168	// This should be handled by FetchBodyOwner
169	ASSERT(m_type != Type::None);	169	ASSERT(m_type != Type::None);
Lines 246-273 void FetchBody::consumeAsStream(FetchBodyOwner& owner, FetchResponseSource& sour a/Source/WebCore/Modules/fetch/FetchBody.cpp_sec5
246	}	246	}
247	#endif	247	#endif
248		248
249	void FetchBody::consumeArrayBuffer(Ref<DeferredWrapper>&& promise)	249	void FetchBody::consumeArrayBuffer(DOMGenericPromise&& promise)
250	{	250	{
251	ASSERT(m_data);	251	ASSERT(m_data);
252	m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_data->data()), m_data->byteLength());	252	m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_data->data()), m_data->byteLength());
253	m_data = nullptr;	253	m_data = nullptr;
254	}	254	}
255		255
256	void FetchBody::consumeArrayBufferView(Ref<DeferredWrapper>&& promise)	256	void FetchBody::consumeArrayBufferView(DOMGenericPromise&& promise)
257	{	257	{
258	ASSERT(m_dataView);	258	ASSERT(m_dataView);
259	m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_dataView->baseAddress()), m_dataView->byteLength());	259	m_consumer.resolveWithData(WTFMove(promise), static_cast<const uint8_t*>(m_dataView->baseAddress()), m_dataView->byteLength());
260	m_dataView = nullptr;	260	m_dataView = nullptr;
261	}	261	}
262		262
263	void FetchBody::consumeText(Ref<DeferredWrapper>&& promise)	263	void FetchBody::consumeText(DOMGenericPromise&& promise)
264	{	264	{
265	Vector<uint8_t> data = extractFromText();	265	Vector<uint8_t> data = extractFromText();
266	m_consumer.resolveWithData(WTFMove(promise), data.data(), data.size());	266	m_consumer.resolveWithData(WTFMove(promise), data.data(), data.size());
267	m_text = { };	267	m_text = { };
268	}	268	}
269		269
270	void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)	270	void FetchBody::consumeBlob(FetchBodyOwner& owner, DOMGenericPromise&& promise)
271	{	271	{
272	ASSERT(m_blob);	272	ASSERT(m_blob);
273		273

Lines 206-212 void FetchResponse::BodyLoader::stop() a/Source/WebCore/Modules/fetch/FetchResponse.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchResponse.cpp -2 / +2 lines
206	m_loader->stop();	206	m_loader->stop();
207	}	207	}
208		208
209	void FetchResponse::consume(unsigned type, Ref<DeferredWrapper>&& wrapper)	209	void FetchResponse::consume(unsigned type, DOMGenericPromise&& wrapper)
210	{	210	{
211	ASSERT(type <= static_cast<unsigned>(FetchBodyConsumer::Type::Text));	211	ASSERT(type <= static_cast<unsigned>(FetchBodyConsumer::Type::Text));
212		212
Lines 241-247 void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk) a/Source/WebCore/Modules/fetch/FetchResponse.cpp_sec2
241	m_consumer.append(chunk->data(), chunk->byteLength());	241	m_consumer.append(chunk->data(), chunk->byteLength());
242	}	242	}
243		243
244	void FetchResponse::finishConsumingStream(Ref<DeferredWrapper>&& promise)	244	void FetchResponse::finishConsumingStream(DOMGenericPromise&& promise)
245	{	245	{
246	m_consumer.resolve(WTFMove(promise));	246	m_consumer.resolve(WTFMove(promise));
247	}	247	}

Lines 96-110 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DO a/Source/WebCore/bindings/js/JSDOMPromise.h_sec1
- a/Source/WebCore/bindings/js/JSDOMPromise.h -32 / +31 lines
96	static constexpr bool passByConstRef = false;	96	static constexpr bool passByConstRef = false;
97	};	97	};
98		98
99	class DeferredWrapper : public RefCounted<DeferredWrapper>, public ActiveDOMCallback {	99	class DOMPromiseDeferred : public RefCounted<DOMPromiseDeferred>, public ActiveDOMCallback {
100	public:	100	public:
101	// FIXME: We should pass references here, not pointers, see bug 161787	101	static Ref<DOMPromiseDeferred> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred)
102	static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
103	{	102	{
104	return adoptRef(*new DeferredWrapper(state, globalObject, deferred));	103	return adoptRef(*new DOMPromiseDeferred(globalObject, deferred));
105	}	104	}
106		105
107	~DeferredWrapper();	106	~DOMPromiseDeferred();
108		107
109	template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type	108	template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
110	resolve(ResolveResultType result) { resolveWithValue(result); }	109	resolve(ResolveResultType result) { resolveWithValue(result); }
Lines 136-142 public: a/Source/WebCore/bindings/js/JSDOMPromise.h_sec2
136	void visitAggregate(JSC::SlotVisitor& visitor) { visitor.appendUnbarrieredWeak(&m_deferred); }	135	void visitAggregate(JSC::SlotVisitor& visitor) { visitor.appendUnbarrieredWeak(&m_deferred); }
137		136
138	private:	137	private:
139	DeferredWrapper(JSC::ExecState, JSDOMGlobalObject, JSC::JSPromiseDeferred*);	138	DOMPromiseDeferred(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
140		139
141	void clear();	140	void clear();
142	void contextDestroyed() override;	141	void contextDestroyed() override;
Lines 152-164 private: a/Source/WebCore/bindings/js/JSDOMPromise.h_sec3
152	JSC::Weak<JSDOMGlobalObject> m_globalObject;	151	JSC::Weak<JSDOMGlobalObject> m_globalObject;
153	};	152	};
154		153
155	void fulfillPromiseWithJSON(Ref<DeferredWrapper>&&, const String&);	154	using DOMGenericPromise = Ref<DOMPromiseDeferred>;
156	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, ArrayBuffer*);	155	DOMGenericPromise createDOMGenericPromise(JSC::ExecState&, JSDOMWindow&);
157	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, const void*, size_t);	156
		157	void fulfillPromiseWithJSON(DOMGenericPromise&&, const String&);
		158	void fulfillPromiseWithArrayBuffer(DOMGenericPromise&&, ArrayBuffer*);
		159	void fulfillPromiseWithArrayBuffer(DOMGenericPromise&&, const void*, size_t);
158	void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);	160	void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
159	JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState&, const String&);	161	JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState&, const String&);
160		162
161	using PromiseFunction = void(JSC::ExecState&, Ref<DeferredWrapper>&&);	163	using PromiseFunction = void(JSC::ExecState&, Ref<DOMPromiseDeferred>&&);
162		164
163	enum class PromiseExecutionScope { WindowOnly, WindowOrWorker };	165	enum class PromiseExecutionScope { WindowOnly, WindowOrWorker };
164		166
Lines 175-190 inline JSC::JSValue callPromiseFunction(JSC::ExecState& state) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec4
175	if (executionScope == PromiseExecutionScope::WindowOrWorker && !promiseDeferred)	177	if (executionScope == PromiseExecutionScope::WindowOrWorker && !promiseDeferred)
176	return JSC::jsUndefined();	178	return JSC::jsUndefined();
177		179
178	promiseFunction(state, DeferredWrapper::create(&state, &globalObject, promiseDeferred));	180	promiseFunction(state, DOMPromiseDeferred::create(globalObject, *promiseDeferred));
179		181
180	rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);	182	rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
181	ASSERT_UNUSED(scope, !scope.exception());	183	ASSERT_UNUSED(scope, !scope.exception());
182	return promiseDeferred->promise();	184	return promiseDeferred->promise();
183	}	185	}
184		186
185	using BindingPromiseFunction = JSC::EncodedJSValue(JSC::ExecState*, Ref<DeferredWrapper>&&);	187	using BindingPromiseFunction = JSC::EncodedJSValue(JSC::ExecState*, DOMGenericPromise&&);
186	template<BindingPromiseFunction bindingFunction>	188	template<BindingPromiseFunction bindingFunction>
187	inline void bindingPromiseFunctionAdapter(JSC::ExecState& state, Ref<DeferredWrapper>&& promise)	189	inline void bindingPromiseFunctionAdapter(JSC::ExecState& state, DOMGenericPromise&& promise)
188	{	190	{
189	bindingFunction(&state, WTFMove(promise));	191	bindingFunction(&state, WTFMove(promise));
190	}	192	}
Lines 199-226 inline JSC::JSValue callPromiseFunction(JSC::ExecState& state) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec5
199	template <typename Value>	201	template <typename Value>
200	class DOMPromise {	202	class DOMPromise {
201	public:	203	public:
202	DOMPromise(Ref<DeferredWrapper>&& wrapper)	204	DOMPromise(DOMGenericPromise&& genericPromise) : m_promiseDeferred(WTFMove(genericPromise)) { }
203	: m_wrapper(WTFMove(wrapper))
204	{
205	}
206		205
207	DOMPromise(DOMPromise&& promise) : m_wrapper(WTFMove(promise.m_wrapper)) { }	206	DOMPromise(DOMPromise&& promise) : m_promiseDeferred(WTFMove(promise.m_promiseDeferred)) { }
208		207
209	DOMPromise(const DOMPromise&) = default;	208	DOMPromise(const DOMPromise&) = default;
210	DOMPromise& operator=(DOMPromise const&) = default;	209	DOMPromise& operator=(DOMPromise const&) = default;
211		210
212	void resolve(typename PromiseResultInspector<Value>::Type value) { m_wrapper->resolve(value); }	211	void resolve(typename PromiseResultInspector<Value>::Type value) { m_promiseDeferred->resolve(value); }
213		212
214	template<typename... ErrorType> void reject(ErrorType&&... error) { m_wrapper->reject(std::forward<ErrorType>(error)...); }	213	template<typename... ErrorType> void reject(ErrorType&&... error) { m_promiseDeferred->reject(std::forward<ErrorType>(error)...); }
215		214
216	DeferredWrapper& deferredWrapper() { return m_wrapper; }	215	JSC::JSValue promise() const { return m_promiseDeferred->promise(); };
217		216
218	private:	217	private:
219	Ref<DeferredWrapper> m_wrapper;	218	DOMGenericPromise m_promiseDeferred;
220	};	219	};
221		220
222	template<class ResolveResultType>	221	template<class ResolveResultType>
223	inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)	222	inline void DOMPromiseDeferred::resolveWithValue(ResolveResultType&& result)
224	{	223	{
225	if (isSuspended())	224	if (isSuspended())
226	return;	225	return;
Lines 231-237 inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec6
231	}	230	}
232		231
233	template<class ResolveResultType>	232	template<class ResolveResultType>
234	inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)	233	inline void DOMPromiseDeferred::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
235	{	234	{
236	if (isSuspended())	235	if (isSuspended())
237	return;	236	return;
Lines 243-249 inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& re a/Source/WebCore/bindings/js/JSDOMPromise.h_sec7
243	}	242	}
244		243
245	template<class RejectResultType>	244	template<class RejectResultType>
246	inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)	245	inline void DOMPromiseDeferred::rejectWithValue(RejectResultType&& result)
247	{	246	{
248	if (isSuspended())	247	if (isSuspended())
249	return;	248	return;
Lines 255-261 inline void DeferredWrapper::rejectWithValue(RejectResultType&& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec8
255	}	254	}
256		255
257	template<>	256	template<>
258	inline void DeferredWrapper::resolve(bool result)	257	inline void DOMPromiseDeferred::resolve(bool result)
259	{	258	{
260	if (isSuspended())	259	if (isSuspended())
261	return;	260	return;
Lines 267-273 inline void DeferredWrapper::resolve(bool result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec9
267	}	266	}
268		267
269	template<>	268	template<>
270	inline void DeferredWrapper::resolve(JSC::JSValue value)	269	inline void DOMPromiseDeferred::resolve(JSC::JSValue value)
271	{	270	{
272	if (isSuspended())	271	if (isSuspended())
273	return;	272	return;
Lines 279-285 inline void DeferredWrapper::resolve(JSC::JSValue value) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec10
279	}	278	}
280		279
281	template<>	280	template<>
282	inline void DeferredWrapper::reject(JSC::JSValue value)	281	inline void DOMPromiseDeferred::reject(JSC::JSValue value)
283	{	282	{
284	if (isSuspended())	283	if (isSuspended())
285	return;	284	return;
Lines 291-297 inline void DeferredWrapper::reject(JSC::JSValue value) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec11
291	}	290	}
292		291
293	template<>	292	template<>
294	inline void DeferredWrapper::resolve(std::nullptr_t)	293	inline void DOMPromiseDeferred::resolve(std::nullptr_t)
295	{	294	{
296	if (isSuspended())	295	if (isSuspended())
297	return;	296	return;
Lines 303-309 inline void DeferredWrapper::resolve(std::nullptr_t) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec12
303	}	302	}
304		303
305	template<>	304	template<>
306	inline void DeferredWrapper::reject(std::nullptr_t)	305	inline void DOMPromiseDeferred::reject(std::nullptr_t)
307	{	306	{
308	if (isSuspended())	307	if (isSuspended())
309	return;	308	return;
Lines 315-321 inline void DeferredWrapper::reject(std::nullptr_t) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec13
315	}	314	}
316		315
317	template<>	316	template<>
318	inline void DeferredWrapper::resolve(const String& result)	317	inline void DOMPromiseDeferred::resolve(const String& result)
319	{	318	{
320	if (isSuspended())	319	if (isSuspended())
321	return;	320	return;
Lines 327-333 inline void DeferredWrapper::resolve(const String& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec14
327	}	326	}
328		327
329	template<>	328	template<>
330	inline void DeferredWrapper::reject(const String& result)	329	inline void DOMPromiseDeferred::reject(const String& result)
331	{	330	{
332	if (isSuspended())	331	if (isSuspended())
333	return;	332	return;

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +131 lines
		1	2016-09-16 Youenn Fablet <youenn@apple.com>
		2
		3	Improve DeferredWrapper code
		4	https://bugs.webkit.org/show_bug.cgi?id=161787
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	No change of behavior.
		9
		10	Renaming DeferredWrapper to DOMPromiseDeferred.
		11	Introduced DOMGenericPromise as a ref of DOMPromiseDeferred to improve readability of code.
		12	Adding create method that creates the underlying JSC::JSPromiseDeferred in non-worker environments.
		13	Updated create method to take references.
		14	Introducing domWindow helper accessor into JSDOMObject to ease creation of promise in non-worker environments.
		15	Doing some minor clean up (renaming of m_wrapper to m_promiseDeferred, accessor change).
		16
		17	* Modules/applepay/ApplePaySession.cpp:
		18	(WebCore::ApplePaySession::canMakePaymentsWithActiveCard):
		19	* Modules/applepay/ApplePaySession.h:
		20	* Modules/fetch/DOMWindowFetch.cpp:
		21	(WebCore::DOMWindowFetch::fetch):
		22	* Modules/fetch/DOMWindowFetch.h: Updated to take a DOMPromiseDeferred to make it consistent with WorkerGlobalScopeFetch.
		23	* Modules/fetch/FetchBody.cpp:
		24	(WebCore::FetchBody::arrayBuffer):
		25	(WebCore::FetchBody::blob):
		26	(WebCore::FetchBody::json):
		27	(WebCore::FetchBody::text):
		28	(WebCore::FetchBody::consume):
		29	(WebCore::FetchBody::consumeArrayBuffer):
		30	(WebCore::FetchBody::consumeArrayBufferView):
		31	(WebCore::FetchBody::consumeText):
		32	(WebCore::FetchBody::consumeBlob):
		33	* Modules/fetch/FetchBody.h:
		34	(WebCore::FetchBody::formData):
		35	* Modules/fetch/FetchBodyConsumer.cpp:
		36	(WebCore::FetchBodyConsumer::resolveWithData):
		37	(WebCore::FetchBodyConsumer::resolve):
		38	* Modules/fetch/FetchBodyConsumer.h:
		39	* Modules/fetch/FetchBodyOwner.cpp:
		40	(WebCore::FetchBodyOwner::arrayBuffer):
		41	(WebCore::FetchBodyOwner::blob):
		42	(WebCore::FetchBodyOwner::formData):
		43	(WebCore::FetchBodyOwner::json):
		44	(WebCore::FetchBodyOwner::text):
		45	* Modules/fetch/FetchBodyOwner.h:
		46	* Modules/fetch/FetchResponse.cpp:
		47	(WebCore::FetchResponse::consume):
		48	(WebCore::FetchResponse::finishConsumingStream):
		49	* Modules/fetch/FetchResponse.h:
		50	* Modules/fetch/WorkerGlobalScopeFetch.cpp:
		51	(WebCore::WorkerGlobalScopeFetch::fetch):
		52	* Modules/fetch/WorkerGlobalScopeFetch.h:
		53	* bindings/js/JSCustomElementRegistryCustom.cpp:
		54	(WebCore::whenDefinedPromise):
		55	(WebCore::JSCustomElementRegistry::whenDefined):
		56	* bindings/js/JSDOMGlobalObject.cpp:
		57	(WebCore::JSDOMGlobalObject::visitChildren):
		58	* bindings/js/JSDOMGlobalObject.h:
		59	* bindings/js/JSDOMPromise.cpp:
		60	(WebCore::DOMDeferredPromise::DOMDeferredPromise):
		61	(WebCore::DOMDeferredPromise::~DOMDeferredPromise):
		62	(WebCore::DOMDeferredPromise::clear):
		63	(WebCore::DOMDeferredPromise::contextDestroyed):
		64	(WebCore::DOMDeferredPromise::promise):
65	(WebCore::DOMDeferredPromise::callFunction):
66	(WebCore::DOMDeferredPromise::reject):
67	(WebCore::rejectPromiseWithExceptionIfAny):
68	(WebCore::fulfillPromiseWithJSON):
69	(WebCore::fulfillPromiseWithArrayBuffer):
70	(WebCore::DeferredWrapper::DeferredWrapper): Deleted.
71	(WebCore::DeferredWrapper::~DeferredWrapper): Deleted.
72	(WebCore::DeferredWrapper::clear): Deleted.
73	(WebCore::DeferredWrapper::contextDestroyed): Deleted.
74	(WebCore::DeferredWrapper::promise): Deleted.
75	(WebCore::DeferredWrapper::callFunction): Deleted.
76	(WebCore::DeferredWrapper::reject): Deleted.
77	* bindings/js/JSDOMPromise.h:
78	(WebCore::DOMDeferredPromise::create):
79	(WebCore::callPromiseFunction):
80	(WebCore::DOMPromise::DOMPromise):
81	(WebCore::DOMPromise::deferredPromise):
82	(WebCore::DOMDeferredPromise::resolveWithValue):
83	(WebCore::DOMDeferredPromise::resolveWithNewlyCreated):
84	(WebCore::DOMDeferredPromise::rejectWithValue):
85	(WebCore::DOMDeferredPromise::resolve):
86	(WebCore::DOMDeferredPromise::reject):
87	(WebCore::DeferredWrapper::create): Deleted.
88	(WebCore::DOMPromise::deferredWrapper): Deleted.
89	(WebCore::DeferredWrapper::resolveWithValue): Deleted.
90	(WebCore::DeferredWrapper::resolveWithNewlyCreated): Deleted.
91	(WebCore::DeferredWrapper::rejectWithValue): Deleted.
92	(WebCore::DeferredWrapper::resolve): Deleted.
93	(WebCore::DeferredWrapper::reject): Deleted.
94	* bindings/js/JSDOMWrapper.cpp: Introducing domWindow() accessor.
95	* bindings/js/JSDOMWrapper.h:
96	* bindings/js/JSFontFaceCustom.cpp:
97	(WebCore::JSFontFace::loaded):
98	* bindings/js/JSFontFaceSetCustom.cpp:
99	(WebCore::JSFontFaceSet::ready):
100	* bindings/js/JSMediaDevicesCustom.cpp:
101	(WebCore::JSMediaDevices::getUserMedia):
102	* bindings/js/JSMediaStreamTrackCustom.cpp:
103	(WebCore::JSMediaStreamTrack::applyConstraints):
104	* bindings/js/JSReadableStreamSourceCustom.cpp:
105	(WebCore::JSReadableStreamSource::start):
106	* bindings/js/JSWebKitSubtleCryptoCustom.cpp:
107	(WebCore::JSWebKitSubtleCrypto::encrypt):
108	(WebCore::JSWebKitSubtleCrypto::decrypt):
109	(WebCore::JSWebKitSubtleCrypto::sign):
110	(WebCore::JSWebKitSubtleCrypto::verify):
111	(WebCore::JSWebKitSubtleCrypto::digest):
112	(WebCore::JSWebKitSubtleCrypto::generateKey):
113	(WebCore::JSWebKitSubtleCrypto::importKey):
114	(WebCore::JSWebKitSubtleCrypto::exportKey):
115	(WebCore::JSWebKitSubtleCrypto::wrapKey):
116	(WebCore::JSWebKitSubtleCrypto::unwrapKey):
117	* bindings/scripts/CodeGeneratorJS.pm:
118	(GenerateImplementation):
119	(GenerateReturnParameters):
120	* bindings/scripts/test/JS/JSTestObj.cpp:
121	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionPromise):
122	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise):
123	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise):
124	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise):
125	(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise):
126	(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise):
127	(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise):
128	(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise):
129	* dom/CustomElementRegistry.h:
130	(WebCore::CustomElementRegistry::promiseMap):
131
1	2016-09-16 Javier Fernandez <jfernandez@igalia.com>	132	2016-09-16 Javier Fernandez <jfernandez@igalia.com>
2		133
3	[GTK] Unreviewed build fix after r206007.	134	[GTK] Unreviewed build fix after r206007.

Lines 52-62 class ScriptExecutionContext; a/Source/WebCore/Modules/fetch/FetchBody.h_sec1
- a/Source/WebCore/Modules/fetch/FetchBody.h -11 / +11 lines
52		52
53	class FetchBody {	53	class FetchBody {
54	public:	54	public:
55	void arrayBuffer(FetchBodyOwner&, Ref<DeferredWrapper>&&);	55	void arrayBuffer(FetchBodyOwner&, DOMGenericPromise&&);
56	void blob(FetchBodyOwner&, Ref<DeferredWrapper>&&);	56	void blob(FetchBodyOwner&, DOMGenericPromise&&);
57	void json(FetchBodyOwner&, Ref<DeferredWrapper>&&);	57	void json(FetchBodyOwner&, DOMGenericPromise&&);
58	void text(FetchBodyOwner&, Ref<DeferredWrapper>&&);	58	void text(FetchBodyOwner&, DOMGenericPromise&&);
59	void formData(FetchBodyOwner&, Ref<DeferredWrapper>&& promise) { promise.get().reject(0); }	59	void formData(FetchBodyOwner&, DOMGenericPromise&& promise) { promise.get().reject(0); }
60		60
61	#if ENABLE(READABLE_STREAM_API)	61	#if ENABLE(READABLE_STREAM_API)
62	void consumeAsStream(FetchBodyOwner&, FetchResponseSource&);	62	void consumeAsStream(FetchBodyOwner&, FetchResponseSource&);
Lines 93-105 private: a/Source/WebCore/Modules/fetch/FetchBody.h_sec2
93	FetchBody(String&&);	93	FetchBody(String&&);
94	FetchBody(Type type) : m_type(type) { }	94	FetchBody(Type type) : m_type(type) { }
95		95
96	void consume(FetchBodyOwner&, Ref<DeferredWrapper>&&);	96	void consume(FetchBodyOwner&, DOMGenericPromise&&);
97		97
98	Vector<uint8_t> extractFromText() const;	98	Vector<uint8_t> extractFromText() const;
99	void consumeArrayBuffer(Ref<DeferredWrapper>&&);	99	void consumeArrayBuffer(DOMGenericPromise&&);
100	void consumeArrayBufferView(Ref<DeferredWrapper>&&);	100	void consumeArrayBufferView(DOMGenericPromise&&);
101	void consumeText(Ref<DeferredWrapper>&&);	101	void consumeText(DOMGenericPromise&&);
102	void consumeBlob(FetchBodyOwner&, Ref<DeferredWrapper>&&);	102	void consumeBlob(FetchBodyOwner&, DOMGenericPromise&&);
103		103
104	Type m_type { Type::None };	104	Type m_type { Type::None };
105	String m_contentType;	105	String m_contentType;
Lines 112-118 private: a/Source/WebCore/Modules/fetch/FetchBody.h_sec3
112	String m_text;	112	String m_text;
113		113
114	FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };	114	FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };
115	RefPtr<DeferredWrapper> m_consumePromise;	115	RefPtr<DOMPromiseDeferred> m_consumePromise;
116	};	116	};
117		117
118	} // namespace WebCore	118	} // namespace WebCore

Lines 59-65 static String textFromUTF8(const unsigned char* data, unsigned length) a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp -2 / +2 lines
59	return decoder->decodeAndFlush(reinterpret_cast<const char*>(data), length);	59	return decoder->decodeAndFlush(reinterpret_cast<const char*>(data), length);
60	}	60	}
61		61
62	void FetchBodyConsumer::resolveWithData(Ref<DeferredWrapper>&& promise, const unsigned char* data, unsigned length)	62	void FetchBodyConsumer::resolveWithData(DOMGenericPromise&& promise, const unsigned char* data, unsigned length)
63	{	63	{
64	switch (m_type) {	64	switch (m_type) {
65	case Type::ArrayBuffer:	65	case Type::ArrayBuffer:
Lines 80-86 void FetchBodyConsumer::resolveWithData(Ref<DeferredWrapper>&& promise, const un a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp_sec2
80	}	80	}
81	}	81	}
82		82
83	void FetchBodyConsumer::resolve(Ref<DeferredWrapper>&& promise)	83	void FetchBodyConsumer::resolve(DOMGenericPromise&& promise)
84	{	84	{
85	ASSERT(m_type != Type::None);	85	ASSERT(m_type != Type::None);
86	switch (m_type) {	86	switch (m_type) {

Lines 30-41 a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h -3 / +3 lines
30		30
31	#if ENABLE(FETCH_API)	31	#if ENABLE(FETCH_API)
32		32
		33	#include "JSDOMPromise.h"
33	#include "SharedBuffer.h"	34	#include "SharedBuffer.h"
34		35
35	namespace WebCore {	36	namespace WebCore {
36		37
37	class Blob;	38	class Blob;
38	class DeferredWrapper;
39		39
40	class FetchBodyConsumer {	40	class FetchBodyConsumer {
41	public:	41	public:
Lines 57-64 public: a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h_sec2
57		57
58	void clean() { m_buffer = nullptr; }	58	void clean() { m_buffer = nullptr; }
59		59
60	void resolve(Ref<DeferredWrapper>&&);	60	void resolve(DOMGenericPromise&&);
61	void resolveWithData(Ref<DeferredWrapper>&&, const unsigned char*, unsigned);	61	void resolveWithData(DOMGenericPromise&&, const unsigned char*, unsigned);
62		62
63	bool hasData() const { return !!m_buffer; }	63	bool hasData() const { return !!m_buffer; }
64		64

Lines 71-77 bool FetchBodyOwner::isDisturbedOrLocked() const a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp -5 / +5 lines
71	return false;	71	return false;
72	}	72	}
73		73
74	void FetchBodyOwner::arrayBuffer(Ref<DeferredWrapper>&& promise)	74	void FetchBodyOwner::arrayBuffer(DOMGenericPromise&& promise)
75	{	75	{
76	if (m_body.isEmpty()) {	76	if (m_body.isEmpty()) {
77	fulfillPromiseWithArrayBuffer(WTFMove(promise), nullptr, 0);	77	fulfillPromiseWithArrayBuffer(WTFMove(promise), nullptr, 0);
Lines 85-91 void FetchBodyOwner::arrayBuffer(Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp_sec2
85	m_body.arrayBuffer(*this, WTFMove(promise));	85	m_body.arrayBuffer(*this, WTFMove(promise));
86	}	86	}
87		87
88	void FetchBodyOwner::blob(Ref<DeferredWrapper>&& promise)	88	void FetchBodyOwner::blob(DOMGenericPromise&& promise)
89	{	89	{
90	if (m_body.isEmpty()) {	90	if (m_body.isEmpty()) {
91	promise->resolve(Blob::create(Vector<uint8_t>(), Blob::normalizedContentType(extractMIMETypeFromMediaType(m_body.contentType()))));	91	promise->resolve(Blob::create(Vector<uint8_t>(), Blob::normalizedContentType(extractMIMETypeFromMediaType(m_body.contentType()))));
Lines 99-105 void FetchBodyOwner::blob(Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp_sec3
99	m_body.blob(*this, WTFMove(promise));	99	m_body.blob(*this, WTFMove(promise));
100	}	100	}
101		101
102	void FetchBodyOwner::formData(Ref<DeferredWrapper>&& promise)	102	void FetchBodyOwner::formData(DOMGenericPromise&& promise)
103	{	103	{
104	if (m_body.isEmpty()) {	104	if (m_body.isEmpty()) {
105	promise->reject(0);	105	promise->reject(0);
Lines 113-119 void FetchBodyOwner::formData(Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp_sec4
113	m_body.formData(*this, WTFMove(promise));	113	m_body.formData(*this, WTFMove(promise));
114	}	114	}
115		115
116	void FetchBodyOwner::json(Ref<DeferredWrapper>&& promise)	116	void FetchBodyOwner::json(DOMGenericPromise&& promise)
117	{	117	{
118	if (m_body.isEmpty()) {	118	if (m_body.isEmpty()) {
119	promise->reject(SYNTAX_ERR);	119	promise->reject(SYNTAX_ERR);
Lines 127-133 void FetchBodyOwner::json(Ref<DeferredWrapper>&& promise) a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp_sec5
127	m_body.json(*this, WTFMove(promise));	127	m_body.json(*this, WTFMove(promise));
128	}	128	}
129		129
130	void FetchBodyOwner::text(Ref<DeferredWrapper>&& promise)	130	void FetchBodyOwner::text(DOMGenericPromise&& promise)
131	{	131	{
132	if (m_body.isEmpty()) {	132	if (m_body.isEmpty()) {
133	promise->resolve(String());	133	promise->resolve(String());

Lines 46-56 public: a/Source/WebCore/Modules/fetch/FetchBodyOwner.h_sec1
- a/Source/WebCore/Modules/fetch/FetchBodyOwner.h -5 / +5 lines
46	// Exposed Body API	46	// Exposed Body API
47	bool isDisturbed() const { return m_isDisturbed; };	47	bool isDisturbed() const { return m_isDisturbed; };
48		48
49	void arrayBuffer(Ref<DeferredWrapper>&&);	49	void arrayBuffer(DOMGenericPromise&&);
50	void blob(Ref<DeferredWrapper>&&);	50	void blob(DOMGenericPromise&&);
51	void formData(Ref<DeferredWrapper>&&);	51	void formData(DOMGenericPromise&&);
52	void json(Ref<DeferredWrapper>&&);	52	void json(DOMGenericPromise&&);
53	void text(Ref<DeferredWrapper>&&);	53	void text(DOMGenericPromise&&);
54		54
55	bool isDisturbedOrLocked() const;	55	bool isDisturbedOrLocked() const;
56		56

Lines 60-70 public: a/Source/WebCore/Modules/fetch/FetchResponse.h_sec1
- a/Source/WebCore/Modules/fetch/FetchResponse.h -2 / +2 lines
60	using FetchPromise = DOMPromise<FetchResponse>;	60	using FetchPromise = DOMPromise<FetchResponse>;
61	static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);	61	static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);
62		62
63	void consume(unsigned, Ref<DeferredWrapper>&&);	63	void consume(unsigned, DOMGenericPromise&&);
64	#if ENABLE(READABLE_STREAM_API)	64	#if ENABLE(READABLE_STREAM_API)
65	void startConsumingStream(unsigned);	65	void startConsumingStream(unsigned);
66	void consumeChunk(Ref<JSC::Uint8Array>&&);	66	void consumeChunk(Ref<JSC::Uint8Array>&&);
67	void finishConsumingStream(Ref<DeferredWrapper>&&);	67	void finishConsumingStream(DOMGenericPromise&&);
68	#endif	68	#endif
69		69
70	void setStatus(int, const String&, ExceptionCode&);	70	void setStatus(int, const String&, ExceptionCode&);

Lines 1530-1535 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec1
- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +4 lines
1530	416E6FE81BBD12DF000A6053 /* WritableStreamInternalsBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E9 / WritableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };	1530	416E6FE81BBD12DF000A6053 /* WritableStreamInternalsBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E9 / WritableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
1531	416E6FE91BBD12E5000A6043 /* ReadableStreamBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D8 / ReadableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };	1531	416E6FE91BBD12E5000A6043 /* ReadableStreamBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D8 / ReadableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
1532	416E6FE91BBD12E5000A6053 /* WritableStreamBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E8 / WritableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };	1532	416E6FE91BBD12E5000A6053 /* WritableStreamBuiltins.h in Headers / = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E8 / WritableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
		1533	4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources / = {isa = PBXBuildFile; fileRef = 4170A2E91D8C0CC000318452 / JSDOMWrapper.cpp */; };
1533	417253AA1354BBBC00360F2A /* MediaControlElements.cpp in Sources / = {isa = PBXBuildFile; fileRef = 417253A81354BBBC00360F2A / MediaControlElements.cpp */; };	1534	417253AA1354BBBC00360F2A /* MediaControlElements.cpp in Sources / = {isa = PBXBuildFile; fileRef = 417253A81354BBBC00360F2A / MediaControlElements.cpp */; };
1534	417253AB1354BBBC00360F2A /* MediaControlElements.h in Headers / = {isa = PBXBuildFile; fileRef = 417253A91354BBBC00360F2A / MediaControlElements.h */; };	1535	417253AB1354BBBC00360F2A /* MediaControlElements.h in Headers / = {isa = PBXBuildFile; fileRef = 417253A91354BBBC00360F2A / MediaControlElements.h */; };
1535	417DA6D913734E6E007C57FB /* Internals.cpp in Sources / = {isa = PBXBuildFile; fileRef = 417DA4CF13734326007C57FB / Internals.cpp */; };	1536	417DA6D913734E6E007C57FB /* Internals.cpp in Sources / = {isa = PBXBuildFile; fileRef = 417DA4CF13734326007C57FB / Internals.cpp */; };
Lines 8454-8459 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec2
8454	4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };	8455	4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };
8455	4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };	8456	4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
8456	416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };	8457	416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
		8458	4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
8457	417253A81354BBBC00360F2A /* MediaControlElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaControlElements.cpp; sourceTree = "<group>"; };	8459	417253A81354BBBC00360F2A /* MediaControlElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaControlElements.cpp; sourceTree = "<group>"; };
8458	417253A91354BBBC00360F2A /* MediaControlElements.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaControlElements.h; sourceTree = "<group>"; };	8460	417253A91354BBBC00360F2A /* MediaControlElements.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaControlElements.h; sourceTree = "<group>"; };
8459	417DA4CE13734326007C57FB /* Internals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Internals.h; sourceTree = "<group>"; };	8461	417DA4CE13734326007C57FB /* Internals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Internals.h; sourceTree = "<group>"; };
Lines 21039-21044 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec3
21039	460CBF341D4BCCFE0092E88E /* JSDOMWindowProperties.h */,	21041	460CBF341D4BCCFE0092E88E /* JSDOMWindowProperties.h */,
21040	BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */,	21042	BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */,
21041	BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */,	21043	BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */,
		21044	4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */,
21042	65E0E9431133C89F00B4CB10 /* JSDOMWrapper.h */,	21045	65E0E9431133C89F00B4CB10 /* JSDOMWrapper.h */,
21043	F3D461461161D53200CA0D09 /* JSErrorHandler.cpp */,	21046	F3D461461161D53200CA0D09 /* JSErrorHandler.cpp */,
21044	F3D461471161D53200CA0D09 /* JSErrorHandler.h */,	21047	F3D461471161D53200CA0D09 /* JSErrorHandler.h */,
Lines 29464-29469 a/Source/WebCore/WebCore.xcodeproj/project.pbxproj_sec4
29464	314BE3A61B3103FB00141982 /* NamedImageGeneratedImage.cpp in Sources */,	29467	314BE3A61B3103FB00141982 /* NamedImageGeneratedImage.cpp in Sources */,
29465	BCF34A3711A231CD00C71804 /* NamedNodeMap.cpp in Sources */,	29468	BCF34A3711A231CD00C71804 /* NamedNodeMap.cpp in Sources */,
29466	A81872240977D3C0005826D9 /* NameNodeList.cpp in Sources */,	29469	A81872240977D3C0005826D9 /* NameNodeList.cpp in Sources */,
		29470	4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources */,
29467	8306EFF11B8BCEA50031D032 /* NativeNodeFilter.cpp in Sources */,	29471	8306EFF11B8BCEA50031D032 /* NativeNodeFilter.cpp in Sources */,
29468	E10B9B6D0B747599003ED890 /* NativeXPathNSResolver.cpp in Sources */,	29472	E10B9B6D0B747599003ED890 /* NativeXPathNSResolver.cpp in Sources */,
29469	93CCF0600AF6CA7600018E89 /* NavigationAction.cpp in Sources */,	29473	93CCF0600AF6CA7600018E89 /* NavigationAction.cpp in Sources */,

Lines 162-168 JSValue JSCustomElementRegistry::define(ExecState& state) a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp -11 / +13 lines
162	}	162	}
163		163
164	// https://html.spec.whatwg.org/#dom-customelementregistry-whendefined	164	// https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
165	static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry)	165	static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry, JSPromiseDeferred& promiseDeferred)
166	{	166	{
167	auto scope = DECLARE_THROW_SCOPE(state.vm());	167	auto scope = DECLARE_THROW_SCOPE(state.vm());
168		168
Lines 173-189 static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObj a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp_sec2
173	if (UNLIKELY(scope.exception()))	173	if (UNLIKELY(scope.exception()))
174	return jsUndefined();	174	return jsUndefined();
175		175
176	if (!validateCustomElementNameAndThrowIfNeeded(state, localName))	176	if (!validateCustomElementNameAndThrowIfNeeded(state, localName)) {
		177	ASSERT(scope.exception());
177	return jsUndefined();	178	return jsUndefined();
		179	}
178		180
179	if (registry.findInterface(localName)) {	181	if (registry.findInterface(localName)) {
180	auto& jsPromise = *JSPromiseDeferred::create(&state, &globalObject);	182	DOMPromiseDeferred::create(globalObject, promiseDeferred)->resolve(nullptr);
181	DeferredWrapper::create(&state, &globalObject, &jsPromise)->resolve(nullptr);	183	return promiseDeferred.promise();
182	return jsPromise.promise();
183	}	184	}
184		185
185	auto result = registry.promiseMap().ensure(localName, [&] {	186	auto result = registry.promiseMap().ensure(localName, [&] {
186	return DeferredWrapper::create(&state, &globalObject, JSPromiseDeferred::create(&state, &globalObject));	187	return DOMPromiseDeferred::create(globalObject, promiseDeferred);
187	});	188	});
188		189
189	return result.iterator->value->promise();	190	return result.iterator->value->promise();
Lines 193-206 JSValue JSCustomElementRegistry::whenDefined(ExecState& state) a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp_sec3
193	{	194	{
194	auto scope = DECLARE_CATCH_SCOPE(state.vm());	195	auto scope = DECLARE_CATCH_SCOPE(state.vm());
195		196
196	JSDOMGlobalObject& globalObject = jsCast<JSDOMGlobalObject>(state.lexicalGlobalObject());	197	ASSERT(globalObject());
197	auto& promiseDeferred = *JSPromiseDeferred::create(&state, &globalObject);	198	auto promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
198	JSValue promise = whenDefinedPromise(state, globalObject, wrapped());	199	ASSERT(promiseDeferred);
		200	JSValue promise = whenDefinedPromise(state, globalObject(), wrapped(), promiseDeferred);
199		201
200	if (UNLIKELY(scope.exception())) {	202	if (UNLIKELY(scope.exception())) {
201	rejectPromiseWithExceptionIfAny(state, globalObject, promiseDeferred);	203	rejectPromiseWithExceptionIfAny(state, globalObject(), promiseDeferred);
202	ASSERT(!scope.exception());	204	ASSERT(!scope.exception());
203	return promiseDeferred.promise();	205	return promiseDeferred->promise();
204	}	206	}
205		207
206	return promise;	208	return promise;

Lines 178-185 void JSDOMGlobalObject::visitChildren(JSCell* cell, SlotVisitor& visitor) a/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp -2 / +2 lines
178	for (auto& constructor : thisObject->constructors().values())	178	for (auto& constructor : thisObject->constructors().values())
179	visitor.append(&constructor);	179	visitor.append(&constructor);
180		180
181	for (auto& deferredWrapper : thisObject->deferredWrappers())	181	for (auto& deferredPromise : thisObject->deferredPromises())
182	deferredWrapper->visitAggregate(visitor);	182	deferredPromise->visitAggregate(visitor);
183		183
184	thisObject->m_builtinInternalFunctions.visit(visitor);	184	thisObject->m_builtinInternalFunctions.visit(visitor);
185	}	185	}

Lines 28-33 a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMPromise.cpp -17 / +26 lines
28		28
29	#include "ExceptionCode.h"	29	#include "ExceptionCode.h"
30	#include "JSDOMError.h"	30	#include "JSDOMError.h"
		31	#include "JSDOMWindow.h"
31	#include <builtins/BuiltinNames.h>	32	#include <builtins/BuiltinNames.h>
32	#include <runtime/Exception.h>	33	#include <runtime/Exception.h>
33	#include <runtime/JSONObject.h>	34	#include <runtime/JSONObject.h>
Lines 37-77 using namespace JSC; a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec2
37		38
38	namespace WebCore {	39	namespace WebCore {
39		40
40	DeferredWrapper::DeferredWrapper(ExecState, JSDOMGlobalObject globalObject, JSPromiseDeferred* promiseDeferred)	41	DOMPromiseDeferred::DOMPromiseDeferred(JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
41	: ActiveDOMCallback(globalObject->scriptExecutionContext())	42	: ActiveDOMCallback(globalObject.scriptExecutionContext())
42	, m_deferred(promiseDeferred)	43	, m_deferred(&promiseDeferred)
43	, m_globalObject(globalObject)	44	, m_globalObject(&globalObject)
44	{	45	{
45	globalObject->vm().heap.writeBarrier(globalObject, promiseDeferred);	46	globalObject.vm().heap.writeBarrier(&globalObject, &promiseDeferred);
46	m_globalObject->deferredWrappers().add(this);	47	globalObject.deferredPromises().add(this);
47	}	48	}
48		49
49	DeferredWrapper::~DeferredWrapper()	50	DOMPromiseDeferred::~DOMPromiseDeferred()
50	{	51	{
51	clear();	52	clear();
52	}	53	}
53		54
54	void DeferredWrapper::clear()	55	void DOMPromiseDeferred::clear()
55	{	56	{
56	ASSERT(!m_deferred \|\| m_globalObject);	57	ASSERT(!m_deferred \|\| m_globalObject);
57	if (m_deferred && m_globalObject)	58	if (m_deferred && m_globalObject)
58	m_globalObject->deferredWrappers().remove(this);	59	m_globalObject->deferredPromises().remove(this);
59	m_deferred.clear();	60	m_deferred.clear();
60	}	61	}
61		62
62	void DeferredWrapper::contextDestroyed()	63	void DOMPromiseDeferred::contextDestroyed()
63	{	64	{
64	ActiveDOMCallback::contextDestroyed();	65	ActiveDOMCallback::contextDestroyed();
65	clear();	66	clear();
66	}	67	}
67		68
68	JSC::JSValue DeferredWrapper::promise() const	69	JSC::JSValue DOMPromiseDeferred::promise() const
69	{	70	{
70	ASSERT(m_deferred);	71	ASSERT(m_deferred);
71	return m_deferred->promise();	72	return m_deferred->promise();
72	}	73	}
73		74
74	void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue resolution)	75	void DOMPromiseDeferred::callFunction(ExecState& exec, JSValue function, JSValue resolution)
75	{	76	{
76	if (!canInvokeCallback())	77	if (!canInvokeCallback())
77	return;	78	return;
Lines 88-94 void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue re a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec3
88	clear();	89	clear();
89	}	90	}
90		91
91	void DeferredWrapper::reject(ExceptionCode ec, const String& message)	92	void DOMPromiseDeferred::reject(ExceptionCode ec, const String& message)
92	{	93	{
93	if (isSuspended())	94	if (isSuspended())
94	return;	95	return;
Lines 111-117 void rejectPromiseWithExceptionIfAny(JSC::ExecState& state, JSDOMGlobalObject& g a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec4
111	JSValue error = scope.exception()->value();	112	JSValue error = scope.exception()->value();
112	scope.clearException();	113	scope.clearException();
113		114
114	DeferredWrapper::create(&state, &globalObject, &promiseDeferred)->reject(error);	115	DOMPromiseDeferred::create(globalObject, promiseDeferred)->reject(error);
		116	}
		117
		118	DOMGenericPromise createDOMGenericPromise(JSC::ExecState& state, JSDOMWindow& domWindow)
		119	{
		120	JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &domWindow);
		121	// deferred can only be null in workers.
		122	ASSERT(deferred);
		123	return DOMPromiseDeferred::create(domWindow, *deferred);
115	}	124	}
116		125
117	JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState& state, const String& errorMessage)	126	JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState& state, const String& errorMessage)
Lines 139-145 static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec5
139	return JSC::JSONParse(state, data);	148	return JSC::JSONParse(state, data);
140	}	149	}
141		150
142	void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data)	151	void fulfillPromiseWithJSON(DOMGenericPromise&& promise, const String& data)
143	{	152	{
144	JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);	153	JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);
145	if (!value)	154	if (!value)
Lines 148-154 void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data) a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec6
148	promise->resolve(value);	157	promise->resolve(value);
149	}	158	}
150		159
151	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* arrayBuffer)	160	void fulfillPromiseWithArrayBuffer(DOMGenericPromise&& promise, ArrayBuffer* arrayBuffer)
152	{	161	{
153	if (!arrayBuffer) {	162	if (!arrayBuffer) {
154	promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));	163	promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));
Lines 157-163 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec7
157	promise->resolve(arrayBuffer);	166	promise->resolve(arrayBuffer);
158	}	167	}
159		168
160	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, const void* data, size_t length)	169	void fulfillPromiseWithArrayBuffer(DOMGenericPromise&& promise, const void* data, size_t length)
161	{	170	{
162	fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());	171	fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());
163	}	172	}

Lines 39-49 JSC::JSValue JSFontFace::loaded(JSC::ExecState& state) const a/Source/WebCore/bindings/js/JSFontFaceCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSFontFaceCustom.cpp -2 / +2 lines
39	{	39	{
40	if (!m_loaded) {	40	if (!m_loaded) {
41	if (!wrapped().promise()) {	41	if (!wrapped().promise()) {
42	Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));	42	auto promise = createDOMGenericPromise(state, domWindow());
43	m_loaded.set(state.vm(), this, promise->promise());	43	m_loaded.set(state.vm(), this, promise->promise());
44	wrapped().registerLoaded(WTFMove(promise));	44	wrapped().registerLoaded(WTFMove(promise));
45	} else	45	} else
46	m_loaded.set(state.vm(), this, wrapped().promise().value().deferredWrapper().promise());	46	m_loaded.set(state.vm(), this, wrapped().promise().value().promise());
47	}	47	}
48	return m_loaded.get();	48	return m_loaded.get();
49	}	49	}

Lines 173-181 JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp -31 / +30 lines
173	if (!success)	173	if (!success)
174	return jsUndefined();	174	return jsUndefined();
175		175
176		176	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
177	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	177	auto promise = wrapper->promise();
178	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
179	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	178	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
180	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	179	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
181	};	180	};
Lines 190-196 JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec2
190	return jsUndefined();	189	return jsUndefined();
191	}	190	}
192		191
193	return promiseDeferred->promise();	192	return promise;
194	}	193	}
195		194
196	JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)	195	JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)
Lines 227-234 JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec3
227	if (!success)	226	if (!success)
228	return jsUndefined();	227	return jsUndefined();
229		228
230	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	229	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
231	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	230	auto promise = wrapper->promise();
232	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	231	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
233	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	232	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
234	};	233	};
Lines 243-249 JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec4
243	return jsUndefined();	242	return jsUndefined();
244	}	243	}
245		244
246	return promiseDeferred->promise();	245	return promise;
247	}	246	}
248		247
249	JSValue JSWebKitSubtleCrypto::sign(ExecState& state)	248	JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
Lines 280-287 JSValue JSWebKitSubtleCrypto::sign(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec5
280	if (!success)	279	if (!success)
281	return jsUndefined();	280	return jsUndefined();
282		281
283	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	282	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
284	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	283	auto promise = wrapper->promise();
285	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	284	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
286	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	285	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
287	};	286	};
Lines 296-302 JSValue JSWebKitSubtleCrypto::sign(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec6
296	return jsUndefined();	295	return jsUndefined();
297	}	296	}
298		297
299	return promiseDeferred->promise();	298	return promise;
300	}	299	}
301		300
302	JSValue JSWebKitSubtleCrypto::verify(ExecState& state)	301	JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
Lines 339-346 JSValue JSWebKitSubtleCrypto::verify(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec7
339	if (!success)	338	if (!success)
340	return jsUndefined();	339	return jsUndefined();
341		340
342	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	341	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
343	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	342	auto promise = wrapper->promise();
344	auto successCallback = [wrapper](bool result) mutable {	343	auto successCallback = [wrapper](bool result) mutable {
345	wrapper->resolve(result);	344	wrapper->resolve(result);
346	};	345	};
Lines 355-361 JSValue JSWebKitSubtleCrypto::verify(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec8
355	return jsUndefined();	354	return jsUndefined();
356	}	355	}
357		356
358	return promiseDeferred->promise();	357	return promise;
359	}	358	}
360		359
361	JSValue JSWebKitSubtleCrypto::digest(ExecState& state)	360	JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
Lines 382-389 JSValue JSWebKitSubtleCrypto::digest(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec9
382	if (!success)	381	if (!success)
383	return jsUndefined();	382	return jsUndefined();
384		383
385	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	384	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
386	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	385	auto promise = wrapper->promise();
387	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	386	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
388	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	387	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
389	};	388	};
Lines 398-404 JSValue JSWebKitSubtleCrypto::digest(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec10
398	return jsUndefined();	397	return jsUndefined();
399	}	398	}
400		399
401	return promiseDeferred->promise();	400	return promise;
402	}	401	}
403		402
404	JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)	403	JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)
Lines 434-441 JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec11
434	return jsUndefined();	433	return jsUndefined();
435	}	434	}
436		435
437	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	436	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
438	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	437	auto promise = wrapper->promise();
439	auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {	438	auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
440	ASSERT(key \|\| keyPair);	439	ASSERT(key \|\| keyPair);
441	ASSERT(!key \|\| !keyPair);	440	ASSERT(!key \|\| !keyPair);
Lines 455-461 JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec12
455	return jsUndefined();	454	return jsUndefined();
456	}	455	}
457		456
458	return promiseDeferred->promise();	457	return promise;
459	}	458	}
460		459
461	static void importKey(ExecState& state, CryptoKeyFormat keyFormat, CryptoOperationData data, RefPtr<CryptoAlgorithm> algorithm, RefPtr<CryptoAlgorithmParameters> parameters, bool extractable, CryptoKeyUsage keyUsages, CryptoAlgorithm::KeyCallback callback, CryptoAlgorithm::VoidCallback failureCallback)	460	static void importKey(ExecState& state, CryptoKeyFormat keyFormat, CryptoOperationData data, RefPtr<CryptoAlgorithm> algorithm, RefPtr<CryptoAlgorithmParameters> parameters, bool extractable, CryptoKeyUsage keyUsages, CryptoAlgorithm::KeyCallback callback, CryptoAlgorithm::VoidCallback failureCallback)
Lines 570-577 JSValue JSWebKitSubtleCrypto::importKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec13
570	return jsUndefined();	569	return jsUndefined();
571	}	570	}
572		571
573	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	572	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
574	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	573	auto promise = wrapper->promise();
575	auto successCallback = [wrapper](CryptoKey& result) mutable {	574	auto successCallback = [wrapper](CryptoKey& result) mutable {
576	wrapper->resolve(result);	575	wrapper->resolve(result);
577	};	576	};
Lines 583-589 JSValue JSWebKitSubtleCrypto::importKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec14
583	if (UNLIKELY(scope.exception()))	582	if (UNLIKELY(scope.exception()))
584	return jsUndefined();	583	return jsUndefined();
585		584
586	return promiseDeferred->promise();	585	return promise;
587	}	586	}
588		587
589	static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback)	588	static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback)
Lines 639-646 JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec15
639	if (!key)	638	if (!key)
640	return throwTypeError(&state, scope);	639	return throwTypeError(&state, scope);
641		640
642	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	641	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
643	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	642	auto promise = wrapper->promise();
644	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	643	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
645	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	644	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
646	};	645	};
Lines 652-658 JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec16
652	if (UNLIKELY(scope.exception()))	651	if (UNLIKELY(scope.exception()))
653	return jsUndefined();	652	return jsUndefined();
654		653
655	return promiseDeferred->promise();	654	return promise;
656	}	655	}
657		656
658	JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)	657	JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
Lines 693-700 JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec17
693	if (!parameters)	692	if (!parameters)
694	return jsUndefined();	693	return jsUndefined();
695		694
696	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	695	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
697	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	696	auto promise = wrapper->promise();
698		697
699	auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {	698	auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {
700	auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable {	699	auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable {
Lines 722-728 JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec18
722	return jsUndefined();	721	return jsUndefined();
723	}	722	}
724		723
725	return promiseDeferred->promise();	724	return promise;
726	}	725	}
727		726
728	JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)	727	JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)
Lines 793-800 JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec19
793	return jsUndefined();	792	return jsUndefined();
794	}	793	}
795		794
796	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	795	RefPtr<DOMPromiseDeferred> wrapper = createDOMGenericPromise(state, domWindow());
797	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	796	auto promise = wrapper->promise();
798	Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());	797	Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());
799		798
800	auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithm, unwrappedKeyAlgorithmParameters, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {	799	auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithm, unwrappedKeyAlgorithmParameters, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {
Lines 828-834 JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec20
828	return jsUndefined();	827	return jsUndefined();
829	}	828	}
830		829
831	return promiseDeferred->promise();	830	return promise;
832	}	831	}
833		832
834	} // namespace WebCore	833	} // namespace WebCore

Lines 3425-3431 sub GenerateImplementation a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec1
- a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm -3 / +3 lines
3425		3425
3426	my $scope = $interface->extendedAttributes->{"Exposed"} ? "WindowOrWorker" : "WindowOnly";	3426	my $scope = $interface->extendedAttributes->{"Exposed"} ? "WindowOrWorker" : "WindowOnly";
3427	push(@implContent, <<END);	3427	push(@implContent, <<END);
3428	static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DeferredWrapper>&&);	3428	static EncodedJSValue ${functionName}Promise(ExecState*, DOMGenericPromise&&);
3429		3429
3430	${functionReturn} ${functionName}(ExecState* state)	3430	${functionReturn} ${functionName}(ExecState* state)
3431	{	3431	{
Lines 3433-3439 ${functionReturn} ${functionName}(ExecState* state) a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec2
3433	return JSValue::encode(callPromiseFunction<${functionName}Promise, PromiseExecutionScope::${scope}>(*state));	3433	return JSValue::encode(callPromiseFunction<${functionName}Promise, PromiseExecutionScope::${scope}>(*state));
3434	}	3434	}
3435		3435
3436	static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	3436	static inline EncodedJSValue ${functionName}Promise(ExecState* state, DOMGenericPromise&& promise)
3437	END	3437	END
3438	}	3438	}
3439	else {	3439	else {
Lines 4145-4151 sub GenerateReturnParameters a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec3
4145	my @arguments;	4145	my @arguments;
4146		4146
4147	if (IsReturningPromise($function)) {	4147	if (IsReturningPromise($function)) {
4148	push(@arguments, "WTFMove(deferredWrapper)");	4148	push(@arguments, "WTFMove(promise)");
4149	}	4149	}
4150	push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} \|\| $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};	4150	push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} \|\| $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};
4151	return @arguments;	4151	return @arguments;

Lines 231-237 JSValue JSTestNode::getConstructor(VM& vm, const JSGlobalObject* globalObject) a/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp -3 / +3 lines
231	return getDOMConstructor<JSTestNodeConstructor>(vm, jsCast<const JSDOMGlobalObject>(globalObject));	231	return getDOMConstructor<JSTestNodeConstructor>(vm, jsCast<const JSDOMGlobalObject>(globalObject));
232	}	232	}
233		233
234	static EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState*, Ref<DeferredWrapper>&&);	234	static EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState*, DOMGenericPromise&&);
235		235
236	EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(ExecState* state)	236	EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(ExecState* state)
237	{	237	{
Lines 239-245 EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(ExecSt a/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp_sec2
239	return JSValue::encode(callPromiseFunction<jsTestNodePrototypeFunctionTestWorkerPromisePromise, PromiseExecutionScope::WindowOrWorker>(*state));	239	return JSValue::encode(callPromiseFunction<jsTestNodePrototypeFunctionTestWorkerPromisePromise, PromiseExecutionScope::WindowOrWorker>(*state));
240	}	240	}
241		241
242	static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	242	static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState* state, DOMGenericPromise&& promise)
243	{	243	{
244	VM& vm = state->vm();	244	VM& vm = state->vm();
245	auto throwScope = DECLARE_THROW_SCOPE(vm);	245	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 250-256 static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise a/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp_sec3
250	return throwThisTypeError(*state, throwScope, "TestNode", "testWorkerPromise");	250	return throwThisTypeError(*state, throwScope, "TestNode", "testWorkerPromise");
251	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestNode::info());	251	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestNode::info());
252	auto& impl = castedThis->wrapped();	252	auto& impl = castedThis->wrapped();
253	impl.testWorkerPromise(WTFMove(deferredWrapper));	253	impl.testWorkerPromise(WTFMove(promise));
254	return JSValue::encode(jsUndefined());	254	return JSValue::encode(jsUndefined());
255	}	255	}
256		256

Lines 7159-7165 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAny(ExecState* state) a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec1
- a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp -24 / +24 lines
7159	return JSValue::encode(jsUndefined());	7159	return JSValue::encode(jsUndefined());
7160	}	7160	}
7161		7161
7162	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);	7162	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, DOMGenericPromise&&);
7163		7163
7164	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)	7164	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)
7165	{	7165	{
Lines 7167-7173 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecS a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec2
7167	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));	7167	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));
7168	}	7168	}
7169		7169
7170	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7170	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, DOMGenericPromise&& promise)
7171	{	7171	{
7172	VM& vm = state->vm();	7172	VM& vm = state->vm();
7173	auto throwScope = DECLARE_THROW_SCOPE(vm);	7173	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7178-7188 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromis a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec3
7178	return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");	7178	return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");
7179	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());	7179	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
7180	auto& impl = castedThis->wrapped();	7180	auto& impl = castedThis->wrapped();
7181	impl.testPromiseFunction(WTFMove(deferredWrapper));	7181	impl.testPromiseFunction(WTFMove(promise));
7182	return JSValue::encode(jsUndefined());	7182	return JSValue::encode(jsUndefined());
7183	}	7183	}
7184		7184
7185	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);	7185	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, DOMGenericPromise&&);
7186		7186
7187	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)	7187	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)
7188	{	7188	{
Lines 7190-7196 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFl a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec4
7190	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));	7190	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));
7191	}	7191	}
7192		7192
7193	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7193	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, DOMGenericPromise&& promise)
7194	{	7194	{
7195	VM& vm = state->vm();	7195	VM& vm = state->vm();
7196	auto throwScope = DECLARE_THROW_SCOPE(vm);	7196	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7206-7216 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFl a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec5
7206	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);	7206	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
7207	if (UNLIKELY(throwScope.exception()))	7207	if (UNLIKELY(throwScope.exception()))
7208	return JSValue::encode(jsUndefined());	7208	return JSValue::encode(jsUndefined());
7209	impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredWrapper));	7209	impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(promise));
7210	return JSValue::encode(jsUndefined());	7210	return JSValue::encode(jsUndefined());
7211	}	7211	}
7212		7212
7213	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);	7213	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, DOMGenericPromise&&);
7214		7214
7215	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)	7215	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)
7216	{	7216	{
Lines 7218-7224 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithEx a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec6
7218	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));	7218	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));
7219	}	7219	}
7220		7220
7221	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7221	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, DOMGenericPromise&& promise)
7222	{	7222	{
7223	VM& vm = state->vm();	7223	VM& vm = state->vm();
7224	auto throwScope = DECLARE_THROW_SCOPE(vm);	7224	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7230-7241 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithEx a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec7
7230	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());	7230	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
7231	auto& impl = castedThis->wrapped();	7231	auto& impl = castedThis->wrapped();
7232	ExceptionCode ec = 0;	7232	ExceptionCode ec = 0;
7233	impl.testPromiseFunctionWithException(WTFMove(deferredWrapper), ec);	7233	impl.testPromiseFunctionWithException(WTFMove(promise), ec);
7234	setDOMException(state, ec);	7234	setDOMException(state, ec);
7235	return JSValue::encode(jsUndefined());	7235	return JSValue::encode(jsUndefined());
7236	}	7236	}
7237		7237
7238	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);	7238	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, DOMGenericPromise&&);
7239		7239
7240	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)	7240	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)
7241	{	7241	{
Lines 7243-7249 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOp a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec8
7243	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));	7243	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise, PromiseExecutionScope::WindowOnly>(*state));
7244	}	7244	}
7245		7245
7246	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7246	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, DOMGenericPromise&& promise)
7247	{	7247	{
7248	VM& vm = state->vm();	7248	VM& vm = state->vm();
7249	auto throwScope = DECLARE_THROW_SCOPE(vm);	7249	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7257-7267 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOp a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec9
7257	auto a = state->argument(0).isUndefined() ? Optional<int32_t>() : convert<int32_t>(*state, state->uncheckedArgument(0), NormalConversion);	7257	auto a = state->argument(0).isUndefined() ? Optional<int32_t>() : convert<int32_t>(*state, state->uncheckedArgument(0), NormalConversion);
7258	if (UNLIKELY(throwScope.exception()))	7258	if (UNLIKELY(throwScope.exception()))
7259	return JSValue::encode(jsUndefined());	7259	return JSValue::encode(jsUndefined());
7260	impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(deferredWrapper));	7260	impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(promise));
7261	return JSValue::encode(jsUndefined());	7261	return JSValue::encode(jsUndefined());
7262	}	7262	}
7263		7263
7264	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DeferredWrapper>&&);	7264	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, DOMGenericPromise&&);
7265		7265
7266	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)	7266	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)
7267	{	7267	{
Lines 7269-7275 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec10
7269	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise, PromiseExecutionScope::WindowOnly>(*state));	7269	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise, PromiseExecutionScope::WindowOnly>(*state));
7270	}	7270	}
7271		7271
7272	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7272	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, DOMGenericPromise&& promise)
7273	{	7273	{
7274	VM& vm = state->vm();	7274	VM& vm = state->vm();
7275	auto throwScope = DECLARE_THROW_SCOPE(vm);	7275	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7285-7295 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec11
7285	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);	7285	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
7286	if (UNLIKELY(throwScope.exception()))	7286	if (UNLIKELY(throwScope.exception()))
7287	return JSValue::encode(jsUndefined());	7287	return JSValue::encode(jsUndefined());
7288	impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredWrapper));	7288	impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(promise));
7289	return JSValue::encode(jsUndefined());	7289	return JSValue::encode(jsUndefined());
7290	}	7290	}
7291		7291
7292	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DeferredWrapper>&&);	7292	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, DOMGenericPromise&&);
7293		7293
7294	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)	7294	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)
7295	{	7295	{
Lines 7297-7303 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec12
7297	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise, PromiseExecutionScope::WindowOnly>(*state));	7297	return JSValue::encode(callPromiseFunction<jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise, PromiseExecutionScope::WindowOnly>(*state));
7298	}	7298	}
7299		7299
7300	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7300	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, DOMGenericPromise&& promise)
7301	{	7301	{
7302	VM& vm = state->vm();	7302	VM& vm = state->vm();
7303	auto throwScope = DECLARE_THROW_SCOPE(vm);	7303	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7313-7319 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec13
7313	auto request = JSFetchRequest::toWrapped(state->argument(0));	7313	auto request = JSFetchRequest::toWrapped(state->argument(0));
7314	if (UNLIKELY(!request))	7314	if (UNLIKELY(!request))
7315	return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");	7315	return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");
7316	impl.testPromiseOverloadedFunction(*request, WTFMove(deferredWrapper));	7316	impl.testPromiseOverloadedFunction(*request, WTFMove(promise));
7317	return JSValue::encode(jsUndefined());	7317	return JSValue::encode(jsUndefined());
7318	}	7318	}
7319		7319
Lines 7334-7340 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec14
7334	return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);	7334	return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);
7335	}	7335	}
7336		7336
7337	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);	7337	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, DOMGenericPromise&&);
7338		7338
7339	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)	7339	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)
7340	{	7340	{
Lines 7342-7357 EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFuncti a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec15
7342	return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));	7342	return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise, PromiseExecutionScope::WindowOnly>(*state));
7343	}	7343	}
7344		7344
7345	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7345	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, DOMGenericPromise&& promise)
7346	{	7346	{
7347	VM& vm = state->vm();	7347	VM& vm = state->vm();
7348	auto throwScope = DECLARE_THROW_SCOPE(vm);	7348	auto throwScope = DECLARE_THROW_SCOPE(vm);
7349	UNUSED_PARAM(throwScope);	7349	UNUSED_PARAM(throwScope);
7350	TestObj::testStaticPromiseFunction(WTFMove(deferredWrapper));	7350	TestObj::testStaticPromiseFunction(WTFMove(promise));
7351	return JSValue::encode(jsUndefined());	7351	return JSValue::encode(jsUndefined());
7352	}	7352	}
7353		7353
7354	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);	7354	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, DOMGenericPromise&&);
7355		7355
7356	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)	7356	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)
7357	{	7357	{
Lines 7359-7371 EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFuncti a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec16
7359	return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));	7359	return JSValue::encode(callPromiseFunction<jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise, PromiseExecutionScope::WindowOnly>(*state));
7360	}	7360	}
7361		7361
7362	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7362	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, DOMGenericPromise&& promise)
7363	{	7363	{
7364	VM& vm = state->vm();	7364	VM& vm = state->vm();
7365	auto throwScope = DECLARE_THROW_SCOPE(vm);	7365	auto throwScope = DECLARE_THROW_SCOPE(vm);
7366	UNUSED_PARAM(throwScope);	7366	UNUSED_PARAM(throwScope);
7367	ExceptionCode ec = 0;	7367	ExceptionCode ec = 0;
7368	TestObj::testStaticPromiseFunctionWithException(WTFMove(deferredWrapper), ec);	7368	TestObj::testStaticPromiseFunctionWithException(WTFMove(promise), ec);
7369	setDOMException(state, ec);	7369	setDOMException(state, ec);
7370	return JSValue::encode(jsUndefined());	7370	return JSValue::encode(jsUndefined());
7371	}	7371	}

Lines 27-32 a/Source/WebCore/dom/CustomElementRegistry.h_sec1
- a/Source/WebCore/dom/CustomElementRegistry.h -3 / +3 lines
27		27
28	#if ENABLE(CUSTOM_ELEMENTS)	28	#if ENABLE(CUSTOM_ELEMENTS)
29		29
		30	#include "JSDOMPromise.h"
30	#include "QualifiedName.h"	31	#include "QualifiedName.h"
31	#include <wtf/HashMap.h>	32	#include <wtf/HashMap.h>
32	#include <wtf/TemporaryChange.h>	33	#include <wtf/TemporaryChange.h>
Lines 44-50 namespace WebCore { a/Source/WebCore/dom/CustomElementRegistry.h_sec2
44		45
45	class CustomElementRegistry;	46	class CustomElementRegistry;
46	class DOMWindow;	47	class DOMWindow;
47	class DeferredWrapper;
48	class Element;	48	class Element;
49	class JSCustomElementInterface;	49	class JSCustomElementInterface;
50	class QualifiedName;	50	class QualifiedName;
Lines 66-72 public: a/Source/WebCore/dom/CustomElementRegistry.h_sec3
66		66
67	JSC::JSValue get(const AtomicString&);	67	JSC::JSValue get(const AtomicString&);
68		68
69	HashMap<AtomicString, Ref<DeferredWrapper>>& promiseMap() { return m_promiseMap; }	69	HashMap<AtomicString, DOMGenericPromise>& promiseMap() { return m_promiseMap; }
70		70
71	private:	71	private:
72	CustomElementRegistry(DOMWindow&);	72	CustomElementRegistry(DOMWindow&);
Lines 74-80 private: a/Source/WebCore/dom/CustomElementRegistry.h_sec4
74	DOMWindow& m_window;	74	DOMWindow& m_window;
75	HashMap<AtomicString, Ref<JSCustomElementInterface>> m_nameMap;	75	HashMap<AtomicString, Ref<JSCustomElementInterface>> m_nameMap;
76	HashMap<const JSC::JSObject, JSCustomElementInterface> m_constructorMap;	76	HashMap<const JSC::JSObject, JSCustomElementInterface> m_constructorMap;
77	HashMap<AtomicString, Ref<DeferredWrapper>> m_promiseMap;	77	HashMap<AtomicString, DOMGenericPromise> m_promiseMap;
78		78
79	bool m_elementDefinitionIsRunning { false };	79	bool m_elementDefinitionIsRunning { false };
80		80