Changeset 200875 in webkit


Ignore:
Timestamp:
May 13, 2016, 12:19:01 PM (9 years ago)
Author:
Chris Dumez
Message:

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

Location:
trunk/Source
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r200866 r200875  
     12016-05-13  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r200837.
     4
     5        Seems to have regressed Speedometer and JetStream on iOS
     6
     7        Reverted changeset:
     8
     9        "DOMPromise should only restrict the resolution type"
     10        https://bugs.webkit.org/show_bug.cgi?id=157307
     11        http://trac.webkit.org/changeset/200837
     12
    1132016-05-13  Beth Dakin  <bdakin@apple.com>
    214

  • trunk/Source/WTF/wtf/Ref.h

    r200837 r200875  
    4747template<typename T> class Ref {
    4848public:
    49     static constexpr bool isRef = true;
    50 
    5149    ~Ref()
    5250    {

  • trunk/Source/WTF/wtf/RefPtr.h

    r200837 r200875  
    3939    typedef T ValueType;
    4040    typedef ValueType* PtrType;
    41 
    42     static constexpr bool isRefPtr = true;
    4341
    4442    ALWAYS_INLINE RefPtr() : m_ptr(nullptr) { }

  • trunk/Source/WebCore/ChangeLog

    r200874 r200875  
     12016-05-13  Chris Dumez  <cdumez@apple.com>
     2
     3        Unreviewed, rolling out r200837.
     4
     5        Seems to have regressed Speedometer and JetStream on iOS
     6
     7        Reverted changeset:
     8
     9        "DOMPromise should only restrict the resolution type"
     10        https://bugs.webkit.org/show_bug.cgi?id=157307
     11        http://trac.webkit.org/changeset/200837
     12
    1132016-05-13  Sam Weinig  <sam@webkit.org>
    214

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

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

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

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

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

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

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

    r200837 r200875  
    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

    r200837 r200875  
    5555    static RefPtr<FetchResponse> redirect(ScriptExecutionContext&, const String&, int, ExceptionCode&);
    5656
    57     using FetchPromise = DOMPromise<FetchResponse>;
     57    using FetchPromise = DOMPromise<RefPtr<FetchResponse>, ExceptionCode>;
    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

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

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

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

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

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

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

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

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

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

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

    r200837 r200875  
    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>&);
    255 template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&&);
    256 template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&);
    257 template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, RefPtr<T>&&);
     254template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const RefPtr<T>&);
     255template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Ref<T>&);
     256template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, const RefPtr<T>&);
     257template<typename T> JSC::JSValue toJSNewlyCreated(JSC::ExecState*, JSDOMGlobalObject*, const Ref<T>&);
    258258template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Vector<T>&);
    259259template<typename T> JSC::JSValue toJS(JSC::ExecState*, JSDOMGlobalObject*, const Vector<RefPtr<T>>&);
    … …  
    270270
    271271JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, JSC::JSValue, JSC::JSValue);
    272 template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, FirstType&, SecondType&);
     272template<typename FirstType, typename SecondType> JSC::JSValue jsPair(JSC::ExecState&, JSDOMGlobalObject*, const FirstType&, const SecondType&);
    273273
    274274RefPtr<JSC::ArrayBufferView> toArrayBufferView(JSC::JSValue);
    … …  
    543543}
    544544
    545 template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>& ptr)
     545template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const RefPtr<T>& ptr)
    546546{
    547547    return toJS(exec, globalObject, ptr.get());
    548548}
    549549
    550 template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>&& ptr)
    551 {
    552     return toJS(exec, globalObject, ptr.get());
    553 }
    554 
    555550template<typename T> inline JSC::JSValue toJS(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const Ref<T>& ptr)
    556551{
    … …  
    558553}
    559554
    560 template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>&& ptr)
     555template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const RefPtr<T>& ptr)
    561556{
    562557    return toJSNewlyCreated(exec, globalObject, ptr.get());
    563558}
    564559
    565 template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, RefPtr<T>& ptr)
    566 {
    567     return toJSNewlyCreated(exec, globalObject, ptr.get());
     560template<typename T> inline JSC::JSValue toJSNewlyCreated(JSC::ExecState* exec, JSDOMGlobalObject* globalObject, const Ref<T>& ptr)
     561{
     562    return toJSNewlyCreated(exec, globalObject, const_cast<T&>(ptr.get()));
    568563}
    569564
    … …  
    662657}
    663658
    664 template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, FirstType& value1, SecondType& value2)
     659template<typename FirstType, typename SecondType> inline JSC::JSValue jsPair(JSC::ExecState& state, JSDOMGlobalObject* globalObject, const FirstType& value1, const SecondType& value2)
    665660{
    666661    return jsPair(state, globalObject, toJS(&state, globalObject, value1), toJS(&state, globalObject, value2));

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

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

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

    r200837 r200875  
    3434namespace WebCore {
    3535
    36 template<typename DOMClass>
    37 struct TypeInspector {
    38 private:
    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 testIsRef(int) -> decltype(T::isRef) { return true; }
    43     template<typename T> static constexpr bool testIsRef(...) { return false; }
    44 
    45     template<typename T> static constexpr auto testIsRefPtr(int) -> decltype(T::isRefPtr) { return true; }
    46     template<typename T> static constexpr bool testIsRefPtr(...) { return false; }
    47 
    48 public:
    49     static constexpr bool isRefOrRefPtr = testIsRef<DOMClass>(0) || testIsRefPtr<DOMClass>(0);
    50     static constexpr bool isPassByValueType = std::is_pointer<DOMClass>::value
    51         || std::is_same<DOMClass, std::nullptr_t>::value
    52         || std::is_same<DOMClass, JSC::JSValue>::value
    53         || std::is_same<DOMClass, bool>::value;
    54     static constexpr bool isPassByConstRefType = testIsVector<DOMClass>(0)
    55         || std::is_same<DOMClass, String>::value;
    56 };
    57 
    58 template<typename DOMClass, typename Enable = void>
    59 struct PromiseResultInspector {
    60 public:
    61     static constexpr bool passByValue = false;
    62     static constexpr bool passByRef = true;
    63     static constexpr bool passByURef = false;
    64     static constexpr bool passByConstRef = false;
    65 
    66     typedef DOMClass& Type;
    67 };
    68 
    69 template<typename DOMClass>
    70 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByValueType>::type> {
    71 public:
    72     static constexpr bool passByValue = true;
    73     static constexpr bool passByRef = false;
    74     static constexpr bool passByURef = false;
    75     static constexpr bool passByConstRef = false;
    76 
    77     typedef DOMClass Type;
    78 };
    79 
    80 template<typename DOMClass>
    81 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByConstRefType>::type> {
    82 public:
    83     static constexpr bool passByValue = false;
    84     static constexpr bool passByRef = false;
    85     static constexpr bool passByURef = false;
    86     static constexpr bool passByConstRef = true;
    87 
    88     typedef const DOMClass& Type;
    89 };
    90 
    91 template<typename DOMClass>
    92 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isRefOrRefPtr>::type> {
    93     static constexpr bool passByValue = false;
    94     static constexpr bool passByRef = false;
    95     static constexpr bool passByURef = true;
    96     static constexpr bool passByConstRef = false;
    97 };
    98 
    9936class DeferredWrapper {
    10037public:
    10138    DeferredWrapper(JSC::ExecState*, JSDOMGlobalObject*, JSC::JSPromiseDeferred*);
    10239
    103     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
    104     resolve(ResolveResultType result) { resolveWithValue(result); }
    105     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByRef, void>::type
    106     resolve(ResolveResultType& result) { resolveWithValue(result); }
    107     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByURef, void>::type
    108     resolve(ResolveResultType&& result) { resolveWithValue(std::forward<ResolveResultType>(result)); }
    109     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByConstRef, void>::type
    110     resolve(const ResolveResultType& result) { resolveWithValue(result); }
     40    template<class ResolveResultType>
     41    void resolve(const ResolveResultType&);
    11142
    112     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByValue, void>::type
    113     reject(RejectResultType result) { rejectWithValue(result); }
    114     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByRef, void>::type
    115     reject(RejectResultType& result) { rejectWithValue(result); }
    116     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByURef, void>::type
    117     reject(RejectResultType&& result) { rejectWithValue(std::forward<RejectResultType>(result)); }
    118     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByConstRef, void>::type
    119     reject(const RejectResultType& result) { rejectWithValue(result); }
    120 
    121     void reject(ExceptionCode);
     43    template<class RejectResultType>
     44    void reject(const RejectResultType&);
    12245
    12346    JSDOMGlobalObject& globalObject() const;
    … …  
    12851    void resolve(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->resolve(), resolution); }
    12952    void reject(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->reject(), resolution); }
    130 
    131     template<class RejectResultType> void rejectWithValue(RejectResultType&&);
    132     template<class ResolveResultType> void resolveWithValue(ResolveResultType&&);
    13353
    13454    JSC::Strong<JSDOMGlobalObject> m_globalObject;
    … …  
    15272}
    15373
    154 template <typename Value>
     74template <typename Value, typename Error>
    15575class DOMPromise {
    15676public:
    … …  
    16181    DOMPromise& operator=(DOMPromise const&) = default;
    16282
    163     void resolve(typename PromiseResultInspector<Value>::Type value) { m_wrapper.resolve(value); }
    164 
    165     template<typename ErrorType> void reject(ErrorType&& error) { m_wrapper.reject(std::forward<ErrorType>(error)); }
     83    void resolve(const Value& value) { m_wrapper.resolve<Value>(value); }
     84    void reject(const Error& error) { m_wrapper.reject<Error>(error); }
    16685
    16786private:
    … …  
    16988};
    17089
    171 inline void DeferredWrapper::reject(ExceptionCode ec)
     90template<class ResolveResultType>
     91inline 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));
     98}
     99
     100template<class RejectResultType>
     101inline 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
     110template<>
     111inline void DeferredWrapper::reject(const std::nullptr_t&)
     112{
     113    ASSERT(m_deferred);
     114    ASSERT(m_globalObject);
     115    JSC::ExecState* exec = m_globalObject->globalExec();
     116    JSC::JSLockHolder locker(exec);
     117    reject(*exec, JSC::jsNull());
     118}
     119
     120template<>
     121inline 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
     130template<>
     131inline void DeferredWrapper::reject<ExceptionCode>(const ExceptionCode& ec)
    172132{
    173133    ASSERT(m_deferred);
    … …  
    178138}
    179139
    180 template<class ResolveResultType>
    181 inline void DeferredWrapper::resolveWithValue(ResolveResultType&& result)
     140template<>
     141inline void DeferredWrapper::resolve<String>(const String& result)
    182142{
    183143    ASSERT(m_deferred);
    … …  
    185145    JSC::ExecState* exec = m_globalObject->globalExec();
    186146    JSC::JSLockHolder locker(exec);
    187     resolve(*exec, toJS(exec, m_globalObject.get(), std::forward<ResolveResultType>(result)));
    188 }
    189 
    190 template<class RejectResultType>
    191 inline void DeferredWrapper::rejectWithValue(RejectResultType&& result)
    192 {
    193     ASSERT(m_deferred);
    194     ASSERT(m_globalObject);
    195     JSC::ExecState* exec = m_globalObject->globalExec();
    196     JSC::JSLockHolder locker(exec);
    197     reject(*exec, toJS(exec, m_globalObject.get(), std::forward<RejectResultType>(result)));
     147    resolve(*exec, jsString(exec, result));
    198148}
    199149
    200150template<>
    201 inline void DeferredWrapper::resolve(bool result)
     151inline void DeferredWrapper::resolve<bool>(const bool& result)
    202152{
    203153    ASSERT(m_deferred);
    … …  
    209159
    210160template<>
    211 inline void DeferredWrapper::resolve(JSC::JSValue value)
     161inline void DeferredWrapper::resolve<JSC::JSValue>(const JSC::JSValue& value)
    212162{
    213163    ASSERT(m_deferred);
    … …  
    219169
    220170template<>
    221 inline void DeferredWrapper::reject(JSC::JSValue value)
    222 {
    223     ASSERT(m_deferred);
    224     ASSERT(m_globalObject);
    225     JSC::ExecState* exec = m_globalObject->globalExec();
    226     JSC::JSLockHolder locker(exec);
    227     reject(*exec, value);
    228 }
    229 
    230 template<>
    231 inline void DeferredWrapper::resolve(std::nullptr_t)
     171inline void DeferredWrapper::resolve(const std::nullptr_t&)
    232172{
    233173    ASSERT(m_deferred);
    … …  
    239179
    240180template<>
    241 inline void DeferredWrapper::reject(std::nullptr_t)
    242 {
    243     ASSERT(m_deferred);
    244     ASSERT(m_globalObject);
    245     JSC::ExecState* exec = m_globalObject->globalExec();
    246     JSC::JSLockHolder locker(exec);
    247     reject(*exec, JSC::jsNull());
    248 }
    249 
    250 template<>
    251 inline void DeferredWrapper::resolve(const String& result)
    252 {
    253     ASSERT(m_deferred);
    254     ASSERT(m_globalObject);
    255     JSC::ExecState* exec = m_globalObject->globalExec();
    256     JSC::JSLockHolder locker(exec);
    257     resolve(*exec, jsString(exec, result));
    258 }
    259 
    260 template<>
    261 inline void DeferredWrapper::reject(const String& result)
     181inline void DeferredWrapper::reject<String>(const String& result)
    262182{
    263183    ASSERT(m_deferred);

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

    r200837 r200875  
    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

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

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

    r200837 r200875  
    8484}
    8585
    86 FontFaceSet::PendingPromise::PendingPromise(LoadPromise&& promise)
     86FontFaceSet::PendingPromise::PendingPromise(Promise&& promise)
    8787    : promise(WTFMove(promise))
    8888{
    … …  
    124124}
    125125
    126 void FontFaceSet::load(const String& font, const String& text, LoadPromise&& promise)
     126void FontFaceSet::load(const String& font, const String& text, DeferredWrapper&& 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)));
     145            promise.reject(DOMCoreException::create(ExceptionCodeDescription(NETWORK_ERR)).ptr());
    146146            return;
    147147        }
    … …  
    168168}
    169169
    170 void FontFaceSet::registerReady(ReadyPromise&& promise)
     170void FontFaceSet::registerReady(Promise&& promise)
    171171{
    172172    ASSERT(!m_promise);

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

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

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

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