Changeset 200766 in webkit


Ignore:
Timestamp:
May 12, 2016, 2:36:00 AM (9 years ago)
Author:
youenn.fablet@crf.canon.fr
Message:

DOMPromise should only restrict the resolution type
​https://bugs.webkit.org/show_bug.cgi?id=157307

Reviewed by Darin Adler.

Removing from DOMPromise the rejection template parameter.
Supported rejection types are integers (Exception codes) and DOM objects (DOMError typically).

Updated toJS and DeferredWrapper to accept Ref<>&& and RefPtr<>&&.
Previously Ref<>&& were not accepted and only "const RefPtr<>&" was accepted.
This in turn created an unecessary churn count when calling toJS.

Changes also allow in most cases to remove the need for explictly declaring the
rejection/resolution type.

Minor refactoring of FontFaceSet promise handling to use DOMPromise in lieu of DeferredWrapper.

Covered by existing tests.
Changes should not be visible from user scripts.

  • Modules/fetch/FetchBody.cpp:

(WebCore::FetchBody::consume):
(WebCore::FetchBody::consumeText):
(WebCore::blobFromArrayBuffer):
(WebCore::FetchBody::loadingFailed):

  • Modules/fetch/FetchBody.h:

(WebCore::FetchBody::formData):

  • Modules/fetch/FetchBodyOwner.cpp:

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

  • Modules/fetch/FetchResponse.cpp:

(WebCore::FetchResponse::BodyLoader::didReceiveResponse):

  • Modules/fetch/FetchResponse.h:
  • Modules/mediastream/MediaDevices.h:
  • Modules/mediastream/PeerConnectionBackend.h:
  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::didCreateStream):

  • Modules/streams/ReadableStreamSource.h:
  • Modules/webaudio/AudioContext.h:
  • bindings/js/JSDOMBinding.h:

(WebCore::toJS):
(WebCore::jsPair):

  • bindings/js/JSDOMPromise.cpp:

(WebCore::fulfillPromiseWithJSON):

  • bindings/js/JSDOMPromise.h:

(WebCore::TypeInspector::decltype):
(WebCore::TypeInspector::testIsVector):
(WebCore::TypeInspector::testIsRefOrRefPtr):
(WebCore::DeferredWrapper::resolve):
(WebCore::DeferredWrapper::reject):
(WebCore::DOMPromise::resolve):
(WebCore::DOMPromise::reject):
(WebCore::DeferredWrapper::resolveWithValue):
(WebCore::DeferredWrapper::rejectWithValue):
(WebCore::callPromiseFunction):

  • bindings/js/JSSubtleCryptoCustom.cpp:

(WebCore::JSSubtleCrypto::importKey):
(WebCore::JSSubtleCrypto::unwrapKey):

  • css/FontFace.h:
  • css/FontFaceSet.cpp:

(WebCore::FontFaceSet::PendingPromise::PendingPromise):
(WebCore::FontFaceSet::load):
(WebCore::FontFaceSet::registerReady):

  • css/FontFaceSet.h:
  • html/HTMLMediaElement.h:
