Attachment #288784 for bug #161787

View Details Raw Unified Return to Bug 161787

| Differences between



2016-09-14  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 DOMDeferredPromise.
        Adding create method that creates the underlying JSC::JSPromiseDeferred.
        This new create is to be used in non-worker environments.
        Updated create method to take references.

        * 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 DOMDeferredPromise 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/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-13  Chris Dumez  <cdumez@apple.com>

        Unreviewed, rolling out r205887.



    return paymentCoordinator.canMakePayments();
}

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

        return;
    }

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



namespace WebCore {

class ArrayValue;
class DOMDeferredPromise;
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<DOMDeferredPromise>&&, 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, Ref<DOMDeferredPromise>&& promise)
41	{	41	{
42	if (!window.scriptExecutionContext())	42	if (!window.scriptExecutionContext())
43	return;	43	return;



namespace WebCore {

class DOMWindow;
class DOMDeferredPromise;
class Dictionary;
class FetchRequest;
class FetchResponse;

class DOMWindowFetch {
public:
    static void fetch(DOMWindow&, FetchRequest&, Ref<DOMDeferredPromise>&&);
};

} // namespace WebCore



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

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

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

    consume(owner, WTFMove(promise));
}

void FetchBody::json(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
{
    ASSERT(m_type != Type::None);


    consume(owner, WTFMove(promise));
}

void FetchBody::text(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
{
    ASSERT(m_type != Type::None);


    consume(owner, WTFMove(promise));
}

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

}
#endif

void FetchBody::consumeArrayBuffer(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& promise)
{
    Vector<uint8_t> data = extractFromText();
    m_consumer.resolveWithData(WTFMove(promise), data.data(), data.size());
    m_text = { };
}

void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
{
    ASSERT(m_blob);





class FetchBody {
public:
    void arrayBuffer(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
    void blob(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
    void json(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
    void text(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
    void formData(FetchBodyOwner&, Ref<DOMDeferredPromise>&& 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&, Ref<DOMDeferredPromise>&&);

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

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

    String m_text;

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

} // namespace WebCore



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

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

    }
}

void FetchBodyConsumer::resolve(Ref<DOMDeferredPromise>&& promise)
{
    ASSERT(m_type != Type::None);
    switch (m_type) {



namespace WebCore {

class Blob;
class DOMDeferredPromise;

class FetchBodyConsumer {
public:


    void clean() { m_buffer = nullptr; }

    void resolve(Ref<DOMDeferredPromise>&&);
    void resolveWithData(Ref<DOMDeferredPromise>&&, const unsigned char*, unsigned);

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




    return false;
}

void FetchBodyOwner::arrayBuffer(Ref<DOMDeferredPromise>&& promise)
{
    if (m_body.isEmpty()) {
        fulfillPromiseWithArrayBuffer(WTFMove(promise), nullptr, 0);

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

void FetchBodyOwner::blob(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& promise)
{
    if (m_body.isEmpty()) {
        promise->reject(0);

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

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

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

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



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

    void arrayBuffer(Ref<DOMDeferredPromise>&&);
    void blob(Ref<DOMDeferredPromise>&&);
    void formData(Ref<DOMDeferredPromise>&&);
    void json(Ref<DOMDeferredPromise>&&);
    void text(Ref<DOMDeferredPromise>&&);

    bool isDisturbedOrLocked() const;




        m_loader->stop();
}

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


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

void FetchResponse::finishConsumingStream(Ref<DOMDeferredPromise>&& promise)
{
    m_consumer.resolve(WTFMove(promise));
}



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

    void consume(unsigned, Ref<DOMDeferredPromise>&&);
#if ENABLE(READABLE_STREAM_API)
    void startConsumingStream(unsigned);
    void consumeChunk(Ref<JSC::Uint8Array>&&);
    void finishConsumingStream(Ref<DOMDeferredPromise>&&);
#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, Ref<DOMDeferredPromise>&& promise)
40	{	40	{
41	if (!scope.scriptExecutionContext())	41	if (!scope.scriptExecutionContext())
42	return;	42	return;



namespace WebCore {

class WorkerGlobalScope;
class DOMDeferredPromise;
class FetchRequest;

class WorkerGlobalScopeFetch {
public:
    static void fetch(WorkerGlobalScope&, FetchRequest&, Ref<DOMDeferredPromise>&&);
};

} // namespace WebCore



        return jsUndefined();

    if (registry.findInterface(localName)) {
        auto domPromise = DOMDeferredPromise::create(state, globalObject);
        domPromise->resolve(nullptr);
        return domPromise->promise();
    }

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

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

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

    JSDOMGlobalObject& globalObject = *jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject());
    auto& promiseDeferred = *JSPromiseDeferred::create(&state, &globalObject);
    JSValue promise = whenDefinedPromise(state, globalObject, wrapped());

    if (UNLIKELY(scope.exception())) {
        auto promiseDeferred = JSPromiseDeferred::create(&state, &globalObject);
        ASSERT(promiseDeferred);
        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 DOMDeferredPromise;
    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<DOMDeferredPromise*> DOMDeferredPromiseSet;

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

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

        DOMDeferredPromiseSet& deferredPromises() { return m_deferredPromises; }

        ScriptExecutionContext* scriptExecutionContext() const;


    protected:
        JSDOMStructureMap m_structures;
        JSDOMConstructorMap m_constructors;
        DOMDeferredPromiseSet m_deferredPromises;

        Event* m_currentEvent;
        Ref<DOMWrapperWorld> m_world;




namespace WebCore {

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

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

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

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

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

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

    clear();
}

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

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

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

static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data)

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

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

        promise->resolve(value);
}

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

    promise->resolve(arrayBuffer);
}

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



    static constexpr bool passByConstRef = false;
};

class DOMDeferredPromise : public RefCounted<DOMDeferredPromise>, public ActiveDOMCallback {
public:
    static Ref<DOMDeferredPromise> create(JSC::ExecState& state, JSDOMGlobalObject& globalObject)
    static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
    {
        JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &globalObject);
        // deferred can only be null in workers.
        ASSERT(deferred);
        return adoptRef(*new DOMDeferredPromise(globalObject, *deferred));
    }

    static Ref<DOMDeferredPromise> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred)
    {
        return adoptRef(*new DOMDeferredPromise(globalObject, deferred));
    }

    ~DOMDeferredPromise();

    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:
    DOMDeferredPromise(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);

    void clear();
    void contextDestroyed() override;

    JSC::Weak<JSDOMGlobalObject> m_globalObject;
};

void fulfillPromiseWithJSON(Ref<DOMDeferredPromise>&&, const String&);
void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&&, ArrayBuffer*);
void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&&, const void*, size_t);
void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);

inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSValue promiseFunction(JSC::ExecState*, Ref<DOMDeferredPromise>&&))
{
    JSC::VM& vm = state.vm();
    auto scope = DECLARE_CATCH_SCOPE(vm);

    if (!promiseDeferred)
        return JSC::jsUndefined();

    promiseFunction(&state, DOMDeferredPromise::create(globalObject, *promiseDeferred));

    rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
    ASSERT_UNUSED(scope, !scope.exception());

template <typename Value>
class DOMPromise {
public:
    DOMPromise(Ref<DOMDeferredPromise>&& wrapper)
        : m_wrapper(WTFMove(wrapper))
    {
    }


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

    DOMDeferredPromise& deferredPromise() { return m_wrapper; }

private:
    Ref<DOMDeferredPromise> m_wrapper;
};

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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

}

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



{
    if (!m_loaded) {
        if (!wrapped().promise()) {
            ASSERT(globalObject());
            auto promise = DOMDeferredPromise::create(state, *globalObject());
            m_loaded.set(state.vm(), this, promise->promise());
            wrapped().registerLoaded(WTFMove(promise));
        } else
            m_loaded.set(state.vm(), this, wrapped().promise().value().deferredPromise().promise());
    }
    return m_loaded.get();
}



JSC::JSValue JSFontFaceSet::ready(JSC::ExecState& state) const
{
    if (!m_ready) {
        ASSERT(globalObject());
        auto promise = DOMDeferredPromise::create(state, *globalObject());
        m_ready.set(state.vm(), this, promise->promise());
        wrapped().registerReady(WTFMove(promise));
    }

Lines 374-383 JSValue JSMediaDevices::getUserMedia(ExecState& state) a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp -3 / +7 lines
374		374
375	auto audioConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryAudioConstraints), WTFMove(advancedAudioConstraints), areAudioConstraintsValid);	375	auto audioConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryAudioConstraints), WTFMove(advancedAudioConstraints), areAudioConstraintsValid);
376	auto videoConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryVideoConstraints), WTFMove(advancedVideoConstraints), areVideoConstraintsValid);	376	auto videoConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryVideoConstraints), WTFMove(advancedVideoConstraints), areVideoConstraintsValid);
377	JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());	377
378	wrapped().getUserMedia(WTFMove(audioConstraints), WTFMove(videoConstraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred), ec);	378	ASSERT(globalObject());
		379	auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
		380	auto promise = deferredPromise->promise();
		381
		382	wrapped().getUserMedia(WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(deferredPromise), ec);
