Unreviewed, rolling out r200837.
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 May 2016 19:19:01 +0000 (19:19 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 May 2016 19:19:01 +0000 (19:19 +0000)
Seems to have regressed Speedometer and JetStream on iOS

Reverted changeset:

"DOMPromise should only restrict the resolution type"
https://bugs.webkit.org/show_bug.cgi?id=157307
http://trac.webkit.org/changeset/200837

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@200875 268f45cc-cd09-0410-ab3c-d52691b4dbfc

22 files changed:
Source/WTF/ChangeLog
Source/WTF/wtf/Ref.h
Source/WTF/wtf/RefPtr.h
Source/WebCore/ChangeLog
Source/WebCore/Modules/fetch/FetchBody.cpp
Source/WebCore/Modules/fetch/FetchBody.h
Source/WebCore/Modules/fetch/FetchBodyOwner.cpp
Source/WebCore/Modules/fetch/FetchResponse.cpp
Source/WebCore/Modules/fetch/FetchResponse.h
Source/WebCore/Modules/mediastream/MediaDevices.h
Source/WebCore/Modules/mediastream/PeerConnectionBackend.h
Source/WebCore/Modules/mediastream/UserMediaRequest.cpp
Source/WebCore/Modules/streams/ReadableStreamSource.h
Source/WebCore/Modules/webaudio/AudioContext.h
Source/WebCore/bindings/js/JSDOMBinding.h
Source/WebCore/bindings/js/JSDOMPromise.cpp
Source/WebCore/bindings/js/JSDOMPromise.h
Source/WebCore/bindings/js/JSSubtleCryptoCustom.cpp
Source/WebCore/css/FontFace.h
Source/WebCore/css/FontFaceSet.cpp
Source/WebCore/css/FontFaceSet.h
Source/WebCore/html/HTMLMediaElement.h

index 0e355b8..ffb66ad 100644 (file)
@@ -1,3 +1,15 @@
+2016-05-13  Chris Dumez  <cdumez@apple.com>
+
+        Unreviewed, rolling out r200837.
+
+        Seems to have regressed Speedometer and JetStream on iOS
+
+        Reverted changeset:
+
+        "DOMPromise should only restrict the resolution type"
+        https://bugs.webkit.org/show_bug.cgi?id=157307
+        http://trac.webkit.org/changeset/200837
+
 2016-05-13  Beth Dakin  <bdakin@apple.com>
 
         Add dyldSPI.h
index 4a7288e..50a5e76 100644 (file)
@@ -46,8 +46,6 @@ template<typename T> Ref<T> adoptRef(T&);
 
 template<typename T> class Ref {
 public:
-    static constexpr bool isRef = true;
-
     ~Ref()
     {
 #if ASAN_ENABLED
index ed51ee6..ca446f4 100644 (file)
@@ -39,8 +39,6 @@ public:
     typedef T ValueType;
     typedef ValueType* PtrType;
 
-    static constexpr bool isRefPtr = true;
-
     ALWAYS_INLINE RefPtr() : m_ptr(nullptr) { }
     ALWAYS_INLINE RefPtr(T* ptr) : m_ptr(ptr) { refIfNotNull(ptr); }
     ALWAYS_INLINE RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { refIfNotNull(m_ptr); }
index 473eed5..b9802de 100644 (file)
@@ -1,3 +1,15 @@
+2016-05-13  Chris Dumez  <cdumez@apple.com>
+
+        Unreviewed, rolling out r200837.
+
+        Seems to have regressed Speedometer and JetStream on iOS
+
+        Reverted changeset:
+
+        "DOMPromise should only restrict the resolution type"
+        https://bugs.webkit.org/show_bug.cgi?id=157307
+        http://trac.webkit.org/changeset/200837
+
 2016-05-13  Sam Weinig  <sam@webkit.org>
 
         Rename WKDataDetectorTypeSpotlightSuggestion to WKDataDetectorTypeLookupSuggestion
index 46ac45d..10a11f1 100644 (file)
@@ -43,7 +43,7 @@
 
 namespace WebCore {
 
-static Ref<Blob> blobFromArrayBuffer(ArrayBuffer*, const String&);
+static RefPtr<Blob> blobFromArrayBuffer(ArrayBuffer*, const String&);
 
 FetchBody::FetchBody(Ref<Blob>&& blob)
     : m_type(Type::Blob)
@@ -141,7 +141,7 @@ void FetchBody::consume(FetchBodyOwner& owner, Consumer::Type type, DeferredWrap
     }
 
     // FIXME: Support other types.
-    promise.reject(0);
+    promise.reject<ExceptionCode>(0);
 }
 
 #if ENABLE(STREAMS_API)
@@ -200,7 +200,7 @@ void FetchBody::consumeText(Consumer::Type type, DeferredWrapper& promise)
         return;
     }
     String contentType = Blob::normalizedContentType(extractMIMETypeFromMediaType(m_mimeType));
-    promise.resolve(Blob::create(extractFromText(), contentType));
+    promise.resolve<RefPtr<Blob>>(Blob::create(extractFromText(), contentType));
 }
 
 FetchLoader::Type FetchBody::loadingType(Consumer::Type type)
@@ -236,7 +236,7 @@ Vector<uint8_t> FetchBody::extractFromText() const
     return value;
 }
 