Location:
trunk/Source/WebCore
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r200755 r200766  
     12016-05-12  Youenn Fablet  <youenn.fablet@crf.canon.fr>
     2
     3        DOMPromise should only restrict the resolution type
     4        https://bugs.webkit.org/show_bug.cgi?id=157307
     5
     6        Reviewed by Darin Adler.
     7
     8        Removing from DOMPromise the rejection template parameter.
     9        Supported rejection types are integers (Exception codes) and DOM objects (DOMError typically).
     10
     11        Updated toJS and DeferredWrapper to accept Ref<>&& and RefPtr<>&&.
     12        Previously Ref<>&& were not accepted and only "const RefPtr<>&" was accepted.
     13        This in turn created an unecessary churn count when calling toJS.
     14
     15        Changes also allow in most cases to remove the need for explictly declaring the
     16        rejection/resolution type.
     17
     18        Minor refactoring of FontFaceSet promise handling to use DOMPromise in lieu of DeferredWrapper.
     19
     20        Covered by existing tests.
     21        Changes should not be visible from user scripts.
     22
     23        * Modules/fetch/FetchBody.cpp:
     24        (WebCore::FetchBody::consume):
     25        (WebCore::FetchBody::consumeText):
     26        (WebCore::blobFromArrayBuffer):
     27        (WebCore::FetchBody::loadingFailed):
     28        * Modules/fetch/FetchBody.h:
     29        (WebCore::FetchBody::formData):
     30        * Modules/fetch/FetchBodyOwner.cpp:
     31        (WebCore::FetchBodyOwner::arrayBuffer):
     32        (WebCore::FetchBodyOwner::blob):
     33        (WebCore::FetchBodyOwner::formData):
     34        (WebCore::FetchBodyOwner::json):
     35        (WebCore::FetchBodyOwner::text):
     36        * Modules/fetch/FetchResponse.cpp:
     37        (WebCore::FetchResponse::BodyLoader::didReceiveResponse):
     38        * Modules/fetch/FetchResponse.h:
     39        * Modules/mediastream/MediaDevices.h:
     40        * Modules/mediastream/PeerConnectionBackend.h:
     41        * Modules/mediastream/UserMediaRequest.cpp:
     42        (WebCore::UserMediaRequest::didCreateStream):
     43        * Modules/streams/ReadableStreamSource.h:
     44        * Modules/webaudio/AudioContext.h:
     45        * bindings/js/JSDOMBinding.h:
     46        (WebCore::toJS):
     47        (WebCore::jsPair):
     48        * bindings/js/JSDOMPromise.cpp:
     49        (WebCore::fulfillPromiseWithJSON):
     50        * bindings/js/JSDOMPromise.h:
     51        (WebCore::TypeInspector::decltype):
     52        (WebCore::TypeInspector::testIsVector):
     53        (WebCore::TypeInspector::testIsRefOrRefPtr):
     54        (WebCore::DeferredWrapper::resolve):
     55        (WebCore::DeferredWrapper::reject):
     56        (WebCore::DOMPromise::resolve):
     57        (WebCore::DOMPromise::reject):
     58        (WebCore::DeferredWrapper::resolveWithValue):
     59        (WebCore::DeferredWrapper::rejectWithValue):
     60        (WebCore::callPromiseFunction):
     61        * bindings/js/JSSubtleCryptoCustom.cpp:
     62        (WebCore::JSSubtleCrypto::importKey):
     63        (WebCore::JSSubtleCrypto::unwrapKey):
     64        * css/FontFace.h:
     65        * css/FontFaceSet.cpp:
     66        (WebCore::FontFaceSet::PendingPromise::PendingPromise):
     67        (WebCore::FontFaceSet::load):
     68        (WebCore::FontFaceSet::registerReady):
     69        * css/FontFaceSet.h:
     70        * html/HTMLMediaElement.h:
     71
    1722016-05-12  Manuel Rego Casasnovas  <rego@igalia.com>
    273

  • trunk/Source/WebCore/Modules/fetch/FetchBody.cpp

    r199641 r200766  
    4444namespace WebCore {
    4545
    46 static RefPtr<Blob> blobFromArrayBuffer(ArrayBuffer*, const String&);
     46static Ref<Blob> blobFromArrayBuffer(ArrayBuffer*, const String&);
    4747
    4848FetchBody::FetchBody(Ref<Blob>&& blob)
    … …  
    142142
    143143    // FIXME: Support other types.
    144     promise.reject<ExceptionCode>(0);
     144    promise.reject(0);
    145145}
    146146
    … …  
    201201    }
    202202    String contentType = Blob::normalizedContentType(extractMIMETypeFromMediaType(m_mimeType));
    203     promise.resolve<RefPtr<Blob>>(Blob::create(extractFromText(), contentType));
     203    promise.resolve(Blob::create(extractFromText(), contentType));
    204204}
    205205
    … …  
    237237}
    238238
    239 static inline RefPtr<Blob> blobFromArrayBuffer(ArrayBuffer* buffer, const String& contentType)
     239static inline Ref<Blob> blobFromArrayBuffer(ArrayBuffer* buffer, const String& contentType)
    240240{
    241241    if (!buffer)
    … …  
    260260{
    261261    ASSERT(m_consumer);
    262     m_consumer->promise.reject<ExceptionCode>(0);
     262    m_consumer->promise.reject(0);
    263263    m_consumer = Nullopt;
    264264}

  • trunk/Source/WebCore/Modules/fetch/FetchBody.h

    r199641 r200766  
    5454    void json(FetchBodyOwner&, DeferredWrapper&&);
    5555    void text(FetchBodyOwner&, DeferredWrapper&&);
    56     void formData(FetchBodyOwner&, DeferredWrapper&& promise) { promise.reject<ExceptionCode>(0); }
     56    void formData(FetchBodyOwner&, DeferredWrapper&& promise) { promise.reject(0); }
    5757
    5858#if ENABLE(STREAMS_API)

  • trunk/Source/WebCore/Modules/fetch/FetchBodyOwner.cpp

    r199641 r200766  
    7676    }
    7777    if (isDisturbed()) {
    78         promise.reject<ExceptionCode>(TypeError);
     78        promise.reject(TypeError);
    7979        return;
    8080    }
    … …  
    8686{
    8787    if (m_body.isEmpty()) {
    88         promise.resolve<RefPtr<Blob>>(Blob::create());
    89         return;
    90     }
    91     if (isDisturbed()) {
    92         promise.reject<ExceptionCode>(TypeError);
     88        promise.resolve(Blob::create());
     89        return;
     90    }
     91    if (isDisturbed()) {
     92        promise.reject(TypeError);
    9393        return;
    9494    }
    … …  
    100100{
    101101    if (m_body.isEmpty()) {
    102         promise.reject<ExceptionCode>(0);
    103         return;
    104     }
    105     if (isDisturbed()) {
    106         promise.reject<ExceptionCode>(TypeError);
     102        promise.reject(0);
     103        return;
     104    }
     105    if (isDisturbed()) {
     106        promise.reject(TypeError);
    107107        return;
    108108    }
    … …  
    114114{
    115115    if (m_body.isEmpty()) {
    116         promise.reject<ExceptionCode>(SYNTAX_ERR);
    117         return;
    118     }
    119     if (isDisturbed()) {
    120         promise.reject<ExceptionCode>(TypeError);
     116        promise.reject(SYNTAX_ERR);
     117        return;
     118    }
     119    if (isDisturbed()) {
     120        promise.reject(TypeError);
    121121        return;
    122122    }
    … …  
    132132    }
    133133    if (isDisturbed()) {
    134         promise.reject<ExceptionCode>(TypeError);
     134        promise.reject(TypeError);
    135135        return;
    136136    }

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.cpp

    r200361 r200766  
    214214    m_response.m_headers->filterAndFill(resourceResponse.httpHeaderFields(), FetchHeaders::Guard::Response);
    215215
    216     std::exchange(m_promise, Nullopt)->resolve(&m_response);
     216    std::exchange(m_promise, Nullopt)->resolve(m_response);
    217217}
    218218

  • trunk/Source/WebCore/Modules/fetch/FetchResponse.h

    r200361 r200766  
    5555    static RefPtr<FetchResponse> redirect(ScriptExecutionContext&, const String&, int, ExceptionCode&);
    5656
    57     using FetchPromise = DOMPromise<RefPtr<FetchResponse>, ExceptionCode>;
     57    using FetchPromise = DOMPromise<FetchResponse>;
    5858    static void fetch(ScriptExecutionContext&, FetchRequest&, const Dictionary&, FetchPromise&&);
    5959    static void fetch(ScriptExecutionContext&, const String&, const Dictionary&, FetchPromise&&);

  • trunk/Source/WebCore/Modules/mediastream/MediaDevices.h

    r192746 r200766  
    5959    Document* document() const;
    6060
    61     typedef DOMPromise<RefPtr<MediaStream>, RefPtr<NavigatorUserMediaError>> Promise;
    62     typedef DOMPromise<MediaDeviceInfoVector, ExceptionCode> EnumerateDevicesPromise;
     61    typedef DOMPromise<MediaStream> Promise;
     62    typedef DOMPromise<MediaDeviceInfoVector> EnumerateDevicesPromise;
    6363
    6464    void getUserMedia(const Dictionary&, Promise&&, ExceptionCode&) const;

  • trunk/Source/WebCore/Modules/mediastream/PeerConnectionBackend.h

    r198492 r200766  
    5454
    5555namespace PeerConnection {
    56 typedef DOMPromise<RefPtr<RTCSessionDescription>, RefPtr<DOMError>> SessionDescriptionPromise;
    57 typedef DOMPromise<std::nullptr_t, RefPtr<DOMError>> VoidPromise;
    58 typedef DOMPromise<RefPtr<RTCStatsResponse>, RefPtr<DOMError>> StatsPromise;
     56typedef DOMPromise<RTCSessionDescription> SessionDescriptionPromise;
     57typedef DOMPromise<std::nullptr_t> VoidPromise;
     58typedef DOMPromise<RTCStatsResponse> StatsPromise;
    5959}
    6060

  • trunk/Source/WebCore/Modules/mediastream/UserMediaRequest.cpp

    r198082 r200766  
    173173
    174174    // 4 - Create the MediaStream and pass it to the success callback.
    175     RefPtr<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
     175    Ref<MediaStream> stream = MediaStream::create(*m_scriptExecutionContext, privateStream);
    176176    if (m_audioConstraints) {
    177177        for (auto& track : stream->getAudioTracks()) {

  • trunk/Source/WebCore/Modules/streams/ReadableStreamSource.h

    r199704 r200766  
    4545    virtual ~ReadableStreamSource() { }
    4646
    47     typedef DOMPromise<std::nullptr_t, ExceptionCode> Promise;
     47    typedef DOMPromise<std::nullptr_t> Promise;
    4848
    4949    void start(ReadableStreamController&&, Promise&&);

  • trunk/Source/WebCore/Modules/webaudio/AudioContext.h

    r200361 r200766  
    110110    using ActiveDOMObject::resume;
    111111
    112     typedef DOMPromise<std::nullptr_t, ExceptionCode> Promise;
     112    typedef DOMPromise<std::nullptr_t> Promise;
    113113
    114114    void suspend(Promise&&);

  • trunk/Source/WebCore/bindings/js/JSDOMBinding.h

    r200619 r200766  
    252252JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, JSC::ArrayBufferView*);
    253253JSC::JSValue toJS(JSC::ExecState*, JSC::JSGlobalObject*, JSC::ArrayBufferView*);
    254 template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>);
     254template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&);
     255template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&&);
    255256template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, PassRefPtr<T>);
    256257template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Vector<T>&);
    … …  
    268269
    269270JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, JSC::JSValue, JSC::JSValue);
    270 template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, const FirstType&, const SecondType&);
     271template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, FirstType&, SecondType&);
    271272
    272273RefPtr<JSC::ArrayBufferView> toArrayBufferView(JSC::JSValue);
    … …  
    541542}
    542543
    543 template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T> ptr)
     544template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>& ptr)
     545{
     546    return toJS(exec, globalObject, ptr.get());
     547}
     548
     549template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>&& ptr)
    544550{
    545551    return toJS(exec, globalObject, ptr.get());
    … …  
    645651}
    646652
    647 template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, const FirstType& value1, const SecondType& value2)
     653template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, FirstType& value1, SecondType& value2)
    648654{
    649655    return jsPair(state, globalObject, toJS(&state, globalObject, value1), toJS(&state, globalObject, value2));

  • trunk/Source/WebCore/bindings/js/JSDOMPromise.cpp

    r200546 r200766  
    8989    JSC::JSValue value = parseAsJSON(promise.globalObject().globalExec(), data);
    9090    if (!value)
    91         promise.reject<ExceptionCode>(SYNTAX_ERR);
     91        promise.reject(SYNTAX_ERR);
    9292    else
    9393        promise.resolve(value);

  • trunk/Source/WebCore/bindings/js/JSDOMPromise.h

    r200546 r200766  
    3434namespace WebCore {
    3535
     36template<typename DOMClass>
     37struct TypeInspector {
     38private:
     39    template<typename T> static constexpr auto testIsVector(int) -> decltype(std::declval<T>().shrinkToFit(), bool()) { return true; }
     40    template<typename T> static constexpr bool testIsVector(...) { return false; }
     41
     42    template<typename T> static constexpr auto testIsRefOrRefPtr(int) -> decltype(std::declval<T>().leakRef(), bool()) { return true; }
     43    template<typename T> static constexpr bool testIsRefOrRefPtr(...) { return false; }
     44
     45public:
     46    static constexpr bool isRefOrRefPtr = testIsRefOrRefPtr<DOMClass>(0);
     47    static constexpr bool isPassByValueType = std::is_pointer<DOMClass>::value
     48        || std::is_same<DOMClass, std::nullptr_t>::value
     49        || std::is_same<DOMClass, JSC::JSValue>::value
     50        || std::is_same<DOMClass, bool>::value;
     51    static constexpr bool isPassByConstRefType = testIsVector<DOMClass>(0)
     52        || std::is_same<DOMClass, String>::value;
     53};
     54
     55template<typename DOMClass, typename Enable = void>
     56struct PromiseResultInspector {
     57public:
     58    static constexpr bool passByValue = false;
     59    static constexpr bool passByRef = true;
     60    static constexpr bool passByURef = false;
     61    static constexpr bool passByConstRef = false;
     62
     63    typedef DOMClass& Type;
     64};
     65
     66template<typename DOMClass>
     67struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByValueType>::type> {
     68public:
     69    static constexpr bool passByValue = true;
     70    static constexpr bool passByRef = false;
     71    static constexpr bool passByURef = false;
     72    static constexpr bool passByConstRef = false;
     73
     74    typedef DOMClass Type;
     75};
     76
     77template<typename DOMClass>
     78struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByConstRefType>::type> {
     79public:
     80    static constexpr bool passByValue = false;
     81    static constexpr bool passByRef = false;
     82    static constexpr bool passByURef = false;
     83    static constexpr bool passByConstRef = true;
     84
     85    typedef const DOMClass& Type;
     86};
     87
     88template<typename DOMClass>
     89struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isRefOrRefPtr>::type> {
     90    static constexpr bool passByValue = false;
     91    static constexpr bool passByRef = false;
     92    static constexpr bool passByURef = true;
     93    static constexpr bool passByConstRef = false;
     94};
     95
    3696class DeferredWrapper {
    3797public:
    3898    DeferredWrapper(JSC::ExecState*, JSDOMGlobalObject*, JSC::JSPromiseDeferred*);
    3999
    40     template<class ResolveResultType>
    41     void resolve(const ResolveResultType&);
    42 
    43     template<class RejectResultType>
    44     void reject(const RejectResultType&);
     100    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
     101    resolve(ResolveResultType result) { resolveWithValue(result); }
     102    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByRef, void>::type
     103    resolve(ResolveResultType& result) { resolveWithValue(result); }
     104    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByURef, void>::type
     105    resolve(ResolveResultType&& result) { resolveWithValue(std::forward<ResolveResultType>(result)); }
     106    template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByConstRef, void>::type
     107    resolve(const ResolveResultType& result) { resolveWithValue(result); }
     108
     109    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByValue, void>::type
     110    reject(RejectResultType result) { rejectWithValue(result); }
     111    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByRef, void>::type
     112    reject(RejectResultType& result) { rejectWithValue(result); }
     113    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByURef, void>::type
     114    reject(RejectResultType&& result) { rejectWithValue(std::forward<RejectResultType>(result)); }
     115    template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByConstRef, void>::type
     116    reject(const RejectResultType& result) { rejectWithValue(result); }
     117
     118    void reject(ExceptionCode);
    45119
    46120    JSDOMGlobalObject& globalObject() const;
    … …  
    52126    void reject(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->reject(), resolution); }
    53127
     128    template<class RejectResultType> void rejectWithValue(RejectResultType&&);
     129    template<class ResolveResultType> void resolveWithValue(ResolveResultType&&);
     130
    54131    JSC::Strong<JSDOMGlobalObject> m_globalObject;
    55132    JSC::Strong<JSC::JSPromiseDeferred> m_deferred;
    … …  
    72149}
    73150
    74 template <typename Value, typename Error>
     151template <typename Value>
    75152class DOMPromise {
    76153public:
    … …  
    81158    DOMPromise& operator=(DOMPromise const&) = default;
    82159
    83     void resolve(const Value& value) { m_wrapper.resolve<Value>(value); }
    84     void reject(const Error& error) { m_wrapper.reject<Error>(error); }
     160    void resolve(typename PromiseResultInspector<Value>::Type value) { m_wrapper.resolve(value); }
     161
     162    template<typename ErrorType> void reject(ErrorType&& error) { m_wrapper.reject(std::forward<ErrorType>(error)); }
    85163
    86164private:
    … …  
    88166};
    89167
     168inline void DeferredWrapper::reject(ExceptionCode ec)
     169{
     170    ASSERT(m_deferred);
     171    ASSERT(m_globalObject);
     172    JSC::ExecState* exec = m_globalObject->globalExec();
     173    JSC::JSLockHolder locker(exec);
     174    reject(*exec, createDOMException(exec, ec));
     175}
     176
    90177template<class ResolveResultType>
    91 inline void DeferredWrapper::resolve(const ResolveResultType& result)
    92 {
    93     ASSERT(m_deferred);
    94     ASSERT(m_globalObject);
    95     JSC::ExecState* exec = m_globalObject->globalExec();
    96     JSC::JSLockHolder locker(exec);
    97     resolve(*exec, toJS(exec, m_globalObject.get(), result));
     178inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
     179{
     180    ASSERT(m_deferred);
     181    ASSERT(m_globalObject);
     182    JSC::ExecState* exec = m_globalObject->globalExec();
     183    JSC::JSLockHolder locker(exec);
     184    resolve(*exec, toJS(exec, m_globalObject.get(), std::forward<ResolveResultType>(result)));
    98185}
    99186
    100187template<class RejectResultType>
    101 inline void DeferredWrapper::reject(const RejectResultType& result)
    102 {
    103     ASSERT(m_deferred);
    104     ASSERT(m_globalObject);
    105     JSC::ExecState* exec = m_globalObject->globalExec();
    106     JSC::JSLockHolder locker(exec);
    107     reject(*exec, toJS(exec, m_globalObject.get(), result));
    108 }
    109 
    110 template<>
    111 inline void DeferredWrapper::reject(const std::nullptr_t&)
     188inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
     189{
     190    ASSERT(m_deferred);
     191    ASSERT(m_globalObject);
     192    JSC::ExecState* exec = m_globalObject->globalExec();
     193    JSC::JSLockHolder locker(exec);
     194    reject(*exec, toJS(exec, m_globalObject.get(), std::forward<RejectResultType>(result)));
     195}
     196
     197template<>
     198inline void DeferredWrapper::resolve(bool result)
     199{
     200    ASSERT(m_deferred);
     201    ASSERT(m_globalObject);
     202    JSC::ExecState* exec = m_globalObject->globalExec();
     203    JSC::JSLockHolder locker(exec);
     204    resolve(*exec, JSC::jsBoolean(result));
     205}
     206
     207template<>
     208inline void DeferredWrapper::resolve(JSC::JSValue value)
     209{
     210    ASSERT(m_deferred);
     211    ASSERT(m_globalObject);
     212    JSC::ExecState* exec = m_globalObject->globalExec();
     213    JSC::JSLockHolder locker(exec);
     214    resolve(*exec, value);
     215}
     216
     217template<>
     218inline void DeferredWrapper::reject(JSC::JSValue value)
     219{
     220    ASSERT(m_deferred);
     221    ASSERT(m_globalObject);
     222    JSC::ExecState* exec = m_globalObject->globalExec();
     223    JSC::JSLockHolder locker(exec);
     224    reject(*exec, value);
     225}
     226
     227template<>
     228inline void DeferredWrapper::resolve(std::nullptr_t)
     229{
     230    ASSERT(m_deferred);
     231    ASSERT(m_globalObject);
     232    JSC::ExecState* exec = m_globalObject->globalExec();
     233    JSC::JSLockHolder locker(exec);
     234    resolve(*exec, JSC::jsUndefined());
     235}
     236
     237template<>
     238inline void DeferredWrapper::reject(std::nullptr_t)
    112239{
    113240    ASSERT(m_deferred);
    … …  
    119246
    120247template<>
    121 inline void DeferredWrapper::reject(const JSC::JSValue& value)
    122 {
    123     ASSERT(m_deferred);
    124     ASSERT(m_globalObject);
    125     JSC::ExecState* exec = m_globalObject->globalExec();
    126     JSC::JSLockHolder locker(exec);
    127     reject(*exec, value);
    128 }
    129 
    130 template<>
    131 inline void DeferredWrapper::reject<ExceptionCode>(const ExceptionCode& ec)
    132 {
    133     ASSERT(m_deferred);
    134     ASSERT(m_globalObject);
    135     JSC::ExecState* exec = m_globalObject->globalExec();
    136     JSC::JSLockHolder locker(exec);
    137     reject(*exec, createDOMException(exec, ec));
    138 }
    139 
    140 template<>
    141 inline void DeferredWrapper::resolve<String>(const String& result)
     248inline void DeferredWrapper::resolve(const String& result)
    142249{
    143250    ASSERT(m_deferred);
    … …  
    149256
    150257template<>
    151 inline void DeferredWrapper::resolve<bool>(const bool& result)
    152 {
    153     ASSERT(m_deferred);
    154     ASSERT(m_globalObject);
    155     JSC::ExecState* exec = m_globalObject->globalExec();
    156     JSC::JSLockHolder locker(exec);
    157     resolve(*exec, JSC::jsBoolean(result));
    158 }
    159 
    160 template<>
    161 inline void DeferredWrapper::resolve<JSC::JSValue>(const JSC::JSValue& value)
    162 {
    163     ASSERT(m_deferred);
    164     ASSERT(m_globalObject);
    165     JSC::ExecState* exec = m_globalObject->globalExec();
    166     JSC::JSLockHolder locker(exec);
    167     resolve(*exec, value);
    168 }
    169 
    170 template<>
    171 inline void DeferredWrapper::resolve(const std::nullptr_t&)
    172 {
    173     ASSERT(m_deferred);
    174     ASSERT(m_globalObject);
    175     JSC::ExecState* exec = m_globalObject->globalExec();
    176     JSC::JSLockHolder locker(exec);
    177     resolve(*exec, JSC::jsUndefined());
    178 }
    179 
    180 template<>
    181 inline void DeferredWrapper::reject<String>(const String& result)
     258inline void DeferredWrapper::reject(const String& result)
    182259{
    183260    ASSERT(m_deferred);

  • trunk/Source/WebCore/bindings/js/JSSubtleCryptoCustom.cpp

    r198622 r200766  
    551551    DeferredWrapper wrapper(&state, globalObject(), promiseDeferred);
    552552    auto successCallback = [wrapper](CryptoKey& result) mutable {
    553         wrapper.resolve(&result);
     553        wrapper.resolve(result);
    554554    };
    555555    auto failureCallback = [wrapper]() mutable {
    … …  
    786786    auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithmPtr, unwrappedKeyAlgorithmParametersPtr, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {
    787787        auto importSuccessCallback = [wrapper](CryptoKey& key) mutable {
    788             wrapper.resolve(&key);
     788            wrapper.resolve(key);
    789789        };
    790790        auto importFailureCallback = [wrapper]() mutable {

  • trunk/Source/WebCore/css/FontFace.h

    r200555 r200766  
    6666    LoadStatus status() const;
    6767
    68     typedef DOMPromise<FontFace&, ExceptionCode> Promise;
     68    typedef DOMPromise<FontFace&> Promise;
    6969    void registerLoaded(Promise&&);
    7070

  • trunk/Source/WebCore/css/FontFaceSet.cpp

    r200619 r200766  
    8484}
    8585
    86 FontFaceSet::PendingPromise::PendingPromise(Promise&& promise)
     86FontFaceSet::PendingPromise::PendingPromise(LoadPromise&& promise)
    8787    : promise(WTFMove(promise))
    8888{
    … …  
    124124}
    125125
    126 void FontFaceSet::load(const String& font, const String& text, DeferredWrapper&& promise)
     126void FontFaceSet::load(const String& font, const String& text, LoadPromise&& promise)
    127127{
    128128    ExceptionCode ec = 0;
    … …  
    143143    for (auto& face : matchingFaces) {
    144144        if (face.get().status() == CSSFontFace::Status::Failure) {
    145             promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)).ptr());
     145            promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)));
    146146            return;
    147147        }
    … …  
    168168}
    169169
    170 void FontFaceSet::registerReady(Promise&& promise)
     170void FontFaceSet::registerReady(ReadyPromise&& promise)
    171171{
    172172    ASSERT(!m_promise);

  • trunk/Source/WebCore/css/FontFaceSet.h

    r200619 r200766  
    4848    void clear();
    4949
    50     void load(const String& font, const String& text, DeferredWrapper&& promise);
     50    typedef DOMPromise<Vector<RefPtr<FontFace>>> LoadPromise;
     51    void load(const String& font, const String& text, LoadPromise&&);
    5152    bool check(const String& font, const String& text, ExceptionCode&);
    5253
    … …  
    5455    LoadStatus status() const;
    5556
    56     typedef DOMPromise<FontFaceSet&, DOMCoreException&> Promise;
    57     void registerReady(Promise&&);
     57    typedef DOMPromise<FontFaceSet&> ReadyPromise;
     58    void registerReady(ReadyPromise&&);
    5859
    5960    CSSFontFaceSet& backing() { return m_backing; }
    … …  
    7576private:
    7677    struct PendingPromise : RefCounted<PendingPromise> {
    77         typedef DOMPromise<Vector<RefPtr<FontFace>>&, DOMCoreException&> Promise;
    78         static Ref<PendingPromise> create(Promise&& promise)
     78        static Ref<PendingPromise> create(LoadPromise&& promise)
    7979        {
    8080            return adoptRef(*new PendingPromise(WTFMove(promise)));
    … …  
    8383
    8484    private:
    85         PendingPromise(Promise&&);
     85        PendingPromise(LoadPromise&&);
    8686
    8787    public:
    8888        Vector<RefPtr<FontFace>> faces;
    89         Promise promise;
     89        LoadPromise promise;
    9090        bool hasReachedTerminalState { false };
    9191    };
    … …  
    111111    Ref<CSSFontFaceSet> m_backing;
    112112    HashMap<RefPtr<CSSFontFace>, Vector<Ref<PendingPromise>>> m_pendingPromises;
    113     Optional<Promise> m_promise;
     113    Optional<ReadyPromise> m_promise;
    114114    bool m_isReady { false };
    115115};

  • trunk/Source/WebCore/html/HTMLMediaElement.h

    r200638 r200766  
    213213    void setLoop(bool b);
    214214
    215     typedef DOMPromise<std::nullptr_t, DOMError&> PlayPromise;
     215    typedef DOMPromise<std::nullptr_t> PlayPromise;
    216216    void play(PlayPromise&&);
    217217
Note: See TracChangeset for help on using the changeset viewer.