379	setDOMException(&state, ec);	383	setDOMException(&state, ec);
380	return promiseDeferred->promise();	384	return promise;
381	}	385	}
382		386
383	}	387	}

Lines 184-194 JSValue JSMediaStreamTrack::applyConstraints(ExecState& state) a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp -3 / +6 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	ASSERT(globalObject());
		188	auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
		189	auto promise = deferredPromise->promise();
		190
188	auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);	191	auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);
189	wrapped().applyConstraints(WTFMove(constraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred));	192	wrapped().applyConstraints(WTFMove(constraints), WTFMove(deferredPromise));
190		193
191	return promiseDeferred->promise();	194	return promise;
192	}	195	}
193		196
194	JSValue JSMediaStreamTrack::getConstraints(ExecState& state)	197	JSValue JSMediaStreamTrack::getConstraints(ExecState& state)

Lines 43-51 JSValue JSReadableStreamSource::start(ExecState& state) a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp -3 / +6 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	JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());	46	ASSERT(globalObject());
47	wrapped().start(ReadableStreamDefaultController(controller), DeferredWrapper::create(&state, globalObject(), promiseDeferred));	47	auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
48	return promiseDeferred->promise();	48	auto promise = deferredPromise->promise();
		49
		50	wrapped().start(ReadableStreamDefaultController(controller), WTFMove(deferredPromise));
		51	return promise;
49	}	52	}
50		53
51	JSValue JSReadableStreamSource::controller(ExecState&) const	54	JSValue JSReadableStreamSource::controller(ExecState&) const



    if (!success)
        return jsUndefined();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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::decrypt(ExecState& state)

    if (!success)
        return jsUndefined();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();
    }

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();
    }

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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);

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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();
    }

    ASSERT(globalObject());
    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
    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



                AddToImplIncludes("JSDOMPromise.h");

                push(@implContent, <<END);
static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DOMDeferredPromise>&&);
${functionReturn} ${functionName}(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, ${functionName}Promise));
}

static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
END
            }
            else {

    my @arguments;

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



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

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionPromise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise), ec);
    setDOMException(state, ec);
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DOMDeferredPromise>&&);
static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise));
    return JSValue::encode(jsUndefined());
}

static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DOMDeferredPromise>&&);
static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise));
}

static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
{
    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(deferredPromise));
    return JSValue::encode(jsUndefined());
}


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

static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise));
}

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

static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)
{
    return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise));
}

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




class CustomElementRegistry;
class DOMWindow;
class DOMDeferredPromise;
class Element;
class JSCustomElementInterface;
class QualifiedName;


    JSC::JSValue get(const AtomicString&);

    HashMap<AtomicString, Ref<DOMDeferredPromise>>& 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, Ref<DOMDeferredPromise>> 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<DOMDeferredPromise>&& 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<DOMDeferredPromise> 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, Ref<DOMDeferredPromise>&& 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, Ref<DOMDeferredPromise>&& 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, Ref<DOMDeferredPromise>&& 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, Ref<DOMDeferredPromise>&& 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, Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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, Ref<DOMDeferredPromise>&& promise)
