Changeset 209390 in webkit


Ignore:
Timestamp:
Dec 5, 2016 11:59:02 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

[WebIDL] Add support for converting dictionaries to JS
​https://bugs.webkit.org/show_bug.cgi?id=165367

Patch by Sam Weinig <​sam@webkit.org> on 2016-12-06
Reviewed by Darin Adler and Alex Christensen.

Source/WebCore:

  • Adds support for converting dictionary types to JSValues via JSDOMConvert.
  • Adopts that functionality to correct the CryptoKeyPair implementation, which is supposed to be a dictionary. (While doing this, I also update places that were passing both a CryptoKey and CryptoKeyPair to use a Variant, since they always only wanted one.)
  • Re-works DOMPromise and DeferredPromise to be based on JSDOMConvert and IDLTypes.
  • CMakeLists.txt:
  • PlatformEfl.cmake:
  • PlatformGTK.cmake:
  • PlatformMac.cmake:
  • WebCore.xcodeproj/project.pbxproj:

Remove JSCryptoKeyPairCustom.cpp and CryptoKeyPair.cpp.

  • Modules/encryptedmedia/legacy/WebKitMediaKeys.cpp:
  • Modules/mediasource/MediaSource.cpp:
  • Modules/mediasource/SourceBuffer.cpp:
  • bindings/js/JSMediaDevicesCustom.cpp:
  • html/MediaController.cpp:
  • html/track/TextTrack.cpp:

Add some missing includes.

  • Modules/applepay/ApplePaySession.cpp:

(WebCore::ApplePaySession::canMakePaymentsWithActiveCard):
(WebCore::ApplePaySession::openPaymentSetup):

  • Modules/fetch/FetchBody.cpp:

(WebCore::FetchBody::text):
(WebCore::FetchBody::consume):
(WebCore::FetchBody::loadingFailed):

  • Modules/fetch/FetchBodyConsumer.cpp:

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

  • Modules/fetch/FetchBodyOwner.cpp:

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

  • Modules/fetch/FetchResponse.h:
  • Modules/mediastream/MediaDevices.h:
  • Modules/mediastream/MediaEndpointPeerConnection.cpp:

(WebCore::MediaEndpointPeerConnection::replaceTrack):
(WebCore::MediaEndpointPeerConnection::replaceTrackTask):

  • Modules/mediastream/MediaEndpointPeerConnection.h:
  • Modules/mediastream/MediaStreamTrack.cpp:

(WebCore::MediaStreamTrack::applyConstraints):

  • Modules/mediastream/PeerConnectionBackend.cpp:

(WebCore::PeerConnectionBackend::setLocalDescription):
(WebCore::PeerConnectionBackend::setRemoteDescription):
(WebCore::PeerConnectionBackend::addIceCandidate):

  • Modules/mediastream/PeerConnectionBackend.h:
  • Modules/mediastream/RTCPeerConnection.cpp:

(WebCore::RTCPeerConnection::queuedSetLocalDescription):
(WebCore::RTCPeerConnection::queuedSetRemoteDescription):
(WebCore::RTCPeerConnection::queuedAddIceCandidate):
(WebCore::RTCPeerConnection::replaceTrack):

  • Modules/mediastream/RTCPeerConnection.h:
  • Modules/mediastream/RTCRtpSender.cpp:

(WebCore::RTCRtpSender::replaceTrack):

  • Modules/mediastream/RTCRtpSender.h:
  • Modules/mediastream/UserMediaRequest.cpp:

(WebCore::UserMediaRequest::deny):

  • Modules/webaudio/AudioContext.cpp:

(WebCore::AudioContext::suspend):
(WebCore::AudioContext::resume):

  • bindings/js/JSCustomElementRegistryCustom.cpp:

(WebCore::whenDefinedPromise):

  • bindings/js/ScriptModuleLoader.cpp:

(WebCore::ScriptModuleLoader::resolve):
(WebCore::ScriptModuleLoader::notifyFinished):

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

(WebCore::FontFaceSet::load):

  • css/FontFaceSet.h:
  • dom/CustomElementRegistry.cpp:

(WebCore::CustomElementRegistry::addElementDefinition):

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::rejectPendingPlayPromises):

  • html/HTMLMediaElement.h:

Update to use new IDLType based promises.

  • bindings/generic/IDLTypes.h:

Add a new type, ParameterType, to use as the parameter to
DOMPromise/DeferredPromise.

  • bindings/js/JSCryptoKeyPairCustom.cpp:

Removed.

  • bindings/js/JSDOMConvert.h:

(WebCore::JSConverter<IDLDictionary<T>>::convert):
Add JSConverter specialization for IDLDictionary. Have it simply forward to a generated
convertDictionaryToJS function, following the convention set in place by IDLEnumeration.

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

Re-write to be based on IDLTypes and JSDOMConvert, simplifying the implementation.

  • bindings/js/JSSubtleCryptoCustom.cpp:
  • bindings/js/JSWebKitSubtleCryptoCustom.cpp:

Update for variant based KeyOrKeyPair.

  • bindings/scripts/CodeGeneratorJS.pm:

(GenerateDictionaryHeaderContent):
(GenerateDictionaryImplementationContent):
Add generation of the convertDictionaryToJS function. I made it require the JSGenerateToJSObject
extended attribute for now, as the majority of dictionaries do not need this code generated for them.

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

(WebCore::convertDictionaryToJS):

  • bindings/scripts/test/JS/JSTestObj.h:
  • bindings/scripts/test/TestObj.idl:

Add JSGenerateToJSObject to a dictionary to test generation in bindings tests.

  • crypto/CryptoAlgorithm.h:

Change KeyOrKeyPairCallback to take a Variant<RefPtr<CryptoKey>, CryptoKeyPair>, rather
than two separate arguments.

  • crypto/CryptoKeyPair.cpp:

Removed.

  • crypto/CryptoKeyPair.h:

Convert to a struct.

  • crypto/CryptoKeyPair.idl:

Convert to a dictionary.

  • crypto/algorithms/CryptoAlgorithmAES_CBC.cpp:

(WebCore::CryptoAlgorithmAES_CBC::generateKey):

  • crypto/algorithms/CryptoAlgorithmAES_KW.cpp:

(WebCore::CryptoAlgorithmAES_KW::generateKey):

  • crypto/algorithms/CryptoAlgorithmHMAC.cpp:

(WebCore::CryptoAlgorithmHMAC::generateKey):

  • crypto/algorithms/CryptoAlgorithmRSAES_PKCS1_v1_5.cpp:

(WebCore::CryptoAlgorithmRSAES_PKCS1_v1_5::generateKey):

  • crypto/algorithms/CryptoAlgorithmRSASSA_PKCS1_v1_5.cpp:

(WebCore::CryptoAlgorithmRSASSA_PKCS1_v1_5::generateKey):

  • crypto/algorithms/CryptoAlgorithmRSA_OAEP.cpp:

(WebCore::CryptoAlgorithmRSA_OAEP::generateKey):

  • crypto/keys/CryptoKeyRSA.h:
  • crypto/mac/CryptoKeyRSAMac.cpp:

(WebCore::CryptoKeyRSA::generatePair):
Update for new signature of KeyOrKeyPairCallback.

Source/WebKit2:

  • CMakeLists.txt:

Add missing directories to look in for headers.

LayoutTests:

  • crypto/subtle/rsa-oaep-generate-key-expected.txt:
  • crypto/subtle/rsa-oaep-generate-key.html:
  • crypto/subtle/rsaes-pkcs1-v1_5-generate-key-expected.txt:
  • crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable-expected.txt:
  • crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable.html:
  • crypto/subtle/rsaes-pkcs1-v1_5-generate-key.html:
  • crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
  • crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html:
  • crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key-expected.txt:
  • crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key.html:
  • crypto/webkitSubtle/rsa-oaep-key-manipulation-expected.txt:
  • crypto/webkitSubtle/rsa-oaep-key-manipulation.html:
  • crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
  • crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent-expected.txt:
  • crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent.html:
  • crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key.html:
  • crypto/workers/subtle/resources/rsa-generate-key.js:
  • crypto/workers/subtle/rsa-generate-key-expected.txt:

Update tests and expected results to show that CryptoKeyPair is now a vanilla object, not a platform object.