-static inline Ref<Blob> blobFromArrayBuffer(ArrayBuffer* buffer, const String& contentType)
+static inline RefPtr<Blob> blobFromArrayBuffer(ArrayBuffer* buffer, const String& contentType)
 {
     if (!buffer)
         return Blob::create(Vector<uint8_t>(), contentType);
@@ -259,7 +259,7 @@ void FetchBody::fulfillTextPromise(FetchBody::Consumer::Type type, const String&
 void FetchBody::loadingFailed()
 {
     ASSERT(m_consumer);
-    m_consumer->promise.reject(0);
+    m_consumer->promise.reject<ExceptionCode>(0);
     m_consumer = Nullopt;
 }
 
index 56f3dfd..046010a 100644 (file)
@@ -53,7 +53,7 @@ public:
     void blob(FetchBodyOwner&, DeferredWrapper&&);
     void json(FetchBodyOwner&, DeferredWrapper&&);
     void text(FetchBodyOwner&, DeferredWrapper&&);
-    void formData(FetchBodyOwner&, DeferredWrapper&& promise) { promise.reject(0); }
+    void formData(FetchBodyOwner&, DeferredWrapper&& promise) { promise.reject<ExceptionCode>(0); }
 
 #if ENABLE(STREAMS_API)
     void consumeAsStream(FetchBodyOwner&, FetchResponseSource&);
index 96c04c3..caf4ac8 100644 (file)
@@ -75,7 +75,7 @@ void FetchBodyOwner::arrayBuffer(DeferredWrapper&& promise)
         return;
     }
     if (isDisturbed()) {
-        promise.reject(TypeError);
+        promise.reject<ExceptionCode>(TypeError);
         return;
     }
     m_isDisturbed = true;
@@ -85,11 +85,11 @@ void FetchBodyOwner::arrayBuffer(DeferredWrapper&& promise)
 void FetchBodyOwner::blob(DeferredWrapper&& promise)
 {
     if (m_body.isEmpty()) {
-        promise.resolve(Blob::create());
+        promise.resolve<RefPtr<Blob>>(Blob::create());
         return;
     }
     if (isDisturbed()) {
-        promise.reject(TypeError);
+        promise.reject<ExceptionCode>(TypeError);
         return;
     }
     m_isDisturbed = true;
@@ -99,11 +99,11 @@ void FetchBodyOwner::blob(DeferredWrapper&& promise)
 void FetchBodyOwner::formData(DeferredWrapper&& promise)
 {
     if (m_body.isEmpty()) {
-        promise.reject(0);
+        promise.reject<ExceptionCode>(0);
         return;
     }
     if (isDisturbed()) {
-        promise.reject(TypeError);
+        promise.reject<ExceptionCode>(TypeError);
         return;
     }
     m_isDisturbed = true;
@@ -113,11 +113,11 @@ void FetchBodyOwner::formData(DeferredWrapper&& promise)
 void FetchBodyOwner::json(DeferredWrapper&& promise)
 {
     if (m_body.isEmpty()) {
-        promise.reject(SYNTAX_ERR);
+        promise.reject<ExceptionCode>(SYNTAX_ERR);
         return;
     }
     if (isDisturbed()) {
-        promise.reject(TypeError);
+        promise.reject<ExceptionCode>(TypeError);
         return;
     }
     m_isDisturbed = true;
@@ -131,7 +131,7 @@ void FetchBodyOwner::text(DeferredWrapper&& promise)
         return;
     }
     if (isDisturbed()) {
-        promise.reject(TypeError);
+        promise.reject<ExceptionCode>(TypeError);
         return;
     }
     m_isDisturbed = true;
index 7c9b9e6..35be243 100644 (file)
@@ -213,7 +213,7 @@ void FetchResponse::BodyLoader::didReceiveResponse(const ResourceResponse& resou
     m_response.m_response = resourceResponse;
     m_response.m_headers->filterAndFill(resourceResponse.httpHeaderFields(), FetchHeaders::Guard::Response);
 
-    std::exchange(m_promise, Nullopt)->resolve(m_response);
+    std::exchange(m_promise, Nullopt)->resolve(&m_response);
 }
 
 void FetchResponse::BodyLoader::didReceiveData(const char* data, size_t size)
index ed24711..7e48b03 100644 (file)
@@ -54,7 +54,7 @@ public:
     static Ref<FetchResponse> error(ScriptExecutionContext&);
     static RefPtr<FetchResponse> redirect(ScriptExecutionContext&, const String&, int, ExceptionCode&);
 
-    using FetchPromise = DOMPromise<FetchResponse>;
+    using FetchPromise = DOMPromise<RefPtr<FetchResponse>, ExceptionCode>;
     static void fetch(ScriptExecutionContext&, FetchRequest&, const Dictionary&, FetchPromise&&);
     static void fetch(ScriptExecutionContext&, const String&, const Dictionary&, FetchPromise&&);
 
index c48d860..702272d 100644 (file)
@@ -58,8 +58,8 @@ public:
 
     Document* document() const;
 
-    typedef DOMPromise<MediaStream> Promise;
-    typedef DOMPromise<MediaDeviceInfoVector> EnumerateDevicesPromise;
+    typedef DOMPromise<RefPtr<MediaStream>, RefPtr<NavigatorUserMediaError>> Promise;
+    typedef DOMPromise<MediaDeviceInfoVector, ExceptionCode> EnumerateDevicesPromise;
 
     void getUserMedia(const Dictionary&, Promise&&, ExceptionCode&) const;
     void enumerateDevices(EnumerateDevicesPromise&&, ExceptionCode&) const;
index bfff44e..50de930 100644 (file)
@@ -53,9 +53,9 @@ class RTCStatsResponse;
 class ScriptExecutionContext;
 
 namespace PeerConnection {
-typedef DOMPromise<RTCSessionDescription> SessionDescriptionPromise;
-typedef DOMPromise<std::nullptr_t> VoidPromise;
-typedef DOMPromise<RTCStatsResponse> StatsPromise;
+typedef DOMPromise<RefPtr<RTCSessionDescription>, RefPtr<DOMError>> SessionDescriptionPromise;
+typedef DOMPromise<std::nullptr_t, RefPtr<DOMError>> VoidPromise;
+typedef DOMPromise<RefPtr<RTCStatsResponse>, RefPtr<DOMError>> StatsPromise;
 }
 
 class PeerConnectionBackendClient {
index 9ce4198..73b149b 100644 (file)
@@ -172,7 +172,7 @@ void UserMediaRequest::didCreateStream(PassRefPtr<MediaStreamPrivate> privateStr
         return;
 
     // 4 - Create the MediaStream and pass it to the success callback.
-    Ref<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
+    RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
     if (m_audioConstraints) {
         for (auto& track : stream->getAudioTracks()) {
             track->applyConstraints(*m_audioConstraints);
index 087b45c..0fd16f3 100644 (file)
@@ -44,7 +44,7 @@ class ReadableStreamSource : public RefCounted<ReadableStreamSource> {
 public:
     virtual ~ReadableStreamSource() { }
 
-    typedef DOMPromise<std::nullptr_t> Promise;
+    typedef DOMPromise<std::nullptr_t, ExceptionCode> Promise;
 
     void start(ReadableStreamController&&, Promise&&);
     void cancel(JSC::JSValue);
index 16b2b3c..858f647 100644 (file)
@@ -109,7 +109,7 @@ public:
     using ActiveDOMObject::suspend;
     using ActiveDOMObject::resume;
 
-    typedef DOMPromise<std::nullptr_t> Promise;
+    typedef DOMPromise<std::nullptr_t, ExceptionCode> Promise;
 
     void suspend(Promise&&);
     void resume(Promise&&);
index 86b7437..b88f060 100644 (file)
@@ -251,10 +251,10 @@ JSC::JSObject* toJSSequence(JSC::ExecState*, JSC::JSValue, unsigned& length);
 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, JSC::ArrayBuffer*);
 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, JSC::ArrayBufferView*);
 JSC::JSValue toJS(JSC::ExecState*, JSC::JSGlobalObject*, JSC::ArrayBufferView*);
-template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&);
-template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&&);
-template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&);
-template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&&);
+template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const RefPtr<T>&);
+template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Ref<T>&);
+template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, const RefPtr<T>&);
+template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, const Ref<T>&);
 template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Vector<T>&);
 template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Vector<RefPtr<T>>&);
 JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const String&);