271	{	271	{
272	ASSERT(m_blob);	272	ASSERT(m_blob);
273		273

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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& promise)
131	{	131	{
132	if (m_body.isEmpty()) {	132	if (m_body.isEmpty()) {
133	promise->resolve(String());	133	promise->resolve(String());

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, Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& promise)
245	{	245	{
246	m_consumer.resolve(WTFMove(promise));	246	m_consumer.resolve(WTFMove(promise));
247	}	247	}

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, Ref<DOMDeferredPromise>&&);
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(Ref<DOMDeferredPromise>&&);
68	#endif	68	#endif
69		69
70	void setStatus(int, const String&, ExceptionCode&);	70	void setStatus(int, const String&, ExceptionCode&);

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +127 lines
		1	2016-09-14 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 DOMDeferredPromise.
		11	Adding create method that creates the underlying JSC::JSPromiseDeferred.
		12	This new create is to be used in non-worker environments.
		13	Updated create method to take references.
		14
		15	* Modules/applepay/ApplePaySession.cpp:
		16	(WebCore::ApplePaySession::canMakePaymentsWithActiveCard):
		17	* Modules/applepay/ApplePaySession.h:
		18	* Modules/fetch/DOMWindowFetch.cpp:
		19	(WebCore::DOMWindowFetch::fetch):
		20	* Modules/fetch/DOMWindowFetch.h: Updated to take a DOMDeferredPromise to make it consistent with WorkerGlobalScopeFetch.
		21	* Modules/fetch/FetchBody.cpp:
		22	(WebCore::FetchBody::arrayBuffer):
		23	(WebCore::FetchBody::blob):
		24	(WebCore::FetchBody::json):
		25	(WebCore::FetchBody::text):
		26	(WebCore::FetchBody::consume):
		27	(WebCore::FetchBody::consumeArrayBuffer):
		28	(WebCore::FetchBody::consumeArrayBufferView):
		29	(WebCore::FetchBody::consumeText):
		30	(WebCore::FetchBody::consumeBlob):
		31	* Modules/fetch/FetchBody.h:
		32	(WebCore::FetchBody::formData):
		33	* Modules/fetch/FetchBodyConsumer.cpp:
		34	(WebCore::FetchBodyConsumer::resolveWithData):
		35	(WebCore::FetchBodyConsumer::resolve):
		36	* Modules/fetch/FetchBodyConsumer.h:
		37	* Modules/fetch/FetchBodyOwner.cpp:
		38	(WebCore::FetchBodyOwner::arrayBuffer):
		39	(WebCore::FetchBodyOwner::blob):
		40	(WebCore::FetchBodyOwner::formData):
		41	(WebCore::FetchBodyOwner::json):
		42	(WebCore::FetchBodyOwner::text):
		43	* Modules/fetch/FetchBodyOwner.h:
		44	* Modules/fetch/FetchResponse.cpp:
		45	(WebCore::FetchResponse::consume):
		46	(WebCore::FetchResponse::finishConsumingStream):
		47	* Modules/fetch/FetchResponse.h:
		48	* Modules/fetch/WorkerGlobalScopeFetch.cpp:
		49	(WebCore::WorkerGlobalScopeFetch::fetch):
		50	* Modules/fetch/WorkerGlobalScopeFetch.h:
		51	* bindings/js/JSCustomElementRegistryCustom.cpp:
		52	(WebCore::whenDefinedPromise):
		53	(WebCore::JSCustomElementRegistry::whenDefined):
		54	* bindings/js/JSDOMGlobalObject.cpp:
		55	(WebCore::JSDOMGlobalObject::visitChildren):
		56	* bindings/js/JSDOMGlobalObject.h:
		57	* bindings/js/JSDOMPromise.cpp:
		58	(WebCore::DOMDeferredPromise::DOMDeferredPromise):
		59	(WebCore::DOMDeferredPromise::~DOMDeferredPromise):
		60	(WebCore::DOMDeferredPromise::clear):
		61	(WebCore::DOMDeferredPromise::contextDestroyed):
		62	(WebCore::DOMDeferredPromise::promise):
		63	(WebCore::DOMDeferredPromise::callFunction):
		64	(WebCore::DOMDeferredPromise::reject):
65	(WebCore::rejectPromiseWithExceptionIfAny):
66	(WebCore::fulfillPromiseWithJSON):
67	(WebCore::fulfillPromiseWithArrayBuffer):
68	(WebCore::DeferredWrapper::DeferredWrapper): Deleted.
69	(WebCore::DeferredWrapper::~DeferredWrapper): Deleted.
70	(WebCore::DeferredWrapper::clear): Deleted.
71	(WebCore::DeferredWrapper::contextDestroyed): Deleted.
72	(WebCore::DeferredWrapper::promise): Deleted.
73	(WebCore::DeferredWrapper::callFunction): Deleted.
74	(WebCore::DeferredWrapper::reject): Deleted.
75	* bindings/js/JSDOMPromise.h:
76	(WebCore::DOMDeferredPromise::create):
77	(WebCore::callPromiseFunction):
78	(WebCore::DOMPromise::DOMPromise):
79	(WebCore::DOMPromise::deferredPromise):
80	(WebCore::DOMDeferredPromise::resolveWithValue):
81	(WebCore::DOMDeferredPromise::resolveWithNewlyCreated):
82	(WebCore::DOMDeferredPromise::rejectWithValue):
83	(WebCore::DOMDeferredPromise::resolve):
84	(WebCore::DOMDeferredPromise::reject):
85	(WebCore::DeferredWrapper::create): Deleted.
86	(WebCore::DOMPromise::deferredWrapper): Deleted.
87	(WebCore::DeferredWrapper::resolveWithValue): Deleted.
88	(WebCore::DeferredWrapper::resolveWithNewlyCreated): Deleted.
89	(WebCore::DeferredWrapper::rejectWithValue): Deleted.
90	(WebCore::DeferredWrapper::resolve): Deleted.
91	(WebCore::DeferredWrapper::reject): Deleted.
92	* bindings/js/JSFontFaceCustom.cpp:
93	(WebCore::JSFontFace::loaded):
94	* bindings/js/JSFontFaceSetCustom.cpp:
95	(WebCore::JSFontFaceSet::ready):
96	* bindings/js/JSMediaDevicesCustom.cpp:
97	(WebCore::JSMediaDevices::getUserMedia):
98	* bindings/js/JSMediaStreamTrackCustom.cpp:
99	(WebCore::JSMediaStreamTrack::applyConstraints):
100	* bindings/js/JSReadableStreamSourceCustom.cpp:
101	(WebCore::JSReadableStreamSource::start):
102	* bindings/js/JSWebKitSubtleCryptoCustom.cpp:
103	(WebCore::JSWebKitSubtleCrypto::encrypt):
104	(WebCore::JSWebKitSubtleCrypto::decrypt):
105	(WebCore::JSWebKitSubtleCrypto::sign):
106	(WebCore::JSWebKitSubtleCrypto::verify):
107	(WebCore::JSWebKitSubtleCrypto::digest):
108	(WebCore::JSWebKitSubtleCrypto::generateKey):
109	(WebCore::JSWebKitSubtleCrypto::importKey):
110	(WebCore::JSWebKitSubtleCrypto::exportKey):
111	(WebCore::JSWebKitSubtleCrypto::wrapKey):
112	(WebCore::JSWebKitSubtleCrypto::unwrapKey):
113	* bindings/scripts/CodeGeneratorJS.pm:
114	(GenerateImplementation):
115	(GenerateReturnParameters):
116	* bindings/scripts/test/JS/JSTestObj.cpp:
117	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionPromise):
118	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise):
119	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise):
120	(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise):
121	(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise):
122	(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise):
123	(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise):
124	(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise):
125	* dom/CustomElementRegistry.h:
126	(WebCore::CustomElementRegistry::promiseMap):
127
1	2016-09-13 Chris Dumez <cdumez@apple.com>	128	2016-09-13 Chris Dumez <cdumez@apple.com>
2		129
3	Unreviewed, rolling out r205887.	130	Unreviewed, rolling out r205887.

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&, Ref<DOMDeferredPromise>&&);
56	void blob(FetchBodyOwner&, Ref<DeferredWrapper>&&);	56	void blob(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
57	void json(FetchBodyOwner&, Ref<DeferredWrapper>&&);	57	void json(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
58	void text(FetchBodyOwner&, Ref<DeferredWrapper>&&);	58	void text(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
59	void formData(FetchBodyOwner&, Ref<DeferredWrapper>&& promise) { promise.get().reject(0); }	59	void formData(FetchBodyOwner&, Ref<DOMDeferredPromise>&& 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&, Ref<DOMDeferredPromise>&&);
97		97
98	Vector<uint8_t> extractFromText() const;	98	Vector<uint8_t> extractFromText() const;
99	void consumeArrayBuffer(Ref<DeferredWrapper>&&);	99	void consumeArrayBuffer(Ref<DOMDeferredPromise>&&);
100	void consumeArrayBufferView(Ref<DeferredWrapper>&&);	100	void consumeArrayBufferView(Ref<DOMDeferredPromise>&&);
101	void consumeText(Ref<DeferredWrapper>&&);	101	void consumeText(Ref<DOMDeferredPromise>&&);
102	void consumeBlob(FetchBodyOwner&, Ref<DeferredWrapper>&&);	102	void consumeBlob(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
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<DOMDeferredPromise> 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(Ref<DOMDeferredPromise>&& 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(Ref<DOMDeferredPromise>&& promise)
84	{	84	{
85	ASSERT(m_type != Type::None);	85	ASSERT(m_type != Type::None);
86	switch (m_type) {	86	switch (m_type) {

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(Ref<DOMDeferredPromise>&&);
50	void blob(Ref<DeferredWrapper>&&);	50	void blob(Ref<DOMDeferredPromise>&&);
51	void formData(Ref<DeferredWrapper>&&);	51	void formData(Ref<DOMDeferredPromise>&&);
52	void json(Ref<DeferredWrapper>&&);	52	void json(Ref<DOMDeferredPromise>&&);
53	void text(Ref<DeferredWrapper>&&);	53	void text(Ref<DOMDeferredPromise>&&);
54		54
55	bool isDisturbedOrLocked() const;	55	bool isDisturbedOrLocked() const;
56		56

Lines 177-189 static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObj a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp -7 / +8 lines
177	return jsUndefined();	177	return jsUndefined();
178		178
179	if (registry.findInterface(localName)) {	179	if (registry.findInterface(localName)) {
180	auto& jsPromise = *JSPromiseDeferred::create(&state, &globalObject);	180	auto domPromise = DOMDeferredPromise::create(state, globalObject);
181	DeferredWrapper::create(&state, &globalObject, &jsPromise)->resolve(nullptr);	181	domPromise->resolve(nullptr);
182	return jsPromise.promise();	182	return domPromise->promise();
183	}	183	}
184		184
185	auto result = registry.promiseMap().ensure(localName, [&] {	185	auto result = registry.promiseMap().ensure(localName, [&] {
186	return DeferredWrapper::create(&state, &globalObject, JSPromiseDeferred::create(&state, &globalObject));	186	return DOMDeferredPromise::create(state, globalObject);
187	});	187	});
188		188
189	return result.iterator->value->promise();	189	return result.iterator->value->promise();
Lines 194-206 JSValue JSCustomElementRegistry::whenDefined(ExecState& state) a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp_sec2
194	auto scope = DECLARE_CATCH_SCOPE(state.vm());	194	auto scope = DECLARE_CATCH_SCOPE(state.vm());
195		195
196	JSDOMGlobalObject& globalObject = jsCast<JSDOMGlobalObject>(state.lexicalGlobalObject());	196	JSDOMGlobalObject& globalObject = jsCast<JSDOMGlobalObject>(state.lexicalGlobalObject());
197	auto& promiseDeferred = *JSPromiseDeferred::create(&state, &globalObject);
198	JSValue promise = whenDefinedPromise(state, globalObject, wrapped());	197	JSValue promise = whenDefinedPromise(state, globalObject, wrapped());
199		198
200	if (UNLIKELY(scope.exception())) {	199	if (UNLIKELY(scope.exception())) {
201	rejectPromiseWithExceptionIfAny(state, globalObject, promiseDeferred);	200	auto promiseDeferred = JSPromiseDeferred::create(&state, &globalObject);
		201	ASSERT(promiseDeferred);
		202	rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
202	ASSERT(!scope.exception());	203	ASSERT(!scope.exception());
203	return promiseDeferred.promise();	204	return promiseDeferred->promise();
204	}	205	}
205		206
206	return promise;	207	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 35-75 using namespace JSC; a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec1
- a/Source/WebCore/bindings/js/JSDOMPromise.cpp -17 / +17 lines
35		35
36	namespace WebCore {	36	namespace WebCore {
37		37
38	DeferredWrapper::DeferredWrapper(ExecState, JSDOMGlobalObject globalObject, JSPromiseDeferred* promiseDeferred)	38	DOMDeferredPromise::DOMDeferredPromise(JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
39	: ActiveDOMCallback(globalObject->scriptExecutionContext())	39	: ActiveDOMCallback(globalObject.scriptExecutionContext())
40	, m_deferred(promiseDeferred)	40	, m_deferred(&promiseDeferred)
41	, m_globalObject(globalObject)	41	, m_globalObject(&globalObject)
42	{	42	{
43	globalObject->vm().heap.writeBarrier(globalObject, promiseDeferred);	43	globalObject.vm().heap.writeBarrier(&globalObject, &promiseDeferred);
44	m_globalObject->deferredWrappers().add(this);	44	globalObject.deferredPromises().add(this);
45	}	45	}
46		46
47	DeferredWrapper::~DeferredWrapper()	47	DOMDeferredPromise::~DOMDeferredPromise()
48	{	48	{
49	clear();	49	clear();
50	}	50	}
51		51
52	void DeferredWrapper::clear()	52	void DOMDeferredPromise::clear()
53	{	53	{
54	ASSERT(!m_deferred \|\| m_globalObject);	54	ASSERT(!m_deferred \|\| m_globalObject);
55	if (m_deferred && m_globalObject)	55	if (m_deferred && m_globalObject)
56	m_globalObject->deferredWrappers().remove(this);	56	m_globalObject->deferredPromises().remove(this);
57	m_deferred.clear();	57	m_deferred.clear();
58	}	58	}
59		59
60	void DeferredWrapper::contextDestroyed()	60	void DOMDeferredPromise::contextDestroyed()
61	{	61	{
62	ActiveDOMCallback::contextDestroyed();	62	ActiveDOMCallback::contextDestroyed();
63	clear();	63	clear();
64	}	64	}
65		65
66	JSC::JSValue DeferredWrapper::promise() const	66	JSC::JSValue DOMDeferredPromise::promise() const
67	{	67	{
68	ASSERT(m_deferred);	68	ASSERT(m_deferred);
69	return m_deferred->promise();	69	return m_deferred->promise();
70	}	70	}
71		71
72	void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue resolution)	72	void DOMDeferredPromise::callFunction(ExecState& exec, JSValue function, JSValue resolution)
73	{	73	{
74	if (!canInvokeCallback())	74	if (!canInvokeCallback())
75	return;	75	return;
Lines 86-92 void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue re a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec2
86	clear();	86	clear();
87	}	87	}
88		88
89	void DeferredWrapper::reject(ExceptionCode ec, const String& message)	89	void DOMDeferredPromise::reject(ExceptionCode ec, const String& message)
90	{	90	{
91	if (isSuspended())	91	if (isSuspended())
92	return;	92	return;
Lines 109-115 void rejectPromiseWithExceptionIfAny(JSC::ExecState& state, JSDOMGlobalObject& g a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec3
109	JSValue error = scope.exception()->value();	109	JSValue error = scope.exception()->value();
110	scope.clearException();	110	scope.clearException();
111		111
112	DeferredWrapper::create(&state, &globalObject, &promiseDeferred)->reject(error);	112	DOMDeferredPromise::create(globalObject, promiseDeferred)->reject(error);
113	}	113	}
114		114
115	static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data)	115	static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data)
Lines 118-124 static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec4
118	return JSC::JSONParse(state, data);	118	return JSC::JSONParse(state, data);
119	}	119	}
120		120
121	void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data)	121	void fulfillPromiseWithJSON(Ref<DOMDeferredPromise>&& promise, const String& data)
122	{	122	{
123	JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);	123	JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);
124	if (!value)	124	if (!value)
Lines 127-133 void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data) a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec5
127	promise->resolve(value);	127	promise->resolve(value);
128	}	128	}
129		129
130	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* arrayBuffer)	130	void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&& promise, ArrayBuffer* arrayBuffer)
131	{	131	{
132	if (!arrayBuffer) {	132	if (!arrayBuffer) {
133	promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));	133	promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));
Lines 136-142 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* a/Source/WebCore/bindings/js/JSDOMPromise.cpp_sec6
136	promise->resolve(arrayBuffer);	136	promise->resolve(arrayBuffer);
137	}	137	}
138		138
139	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, const void* data, size_t length)	139	void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&& promise, const void* data, size_t length)
140	{	140	{
141	fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());	141	fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());
142	}	142	}

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 -24 / +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 DOMDeferredPromise : public RefCounted<DOMDeferredPromise>, public ActiveDOMCallback {
100	public:	100	public:
101	// FIXME: We should pass references here, not pointers, see bug 161787	101	static Ref<DOMDeferredPromise> create(JSC::ExecState& state, JSDOMGlobalObject& globalObject)
102	static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
103	{	102	{
104	return adoptRef(*new DeferredWrapper(state, globalObject, deferred));	103	JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &globalObject);
		104	// deferred can only be null in workers.
		105	ASSERT(deferred);
		106	return adoptRef(new DOMDeferredPromise(globalObject, deferred));
105	}	107	}
106		108
107	~DeferredWrapper();	109	static Ref<DOMDeferredPromise> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred)
		110	{
		111	return adoptRef(*new DOMDeferredPromise(globalObject, deferred));
		112	}
		113
		114	~DOMDeferredPromise();
