Attachment 288808 Details for Bug 161787 – Patch

[patch] Patch

bug-161787-20160914143231.patch (text/plain), 67.98 KB, created by youenn fablet on 2016-09-14 05:35:09 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2016-09-14 05:35:09 PDT

Size: 67.98 KB

patch

obsolete

>Subversion Revision: 205901
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index feb8f31edfa01759b898fc95dae5aa5b41f5472e..2d661eb5b949387a84ae7fd226c6eddd541a80ac 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,130 @@
>+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.
>diff --git a/Source/WebCore/Modules/applepay/ApplePaySession.cpp b/Source/WebCore/Modules/applepay/ApplePaySession.cpp
>index c8c069250ce2bb634925c0fdce30fecfc5cf086c..feed8d2ea9f5870c31ed0ba008d909bfdb808188 100644
>--- a/Source/WebCore/Modules/applepay/ApplePaySession.cpp
>+++ b/Source/WebCore/Modules/applepay/ApplePaySession.cpp
>@@ -733,7 +733,7 @@ bool ApplePaySession::canMakePayments(ScriptExecutionContext& scriptExecutionCon
>     return paymentCoordinator.canMakePayments();
> }
> 
>-void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DeferredWrapper>&& passedPromise, ExceptionCode& ec)
>+void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scriptExecutionContext, const String& merchantIdentifier, Ref<DOMDeferredPromise>&& passedPromise, ExceptionCode& ec)
> {
>     auto& document = downcast<Document>(scriptExecutionContext);
>     DOMWindow& window = *document.domWindow();
>@@ -745,7 +745,7 @@ void ApplePaySession::canMakePaymentsWithActiveCard(ScriptExecutionContext& scri
>         return;
>     }
> 
>-    RefPtr<DeferredWrapper> promise(WTFMove(passedPromise));
>+    RefPtr<DOMDeferredPromise> promise(WTFMove(passedPromise));
>     if (!shouldDiscloseApplePayCapability(document)) {
>         auto& paymentCoordinator = document.frame()->mainFrame().paymentCoordinator();
>         bool canMakePayments = paymentCoordinator.canMakePayments();
>diff --git a/Source/WebCore/Modules/applepay/ApplePaySession.h b/Source/WebCore/Modules/applepay/ApplePaySession.h
>index f6339b4cbcba2de61b944ae289d724d7e118e48d..84798662d9698b497aaee8afc7892182c2428a27 100644
>--- a/Source/WebCore/Modules/applepay/ApplePaySession.h
>+++ b/Source/WebCore/Modules/applepay/ApplePaySession.h
>@@ -37,7 +37,7 @@
> namespace WebCore {
> 
> class ArrayValue;
>-class DeferredWrapper;
>+class DOMDeferredPromise;
> class Dictionary;
> class Document;
> class Payment;
>@@ -63,7 +63,7 @@ public:
> 
>     static bool supportsVersion(ScriptExecutionContext&, unsigned version, ExceptionCode&);
>     static bool canMakePayments(ScriptExecutionContext&, ExceptionCode&);
>-    static void canMakePaymentsWithActiveCard(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DeferredWrapper>&&, ExceptionCode&);
>+    static void canMakePaymentsWithActiveCard(ScriptExecutionContext&, const String& merchantIdentifier, Ref<DOMDeferredPromise>&&, ExceptionCode&);
> 
>     void begin(ExceptionCode&);
>     void abort(ExceptionCode&);
>diff --git a/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp b/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp
>index c480a7db98ef15aa420eba34eba8f9d0174898bc..91c6173bae9b24886fa15c3e61ebfd49d3e3e8d9 100644
>--- a/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp
>+++ b/Source/WebCore/Modules/fetch/DOMWindowFetch.cpp
>@@ -37,7 +37,7 @@
> 
> namespace WebCore {
> 
>-void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, DOMPromise<FetchResponse>&& promise)
>+void DOMWindowFetch::fetch(DOMWindow& window, FetchRequest& request, Ref<DOMDeferredPromise>&& promise)
> {
>     if (!window.scriptExecutionContext())
>         return;
>diff --git a/Source/WebCore/Modules/fetch/DOMWindowFetch.h b/Source/WebCore/Modules/fetch/DOMWindowFetch.h
>index d371f2c38b682ddea083a6aff2e347a01d9afa4b..0bb9cfcf1a25b68cdc1defef57972265056afc5b 100644
>--- a/Source/WebCore/Modules/fetch/DOMWindowFetch.h
>+++ b/Source/WebCore/Modules/fetch/DOMWindowFetch.h
>@@ -36,14 +36,13 @@
> namespace WebCore {
> 
> class DOMWindow;
>-class DeferredWrapper;
>+class DOMDeferredPromise;
> class Dictionary;
> class FetchRequest;
>-class FetchResponse;
> 
> class DOMWindowFetch {
> public:
>-    static void fetch(DOMWindow&, FetchRequest&, DOMPromise<FetchResponse>&&);
>+    static void fetch(DOMWindow&, FetchRequest&, Ref<DOMDeferredPromise>&&);
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/fetch/FetchBody.cpp b/Source/WebCore/Modules/fetch/FetchBody.cpp
>index 25ed1f381dec46ec3ddb06ad25631aa4bdea6106..1e227822aeadc8e16fe3b214b1dfb66bc170f480 100644
>--- a/Source/WebCore/Modules/fetch/FetchBody.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchBody.cpp
>@@ -124,14 +124,14 @@ void FetchBody::updateContentType(FetchHeaders& headers)
>         headers.fastSet(HTTPHeaderName::ContentType, m_contentType);
> }
> 
>-void FetchBody::arrayBuffer(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>+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<DeferredWrapper>&& promise)
>+void FetchBody::blob(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
> {
>     ASSERT(m_type != Type::None);
>     m_consumer.setType(FetchBodyConsumer::Type::Blob);
>@@ -139,7 +139,7 @@ void FetchBody::blob(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>     consume(owner, WTFMove(promise));
> }
> 
>-void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>+void FetchBody::json(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
> {
>     ASSERT(m_type != Type::None);
> 
>@@ -151,7 +151,7 @@ void FetchBody::json(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>     consume(owner, WTFMove(promise));
> }
> 
>-void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>+void FetchBody::text(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
> {
>     ASSERT(m_type != Type::None);
> 
>@@ -163,7 +163,7 @@ void FetchBody::text(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>     consume(owner, WTFMove(promise));
> }
> 
>-void FetchBody::consume(FetchBodyOwner& owner, Ref<DeferredWrapper>&& promise)
>+void FetchBody::consume(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
> {
>     // This should be handled by FetchBodyOwner
>     ASSERT(m_type != Type::None);
>@@ -246,28 +246,28 @@ void FetchBody::consumeAsStream(FetchBodyOwner& owner, FetchResponseSource& sour
> }
> #endif
> 
>-void FetchBody::consumeArrayBuffer(Ref<DeferredWrapper>&& promise)
>+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<DeferredWrapper>&& promise)
>+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<DeferredWrapper>&& promise)
>+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<DeferredWrapper>&& promise)
>+void FetchBody::consumeBlob(FetchBodyOwner& owner, Ref<DOMDeferredPromise>&& promise)
> {
>     ASSERT(m_blob);
> 
>diff --git a/Source/WebCore/Modules/fetch/FetchBody.h b/Source/WebCore/Modules/fetch/FetchBody.h
>index 850e664b4f275d57639bc757dd67151041199622..b196d8ee6c034ad8026342bcb61a8f847273b1ea 100644
>--- a/Source/WebCore/Modules/fetch/FetchBody.h
>+++ b/Source/WebCore/Modules/fetch/FetchBody.h
>@@ -52,11 +52,11 @@ class ScriptExecutionContext;
> 
> class FetchBody {
> public:
>-    void arrayBuffer(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>-    void blob(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>-    void json(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>-    void text(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>-    void formData(FetchBodyOwner&, Ref<DeferredWrapper>&& promise) { promise.get().reject(0); }
>+    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&);
>@@ -93,13 +93,13 @@ private:
>     FetchBody(String&&);
>     FetchBody(Type type) : m_type(type) { }
> 
>-    void consume(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>+    void consume(FetchBodyOwner&, Ref<DOMDeferredPromise>&&);
> 
>     Vector<uint8_t> extractFromText() const;
>-    void consumeArrayBuffer(Ref<DeferredWrapper>&&);
>-    void consumeArrayBufferView(Ref<DeferredWrapper>&&);
>-    void consumeText(Ref<DeferredWrapper>&&);
>-    void consumeBlob(FetchBodyOwner&, Ref<DeferredWrapper>&&);
>+    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;
>@@ -112,7 +112,7 @@ private:
>     String m_text;
> 
>     FetchBodyConsumer m_consumer { FetchBodyConsumer::Type::None };
>-    RefPtr<DeferredWrapper> m_consumePromise;
>+    RefPtr<DOMDeferredPromise> m_consumePromise;
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp b/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>index 7264b8d2d979402f920dcf5056fd31c6b69cb20a..0c0785110e8d8820a74a4ac482f7e77268f5f505 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchBodyConsumer.cpp
>@@ -59,7 +59,7 @@ static String textFromUTF8(const unsigned char* data, unsigned length)
>     return decoder->decodeAndFlush(reinterpret_cast<const char*>(data), length);
> }
> 
>-void FetchBodyConsumer::resolveWithData(Ref<DeferredWrapper>&& promise, const unsigned char* data, unsigned length)
>+void FetchBodyConsumer::resolveWithData(Ref<DOMDeferredPromise>&& promise, const unsigned char* data, unsigned length)
> {
>     switch (m_type) {
>     case Type::ArrayBuffer:
>@@ -80,7 +80,7 @@ void FetchBodyConsumer::resolveWithData(Ref<DeferredWrapper>&& promise, const un
>     }
> }
> 
>-void FetchBodyConsumer::resolve(Ref<DeferredWrapper>&& promise)
>+void FetchBodyConsumer::resolve(Ref<DOMDeferredPromise>&& promise)
> {
>     ASSERT(m_type != Type::None);
>     switch (m_type) {
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h b/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>index f949ac086713b98438effe1ee90bf28954779bbb..6437e449e5186711c5272fee63c3aa602fe679b8 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>+++ b/Source/WebCore/Modules/fetch/FetchBodyConsumer.h
>@@ -35,7 +35,7 @@
> namespace WebCore {
> 
> class Blob;
>-class DeferredWrapper;
>+class DOMDeferredPromise;
> 
> class FetchBodyConsumer {
> public:
>@@ -57,8 +57,8 @@ public:
> 
>     void clean() { m_buffer = nullptr; }
> 
>-    void resolve(Ref<DeferredWrapper>&&);
>-    void resolveWithData(Ref<DeferredWrapper>&&, const unsigned char*, unsigned);
>+    void resolve(Ref<DOMDeferredPromise>&&);
>+    void resolveWithData(Ref<DOMDeferredPromise>&&, const unsigned char*, unsigned);
> 
>     bool hasData() const { return !!m_buffer; }
> 
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp b/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp
>index c29434f351b621e6994abf55c04ba03b25dee28a..b795bacad21400979de38d4724f8b05a6a773891 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp
>@@ -71,7 +71,7 @@ bool FetchBodyOwner::isDisturbedOrLocked() const
>     return false;
> }
> 
>-void FetchBodyOwner::arrayBuffer(Ref<DeferredWrapper>&& promise)
>+void FetchBodyOwner::arrayBuffer(Ref<DOMDeferredPromise>&& promise)
> {
>     if (m_body.isEmpty()) {
>         fulfillPromiseWithArrayBuffer(WTFMove(promise), nullptr, 0);
>@@ -85,7 +85,7 @@ void FetchBodyOwner::arrayBuffer(Ref<DeferredWrapper>&& promise)
>     m_body.arrayBuffer(*this, WTFMove(promise));
> }
> 
>-void FetchBodyOwner::blob(Ref<DeferredWrapper>&& promise)
>+void FetchBodyOwner::blob(Ref<DOMDeferredPromise>&& promise)
> {
>     if (m_body.isEmpty()) {
>         promise->resolve(Blob::create(Vector<uint8_t>(), Blob::normalizedContentType(extractMIMETypeFromMediaType(m_body.contentType()))));
>@@ -99,7 +99,7 @@ void FetchBodyOwner::blob(Ref<DeferredWrapper>&& promise)
>     m_body.blob(*this, WTFMove(promise));
> }
> 
>-void FetchBodyOwner::formData(Ref<DeferredWrapper>&& promise)
>+void FetchBodyOwner::formData(Ref<DOMDeferredPromise>&& promise)
> {
>     if (m_body.isEmpty()) {
>         promise->reject(0);
>@@ -113,7 +113,7 @@ void FetchBodyOwner::formData(Ref<DeferredWrapper>&& promise)
>     m_body.formData(*this, WTFMove(promise));
> }
> 
>-void FetchBodyOwner::json(Ref<DeferredWrapper>&& promise)
>+void FetchBodyOwner::json(Ref<DOMDeferredPromise>&& promise)
> {
>     if (m_body.isEmpty()) {
>         promise->reject(SYNTAX_ERR);
>@@ -127,7 +127,7 @@ void FetchBodyOwner::json(Ref<DeferredWrapper>&& promise)
>     m_body.json(*this, WTFMove(promise));
> }
> 
>-void FetchBodyOwner::text(Ref<DeferredWrapper>&& promise)
>+void FetchBodyOwner::text(Ref<DOMDeferredPromise>&& promise)
> {
>     if (m_body.isEmpty()) {
>         promise->resolve(String());
>diff --git a/Source/WebCore/Modules/fetch/FetchBodyOwner.h b/Source/WebCore/Modules/fetch/FetchBodyOwner.h
>index 0df30b75482eda880bfc7a977d74a29086f695bb..20ddcacb733b2ef89dad59e49f59e3207df5b0ac 100644
>--- a/Source/WebCore/Modules/fetch/FetchBodyOwner.h
>+++ b/Source/WebCore/Modules/fetch/FetchBodyOwner.h
>@@ -46,11 +46,11 @@ public:
>     // Exposed Body API
>     bool isDisturbed() const { return m_isDisturbed; };
> 
>-    void arrayBuffer(Ref<DeferredWrapper>&&);
>-    void blob(Ref<DeferredWrapper>&&);
>-    void formData(Ref<DeferredWrapper>&&);
>-    void json(Ref<DeferredWrapper>&&);
>-    void text(Ref<DeferredWrapper>&&);
>+    void arrayBuffer(Ref<DOMDeferredPromise>&&);
>+    void blob(Ref<DOMDeferredPromise>&&);
>+    void formData(Ref<DOMDeferredPromise>&&);
>+    void json(Ref<DOMDeferredPromise>&&);
>+    void text(Ref<DOMDeferredPromise>&&);
> 
>     bool isDisturbedOrLocked() const;
> 
>diff --git a/Source/WebCore/Modules/fetch/FetchResponse.cpp b/Source/WebCore/Modules/fetch/FetchResponse.cpp
>index b8641d43f0e5178c2d4580c11c57f1dc78a440fe..3eb6ca518f6fe8b8b31a4756804b10afa6f856d9 100644
>--- a/Source/WebCore/Modules/fetch/FetchResponse.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchResponse.cpp
>@@ -206,7 +206,7 @@ void FetchResponse::BodyLoader::stop()
>         m_loader->stop();
> }
> 
>-void FetchResponse::consume(unsigned type, Ref<DeferredWrapper>&& wrapper)
>+void FetchResponse::consume(unsigned type, Ref<DOMDeferredPromise>&& wrapper)
> {
>     ASSERT(type <= static_cast<unsigned>(FetchBodyConsumer::Type::Text));
> 
>@@ -241,7 +241,7 @@ void FetchResponse::consumeChunk(Ref<JSC::Uint8Array>&& chunk)
>     m_consumer.append(chunk->data(), chunk->byteLength());
> }
> 
>-void FetchResponse::finishConsumingStream(Ref<DeferredWrapper>&& promise)
>+void FetchResponse::finishConsumingStream(Ref<DOMDeferredPromise>&& promise)
> {
>     m_consumer.resolve(WTFMove(promise));
> }
>diff --git a/Source/WebCore/Modules/fetch/FetchResponse.h b/Source/WebCore/Modules/fetch/FetchResponse.h
>index ee9936885bcbc968fcbdbc920e4f5e77122c1cee..8ea83a70d60ed4821c9b632e105b8780a6e977b7 100644
>--- a/Source/WebCore/Modules/fetch/FetchResponse.h
>+++ b/Source/WebCore/Modules/fetch/FetchResponse.h
>@@ -60,11 +60,11 @@ public:
>     using FetchPromise = DOMPromise<FetchResponse>;
>     static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);
> 
>-    void consume(unsigned, Ref<DeferredWrapper>&&);
>+    void consume(unsigned, Ref<DOMDeferredPromise>&&);
> #if ENABLE(READABLE_STREAM_API)
>     void startConsumingStream(unsigned);
>     void consumeChunk(Ref<JSC::Uint8Array>&&);
>-    void finishConsumingStream(Ref<DeferredWrapper>&&);
>+    void finishConsumingStream(Ref<DOMDeferredPromise>&&);
> #endif
> 
>     void setStatus(int, const String&, ExceptionCode&);
>diff --git a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp b/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp
>index 535516c11cb34c3cc70c4c72116e69dda3e5b8f5..443b57d3dce46e8437b285307ddeab0342047bae 100644
>--- a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp
>+++ b/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.cpp
>@@ -36,7 +36,7 @@
> 
> namespace WebCore {
> 
>-void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, Ref<DeferredWrapper>&& promise)
>+void WorkerGlobalScopeFetch::fetch(WorkerGlobalScope& scope, FetchRequest& request, Ref<DOMDeferredPromise>&& promise)
> {
>     if (!scope.scriptExecutionContext())
>         return;
>diff --git a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.h b/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.h
>index 20b262576e7dc090712df3da98308de2a0ecbe0a..26d13e91947df30ca88d6630f417cc92efaff4bf 100644
>--- a/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.h
>+++ b/Source/WebCore/Modules/fetch/WorkerGlobalScopeFetch.h
>@@ -36,12 +36,12 @@
> namespace WebCore {
> 
> class WorkerGlobalScope;
>-class DeferredWrapper;
>+class DOMDeferredPromise;
> class FetchRequest;
> 
> class WorkerGlobalScopeFetch {
> public:
>-    static void fetch(WorkerGlobalScope&, FetchRequest&, Ref<DeferredWrapper>&&);
>+    static void fetch(WorkerGlobalScope&, FetchRequest&, Ref<DOMDeferredPromise>&&);
> };
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp b/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp
>index c97b93b0065897477064b2275e8833e2acb02111..d429d5feb0b30bba84fc5e60f55ba9d4b874b3a9 100644
>--- a/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSCustomElementRegistryCustom.cpp
>@@ -177,13 +177,13 @@ static JSValue whenDefinedPromise(ExecState& state, JSDOMGlobalObject& globalObj
>         return jsUndefined();
> 
>     if (registry.findInterface(localName)) {
>-        auto& jsPromise = *JSPromiseDeferred::create(&state, &globalObject);
>-        DeferredWrapper::create(&state, &globalObject, &jsPromise)->resolve(nullptr);
>-        return jsPromise.promise();
>+        auto domPromise = DOMDeferredPromise::create(state, globalObject);
>+        domPromise->resolve(nullptr);
>+        return domPromise->promise();
>     }
> 
>     auto result = registry.promiseMap().ensure(localName, [&] {
>-        return DeferredWrapper::create(&state, &globalObject, JSPromiseDeferred::create(&state, &globalObject));
>+        return DOMDeferredPromise::create(state, globalObject);
>     });
> 
>     return result.iterator->value->promise();
>@@ -194,13 +194,14 @@ JSValue JSCustomElementRegistry::whenDefined(ExecState& state)
>     auto scope = DECLARE_CATCH_SCOPE(state.vm());
> 
>     JSDOMGlobalObject& globalObject = *jsCast<JSDOMGlobalObject*>(state.lexicalGlobalObject());
>-    auto& promiseDeferred = *JSPromiseDeferred::create(&state, &globalObject);
>+    auto promiseDeferred = JSPromiseDeferred::create(&state, &globalObject);
>+    ASSERT(promiseDeferred);
>     JSValue promise = whenDefinedPromise(state, globalObject, wrapped());
> 
>     if (UNLIKELY(scope.exception())) {
>-        rejectPromiseWithExceptionIfAny(state, globalObject, promiseDeferred);
>+        rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
>         ASSERT(!scope.exception());
>-        return promiseDeferred.promise();
>+        return promiseDeferred->promise();
>     }
> 
>     return promise;
>diff --git a/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp b/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp
>index 35f895c80c75b79a096529f6c5dc191a260e56ad..e870aeb67f51d8c16482e1132ffe7cc8fca30bea 100644
>--- a/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp
>+++ b/Source/WebCore/bindings/js/JSDOMGlobalObject.cpp
>@@ -178,8 +178,8 @@ void JSDOMGlobalObject::visitChildren(JSCell* cell, SlotVisitor& visitor)
>     for (auto& constructor : thisObject->constructors().values())
>         visitor.append(&constructor);
> 
>-    for (auto& deferredWrapper : thisObject->deferredWrappers())
>-        deferredWrapper->visitAggregate(visitor);
>+    for (auto& deferredPromise : thisObject->deferredPromises())
>+        deferredPromise->visitAggregate(visitor);
> 
>     thisObject->m_builtinInternalFunctions.visit(visitor);
> }
>diff --git a/Source/WebCore/bindings/js/JSDOMGlobalObject.h b/Source/WebCore/bindings/js/JSDOMGlobalObject.h
>index c672e4b92d2253785948b5da216afeab47bbb57c..ce9bab8e2a57152161dab98b3fcccfa879f4564b 100644
>--- a/Source/WebCore/bindings/js/JSDOMGlobalObject.h
>+++ b/Source/WebCore/bindings/js/JSDOMGlobalObject.h
>@@ -34,7 +34,7 @@
> 
> namespace WebCore {
> 
>-    class DeferredWrapper;
>+    class DOMDeferredPromise;
>     class Document;
>     class Event;
>     class DOMWrapperWorld;
>@@ -42,7 +42,7 @@ namespace WebCore {
> 
>     typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::Structure>> JSDOMStructureMap;
>     typedef HashMap<const JSC::ClassInfo*, JSC::WriteBarrier<JSC::JSObject>> JSDOMConstructorMap;
>-    typedef HashSet<DeferredWrapper*> DeferredWrapperSet;
>+    typedef HashSet<DOMDeferredPromise*> DOMDeferredPromiseSet;
> 
>     class WEBCORE_EXPORT JSDOMGlobalObject : public JSC::JSGlobalObject {
>         typedef JSC::JSGlobalObject Base;
>@@ -58,7 +58,7 @@ namespace WebCore {
>         JSDOMStructureMap& structures() { return m_structures; }
>         JSDOMConstructorMap& constructors() { return m_constructors; }
> 
>-        DeferredWrapperSet& deferredWrappers() { return m_deferredWrappers; }
>+        DOMDeferredPromiseSet& deferredPromises() { return m_deferredPromises; }
> 
>         ScriptExecutionContext* scriptExecutionContext() const;
> 
>@@ -91,7 +91,7 @@ namespace WebCore {
>     protected:
>         JSDOMStructureMap m_structures;
>         JSDOMConstructorMap m_constructors;
>-        DeferredWrapperSet m_deferredWrappers;
>+        DOMDeferredPromiseSet m_deferredPromises;
> 
>         Event* m_currentEvent;
>         Ref<DOMWrapperWorld> m_world;
>diff --git a/Source/WebCore/bindings/js/JSDOMPromise.cpp b/Source/WebCore/bindings/js/JSDOMPromise.cpp
>index 5c129c8ee610cd0522cea8499c8d2ac28ac88f60..3128ba979ad649a1505f98c219397fecbb7f2c9e 100644
>--- a/Source/WebCore/bindings/js/JSDOMPromise.cpp
>+++ b/Source/WebCore/bindings/js/JSDOMPromise.cpp
>@@ -35,41 +35,41 @@ using namespace JSC;
> 
> namespace WebCore {
> 
>-DeferredWrapper::DeferredWrapper(ExecState*, JSDOMGlobalObject* globalObject, JSPromiseDeferred* promiseDeferred)
>-    : ActiveDOMCallback(globalObject->scriptExecutionContext())
>-    , m_deferred(promiseDeferred)
>-    , m_globalObject(globalObject)
>+DOMDeferredPromise::DOMDeferredPromise(JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
>+    : ActiveDOMCallback(globalObject.scriptExecutionContext())
>+    , m_deferred(&promiseDeferred)
>+    , m_globalObject(&globalObject)
> {
>-    globalObject->vm().heap.writeBarrier(globalObject, promiseDeferred);
>-    m_globalObject->deferredWrappers().add(this);
>+    globalObject.vm().heap.writeBarrier(&globalObject, &promiseDeferred);
>+    globalObject.deferredPromises().add(this);
> }
> 
>-DeferredWrapper::~DeferredWrapper()
>+DOMDeferredPromise::~DOMDeferredPromise()
> {
>     clear();
> }
> 
>-void DeferredWrapper::clear()
>+void DOMDeferredPromise::clear()
> {
>     ASSERT(!m_deferred || m_globalObject);
>     if (m_deferred && m_globalObject)
>-        m_globalObject->deferredWrappers().remove(this);
>+        m_globalObject->deferredPromises().remove(this);
>     m_deferred.clear();
> }
> 
>-void DeferredWrapper::contextDestroyed()
>+void DOMDeferredPromise::contextDestroyed()
> {
>     ActiveDOMCallback::contextDestroyed();
>     clear();
> }
> 
>-JSC::JSValue DeferredWrapper::promise() const
>+JSC::JSValue DOMDeferredPromise::promise() const
> {
>     ASSERT(m_deferred);
>     return m_deferred->promise();
> }
> 
>-void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue resolution)
>+void DOMDeferredPromise::callFunction(ExecState& exec, JSValue function, JSValue resolution)
> {
>     if (!canInvokeCallback())
>         return;
>@@ -86,7 +86,7 @@ void DeferredWrapper::callFunction(ExecState& exec, JSValue function, JSValue re
>     clear();
> }
> 
>-void DeferredWrapper::reject(ExceptionCode ec, const String& message)
>+void DOMDeferredPromise::reject(ExceptionCode ec, const String& message)
> {
>     if (isSuspended())
>         return;
>@@ -109,7 +109,7 @@ void rejectPromiseWithExceptionIfAny(JSC::ExecState& state, JSDOMGlobalObject& g
>     JSValue error = scope.exception()->value();
>     scope.clearException();
> 
>-    DeferredWrapper::create(&state, &globalObject, &promiseDeferred)->reject(error);
>+    DOMDeferredPromise::create(globalObject, promiseDeferred)->reject(error);
> }
> 
> static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data)
>@@ -118,7 +118,7 @@ static inline JSC::JSValue parseAsJSON(JSC::ExecState* state, const String& data
>     return JSC::JSONParse(state, data);
> }
> 
>-void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data)
>+void fulfillPromiseWithJSON(Ref<DOMDeferredPromise>&& promise, const String& data)
> {
>     JSC::JSValue value = parseAsJSON(promise->globalObject()->globalExec(), data);
>     if (!value)
>@@ -127,7 +127,7 @@ void fulfillPromiseWithJSON(Ref<DeferredWrapper>&& promise, const String& data)
>         promise->resolve(value);
> }
> 
>-void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer* arrayBuffer)
>+void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&& promise, ArrayBuffer* arrayBuffer)
> {
>     if (!arrayBuffer) {
>         promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));
>@@ -136,7 +136,7 @@ void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, ArrayBuffer*
>     promise->resolve(arrayBuffer);
> }
> 
>-void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&& promise, const void* data, size_t length)
>+void fulfillPromiseWithArrayBuffer(Ref<DOMDeferredPromise>&& promise, const void* data, size_t length)
> {
>     fulfillPromiseWithArrayBuffer(WTFMove(promise), ArrayBuffer::tryCreate(data, length).get());
> }
>diff --git a/Source/WebCore/bindings/js/JSDOMPromise.h b/Source/WebCore/bindings/js/JSDOMPromise.h
>index 54d68c7f4694e0c7f4974a3acfbe6b0dbd857f2a..2691222ecc8b1a0fb6b758151caee244135d94a2 100644
>--- a/Source/WebCore/bindings/js/JSDOMPromise.h
>+++ b/Source/WebCore/bindings/js/JSDOMPromise.h
>@@ -96,15 +96,22 @@ struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DO
>     static constexpr bool passByConstRef = false;
> };
> 
>-class DeferredWrapper : public RefCounted<DeferredWrapper>, public ActiveDOMCallback {
>+class DOMDeferredPromise : public RefCounted<DOMDeferredPromise>, public ActiveDOMCallback {
> public:
>-    // FIXME: We should pass references here, not pointers, see bug 161787
>-    static Ref<DeferredWrapper> create(JSC::ExecState* state, JSDOMGlobalObject* globalObject, JSC::JSPromiseDeferred* deferred)
>+    static Ref<DOMDeferredPromise> create(JSC::ExecState& state, JSDOMGlobalObject& globalObject)
>     {
>-        return adoptRef(*new DeferredWrapper(state, globalObject, deferred));
>+        JSC::JSPromiseDeferred* deferred = JSC::JSPromiseDeferred::create(&state, &globalObject);
>+        // deferred can only be null in workers.
>+        ASSERT(deferred);
>+        return adoptRef(*new DOMDeferredPromise(globalObject, *deferred));
>     }
> 
>-    ~DeferredWrapper();
>+    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); }
>@@ -136,7 +143,7 @@ public:
>     void visitAggregate(JSC::SlotVisitor& visitor) { visitor.appendUnbarrieredWeak(&m_deferred); }
> 
> private:
>-    DeferredWrapper(JSC::ExecState*, JSDOMGlobalObject*, JSC::JSPromiseDeferred*);
>+    DOMDeferredPromise(JSDOMGlobalObject&, JSC::JSPromiseDeferred&);
> 
>     void clear();
>     void contextDestroyed() override;
>@@ -152,12 +159,12 @@ private:
>     JSC::Weak<JSDOMGlobalObject> m_globalObject;
> };
> 
>-void fulfillPromiseWithJSON(Ref<DeferredWrapper>&&, const String&);
>-void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, ArrayBuffer*);
>-void fulfillPromiseWithArrayBuffer(Ref<DeferredWrapper>&&, const void*, size_t);
>+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<DeferredWrapper>&&))
>+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);
>@@ -169,7 +176,7 @@ inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSVal
>     if (!promiseDeferred)
>         return JSC::jsUndefined();
> 
>-    promiseFunction(&state, DeferredWrapper::create(&state, &globalObject, promiseDeferred));
>+    promiseFunction(&state, DOMDeferredPromise::create(globalObject, *promiseDeferred));
> 
>     rejectPromiseWithExceptionIfAny(state, globalObject, *promiseDeferred);
>     ASSERT_UNUSED(scope, !scope.exception());
>@@ -180,7 +187,7 @@ inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSVal
> template <typename Value>
> class DOMPromise {
> public:
>-    DOMPromise(Ref<DeferredWrapper>&& wrapper)
>+    DOMPromise(Ref<DOMDeferredPromise>&& wrapper)
>         : m_wrapper(WTFMove(wrapper))
>     {
>     }
>@@ -194,14 +201,14 @@ public:
> 
>     template<typename... ErrorType> void reject(ErrorType&&... error) { m_wrapper->reject(std::forward<ErrorType>(error)...); }
> 
>-    DeferredWrapper& deferredWrapper() { return m_wrapper; }
>+    DOMDeferredPromise& deferredPromise() { return m_wrapper; }
> 
> private:
>-    Ref<DeferredWrapper> m_wrapper;
>+    Ref<DOMDeferredPromise> m_wrapper;
> };
> 
> template<class ResolveResultType>
>-inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
>+inline void DOMDeferredPromise::resolveWithValue(ResolveResultType&& result)
> {
>     if (isSuspended())
>         return;
>@@ -212,7 +219,7 @@ inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
> }
> 
> template<class ResolveResultType>
>-inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
>+inline void DOMDeferredPromise::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
> {
>     if (isSuspended())
>         return;
>@@ -224,7 +231,7 @@ inline void DeferredWrapper::resolveWithNewlyCreated(Ref<ResolveResultType>&& re
> }
> 
> template<class RejectResultType>
>-inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
>+inline void DOMDeferredPromise::rejectWithValue(RejectResultType&& result)
> {
>     if (isSuspended())
>         return;
>@@ -236,7 +243,7 @@ inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
> }
> 
> template<>
>-inline void DeferredWrapper::resolve(bool result)
>+inline void DOMDeferredPromise::resolve(bool result)
> {
>     if (isSuspended())
>         return;
>@@ -248,7 +255,7 @@ inline void DeferredWrapper::resolve(bool result)
> }
> 
> template<>
>-inline void DeferredWrapper::resolve(JSC::JSValue value)
>+inline void DOMDeferredPromise::resolve(JSC::JSValue value)
> {
>     if (isSuspended())
>         return;
>@@ -260,7 +267,7 @@ inline void DeferredWrapper::resolve(JSC::JSValue value)
> }
> 
> template<>
>-inline void DeferredWrapper::reject(JSC::JSValue value)
>+inline void DOMDeferredPromise::reject(JSC::JSValue value)
> {
>     if (isSuspended())
>         return;
>@@ -272,7 +279,7 @@ inline void DeferredWrapper::reject(JSC::JSValue value)
> }
> 
> template<>
>-inline void DeferredWrapper::resolve(std::nullptr_t)
>+inline void DOMDeferredPromise::resolve(std::nullptr_t)
> {
>     if (isSuspended())
>         return;
>@@ -284,7 +291,7 @@ inline void DeferredWrapper::resolve(std::nullptr_t)
> }
> 
> template<>
>-inline void DeferredWrapper::reject(std::nullptr_t)
>+inline void DOMDeferredPromise::reject(std::nullptr_t)
> {
>     if (isSuspended())
>         return;
>@@ -296,7 +303,7 @@ inline void DeferredWrapper::reject(std::nullptr_t)
> }
> 
> template<>
>-inline void DeferredWrapper::resolve(const String& result)
>+inline void DOMDeferredPromise::resolve(const String& result)
> {
>     if (isSuspended())
>         return;
>@@ -308,7 +315,7 @@ inline void DeferredWrapper::resolve(const String& result)
> }
> 
> template<>
>-inline void DeferredWrapper::reject(const String& result)
>+inline void DOMDeferredPromise::reject(const String& result)
> {
>     if (isSuspended())
>         return;
>diff --git a/Source/WebCore/bindings/js/JSFontFaceCustom.cpp b/Source/WebCore/bindings/js/JSFontFaceCustom.cpp
>index b741e5366b7f976e832482bc4cf20086f6826b8c..2f3b9d50c92b0f7deb5007fde85b19bd1e36cd85 100644
>--- a/Source/WebCore/bindings/js/JSFontFaceCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSFontFaceCustom.cpp
>@@ -39,11 +39,12 @@ JSC::JSValue JSFontFace::loaded(JSC::ExecState& state) const
> {
>     if (!m_loaded) {
>         if (!wrapped().promise()) {
>-            Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));
>+            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().deferredWrapper().promise());
>+            m_loaded.set(state.vm(), this, wrapped().promise().value().deferredPromise().promise());
>     }
>     return m_loaded.get();
> }
>diff --git a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp b/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp
>index 2870b486d24c286d923eeecf4ea65fe62cc8091a..d5e8bdcaccdb37bb8545e6fea4d2289858f30b21 100644
>--- a/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSFontFaceSetCustom.cpp
>@@ -34,7 +34,8 @@ namespace WebCore {
> JSC::JSValue JSFontFaceSet::ready(JSC::ExecState& state) const
> {
>     if (!m_ready) {
>-        Ref<DeferredWrapper> promise = DeferredWrapper::create(&state, globalObject(), JSC::JSPromiseDeferred::create(&state, globalObject()));
>+        ASSERT(globalObject());
>+        auto promise = DOMDeferredPromise::create(state, *globalObject());
>         m_ready.set(state.vm(), this, promise->promise());
>         wrapped().registerReady(WTFMove(promise));
>     }
>diff --git a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp b/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp
>index 4ce613ae13a95cdfda5461462127f8c05081e7ef..65dfd8b5f4072e420520b7249c97474797a734d2 100644
>--- a/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSMediaDevicesCustom.cpp
>@@ -374,10 +374,14 @@ JSValue JSMediaDevices::getUserMedia(ExecState& state)
> 
>     auto audioConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryAudioConstraints), WTFMove(advancedAudioConstraints), areAudioConstraintsValid);
>     auto videoConstraints = MediaConstraintsImpl::create(WTFMove(mandatoryVideoConstraints), WTFMove(advancedVideoConstraints), areVideoConstraintsValid);
>-    JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
>-    wrapped().getUserMedia(WTFMove(audioConstraints), WTFMove(videoConstraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred), ec);
>+
>+    ASSERT(globalObject());
>+    auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
>+    auto promise = deferredPromise->promise();
>+
>+    wrapped().getUserMedia(WTFMove(audioConstraints), WTFMove(videoConstraints), WTFMove(deferredPromise), ec);
>     setDOMException(&state, ec);
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> }
>diff --git a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp b/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp
>index fdf66a7d0c38013402a5d2a0aebf7eb1fa295a26..834adce4c6b56a0cd3ef49e953693b63db384c66 100644
>--- a/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSMediaStreamTrackCustom.cpp
>@@ -184,11 +184,14 @@ JSValue JSMediaStreamTrack::applyConstraints(ExecState& state)
>         valid = !advancedConstraints.isEmpty() || !mandatoryConstraints.isEmpty();
>     }
> 
>-    JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
>+    ASSERT(globalObject());
>+    auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
>+    auto promise = deferredPromise->promise();
>+
>     auto constraints = MediaConstraintsImpl::create(WTFMove(mandatoryConstraints), WTFMove(advancedConstraints), valid);
>-    wrapped().applyConstraints(WTFMove(constraints), DeferredWrapper::create(&state, globalObject(), promiseDeferred));
>+    wrapped().applyConstraints(WTFMove(constraints), WTFMove(deferredPromise));
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSMediaStreamTrack::getConstraints(ExecState& state)
>diff --git a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp b/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp
>index 39a73f53748d10267012989605c7d532b8b10852..8fdcdc44c06ab31cd22b59f607d2a5e3ad60959a 100644
>--- a/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSReadableStreamSourceCustom.cpp
>@@ -43,9 +43,12 @@ JSValue JSReadableStreamSource::start(ExecState& state)
>     JSReadableStreamSource* jsSource = const_cast<JSReadableStreamSource*>(this);
>     m_controller.set(state.vm(), jsSource, state.argument(0));
> 
>-    JSC::JSPromiseDeferred* promiseDeferred = JSC::JSPromiseDeferred::create(&state, globalObject());
>-    wrapped().start(ReadableStreamDefaultController(controller), DeferredWrapper::create(&state, globalObject(), promiseDeferred));
>-    return promiseDeferred->promise();
>+    ASSERT(globalObject());
>+    auto deferredPromise = DOMDeferredPromise::create(state, *globalObject());
>+    auto promise = deferredPromise->promise();
>+
>+    wrapped().start(ReadableStreamDefaultController(controller), WTFMove(deferredPromise));
>+    return promise;
> }
> 
> JSValue JSReadableStreamSource::controller(ExecState&) const
>diff --git a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp b/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp
>index ca9e14b8b6646dd64a84a9293e6f9b89e93fb8c4..802b1e0ff906ab60445c1cfc3c8b89b84817daf4 100644
>--- a/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp
>+++ b/Source/WebCore/bindings/js/JSWebKitSubtleCryptoCustom.cpp
>@@ -173,9 +173,9 @@ JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state)
>     if (!success)
>         return jsUndefined();
> 
>-    
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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());
>     };
>@@ -190,7 +190,7 @@ JSValue JSWebKitSubtleCrypto::encrypt(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)
>@@ -227,8 +227,9 @@ JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)
>     if (!success)
>         return jsUndefined();
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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());
>     };
>@@ -243,7 +244,7 @@ JSValue JSWebKitSubtleCrypto::decrypt(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
>@@ -280,8 +281,9 @@ JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
>     if (!success)
>         return jsUndefined();
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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());
>     };
>@@ -296,7 +298,7 @@ JSValue JSWebKitSubtleCrypto::sign(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
>@@ -339,8 +341,9 @@ JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
>     if (!success)
>         return jsUndefined();
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    ASSERT(globalObject());
>+    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
>+    auto promise = wrapper->promise();
>     auto successCallback = [wrapper](bool result) mutable {
>         wrapper->resolve(result);
>     };
>@@ -355,7 +358,7 @@ JSValue JSWebKitSubtleCrypto::verify(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
>@@ -382,8 +385,9 @@ JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
>     if (!success)
>         return jsUndefined();
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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());
>     };
>@@ -398,7 +402,7 @@ JSValue JSWebKitSubtleCrypto::digest(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)
>@@ -434,8 +438,9 @@ JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)
>             return jsUndefined();
>     }
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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);
>@@ -455,7 +460,7 @@ JSValue JSWebKitSubtleCrypto::generateKey(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    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)
>@@ -570,8 +575,9 @@ JSValue JSWebKitSubtleCrypto::importKey(ExecState& state)
>             return jsUndefined();
>     }
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    ASSERT(globalObject());
>+    RefPtr<DOMDeferredPromise> wrapper = DOMDeferredPromise::create(state, *globalObject());
>+    auto promise = wrapper->promise();
>     auto successCallback = [wrapper](CryptoKey& result) mutable {
>         wrapper->resolve(result);
>     };
>@@ -583,7 +589,7 @@ JSValue JSWebKitSubtleCrypto::importKey(ExecState& state)
>     if (UNLIKELY(scope.exception()))
>         return jsUndefined();
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> static void exportKey(ExecState& state, CryptoKeyFormat keyFormat, const CryptoKey& key, CryptoAlgorithm::VectorCallback callback, CryptoAlgorithm::VoidCallback failureCallback)
>@@ -639,8 +645,9 @@ JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state)
>     if (!key)
>         return throwTypeError(&state, scope);
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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());
>     };
>@@ -652,7 +659,7 @@ JSValue JSWebKitSubtleCrypto::exportKey(ExecState& state)
>     if (UNLIKELY(scope.exception()))
>         return jsUndefined();
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
>@@ -693,8 +700,9 @@ JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
>     if (!parameters)
>         return jsUndefined();
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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 {
>@@ -722,7 +730,7 @@ JSValue JSWebKitSubtleCrypto::wrapKey(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)
>@@ -793,8 +801,9 @@ JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)
>             return jsUndefined();
>     }
> 
>-    JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
>-    RefPtr<DeferredWrapper> wrapper = DeferredWrapper::create(&state, globalObject(), promiseDeferred);
>+    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 {
>@@ -828,7 +837,7 @@ JSValue JSWebKitSubtleCrypto::unwrapKey(ExecState& state)
>         return jsUndefined();
>     }
> 
>-    return promiseDeferred->promise();
>+    return promise;
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm b/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
>index ddd650dfe94018e82a317054a23a1e404c37bf77..26bddb522da7559a2a53fc197af6e0178afd39fa 100644
>--- a/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
>+++ b/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
>@@ -3409,13 +3409,13 @@ sub GenerateImplementation
>                 AddToImplIncludes("JSDOMPromise.h");
> 
>                 push(@implContent, <<END);
>-static EncodedJSValue ${functionName}Promise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue ${functionName}Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> END
>             }
>             else {
>@@ -4122,7 +4122,7 @@ sub GenerateReturnParameters
>     my @arguments;
> 
>     if (IsReturningPromise($function)) {
>-        push(@arguments, "WTFMove(deferredWrapper)");
>+        push(@arguments, "WTFMove(deferredPromise)");
>     }
>     push(@arguments, "ec") if $function->signature->extendedAttributes->{"RaisesException"} || $function->signature->extendedAttributes->{"RaisesExceptionWithMessage"};
>     return @arguments;
>diff --git a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp b/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
>index 6dbadecdc1496b06c7cdf1fe213c1d2291a8826b..ae340ceb4f54a6564b0dd23ad2a00ee87506ffe8 100644
>--- a/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
>+++ b/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
>@@ -7157,13 +7157,13 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionAny(ExecState* state)
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7174,17 +7174,17 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionPromis
>         return throwThisTypeError(*state, throwScope, "TestObject", "testPromiseFunction");
>     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
>     auto& impl = castedThis->wrapped();
>-    impl.testPromiseFunction(WTFMove(deferredWrapper));
>+    impl.testPromiseFunction(WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFloatArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7200,17 +7200,17 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithFl
>     auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
>     if (UNLIKELY(throwScope.exception()))
>         return JSValue::encode(jsUndefined());
>-    impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredWrapper));
>+    impl.testPromiseFunctionWithFloatArgument(WTFMove(a), WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithExceptionPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7222,18 +7222,18 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithEx
>     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
>     auto& impl = castedThis->wrapped();
>     ExceptionCode ec = 0;
>-    impl.testPromiseFunctionWithException(WTFMove(deferredWrapper), ec);
>+    impl.testPromiseFunctionWithException(WTFMove(deferredPromise), ec);
>     setDOMException(state, ec);
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOptionalIntArgumentPromise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7247,17 +7247,17 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseFunctionWithOp
>     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(deferredWrapper));
>+    impl.testPromiseFunctionWithOptionalIntArgument(WTFMove(a), WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction1Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7273,17 +7273,17 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc
>     auto a = convert<float>(*state, state->argument(0), ShouldAllowNonFinite::No);
>     if (UNLIKELY(throwScope.exception()))
>         return JSValue::encode(jsUndefined());
>-    impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredWrapper));
>+    impl.testPromiseOverloadedFunction(WTFMove(a), WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunction2Promise(ExecState* state, Ref<DOMDeferredPromise>&&  deferredPromise)
> {
>     VM& vm = state->vm();
>     auto throwScope = DECLARE_THROW_SCOPE(vm);
>@@ -7299,7 +7299,7 @@ static inline EncodedJSValue jsTestObjPrototypeFunctionTestPromiseOverloadedFunc
>     auto request = JSFetchRequest::toWrapped(state->argument(0));
>     if (UNLIKELY(!request))
>         return throwArgumentTypeError(*state, throwScope, 0, "request", "TestObject", "testPromiseOverloadedFunction", "FetchRequest");
>-    impl.testPromiseOverloadedFunction(*request, WTFMove(deferredWrapper));
>+    impl.testPromiseOverloadedFunction(*request, WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>@@ -7320,34 +7320,34 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionTestPromiseOverloadedFunc
>     return argsCount < 1 ? throwVMError(state, throwScope, createNotEnoughArgumentsError(state)) : throwVMTypeError(state, throwScope);
> }
> 
>-static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+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(deferredWrapper));
>+    TestObj::testStaticPromiseFunction(WTFMove(deferredPromise));
>     return JSValue::encode(jsUndefined());
> }
> 
>-static EncodedJSValue jsTestObjConstructorFunctionTestStaticPromiseFunctionWithExceptionPromise(ExecState*, Ref<DeferredWrapper>&&);
>+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<DeferredWrapper>&&  deferredWrapper)
>+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(deferredWrapper), ec);
>+    TestObj::testStaticPromiseFunctionWithException(WTFMove(deferredPromise), ec);
>     setDOMException(state, ec);
>     return JSValue::encode(jsUndefined());
> }
>diff --git a/Source/WebCore/dom/CustomElementRegistry.h b/Source/WebCore/dom/CustomElementRegistry.h
>index 5761a474cf1608efd6fb552451d37c2c0cf5d3d4..ed9ada0cc6a4230e186d1c6490d23c0d4528deb4 100644
>--- a/Source/WebCore/dom/CustomElementRegistry.h
>+++ b/Source/WebCore/dom/CustomElementRegistry.h
>@@ -44,7 +44,7 @@ namespace WebCore {
> 
> class CustomElementRegistry;
> class DOMWindow;
>-class DeferredWrapper;
>+class DOMDeferredPromise;
> class Element;
> class JSCustomElementInterface;
> class QualifiedName;
>@@ -66,7 +66,7 @@ public:
> 
>     JSC::JSValue get(const AtomicString&);
> 
>-    HashMap<AtomicString, Ref<DeferredWrapper>>& promiseMap() { return m_promiseMap; }
>+    HashMap<AtomicString, Ref<DOMDeferredPromise>>& promiseMap() { return m_promiseMap; }
> 
> private:
>     CustomElementRegistry(DOMWindow&);
>@@ -74,7 +74,7 @@ private:
>     DOMWindow& m_window;
>     HashMap<AtomicString, Ref<JSCustomElementInterface>> m_nameMap;
>     HashMap<const JSC::JSObject*, JSCustomElementInterface*> m_constructorMap;
>-    HashMap<AtomicString, Ref<DeferredWrapper>> m_promiseMap;
>+    HashMap<AtomicString, Ref<DOMDeferredPromise>> m_promiseMap;
> 
>     bool m_elementDefinitionIsRunning { false };
>

Flags:

buildbot: commit-queue-

Actions: View | Formatted Diff | Diff

Attachments on bug 161787: 288784 | 288790 | 288791 | 288792 | 288808 | 288809 | 288810 | 288811 | 288816 | 289058 | 289061 | 289063 | 289439 | 289526