@@ -269,7 +269,7 @@ template<typename T, size_t inlineCapacity> JSC::JSValue jsArray(JSC::ExecState*
 WEBCORE_EXPORT JSC::JSValue jsArray(JSC::ExecState*, JSDOMGlobalObject*, PassRefPtr<DOMStringList>);
 
 JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, JSC::JSValue, JSC::JSValue);
-template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, FirstType&, SecondType&);
+template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, const FirstType&, const SecondType&);
 
 RefPtr<JSC::ArrayBufferView> toArrayBufferView(JSC::JSValue);
 RefPtr<JSC::Int8Array> toInt8Array(JSC::JSValue);
@@ -542,12 +542,7 @@ inline JSC::JSValue toJS(JSC::ExecState* exec, JSC::JSGlobalObject* globalObject
     return view->wrap(exec, globalObject);
 }
 
-template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>& ptr)
-{
-    return toJS(exec, globalObject, ptr.get());
-}
-
-template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>&& ptr)
+template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const RefPtr<T>& ptr)
 {
     return toJS(exec, globalObject, ptr.get());
 }
@@ -557,14 +552,14 @@ template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalO
     return toJS(exec, globalObject, const_cast<T&>(ptr.get()));
 }
 
-template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>&& ptr)
+template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const RefPtr<T>& ptr)
 {
     return toJSNewlyCreated(exec, globalObject, ptr.get());
 }
 