108		115
109	template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type	116	template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
110	resolve(ResolveResultType result) { resolveWithValue(result); }	117	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); }	143	void visitAggregate(JSC::SlotVisitor& visitor) { visitor.appendUnbarrieredWeak(&m_deferred); }
137		144
138	private:	145	private:
139	DeferredWrapper(JSC::ExecState, JSDOMGlobalObject, JSC::JSPromiseDeferred*);	146	DOMDeferredPromise(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
140		147
141	void clear();	148	void clear();
142	void contextDestroyed() override;	149	void contextDestroyed() override;
Lines 152-163 private: a/Source/WebCore/bindings/js/JSDOMPromise.h_sec3
152	JSC::Weak<JSDOMGlobalObject> m_globalObject;	159	JSC::Weak<JSDOMGlobalObject> m_globalObject;
153	};	160	};
154		161
155	void fulfillPromiseWithJSON(Ref<DeferredWrapper>&&, const String&);	162	void fulfillPromiseWithJSON(Ref<DOMDeferredPromise>&&, const String&);
156	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, ArrayBuffer*);	163	void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&&, ArrayBuffer*);
157	void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, const void*, size_t);	164	void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&&, const void*, size_t);
158	void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);	165	void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
159		166
160	inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSValue promiseFunction(JSC::ExecState*, Ref<DeferredWrapper>&&))	167	inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSValue promiseFunction(JSC::ExecState*, Ref<DOMDeferredPromise>&&))
161	{	168	{
162	JSC::VM& vm = state.vm();	169	JSC::VM& vm = state.vm();
163	auto scope = DECLARE_CATCH_SCOPE(vm);	170	auto scope = DECLARE_CATCH_SCOPE(vm);
Lines 169-175 inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSVal a/Source/WebCore/bindings/js/JSDOMPromise.h_sec4
169	if (!promiseDeferred)	176	if (!promiseDeferred)
170	return JSC::jsUndefined();	177	return JSC::jsUndefined();
171		178
172	promiseFunction(&state, DeferredWrapper::create(&state, &globalObject, promiseDeferred));	179	promiseFunction(&state, DOMDeferredPromise::create(globalObject, *promiseDeferred));
173		180
174	rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);	181	rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
175	ASSERT_UNUSED(scope, !scope.exception());	182	ASSERT_UNUSED(scope, !scope.exception());
Lines 180-186 inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSVal a/Source/WebCore/bindings/js/JSDOMPromise.h_sec5
180	template <typename Value>	187	template <typename Value>
181	class DOMPromise {	188	class DOMPromise {
182	public:	189	public:
183	DOMPromise(Ref<DeferredWrapper>&& wrapper)	190	DOMPromise(Ref<DOMDeferredPromise>&& wrapper)
184	: m_wrapper(WTFMove(wrapper))	191	: m_wrapper(WTFMove(wrapper))
185	{	192	{
186	}	193	}
Lines 194-207 public: a/Source/WebCore/bindings/js/JSDOMPromise.h_sec6
194		201
195	template<typename... ErrorType> void reject(ErrorType&&... error) { m_wrapper->reject(std::forward<ErrorType>(error)...); }	202	template<typename... ErrorType> void reject(ErrorType&&... error) { m_wrapper->reject(std::forward<ErrorType>(error)...); }
196		203
197	DeferredWrapper& deferredWrapper() { return m_wrapper; }	204	DOMDeferredPromise& deferredPromise() { return m_wrapper; }
198		205
199	private:	206	private:
200	Ref<DeferredWrapper> m_wrapper;	207	Ref<DOMDeferredPromise> m_wrapper;
201	};	208	};
202		209
203	template<class ResolveResultType>	210	template<class ResolveResultType>
204	inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)	211	inline void DOMDeferredPromise::resolveWithValue(ResolveResultType&& result)
205	{	212	{
206	if (isSuspended())	213	if (isSuspended())
207	return;	214	return;
Lines 212-218 inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec7
212	}	219	}
213		220
214	template<class ResolveResultType>	221	template<class ResolveResultType>
215	inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)	222	inline void DOMDeferredPromise::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
216	{	223	{
217	if (isSuspended())	224	if (isSuspended())
218	return;	225	return;
Lines 224-230 inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& re a/Source/WebCore/bindings/js/JSDOMPromise.h_sec8
224	}	231	}
225		232
226	template<class RejectResultType>	233	template<class RejectResultType>
227	inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)	234	inline void DOMDeferredPromise::rejectWithValue(RejectResultType&& result)
228	{	235	{
229	if (isSuspended())	236	if (isSuspended())
230	return;	237	return;
Lines 236-242 inline void DeferredWrapper::rejectWithValue(RejectResultType&& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec9
236	}	243	}
237		244
238	template<>	245	template<>
239	inline void DeferredWrapper::resolve(bool result)	246	inline void DOMDeferredPromise::resolve(bool result)
240	{	247	{
241	if (isSuspended())	248	if (isSuspended())
242	return;	249	return;
Lines 248-254 inline void DeferredWrapper::resolve(bool result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec10
248	}	255	}
249		256
250	template<>	257	template<>
251	inline void DeferredWrapper::resolve(JSC::JSValue value)	258	inline void DOMDeferredPromise::resolve(JSC::JSValue value)
252	{	259	{
253	if (isSuspended())	260	if (isSuspended())
254	return;	261	return;
Lines 260-266 inline void DeferredWrapper::resolve(JSC::JSValue value) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec11
260	}	267	}
261		268
262	template<>	269	template<>
263	inline void DeferredWrapper::reject(JSC::JSValue value)	270	inline void DOMDeferredPromise::reject(JSC::JSValue value)
264	{	271	{
265	if (isSuspended())	272	if (isSuspended())
266	return;	273	return;
Lines 272-278 inline void DeferredWrapper::reject(JSC::JSValue value) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec12
272	}	279	}
273		280
274	template<>	281	template<>
275	inline void DeferredWrapper::resolve(std::nullptr_t)	282	inline void DOMDeferredPromise::resolve(std::nullptr_t)
276	{	283	{
277	if (isSuspended())	284	if (isSuspended())
278	return;	285	return;
Lines 284-290 inline void DeferredWrapper::resolve(std::nullptr_t) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec13
284	}	291	}
285		292
286	template<>	293	template<>
287	inline void DeferredWrapper::reject(std::nullptr_t)	294	inline void DOMDeferredPromise::reject(std::nullptr_t)
288	{	295	{
289	if (isSuspended())	296	if (isSuspended())
290	return;	297	return;
Lines 296-302 inline void DeferredWrapper::reject(std::nullptr_t) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec14
296	}	303	}
297		304
298	template<>	305	template<>
299	inline void DeferredWrapper::resolve(const String& result)	306	inline void DOMDeferredPromise::resolve(const String& result)
300	{	307	{
301	if (isSuspended())	308	if (isSuspended())
302	return;	309	return;
Lines 308-314 inline void DeferredWrapper::resolve(const String& result) a/Source/WebCore/bindings/js/JSDOMPromise.h_sec15
308	}	315	}
309		316
310	template<>	317	template<>
311	inline void DeferredWrapper::reject(const String& result)	318	inline void DOMDeferredPromise::reject(const String& result)
312	{	319	{
313	if (isSuspended())	320	if (isSuspended())
314	return;	321	return;

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 / +3 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	ASSERT(globalObject());
		43	auto promise = DOMDeferredPromise::create(state, *globalObject());
43	m_loaded.set(state.vm(), this, promise->promise());	44	m_loaded.set(state.vm(), this, promise->promise());
44	wrapped().registerLoaded(WTFMove(promise));	45	wrapped().registerLoaded(WTFMove(promise));
45	} else	46	} else
46	m_loaded.set(state.vm(), this, wrapped().promise().value().deferredWrapper().promise());	47	m_loaded.set(state.vm(), this, wrapped().promise().value().deferredPromise().promise());
47	}	48	}
48	return m_loaded.get();	49	return m_loaded.get();
49	}	50	}