Location:
trunk
Files:
2 deleted
80 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r209388 r209390  
     12016-12-06  Sam Weinig  <sam@webkit.org>
     2
     3        [WebIDL] Add support for converting dictionaries to JS
     4        https://bugs.webkit.org/show_bug.cgi?id=165367
     5
     6        Reviewed by Darin Adler and Alex Christensen.
     7
     8        * crypto/subtle/rsa-oaep-generate-key-expected.txt:
     9        * crypto/subtle/rsa-oaep-generate-key.html:
     10        * crypto/subtle/rsaes-pkcs1-v1_5-generate-key-expected.txt:
     11        * crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable-expected.txt:
     12        * crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable.html:
     13        * crypto/subtle/rsaes-pkcs1-v1_5-generate-key.html:
     14        * crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
     15        * crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html:
     16        * crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key-expected.txt:
     17        * crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key.html:
     18        * crypto/webkitSubtle/rsa-oaep-key-manipulation-expected.txt:
     19        * crypto/webkitSubtle/rsa-oaep-key-manipulation.html:
     20        * crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-expected.txt:
     21        * crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent-expected.txt:
     22        * crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent.html:
     23        * crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key.html:
     24        * crypto/workers/subtle/resources/rsa-generate-key.js:
     25        * crypto/workers/subtle/rsa-generate-key-expected.txt:
     26        Update tests and expected results to show that CryptoKeyPair is now a vanilla object, not a platform object.
     27
    1282016-12-05  Antoine Quint  <graouts@apple.com>
    229

  • trunk/LayoutTests/crypto/subtle/rsa-oaep-generate-key-expected.txt

    r207809 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.extractable is true

  • trunk/LayoutTests/crypto/subtle/rsa-oaep-generate-key.html

    r207809 r209390  
    2626crypto.subtle.generateKey(algorithmKeyGen, nonExtractable, ["decrypt", "encrypt", "wrapKey", "unwrapKey"]).then(function(result) {
    2727    keyPair = result;
    28     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     28    shouldBe("keyPair.toString()", "'[object Object]'");
    2929    shouldBe("keyPair.publicKey.type", "'public'");
    3030    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/subtle/rsaes-pkcs1-v1_5-generate-key-expected.txt

    r207809 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.extractable is true

  • trunk/LayoutTests/crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable-expected.txt

    r207809 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.extractable is true

  • trunk/LayoutTests/crypto/subtle/rsaes-pkcs1-v1_5-generate-key-extractable.html

    r207809 r209390  
    2525crypto.subtle.generateKey(algorithmKeyGen, extractable, ["decrypt", "encrypt"]).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/subtle/rsaes-pkcs1-v1_5-generate-key.html

    r207809 r209390  
    2525crypto.subtle.generateKey(algorithmKeyGen, nonExtractable, ["decrypt", "encrypt"]).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-generate-key-expected.txt

    r207809 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.extractable is true

  • trunk/LayoutTests/crypto/subtle/rsassa-pkcs1-v1_5-generate-key.html

    r207809 r209390  
    2626crypto.subtle.generateKey(algorithmKeyGen, nonExtractable, ["sign", "verify"]).then(function(result) {
    2727    keyPair = result;
    28     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     28    shouldBe("keyPair.toString()", "'[object Object]'");
    2929    shouldBe("keyPair.publicKey.type", "'public'");
    3030    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key-expected.txt

    r206883 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.extractable is true

  • trunk/LayoutTests/crypto/webkitSubtle/rsa-oaep-generate-non-extractable-key.html

    r206883 r209390  
    2525crypto.webkitSubtle.generateKey(algorithmKeyGen, nonExtractable, []).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/webkitSubtle/rsa-oaep-key-manipulation-expected.txt

    r206883 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.algorithm.name is 'RSA-OAEP'

  • trunk/LayoutTests/crypto/webkitSubtle/rsa-oaep-key-manipulation.html

    r206883 r209390  
    2525crypto.webkitSubtle.generateKey(algorithmKeyGen, extractable, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.algorithm.name", "'RSA-OAEP'");

  • trunk/LayoutTests/crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-expected.txt

    r206883 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.algorithm.name is 'RSASSA-PKCS1-v1_5'

  • trunk/LayoutTests/crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent-expected.txt

    r206883 r209390  
    55
    66Generating a key pair...
    7 PASS keyPair.toString() is '[object CryptoKeyPair]'
     7PASS keyPair.toString() is '[object Object]'
    88PASS keyPair.publicKey.type is 'public'
    99PASS keyPair.publicKey.algorithm.name is 'RSASSA-PKCS1-v1_5'

  • trunk/LayoutTests/crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key-with-leading-zeroes-in-exponent.html

    r206883 r209390  
    2525crypto.webkitSubtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.algorithm.name", "'RSASSA-PKCS1-v1_5'");

  • trunk/LayoutTests/crypto/webkitSubtle/rsassa-pkcs1-v1_5-generate-key.html

    r206883 r209390  
    2525crypto.webkitSubtle.generateKey(algorithmKeyGen, extractable, ["sign", "verify"]).then(function(result) {
    2626    keyPair = result;
    27     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     27    shouldBe("keyPair.toString()", "'[object Object]'");
    2828    shouldBe("keyPair.publicKey.type", "'public'");
    2929    shouldBe("keyPair.publicKey.algorithm.name", "'RSASSA-PKCS1-v1_5'");

  • trunk/LayoutTests/crypto/workers/subtle/resources/rsa-generate-key.js

    r208759 r209390  
    1414}).then(function(result) {
    1515    keyPair = result;
    16     shouldBe("keyPair.toString()", "'[object CryptoKeyPair]'");
     16    shouldBe("keyPair.toString()", "'[object Object]'");
    1717    shouldBe("keyPair.publicKey.type", "'public'");
    1818    shouldBe("keyPair.publicKey.extractable", "true");

  • trunk/LayoutTests/crypto/workers/subtle/rsa-generate-key-expected.txt

    r208759 r209390  
    88PASS [Worker] crypto.subtle.generateKey({name: "RSASSA-PKCS1-v1_5", modulusLength: 0, publicExponent: publicExponent, hash: "sha-1"}, extractable, ["sign", "verify"]) rejected promise  with OperationError (DOM Exception 34): The operation failed for an operation-specific reason.
    99[Worker] Generating a key...
    10 PASS [Worker] keyPair.toString() is '[object CryptoKeyPair]'
     10PASS [Worker] keyPair.toString() is '[object Object]'
    1111PASS [Worker] keyPair.publicKey.type is 'public'
    1212PASS [Worker] keyPair.publicKey.extractable is true

  • trunk/Source/WebCore/CMakeLists.txt

    r209303 r209390  
    11061106    bindings/js/JSCryptoCustom.cpp
    11071107    bindings/js/JSCryptoKeyCustom.cpp
    1108     bindings/js/JSCryptoKeyPairCustom.cpp
    11091108    bindings/js/JSCryptoKeySerializationJWK.cpp
    11101109    bindings/js/JSCryptoOperationData.cpp

  • trunk/Source/WebCore/ChangeLog

    r209389 r209390  
     12016-12-06  Sam Weinig  <sam@webkit.org>
     2
     3        [WebIDL] Add support for converting dictionaries to JS
     4        https://bugs.webkit.org/show_bug.cgi?id=165367
     5
     6        Reviewed by Darin Adler and Alex Christensen.
     7
     8        - Adds support for converting dictionary types to JSValues via JSDOMConvert.
     9        - Adopts that functionality to correct the CryptoKeyPair implementation, which
     10          is supposed to be a dictionary.
     11          (While doing this, I also update places that were passing both a CryptoKey
     12          and CryptoKeyPair to use a Variant, since they always only wanted one.)
     13        - Re-works DOMPromise and DeferredPromise to be based on JSDOMConvert and IDLTypes.
     14
     15        * CMakeLists.txt:
     16        * PlatformEfl.cmake:
     17        * PlatformGTK.cmake:
     18        * PlatformMac.cmake:
     19        * WebCore.xcodeproj/project.pbxproj:
     20        Remove JSCryptoKeyPairCustom.cpp and CryptoKeyPair.cpp.
     21
     22        * Modules/encryptedmedia/legacy/WebKitMediaKeys.cpp:
     23        * Modules/mediasource/MediaSource.cpp:
     24        * Modules/mediasource/SourceBuffer.cpp:
     25        * bindings/js/JSMediaDevicesCustom.cpp:
     26        * html/MediaController.cpp:
     27        * html/track/TextTrack.cpp:
     28        Add some missing includes.
     29
     30        * Modules/applepay/ApplePaySession.cpp:
     31        (WebCore::ApplePaySession::canMakePaymentsWithActiveCard):
     32        (WebCore::ApplePaySession::openPaymentSetup):
     33        * Modules/fetch/FetchBody.cpp:
     34        (WebCore::FetchBody::text):
     35        (WebCore::FetchBody::consume):
     36        (WebCore::FetchBody::loadingFailed):
     37        * Modules/fetch/FetchBodyConsumer.cpp:
     38        (WebCore::FetchBodyConsumer::resolveWithData):
     39        (WebCore::FetchBodyConsumer::resolve):
     40        * Modules/fetch/FetchBodyOwner.cpp:
     41        (WebCore::FetchBodyOwner::blob):
     42        (WebCore::FetchBodyOwner::formData):
     43        (WebCore::FetchBodyOwner::text):
     44        * Modules/fetch/FetchResponse.h:
     45        * Modules/mediastream/MediaDevices.h:
     46        * Modules/mediastream/MediaEndpointPeerConnection.cpp:
     47        (WebCore::MediaEndpointPeerConnection::replaceTrack):
     48        (WebCore::MediaEndpointPeerConnection::replaceTrackTask):
     49        * Modules/mediastream/MediaEndpointPeerConnection.h:
     50        * Modules/mediastream/MediaStreamTrack.cpp:
     51        (WebCore::MediaStreamTrack::applyConstraints):
     52        * Modules/mediastream/PeerConnectionBackend.cpp:
     53        (WebCore::PeerConnectionBackend::setLocalDescription):
     54        (WebCore::PeerConnectionBackend::setRemoteDescription):
     55        (WebCore::PeerConnectionBackend::addIceCandidate):
     56        * Modules/mediastream/PeerConnectionBackend.h:
     57        * Modules/mediastream/RTCPeerConnection.cpp:
     58        (WebCore::RTCPeerConnection::queuedSetLocalDescription):
     59        (WebCore::RTCPeerConnection::queuedSetRemoteDescription):
     60        (WebCore::RTCPeerConnection::queuedAddIceCandidate):
     61        (WebCore::RTCPeerConnection::replaceTrack):
     62        * Modules/mediastream/RTCPeerConnection.h:
     63        * Modules/mediastream/RTCRtpSender.cpp:
     64        (WebCore::RTCRtpSender::replaceTrack):
     65        * Modules/mediastream/RTCRtpSender.h:
     66        * Modules/mediastream/UserMediaRequest.cpp:
     67        (WebCore::UserMediaRequest::deny):
     68        * Modules/webaudio/AudioContext.cpp:
     69        (WebCore::AudioContext::suspend):
     70        (WebCore::AudioContext::resume):
     71        * bindings/js/JSCustomElementRegistryCustom.cpp:
     72        (WebCore::whenDefinedPromise):
     73        * bindings/js/ScriptModuleLoader.cpp:
     74        (WebCore::ScriptModuleLoader::resolve):
     75        (WebCore::ScriptModuleLoader::notifyFinished):
     76        * css/FontFace.h:
     77        * css/FontFaceSet.cpp:
     78        (WebCore::FontFaceSet::load):
     79        * css/FontFaceSet.h:
     80        * dom/CustomElementRegistry.cpp:
     81        (WebCore::CustomElementRegistry::addElementDefinition):
     82        * html/HTMLMediaElement.cpp:
     83        (WebCore::HTMLMediaElement::rejectPendingPlayPromises):
     84        * html/HTMLMediaElement.h:
     85        Update to use new IDLType based promises.
     86
     87        * bindings/generic/IDLTypes.h:
     88        Add a new type, ParameterType, to use as the parameter to
     89        DOMPromise/DeferredPromise.
     90
     91        * bindings/js/JSCryptoKeyPairCustom.cpp:
     92        Removed.
     93
     94        * bindings/js/JSDOMConvert.h:
     95        (WebCore::JSConverter<IDLDictionary<T>>::convert):
     96        Add JSConverter specialization for IDLDictionary. Have it simply forward to a generated
     97        convertDictionaryToJS function, following the convention set in place by IDLEnumeration.
     98
     99        * bindings/js/JSDOMPromise.cpp:
     100        * bindings/js/JSDOMPromise.h:
     101        Re-write to be based on IDLTypes and JSDOMConvert, simplifying the implementation.
     102
     103        * bindings/js/JSSubtleCryptoCustom.cpp:
     104        * bindings/js/JSWebKitSubtleCryptoCustom.cpp:
     105        Update for variant based KeyOrKeyPair.
     106
     107        * bindings/scripts/CodeGeneratorJS.pm:
     108        (GenerateDictionaryHeaderContent):
     109        (GenerateDictionaryImplementationContent):
     110        Add generation of the convertDictionaryToJS function. I made it require the JSGenerateToJSObject
     111        extended attribute for now, as the majority of dictionaries do not need this code generated for them.
     112
     113        * bindings/scripts/test/JS/JSTestObj.cpp:
     114        (WebCore::convertDictionaryToJS):
     115        * bindings/scripts/test/JS/JSTestObj.h:
     116        * bindings/scripts/test/TestObj.idl:
     117        Add JSGenerateToJSObject to a dictionary to test generation in bindings tests.
     118
     119        * crypto/CryptoAlgorithm.h:
     120        Change KeyOrKeyPairCallback to take a Variant<RefPtr<CryptoKey>, CryptoKeyPair>, rather
     121        than two separate arguments.
     122
     123        * crypto/CryptoKeyPair.cpp:
     124        Removed.
     125
     126        * crypto/CryptoKeyPair.h:
     127        Convert to a struct.
     128
     129        * crypto/CryptoKeyPair.idl:
     130        Convert to a dictionary.
     131
     132        * crypto/algorithms/CryptoAlgorithmAES_CBC.cpp:
     133        (WebCore::CryptoAlgorithmAES_CBC::generateKey):
     134        * crypto/algorithms/CryptoAlgorithmAES_KW.cpp:
     135        (WebCore::CryptoAlgorithmAES_KW::generateKey):
     136        * crypto/algorithms/CryptoAlgorithmHMAC.cpp:
     137        (WebCore::CryptoAlgorithmHMAC::generateKey):
     138        * crypto/algorithms/CryptoAlgorithmRSAES_PKCS1_v1_5.cpp:
     139        (WebCore::CryptoAlgorithmRSAES_PKCS1_v1_5::generateKey):
     140        * crypto/algorithms/CryptoAlgorithmRSASSA_PKCS1_v1_5.cpp:
     141        (WebCore::CryptoAlgorithmRSASSA_PKCS1_v1_5::generateKey):
     142        * crypto/algorithms/CryptoAlgorithmRSA_OAEP.cpp:
     143        (WebCore::CryptoAlgorithmRSA_OAEP::generateKey):
     144        * crypto/keys/CryptoKeyRSA.h:
     145        * crypto/mac/CryptoKeyRSAMac.cpp:
     146        (WebCore::CryptoKeyRSA::generatePair):
     147        Update for new signature of KeyOrKeyPairCallback.
     148
    11492016-12-05  Dave Hyatt  <hyatt@apple.com>
    2150

  • trunk/Source/WebCore/Modules/applepay/ApplePaySession.cpp

    r208985 r209390  
    736736
    737737        RunLoop::main().dispatch([promise, canMakePayments]() mutable {
    738             promise->resolve(canMakePayments);
     738            promise->resolve<IDLBoolean>(canMakePayments);
    739739        });
    740740        return { };
    … …  
    744744
    745745    paymentCoordinator.canMakePaymentsWithActiveCard(merchantIdentifier, document.domain(), [promise](bool canMakePayments) mutable {
    746         promise->resolve(canMakePayments);
     746        promise->resolve<IDLBoolean>(canMakePayments);
    747747    });
    748748    return { };
    … …  
    769769
    770770    paymentCoordinator.openPaymentSetup(merchantIdentifier, document.domain(), [promise](bool result) mutable {
    771         promise->resolve(result);
     771        promise->resolve<IDLBoolean>(result);
    772772    });
    773773

  • trunk/Source/WebCore/Modules/encryptedmedia/legacy/WebKitMediaKeys.cpp

    r206984 r209390  
    3030
    3131#include "EventNames.h"
     32#include "ExceptionCode.h"
    3233#include "HTMLMediaElement.h"
    3334#include "WebKitMediaKeySession.h"

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

    r209195 r209390  
    108108{
    109109    if (isText()) {
    110         promise->resolve(textBody());
     110        promise->resolve<IDLDOMString>(textBody());
    111111        return;
    112112    }
    … …  
    145145    if (isFormData()) {
    146146        // FIXME: Support consuming FormData.
    147         promise->reject(0);
     147        promise->reject();
    148148        return;
    149149    }
    … …  
    213213{
    214214    if (m_consumePromise) {
    215         m_consumePromise->reject(0);
     215        m_consumePromise->reject();
    216216        m_consumePromise = nullptr;
    217217    }

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

    r209195 r209390  
    6666        return;
    6767    case Type::Blob:
    68         promise->resolveWithNewlyCreated(blobFromData(data, length, m_contentType));
     68        promise->resolveWithNewlyCreated<IDLInterface<Blob>>(blobFromData(data, length, m_contentType).get());
    6969        return;
    7070    case Type::JSON:
    … …  
    7272        return;
    7373    case Type::Text:
    74         promise->resolve(textFromUTF8(data, length));
     74        promise->resolve<IDLDOMString>(textFromUTF8(data, length));
    7575        return;
    7676    case Type::None:
    … …  
    8888        return;
    8989    case Type::Blob:
    90         promise->resolveWithNewlyCreated(takeAsBlob());
     90        promise->resolveWithNewlyCreated<IDLInterface<Blob>>(takeAsBlob().get());
    9191        return;
    9292    case Type::JSON:
    … …  
    9494        return;
    9595    case Type::Text:
    96         promise->resolve(takeAsText());
     96        promise->resolve<IDLDOMString>(takeAsText());
    9797        return;
    9898    case Type::None:

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

    r209195 r209390  
    9191{
    9292    if (isBodyNull()) {
    93         promise->resolve(Blob::create(Vector<uint8_t>(), Blob::normalizedContentType(extractMIMETypeFromMediaType(m_contentType))));
     93        promise->resolve<IDLInterface<Blob>>(Blob::create({ }, Blob::normalizedContentType(extractMIMETypeFromMediaType(m_contentType))).get());
    9494        return;
    9595    }
    … …  
    139139{
    140140    if (isBodyNull()) {
    141         promise->reject(0);
     141        promise->reject();
    142142        return;
    143143    }
    … …  
    167167{
    168168    if (isBodyNull()) {
    169         promise->resolve(String());
     169        promise->resolve<IDLDOMString>({ });
    170170        return;
    171171    }

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

    r209195 r209390  
    5353    static ExceptionOr<Ref<FetchResponse>> redirect(ScriptExecutionContext&, const String& url, int status);
    5454
    55     using FetchPromise = DOMPromise<FetchResponse>;
     55    using FetchPromise = DOMPromise<IDLInterface<FetchResponse>>;
    5656    static void fetch(ScriptExecutionContext&, FetchRequest&, FetchPromise&&);
    5757

  • trunk/Source/WebCore/Modules/mediasource/MediaSource.cpp

    r208985 r209390  
    3939#include "Event.h"
    4040#include "EventNames.h"
     41#include "ExceptionCode.h"
    4142#include "HTMLMediaElement.h"
    4243#include "Logging.h"

  • trunk/Source/WebCore/Modules/mediasource/SourceBuffer.cpp

    r208658 r209390  
    3939#include "Event.h"
    4040#include "EventNames.h"
     41#include "ExceptionCode.h"
    4142#include "GenericEventQueue.h"
    4243#include "HTMLMediaElement.h"

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

    r208663 r209390  
    3333#if ENABLE(MEDIA_STREAM)
    3434
     35#include "ExceptionOr.h"
    3536#include "JSDOMPromise.h"
    3637#include "MediaDeviceInfo.h"
    … …  
    4950    Document* document() const;
    5051
    51     using Promise = DOMPromise<MediaStream>;
    52     using EnumerateDevicesPromise = DOMPromise<MediaDeviceInfoVector>;
     52    using Promise = DOMPromise<IDLInterface<MediaStream>>;
     53    using EnumerateDevicesPromise = DOMPromise<IDLSequence<IDLInterface<MediaDeviceInfo>>>;
    5354
    5455    ExceptionOr<void> getUserMedia(Ref<MediaConstraintsImpl>&& audioConstraints, Ref<MediaConstraintsImpl>&& videoConstraints, Promise&&) const;

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

    r208703 r209390  
    704704}
    705705
    706 void MediaEndpointPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, PeerConnection::VoidPromise&& promise)
     706void MediaEndpointPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
    707707{
    708708    RTCRtpTransceiver* transceiver = matchTransceiver(m_peerConnection.getTransceivers(), [&sender] (RTCRtpTransceiver& current) {
    … …  
    724724}
    725725
    726 void MediaEndpointPeerConnection::replaceTrackTask(RTCRtpSender& sender, const String& mid, RefPtr<MediaStreamTrack>&& withTrack, PeerConnection::VoidPromise& promise)
     726void MediaEndpointPeerConnection::replaceTrackTask(RTCRtpSender& sender, const String& mid, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>& promise)
    727727{
    728728    if (m_peerConnection.internalSignalingState() == SignalingState::Closed)

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

    r208694 r209390  
    7070
    7171    Ref<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) override;
    72     void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, PeerConnection::VoidPromise&&) override;
     72    void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) override;
    7373
    7474    bool isNegotiationNeeded() const override { return m_negotiationNeeded; };
    … …  
    9797    void addIceCandidateTask(RTCIceCandidate&);
    9898
    99     void replaceTrackTask(RTCRtpSender&, const String& mid, RefPtr<MediaStreamTrack>&&, PeerConnection::VoidPromise&);
     99    void replaceTrackTask(RTCRtpSender&, const String& mid, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&);
    100100
    101101    bool localDescriptionTypeValidForState(RTCSessionDescription::SdpType) const;

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

    r208688 r209390  
    188188            return;
    189189
    190         weakThis->m_promise->reject(OverconstrainedError::create(failedConstraint, message).get());
     190        weakThis->m_promise->rejectType<IDLInterface<OverconstrainedError>>(OverconstrainedError::create(failedConstraint, message).get());
    191191    };
    192192

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

    r208985 r209390  
    128128}
    129129
    130 void PeerConnectionBackend::setLocalDescription(RTCSessionDescription& sessionDescription, PeerConnection::VoidPromise&& promise)
     130void PeerConnectionBackend::setLocalDescription(RTCSessionDescription& sessionDescription, DOMPromise<void>&& promise)
    131131{
    132132    ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
    … …  
    186186}
    187187
    188 void PeerConnectionBackend::setRemoteDescription(RTCSessionDescription& sessionDescription, PeerConnection::VoidPromise&& promise)
     188void PeerConnectionBackend::setRemoteDescription(RTCSessionDescription& sessionDescription, DOMPromise<void>&& promise)
    189189{
    190190    ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);
    … …  
    225225}
    226226
    227 void PeerConnectionBackend::addIceCandidate(RTCIceCandidate& iceCandidate, PeerConnection::VoidPromise&& promise)
     227void PeerConnectionBackend::addIceCandidate(RTCIceCandidate& iceCandidate, DOMPromise<void>&& promise)
    228228{
    229229    ASSERT(m_peerConnection.internalSignalingState() != PeerConnectionStates::SignalingState::Closed);

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

    r208985 r209390  
    6060
    6161namespace PeerConnection {
    62 typedef DOMPromise<RTCSessionDescription> SessionDescriptionPromise;
    63 typedef DOMPromise<void> VoidPromise;
    64 typedef DOMPromise<RTCStatsResponse> StatsPromise;
     62using SessionDescriptionPromise = DOMPromise<IDLInterface<RTCSessionDescription>>;
     63using StatsPromise = DOMPromise<IDLInterface<RTCStatsResponse>>;
    6564}
    6665
    … …  
    7675    void createOffer(RTCOfferOptions&&, PeerConnection::SessionDescriptionPromise&&);
    7776    void createAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
    78     void setLocalDescription(RTCSessionDescription&, PeerConnection::VoidPromise&&);
    79     void setRemoteDescription(RTCSessionDescription&, PeerConnection::VoidPromise&&);
    80     void addIceCandidate(RTCIceCandidate&, PeerConnection::VoidPromise&&);
     77    void setLocalDescription(RTCSessionDescription&, DOMPromise<void>&&);
     78    void setRemoteDescription(RTCSessionDescription&, DOMPromise<void>&&);
     79    void addIceCandidate(RTCIceCandidate&, DOMPromise<void>&&);
    8180
    8281    virtual std::unique_ptr<RTCDataChannelHandler> createDataChannelHandler(const String&, const RTCDataChannelInit&) = 0;
    … …  
    9998
    10099    virtual Ref<RTCRtpReceiver> createReceiver(const String& transceiverMid, const String& trackKind, const String& trackId) = 0;
    101     virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, PeerConnection::VoidPromise&&) = 0;
     100    virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
    102101
    103102    virtual bool isNegotiationNeeded() const = 0;
    … …  
    141140private:
    142141    std::optional<PeerConnection::SessionDescriptionPromise> m_offerAnswerPromise;
    143     std::optional<PeerConnection::VoidPromise> m_setDescriptionPromise;
    144     std::optional<PeerConnection::VoidPromise> m_addIceCandidatePromise;
     142    std::optional<DOMPromise<void>> m_setDescriptionPromise;
     143    std::optional<DOMPromise<void>> m_addIceCandidatePromise;
    145144};
    146145

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

    r208694 r209390  
    229229}
    230230
    231 void RTCPeerConnection::queuedSetLocalDescription(RTCSessionDescription& description, PeerConnection::VoidPromise&& promise)
     231void RTCPeerConnection::queuedSetLocalDescription(RTCSessionDescription& description, DOMPromise<void>&& promise)
    232232{
    233233    if (m_signalingState == SignalingState::Closed) {
    … …  
    254254}
    255255
    256 void RTCPeerConnection::queuedSetRemoteDescription(RTCSessionDescription& description, PeerConnection::VoidPromise&& promise)
     256void RTCPeerConnection::queuedSetRemoteDescription(RTCSessionDescription& description, DOMPromise<void>&& promise)
    257257{
    258258    if (m_signalingState == SignalingState::Closed) {
    … …  
    279279}
    280280
    281 void RTCPeerConnection::queuedAddIceCandidate(RTCIceCandidate& rtcCandidate, VoidPromise&& promise)
     281void RTCPeerConnection::queuedAddIceCandidate(RTCIceCandidate& rtcCandidate, DOMPromise<void>&& promise)
    282282{
    283283    if (m_signalingState == SignalingState::Closed) {
    … …  
    470470}
    471471
    472 void RTCPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, PeerConnection::VoidPromise&& promise)
     472void RTCPeerConnection::replaceTrack(RTCRtpSender& sender, RefPtr<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
    473473{
    474474    m_backend->replaceTrack(sender, WTFMove(withTrack), WTFMove(promise));

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

    r208694 r209390  
    9191    void queuedCreateAnswer(RTCAnswerOptions&&, PeerConnection::SessionDescriptionPromise&&);
    9292
    93     void queuedSetLocalDescription(RTCSessionDescription&, PeerConnection::VoidPromise&&);
     93    void queuedSetLocalDescription(RTCSessionDescription&, DOMPromise<void>&&);
    9494    RefPtr<RTCSessionDescription> localDescription() const;
    9595    RefPtr<RTCSessionDescription> currentLocalDescription() const;
    9696    RefPtr<RTCSessionDescription> pendingLocalDescription() const;
    9797
    98     void queuedSetRemoteDescription(RTCSessionDescription&, PeerConnection::VoidPromise&&);
     98    void queuedSetRemoteDescription(RTCSessionDescription&, DOMPromise<void>&&);
    9999    RefPtr<RTCSessionDescription> remoteDescription() const;
    100100    RefPtr<RTCSessionDescription> currentRemoteDescription() const;
    … …  
    103103    String signalingState() const;
    104104
    105     void queuedAddIceCandidate(RTCIceCandidate&, PeerConnection::VoidPromise&&);
     105    void queuedAddIceCandidate(RTCIceCandidate&, DOMPromise<void>&&);
    106106
    107107    String iceGatheringState() const;
    … …  
    156156
    157157    // RTCRtpSenderClient
    158     void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, PeerConnection::VoidPromise&&) final;
     158    void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) final;
    159159
    160160    PeerConnectionStates::SignalingState m_signalingState { PeerConnectionStates::SignalingState::Stable };

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

    r208118 r209390  
    6868}
    6969
    70 ExceptionOr<void> RTCRtpSender::replaceTrack(Ref<MediaStreamTrack>&& withTrack, PeerConnection::VoidPromise&& promise)
     70ExceptionOr<void> RTCRtpSender::replaceTrack(Ref<MediaStreamTrack>&& withTrack, DOMPromise<void>&& promise)
    7171{
    7272    if (isStopped()) {

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

    r208118 r209390  
    4040class RTCRtpSenderClient {
    4141public:
    42     virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, PeerConnection::VoidPromise&&) = 0;
     42    virtual void replaceTrack(RTCRtpSender&, RefPtr<MediaStreamTrack>&&, DOMPromise<void>&&) = 0;
    4343
    4444    virtual ~RTCRtpSenderClient() { }
    … …  
    6060    void setTrack(RefPtr<MediaStreamTrack>&&);
    6161
    62     ExceptionOr<void> replaceTrack(Ref<MediaStreamTrack>&&, PeerConnection::VoidPromise&&);
     62    ExceptionOr<void> replaceTrack(Ref<MediaStreamTrack>&&, DOMPromise<void>&&);
    6363
    6464private:

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

    r208938 r209390  
    213213        break;
    214214    case MediaAccessDenialReason::InvalidConstraint:
    215         m_promise.reject(OverconstrainedError::create(invalidConstraint, ASCIILiteral("Invalid constraint")).get());
     215        m_promise.rejectType<IDLInterface<OverconstrainedError>>(OverconstrainedError::create(invalidConstraint, ASCIILiteral("Invalid constraint")).get());
    216216        break;
    217217    case MediaAccessDenialReason::HardwareError:

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

    r208606 r209390  
    10321032
    10331033    if (m_state == State::Closed || m_state == State::Interrupted || !m_destinationNode) {
    1034         promise.reject(0);
     1034        promise.reject();
    10351035        return;
    10361036    }
    … …  
    10611061
    10621062    if (m_state == State::Closed || !m_destinationNode) {
    1063         promise.reject(0);
     1063        promise.reject();
    10641064        return;
    10651065    }

  • trunk/Source/WebCore/PlatformEfl.cmake

    r208677 r209390  
    408408        crypto/CryptoAlgorithmRegistry.cpp
    409409        crypto/CryptoKey.cpp
    410         crypto/CryptoKeyPair.cpp
    411410        crypto/SubtleCrypto.cpp
    412411        crypto/WebKitSubtleCrypto.cpp

  • trunk/Source/WebCore/PlatformGTK.cmake

    r208948 r209390  
    400400        crypto/CryptoAlgorithmRegistry.cpp
    401401        crypto/CryptoKey.cpp
    402         crypto/CryptoKeyPair.cpp
    403402        crypto/SubtleCrypto.cpp
    404403        crypto/WebKitSubtleCrypto.cpp

  • trunk/Source/WebCore/PlatformMac.cmake

    r209126 r209390  
    181181    crypto/CryptoAlgorithmRegistry.cpp
    182182    crypto/CryptoKey.cpp
    183     crypto/CryptoKeyPair.cpp
    184183    crypto/SubtleCrypto.cpp
    185184    crypto/WebKitSubtleCrypto.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r209346 r209390  
    62626262                E1F1E82F0C3C2BB9006DB391 /* XSLTExtensions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1F1E82D0C3C2BB9006DB391 /* XSLTExtensions.cpp */; };
    62636263                E1F1E8300C3C2BB9006DB391 /* XSLTExtensions.h in Headers */ = {isa = PBXBuildFile; fileRef = E1F1E82E0C3C2BB9006DB391 /* XSLTExtensions.h */; };
    6264                 E1F80B8718317252007885C3 /* CryptoKeyPair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1F80B8518317252007885C3 /* CryptoKeyPair.cpp */; };
    6265                 E1F80B8818317252007885C3 /* CryptoKeyPair.h in Headers */ = {isa = PBXBuildFile; fileRef = E1F80B8618317252007885C3 /* CryptoKeyPair.h */; };
    6266                 E1F80B8A183172A2007885C3 /* JSCryptoKeyPairCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1F80B89183172A2007885C3 /* JSCryptoKeyPairCustom.cpp */; };
     6264                E1F80B8818317252007885C3 /* CryptoKeyPair.h in Headers */ = {isa = PBXBuildFile; fileRef = E1F80B8618317252007885C3 /* CryptoKeyPair.h */; settings = {ATTRIBUTES = (Private, ); }; };
    62676265                E1F80B8D183172B5007885C3 /* JSCryptoKeyPair.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E1F80B8B183172B5007885C3 /* JSCryptoKeyPair.cpp */; };
    62686266                E1F80B8E183172B5007885C3 /* JSCryptoKeyPair.h in Headers */ = {isa = PBXBuildFile; fileRef = E1F80B8C183172B5007885C3 /* JSCryptoKeyPair.h */; };
    … …  
    97719769                5DB1BC6910715A6400EFAA49 /* TransformSourceLibxslt.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TransformSourceLibxslt.cpp; sourceTree = "<group>"; };
    97729770                5DFEBAB618592B6D00C75BEB /* WebKitAvailability.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WebKitAvailability.h; sourceTree = "<group>"; };
    9773                 5E16A2E21BFA64FB0029A21E /* MediaEndpointPeerConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MediaEndpointPeerConnection.cpp; sourceTree = "<group>"; };
    9774                 5E16A2E31BFA64FB0029A21E /* MediaEndpointPeerConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MediaEndpointPeerConnection.h; sourceTree = "<group>"; };
     9771                5E16A2E21BFA64FB0029A21E /* MediaEndpointPeerConnection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; lineEnding = 0; path = MediaEndpointPeerConnection.cpp; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.cpp; };
     9772                5E16A2E31BFA64FB0029A21E /* MediaEndpointPeerConnection.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; lineEnding = 0; path = MediaEndpointPeerConnection.h; sourceTree = "<group>"; xcLanguageSpecificationIdentifier = xcode.lang.objcpp; };
    97759773                5E2C434D1BCEE2E50001E2BC /* PeerConnectionBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PeerConnectionBackend.h; sourceTree = "<group>"; };
    97769774                5E2C434F1BCEE2E50001E2BC /* RTCConfiguration.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RTCConfiguration.cpp; sourceTree = "<group>"; };
    … …  
    1426214260                E1F1E82E0C3C2BB9006DB391 /* XSLTExtensions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = XSLTExtensions.h; sourceTree = "<group>"; };
    1426314261                E1F80B8418317247007885C3 /* CryptoKeyPair.idl */ = {isa = PBXFileReference; lastKnownFileType = text; path = CryptoKeyPair.idl; sourceTree = "<group>"; };
    14264                 E1F80B8518317252007885C3 /* CryptoKeyPair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CryptoKeyPair.cpp; sourceTree = "<group>"; };
    1426514262                E1F80B8618317252007885C3 /* CryptoKeyPair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = CryptoKeyPair.h; sourceTree = "<group>"; };
    14266                 E1F80B89183172A2007885C3 /* JSCryptoKeyPairCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCryptoKeyPairCustom.cpp; sourceTree = "<group>"; };
    1426714263                E1F80B8B183172B5007885C3 /* JSCryptoKeyPair.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCryptoKeyPair.cpp; sourceTree = "<group>"; };
    1426814264                E1F80B8C183172B5007885C3 /* JSCryptoKeyPair.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCryptoKeyPair.h; sourceTree = "<group>"; };
    … …  
    2205122047                                7CEF26181D6A92E300BE905D /* JSCryptoCustom.cpp */,
    2205222048                                E157A8E618184C67009F821D /* JSCryptoKeyCustom.cpp */,
    22053                                 E1F80B89183172A2007885C3 /* JSCryptoKeyPairCustom.cpp */,
    2205422049                                BC46C1ED0C0DDBDF0020CFC3 /* JSCSSRuleCustom.cpp */,
    2205522050                                AD726FE916D9F40A003A4E6D /* JSCSSRuleCustom.h */,
    … …  
    2320023195                                E157A8DC18172C2C009F821D /* CryptoKey.idl */,
    2320123196                                E125F85D182C2DF600D84CD9 /* CryptoKeyData.h */,
    23202                                 E1F80B8518317252007885C3 /* CryptoKeyPair.cpp */,
    2320323197                                E1F80B8618317252007885C3 /* CryptoKeyPair.h */,
    2320423198                                E1F80B8418317247007885C3 /* CryptoKeyPair.idl */,
    … …  
    2903329027                                E125F8351822F18A00D84CD9 /* CryptoKeyHMAC.cpp in Sources */,
    2903429028                                E19AC3F9182566F700349426 /* CryptoKeyMac.cpp in Sources */,
    29035                                 E1F80B8718317252007885C3 /* CryptoKeyPair.cpp in Sources */,
    2903629029                                57E2336B1DCC262400F28D01 /* CryptoKeyRSA.cpp in Sources */,
    2903729030                                E164FAA518315E1A00DB4E61 /* CryptoKeyRSAMac.cpp in Sources */,
    … …  
    2981429807                                E157A8E818184C67009F821D /* JSCryptoKeyCustom.cpp in Sources */,
    2981529808                                E1F80B8D183172B5007885C3 /* JSCryptoKeyPair.cpp in Sources */,
    29816                                 E1F80B8A183172A2007885C3 /* JSCryptoKeyPairCustom.cpp in Sources */,
    2981729809                                E125F85118283A5600D84CD9 /* JSCryptoKeySerializationJWK.cpp in Sources */,
    2981829810                                E125F83D182411E700D84CD9 /* JSCryptoOperationData.cpp in Sources */,

  • trunk/Source/WebCore/bindings/generic/IDLTypes.h

    r209303 r209390  
    4141namespace WebCore {
    4242
    43 class Dictionary;
    44 class EventListener;
    45 class XPathNSResolver;
    46 
    47 template <typename Value> class DOMPromise;
     43template<typename> class DOMPromise;
    4844
    4945template<typename T>
    5046struct IDLType {
    5147    using ImplementationType = T;
     48    using ParameterType = T;
    5249
    5350    using NullableType = std::optional<ImplementationType>;
    … …  
    8885
    8986struct IDLString : IDLType<String> {
     87    using ParameterType = const String&;
     88
    9089    using NullableType = String;
    9190    static String nullValue() { return String(); }
    … …  
    101100template<typename T> struct IDLWrapper : IDLType<RefPtr<T>> {
    102101    using RawType = T;
     102
     103    using ParameterType = T&;
     104
    103105    using NullableType = RefPtr<T>;
    104 
    105106    static inline std::nullptr_t nullValue() { return nullptr; }
    106107    template<typename U> static inline bool isNullValue(U&& value) { return !value; }
    … …  
    112113template<typename T> struct IDLCallbackFunction : IDLWrapper<T> { };
    113114
    114 template<typename T> struct IDLDictionary : IDLType<T> { };
     115template<typename T> struct IDLDictionary : IDLType<T> {
     116    using ParameterType = const T&;
     117};
     118
    115119template<typename T> struct IDLEnumeration : IDLType<T> { };
    116120
    … …  
    121125template<typename T> struct IDLSequence : IDLType<Vector<typename T::ImplementationType>> {
    122126    using InnerType = T;
     127
     128    using ParameterType = const Vector<typename T::ImplementationType>&;
    123129};
    124130
    125131template<typename T> struct IDLFrozenArray : IDLType<Vector<typename T::ImplementationType>> {
    126132    using InnerType = T;
     133
     134    using ParameterType = const Vector<typename T::ImplementationType>&;
    127135};
    128136
    … …  
    130138    using KeyType = K;
    131139    using ValueType = V;
     140
     141    using ParameterType = const HashMap<typename K::ImplementationType, typename V::ImplementationType>&;
    132142};
    133143
    … …  
    142152struct IDLUnion : IDLType<Variant<typename Ts::ImplementationType...>> {
    143153    using TypeList = brigand::list<Ts...>;
     154
     155    using ParameterType = const Variant<typename Ts::ImplementationType...>&;
    144156};
    145157

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

    r208841 r209390  
    172172
    173173    if (registry.findInterface(localName)) {
    174         DeferredPromise::create(globalObject, promiseDeferred)->resolve(nullptr);
     174        DeferredPromise::create(globalObject, promiseDeferred)->resolve();
    175175        return promiseDeferred.promise();
    176176    }

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

    r209303 r209390  
    10671067};
    10681068
     1069template<typename T> struct JSConverter<IDLDictionary<T>> {
     1070    static constexpr bool needsState = true;
     1071    static constexpr bool needsGlobalObject = true;
     1072
     1073    static JSC::JSValue convert(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const T& dictionary)
     1074    {
     1075        return convertDictionaryToJS(state, globalObject, dictionary);
     1076    }
     1077};
     1078
    10691079// MARK: -
    10701080// MARK: Enumeration type

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

    r206976 r209390  
    9090}
    9191
     92void DeferredPromise::reject()
     93{
     94    if (isSuspended())
     95        return;
     96
     97    ASSERT(m_deferred);
     98    ASSERT(m_globalObject);
     99    auto& state = *m_globalObject->globalExec();
     100    JSC::JSLockHolder locker(&state);
     101    reject(state, JSC::jsUndefined());
     102}
     103
     104void DeferredPromise::reject(std::nullptr_t)
     105{
     106    if (isSuspended())
     107        return;
     108
     109    ASSERT(m_deferred);
     110    ASSERT(m_globalObject);
     111    auto& state = *m_globalObject->globalExec();
     112    JSC::JSLockHolder locker(&state);
     113    reject(state, JSC::jsNull());
     114}
     115
    92116void DeferredPromise::reject(Exception&& exception)
    93117{
    … …  
    114138}
    115139
     140void DeferredPromise::reject(const JSC::PrivateName& privateName)
     141{
     142    if (isSuspended())
     143        return;
     144
     145    ASSERT(m_deferred);
     146    ASSERT(m_globalObject);
     147    JSC::ExecState* state = m_globalObject->globalExec();
     148    JSC::JSLockHolder locker(state);
     149    reject(*state, toJS(state, m_globalObject.get(), privateName));
     150}
     151
    116152void rejectPromiseWithExceptionIfAny(JSC::ExecState& state, JSDOMGlobalObject& globalObject, JSPromiseDeferred& promiseDeferred)
    117153{
    … …  
    125161    scope.clearException();
    126162
    127     DeferredPromise::create(globalObject, promiseDeferred)->reject(error);
     163    DeferredPromise::create(globalObject, promiseDeferred)->reject<IDLAny>(error);
    128164}
    129165
    … …  
    167203        promise->reject(SYNTAX_ERR);
    168204    else
    169         promise->resolve(value);
     205        promise->resolve<IDLAny>(value);
    170206}
    171207
    … …  
    173209{
    174210    if (!arrayBuffer) {
    175         promise->reject<JSValue>(createOutOfMemoryError(promise->globalObject()->globalExec()));
     211        promise->reject<IDLAny>(createOutOfMemoryError(promise->globalObject()->globalExec()));
    176212        return;
    177213    }
    178     promise->resolve(arrayBuffer);
     214    promise->resolve<IDLInterface<ArrayBuffer>>(*arrayBuffer);
    179215}
    180216

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

    r208985 r209390  
    2727
    2828#include "ActiveDOMCallback.h"
    29 #include "JSDOMBinding.h"
     29#include "JSDOMConvert.h"
    3030#include <heap/StrongInlines.h>
    3131#include <runtime/JSPromiseDeferred.h>
    … …  
    3333namespace WebCore {
    3434
    35 template<typename DOMClass>
    36 struct TypeInspector {
    37 private:
    38     template<typename T> static constexpr auto testIsVector(int) -> decltype(std::declval<T>().shrinkToFit(), bool()) { return true; }
    39     template<typename T> static constexpr bool testIsVector(...) { return false; }
    40 
    41     template<typename T> static constexpr auto testIsRef(int) -> decltype(T::isRef) { return true; }
    42     template<typename T> static constexpr bool testIsRef(...) { return false; }
    43 
    44     template<typename T> static constexpr auto testIsRefPtr(int) -> decltype(T::isRefPtr) { return true; }
    45     template<typename T> static constexpr bool testIsRefPtr(...) { return false; }
    46 
    47 public:
    48     static constexpr bool isRefOrRefPtr = testIsRef<DOMClass>(0) || testIsRefPtr<DOMClass>(0);
    49     static constexpr bool isPassByValueType = std::is_pointer<DOMClass>::value
    50         || std::is_same<DOMClass, std::nullptr_t>::value
    51         || std::is_same<DOMClass, JSC::JSValue>::value
    52         || std::is_same<DOMClass, bool>::value;
    53     static constexpr bool isPassByConstRefType = testIsVector<DOMClass>(0)
    54         || std::is_same<DOMClass, String>::value;
    55 };
    56 
    57 template<typename DOMClass, typename Enable = void>
    58 struct PromiseResultInspector {
    59 public:
    60     static constexpr bool passByValue = false;
    61     static constexpr bool passByRef = true;
    62     static constexpr bool passByURef = false;
    63     static constexpr bool passByConstRef = false;
    64 
    65     typedef DOMClass& Type;
    66 };
    67 
    68 template<>
    69 struct PromiseResultInspector<void> {
    70 public:
    71     typedef int Type;
    72 };
    73 
    74 template<typename DOMClass>
    75 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByValueType>::type> {
    76 public:
    77     static constexpr bool passByValue = true;
    78     static constexpr bool passByRef = false;
    79     static constexpr bool passByURef = false;
    80     static constexpr bool passByConstRef = false;
    81 
    82     typedef DOMClass Type;
    83 };
    84 
    85 template<typename DOMClass>
    86 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isPassByConstRefType>::type> {
    87 public:
    88     static constexpr bool passByValue = false;
    89     static constexpr bool passByRef = false;
    90     static constexpr bool passByURef = false;
    91     static constexpr bool passByConstRef = true;
    92 
    93     typedef const DOMClass& Type;
    94 };
    95 
    96 template<typename DOMClass>
    97 struct PromiseResultInspector<DOMClass, typename std::enable_if<TypeInspector<DOMClass>::isRefOrRefPtr>::type> {
    98     static constexpr bool passByValue = false;
    99     static constexpr bool passByRef = false;
    100     static constexpr bool passByURef = true;
    101     static constexpr bool passByConstRef = false;
    102 };
    103 
    10435class DeferredPromise : public RefCounted<DeferredPromise>, public ActiveDOMCallback {
    10536public:
    … …  
    11142    ~DeferredPromise();
    11243
    113     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByValue, void>::type
    114     resolve(ResolveResultType result) { resolveWithValue(result); }
    115     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByRef, void>::type
    116     resolve(ResolveResultType& result) { resolveWithValue(result); }
    117     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByURef, void>::type
    118     resolve(ResolveResultType&& result) { resolveWithValue(std::forward<ResolveResultType>(result)); }
    119     template<class ResolveResultType> typename std::enable_if<PromiseResultInspector<ResolveResultType>::passByConstRef, void>::type
    120     resolve(const ResolveResultType& result) { resolveWithValue(result); }
    121 
    122     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByValue, void>::type
    123     reject(RejectResultType result) { rejectWithValue(result); }
    124     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByRef, void>::type
    125     reject(RejectResultType& result) { rejectWithValue(result); }
    126     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByURef, void>::type
    127     reject(RejectResultType&& result) { rejectWithValue(std::forward<RejectResultType>(result)); }
    128     template<class RejectResultType> typename std::enable_if<PromiseResultInspector<RejectResultType>::passByConstRef, void>::type
    129     reject(const RejectResultType& result) { rejectWithValue(result); }
    130 
    131     template<class ResolveResultType> void resolveWithNewlyCreated(Ref<ResolveResultType>&&);
    132 
     44    template<class IDLType>
     45    void resolve(typename IDLType::ParameterType value)
     46    {
     47        if (isSuspended())
     48            return;
     49        ASSERT(m_deferred);
     50        ASSERT(m_globalObject);
     51        JSC::ExecState* exec = m_globalObject->globalExec();
     52        JSC::JSLockHolder locker(exec);
     53        resolve(*exec, toJS<IDLType>(*exec, *m_globalObject.get(), std::forward<typename IDLType::ParameterType>(value)));
     54    }
     55
     56    void resolve()
     57    {
     58        if (isSuspended())
     59            return;
     60        ASSERT(m_deferred);
     61        ASSERT(m_globalObject);
     62        JSC::ExecState* exec = m_globalObject->globalExec();
     63        JSC::JSLockHolder locker(exec);
     64        resolve(*exec, JSC::jsUndefined());
     65    }
     66
     67    template<class IDLType>
     68    void resolveWithNewlyCreated(typename IDLType::ParameterType value)
     69    {
     70        if (isSuspended())
     71            return;
     72        ASSERT(m_deferred);
     73        ASSERT(m_globalObject);
     74        JSC::ExecState* exec = m_globalObject->globalExec();
     75        JSC::JSLockHolder locker(exec);
     76        resolve(*exec, toJSNewlyCreated<IDLType>(*exec, *m_globalObject.get(), std::forward<typename IDLType::ParameterType>(value)));
     77    }
     78
     79    template<class IDLType>
     80    void reject(typename IDLType::ParameterType value)
     81    {
     82        if (isSuspended())
     83            return;
     84        ASSERT(m_deferred);
     85        ASSERT(m_globalObject);
     86        JSC::ExecState* exec = m_globalObject->globalExec();
     87        JSC::JSLockHolder locker(exec);
     88        reject(*exec, toJS<IDLType>(*exec, *m_globalObject.get(), std::forward<typename IDLType::ParameterType>(value)));
     89    }
     90
     91    void reject();
     92    void reject(std::nullptr_t);
    13393    void reject(Exception&&);
    13494    void reject(ExceptionCode, const String& = { });
     95    void reject(const JSC::PrivateName&);
    13596
    13697    JSC::JSValue promise() const;
    … …  
    151112    void reject(JSC::ExecState& state, JSC::JSValue resolution) { callFunction(state, m_deferred->reject(), resolution); }
    152113
    153     template<class RejectResultType> void rejectWithValue(RejectResultType&&);
    154     template<class ResolveResultType> void resolveWithValue(ResolveResultType&&);
    155 
    156114    JSC::Weak<JSC::JSPromiseDeferred> m_deferred;
    157115    JSC::Weak<JSDOMGlobalObject> m_globalObject;
    158116};
     117
     118class DOMPromiseBase {
     119public:
     120    DOMPromiseBase(Ref<DeferredPromise>&& genericPromise)
     121        : m_promiseDeferred(WTFMove(genericPromise))
     122    {
     123    }
     124
     125    DOMPromiseBase(DOMPromiseBase&& promise)
     126        : m_promiseDeferred(WTFMove(promise.m_promiseDeferred))
     127    {
     128    }
     129
     130    DOMPromiseBase(const DOMPromiseBase& other)
     131        : m_promiseDeferred(other.m_promiseDeferred.copyRef())
     132    {
     133    }
     134
     135    DOMPromiseBase& operator=(const DOMPromiseBase& other)
     136    {
     137        m_promiseDeferred = other.m_promiseDeferred.copyRef();
     138        return *this;
     139    }
     140
     141    DOMPromiseBase& operator=(DOMPromiseBase&& other)
     142    {
     143        m_promiseDeferred = WTFMove(other.m_promiseDeferred);
     144        return *this;
     145    }
     146
     147    void reject()
     148    {
     149        m_promiseDeferred->reject();
     150    }
     151
     152    template<typename... ErrorType>
     153    void reject(ErrorType&&... error)
     154    {
     155        m_promiseDeferred->reject(std::forward<ErrorType>(error)...);
     156    }
     157
     158    template<typename IDLType>
     159    void rejectType(typename IDLType::ParameterType value)
     160    {
     161        m_promiseDeferred->reject<IDLType>(std::forward<typename IDLType::ParameterType>(value));
     162    }
     163
     164    JSC::JSValue promise() const { return m_promiseDeferred->promise(); };
     165
     166protected:
     167    Ref<DeferredPromise> m_promiseDeferred;
     168};
     169
     170template<typename IDLType>
     171class DOMPromise : public DOMPromiseBase {
     172public:
     173    using DOMPromiseBase::DOMPromiseBase;
     174    using DOMPromiseBase::operator=;
     175    using DOMPromiseBase::promise;
     176    using DOMPromiseBase::reject;
     177
     178    void resolve(typename IDLType::ParameterType value)
     179    {
     180        m_promiseDeferred->resolve<IDLType>(std::forward<typename IDLType::ParameterType>(value));
     181    }
     182};
     183
     184template<> class DOMPromise<void> : public DOMPromiseBase {
     185public:
     186    using DOMPromiseBase::DOMPromiseBase;
     187    using DOMPromiseBase::operator=;
     188    using DOMPromiseBase::promise;
     189    using DOMPromiseBase::reject;
     190
     191    void resolve()
     192    {
     193        m_promiseDeferred->resolve();
     194    }
     195};
     196
    159197
    160198Ref<DeferredPromise> createDeferredPromise(JSC::ExecState&, JSDOMWindow&);
    … …  
    203241}
    204242
    205 // At the moment, Value cannot be a Ref<T> or RefPtr<T>, it should be a DOM class.
    206 template<typename Value> class DOMPromise {
    207 public:
    208     DOMPromise(Ref<DeferredPromise>&& genericPromise) : m_promiseDeferred(WTFMove(genericPromise)) { }
    209     DOMPromise(DOMPromise&& promise) : m_promiseDeferred(WTFMove(promise.m_promiseDeferred)) { }
    210     DOMPromise(const DOMPromise& other) : m_promiseDeferred(other.m_promiseDeferred.copyRef()) { }
    211 
    212     DOMPromise& operator=(const DOMPromise& other)
    213     {
    214         m_promiseDeferred = other.copyRef();
    215         return *this;
    216     }
    217 
    218     DOMPromise& operator=(DOMPromise&& other)
    219     {
    220         m_promiseDeferred = WTFMove(other.m_promiseDeferred);
    221         return *this;
    222     }
    223 
    224     template<typename T = Value>
    225     typename std::enable_if<!std::is_void<T>::value, void>::type resolve(typename PromiseResultInspector<Value>::Type value) { m_promiseDeferred->resolve(value); }
    226 
    227     template<typename T = Value>
    228     typename std::enable_if<std::is_void<T>::value, void>::type resolve() { m_promiseDeferred->resolve(nullptr); }
    229 
    230     template<typename... ErrorType> void reject(ErrorType&&... error) { m_promiseDeferred->reject(std::forward<ErrorType>(error)...); }
    231 
    232     JSC::JSValue promise() const { return m_promiseDeferred->promise(); };
    233 
    234 private:
    235     Ref<DeferredPromise> m_promiseDeferred;
    236 };
    237 
    238 template<class ResolveResultType>
    239 inline void DeferredPromise::resolveWithValue(ResolveResultType&& result)
    240 {
    241     if (isSuspended())
    242         return;
    243     ASSERT(m_globalObject);
    244     JSC::ExecState* exec = m_globalObject->globalExec();
    245     JSC::JSLockHolder locker(exec);
    246     resolve(*exec, toJS(exec, m_globalObject.get(), std::forward<ResolveResultType>(result)));
    247 }
    248 
    249 template<class ResolveResultType>
    250 inline void DeferredPromise::resolveWithNewlyCreated(Ref<ResolveResultType>&& result)
    251 {
    252     if (isSuspended())
    253         return;
    254     ASSERT(m_deferred);
    255     ASSERT(m_globalObject);
    256     JSC::ExecState* exec = m_globalObject->globalExec();
    257     JSC::JSLockHolder locker(exec);
    258     resolve(*exec, toJSNewlyCreated(exec, m_globalObject.get(), WTFMove(result)));
    259 }
    260 
    261 template<class RejectResultType>
    262 inline void DeferredPromise::rejectWithValue(RejectResultType&& result)
    263 {
    264     if (isSuspended())
    265         return;
    266     ASSERT(m_deferred);
    267     ASSERT(m_globalObject);
    268     JSC::ExecState* exec = m_globalObject->globalExec();
    269     JSC::JSLockHolder locker(exec);
    270     reject(*exec, toJS(exec, m_globalObject.get(), std::forward<RejectResultType>(result)));
    271 }
    272 
    273 template<>
    274 inline void DeferredPromise::resolve(bool result)
    275 {
    276     if (isSuspended())
    277         return;
    278     ASSERT(m_deferred);
    279     ASSERT(m_globalObject);
    280     JSC::ExecState* exec = m_globalObject->globalExec();
    281     JSC::JSLockHolder locker(exec);
    282     resolve(*exec, JSC::jsBoolean(result));
    283 }
    284 
    285 template<>
    286 inline void DeferredPromise::resolve(JSC::JSValue value)
    287 {
    288     if (isSuspended())
    289         return;
    290     ASSERT(m_deferred);
    291     ASSERT(m_globalObject);
    292     JSC::ExecState* exec = m_globalObject->globalExec();
    293     JSC::JSLockHolder locker(exec);
    294     resolve(*exec, value);
    295 }
    296 
    297 template<>
    298 inline void DeferredPromise::reject(JSC::JSValue value)
    299 {
    300     if (isSuspended())
    301         return;
    302     ASSERT(m_deferred);
    303     ASSERT(m_globalObject);
    304     JSC::ExecState* exec = m_globalObject->globalExec();
    305     JSC::JSLockHolder locker(exec);
    306     reject(*exec, value);
    307 }
    308 
    309 template<>
    310 inline void DeferredPromise::resolve(std::nullptr_t)
    311 {
    312     if (isSuspended())
    313         return;
    314     ASSERT(m_deferred);
    315     ASSERT(m_globalObject);
    316     JSC::ExecState* exec = m_globalObject->globalExec();
    317     JSC::JSLockHolder locker(exec);
    318     resolve(*exec, JSC::jsUndefined());
    319 }
    320 
    321 template<>
    322 inline void DeferredPromise::reject(std::nullptr_t)
    323 {
    324     if (isSuspended())
    325         return;
    326     ASSERT(m_deferred);
    327     ASSERT(m_globalObject);
    328     JSC::ExecState* exec = m_globalObject->globalExec();
    329     JSC::JSLockHolder locker(exec);
    330     reject(*exec, JSC::jsNull());
    331 }
    332 
    333 template<>
    334 inline void DeferredPromise::resolve(const String& result)
    335 {
    336     if (isSuspended())
    337         return;
    338     ASSERT(m_deferred);
    339     ASSERT(m_globalObject);
    340     JSC::ExecState* exec = m_globalObject->globalExec();
    341     JSC::JSLockHolder locker(exec);
    342     resolve(*exec, jsString(exec, result));
    343 }
    344 
    345 template<>
    346 inline void DeferredPromise::reject(const String& result)
    347 {
    348     if (isSuspended())
    349         return;
    350     ASSERT(m_deferred);
    351     ASSERT(m_globalObject);
    352     JSC::ExecState* exec = m_globalObject->globalExec();
    353     JSC::JSLockHolder locker(exec);
    354     reject(*exec, jsString(exec, result));
    355 }
    356 
    357243} // namespace WebCore

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

    r208985 r209390  
    3232#include "Dictionary.h"
    3333#include "ExceptionCode.h"
     34#include "JSDOMPromise.h"
    3435#include "JSMediaDevices.h"
    3536#include "Logging.h"

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

    r209200 r209390  
    478478
    479479    if (UNLIKELY(state.argumentCount() < 3)) {
    480         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     480        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    481481        return;
    482482    }
    … …  
    523523
    524524    if (UNLIKELY(state.argumentCount() < 3)) {
    525         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     525        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    526526        return;
    527527    }
    … …  
    568568
    569569    if (UNLIKELY(state.argumentCount() < 3)) {
    570         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     570        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    571571        return;
    572572    }
    … …  
    613613
    614614    if (UNLIKELY(state.argumentCount() < 4)) {
    615         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     615        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    616616        return;
    617617    }
    … …  
    643643
    644644    auto callback = [capturedPromise = promise.copyRef()](bool result) mutable {
    645         capturedPromise->resolve(result);
     645        capturedPromise->resolve<IDLBoolean>(result);
    646646        return;
    647647    };
    … …  
    661661
    662662    if (UNLIKELY(state.argumentCount() < 2)) {
    663         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     663        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    664664        return;
    665665    }
    … …  
    693693
    694694    if (UNLIKELY(state.argumentCount() < 5)) {
    695         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     695        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    696696        return;
    697697    }
    … …  
    710710
    711711    if (UNLIKELY(state.argumentCount() < 3)) {
    712         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     712        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    713713        return;
    714714    }
    … …  
    727727
    728728    if (UNLIKELY(state.argumentCount() < 3)) {
    729         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     729        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    730730        return;
    731731    }
    … …  
    743743    RETURN_IF_EXCEPTION(scope, void());
    744744
    745     auto callback = [capturedPromise = promise.copyRef()](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
    746         ASSERT(key || keyPair);
    747         ASSERT(!key || !keyPair);
    748         if (key) {
    749             if ((key->type() == CryptoKeyType::Private || key->type() == CryptoKeyType::Secret) && !key->usagesBitmap()) {
    750                 rejectWithException(WTFMove(capturedPromise), SYNTAX_ERR);
    751                 return;
    752             }
    753             capturedPromise->resolve(key);
    754         } else {
    755             if (!keyPair->privateKey()->usagesBitmap()) {
    756                 rejectWithException(WTFMove(capturedPromise), SYNTAX_ERR);
    757                 return;
    758             }
    759             capturedPromise->resolve(keyPair);
    760         }
     745    auto callback = [capturedPromise = promise.copyRef()](KeyOrKeyPair&& keyOrKeyPair) mutable {
     746        WTF::switchOn(keyOrKeyPair,
     747            [&capturedPromise] (RefPtr<CryptoKey>& key) {
     748                if ((key->type() == CryptoKeyType::Private || key->type() == CryptoKeyType::Secret) && !key->usagesBitmap()) {
     749                    rejectWithException(WTFMove(capturedPromise), SYNTAX_ERR);
     750                    return;
     751                }
     752                capturedPromise->resolve<IDLInterface<CryptoKey>>(*key);
     753            },
     754            [&capturedPromise] (CryptoKeyPair& keyPair) {
     755                if (!keyPair.privateKey->usagesBitmap()) {
     756                    rejectWithException(WTFMove(capturedPromise), SYNTAX_ERR);
     757                    return;
     758                }
     759                capturedPromise->resolve<IDLDictionary<CryptoKeyPair>>(keyPair);
     760            }
     761        );
    761762    };
    762763    auto exceptionCallback = [capturedPromise = WTFMove(promise)](ExceptionCode ec) mutable {
    … …  
    776777
    777778    if (UNLIKELY(state.argumentCount() < 5)) {
    778         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     779        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    779780        return;
    780781    }
    … …  
    803804            return;
    804805        }
    805         capturedPromise->resolve(key);
     806        capturedPromise->resolve<IDLInterface<CryptoKey>>(key);
    806807    };
    807808    auto exceptionCallback = [capturedPromise = WTFMove(promise)](ExceptionCode ec) mutable {
    … …  
    821822
    822823    if (UNLIKELY(state.argumentCount() < 2)) {
    823         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     824        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    824825        return;
    825826    }
    … …  
    852853        }
    853854        case SubtleCrypto::KeyFormat::Jwk:
    854             capturedPromise->resolve(toJSValueFromJsonWebKey(*(capturedPromise->globalObject()), WTFMove(WTF::get<JsonWebKey>(key))));
     855            capturedPromise->resolve<IDLAny>(toJSValueFromJsonWebKey(*(capturedPromise->globalObject()), WTFMove(WTF::get<JsonWebKey>(key))));
    855856            return;
    856857        }
    … …  
    873874
    874875    if (UNLIKELY(state.argumentCount() < 4)) {
    875         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     876        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    876877        return;
    877878    }
    … …  
    974975
    975976    if (UNLIKELY(state.argumentCount() < 7)) {
    976         promise->reject<JSValue>(createNotEnoughArgumentsError(&state));
     977        promise->reject<IDLAny>(createNotEnoughArgumentsError(&state));
    977978        return;
    978979    }
    … …  
    10521053                return;
    10531054            }
    1054             promise->resolve(key);
     1055            promise->resolve<IDLInterface<CryptoKey>>(key);
    10551056        };
    10561057        auto exceptionCallback = [promise = WTFMove(promise)](ExceptionCode ec) mutable {

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

    r208985 r209390  
    179179    };
    180180    auto failureCallback = [wrapper]() mutable {
    181         wrapper->reject(nullptr);
     181        wrapper->reject(); // FIXME: This should reject with an Exception.
    182182    };
    183183
    … …  
    231231    };
    232232    auto failureCallback = [wrapper]() mutable {
    233         wrapper->reject(nullptr);
     233        wrapper->reject(); // FIXME: This should reject with an Exception.
    234234    };
    235235
    … …  
    283283    };
    284284    auto failureCallback = [wrapper]() mutable {
    285         wrapper->reject(nullptr);
     285        wrapper->reject(); // FIXME: This should reject with an Exception.
    286286    };
    287287
    … …  
    338338    auto promise = wrapper->promise();
    339339    auto successCallback = [wrapper](bool result) mutable {
    340         wrapper->resolve(result);
     340        wrapper->resolve<IDLBoolean>(result);
    341341    };
    342342    auto failureCallback = [wrapper]() mutable {
    343         wrapper->reject(nullptr);
     343        wrapper->reject(); // FIXME: This should reject with an Exception.
    344344    };
    345345
    … …  
    383383    };
    384384    auto failureCallback = [wrapper]() mutable {
    385         wrapper->reject(nullptr);
     385        wrapper->reject(); // FIXME: This should reject with an Exception.
    386386    };
    387387
    … …  
    429429    RefPtr<DeferredPromise> wrapper = createDeferredPromise(state, domWindow());
    430430    auto promise = wrapper->promise();
    431     auto successCallback = [wrapper](CryptoKey* key, CryptoKeyPair* keyPair) mutable {
    432         ASSERT(key || keyPair);
    433         ASSERT(!key || !keyPair);
    434         if (key)
    435             wrapper->resolve(key);
    436         else
    437             wrapper->resolve(keyPair);
     431    auto successCallback = [wrapper](KeyOrKeyPair&& keyOrKeyPair) mutable {
     432        WTF::switchOn(keyOrKeyPair,
     433            [&wrapper] (RefPtr<CryptoKey>& key) {
     434                wrapper->resolve<IDLInterface<CryptoKey>>(*key);
     435            },
     436            [&wrapper] (CryptoKeyPair& keyPair) {
     437                wrapper->resolve<IDLDictionary<CryptoKeyPair>>(keyPair);
     438            }
     439        );
    438440    };
    439441    auto failureCallback = [wrapper]() mutable {
    440         wrapper->reject(nullptr);
     442        wrapper->reject(); // FIXME: This should reject with an Exception.
    441443    };
    442444
    … …  
    556558    auto promise = wrapper->promise();
    557559    auto successCallback = [wrapper](CryptoKey& result) mutable {
    558         wrapper->resolve(result);
     560        wrapper->resolve<IDLInterface<CryptoKey>>(result);
    559561    };
    560562    auto failureCallback = [wrapper]() mutable {
    561         wrapper->reject(nullptr);
     563        wrapper->reject(); // FIXME: This should reject with an Exception.
    562564    };
    563565
    … …  
    626628    };
    627629    auto failureCallback = [wrapper]() mutable {
    628         wrapper->reject(nullptr);
     630        wrapper->reject(); // FIXME: This should reject with an Exception.
    629631    };
    630632
    … …  
    681683        };
    682684        auto encryptFailureCallback = [wrapper]() mutable {
    683             wrapper->reject(nullptr);
     685        wrapper->reject(); // FIXME: This should reject with an Exception.
    684686        };
    685687        auto result = algorithm->encryptForWrapKey(*parameters, *wrappingKey, std::make_pair(exportedKeyData.data(), exportedKeyData.size()), WTFMove(encryptSuccessCallback), WTFMove(encryptFailureCallback));
    686688        if (result.hasException()) {
    687689            // FIXME: Report failure details to console, and possibly to calling script once there is a standardized way to pass errors to WebCrypto promise reject functions.
    688             wrapper->reject(nullptr);
     690            wrapper->reject(); // FIXME: This should reject with an Exception.
    689691        }
    690692    };
    691693
    692694    auto exportFailureCallback = [wrapper]() mutable {
    693         wrapper->reject(nullptr);
     695        wrapper->reject(); // FIXME: This should reject with an Exception.
    694696    };
    695697
    … …  
    772774    auto decryptSuccessCallback = [domGlobalObject, keyFormat, unwrappedKeyAlgorithm, unwrappedKeyAlgorithmParameters, extractable, keyUsages, wrapper](const Vector<uint8_t>& result) mutable {
    773775        auto importSuccessCallback = [wrapper](CryptoKey& key) mutable {
    774             wrapper->resolve(key);
     776            wrapper->resolve<IDLInterface<CryptoKey>>(key);
    775777        };
    776778        auto importFailureCallback = [wrapper]() mutable {
    777             wrapper->reject(nullptr);
     779            wrapper->reject(); // FIXME: This should reject with an Exception.
    778780        };
    779781
    … …  
    786788            // FIXME: Report exception details to console, and possibly to calling script once there is a standardized way to pass errors to WebCrypto promise reject functions.
    787789            scope.clearException();
    788             wrapper->reject(nullptr);
     790            wrapper->reject(); // FIXME: This should reject with an Exception.
    789791        }
    790792    };
    791793
    792794    auto decryptFailureCallback = [wrapper]() mutable {
    793         wrapper->reject(nullptr);
     795        wrapper->reject(); // FIXME: This should reject with an Exception.
    794796    };
    795797

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

    r208788 r209390  
    7373    // value is a Symbol, it is used directly as a module key.
    7474    if (moduleNameValue.isSymbol()) {
    75         promise->resolve(asSymbol(moduleNameValue)->privateName());
     75        promise->resolve<IDLAny>(toJS(exec, &globalObject, asSymbol(moduleNameValue)->privateName()));
    7676        return jsPromise.promise();
    7777    }
    … …  
    8989    URL absoluteURL(URL(), specifier);
    9090    if (absoluteURL.isValid()) {
    91         promise->resolve(absoluteURL.string());
     91        promise->resolve<IDLDOMString>(absoluteURL.string());
    9292        return jsPromise.promise();
    9393    }
    … …  
    130130    }
    131131
    132     promise->resolve(completedURL.string());
     132    promise->resolve<IDLDOMString>(completedURL.string());
    133133    return jsPromise.promise();
    134134}
    … …  
    248248    m_requestURLToResponseURLMap.add(cachedScript.url(), cachedScript.response().url());
    249249    // FIXME: Let's wrap around ScriptSourceCode to propagate it directly through the module pipeline.
    250     promise->resolve(ScriptSourceCode(&cachedScript, JSC::SourceProviderSourceType::Module).source().toString());
    251 }
    252 
    253 }
     250    promise->resolve<IDLDOMString>(ScriptSourceCode(&cachedScript, JSC::SourceProviderSourceType::Module).source().toString());
     251}
     252
     253}

  • trunk/Source/WebCore/bindings/scripts/CodeGeneratorJS.pm

    r209303 r209390  
    12051205    my $result = "";
    12061206    $result .= "#if ${conditionalString}\n\n" if $conditionalString;
    1207     $result .= "template<> $className convertDictionary<$className>(JSC::ExecState&, JSC::JSValue);\n\n";
     1207    $result .= "template<> ${className} convertDictionary<$className>(JSC::ExecState&, JSC::JSValue);\n\n";
     1208
     1209    if ($dictionary->extendedAttributes->{JSGenerateToJSObject}) {
     1210        $result .= "JSC::JSObject* convertDictionaryToJS(JSC::ExecState&, JSDOMGlobalObject&, const ${className}&);\n\n";
     1211    }
     1212
    12081213    $result .= "#endif\n\n" if $conditionalString;
    12091214    return $result;
    … …  
    12481253    $result .= "    bool isNullOrUndefined = value.isUndefinedOrNull();\n";
    12491254    $result .= "    auto* object = isNullOrUndefined ? nullptr : value.getObject();\n";
     1255
    12501256    # 1. If Type(V) is not Undefined, Null or Object, then throw a TypeError.
    12511257    $result .= "    if (UNLIKELY(!isNullOrUndefined && !object)) {\n";
    … …  
    13211327    $result .= "    return result;\n";
    13221328    $result .= "}\n\n";
     1329
     1330    if ($dictionary->extendedAttributes->{JSGenerateToJSObject}) {
     1331        $result .= "JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject& globalObject, const ${className}& dictionary)\n";
     1332        $result .= "{\n";
     1333        $result .= "    auto& vm = state.vm();\n\n";
     1334
     1335        # 1. Let O be ! ObjectCreate(%ObjectPrototype%).
     1336        $result .= "    auto result = constructEmptyObject(&state);\n\n";
     1337
     1338        # 2. Let dictionaries be a list consisting of D and all of D’s inherited dictionaries,
     1339        #    in order from least to most derived.
     1340        #    NOTE: This was done above.
     1341
     1342        # 3. For each dictionary dictionary in dictionaries, in order:
     1343        foreach my $dictionary (@dictionaries) {
     1344            # 3.1. For each dictionary member member declared on dictionary, in lexicographical order:
     1345            my @sortedMembers = sort { $a->name cmp $b->name } @{$dictionary->members};
     1346            foreach my $member (@sortedMembers) {
     1347                my $key = $member->name;
     1348                my $IDLType = GetIDLType($interface, $member->type);
     1349
     1350                # 1. Let key be the identifier of member.
     1351                # 2. If the dictionary member named key is present in V, then:
     1352                    # 1. Let idlValue be the value of member on V.
     1353                    # 2. Let value be the result of converting idlValue to an ECMAScript value.
     1354                    # 3. Perform ! CreateDataProperty(O, key, value).
     1355                if (!$member->isRequired && not defined $member->default) {
     1356                    $result .= "    if (dictionary.${key}) {\n";
     1357                    $result .= "        auto ${key}Value = toJS<$IDLType>(state, globalObject, dictionary.${key});\n";
     1358                    $result .= "        result->putDirect(vm, JSC::Identifier::fromString(&vm, \"${key}\"), ${key}Value);\n";
     1359                    $result .= "    }\n";
     1360                } else {
     1361                    $result .= "    auto ${key}Value = toJS<$IDLType>(state, globalObject, dictionary.${key});\n";
     1362                    $result .= "    result->putDirect(vm, JSC::Identifier::fromString(&vm, \"${key}\"), ${key}Value);\n";
     1363                }
     1364            }
     1365        }
     1366
     1367        $result .= "    return result;\n";
     1368        $result .= "}\n\n";
     1369    }
     1370
    13231371    $result .= "#endif\n\n" if $conditionalString;
    13241372

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r209303 r209390  
    680680    } else
    681681        result.unsignedLargeIntegerWithDefault = 0;
     682    return result;
     683}
     684
     685template<> JSC::JSObject* convertDictionaryToJS(JSC::ExecState& state, JSDOMGlobalObject&, const TestObj::Dictionary& dictionary)
     686{
     687    auto& vm = state.vm();
     688
     689    auto result = constructEmptyObject(&state)
     690
     691    auto anyTypedefValueValue = toJS<IDLAny>(state, globalObject, dictionary.anyTypedefValue);
     692    result->putDirect(vm, JSC::Identifier::fromString(&vm, "anyTypedefValue"), anyTypedefValueValue);
     693    auto anyValueValue = toJS<IDLAny>(state, globalObject, dictionary.anyValue);
     694    result->putDirect(vm, JSC::Identifier::fromString(&vm, "anyValue"), anyValueValue);
     695    auto anyValueWithNullDefaultValue = toJS<IDLAny>(state, globalObject, dictionary.anyValueWithNullDefault);
     696    result->putDirect(vm, JSC::Identifier::fromString(&vm, "anyValueWithNullDefault"), anyValueWithNullDefaultValue);
     697    auto booleanWithDefaultValue = toJS<IDLBoolean>(state, globalObject, dictionary.booleanWithDefault);
     698    result->putDirect(vm, JSC::Identifier::fromString(&vm, "booleanWithDefault"), booleanWithDefaultValue);
     699    if (dictionary.booleanWithoutDefault) {
     700        auto booleanWithoutDefaultValue = toJS<IDLBoolean>(state, globalObject, dictionary.booleanWithoutDefault);
     701        result->putDirect(vm, JSC::Identifier::fromString(&vm, "booleanWithoutDefault"), booleanWithoutDefaultValue);
     702    }
     703    if (dictionary.bufferSourceValue) {
     704        auto bufferSourceValueValue = toJS<IDLBufferSource>(state, globalObject, dictionary.bufferSourceValue);
     705        result->putDirect(vm, JSC::Identifier::fromString(&vm, "bufferSourceValue"), bufferSourceValueValue);
     706    }
     707    if (dictionary.dictionaryMember) {
     708        auto dictionaryMemberValue = toJS<IDLDictionary<TestObj::DictionaryThatShouldTolerateNull>>(state, globalObject, dictionary.dictionaryMember);
     709        result->putDirect(vm, JSC::Identifier::fromString(&vm, "dictionaryMember"), dictionaryMemberValue);
     710    }
     711    auto enumerationValueWithDefaultValue = toJS<IDLEnumeration<TestObj::EnumType>>(state, globalObject, dictionary.enumerationValueWithDefault);
     712    result->putDirect(vm, JSC::Identifier::fromString(&vm, "enumerationValueWithDefault"), enumerationValueWithDefaultValue);
     713    auto enumerationValueWithEmptyStringDefaultValue = toJS<IDLEnumeration<TestObj::EnumType>>(state, globalObject, dictionary.enumerationValueWithEmptyStringDefault);
     714    result->putDirect(vm, JSC::Identifier::fromString(&vm, "enumerationValueWithEmptyStringDefault"), enumerationValueWithEmptyStringDefaultValue);
     715    if (dictionary.enumerationValueWithoutDefault) {
     716        auto enumerationValueWithoutDefaultValue = toJS<IDLEnumeration<TestObj::EnumType>>(state, globalObject, dictionary.enumerationValueWithoutDefault);
     717        result->putDirect(vm, JSC::Identifier::fromString(&vm, "enumerationValueWithoutDefault"), enumerationValueWithoutDefaultValue);
     718    }
     719    if (dictionary.integer) {
     720        auto integerValue = toJS<IDLLong>(state, globalObject, dictionary.integer);
     721        result->putDirect(vm, JSC::Identifier::fromString(&vm, "integer"), integerValue);
     722    }
     723    auto integerWithDefaultValue = toJS<IDLLong>(state, globalObject, dictionary.integerWithDefault);
     724    result->putDirect(vm, JSC::Identifier::fromString(&vm, "integerWithDefault"), integerWithDefaultValue);
     725    if (dictionary.largeInteger) {
     726        auto largeIntegerValue = toJS<IDLLongLong>(state, globalObject, dictionary.largeInteger);
     727        result->putDirect(vm, JSC::Identifier::fromString(&vm, "largeInteger"), largeIntegerValue);
     728    }
     729    auto largeIntegerWithDefaultValue = toJS<IDLLongLong>(state, globalObject, dictionary.largeIntegerWithDefault);
     730    result->putDirect(vm, JSC::Identifier::fromString(&vm, "largeIntegerWithDefault"), largeIntegerWithDefaultValue);
     731    auto nullableIntegerWithDefaultValue = toJS<IDLNullable<IDLLong>>(state, globalObject, dictionary.nullableIntegerWithDefault);
     732    result->putDirect(vm, JSC::Identifier::fromString(&vm, "nullableIntegerWithDefault"), nullableIntegerWithDefaultValue);
     733    auto nullableNodeValue = toJS<IDLNullable<IDLInterface<Node>>>(state, globalObject, dictionary.nullableNode);
     734    result->putDirect(vm, JSC::Identifier::fromString(&vm, "nullableNode"), nullableNodeValue);
     735    auto nullableStringWithDefaultValue = toJS<IDLNullable<IDLDOMString>>(state, globalObject, dictionary.nullableStringWithDefault);
     736    result->putDirect(vm, JSC::Identifier::fromString(&vm, "nullableStringWithDefault"), nullableStringWithDefaultValue);
     737    auto nullableUnionMemberValue = toJS<IDLNullable<IDLUnion<IDLLong, IDLInterface<Node>>>>(state, globalObject, dictionary.nullableUnionMember);
     738    result->putDirect(vm, JSC::Identifier::fromString(&vm, "nullableUnionMember"), nullableUnionMemberValue);
     739    if (dictionary.restrictedDouble) {
     740        auto restrictedDoubleValue = toJS<IDLDouble>(state, globalObject, dictionary.restrictedDouble);
     741        result->putDirect(vm, JSC::Identifier::fromString(&vm, "restrictedDouble"), restrictedDoubleValue);
     742    }
     743    auto restrictedDoubleWithDefaultValue = toJS<IDLDouble>(state, globalObject, dictionary.restrictedDoubleWithDefault);
     744    result->putDirect(vm, JSC::Identifier::fromString(&vm, "restrictedDoubleWithDefault"), restrictedDoubleWithDefaultValue);
     745    if (dictionary.restrictedFloat) {
     746        auto restrictedFloatValue = toJS<IDLFloat>(state, globalObject, dictionary.restrictedFloat);
     747        result->putDirect(vm, JSC::Identifier::fromString(&vm, "restrictedFloat"), restrictedFloatValue);
     748    }
     749    auto restrictedFloatWithDefaultValue = toJS<IDLFloat>(state, globalObject, dictionary.restrictedFloatWithDefault);
     750    result->putDirect(vm, JSC::Identifier::fromString(&vm, "restrictedFloatWithDefault"), restrictedFloatWithDefaultValue);
     751    if (dictionary.sequenceOfStrings) {
     752        auto sequenceOfStringsValue = toJS<IDLSequence<IDLDOMString>>(state, globalObject, dictionary.sequenceOfStrings);
     753        result->putDirect(vm, JSC::Identifier::fromString(&vm, "sequenceOfStrings"), sequenceOfStringsValue);
     754    }
     755    if (dictionary.smallIntegerClamped) {
     756        auto smallIntegerClampedValue = toJS<IDLByte>(state, globalObject, dictionary.smallIntegerClamped);
     757        result->putDirect(vm, JSC::Identifier::fromString(&vm, "smallIntegerClamped"), smallIntegerClampedValue);
     758    }
     759    if (dictionary.smallIntegerWithDefault) {
     760        auto smallIntegerWithDefaultValue = toJS<IDLByte>(state, globalObject, dictionary.smallIntegerWithDefault);
     761        result->putDirect(vm, JSC::Identifier::fromString(&vm, "smallIntegerWithDefault"), smallIntegerWithDefaultValue);
     762    }
     763    if (dictionary.smallUnsignedIntegerEnforcedRange) {
     764        auto smallUnsignedIntegerEnforcedRangeValue = toJS<IDLOctet>(state, globalObject, dictionary.smallUnsignedIntegerEnforcedRange);
     765        result->putDirect(vm, JSC::Identifier::fromString(&vm, "smallUnsignedIntegerEnforcedRange"), smallUnsignedIntegerEnforcedRangeValue);
     766    }
     767    auto smallUnsignedIntegerWithDefaultValue = toJS<IDLOctet>(state, globalObject, dictionary.smallUnsignedIntegerWithDefault);
     768    result->putDirect(vm, JSC::Identifier::fromString(&vm, "smallUnsignedIntegerWithDefault"), smallUnsignedIntegerWithDefaultValue);
     769    auto stringWithDefaultValue = toJS<IDLDOMString>(state, globalObject, dictionary.stringWithDefault);
     770    result->putDirect(vm, JSC::Identifier::fromString(&vm, "stringWithDefault"), stringWithDefaultValue);
     771    if (dictionary.stringWithoutDefault) {
     772        auto stringWithoutDefaultValue = toJS<IDLDOMString>(state, globalObject, dictionary.stringWithoutDefault);
     773        result->putDirect(vm, JSC::Identifier::fromString(&vm, "stringWithoutDefault"), stringWithoutDefaultValue);
     774    }
     775    if (dictionary.unionMember) {
     776        auto unionMemberValue = toJS<IDLUnion<IDLLong, IDLInterface<Node>>>(state, globalObject, dictionary.unionMember);
     777        result->putDirect(vm, JSC::Identifier::fromString(&vm, "unionMember"), unionMemberValue);
     778    }
     779    if (dictionary.unrestrictedDouble) {
     780        auto unrestrictedDoubleValue = toJS<IDLUnrestrictedDouble>(state, globalObject, dictionary.unrestrictedDouble);
     781        result->putDirect(vm, JSC::Identifier::fromString(&vm, "unrestrictedDouble"), unrestrictedDoubleValue);
     782    }
     783    auto unrestrictedDoubleWithDefaultValue = toJS<IDLUnrestrictedDouble>(state, globalObject, dictionary.unrestrictedDoubleWithDefault);
     784    result->putDirect(vm, JSC::Identifier::fromString(&vm, "unrestrictedDoubleWithDefault"), unrestrictedDoubleWithDefaultValue);
     785    if (dictionary.unrestrictedFloat) {
     786        auto unrestrictedFloatValue = toJS<IDLUnrestrictedFloat>(state, globalObject, dictionary.unrestrictedFloat);
     787        result->putDirect(vm, JSC::Identifier::fromString(&vm, "unrestrictedFloat"), unrestrictedFloatValue);
     788    }
     789    auto unrestrictedFloatWithDefaultValue = toJS<IDLUnrestrictedFloat>(state, globalObject, dictionary.unrestrictedFloatWithDefault);
     790    result->putDirect(vm, JSC::Identifier::fromString(&vm, "unrestrictedFloatWithDefault"), unrestrictedFloatWithDefaultValue);
     791    if (dictionary.unsignedInteger) {
     792        auto unsignedIntegerValue = toJS<IDLUnsignedLong>(state, globalObject, dictionary.unsignedInteger);
     793        result->putDirect(vm, JSC::Identifier::fromString(&vm, "unsignedInteger"), unsignedIntegerValue);
     794    }
     795    auto unsignedIntegerWithDefaultValue = toJS<IDLUnsignedLong>(state, globalObject, dictionary.unsignedIntegerWithDefault);
     796    result->putDirect(vm, JSC::Identifier::fromString(&vm, "unsignedIntegerWithDefault"), unsignedIntegerWithDefaultValue);
     797    if (dictionary.unsignedLargeInteger) {
     798        auto unsignedLargeIntegerValue = toJS<IDLUnsignedLongLong>(state, globalObject, dictionary.unsignedLargeInteger);
     799        result->putDirect(vm, JSC::Identifier::fromString(&vm, "unsignedLargeInteger"), unsignedLargeIntegerValue);
     800    }
     801    auto unsignedLargeIntegerWithDefaultValue = toJS<IDLUnsignedLongLong>(state, globalObject, dictionary.unsignedLargeIntegerWithDefault);
     802    result->putDirect(vm, JSC::Identifier::fromString(&vm, "unsignedLargeIntegerWithDefault"), unsignedLargeIntegerWithDefaultValue);
    682803    return result;
    683804}

  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.h

    r208985 r209390  
    170170template<> TestObj::Dictionary convertDictionary<TestObj::Dictionary>(JSC::ExecState&, JSC::JSValue);
    171171
     172template<> JSC::JSObject* convertDictionaryToJS(JSC::ExecState&, JSDOMGlobalObject&, const TestObj::Dictionary&);
     173
    172174template<> TestObj::DictionaryThatShouldNotTolerateNull convertDictionary<TestObj::DictionaryThatShouldNotTolerateNull>(JSC::ExecState&, JSC::JSValue);
    173175

  • trunk/Source/WebCore/bindings/scripts/test/TestObj.idl

    r209303 r209390  
    434434typedef any AnyTypedef;
    435435
    436 dictionary TestDictionary {
     436[
     437    JSGenerateToJSObject
     438]dictionary TestDictionary {
    437439    TestEnumType enumerationValueWithoutDefault;
    438440    TestEnumType enumerationValueWithDefault = "enumValue1";

  • trunk/Source/WebCore/crypto/CryptoAlgorithm.h

    r209200 r209390  
    2727
    2828#include "CryptoAlgorithmIdentifier.h"
     29#include "CryptoKeyPair.h"
    2930#include "CryptoKeyUsage.h"
    3031#include "ExceptionOr.h"
    … …  
    4243class CryptoAlgorithmParametersDeprecated;
    4344class CryptoKey;
    44 class CryptoKeyPair;
    4545class CryptoKeyData;
    4646class ScriptExecutionContext;
    … …  
    5050
    5151using KeyData = Variant<Vector<uint8_t>, JsonWebKey>;
     52using KeyOrKeyPair = Variant<RefPtr<CryptoKey>, CryptoKeyPair>;
    5253
    5354class CryptoAlgorithm : public RefCounted<CryptoAlgorithm> {
    … …  
    5960    using BoolCallback = WTF::Function<void(bool)>;
    6061    using KeyCallback = WTF::Function<void(CryptoKey&)>;
    61     using KeyOrKeyPairCallback = WTF::Function<void(CryptoKey*, CryptoKeyPair*)>;
     62    using KeyOrKeyPairCallback = WTF::Function<void(KeyOrKeyPair&&)>;
    6263    using VectorCallback = WTF::Function<void(const Vector<uint8_t>&)>;
    6364    using VoidCallback = WTF::Function<void()>;

  • trunk/Source/WebCore/crypto/CryptoKeyPair.h

    r208646 r209390  
    2626#pragma once
    2727
    28 #include "CryptoKey.h"
    2928#include <wtf/RefCounted.h>
    3029#include <wtf/RefPtr.h>
    … …  
    3433namespace WebCore {
    3534
    36 class CryptoKeyPair : public RefCounted<CryptoKeyPair> {
    37 public:
    38     static Ref<CryptoKeyPair> create(RefPtr<CryptoKey>&& publicKey, RefPtr<CryptoKey>&& privateKey)
    39     {
    40         return adoptRef(*new CryptoKeyPair(WTFMove(publicKey), WTFMove(privateKey)));
    41     }
    42     ~CryptoKeyPair();
     35class CryptoKey;
    4336
    44     CryptoKey* publicKey() { return m_publicKey.get(); }
    45     CryptoKey* privateKey() { return m_privateKey.get(); }
    46 
    47 private:
    48     CryptoKeyPair(RefPtr<CryptoKey>&& publicKey, RefPtr<CryptoKey>&& privateKey);
    49 
    50     RefPtr<CryptoKey> m_publicKey;
    51     RefPtr<CryptoKey> m_privateKey;
     37struct CryptoKeyPair {
     38    RefPtr<CryptoKey> publicKey;
     39    RefPtr<CryptoKey> privateKey;
    5240};
    5341

  • trunk/Source/WebCore/crypto/CryptoKeyPair.idl

    r207809 r209390  
    11/*
    2  * Copyright (C) 2013 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 // FIXME: The spec suggests that CryptoKeyPair should be of type Dictionary
    27 // as of 11 December 2014: https://www.w3.org/TR/WebCryptoAPI/#keypair
    28 // Since we don't support convert a Dictionary type object from its native
    29 // type to JSValue yet, we use a NoInterfaceObject hack for now. See:
    30 // https://bugs.webkit.org/show_bug.cgi?id=163711
    3126[
    3227    Conditional=SUBTLE_CRYPTO,
    33     ImplementationLacksVTable,
    34     JSCustomMarkFunction,
    35     NoInterfaceObject
    36 ] interface CryptoKeyPair {
    37     readonly attribute CryptoKey publicKey;
    38     readonly attribute CryptoKey privateKey;
     28    JSGenerateToJSObject
     29] dictionary CryptoKeyPair {
     30    CryptoKey publicKey;
     31    CryptoKey privateKey;
    3932};

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmAES_CBC.cpp

    r209077 r209390  
    104104    }
    105105
    106     callback(result.get(), nullptr);
     106    callback(WTFMove(result));
    107107}
    108108
    … …  
    213213    }
    214214
    215     callback(result.get(), nullptr);
     215    callback(WTFMove(result));
    216216    return { };
    217217}

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmAES_KW.cpp

    r209200 r209390  
    7777    }
    7878
    79     callback(result.get(), nullptr);
     79    callback(WTFMove(result));
    8080}
    8181
    … …  
    194194        return { };
    195195    }
    196     callback(result.get(), nullptr);
     196
     197    callback(WTFMove(result));
    197198    return { };
    198199}

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmHMAC.cpp

    r209150 r209390  
    100100    }
    101101
    102     callback(result.get(), nullptr);
     102    callback(WTFMove(result));
    103103}
    104104
    … …  
    221221        return { };
    222222    }
    223     callback(result.get(), nullptr);
     223    callback(WTFMove(result));
    224224    return { };
    225225}

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmRSAES_PKCS1_v1_5.cpp

    r209077 r209390  
    8787    }
    8888
    89     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    90         pair.publicKey()->setUsagesBitmap(pair.publicKey()->usagesBitmap() & CryptoKeyUsageEncrypt);
    91         pair.privateKey()->setUsagesBitmap(pair.privateKey()->usagesBitmap() & CryptoKeyUsageDecrypt);
    92         capturedCallback(nullptr, &pair);
     89    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     90        pair.publicKey->setUsagesBitmap(pair.publicKey->usagesBitmap() & CryptoKeyUsageEncrypt);
     91        pair.privateKey->setUsagesBitmap(pair.privateKey->usagesBitmap() & CryptoKeyUsageDecrypt);
     92        capturedCallback(WTFMove(pair));
    9393    };
    9494    auto failureCallback = [capturedCallback = WTFMove(exceptionCallback)]() {
    … …  
    175175{
    176176    auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyGenParamsDeprecated>(parameters);
    177     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    178         capturedCallback(nullptr, &pair);
     177    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     178        capturedCallback(WTFMove(pair));
    179179    };
    180180    CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSAES_PKCS1_v1_5, rsaParameters.hash, rsaParameters.hasHash, rsaParameters.modulusLength, rsaParameters.publicExponent, extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmRSASSA_PKCS1_v1_5.cpp

    r209150 r209390  
    9696    }
    9797
    98     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    99         pair.publicKey()->setUsagesBitmap(pair.publicKey()->usagesBitmap() & CryptoKeyUsageVerify);
    100         pair.privateKey()->setUsagesBitmap(pair.privateKey()->usagesBitmap() & CryptoKeyUsageSign);
    101         capturedCallback(nullptr, &pair);
     98    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     99        pair.publicKey->setUsagesBitmap(pair.publicKey->usagesBitmap() & CryptoKeyUsageVerify);
     100        pair.privateKey->setUsagesBitmap(pair.privateKey->usagesBitmap() & CryptoKeyUsageSign);
     101        capturedCallback(WTFMove(pair));
    102102    };
    103103    auto failureCallback = [capturedCallback = WTFMove(exceptionCallback)]() {
    … …  
    228228{
    229229    auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyGenParamsDeprecated>(parameters);
    230     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    231         capturedCallback(nullptr, &pair);
     230    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     231        capturedCallback(WTFMove(pair));
    232232    };
    233233    CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSASSA_PKCS1_v1_5, rsaParameters.hash, rsaParameters.hasHash, rsaParameters.modulusLength, rsaParameters.publicExponent, extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);

  • trunk/Source/WebCore/crypto/algorithms/CryptoAlgorithmRSA_OAEP.cpp

    r209077 r209390  
    9898    }
    9999
    100     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    101         pair.publicKey()->setUsagesBitmap(pair.publicKey()->usagesBitmap() & (CryptoKeyUsageEncrypt | CryptoKeyUsageWrapKey));
    102         pair.privateKey()->setUsagesBitmap(pair.privateKey()->usagesBitmap() & (CryptoKeyUsageDecrypt | CryptoKeyUsageUnwrapKey));
    103         capturedCallback(nullptr, &pair);
     100    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     101        pair.publicKey->setUsagesBitmap(pair.publicKey->usagesBitmap() & (CryptoKeyUsageEncrypt | CryptoKeyUsageWrapKey));
     102        pair.privateKey->setUsagesBitmap(pair.privateKey->usagesBitmap() & (CryptoKeyUsageDecrypt | CryptoKeyUsageUnwrapKey));
     103        capturedCallback(WTFMove(pair));
    104104    };
    105105    auto failureCallback = [capturedCallback = WTFMove(exceptionCallback)]() {
    … …  
    241241{
    242242    auto& rsaParameters = downcast<CryptoAlgorithmRsaKeyGenParamsDeprecated>(parameters);
    243     auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair& pair) {
    244         capturedCallback(nullptr, &pair);
     243    auto keyPairCallback = [capturedCallback = WTFMove(callback)](CryptoKeyPair&& pair) {
     244        capturedCallback(WTFMove(pair));
    245245    };
    246246    CryptoKeyRSA::generatePair(CryptoAlgorithmIdentifier::RSA_OAEP, rsaParameters.hash, rsaParameters.hasHash, rsaParameters.modulusLength, rsaParameters.publicExponent, extractable, usages, WTFMove(keyPairCallback), WTFMove(failureCallback), &context);

  • trunk/Source/WebCore/crypto/keys/CryptoKeyRSA.h

    r208985 r209390  
    4444
    4545class CryptoKeyDataRSAComponents;
    46 class CryptoKeyPair;
    4746class PromiseWrapper;
    4847class ScriptExecutionContext;
    4948
     49struct CryptoKeyPair;
    5050struct JsonWebKey;
    5151
    … …  
    9898    size_t keySizeInBits() const;
    9999
    100     using KeyPairCallback = WTF::Function<void(CryptoKeyPair&)>;
     100    using KeyPairCallback = WTF::Function<void(CryptoKeyPair&&)>;
    101101    using VoidCallback = WTF::Function<void()>;
    102102    static void generatePair(CryptoAlgorithmIdentifier, CryptoAlgorithmIdentifier hash, bool hasHash, unsigned modulusLength, const Vector<uint8_t>& publicExponent, bool extractable, CryptoKeyUsageBitmap, KeyPairCallback&&, VoidCallback&& failureCallback, ScriptExecutionContext*);

  • trunk/Source/WebCore/crypto/mac/CryptoKeyRSAMac.cpp

    r208891 r209390  
    271271            auto publicKey = CryptoKeyRSA::create(algorithm, hash, hasHash, CryptoKeyType::Public, ccPublicKey, true, usage);
    272272            auto privateKey = CryptoKeyRSA::create(algorithm, hash, hasHash, CryptoKeyType::Private, ccPrivateKey, extractable, usage);
    273             (*localCallback)(CryptoKeyPair::create(WTFMove(publicKey), WTFMove(privateKey)));
     273
     274            (*localCallback)(CryptoKeyPair { WTFMove(publicKey), WTFMove(privateKey) });
     275
    274276            delete localCallback;
    275277            delete localFailureCallback;

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

    r208985 r209390  
    6666    LoadStatus status() const;
    6767
    68     typedef DOMPromise<FontFace&> Promise;
     68    using Promise = DOMPromise<IDLInterface<FontFace>>;
    6969    std::optional<Promise>& promise() { return m_promise; }
    7070    void registerLoaded(Promise&&);

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

    r208985 r209390  
    134134
    135135    if (matchingFaces.isEmpty()) {
    136         promise.resolve(Vector<RefPtr<FontFace>>());
     136        promise.resolve({ });
    137137        return;
    138138    }

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

    r208985 r209390  
    4747    void clear();
    4848
    49     typedef DOMPromise<Vector<RefPtr<FontFace>>> LoadPromise;
     49    using LoadPromise = DOMPromise<IDLSequence<IDLInterface<FontFace>>>;
    5050    void load(const String& font, const String& text, LoadPromise&&);
    5151    ExceptionOr<bool> check(const String& font, const String& text);
    … …  
    5454    LoadStatus status() const;
    5555
    56     typedef DOMPromise<FontFaceSet&> ReadyPromise;
     56    using ReadyPromise = DOMPromise<IDLInterface<FontFaceSet>>;
    5757    void registerReady(ReadyPromise&&);
    5858

  • trunk/Source/WebCore/dom/CustomElementRegistry.cpp

    r208716 r209390  
    7878
    7979    if (auto promise = m_promiseMap.take(localName))
    80         promise.value()->resolve(nullptr);
     80        promise.value()->resolve();
    8181}
    8282

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

    r209206 r209390  
    5555#include "HTMLVideoElement.h"
    5656#include "JSDOMError.h"
     57#include "JSDOMPromise.h"
    5758#include "JSHTMLMediaElement.h"
    5859#include "Language.h"
    … …  
    978979
    979980    for (auto& promise : pendingPlayPromises)
    980         promise.reject(error);
     981        promise.rejectType<IDLInterface<DOMError>>(error);
    981982}
    982983

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

    r208851 r209390  
    3333#include "GenericTaskQueue.h"
    3434#include "HTMLMediaElementEnums.h"
    35 #include "JSDOMPromise.h"
    3635#include "MediaCanStartListener.h"
    3736#include "MediaControllerInterface.h"
    … …  
    6059class AudioTrackPrivate;
    6160class DOMError;
     61class DeferredPromise;
    6262class DisplaySleepDisabler;
    6363class Event;
    … …  
    8787class VideoTrackPrivate;
    8888class WebKitMediaKeys;
     89
     90template<typename> class DOMPromise;
    8991
    9092#if ENABLE(VIDEO_TRACK)

  • trunk/Source/WebCore/html/MediaController.cpp

    r208096 r209390  
    3131#include "Clock.h"
    3232#include "EventNames.h"
     33#include "ExceptionCode.h"
    3334#include "HTMLMediaElement.h"
    3435#include "TimeRanges.h"

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContext.cpp

    r208910 r209390  
    6262#include <JavaScriptCore/JSCellInlines.h>
    6363#include <JavaScriptCore/JSGenericTypedArrayViewInlines.h>
     64#include <heap/HeapInlines.h>
    6465
    6566namespace WebCore {

  • trunk/Source/WebCore/html/track/TextTrack.cpp

    r207907 r209390  
    3737
    3838#include "Event.h"
     39#include "ExceptionCode.h"
    3940#include "HTMLMediaElement.h"
    4041#include "SourceBuffer.h"

  • trunk/Source/WebKit2/CMakeLists.txt

    r208388 r209390  
    9393    "${WEBCORE_DIR}/bridge/jsc"
    9494    "${WEBCORE_DIR}/contentextensions"
     95    "${WEBCORE_DIR}/crypto"
     96    "${WEBCORE_DIR}/crypto/algorithms"
     97    "${WEBCORE_DIR}/crypto/keys"
     98    "${WEBCORE_DIR}/crypto/parameters"
    9599    "${WEBCORE_DIR}/css"
    96100    "${WEBCORE_DIR}/css/parser"

  • trunk/Source/WebKit2/ChangeLog

    r209378 r209390  
     12016-12-06  Sam Weinig  <sam@webkit.org>
     2
     3        [WebIDL] Add support for converting dictionaries to JS
     4        https://bugs.webkit.org/show_bug.cgi?id=165367
     5
     6        Reviewed by Darin Adler and Alex Christensen.
     7
     8        * CMakeLists.txt:
     9        Add missing directories to look in for headers.
     10
    1112016-12-05  Tim Horton  <timothy_horton@apple.com>
    212
Note: See TracChangeset for help on using the changeset viewer.