-template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>& ptr)
+template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const Ref<T>& ptr)
 {
-    return toJSNewlyCreated(exec, globalObject, ptr.get());
+    return toJSNewlyCreated(exec, globalObject, const_cast<T&>(ptr.get()));
 }
 
 template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const Vector<T>& vector)
@@ -661,7 +656,7 @@ inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObjec
     return constructArray(&state, 0, globalObject, args);
 }
 
-template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, FirstType& value1, SecondType& value2)
+template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, const FirstType& value1, const SecondType& value2)
 {
     return jsPair(state, globalObject, toJS(&state, globalObject, value1), toJS(&state, globalObject, value2));
 }
index a214b87..896f849 100644 (file)
@@ -88,7 +88,7 @@ void fulfillPromiseWithJSON(DeferredWrapper& promise, const String& data)
 {
     JSC::JSValue value = parseAsJSON(promise.globalObject().globalExec(), data);
     if (!value)
-        promise.reject(SYNTAX_ERR);
+        promise.reject<ExceptionCode>(SYNTAX_ERR);
     else
         promise.resolve(value);
 }
index dd0211c..fb51b72 100644 (file)
 
 namespace WebCore {
 
-template<typename DOMClass>
-struct TypeInspector {
-private:
-    template<typename T> static constexpr auto testIsVector(int) -> decltype(std::declval<T>().shrinkToFit(), bool()) { return true; }
-    template<typename T> static constexpr bool testIsVector(...) { return false; }
-
-    template<typename T> static constexpr auto testIsRef(int) -> decltype(T::isRef) { return true; }
-    template<typename T> static constexpr bool testIsRef(...) { return false; }
-
-    template<typename T> static constexpr auto testIsRefPtr(int) -> decltype(T::isRefPtr) { return true; }
-    template<typename T> static constexpr bool testIsRefPtr(...) { return false; }
-
-public:
-    static constexpr bool isRefOrRefPtr = testIsRef<DOMClass>(0) || testIsRefPtr<DOMClass>(0);
-    static constexpr bool isPassByValueType = std::is_pointer<DOMClass>::value
-        || std::is_same<DOMClass, std::nullptr_t>::value
-        || std::is_same<DOMClass, JSC::JSValue>::value
-        || std::is_same<DOMClass, bool>::value;
-    static constexpr bool isPassByConstRefType = testIsVector<DOMClass>(0)
-        || std::is_same<DOMClass, String>::value;
-};
-
-template<typename DOMClass, typename Enable = void>
-struct PromiseResultInspector {
-public:
-    static constexpr bool passByValue = false;
-    static constexpr bool passByRef = true;
-    static constexpr bool passByURef = false;
-    static constexpr bool passByConstRef = false;
-
-    typedef DOMClass& Type;
-};
-
-template<typename DOMClass>
-struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByValueType>::type> {
-public:
-    static constexpr bool passByValue = true;
-    static constexpr bool passByRef = false;
-    static constexpr bool passByURef = false;
-    static constexpr bool passByConstRef = false;
-
-    typedef DOMClass Type;
-};
-
-template<typename DOMClass>
-struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByConstRefType>::type> {
-public:
-    static constexpr bool passByValue = false;
-    static constexpr bool passByRef = false;
-    static constexpr bool passByURef = false;
-    static constexpr bool passByConstRef = true;
-
-    typedef const DOMClass& Type;
-};
-
-template<typename DOMClass>
-struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isRefOrRefPtr>::type> {
-    static constexpr bool passByValue = false;
-    static constexpr bool passByRef = false;
-    static constexpr bool passByURef = true;
-    static constexpr bool passByConstRef = false;
-};
-
 class DeferredWrapper {
 public:
     DeferredWrapper(JSC::ExecState*, JSDOMGlobalObject*, JSC::JSPromiseDeferred*);
 
-    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
-    resolve(ResolveResultType result) { resolveWithValue(result); }
-    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByRef, void>::type
-    resolve(ResolveResultType& result) { resolveWithValue(result); }
-    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByURef, void>::type
-    resolve(ResolveResultType&& result) { resolveWithValue(std::forward<ResolveResultType>(result)); }
-    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByConstRef, void>::type
-    resolve(const ResolveResultType& result) { resolveWithValue(result); }
-
-    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByValue, void>::type
-    reject(RejectResultType result) { rejectWithValue(result); }
-    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByRef, void>::type
-    reject(RejectResultType& result) { rejectWithValue(result); }
-    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByURef, void>::type
-    reject(RejectResultType&& result) { rejectWithValue(std::forward<RejectResultType>(result)); }
-    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByConstRef, void>::type
-    reject(const RejectResultType& result) { rejectWithValue(result); }
+    template<class ResolveResultType>
+    void resolve(const ResolveResultType&);
 
-    void reject(ExceptionCode);
+    template<class RejectResultType>
+    void reject(const RejectResultType&);
 
     JSDOMGlobalObject& globalObject() const;
     JSC::JSValue promise() const;
@@ -128,9 +51,6 @@ private:
     void resolve(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->resolve(), resolution); }
     void reject(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->reject(), resolution); }
 