Lines 34-40 namespace WebCore { a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp -1 / +2 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	ASSERT(globalObject());
		38	auto promise = DOMDeferredPromise::create(state, *globalObject());
38	m_ready.set(state.vm(), this, promise->promise());	39	m_ready.set(state.vm(), this, promise->promise());
39	wrapped().registerReady(WTFMove(promise));	40	wrapped().registerReady(WTFMove(promise));
40	}	41	}

Lines 173-181 JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec1
- a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp -31 / +40 lines
173	if (!success)	173	if (!success)
174	return jsUndefined();	174	return jsUndefined();
175		175
176		176	ASSERT(globalObject());
177	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	177	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
178	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	178	auto promise = wrapper->promise();
179	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	179	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
180	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	180	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
181	};	181	};
Lines 190-196 JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec2
190	return jsUndefined();	190	return jsUndefined();
191	}	191	}
192		192
193	return promiseDeferred->promise();	193	return promise;
194	}	194	}
195		195
196	JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)	196	JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)
Lines 227-234 JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec3
227	if (!success)	227	if (!success)
228	return jsUndefined();	228	return jsUndefined();
229		229
230	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	230	ASSERT(globalObject());
231	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	231	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		232	auto promise = wrapper->promise();
232	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	233	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
233	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	234	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
234	};	235	};
Lines 243-249 JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec4
243	return jsUndefined();	244	return jsUndefined();
244	}	245	}
245		246
246	return promiseDeferred->promise();	247	return promise;
247	}	248	}
248		249
249	JSValue JSWebKitSubtleCrypto::sign(ExecState& state)	250	JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
Lines 280-287 JSValue JSWebKitSubtleCrypto::sign(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec5
280	if (!success)	281	if (!success)
281	return jsUndefined();	282	return jsUndefined();
282		283
283	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	284	ASSERT(globalObject());
284	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	285	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		286	auto promise = wrapper->promise();
285	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	287	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
286	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	288	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
287	};	289	};
Lines 296-302 JSValue JSWebKitSubtleCrypto::sign(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec6
296	return jsUndefined();	298	return jsUndefined();
297	}	299	}
298		300
299	return promiseDeferred->promise();	301	return promise;
300	}	302	}
301		303
302	JSValue JSWebKitSubtleCrypto::verify(ExecState& state)	304	JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
Lines 339-346 JSValue JSWebKitSubtleCrypto::verify(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec7
339	if (!success)	341	if (!success)
340	return jsUndefined();	342	return jsUndefined();
341		343
342	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	344	ASSERT(globalObject());
343	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	345	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		346	auto promise = wrapper->promise();
344	auto successCallback = [wrapper](bool result) mutable {	347	auto successCallback = [wrapper](bool result) mutable {
345	wrapper->resolve(result);	348	wrapper->resolve(result);
346	};	349	};
Lines 355-361 JSValue JSWebKitSubtleCrypto::verify(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec8
355	return jsUndefined();	358	return jsUndefined();
356	}	359	}
357		360
358	return promiseDeferred->promise();	361	return promise;
359	}	362	}
360		363
361	JSValue JSWebKitSubtleCrypto::digest(ExecState& state)	364	JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
Lines 382-389 JSValue JSWebKitSubtleCrypto::digest(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec9
382	if (!success)	385	if (!success)
383	return jsUndefined();	386	return jsUndefined();
384		387
385	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	388	ASSERT(globalObject());
386	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	389	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		390	auto promise = wrapper->promise();
387	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	391	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
388	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	392	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
389	};	393	};
Lines 398-404 JSValue JSWebKitSubtleCrypto::digest(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec10
398	return jsUndefined();	402	return jsUndefined();
399	}	403	}
400		404
401	return promiseDeferred->promise();	405	return promise;
402	}	406	}
403		407
404	JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)	408	JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)
Lines 434-441 JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec11
434	return jsUndefined();	438	return jsUndefined();
435	}	439	}
436		440
437	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	441	ASSERT(globalObject());
438	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	442	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		443	auto promise = wrapper->promise();
439	auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {	444	auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
440	ASSERT(key \|\| keyPair);	445	ASSERT(key \|\| keyPair);
441	ASSERT(!key \|\| !keyPair);	446	ASSERT(!key \|\| !keyPair);
Lines 455-461 JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec12
455	return jsUndefined();	460	return jsUndefined();
456	}	461	}
457		462
458	return promiseDeferred->promise();	463	return promise;
459	}	464	}
460		465
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)	466	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();	575	return jsUndefined();
571	}	576	}
572		577
573	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	578	ASSERT(globalObject());
574	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	579	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		580	auto promise = wrapper->promise();
575	auto successCallback = [wrapper](CryptoKey& result) mutable {	581	auto successCallback = [wrapper](CryptoKey& result) mutable {
576	wrapper->resolve(result);	582	wrapper->resolve(result);
577	};	583	};
Lines 583-589 JSValue JSWebKitSubtleCrypto::importKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec14
583	if (UNLIKELY(scope.exception()))	589	if (UNLIKELY(scope.exception()))
584	return jsUndefined();	590	return jsUndefined();
585		591
586	return promiseDeferred->promise();	592	return promise;
587	}	593	}
588		594
589	static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback)	595	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)	645	if (!key)
640	return throwTypeError(&state, scope);	646	return throwTypeError(&state, scope);
641		647
642	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	648	ASSERT(globalObject());
643	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	649	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		650	auto promise = wrapper->promise();
644	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {	651	auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
645	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());	652	fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
646	};	653	};
Lines 652-658 JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec16
652	if (UNLIKELY(scope.exception()))	659	if (UNLIKELY(scope.exception()))
653	return jsUndefined();	660	return jsUndefined();
654		661
655	return promiseDeferred->promise();	662	return promise;
656	}	663	}
657		664
658	JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)	665	JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
Lines 693-700 JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec17
693	if (!parameters)	700	if (!parameters)
694	return jsUndefined();	701	return jsUndefined();
695		702
696	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	703	ASSERT(globalObject());
697	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	704	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		705	auto promise = wrapper->promise();
698		706
699	auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {	707	auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {
700	auto encryptSuccessCallback = [wrapper](const Vector<uint8_t>& encryptedData) mutable {	708	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();	730	return jsUndefined();
723	}	731	}
724		732
725	return promiseDeferred->promise();	733	return promise;
726	}	734	}
727		735
728	JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)	736	JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)
Lines 793-800 JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state) a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp_sec19
793	return jsUndefined();	801	return jsUndefined();
794	}	802	}
795		803
796	JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());	804	ASSERT(globalObject());
797	RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);	805	RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
		806	auto promise = wrapper->promise();
