Changeset 206252 in webkit


Ignore:
Timestamp:
Sep 22, 2016 12:35:46 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

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

Patch by Youenn Fablet <youenn@apple.com> on 2016-09-22
Reviewed by Darin Adler.

No change of behavior.

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

  • Modules/applepay/ApplePaySession.cpp:

(WebCore::ApplePaySession::canMakePaymentsWithActiveCard):

  • Modules/applepay/ApplePaySession.h:
  • Modules/fetch/DOMWindowFetch.cpp:

(WebCore::DOMWindowFetch::fetch):

  • Modules/fetch/DOMWindowFetch.h: Updated to take a DeferredPromise to make it consistent with WorkerGlobalScopeFetch.
  • Modules/fetch/FetchBody.cpp:

(WebCore::FetchBody::arrayBuffer):
(WebCore::FetchBody::blob):
(WebCore::FetchBody::json):
(WebCore::FetchBody::text):
(WebCore::FetchBody::consume):
(WebCore::FetchBody::consumeArrayBuffer):
(WebCore::FetchBody::consumeArrayBufferView):
(WebCore::FetchBody::consumeText):
(WebCore::FetchBody::consumeBlob):

  • Modules/fetch/FetchBody.h:

(WebCore::FetchBody::formData):

  • Modules/fetch/FetchBodyConsumer.cpp:

(WebCore::FetchBodyConsumer::resolveWithData):
(WebCore::FetchBodyConsumer::resolve):

  • Modules/fetch/FetchBodyConsumer.h:
  • Modules/fetch/FetchBodyOwner.cpp:

(WebCore::FetchBodyOwner::arrayBuffer):
(WebCore::FetchBodyOwner::blob):
(WebCore::FetchBodyOwner::formData):
(WebCore::FetchBodyOwner::json):
(WebCore::FetchBodyOwner::text):

  • Modules/fetch/FetchBodyOwner.h:
  • Modules/fetch/FetchResponse.cpp:

(WebCore::FetchResponse::consume):
(WebCore::FetchResponse::finishConsumingStream):

  • Modules/fetch/FetchResponse.h:
  • Modules/fetch/WorkerGlobalScopeFetch.cpp:

(WebCore::WorkerGlobalScopeFetch::fetch):

  • Modules/fetch/WorkerGlobalScopeFetch.h:
  • bindings/js/JSCustomElementRegistryCustom.cpp:

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

  • bindings/js/JSDOMGlobalObject.cpp:

(WebCore::JSDOMGlobalObject::visitChildren):

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

(WebCore::DOMDeferredPromise::DOMDeferredPromise):
(WebCore::DOMDeferredPromise::~DOMDeferredPromise):
(WebCore::DOMDeferredPromise::clear):
(WebCore::DOMDeferredPromise::contextDestroyed):
(WebCore::DOMDeferredPromise::promise):
(WebCore::DOMDeferredPromise::callFunction):
(WebCore::DOMDeferredPromise::reject):
(WebCore::rejectPromiseWithExceptionIfAny):
(WebCore::fulfillPromiseWithJSON):
(WebCore::fulfillPromiseWithArrayBuffer):
(WebCore::DeferredWrapper::DeferredWrapper): Deleted.
(WebCore::DeferredWrapper::~DeferredWrapper): Deleted.
(WebCore::DeferredWrapper::clear): Deleted.
(WebCore::DeferredWrapper::contextDestroyed): Deleted.
(WebCore::DeferredWrapper::promise): Deleted.
(WebCore::DeferredWrapper::callFunction): Deleted.
(WebCore::DeferredWrapper::reject): Deleted.

  • bindings/js/JSDOMPromise.h:

(WebCore::DOMDeferredPromise::create):
(WebCore::callPromiseFunction):
(WebCore::DOMPromise::DOMPromise):
(WebCore::DOMPromise::deferredPromise):
(WebCore::DOMDeferredPromise::resolveWithValue):
(WebCore::DOMDeferredPromise::resolveWithNewlyCreated):
(WebCore::DOMDeferredPromise::rejectWithValue):
(WebCore::DOMDeferredPromise::resolve):
(WebCore::DOMDeferredPromise::reject):
(WebCore::DeferredWrapper::create): Deleted.
(WebCore::DOMPromise::deferredWrapper): Deleted.
(WebCore::DeferredWrapper::resolveWithValue): Deleted.
(WebCore::DeferredWrapper::resolveWithNewlyCreated): Deleted.
(WebCore::DeferredWrapper::rejectWithValue): Deleted.
(WebCore::DeferredWrapper::resolve): Deleted.
(WebCore::DeferredWrapper::reject): Deleted.

  • bindings/js/JSDOMWrapper.cpp: Introducing domWindow() accessor.
  • bindings/js/JSDOMWrapper.h:
  • bindings/js/JSFontFaceCustom.cpp:

(WebCore::JSFontFace::loaded):

  • bindings/js/JSFontFaceSetCustom.cpp:

(WebCore::JSFontFaceSet::ready):

  • bindings/js/JSMediaDevicesCustom.cpp:

(WebCore::JSMediaDevices::getUserMedia):

  • bindings/js/JSMediaStreamTrackCustom.cpp:

(WebCore::JSMediaStreamTrack::applyConstraints):

  • bindings/js/JSReadableStreamSourceCustom.cpp:

(WebCore::JSReadableStreamSource::start):

  • bindings/js/JSWebKitSubtleCryptoCustom.cpp:

(WebCore::JSWebKitSubtleCrypto::encrypt):
(WebCore::JSWebKitSubtleCrypto::decrypt):
(WebCore::JSWebKitSubtleCrypto::sign):
(WebCore::JSWebKitSubtleCrypto::verify):
(WebCore::JSWebKitSubtleCrypto::digest):
(WebCore::JSWebKitSubtleCrypto::generateKey):
(WebCore::JSWebKitSubtleCrypto::importKey):
(WebCore::JSWebKitSubtleCrypto::exportKey):
(WebCore::JSWebKitSubtleCrypto::wrapKey):
(WebCore::JSWebKitSubtleCrypto::unwrapKey):

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateImplementation):
(GenerateReturnParameters):

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

(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionPromise):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise):
(WebCore::jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise):
(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise):
(WebCore::jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise):
(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise):
(WebCore::jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise):

  • dom/CustomElementRegistry.h:

(WebCore::CustomElementRegistry::promiseMap):