-    template<class RejectResultType> void rejectWithValue(RejectResultType&&);
-    template<class ResolveResultType> void resolveWithValue(ResolveResultType&&);
-
     JSC::Strong<JSDOMGlobalObject> m_globalObject;
     JSC::Strong<JSC::JSPromiseDeferred> m_deferred;
 };
@@ -151,7 +71,7 @@ inline JSC::JSValue callPromiseFunction(JSC::ExecState& state, JSC::EncodedJSVal
     return promiseDeferred.promise();
 }
 
-template <typename Value>
+template <typename Value, typename Error>
 class DOMPromise {
 public:
     DOMPromise(DeferredWrapper&& wrapper) : m_wrapper(WTFMove(wrapper)) { }
@@ -160,105 +80,105 @@ public:
     DOMPromise(const DOMPromise&) = default;
     DOMPromise& operator=(DOMPromise const&) = default;
 
-    void resolve(typename PromiseResultInspector<Value>::Type value) { m_wrapper.resolve(value); }
-
-    template<typename ErrorType> void reject(ErrorType&& error) { m_wrapper.reject(std::forward<ErrorType>(error)); }
+    void resolve(const Value& value) { m_wrapper.resolve<Value>(value); }
+    void reject(const Error& error) { m_wrapper.reject<Error>(error); }
 
 private:
     DeferredWrapper m_wrapper;
 };
 