798	Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());	807	Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());
799		808
800	auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithm, unwrappedKeyAlgorithmParameters, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {	809	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();	837	return jsUndefined();
829	}	838	}
830		839
831	return promiseDeferred->promise();	840	return promise;
832	}	841	}
833		842
834	} // namespace WebCore	843	} // namespace WebCore

Lines 3409-3421 sub GenerateImplementation a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec1
- a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm -3 / +3 lines
3409	AddToImplIncludes("JSDOMPromise.h");	3409	AddToImplIncludes("JSDOMPromise.h");
3410		3410
3411	push(@implContent, <<END);	3411	push(@implContent, <<END);
3412	static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DeferredWrapper>&&);	3412	static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DOMDeferredPromise>&&);
3413	${functionReturn} ${functionName}(ExecState* state)	3413	${functionReturn} ${functionName}(ExecState* state)
3414	{	3414	{
3415	return JSValue::encode(callPromiseFunction(*state, ${functionName}Promise));	3415	return JSValue::encode(callPromiseFunction(*state, ${functionName}Promise));
3416	}	3416	}
3417		3417
3418	static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	3418	static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
3419	END	3419	END
3420	}	3420	}
3421	else {	3421	else {
Lines 4122-4128 sub GenerateReturnParameters a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm_sec2
4122	my @arguments;	4122	my @arguments;
4123		4123
4124	if (IsReturningPromise($function)) {	4124	if (IsReturningPromise($function)) {
4125	push(@arguments, "WTFMove(deferredWrapper)");	4125	push(@arguments, "WTFMove(deferredPromise)");
4126	}	4126	}
4127	push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} \|\| $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};	4127	push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} \|\| $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};
4128	return @arguments;	4128	return @arguments;