Location:
trunk/Source/WebCore
Files:
34 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

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

    r206241 r206252  
    734734}
    735735
    736 void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredWrapper>&& passedPromise, ExceptionCode& ec)
     736void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredPromise>&& passedPromise, ExceptionCode& ec)
    737737{
    738738    auto& document = downcast<Document>(scriptExecutionContext);
     
    746746    }
    747747
    748     RefPtr<DeferredWrapper> promise(WTFMove(passedPromise));
     748    RefPtr<DeferredPromise> promise(WTFMove(passedPromise));
    749749    if (!shouldDiscloseApplePayCapability(document)) {
    750750        auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();
     
    764764}
    765765
    766 void ApplePaySession::openPaymentSetup(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredWrapper>&& passedPromise, ExceptionCode& ec)
     766void ApplePaySession::openPaymentSetup(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredPromise>&& passedPromise, ExceptionCode& ec)
    767767{
    768768    auto& document = downcast<Document>(scriptExecutionContext);
     
    782782    }
    783783
    784     RefPtr<DeferredWrapper> promise(WTFMove(passedPromise));
     784    RefPtr<DeferredPromise> promise(WTFMove(passedPromise));
    785785    auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();
    786786
  • trunk/Source/WebCore/Modules/applepay/ApplePaySession.h

    r206238 r206252  
    3838
    3939class ArrayValue;
    40 class DeferredWrapper;
     40class DeferredPromise;
    4141class Dictionary;
    4242class Document;
     
    6464    static bool supportsVersion(ScriptExecutionContext&, unsigned version, ExceptionCode&);
    6565    static bool canMakePayments(ScriptExecutionContext&, ExceptionCode&);
    66     static void canMakePaymentsWithActiveCard(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DeferredWrapper>&&, ExceptionCode&);
    67     static void openPaymentSetup(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DeferredWrapper>&&, ExceptionCode&);
     66    static void canMakePaymentsWithActiveCard(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DeferredPromise>&&, ExceptionCode&);
     67    static void openPaymentSetup(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DeferredPromise>&&, ExceptionCode&);
    6868
    6969    void begin(ExceptionCode&);
  • trunk/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp

    r205257 r206252  
    3838namespace WebCore {
    3939
    40 void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, DOMPromise<FetchResponse>&& promise)
     40void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, Ref<DeferredPromise>&& promise)
    4141{
    4242    if (!window.scriptExecutionContext())
  • trunk/Source/WebCore/Modules/fetch/DOMWindowFetch.h

    r205257 r206252  
    3737
    3838class DOMWindow;
    39 class DeferredWrapper;
    4039class Dictionary;
    4140class FetchRequest;
    42 class FetchResponse;
    4341
    4442class DOMWindowFetch {
    4543public:
    46     static void fetch(DOMWindow&, FetchRequest&, DOMPromise<FetchResponse>&&);
     44    static void fetch(DOMWindow&, FetchRequest&, Ref<DeferredPromise>&&);
    4745};
    4846
  • trunk/Source/WebCore/Modules/fetch/FetchBody.cpp

    r205549 r206252  
    125125}
    126126
    127 void FetchBody::arrayBuffer(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     127void FetchBody::arrayBuffer(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    128128{
    129129    ASSERT(m_type != Type::None);
     
    132132}
    133133
    134 void FetchBody::blob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     134void FetchBody::blob(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    135135{
    136136    ASSERT(m_type != Type::None);
     
    140140}
    141141
    142 void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     142void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    143143{
    144144    ASSERT(m_type != Type::None);
     
    152152}
    153153
    154 void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     154void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    155155{
    156156    ASSERT(m_type != Type::None);
     
    164164}
    165165
    166 void FetchBody::consume(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     166void FetchBody::consume(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    167167{
    168168    // This should be handled by FetchBodyOwner
     
    247247#endif
    248248
    249 void FetchBody::consumeArrayBuffer(Ref<DeferredWrapper>&& promise)
     249void FetchBody::consumeArrayBuffer(Ref<DeferredPromise>&& promise)
    250250{
    251251    ASSERT(m_data);
     
    254254}
    255255
    256 void FetchBody::consumeArrayBufferView(Ref<DeferredWrapper>&& promise)
     256void FetchBody::consumeArrayBufferView(Ref<DeferredPromise>&& promise)
    257257{
    258258    ASSERT(m_dataView);
     
    261261}
    262262
    263 void FetchBody::consumeText(Ref<DeferredWrapper>&& promise)
     263void FetchBody::consumeText(Ref<DeferredPromise>&& promise)
    264264{
    265265    Vector<uint8_t> data = extractFromText();
     
    268268}
    269269
    270 void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
     270void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DeferredPromise>&& promise)
    271271{
    272272    ASSERT(m_blob);
  • trunk/Source/WebCore/Modules/fetch/FetchBody.h

    r205549 r206252  
    5353class FetchBody {
    5454public:
    55     void arrayBuffer(FetchBodyOwner&, Ref<DeferredWrapper>&&);
    56     void blob(FetchBodyOwner&, Ref<DeferredWrapper>&&);
    57     void json(FetchBodyOwner&, Ref<DeferredWrapper>&&);
    58     void text(FetchBodyOwner&, Ref<DeferredWrapper>&&);
    59     void formData(FetchBodyOwner&, Ref<DeferredWrapper>&& promise) { promise.get().reject(0); }
     55    void arrayBuffer(FetchBodyOwner&, Ref<DeferredPromise>&&);
     56    void blob(FetchBodyOwner&, Ref<DeferredPromise>&&);
     57    void json(FetchBodyOwner&, Ref<DeferredPromise>&&);
     58    void text(FetchBodyOwner&, Ref<DeferredPromise>&&);
     59    void formData(FetchBodyOwner&, Ref<DeferredPromise>&& promise) { promise.get().reject(0); }
    6060
    6161#if ENABLE(READABLE_STREAM_API)
     
    9494    FetchBody(Type type) : m_type(type) { }
    9595
    96     void consume(FetchBodyOwner&, Ref<DeferredWrapper>&&);
     96    void consume(FetchBodyOwner&, Ref<DeferredPromise>&&);
    9797
    9898    Vector<uint8_t> extractFromText() const;
    99     void consumeArrayBuffer(Ref<DeferredWrapper>&&);
    100     void consumeArrayBufferView(Ref<DeferredWrapper>&&);
    101     void consumeText(Ref<DeferredWrapper>&&);
    102     void consumeBlob(FetchBodyOwner&, Ref<DeferredWrapper>&&);
     99    void consumeArrayBuffer(Ref<DeferredPromise>&&);
     100    void consumeArrayBufferView(Ref<DeferredPromise>&&);
     101    void consumeText(Ref<DeferredPromise>&&);
     102    void consumeBlob(FetchBodyOwner&, Ref<DeferredPromise>&&);
    103103
    104104    Type m_type { Type::None };
     
    113113
    114114    FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };
    115     RefPtr<DeferredWrapper> m_consumePromise;
     115    RefPtr<DeferredPromise> m_consumePromise;
    116116};
    117117
  • trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp

    r205257 r206252  
    6060}
    6161
    62 void FetchBodyConsumer::resolveWithData(Ref<DeferredWrapper>&& promise, const unsigned char* data, unsigned length)
     62void FetchBodyConsumer::resolveWithData(Ref<DeferredPromise>&& promise, const unsigned char* data, unsigned length)
    6363{
    6464    switch (m_type) {
     
    8181}
    8282
    83 void FetchBodyConsumer::resolve(Ref<DeferredWrapper>&& promise)
     83void FetchBodyConsumer::resolve(Ref<DeferredPromise>&& promise)
    8484{
    8585    ASSERT(m_type != Type::None);
  • trunk/Source/WebCore/Modules/fetch/FetchBodyConsumer.h

    r205257 r206252  
    3131#if ENABLE(FETCH_API)
    3232
     33#include "JSDOMPromise.h"
    3334#include "SharedBuffer.h"
    3435
     
    3637
    3738class Blob;
    38 class DeferredWrapper;
    3939
    4040class FetchBodyConsumer {
     
    5858    void clean() { m_buffer = nullptr; }
    5959
    60     void resolve(Ref<DeferredWrapper>&&);
    61     void resolveWithData(Ref<DeferredWrapper>&&, const unsigned char*, unsigned);
     60    void resolve(Ref<DeferredPromise>&&);
     61    void resolveWithData(Ref<DeferredPromise>&&, const unsigned char*, unsigned);
    6262
    6363    bool hasData() const { return !!m_buffer; }
  • trunk/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp

    r205549 r206252  
    7272}
    7373
    74 void FetchBodyOwner::arrayBuffer(Ref<DeferredWrapper>&& promise)
     74void FetchBodyOwner::arrayBuffer(Ref<DeferredPromise>&& promise)
    7575{
    7676    if (m_body.isEmpty()) {
     
    8686}
    8787
    88 void FetchBodyOwner::blob(Ref<DeferredWrapper>&& promise)
     88void FetchBodyOwner::blob(Ref<DeferredPromise>&& promise)
    8989{
    9090    if (m_body.isEmpty()) {
     
    100100}
    101101
    102 void FetchBodyOwner::formData(Ref<DeferredWrapper>&& promise)
     102void FetchBodyOwner::formData(Ref<DeferredPromise>&& promise)
    103103{
    104104    if (m_body.isEmpty()) {
     
    114114}
    115115
    116 void FetchBodyOwner::json(Ref<DeferredWrapper>&& promise)
     116void FetchBodyOwner::json(Ref<DeferredPromise>&& promise)
    117117{
    118118    if (m_body.isEmpty()) {
     
    128128}
    129129
    130 void FetchBodyOwner::text(Ref<DeferredWrapper>&& promise)
     130void FetchBodyOwner::text(Ref<DeferredPromise>&& promise)
    131131{
    132132    if (m_body.isEmpty()) {
  • trunk/Source/WebCore/Modules/fetch/FetchBodyOwner.h

    r205549 r206252  
    4747    bool isDisturbed() const { return m_isDisturbed; };
    4848
    49     void arrayBuffer(Ref<DeferredWrapper>&&);
    50     void blob(Ref<DeferredWrapper>&&);
    51     void formData(Ref<DeferredWrapper>&&);
    52     void json(Ref<DeferredWrapper>&&);
    53     void text(Ref<DeferredWrapper>&&);
     49    void arrayBuffer(Ref<DeferredPromise>&&);
     50    void blob(Ref<DeferredPromise>&&);
     51    void formData(Ref<DeferredPromise>&&);
     52    void json(Ref<DeferredPromise>&&);
     53    void text(Ref<DeferredPromise>&&);
    5454
    5555    bool isDisturbedOrLocked() const;
  • trunk/Source/WebCore/Modules/fetch/FetchResponse.cpp

    r205549 r206252  
    207207}
    208208
    209 void FetchResponse::consume(unsigned type, Ref<DeferredWrapper>&& wrapper)
     209void FetchResponse::consume(unsigned type, Ref<DeferredPromise>&& wrapper)
    210210{
    211211    ASSERT(type <= static_cast<unsigned>(FetchBodyConsumer::Type::Text));
     
    242242}
    243243
    244 void FetchResponse::finishConsumingStream(Ref<DeferredWrapper>&& promise)
     244void FetchResponse::finishConsumingStream(Ref<DeferredPromise>&& promise)
    245245{
    246246    m_consumer.resolve(WTFMove(promise));
  • trunk/Source/WebCore/Modules/fetch/FetchResponse.h

    r205549 r206252  
    6161    static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);
    6262
    63     void consume(unsigned, Ref<DeferredWrapper>&&);
     63    void consume(unsigned, Ref<DeferredPromise>&&);
    6464#if ENABLE(READABLE_STREAM_API)
    6565    void startConsumingStream(unsigned);
    6666    void consumeChunk(Ref<JSC::Uint8Array>&&);
    67     void finishConsumingStream(Ref<DeferredWrapper>&&);
     67    void finishConsumingStream(Ref<DeferredPromise>&&);
    6868#endif
    6969
  • trunk/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp

    r205257 r206252  
    3737namespace WebCore {
    3838
    39 void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, Ref<DeferredWrapper>&& promise)
     39void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, Ref<DeferredPromise>&& promise)
    4040{
    4141    if (!scope.scriptExecutionContext())
  • trunk/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.h

    r205257 r206252  
    3232
    3333#include "JSDOMPromise.h"
    34 #include <wtf/Forward.h>
    3534
    3635namespace WebCore {
    3736
     37class FetchRequest;
    3838class WorkerGlobalScope;
    39 class DeferredWrapper;
    40 class FetchRequest;
    4139
    4240class WorkerGlobalScopeFetch {
    4341public:
    44     static void fetch(WorkerGlobalScope&, FetchRequest&, Ref<DeferredWrapper>&&);
     42    static void fetch(WorkerGlobalScope&, FetchRequest&, Ref<DeferredPromise>&&);
    4543};
    4644
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r206156 r206252  
    15311531                416E6FE91BBD12E5000A6043 /* ReadableStreamBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D8 /* ReadableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
    15321532                416E6FE91BBD12E5000A6053 /* WritableStreamBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764E8 /* WritableStreamBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1533                4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */; };
    15331534                417253AA1354BBBC00360F2A /* MediaControlElements.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 417253A81354BBBC00360F2A /* MediaControlElements.cpp */; };
    15341535                417253AB1354BBBC00360F2A /* MediaControlElements.h in Headers */ = {isa = PBXBuildFile; fileRef = 417253A91354BBBC00360F2A /* MediaControlElements.h */; };
     
    84578458                4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
    84588459                416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
     8460                4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
    84598461                417253A81354BBBC00360F2A /* MediaControlElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaControlElements.cpp; sourceTree = "<group>"; };
    84608462                417253A91354BBBC00360F2A /* MediaControlElements.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaControlElements.h; sourceTree = "<group>"; };
     
    2104621048                                BCBFB53A0DCD29CF0019B3E5 /* JSDOMWindowShell.cpp */,
    2104721049                                BCBFB53B0DCD29CF0019B3E5 /* JSDOMWindowShell.h */,
     21050                                4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */,
    2104821051                                65E0E9431133C89F00B4CB10 /* JSDOMWrapper.h */,
    2104921052                                F3D461461161D53200CA0D09 /* JSErrorHandler.cpp */,
     
    2947329476                                BCF34A3711A231CD00C71804 /* NamedNodeMap.cpp in Sources */,
    2947429477                                A81872240977D3C0005826D9 /* NameNodeList.cpp in Sources */,
     29478                                4170A2EA1D8C0CCA00318452 /* JSDOMWrapper.cpp in Sources */,
    2947529479                                8306EFF11B8BCEA50031D032 /* NativeNodeFilter.cpp in Sources */,
    2947629480                                E10B9B6D0B747599003ED890 /* NativeXPathNSResolver.cpp in Sources */,
  • trunk/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp

    r205569 r206252  
    163163
    164164// https://html.spec.whatwg.org/#dom-customelementregistry-whendefined
    165 static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry)
     165static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObject, CustomElementRegistry& registry, JSPromiseDeferred& promiseDeferred)
    166166{
    167167    auto scope = DECLARE_THROW_SCOPE(state.vm());
     
    174174        return jsUndefined();
    175175
    176     if (!validateCustomElementNameAndThrowIfNeeded(state, localName))
    177         return jsUndefined();
     176    if (!validateCustomElementNameAndThrowIfNeeded(state, localName)) {
     177        ASSERT(scope.exception());
     178        return jsUndefined();
     179    }
    178180
    179181    if (registry.findInterface(localName)) {
    180         auto& jsPromise = *JSPromiseDeferred::create(&state, &globalObject);
    181         DeferredWrapper::create(&state, &globalObject, &jsPromise)->resolve(nullptr);
    182         return jsPromise.promise();
     182        DeferredPromise::create(globalObject, promiseDeferred)->resolve(nullptr);
     183        return promiseDeferred.promise();
    183184    }
    184185
    185186    auto result = registry.promiseMap().ensure(localName, [&] {
    186         return DeferredWrapper::create(&state, &globalObject, JSPromiseDeferred::create(&state, &globalObject));
     187        return DeferredPromise::create(globalObject, promiseDeferred);
    187188    });
    188189
     
    194195    auto scope = DECLARE_CATCH_SCOPE(state.vm());
    195196
    196     JSDOMGlobalObject& globalObject = *jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject());
    197     auto& promiseDeferred = *JSPromiseDeferred::create(&state, &globalObject);
    198     JSValue promise = whenDefinedPromise(state, globalObject, wrapped());
     197    ASSERT(globalObject());
     198    auto promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
     199    ASSERT(promiseDeferred);
     200    JSValue promise = whenDefinedPromise(state, *globalObject(), wrapped(), *promiseDeferred);
    199201
    200202    if (UNLIKELY(scope.exception())) {
    201         rejectPromiseWithExceptionIfAny(state, globalObject, promiseDeferred);
     203        rejectPromiseWithExceptionIfAny(state, *globalObject(), *promiseDeferred);
    202204        ASSERT(!scope.exception());
    203         return promiseDeferred.promise();
     205        return promiseDeferred->promise();
    204206    }
    205207
  • trunk/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp

    r205569 r206252  
    179179        visitor.append(&constructor);
    180180
    181     for (auto& deferredWrapper : thisObject->deferredWrappers())
    182         deferredWrapper->visitAggregate(visitor);
     181    for (auto& deferredPromise : thisObject->deferredPromises())
     182        deferredPromise->visitAggregate(visitor);
    183183
    184184    thisObject->m_builtinInternalFunctions.visit(visitor);
  • trunk/Source/WebCore/bindings/js/JSDOMGlobalObject.h

    r205257 r206252  
    3535namespace WebCore {
    3636
    37     class DeferredWrapper;
     37    class DeferredPromise;
    3838    class Document;
    3939    class Event;
     
    4343    typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::Structure>> JSDOMStructureMap;
    4444    typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::JSObject>> JSDOMConstructorMap;
    45     typedef HashSet<DeferredWrapper*> DeferredWrapperSet;
     45    typedef HashSet<DeferredPromise*> DeferredPromiseSet;
    4646
    4747    class WEBCORE_EXPORT JSDOMGlobalObject : public JSC::JSGlobalObject {
     
    5959        JSDOMConstructorMap& constructors() { return m_constructors; }
    6060
    61         DeferredWrapperSet& deferredWrappers() { return m_deferredWrappers; }
     61        DeferredPromiseSet& deferredPromises() { return m_deferredPromises; }
    6262
    6363        ScriptExecutionContext* scriptExecutionContext() const;
     
    9292        JSDOMStructureMap m_structures;
    9393        JSDOMConstructorMap m_constructors;
    94         DeferredWrapperSet m_deferredWrappers;
     94        DeferredPromiseSet m_deferredPromises;
    9595
    9696        Event* m_currentEvent;
  • trunk/Source/WebCore/bindings/js/JSDOMPromise.cpp

    r206011 r206252  
    2929#include "ExceptionCode.h"
    3030#include "JSDOMError.h"
     31#include "JSDOMWindow.h"
    3132#include <builtins/BuiltinNames.h>
    3233#include <runtime/Exception.h>
     
    3839namespace WebCore {
    3940
    40 DeferredWrapper::DeferredWrapper(ExecState*, JSDOMGlobalObject* globalObject, JSPromiseDeferred* promiseDeferred)
    41     : ActiveDOMCallback(globalObject->scriptExecutionContext())
    42     , m_deferred(promiseDeferred)
    43     , m_globalObject(globalObject)
     41DeferredPromise::DeferredPromise(JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
     42    : ActiveDOMCallback(globalObject.scriptExecutionContext())
     43    , m_deferred(&promiseDeferred)
     44    , m_globalObject(&globalObject)
    4445{
    45     globalObject->vm().heap.writeBarrier(globalObject, promiseDeferred);
    46     m_globalObject->deferredWrappers().add(this);
     46    globalObject.vm().heap.writeBarrier(&globalObject, &promiseDeferred);
     47    globalObject.deferredPromises().add(this);
    4748}
    4849
    49 DeferredWrapper::~DeferredWrapper()
     50DeferredPromise::~DeferredPromise()
    5051{
    5152    clear();
    5253}
    5354
    54 void DeferredWrapper::clear()
     55void DeferredPromise::clear()
    5556{
    5657    ASSERT(!m_deferred || m_globalObject);
    5758    if (m_deferred && m_globalObject)
    58         m_globalObject->deferredWrappers().remove(this);
     59        m_globalObject->deferredPromises().remove(this);
    5960    m_deferred.clear();
    6061}
    6162
    62 void DeferredWrapper::contextDestroyed()
     63void DeferredPromise::contextDestroyed()
    6364{
    6465    ActiveDOMCallback::contextDestroyed();
     
    6667}
    6768
    68 JSC::JSValue DeferredWrapper::promise() const
     69JSC::JSValue DeferredPromise::promise() const
    6970{
    7071    ASSERT(m_deferred);
     
    7273}
    7374
    74 void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue resolution)
     75void DeferredPromise::callFunction(ExecState& exec, JSValue function, JSValue resolution)
    7576{
    7677    if (!canInvokeCallback())
     
    8990}
    9091
    91 void DeferredWrapper::reject(ExceptionCode ec, const String& message)
     92void DeferredPromise::reject(ExceptionCode ec, const String& message)
    9293{
    9394    if (isSuspended())
     
    112113    scope.clearException();
    113114
    114     DeferredWrapper::create(&state, &globalObject, &promiseDeferred)->reject(error);
     115    DeferredPromise::create(globalObject, promiseDeferred)->reject(error);
     116}
     117
     118Ref<DeferredPromise> createDeferredPromise(JSC::ExecState& state, JSDOMWindow& domWindow)
     119{
     120    JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &domWindow);
     121    // deferred can only be null in workers.
     122    ASSERT(deferred);
     123    return DeferredPromise::create(domWindow, *deferred);
    115124}
    116125
     
    140149}
    141150
    142 void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data)
     151void fulfillPromiseWithJSON(Ref<DeferredPromise>&& promise, const String& data)
    143152{
    144153    JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);
     
    149158}
    150159
    151 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* arrayBuffer)
     160void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&& promise, ArrayBuffer* arrayBuffer)
    152161{
    153162    if (!arrayBuffer) {
     
    158167}
    159168
    160 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, const void* data, size_t length)
     169void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&& promise, const void* data, size_t length)
    161170{
    162171    fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());
  • trunk/Source/WebCore/bindings/js/JSDOMPromise.h

    r206011 r206252  
    9797};
    9898
    99 class DeferredWrapper : public RefCounted<DeferredWrapper>, public ActiveDOMCallback {
    100 public:
    101     // FIXME: We should pass references here, not pointers, see bug 161787
    102     static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
     99class DeferredPromise : public RefCounted<DeferredPromise>, public ActiveDOMCallback {
     100public:
     101    static Ref<DeferredPromise> create(JSDOMGlobalObject& globalObject, JSC::JSPromiseDeferred& deferred)
    103102    {
    104         return adoptRef(*new DeferredWrapper(state, globalObject, deferred));
     103        return adoptRef(*new DeferredPromise(globalObject, deferred));
    105104    }
    106105
    107     ~DeferredWrapper();
     106    ~DeferredPromise();
    108107
    109108    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
     
    137136
    138137private:
    139     DeferredWrapper(JSC::ExecState*, JSDOMGlobalObject*, JSC::JSPromiseDeferred*);
     138    DeferredPromise(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
    140139
    141140    void clear();
     
    153152};
    154153
    155 void fulfillPromiseWithJSON(Ref<DeferredWrapper>&&, const String&);
    156 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, ArrayBuffer*);
    157 void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, const void*, size_t);
     154Ref<DeferredPromise> createDeferredPromise(JSC::ExecState&, JSDOMWindow&);
     155
     156void fulfillPromiseWithJSON(Ref<DeferredPromise>&&, const String&);
     157void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&&, ArrayBuffer*);
     158void fulfillPromiseWithArrayBuffer(Ref<DeferredPromise>&&, const void*, size_t);
    158159void rejectPromiseWithExceptionIfAny(JSC::ExecState&, JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
    159160JSC::EncodedJSValue createRejectedPromiseWithTypeError(JSC::ExecState&, const String&);
    160161
    161 using PromiseFunction = void(JSC::ExecState&, Ref<DeferredWrapper>&&);
     162using PromiseFunction = void(JSC::ExecState&, Ref<DeferredPromise>&&);
    162163
    163164enum class PromiseExecutionScope { WindowOnly, WindowOrWorker };
     
    176177        return JSC::jsUndefined();
    177178
    178     promiseFunction(state, DeferredWrapper::create(&state, &globalObject, promiseDeferred));
     179    promiseFunction(state, DeferredPromise::create(globalObject, *promiseDeferred));
    179180
    180181    rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
     
    183184}
    184185
    185 using BindingPromiseFunction = JSC::EncodedJSValue(JSC::ExecState*, Ref<DeferredWrapper>&&);
     186using BindingPromiseFunction = JSC::EncodedJSValue(JSC::ExecState*, Ref<DeferredPromise>&&);
    186187template<BindingPromiseFunction bindingFunction>
    187 inline void bindingPromiseFunctionAdapter(JSC::ExecState& state, Ref<DeferredWrapper>&& promise)
     188inline void bindingPromiseFunctionAdapter(JSC::ExecState& state, Ref<DeferredPromise>&& promise)
    188189{
    189190    bindingFunction(&state, WTFMove(promise));
     
    200201class DOMPromise {
    201202public:
    202     DOMPromise(Ref<DeferredWrapper>&& wrapper)
    203         : m_wrapper(WTFMove(wrapper))
    204     {
    205     }
    206 
    207     DOMPromise(DOMPromise&& promise) : m_wrapper(WTFMove(promise.m_wrapper)) { }
     203    DOMPromise(Ref<DeferredPromise>&& genericPromise) : m_promiseDeferred(WTFMove(genericPromise)) { }
     204
     205    DOMPromise(DOMPromise&& promise) : m_promiseDeferred(WTFMove(promise.m_promiseDeferred)) { }
    208206
    209207    DOMPromise(const DOMPromise&) = default;
    210208    DOMPromise& operator=(DOMPromise const&) = default;
    211209
    212     void resolve(typename PromiseResultInspector<Value>::Type value) { m_wrapper->resolve(value); }
    213 
    214     template<typename... ErrorType> void reject(ErrorType&&... error) { m_wrapper->reject(std::forward<ErrorType>(error)...); }
    215 
    216     DeferredWrapper& deferredWrapper() { return m_wrapper; }
     210    void resolve(typename PromiseResultInspector<Value>::Type value) { m_promiseDeferred->resolve(value); }
     211
     212    template<typename... ErrorType> void reject(ErrorType&&... error) { m_promiseDeferred->reject(std::forward<ErrorType>(error)...); }
     213
     214    JSC::JSValue promise() const { return m_promiseDeferred->promise(); };
    217215
    218216private:
    219     Ref<DeferredWrapper> m_wrapper;
     217    Ref<DeferredPromise> m_promiseDeferred;
    220218};
    221219
    222220template<class ResolveResultType>
    223 inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
     221inline void DeferredPromise::resolveWithValue(ResolveResultType&& result)
    224222{
    225223    if (isSuspended())
     
    232230
    233231template<class ResolveResultType>
    234 inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
     232inline void DeferredPromise::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
    235233{
    236234    if (isSuspended())
     
    244242
    245243template<class RejectResultType>
    246 inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
     244inline void DeferredPromise::rejectWithValue(RejectResultType&& result)
    247245{
    248246    if (isSuspended())
     
    256254
    257255template<>
    258 inline void DeferredWrapper::resolve(bool result)
     256inline void DeferredPromise::resolve(bool result)
    259257{
    260258    if (isSuspended())
     
    268266
    269267template<>
    270 inline void DeferredWrapper::resolve(JSC::JSValue value)
     268inline void DeferredPromise::resolve(JSC::JSValue value)
    271269{
    272270    if (isSuspended())
     
    280278
    281279template<>
    282 inline void DeferredWrapper::reject(JSC::JSValue value)
     280inline void DeferredPromise::reject(JSC::JSValue value)
    283281{
    284282    if (isSuspended())
     
    292290
    293291template<>
    294 inline void DeferredWrapper::resolve(std::nullptr_t)
     292inline void DeferredPromise::resolve(std::nullptr_t)
    295293{
    296294    if (isSuspended())
     
    304302
    305303template<>
    306 inline void DeferredWrapper::reject(std::nullptr_t)
     304inline void DeferredPromise::reject(std::nullptr_t)
    307305{
    308306    if (isSuspended())
     
    316314
    317315template<>
    318 inline void DeferredWrapper::resolve(const String& result)
     316inline void DeferredPromise::resolve(const String& result)
    319317{
    320318    if (isSuspended())
     
    328326
    329327template<>
    330 inline void DeferredWrapper::reject(const String& result)
     328inline void DeferredPromise::reject(const String& result)
    331329{
    332330    if (isSuspended())
  • trunk/Source/WebCore/bindings/js/JSDOMWrapper.cpp

    r191060 r206252  
    2828
    2929#include "DOMWrapperWorld.h"
     30#include "JSDOMWindow.h"
    3031#include <runtime/Error.h>
    3132
     
    3637STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSDOMObject);
    3738
     39JSDOMWindow& JSDOMObject::domWindow() const
     40{
     41    auto* domWindow = JSC::jsCast<JSDOMWindow*>(JSC::JSNonFinalObject::globalObject());
     42    ASSERT(domWindow);
     43    return *domWindow;
     44}
     45
    3846} // namespace WebCore
  • trunk/Source/WebCore/bindings/js/JSDOMWrapper.h

    r205422 r206252  
    2828namespace WebCore {
    2929
     30class JSDOMWindow;
    3031class ScriptExecutionContext;
    3132
     
    4243    ScriptExecutionContext* scriptExecutionContext() const { return globalObject()->scriptExecutionContext(); }
    4344
     45    JSDOMWindow& domWindow() const;
     46
    4447protected:
    45     JSDOMObject(JSC::Structure* structure, JSC::JSGlobalObject& globalObject) 
     48    JSDOMObject(JSC::Structure* structure, JSC::JSGlobalObject& globalObject)
    4649        : Base(globalObject.vm(), structure)
    4750    {
  • trunk/Source/WebCore/bindings/js/JSFontFaceCustom.cpp

    r205257 r206252  
    4040    if (!m_loaded) {
    4141        if (!wrapped().promise()) {
    42             Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));
     42            auto promise = createDeferredPromise(state, domWindow());
    4343            m_loaded.set(state.vm(), this, promise->promise());
    4444            wrapped().registerLoaded(WTFMove(promise));
    4545        } else
    46             m_loaded.set(state.vm(), this, wrapped().promise().value().deferredWrapper().promise());
     46            m_loaded.set(state.vm(), this, wrapped().promise().value().promise());
    4747    }
    4848    return m_loaded.get();
  • trunk/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp

    r205257 r206252  
    3535{
    3636    if (!m_ready) {
    37         Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));
     37        auto promise = createDeferredPromise(state, domWindow());
    3838        m_ready.set(state.vm(), this, promise->promise());
    3939        wrapped().registerReady(WTFMove(promise));
  • trunk/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp

    r205953 r206252  
    341341}
    342342
    343 static void JSMediaDevicesGetUserMediaPromiseFunction(ExecState& state, Ref<DeferredWrapper>&& promise)
     343static void JSMediaDevicesGetUserMediaPromiseFunction(ExecState& state, Ref<DeferredPromise>&& promise)
    344344{
    345345    VM& vm = state.vm();
  • trunk/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp

    r205348 r206252  
    185185    }
    186186
    187     JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
     187    auto deferredPromise = createDeferredPromise(state, domWindow());
     188    auto promise = deferredPromise->promise();
     189
    188190    auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);
    189     wrapped().applyConstraints(WTFMove(constraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred));
    190 
    191     return promiseDeferred->promise();
     191    wrapped().applyConstraints(WTFMove(constraints), WTFMove(deferredPromise));
     192
     193    return promise;
    192194}
    193195
  • trunk/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp

    r205549 r206252  
    4444    m_controller.set(state.vm(), jsSource, state.argument(0));
    4545
     46    ASSERT(globalObject());
    4647    JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
    47     wrapped().start(ReadableStreamDefaultController(controller), DeferredWrapper::create(&state, globalObject(), promiseDeferred));
     48    if (!promiseDeferred)
     49        return jsUndefined();
     50    wrapped().start(ReadableStreamDefaultController(controller), DeferredPromise::create(*globalObject(), *promiseDeferred));
    4851    return promiseDeferred->promise();
    4952}
  • trunk/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp

    r205569 r206252  
    174174        return jsUndefined();
    175175
    176    
    177     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    178     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     176    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     177    auto promise = wrapper->promise();
    179178    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
    180179        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
     
    191190    }
    192191
    193     return promiseDeferred->promise();
     192    return promise;
    194193}
    195194
     
    228227        return jsUndefined();
    229228
    230     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    231     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     229    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     230    auto promise = wrapper->promise();
    232231    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
    233232        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
     
    244243    }
    245244
    246     return promiseDeferred->promise();
     245    return promise;
    247246}
    248247
     
    281280        return jsUndefined();
    282281
    283     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    284     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     282    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     283    auto promise = wrapper->promise();
    285284    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
    286285        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
     
    297296    }
    298297
    299     return promiseDeferred->promise();
     298    return promise;
    300299}
    301300
     
    340339        return jsUndefined();
    341340
    342     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    343     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     341    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     342    auto promise = wrapper->promise();
    344343    auto successCallback = [wrapper](bool result) mutable {
    345344        wrapper->resolve(result);
     
    356355    }
    357356
    358     return promiseDeferred->promise();
     357    return promise;
    359358}
    360359
     
    383382        return jsUndefined();
    384383
    385     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    386     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     384    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     385    auto promise = wrapper->promise();
    387386    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
    388387        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
     
    399398    }
    400399
    401     return promiseDeferred->promise();
     400    return promise;
    402401}
    403402
     
    435434    }
    436435
    437     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    438     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     436    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     437    auto promise = wrapper->promise();
    439438    auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
    440439        ASSERT(key || keyPair);
     
    456455    }
    457456
    458     return promiseDeferred->promise();
     457    return promise;
    459458}
    460459
     
    571570    }
    572571
    573     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    574     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     572    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     573    auto promise = wrapper->promise();
    575574    auto successCallback = [wrapper](CryptoKey& result) mutable {
    576575        wrapper->resolve(result);
     
    584583        return jsUndefined();
    585584
    586     return promiseDeferred->promise();
     585    return promise;
    587586}
    588587
     
    640639        return throwTypeError(&state, scope);
    641640
    642     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    643     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     641    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     642    auto promise = wrapper->promise();
    644643    auto successCallback = [wrapper](const Vector<uint8_t>& result) mutable {
    645644        fulfillPromiseWithArrayBuffer(wrapper.releaseNonNull(), result.data(), result.size());
     
    653652        return jsUndefined();
    654653
    655     return promiseDeferred->promise();
     654    return promise;
    656655}
    657656
     
    694693        return jsUndefined();
    695694
    696     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    697     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     695    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     696    auto promise = wrapper->promise();
    698697
    699698    auto exportSuccessCallback = [keyFormat, algorithm, parameters, wrappingKey, wrapper](const Vector<uint8_t>& exportedKeyData) mutable {
     
    723722    }
    724723
    725     return promiseDeferred->promise();
     724    return promise;
    726725}
    727726
     
    794793    }
    795794
    796     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
    797     RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
     795    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
     796    auto promise = wrapper->promise();
    798797    Strong<JSDOMGlobalObject> domGlobalObject(state.vm(), globalObject());
    799798
     
    829828    }
    830829
    831     return promiseDeferred->promise();
     830    return promise;
    832831}
    833832
  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r206094 r206252  
    34263426                my $scope = $interface->extendedAttributes->{"Exposed"} ? "WindowOrWorker" : "WindowOnly";
    34273427                push(@implContent, <<END);
    3428 static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DeferredWrapper>&&);
     3428static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DeferredPromise>&&);
    34293429
    34303430${functionReturn} ${functionName}(ExecState* state)
     
    34343434}
    34353435
    3436 static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     3436static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DeferredPromise>&& promise)
    34373437END
    34383438            }
     
    41474147
    41484148    if (IsReturningPromise($function)) {
    4149         push(@arguments, "WTFMove(deferredWrapper)");
     4149        push(@arguments, "WTFMove(promise)");
    41504150    }
    41514151    push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} || $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};
  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp

    r205964 r206252  
    232232}
    233233
    234 static EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState*, Ref<DeferredWrapper>&&);
     234static EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState*, Ref<DeferredPromise>&&);
    235235
    236236EncodedJSValue JSC_HOST_CALL jsTestNodePrototypeFunctionTestWorkerPromise(ExecState* state)
     
    240240}
    241241
    242 static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     242static inline EncodedJSValue jsTestNodePrototypeFunctionTestWorkerPromisePromise(ExecState* state, Ref<DeferredPromise>&& promise)
    243243{
    244244    VM& vm = state->vm();
     
    251251    ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestNode::info());
    252252    auto& impl = castedThis->wrapped();
    253     impl.testWorkerPromise(WTFMove(deferredWrapper));
     253    impl.testWorkerPromise(WTFMove(promise));
    254254    return JSValue::encode(jsUndefined());
    255255}
  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r206094 r206252  
    71617161}
    71627162
    7163 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);
     7163static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DeferredPromise>&&);
    71647164
    71657165EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunction(ExecState* state)
     
    71697169}
    71707170
    7171 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7171static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DeferredPromise>&& promise)
    71727172{
    71737173    VM& vm = state->vm();
     
    71807180    ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
    71817181    auto& impl = castedThis->wrapped();
    7182     impl.testPromiseFunction(WTFMove(deferredWrapper));
    7183     return JSValue::encode(jsUndefined());
    7184 }
    7185 
    7186 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);
     7182    impl.testPromiseFunction(WTFMove(promise));
     7183    return JSValue::encode(jsUndefined());
     7184}
     7185
     7186static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DeferredPromise>&&);
    71877187
    71887188EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgument(ExecState* state)
     
    71927192}
    71937193
    7194 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7194static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DeferredPromise>&& promise)
    71957195{
    71967196    VM& vm = state->vm();
     
    72087208    if (UNLIKELY(throwScope.exception()))
    72097209        return JSValue::encode(jsUndefined());
    7210     impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredWrapper));
    7211     return JSValue::encode(jsUndefined());
    7212 }
    7213 
    7214 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);
     7210    impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(promise));
     7211    return JSValue::encode(jsUndefined());
     7212}
     7213
     7214static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredPromise>&&);
    72157215
    72167216EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithException(ExecState* state)
     
    72207220}
    72217221
    7222 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7222static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredPromise>&& promise)
    72237223{
    72247224    VM& vm = state->vm();
     
    72327232    auto& impl = castedThis->wrapped();
    72337233    ExceptionCode ec = 0;
    7234     impl.testPromiseFunctionWithException(WTFMove(deferredWrapper), ec);
     7234    impl.testPromiseFunctionWithException(WTFMove(promise), ec);
    72357235    setDOMException(state, ec);
    72367236    return JSValue::encode(jsUndefined());
    72377237}
    72387238
    7239 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);
     7239static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DeferredPromise>&&);
    72407240
    72417241EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgument(ExecState* state)
     
    72457245}
    72467246
    7247 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7247static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DeferredPromise>&& promise)
    72487248{
    72497249    VM& vm = state->vm();
     
    72597259    if (UNLIKELY(throwScope.exception()))
    72607260        return JSValue::encode(jsUndefined());
    7261     impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(deferredWrapper));
    7262     return JSValue::encode(jsUndefined());
    7263 }
    7264 
    7265 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DeferredWrapper>&&);
     7261    impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(promise));
     7262    return JSValue::encode(jsUndefined());
     7263}
     7264
     7265static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DeferredPromise>&&);
    72667266
    72677267static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1(ExecState* state)
     
    72717271}
    72727272
    7273 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7273static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DeferredPromise>&& promise)
    72747274{
    72757275    VM& vm = state->vm();
     
    72877287    if (UNLIKELY(throwScope.exception()))
    72887288        return JSValue::encode(jsUndefined());
    7289     impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredWrapper));
    7290     return JSValue::encode(jsUndefined());
    7291 }
    7292 
    7293 static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DeferredWrapper>&&);
     7289    impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(promise));
     7290    return JSValue::encode(jsUndefined());
     7291}
     7292
     7293static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DeferredPromise>&&);
    72947294
    72957295static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2(ExecState* state)
     
    72997299}
    73007300
    7301 static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7301static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DeferredPromise>&& promise)
    73027302{
    73037303    VM& vm = state->vm();
     
    73157315    if (UNLIKELY(!request))
    73167316        return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");
    7317     impl.testPromiseOverloadedFunction(*request, WTFMove(deferredWrapper));
     7317    impl.testPromiseOverloadedFunction(*request, WTFMove(promise));
    73187318    return JSValue::encode(jsUndefined());
    73197319}
     
    73367336}
    73377337
    7338 static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);
     7338static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DeferredPromise>&&);
    73397339
    73407340EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunction(ExecState* state)
     
    73447344}
    73457345
    7346 static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
    7347 {
    7348     VM& vm = state->vm();
    7349     auto throwScope = DECLARE_THROW_SCOPE(vm);
    7350     UNUSED_PARAM(throwScope);
    7351     TestObj::testStaticPromiseFunction(WTFMove(deferredWrapper));
    7352     return JSValue::encode(jsUndefined());
    7353 }
    7354 
    7355 static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);
     7346static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState* state, Ref<DeferredPromise>&& promise)
     7347{
     7348    VM& vm = state->vm();
     7349    auto throwScope = DECLARE_THROW_SCOPE(vm);
     7350    UNUSED_PARAM(throwScope);
     7351    TestObj::testStaticPromiseFunction(WTFMove(promise));
     7352    return JSValue::encode(jsUndefined());
     7353}
     7354
     7355static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredPromise>&&);
    73567356
    73577357EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionTestStaticPromiseFunctionWithException(ExecState* state)
     
    73617361}
    73627362
    7363 static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredWrapper>&& deferredWrapper)
     7363static inline EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DeferredPromise>&& promise)
    73647364{
    73657365    VM& vm = state->vm();
     
    73677367    UNUSED_PARAM(throwScope);
    73687368    ExceptionCode ec = 0;
    7369     TestObj::testStaticPromiseFunctionWithException(WTFMove(deferredWrapper), ec);
     7369    TestObj::testStaticPromiseFunctionWithException(WTFMove(promise), ec);
    73707370    setDOMException(state, ec);
    73717371    return JSValue::encode(jsUndefined());
  • trunk/Source/WebCore/dom/CustomElementRegistry.cpp

    r205416 r206252  
    3535#include "ElementTraversal.h"
    3636#include "JSCustomElementInterface.h"
    37 #include "JSDOMPromise.h"
    3837#include "MathMLNames.h"
    3938#include "QualifiedName.h"
  • trunk/Source/WebCore/dom/CustomElementRegistry.h

    r205410 r206252  
    2828#if ENABLE(CUSTOM_ELEMENTS)
    2929
     30#include "JSDOMPromise.h"
    3031#include "QualifiedName.h"
    3132#include <wtf/HashMap.h>
     
    4546class CustomElementRegistry;
    4647class DOMWindow;
    47 class DeferredWrapper;
    4848class Element;
    4949class JSCustomElementInterface;
     
    6767    JSC::JSValue get(const AtomicString&);
    6868
    69     HashMap<AtomicString, Ref<DeferredWrapper>>& promiseMap() { return m_promiseMap; }
     69    HashMap<AtomicString, Ref<DeferredPromise>>& promiseMap() { return m_promiseMap; }
    7070
    7171private:
     
    7575    HashMap<AtomicString, Ref<JSCustomElementInterface>> m_nameMap;
    7676    HashMap<const JSC::JSObject*, JSCustomElementInterface*> m_constructorMap;
    77     HashMap<AtomicString, Ref<DeferredWrapper>> m_promiseMap;
     77    HashMap<AtomicString, Ref<DeferredPromise>> m_promiseMap;
    7878
    7979    bool m_elementDefinitionIsRunning { false };
Note: See TracChangeset for help on using the changeset viewer.