-inline void DeferredWrapper::reject(ExceptionCode ec)
+template<class ResolveResultType>
+inline void DeferredWrapper::resolve(const ResolveResultType& result)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    reject(*exec, createDOMException(exec, ec));
+    resolve(*exec, toJS(exec, m_globalObject.get(), result));
 }
 
-template<class ResolveResultType>
-inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
+template<class RejectResultType>
+inline void DeferredWrapper::reject(const RejectResultType& result)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    resolve(*exec, toJS(exec, m_globalObject.get(), std::forward<ResolveResultType>(result)));
+    reject(*exec, toJS(exec, m_globalObject.get(), result));
 }
 
-template<class RejectResultType>
-inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
+template<>
+inline void DeferredWrapper::reject(const std::nullptr_t&)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    reject(*exec, toJS(exec, m_globalObject.get(), std::forward<RejectResultType>(result)));
+    reject(*exec, JSC::jsNull());
 }
 
 template<>
-inline void DeferredWrapper::resolve(bool result)
+inline void DeferredWrapper::reject(const JSC::JSValue& value)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    resolve(*exec, JSC::jsBoolean(result));
+    reject(*exec, value);
 }
 
 template<>
-inline void DeferredWrapper::resolve(JSC::JSValue value)
+inline void DeferredWrapper::reject<ExceptionCode>(const ExceptionCode& ec)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    resolve(*exec, value);
+    reject(*exec, createDOMException(exec, ec));
 }
 
 template<>
-inline void DeferredWrapper::reject(JSC::JSValue value)
+inline void DeferredWrapper::resolve<String>(const String& result)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    reject(*exec, value);
+    resolve(*exec, jsString(exec, result));
 }
 
 template<>
-inline void DeferredWrapper::resolve(std::nullptr_t)
+inline void DeferredWrapper::resolve<bool>(const bool& result)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    resolve(*exec, JSC::jsUndefined());
+    resolve(*exec, JSC::jsBoolean(result));
 }
 
 template<>
-inline void DeferredWrapper::reject(std::nullptr_t)
+inline void DeferredWrapper::resolve<JSC::JSValue>(const JSC::JSValue& value)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    reject(*exec, JSC::jsNull());
+    resolve(*exec, value);
 }
 
 template<>
-inline void DeferredWrapper::resolve(const String& result)
+inline void DeferredWrapper::resolve(const std::nullptr_t&)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
     JSC::ExecState* exec = m_globalObject->globalExec();
     JSC::JSLockHolder locker(exec);
-    resolve(*exec, jsString(exec, result));
+    resolve(*exec, JSC::jsUndefined());
 }
 
 template<>