Lines 7157-7169 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
7157	return JSValue::encode(jsUndefined());	7157	return JSValue::encode(jsUndefined());
7158	}	7158	}
7159		7159
7160	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);	7160	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7161	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)	7161	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)
7162	{	7162	{
7163	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionPromise));	7163	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionPromise));
7164	}	7164	}
7165		7165
7166	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7166	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7167	{	7167	{
7168	VM& vm = state->vm();	7168	VM& vm = state->vm();
7169	auto throwScope = DECLARE_THROW_SCOPE(vm);	7169	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7174-7190 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromis a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec2
7174	return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");	7174	return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");
7175	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());	7175	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
7176	auto& impl = castedThis->wrapped();	7176	auto& impl = castedThis->wrapped();
7177	impl.testPromiseFunction(WTFMove(deferredWrapper));	7177	impl.testPromiseFunction(WTFMove(deferredPromise));
7178	return JSValue::encode(jsUndefined());	7178	return JSValue::encode(jsUndefined());
7179	}	7179	}
7180		7180
7181	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);	7181	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7182	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)	7182	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)
7183	{	7183	{
7184	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise));	7184	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise));
7185	}	7185	}
7186		7186
7187	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7187	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7188	{	7188	{
7189	VM& vm = state->vm();	7189	VM& vm = state->vm();
7190	auto throwScope = DECLARE_THROW_SCOPE(vm);	7190	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7200-7216 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFl a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec3
7200	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);	7200	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
7201	if (UNLIKELY(throwScope.exception()))	7201	if (UNLIKELY(throwScope.exception()))
7202	return JSValue::encode(jsUndefined());	7202	return JSValue::encode(jsUndefined());
7203	impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredWrapper));	7203	impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredPromise));
7204	return JSValue::encode(jsUndefined());	7204	return JSValue::encode(jsUndefined());
7205	}	7205	}
7206		7206
7207	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);	7207	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7208	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)	7208	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)
7209	{	7209	{
7210	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise));	7210	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise));
7211	}	7211	}
7212		7212
7213	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7213	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7214	{	7214	{
7215	VM& vm = state->vm();	7215	VM& vm = state->vm();
7216	auto throwScope = DECLARE_THROW_SCOPE(vm);	7216	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7222-7239 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithEx a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec4
7222	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());	7222	ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
7223	auto& impl = castedThis->wrapped();	7223	auto& impl = castedThis->wrapped();
7224	ExceptionCode ec = 0;	7224	ExceptionCode ec = 0;
7225	impl.testPromiseFunctionWithException(WTFMove(deferredWrapper), ec);	7225	impl.testPromiseFunctionWithException(WTFMove(deferredPromise), ec);
7226	setDOMException(state, ec);	7226	setDOMException(state, ec);
7227	return JSValue::encode(jsUndefined());	7227	return JSValue::encode(jsUndefined());
7228	}	7228	}
7229		7229
7230	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);	7230	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7231	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)	7231	EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)
7232	{	7232	{
7233	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise));	7233	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise));
7234	}	7234	}
7235		7235
7236	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7236	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7237	{	7237	{
7238	VM& vm = state->vm();	7238	VM& vm = state->vm();
7239	auto throwScope = DECLARE_THROW_SCOPE(vm);	7239	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7247-7263 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOp a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec5
7247	auto a = state->argument(0).isUndefined() ? Optional<int32_t>() : convert<int32_t>(*state, state->uncheckedArgument(0), NormalConversion);	7247	auto a = state->argument(0).isUndefined() ? Optional<int32_t>() : convert<int32_t>(*state, state->uncheckedArgument(0), NormalConversion);
7248	if (UNLIKELY(throwScope.exception()))	7248	if (UNLIKELY(throwScope.exception()))
7249	return JSValue::encode(jsUndefined());	7249	return JSValue::encode(jsUndefined());
7250	impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(deferredWrapper));	7250	impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(deferredPromise));
7251	return JSValue::encode(jsUndefined());	7251	return JSValue::encode(jsUndefined());
7252	}	7252	}
7253		7253
7254	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DeferredWrapper>&&);	7254	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DOMDeferredPromise>&&);
7255	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)	7255	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)
7256	{	7256	{
7257	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise));	7257	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise));
7258	}	7258	}
7259		7259
7260	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7260	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7261	{	7261	{
7262	VM& vm = state->vm();	7262	VM& vm = state->vm();
7263	auto throwScope = DECLARE_THROW_SCOPE(vm);	7263	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7273-7289 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec6
7273	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);	7273	auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
7274	if (UNLIKELY(throwScope.exception()))	7274	if (UNLIKELY(throwScope.exception()))
7275	return JSValue::encode(jsUndefined());	7275	return JSValue::encode(jsUndefined());
7276	impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredWrapper));	7276	impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredPromise));
7277	return JSValue::encode(jsUndefined());	7277	return JSValue::encode(jsUndefined());
7278	}	7278	}
7279		7279
7280	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DeferredWrapper>&&);	7280	static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DOMDeferredPromise>&&);
7281	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)	7281	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)
7282	{	7282	{
7283	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise));	7283	return JSValue::encode(callPromiseFunction(*state, jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise));
7284	}	7284	}
7285		7285
7286	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7286	static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7287	{	7287	{
7288	VM& vm = state->vm();	7288	VM& vm = state->vm();
7289	auto throwScope = DECLARE_THROW_SCOPE(vm);	7289	auto throwScope = DECLARE_THROW_SCOPE(vm);
Lines 7299-7305 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec7
7299	auto request = JSFetchRequest::toWrapped(state->argument(0));	7299	auto request = JSFetchRequest::toWrapped(state->argument(0));
7300	if (UNLIKELY(!request))	7300	if (UNLIKELY(!request))
7301	return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");	7301	return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");
7302	impl.testPromiseOverloadedFunction(*request, WTFMove(deferredWrapper));	7302	impl.testPromiseOverloadedFunction(*request, WTFMove(deferredPromise));
7303	return JSValue::encode(jsUndefined());	7303	return JSValue::encode(jsUndefined());
7304	}	7304	}
7305		7305
Lines 7320-7353 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunc a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp_sec8
7320	return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);	7320	return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);
7321	}	7321	}
7322		7322
7323	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);	7323	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7324	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)	7324	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)
7325	{	7325	{
7326	return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise));	7326	return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise));
7327	}	7327	}
7328		7328
7329	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7329	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7330	{	7330	{
7331	VM& vm = state->vm();	7331	VM& vm = state->vm();
7332	auto throwScope = DECLARE_THROW_SCOPE(vm);	7332	auto throwScope = DECLARE_THROW_SCOPE(vm);
7333	UNUSED_PARAM(throwScope);	7333	UNUSED_PARAM(throwScope);
7334	TestObj::testStaticPromiseFunction(WTFMove(deferredWrapper));	7334	TestObj::testStaticPromiseFunction(WTFMove(deferredPromise));
7335	return JSValue::encode(jsUndefined());	7335	return JSValue::encode(jsUndefined());
7336	}	7336	}
7337		7337
7338	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);	7338	static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DOMDeferredPromise>&&);
7339	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)	7339	EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)
7340	{	7340	{
7341	return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise));	7341	return JSValue::encode(callPromiseFunction(*state, jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise));
7342	}	7342	}
7343		7343
7344	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)	7344	static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DOMDeferredPromise>&& deferredPromise)
7345	{	7345	{
7346	VM& vm = state->vm();	7346	VM& vm = state->vm();
7347	auto throwScope = DECLARE_THROW_SCOPE(vm);	7347	auto throwScope = DECLARE_THROW_SCOPE(vm);
7348	UNUSED_PARAM(throwScope);	7348	UNUSED_PARAM(throwScope);
7349	ExceptionCode ec = 0;	7349	ExceptionCode ec = 0;
7350	TestObj::testStaticPromiseFunctionWithException(WTFMove(deferredWrapper), ec);	7350	TestObj::testStaticPromiseFunctionWithException(WTFMove(deferredPromise), ec);
7351	setDOMException(state, ec);	7351	setDOMException(state, ec);
7352	return JSValue::encode(jsUndefined());	7352	return JSValue::encode(jsUndefined());
7353	}	7353	}

Lines 44-50 namespace WebCore { a/Source/WebCore/dom/CustomElementRegistry.h_sec1
- a/Source/WebCore/dom/CustomElementRegistry.h -3 / +3 lines
44		44
45	class CustomElementRegistry;	45	class CustomElementRegistry;
46	class DOMWindow;	46	class DOMWindow;
47	class DeferredWrapper;	47	class DOMDeferredPromise;
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_sec2
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, Ref<DOMDeferredPromise>>& 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_sec3
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, Ref<DOMDeferredPromise>> m_promiseMap;
78		78
79	bool m_elementDefinitionIsRunning { false };	79	bool m_elementDefinitionIsRunning { false };
80		80