-inline void DeferredWrapper::reject(const String& result)
+inline void DeferredWrapper::reject<String>(const String& result)
 {
     ASSERT(m_deferred);
     ASSERT(m_globalObject);
index 8c6d88a..4fa6782 100644 (file)
@@ -550,7 +550,7 @@ JSValue JSSubtleCrypto::importKey(ExecState& state)
     JSPromiseDeferred* promiseDeferred = JSPromiseDeferred::create(&state, globalObject());
     DeferredWrapper wrapper(&state, globalObject(), promiseDeferred);
     auto successCallback = [wrapper](CryptoKey& result) mutable {
-        wrapper.resolve(result);
+        wrapper.resolve(&result);
     };
     auto failureCallback = [wrapper]() mutable {
         wrapper.reject(nullptr);
@@ -785,7 +785,7 @@ JSValue JSSubtleCrypto::unwrapKey(ExecState& state)
 
     auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithmPtr, unwrappedKeyAlgorithmParametersPtr, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {
         auto importSuccessCallback = [wrapper](CryptoKey& key) mutable {
-            wrapper.resolve(key);
+            wrapper.resolve(&key);
         };
         auto importFailureCallback = [wrapper]() mutable {
             wrapper.reject(nullptr);
index e24934d..8971ef1 100644 (file)
@@ -65,7 +65,7 @@ public:
     enum class LoadStatus { Unloaded, Loading, Loaded, Error };
     LoadStatus status() const;
 
-    typedef DOMPromise<FontFace&> Promise;
+    typedef DOMPromise<FontFace&, ExceptionCode> Promise;
     void registerLoaded(Promise&&);
 
     void load();
index 189e5bd..7e74498 100644 (file)
@@ -83,7 +83,7 @@ RefPtr<FontFace> FontFaceSet::Iterator::next()
     return m_target->backing()[m_index++].wrapper();
 }
 
-FontFaceSet::PendingPromise::PendingPromise(LoadPromise&& promise)
+FontFaceSet::PendingPromise::PendingPromise(Promise&& promise)
     : promise(WTFMove(promise))
 {
 }
@@ -123,7 +123,7 @@ void FontFaceSet::clear()
         m_backing->remove(m_backing.get()[0]);
 }
 
-void FontFaceSet::load(const String& font, const String& text, LoadPromise&& promise)
+void FontFaceSet::load(const String& font, const String& text, DeferredWrapper&& promise)
 {
     ExceptionCode ec = 0;
     auto matchingFaces = m_backing->matchingFaces(font, text, ec);
@@ -142,7 +142,7 @@ void FontFaceSet::load(const String& font, const String& text, LoadPromise&& pro
 
     for (auto& face : matchingFaces) {
         if (face.get().status() == CSSFontFace::Status::Failure) {
-            promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)));
+            promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)).ptr());
             return;
         }
     }
@@ -167,7 +167,7 @@ bool FontFaceSet::check(const String& family, const String& text, ExceptionCode&
     return m_backing->check(family, text, ec);
 }
 
-void FontFaceSet::registerReady(ReadyPromise&& promise)
+void FontFaceSet::registerReady(Promise&& promise)
 {
     ASSERT(!m_promise);
     if (m_isReady) {
index 89ad08d..f0470e9 100644 (file)
@@ -47,15 +47,14 @@ public:
     bool remove(FontFace&);
     void clear();
 
-    typedef DOMPromise<Vector<RefPtr<FontFace>>> LoadPromise;
-    void load(const String& font, const String& text, LoadPromise&&);
+    void load(const String& font, const String& text, DeferredWrapper&& promise);
     bool check(const String& font, const String& text, ExceptionCode&);
 
     enum class LoadStatus { Loading, Loaded };
     LoadStatus status() const;
 
-    typedef DOMPromise<FontFaceSet&> ReadyPromise;
-    void registerReady(ReadyPromise&&);
+    typedef DOMPromise<FontFaceSet&, DOMCoreException&> Promise;
+    void registerReady(Promise&&);
 
     CSSFontFaceSet& backing() { return m_backing; }
 
@@ -75,18 +74,19 @@ public:
 
 private:
     struct PendingPromise : RefCounted<PendingPromise> {
-        static Ref<PendingPromise> create(LoadPromise&& promise)
+        typedef DOMPromise<Vector<RefPtr<FontFace>>&, DOMCoreException&> Promise;
+        static Ref<PendingPromise> create(Promise&& promise)
         {
             return adoptRef(*new PendingPromise(WTFMove(promise)));
         }
         ~PendingPromise();
 
     private:
-        PendingPromise(LoadPromise&&);
+        PendingPromise(Promise&&);
 
     public:
         Vector<RefPtr<FontFace>> faces;
-        LoadPromise promise;
+        Promise promise;
         bool hasReachedTerminalState { false };
     };
 
@@ -110,7 +110,7 @@ private:
 
     Ref<CSSFontFaceSet> m_backing;
     HashMap<RefPtr<CSSFontFace>, Vector<Ref<PendingPromise>>> m_pendingPromises;
-    Optional<ReadyPromise> m_promise;
+    Optional<Promise> m_promise;
     bool m_isReady { false };
 };
 
index c84193b..b431b0c 100644 (file)
@@ -212,7 +212,7 @@ public:
     bool loop() const;
     void setLoop(bool b);
 
-    typedef DOMPromise<std::nullptr_t> PlayPromise;
+    typedef DOMPromise<std::nullptr_t, DOMError&> PlayPromise;
     void play(PlayPromise&&);
 
     WEBCORE_EXPORT void play() override;