Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-16 19:05:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision fc33be9acfbf8e883fd9683c527aab22d842542b

Browse source
This commit is contained in:
WPT Sync Bot 2018-03-30 21:21:31 -04:00
parent d232705106
commit 09b1413275
32 changed files with 1112 additions and 577 deletions
Download patch file Download diff file Expand all files Collapse all files

72
tests/wpt/web-platform-tests/css/css-align/gaps/gap-normal-computed-001.html Normal file
View file

@ -0,0 +1,72 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Box Alignment Test: computed value of normal on *-gap properties</title>
<link rel="author" title="Florian Rivoal" href="https://florian.rivoal.net">
<link rel="help" href="https://www.w3.org/TR/css-align-3/#column-row-gap">
<meta assert="The computed value of [row-|column-]?gap is normal for all elements it applies to. Checking explicitely because earlier version of the spec called for 0px in some cases.">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<style>
#col,
#grid,
#flex {
/* Not using the shorthand because that's not what we're interested in,
and there are implementations that support column-gap without supporting the shorthand */
colum-gap: normal;
row-gap: normal;
float: right; /* for shrinkwrap*/
}
#col {
column-count: 2;
column-width: 50px;
}
#grid {
display: grid;
grid-template-columns: 50px 50px;
grid-template-rows: 50px 50px;
}
#flex {
display: flex;
}
#flex * { width: 50px; height: 50px;}
</style>
<body>
<div id="log"></div>
<div id=col></div>
<div id=grid></div>
<div id=flex><span></span><span></span></div>
<script>
test(
function(){
var target = document.getElementById("col");
assert_equals(getComputedStyle(target).columnGap, "normal");
}, "colum-gap:normal computes to normal on multicol elements");
test(
function(){
var target = document.getElementById("col");
assert_equals(getComputedStyle(target).rowGap, "normal");
}, "row-gap:normal computes to normal on multicol elements");
test(
function(){
var target = document.getElementById("grid");
assert_equals(getComputedStyle(target).columnGap, "normal");
}, "colum-gap:normal computes to normal on grid");
test(
function(){
var target = document.getElementById("grid");
assert_equals(getComputedStyle(target).rowGap, "normal");
}, "row-gap:normal computes to normal on grid");
test(
function(){
var target = document.getElementById("flex");
assert_equals(getComputedStyle(target).columnGap, "normal");
}, "colum-gap:normal (main axis) computes to normal on flexbox");
test(
function(){
var target = document.getElementById("flex");
assert_equals(getComputedStyle(target).rowGap, "normal");
}, "row-gap:normal (cross axis) computes to normal on flexbox");
</script>
</body>

29
tests/wpt/web-platform-tests/css/css-align/gaps/gap-normal-used-001.html Normal file
View file

@ -0,0 +1,29 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Box Alignment Test: used value of *-gap:normal on grid</title>
<link rel="author" title="Florian Rivoal" href="https://florian.rivoal.net">
<link rel="help" href="https://www.w3.org/TR/css-align-3/#column-row-gap">
<meta assert="The used value of row-gap and column-gap normal for grids is 0">
<link rel="match" href="../../reference/ref-filled-green-100px-square.xht" />
<style>
#grid {
colum-gap: normal;
row-gap: normal;
display: grid;
grid-template-columns: 50px 50px;
grid-template-rows: 50px 50px;
position: absolute;
}
#grid * { background: green; }
#red {
width: 100px;
height: 100px;
background: red;
}
</style>
<p>Test passes if there is a filled green square and <strong>no red</strong>.</p>
<div id=grid><span></span><span></span><span></span><span></span></div>
<div id=red></div>

33
tests/wpt/web-platform-tests/css/css-align/gaps/gap-normal-used-002.html Normal file
View file

@ -0,0 +1,33 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Box Alignment Test: used value of *-gap:normal on flexbox</title>
<link rel="author" title="Florian Rivoal" href="https://florian.rivoal.net">
<link rel="help" href="https://www.w3.org/TR/css-align-3/#column-row-gap">
<meta assert="The used value row-gap:normal and column:normal normal is 0px in flexbox">
<link rel="match" href="../../reference/ref-filled-green-100px-square.xht" />
<style>
#flex {
colum-gap: normal;
row-gap: normal;
display: flex;
flex-flow: wrap;
max-width: 145px; /* more than 100, less than 150, to force wrapping and get 2 items per line*/
position: absolute;
}
#flex * {
width: 50px;
height: 50px;
background: green
}
#red {
width: 100px;
height: 100px;
background: red;
}
</style>
<p>Test passes if there is a filled green square and <strong>no red</strong>.</p>
<div id=flex><span></span><span></span><span></span><span></span></div>
<div id=red></div>

2
tests/wpt/web-platform-tests/css/css-overflow/OWNERS Normal file
View file

@ -0,0 +1,2 @@
@frivoal
@dbaron

42
tests/wpt/web-platform-tests/css/css-overflow/logical-overflow-001.html Normal file
View file

@ -0,0 +1,42 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Overflow Test: flow-relative versions of overflow-x and -y</title>
<link rel="author" title="Florian Rivoal" href="https://florian.rivoal.net">
<link rel="help" href="https://drafts.csswg.org/css-overflow-3/#logical">
<link rel="help" href="https://drafts.csswg.org/css-logical/#box">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<style>
#d1, #d2 {
overflow-block: hidden;
overflow-inline: scroll
}
#d1 {
writing-mode: horizontal-tb;
}
#d2 {
writing-mode: vertical-rl;
}
</style>
<body>
<div id="log"></div>
<div id=d1></div>
<div id=d2></div>
<script>
test(
function(){
var target = document.getElementById("d1");
assert_equals(getComputedStyle(target).overflowX, "scroll");
assert_equals(getComputedStyle(target).overflowY, "hidden");
}, "overflow-x matches overflow-inline, and overflow-y matches overflow-block when the element has a horizontal writing mode");
test(
function(){
var target = document.getElementById("d2");
assert_equals(getComputedStyle(target).overflowX, "hidden");
assert_equals(getComputedStyle(target).overflowY, "scroll");
}, "overflow-y matches overflow-inline, and overflow-x matches overflow-block when the element has a vertical writing mode");
</script>
</body>

4
tests/wpt/web-platform-tests/css/css-text/word-break/reference/word-break-break-all-ref-005.html
View file

@ -7,7 +7,7 @@
<style type='text/css'>
.test { word-break: break-all; }
/* the CSS below is not part of the test */
.test, .ref { border: 1px solid orange; margin: 20px; padding: 10px; width: 390px; font: 36px/1.5 sans-serif; }
.test, .ref { border: 1px solid orange; margin: 20px; padding: 10px; width: 390px; font: 36px/1.5 Arial; }
</style>
</head>
<body>
@ -15,4 +15,4 @@
<div class="ref" lang="bo"><span>ལྷ་སའི་སྐད་ད་<br/>ལྟ</span></div>
<div class="ref" lang="bo"><span>ལྷ་སའི་སྐད་ད་<br/>ལྟ</span></div>
</body>
</html>
</html>

4
tests/wpt/web-platform-tests/css/css-text/word-break/word-break-break-all-005.html
View file

@ -10,7 +10,7 @@
<style type='text/css'>
.test { word-break: break-all; }
/* the CSS below is not part of the test */
.test, .ref { border: 1px solid orange; margin: 20px; padding: 10px; width: 390px; font: 36px/1.5 sans-serif; }
.test, .ref { border: 1px solid orange; margin: 20px; padding: 10px; width: 390px; font: 36px/1.5 Arial; }
</style>
</head>
<body>
@ -22,4 +22,4 @@ var sentenceWidth = document.getElementById('testspan').offsetWidth
document.getElementById('testdiv').style.width = String(sentenceWidth - 5)+'px'
</script>
</body>
</html>
</html>

49
tests/wpt/web-platform-tests/css/css-transitions/transition-background-position-with-edge-offset.html Normal file
View file

@ -0,0 +1,49 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>CSS Transitions Test: transition-property - background-position</title>
<link rel="author" title="Zhuoyu Qian" href="mailto:zhuoyu.qian@samsung.com">
<link rel="help" title="7.1. Properties from CSS" href="http://www.w3.org/TR/css3-transitions/#animatable-css">
<link rel="help" title="5.3.6 background-position" href="https://www.w3.org/TR/CSS1/#background-position">
<meta name="assert" content="Test checks that the 'background-position' property with edge offset is animatable.">
<script src="/resources/testharness.js" type="text/javascript"></script>
<script src="/resources/testharnessreport.js" type="text/javascript"></script>
<style>
#test {
border: 1px solid;
background-image: url("support/cat.png");
background-repeat: no-repeat;
height: 200px;
transition-duration: 100s;
transition-property: background-position;
transition-timing-function: step-end;
}
</style>
<body>
<div id="test"></div>
</body>
<script>
var startValue = "left 10px top 10px";
var endValue = "right 10px bottom 10px";
var div = document.getElementById("test");
// getComputedStyle helper
function gCS(aProperty) {
return document.defaultView
.getComputedStyle(div, "")
.getPropertyValue(aProperty);
}
(function() {
div.style.backgroundPosition = startValue;
// flush styles
gCS("background-position");
// set property to endValue
div.setAttribute("style", "background-position: " + endValue);
test(function() {
assert_true(gCS("background-position") != endValue);
}, "background-position not equals to end value");
})();
</script>

27
tests/wpt/web-platform-tests/css/css-typed-om/the-stylepropertymap/properties/marker.html Normal file
View file

@ -0,0 +1,27 @@
<!doctype html>
<meta charset="utf-8">
<title>'marker-*' properties</title>
<link rel="help" href="https://drafts.css-houdini.org/css-typed-om-1/#dom-stylepropertymap-get">
<link rel="help" href="https://drafts.css-houdini.org/css-typed-om-1/#dom-stylepropertymap-set">
<link rel="help" href="https://drafts.css-houdini.org/css-typed-om-1/#property-stle-value-normalization">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="../../resources/testhelper.js"></script>
<script src="resources/testsuite.js"></script>
<body>
<div id="log"></div>
<script>
'use strict';
runUnsupportedPropertyTests('marker', [
'none', 'url(#m1)'
]);
for (const suffix of ['start', 'mid', 'end']) {
runPropertyTests(`marker-${suffix}`, [
{ syntax: 'none' },
{ syntax: '<url>' },
]);
}
</script>

7
tests/wpt/web-platform-tests/css/css-typed-om/the-stylepropertymap/properties/resources/testsuite.js
View file

@ -152,6 +152,13 @@ const gTestSyntaxExamples = {
}
],
},
'<url>': {
description: 'a URL',
examples: [
// TODO(https://github.com/w3c/css-houdini-drafts/issues/716):
// We can't test this until CSSURLValue is spec'd.
],
},
'<transform>': {
description: 'a transform',
examples: [

2
tests/wpt/web-platform-tests/css/geometry/support/interfaces.js
View file

@ -19,6 +19,8 @@ function doTest(idl) {
DOMMatrixReadOnly: ["new DOMMatrixReadOnly()", "DOMMatrixReadOnly.fromMatrix({is2D: false})"],
DOMMatrix: ["new DOMMatrix()", "DOMMatrix.fromMatrix({is2D: false})"],
});
idlArray.prevent_multiple_testing("DOMMatrixReadOnly");
idlArray.prevent_multiple_testing("DOMMatrix");
idlArray.test();
done();
}

15
tests/wpt/web-platform-tests/interfaces/geometry.idl
View file

@ -1,3 +1,7 @@
// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the Geometry Interfaces spec.
// See https://drafts.fxtf.org/geometry/
[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
optional unrestricted double z = 0, optional unrestricted double w = 1),
Exposed=(Window,Worker),
@ -12,7 +16,7 @@ interface DOMPointReadOnly {
DOMPoint matrixTransform(optional DOMMatrixInit matrix);
[Default] toJSON();
[Default] object toJSON();
};
[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
@ -52,7 +56,7 @@ interface DOMRectReadOnly {
readonly attribute unrestricted double bottom;
readonly attribute unrestricted double left;
[Default] toJSON();
[Default] object toJSON();
};
[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
@ -76,8 +80,7 @@ dictionary DOMRectInit {
unrestricted double height = 0;
};
[NoInterfaceObject,
LegacyArrayClass]
[LegacyArrayClass]
interface DOMRectList {
readonly attribute unsigned long length;
getter DOMRect? item(unsigned long index);
@ -97,7 +100,7 @@ interface DOMQuad {
[SameObject] readonly attribute DOMPoint p4;
[NewObject] DOMRect getBounds();
[Default] toJSON();
[Default] object toJSON();
};
dictionary DOMQuadInit {
@ -178,7 +181,7 @@ interface DOMMatrixReadOnly {
[NewObject] Float64Array toFloat64Array();
[Exposed=Window] stringifier;
[Default] toJSON();
[Default] object toJSON();
};
[Constructor(optional (DOMString or sequence<unrestricted double>) init),

4
tests/wpt/web-platform-tests/interfaces/webaudio.idl → tests/wpt/web-platform-tests/interfaces/web-audio-api.idl
View file

@ -1,3 +1,7 @@
// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the Web Audio API spec.
// See https://webaudio.github.io/web-audio-api/
enum AudioContextState {
"suspended",
"running",

119
tests/wpt/web-platform-tests/interfaces/webauthn.idl
View file

@ -1,12 +1,16 @@
// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the Web Authentication spec.
// See https://w3c.github.io/webauthn/
[SecureContext, Exposed=Window]
interface PublicKeyCredential : Credential {
[SameObject] readonly attribute ArrayBuffer rawId;
[SameObject] readonly attribute AuthenticatorResponse response;
AuthenticationExtensions getClientExtensionResults();
AuthenticationExtensionsClientOutputs getClientExtensionResults();
};
partial dictionary CredentialCreationOptions {
MakePublicKeyCredentialOptions publicKey;
PublicKeyCredentialCreationOptions publicKey;
};
partial dictionary CredentialRequestOptions {
@ -31,7 +35,7 @@ interface AuthenticatorAttestationResponse : AuthenticatorResponse {
interface AuthenticatorAssertionResponse : AuthenticatorResponse {
[SameObject] readonly attribute ArrayBuffer authenticatorData;
[SameObject] readonly attribute ArrayBuffer signature;
[SameObject] readonly attribute ArrayBuffer userHandle;
[SameObject] readonly attribute ArrayBuffer? userHandle;
};
dictionary PublicKeyCredentialParameters {
@ -39,7 +43,7 @@ dictionary PublicKeyCredentialParameters {
required COSEAlgorithmIdentifier alg;
};
dictionary MakePublicKeyCredentialOptions {
dictionary PublicKeyCredentialCreationOptions {
required PublicKeyCredentialRpEntity rp;
required PublicKeyCredentialUserEntity user;
@ -50,7 +54,7 @@ dictionary MakePublicKeyCredentialOptions {
sequence<PublicKeyCredentialDescriptor> excludeCredentials = [];
AuthenticatorSelectionCriteria authenticatorSelection;
AttestationConveyancePreference attestation = "none";
AuthenticationExtensions extensions;
AuthenticationExtensionsClientInputs extensions;
};
dictionary PublicKeyCredentialEntity {
@ -90,21 +94,31 @@ dictionary PublicKeyCredentialRequestOptions {
USVString rpId;
sequence<PublicKeyCredentialDescriptor> allowCredentials = [];
UserVerificationRequirement userVerification = "preferred";
AuthenticationExtensions extensions;
AuthenticationExtensionsClientInputs extensions;
};
typedef record<DOMString, any> AuthenticationExtensions;
dictionary AuthenticationExtensionsClientInputs {
};
dictionary AuthenticationExtensionsClientOutputs {
};
typedef record<DOMString, DOMString> AuthenticationExtensionsAuthenticatorInputs;
dictionary CollectedClientData {
required DOMString type;
required DOMString challenge;
required DOMString origin;
required DOMString hashAlgorithm;
DOMString tokenBindingId;
AuthenticationExtensions clientExtensions;
AuthenticationExtensions authenticatorExtensions;
TokenBinding tokenBinding;
};
dictionary TokenBinding {
required TokenBindingStatus status;
DOMString id;
};
enum TokenBindingStatus { "present", "supported", "not-supported" };
enum PublicKeyCredentialType {
"public-key"
};
@ -129,6 +143,85 @@ enum UserVerificationRequirement {
"discouraged"
};
typedef sequence<AAGUID> AuthenticatorSelectionList;
partial dictionary AuthenticationExtensionsClientInputs {
USVString appid;
};
typedef BufferSource AAGUID;
partial dictionary AuthenticationExtensionsClientOutputs {
boolean appid;
};
partial dictionary AuthenticationExtensionsClientInputs {
USVString txAuthSimple;
};
partial dictionary AuthenticationExtensionsClientOutputs {
USVString txAuthSimple;
};
dictionary txAuthGenericArg {
required USVString contentType; // MIME-Type of the content, e.g., "image/png"
required ArrayBuffer content;
};
partial dictionary AuthenticationExtensionsClientInputs {
txAuthGenericArg txAuthGeneric;
};
partial dictionary AuthenticationExtensionsClientOutputs {
ArrayBuffer txAuthGeneric;
};
typedef sequence<AAGUID> AuthenticatorSelectionList;
partial dictionary AuthenticationExtensionsClientInputs {
AuthenticatorSelectionList authnSel;
};
typedef BufferSource AAGUID;
partial dictionary AuthenticationExtensionsClientOutputs {
boolean authnSel;
};
partial dictionary AuthenticationExtensionsClientInputs {
boolean exts;
};
typedef sequence<USVString> AuthenticationExtensionsSupported;
partial dictionary AuthenticationExtensionsClientOutputs {
AuthenticationExtensionsSupported exts;
};
partial dictionary AuthenticationExtensionsClientInputs {
boolean uvi;
};
partial dictionary AuthenticationExtensionsClientOutputs {
ArrayBuffer uvi;
};
partial dictionary AuthenticationExtensionsClientInputs {
boolean loc;
};
partial dictionary AuthenticationExtensionsClientOutputs {
Coordinates loc;
};
partial dictionary AuthenticationExtensionsClientInputs {
boolean uvm;
};
typedef sequence<unsigned long> UvmEntry;
typedef sequence<UvmEntry> UvmEntries;
partial dictionary AuthenticationExtensionsClientOutputs {
UvmEntries uvm;
};
dictionary authenticatorBiometricPerfBounds{
float FAR;
float FRR;
};

651
tests/wpt/web-platform-tests/interfaces/webrtc-pc.idl
View file

@ -1,15 +1,16 @@
// IDL definition extracted from
// https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
// GENERATED CONTENT - DO NOT EDIT
// Content of this file was automatically extracted from the WebRTC spec.
// See https://w3c.github.io/webrtc-pc/
dictionary RTCConfiguration {
sequence<RTCIceServer> iceServers;
RTCIceTransportPolicy iceTransportPolicy = "all";
RTCBundlePolicy bundlePolicy = "balanced";
RTCRtcpMuxPolicy rtcpMuxPolicy = "require";
DOMString peerIdentity;
sequence<RTCCertificate> certificates;
[EnforceRange]
octet iceCandidatePoolSize = 0;
sequence<RTCIceServer> iceServers;
RTCIceTransportPolicy iceTransportPolicy = "all";
RTCBundlePolicy bundlePolicy = "balanced";
RTCRtcpMuxPolicy rtcpMuxPolicy = "require";
DOMString peerIdentity;
sequence<RTCCertificate> certificates;
[EnforceRange]
octet iceCandidatePoolSize = 0;
};
enum RTCIceCredentialType {
@ -18,14 +19,14 @@ enum RTCIceCredentialType {
};
dictionary RTCOAuthCredential {
required DOMString macKey;
required DOMString accessToken;
required DOMString macKey;
required DOMString accessToken;
};
dictionary RTCIceServer {
required (DOMString or sequence<DOMString>) urls;
DOMString username;
(DOMString or RTCOAuthCredential) credential;
(DOMString or RTCOAuthCredential) credential;
RTCIceCredentialType credentialType = "password";
};
@ -47,71 +48,16 @@ enum RTCRtcpMuxPolicy {
};
dictionary RTCOfferAnswerOptions {
boolean voiceActivityDetection = true;
boolean voiceActivityDetection = true;
};
dictionary RTCOfferOptions : RTCOfferAnswerOptions {
boolean iceRestart = false;
boolean offerToReceiveAudio;
boolean offerToReceiveVideo;
boolean iceRestart = false;
};
dictionary RTCAnswerOptions : RTCOfferAnswerOptions {
dictionary RTCAnswerOptions : RTCOfferAnswerOptions {
};
[Constructor(optional RTCConfiguration configuration)]
interface RTCPeerConnection : EventTarget {
Promise<RTCSessionDescriptionInit> createOffer(optional RTCOfferOptions options);
Promise<RTCSessionDescriptionInit> createAnswer(optional RTCAnswerOptions options);
Promise<void> setLocalDescription(RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? localDescription;
readonly attribute RTCSessionDescription? currentLocalDescription;
readonly attribute RTCSessionDescription? pendingLocalDescription;
Promise<void> setRemoteDescription(RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? remoteDescription;
readonly attribute RTCSessionDescription? currentRemoteDescription;
readonly attribute RTCSessionDescription? pendingRemoteDescription;
Promise<void> addIceCandidate((RTCIceCandidateInit or RTCIceCandidate) candidate);
readonly attribute RTCSignalingState signalingState;
readonly attribute RTCIceGatheringState iceGatheringState;
readonly attribute RTCIceConnectionState iceConnectionState;
readonly attribute RTCPeerConnectionState connectionState;
readonly attribute boolean? canTrickleIceCandidates;
static sequence<RTCIceServer> getDefaultIceServers();
RTCConfiguration getConfiguration();
void setConfiguration(RTCConfiguration configuration);
void close();
attribute EventHandler onnegotiationneeded;
attribute EventHandler onicecandidate;
attribute EventHandler onicecandidateerror;
attribute EventHandler onsignalingstatechange;
attribute EventHandler oniceconnectionstatechange;
attribute EventHandler onicegatheringstatechange;
attribute EventHandler onconnectionstatechange;
attribute EventHandler onfingerprintfailure;
};
partial interface RTCPeerConnection {
Promise<void> createOffer(RTCSessionDescriptionCallback successCallback,
RTCPeerConnectionErrorCallback failureCallback,
optional RTCOfferOptions options);
Promise<void> setLocalDescription(RTCSessionDescriptionInit description,
VoidFunction successCallback,
RTCPeerConnectionErrorCallback failureCallback);
Promise<void> createAnswer(RTCSessionDescriptionCallback successCallback,
RTCPeerConnectionErrorCallback failureCallback);
Promise<void> setRemoteDescription(RTCSessionDescriptionInit description,
VoidFunction successCallback,
RTCPeerConnectionErrorCallback failureCallback);
Promise<void> addIceCandidate((RTCIceCandidateInit or RTCIceCandidate) candidate,
VoidFunction successCallback,
RTCPeerConnectionErrorCallback failureCallback);
};
callback RTCPeerConnectionErrorCallback = void (DOMException error);
callback RTCSessionDescriptionCallback = void (RTCSessionDescriptionInit description);
enum RTCSignalingState {
"stable",
"have-local-offer",
@ -141,11 +87,59 @@ enum RTCIceConnectionState {
"checking",
"connected",
"completed",
"failed",
"disconnected",
"failed",
"closed"
};
[ Constructor (optional RTCConfiguration configuration), Exposed=Window]
interface RTCPeerConnection : EventTarget {
Promise<RTCSessionDescriptionInit> createOffer (optional RTCOfferOptions options);
Promise<RTCSessionDescriptionInit> createAnswer (optional RTCAnswerOptions options);
Promise<void> setLocalDescription (RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? localDescription;
readonly attribute RTCSessionDescription? currentLocalDescription;
readonly attribute RTCSessionDescription? pendingLocalDescription;
Promise<void> setRemoteDescription (RTCSessionDescriptionInit description);
readonly attribute RTCSessionDescription? remoteDescription;
readonly attribute RTCSessionDescription? currentRemoteDescription;
readonly attribute RTCSessionDescription? pendingRemoteDescription;
Promise<void> addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate);
readonly attribute RTCSignalingState signalingState;
readonly attribute RTCIceGatheringState iceGatheringState;
readonly attribute RTCIceConnectionState iceConnectionState;
readonly attribute RTCPeerConnectionState connectionState;
readonly attribute boolean? canTrickleIceCandidates;
static sequence<RTCIceServer> getDefaultIceServers ();
RTCConfiguration getConfiguration ();
void setConfiguration (RTCConfiguration configuration);
void close ();
attribute EventHandler onnegotiationneeded;
attribute EventHandler onicecandidate;
attribute EventHandler onicecandidateerror;
attribute EventHandler onsignalingstatechange;
attribute EventHandler oniceconnectionstatechange;
attribute EventHandler onicegatheringstatechange;
attribute EventHandler onconnectionstatechange;
};
partial interface RTCPeerConnection {
Promise<void> createOffer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback, optional RTCOfferOptions options);
Promise<void> setLocalDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> createAnswer (RTCSessionDescriptionCallback successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> setRemoteDescription (RTCSessionDescriptionInit description, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
Promise<void> addIceCandidate ((RTCIceCandidateInit or RTCIceCandidate) candidate, VoidFunction successCallback, RTCPeerConnectionErrorCallback failureCallback);
};
callback RTCPeerConnectionErrorCallback = void (DOMException error);
callback RTCSessionDescriptionCallback = void (RTCSessionDescriptionInit description);
partial dictionary RTCOfferOptions {
boolean offerToReceiveAudio;
boolean offerToReceiveVideo;
};
enum RTCSdpType {
"offer",
"pranswer",
@ -153,10 +147,10 @@ enum RTCSdpType {
"rollback"
};
[Constructor(RTCSessionDescriptionInit descriptionInitDict)]
[ Constructor (RTCSessionDescriptionInit descriptionInitDict), Exposed=Window]
interface RTCSessionDescription {
readonly attribute RTCSdpType type;
readonly attribute DOMString sdp;
readonly attribute RTCSdpType type;
readonly attribute DOMString sdp;
[Default] object toJSON();
};
@ -165,30 +159,30 @@ dictionary RTCSessionDescriptionInit {
DOMString sdp = "";
};
[Constructor(optional RTCIceCandidateInit candidateInitDict)]
[ Constructor (optional RTCIceCandidateInit candidateInitDict), Exposed=Window]
interface RTCIceCandidate {
readonly attribute DOMString candidate;
readonly attribute DOMString? sdpMid;
readonly attribute unsigned short? sdpMLineIndex;
readonly attribute DOMString? foundation;
readonly attribute RTCIceComponent? component;
readonly attribute unsigned long? priority;
readonly attribute DOMString? ip;
readonly attribute RTCIceProtocol? protocol;
readonly attribute unsigned short? port;
readonly attribute RTCIceCandidateType? type;
readonly attribute RTCIceTcpCandidateType? tcpType;
readonly attribute DOMString? relatedAddress;
readonly attribute unsigned short? relatedPort;
readonly attribute DOMString? usernameFragment;
readonly attribute DOMString candidate;
readonly attribute DOMString? sdpMid;
readonly attribute unsigned short? sdpMLineIndex;
readonly attribute DOMString? foundation;
readonly attribute RTCIceComponent? component;
readonly attribute unsigned long? priority;
readonly attribute DOMString? ip;
readonly attribute RTCIceProtocol? protocol;
readonly attribute unsigned short? port;
readonly attribute RTCIceCandidateType? type;
readonly attribute RTCIceTcpCandidateType? tcpType;
readonly attribute DOMString? relatedAddress;
readonly attribute unsigned short? relatedPort;
readonly attribute DOMString? usernameFragment;
RTCIceCandidateInit toJSON();
};
dictionary RTCIceCandidateInit {
DOMString candidate = "";
DOMString? sdpMid = null;
unsigned short? sdpMLineIndex = null;
DOMString usernameFragment;
DOMString candidate = "";
DOMString? sdpMid = null;
unsigned short? sdpMLineIndex = null;
DOMString usernameFragment;
};
enum RTCIceProtocol {
@ -209,29 +203,29 @@ enum RTCIceCandidateType {
"relay"
};
[Constructor(DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict)]
[ Constructor (DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceEvent : Event {
readonly attribute RTCIceCandidate? candidate;
readonly attribute DOMString? url;
readonly attribute RTCIceCandidate? candidate;
readonly attribute DOMString? url;
};
dictionary RTCPeerConnectionIceEventInit : EventInit {
RTCIceCandidate? candidate;
DOMString? url;
dictionary RTCPeerConnectionIceEventInit : EventInit {
RTCIceCandidate? candidate;
DOMString? url;
};
[Constructor(DOMString type, RTCPeerConnectionIceErrorEventInit eventInitDict)]
[ Constructor (DOMString type, RTCPeerConnectionIceErrorEventInit eventInitDict), Exposed=Window]
interface RTCPeerConnectionIceErrorEvent : Event {
readonly attribute DOMString hostCandidate;
readonly attribute DOMString url;
readonly attribute unsigned short errorCode;
readonly attribute USVString errorText;
readonly attribute DOMString hostCandidate;
readonly attribute DOMString url;
readonly attribute unsigned short errorCode;
readonly attribute USVString errorText;
};
dictionary RTCPeerConnectionIceErrorEventInit : EventInit {
dictionary RTCPeerConnectionIceErrorEventInit : EventInit {
DOMString hostCandidate;
DOMString url;
required unsigned short errorCode;
required unsigned short errorCode;
USVString statusText;
};
@ -243,7 +237,7 @@ enum RTCPriorityType {
};
partial interface RTCPeerConnection {
static Promise<RTCCertificate> generateCertificate(AlgorithmIdentifier keygenAlgorithm);
static Promise<RTCCertificate> generateCertificate (AlgorithmIdentifier keygenAlgorithm);
};
dictionary RTCCertificateExpiration {
@ -251,29 +245,26 @@ dictionary RTCCertificateExpiration {
DOMTimeStamp expires;
};
interface RTCCertificate {
readonly attribute DOMTimeStamp expires;
sequence<RTCDtlsFingerprint> getFingerprints();
// At risk due to lack of implementers' interest.
AlgorithmIdentifier getAlgorithm();
[Exposed=Window] interface RTCCertificate {
readonly attribute DOMTimeStamp expires;
static sequence<AlgorithmIdentifier> getSupportedAlgorithms();
sequence<RTCDtlsFingerprint> getFingerprints ();
};
partial interface RTCPeerConnection {
sequence<RTCRtpSender> getSenders();
sequence<RTCRtpReceiver> getReceivers();
sequence<RTCRtpTransceiver> getTransceivers();
RTCRtpSender addTrack(MediaStreamTrack track,
MediaStream... streams);
void removeTrack(RTCRtpSender sender);
RTCRtpTransceiver addTransceiver((MediaStreamTrack or DOMString) trackOrKind,
optional RTCRtpTransceiverInit init);
attribute EventHandler ontrack;
sequence<RTCRtpSender> getSenders ();
sequence<RTCRtpReceiver> getReceivers ();
sequence<RTCRtpTransceiver> getTransceivers ();
RTCRtpSender addTrack (MediaStreamTrack track, MediaStream... streams);
void removeTrack (RTCRtpSender sender);
RTCRtpTransceiver addTransceiver ((MediaStreamTrack or DOMString) trackOrKind, optional RTCRtpTransceiverInit init);
attribute EventHandler ontrack;
};
dictionary RTCRtpTransceiverInit {
RTCRtpTransceiverDirection direction = "sendrecv";
sequence<MediaStream> streams;
sequence<RTCRtpEncodingParameters> sendEncodings;
RTCRtpTransceiverDirection direction = "sendrecv";
sequence<MediaStream> streams = [];
sequence<RTCRtpEncodingParameters> sendEncodings = [];
};
enum RTCRtpTransceiverDirection {
@ -283,45 +274,42 @@ enum RTCRtpTransceiverDirection {
"inactive"
};
interface RTCRtpSender {
readonly attribute MediaStreamTrack? track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
// Feature at risk
static RTCRtpCapabilities getCapabilities(DOMString kind);
Promise<void> setParameters(optional RTCRtpParameters parameters);
RTCRtpParameters getParameters();
Promise<void> replaceTrack(MediaStreamTrack withTrack);
Promise<RTCStatsReport> getStats();
[Exposed=Window] interface RTCRtpSender {
readonly attribute MediaStreamTrack? track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
static RTCRtpCapabilities getCapabilities (DOMString kind);
Promise<void> setParameters (optional RTCRtpParameters parameters);
RTCRtpParameters getParameters ();
Promise<void> replaceTrack (MediaStreamTrack? withTrack);
Promise<RTCStatsReport> getStats();
};
dictionary RTCRtpParameters {
DOMString transactionId;
sequence<RTCRtpEncodingParameters> encodings;
sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
RTCRtcpParameters rtcp;
sequence<RTCRtpCodecParameters> codecs;
RTCDegradationPreference degradationPreference;
DOMString transactionId;
sequence<RTCRtpEncodingParameters> encodings;
sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
RTCRtcpParameters rtcp;
sequence<RTCRtpCodecParameters> codecs;
RTCDegradationPreference degradationPreference;
};
dictionary RTCRtpEncodingParameters {
unsigned long ssrc;
RTCRtpRtxParameters rtx;
RTCRtpFecParameters fec;
RTCDtxStatus dtx;
boolean active;
RTCPriorityType priority;
unsigned long ptime;
unsigned long maxBitrate;
double maxFramerate;
DOMString rid;
double scaleResolutionDownBy;
octet codecPayloadType;
RTCDtxStatus dtx;
boolean active = true;
RTCPriorityType priority = "low";
unsigned long ptime;
unsigned long maxBitrate;
double maxFramerate;
DOMString rid;
double scaleResolutionDownBy;
};
enum RTCDtxStatus {
"disabled",
"enabled"
};
"disabled",
"enabled"
};
enum RTCDegradationPreference {
"maintain-framerate",
@ -329,93 +317,81 @@ enum RTCDegradationPreference {
"balanced"
};
dictionary RTCRtpRtxParameters {
unsigned long ssrc;
};
dictionary RTCRtpFecParameters {
unsigned long ssrc;
};
dictionary RTCRtcpParameters {
DOMString cname;
boolean reducedSize;
DOMString cname;
boolean reducedSize;
};
dictionary RTCRtpHeaderExtensionParameters {
DOMString uri;
unsigned short id;
boolean encrypted;
DOMString uri;
unsigned short id;
boolean encrypted;
};
dictionary RTCRtpCodecParameters {
unsigned short payloadType;
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
octet payloadType;
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
};
dictionary RTCRtpCapabilities {
sequence<RTCRtpCodecCapability> codecs;
sequence<RTCRtpHeaderExtensionCapability> headerExtensions;
sequence<RTCRtpCodecCapability> codecs;
sequence<RTCRtpHeaderExtensionCapability> headerExtensions;
};
dictionary RTCRtpCodecCapability {
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
DOMString mimeType;
unsigned long clockRate;
unsigned short channels;
DOMString sdpFmtpLine;
};
dictionary RTCRtpHeaderExtensionCapability {
DOMString uri;
DOMString uri;
};
interface RTCRtpReceiver {
readonly attribute MediaStreamTrack track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
// Feature at risk
static RTCRtpCapabilities getCapabilities(DOMString kind);
RTCRtpParameters getParameters();
sequence<RTCRtpContributingSource> getContributingSources();
sequence<RTCRtpSynchronizationSource> getSynchronizationSources();
Promise<RTCStatsReport> getStats();
[Exposed=Window] interface RTCRtpReceiver {
readonly attribute MediaStreamTrack track;
readonly attribute RTCDtlsTransport? transport;
readonly attribute RTCDtlsTransport? rtcpTransport;
static RTCRtpCapabilities getCapabilities (DOMString kind);
RTCRtpParameters getParameters ();
sequence<RTCRtpContributingSource> getContributingSources ();
sequence<RTCRtpSynchronizationSource> getSynchronizationSources ();
Promise<RTCStatsReport> getStats();
};
interface RTCRtpContributingSource {
readonly attribute DOMHighResTimeStamp timestamp;
readonly attribute unsigned long source;
readonly attribute byte? audioLevel;
dictionary RTCRtpContributingSource {
required DOMHighResTimeStamp timestamp;
required unsigned long source;
double audioLevel;
};
interface RTCRtpSynchronizationSource {
readonly attribute DOMHighResTimeStamp timestamp;
readonly attribute unsigned long source;
readonly attribute byte audioLevel;
readonly attribute boolean? voiceActivityFlag;
dictionary RTCRtpSynchronizationSource : RTCRtpContributingSource {
boolean voiceActivityFlag;
};
interface RTCRtpTransceiver {
readonly attribute DOMString? mid;
[Exposed=Window] interface RTCRtpTransceiver {
readonly attribute DOMString? mid;
[SameObject]
readonly attribute RTCRtpSender sender;
readonly attribute RTCRtpSender sender;
[SameObject]
readonly attribute RTCRtpReceiver receiver;
readonly attribute boolean stopped;
readonly attribute RTCRtpTransceiverDirection direction;
readonly attribute RTCRtpTransceiverDirection? currentDirection;
void setDirection(RTCRtpTransceiverDirection direction);
void stop();
void setCodecPreferences(sequence<RTCRtpCodecCapability> codecs);
readonly attribute RTCRtpReceiver receiver;
readonly attribute boolean stopped;
attribute RTCRtpTransceiverDirection direction;
readonly attribute RTCRtpTransceiverDirection? currentDirection;
void stop ();
void setCodecPreferences (sequence<RTCRtpCodecCapability> codecs);
};
interface RTCDtlsTransport {
readonly attribute RTCIceTransport transport;
readonly attribute RTCDtlsTransportState state;
sequence<ArrayBuffer> getRemoteCertificates();
attribute EventHandler onstatechange;
[Exposed=Window] interface RTCDtlsTransport : EventTarget {
readonly attribute RTCIceTransport transport;
readonly attribute RTCDtlsTransportState state;
sequence<ArrayBuffer> getRemoteCertificates ();
attribute EventHandler onstatechange;
attribute EventHandler onerror;
};
enum RTCDtlsTransportState {
@ -427,33 +403,33 @@ enum RTCDtlsTransportState {
};
dictionary RTCDtlsFingerprint {
DOMString algorithm;
DOMString value;
DOMString algorithm;
DOMString value;
};
interface RTCIceTransport {
readonly attribute RTCIceRole role;
readonly attribute RTCIceComponent component;
readonly attribute RTCIceTransportState state;
readonly attribute RTCIceGathererState gatheringState;
sequence<RTCIceCandidate> getLocalCandidates();
sequence<RTCIceCandidate> getRemoteCandidates();
RTCIceCandidatePair? getSelectedCandidatePair();
RTCIceParameters? getLocalParameters();
RTCIceParameters? getRemoteParameters();
attribute EventHandler onstatechange;
attribute EventHandler ongatheringstatechange;
attribute EventHandler onselectedcandidatepairchange;
[Exposed=Window] interface RTCIceTransport : EventTarget {
readonly attribute RTCIceRole role;
readonly attribute RTCIceComponent component;
readonly attribute RTCIceTransportState state;
readonly attribute RTCIceGathererState gatheringState;
sequence<RTCIceCandidate> getLocalCandidates ();
sequence<RTCIceCandidate> getRemoteCandidates ();
RTCIceCandidatePair? getSelectedCandidatePair ();
RTCIceParameters? getLocalParameters ();
RTCIceParameters? getRemoteParameters ();
attribute EventHandler onstatechange;
attribute EventHandler ongatheringstatechange;
attribute EventHandler onselectedcandidatepairchange;
};
dictionary RTCIceParameters {
DOMString usernameFragment;
DOMString password;
DOMString usernameFragment;
DOMString password;
};
dictionary RTCIceCandidatePair {
RTCIceCandidate local;
RTCIceCandidate remote;
RTCIceCandidate local;
RTCIceCandidate remote;
};
enum RTCIceGathererState {
@ -467,8 +443,8 @@ enum RTCIceTransportState {
"checking",
"connected",
"completed",
"failed",
"disconnected",
"failed",
"closed"
};
@ -482,13 +458,13 @@ enum RTCIceComponent {
"rtcp"
};
[Constructor(DOMString type, RTCTrackEventInit eventInitDict)]
[ Constructor (DOMString type, RTCTrackEventInit eventInitDict), Exposed=Window]
interface RTCTrackEvent : Event {
readonly attribute RTCRtpReceiver receiver;
readonly attribute MediaStreamTrack track;
readonly attribute RTCRtpReceiver receiver;
readonly attribute MediaStreamTrack track;
[SameObject]
readonly attribute FrozenArray<MediaStream> streams;
readonly attribute RTCRtpTransceiver transceiver;
readonly attribute FrozenArray<MediaStream> streams;
readonly attribute RTCRtpTransceiver transceiver;
};
dictionary RTCTrackEventInit : EventInit {
@ -499,51 +475,59 @@ dictionary RTCTrackEventInit : EventInit {
};
partial interface RTCPeerConnection {
readonly attribute RTCSctpTransport? sctp;
RTCDataChannel createDataChannel(USVString label,
optional RTCDataChannelInit dataChannelDict);
attribute EventHandler ondatachannel;
readonly attribute RTCSctpTransport? sctp;
RTCDataChannel createDataChannel (USVString label, optional RTCDataChannelInit dataChannelDict);
attribute EventHandler ondatachannel;
};
interface RTCSctpTransport {
readonly attribute RTCDtlsTransport transport;
readonly attribute unrestricted double maxMessageSize;
[Exposed=Window] interface RTCSctpTransport {
readonly attribute RTCDtlsTransport transport;
readonly attribute RTCSctpTransportState state;
readonly attribute unrestricted double maxMessageSize;
attribute EventHandler onstatechange;
};
interface RTCDataChannel : EventTarget {
readonly attribute USVString label;
readonly attribute boolean ordered;
readonly attribute unsigned short? maxPacketLifeTime;
readonly attribute unsigned short? maxRetransmits;
readonly attribute USVString protocol;
readonly attribute boolean negotiated;
readonly attribute unsigned short? id;
readonly attribute RTCPriorityType priority;
readonly attribute RTCDataChannelState readyState;
readonly attribute unsigned long bufferedAmount;
attribute unsigned long bufferedAmountLowThreshold;
attribute EventHandler onopen;
attribute EventHandler onbufferedamountlow;
attribute EventHandler onerror;
attribute EventHandler onclose;
void close();
attribute EventHandler onmessage;
attribute DOMString binaryType;
void send(USVString data);
void send(Blob data);
void send(ArrayBuffer data);
void send(ArrayBufferView data);
enum RTCSctpTransportState {
"new",
"connecting",
"connected",
"closed"
};
[Exposed=Window] interface RTCDataChannel : EventTarget {
readonly attribute USVString label;
readonly attribute boolean ordered;
readonly attribute unsigned short? maxPacketLifeTime;
readonly attribute unsigned short? maxRetransmits;
readonly attribute USVString protocol;
readonly attribute boolean negotiated;
readonly attribute unsigned short? id;
readonly attribute RTCPriorityType priority;
readonly attribute RTCDataChannelState readyState;
readonly attribute unsigned long bufferedAmount;
attribute unsigned long bufferedAmountLowThreshold;
attribute EventHandler onopen;
attribute EventHandler onbufferedamountlow;
attribute EventHandler onerror;
attribute EventHandler onclose;
void close ();
attribute EventHandler onmessage;
attribute DOMString binaryType;
void send (USVString data);
void send (Blob data);
void send (ArrayBuffer data);
void send (ArrayBufferView data);
};
dictionary RTCDataChannelInit {
boolean ordered = true;
unsigned short maxPacketLifeTime;
unsigned short maxRetransmits;
USVString protocol = "";
boolean negotiated = false;
[EnforceRange]
unsigned short id;
RTCPriorityType priority = "low";
boolean ordered = true;
unsigned short maxPacketLifeTime;
unsigned short maxRetransmits;
USVString protocol = "";
boolean negotiated = false;
[EnforceRange]
unsigned short id;
RTCPriorityType priority = "low";
};
enum RTCDataChannelState {
@ -553,59 +537,64 @@ enum RTCDataChannelState {
"closed"
};
[Constructor(DOMString type, RTCDataChannelEventInit eventInitDict)]
[ Constructor (DOMString type, RTCDataChannelEventInit eventInitDict), Exposed=Window]
interface RTCDataChannelEvent : Event {
readonly attribute RTCDataChannel channel;
readonly attribute RTCDataChannel channel;
};
dictionary RTCDataChannelEventInit : EventInit {
required RTCDataChannel channel;
required RTCDataChannel channel;
};
partial interface RTCRtpSender {
readonly attribute RTCDTMFSender? dtmf;
readonly attribute RTCDTMFSender? dtmf;
};
interface RTCDTMFSender : EventTarget {
void insertDTMF(DOMString tones,
optional unsigned long duration = 100,
optional unsigned long interToneGap = 70);
attribute EventHandler ontonechange;
readonly attribute DOMString toneBuffer;
[Exposed=Window] interface RTCDTMFSender : EventTarget {
void insertDTMF (DOMString tones, optional unsigned long duration = 100, optional unsigned long interToneGap = 70);
attribute EventHandler ontonechange;
readonly attribute boolean canInsertDTMF;
readonly attribute DOMString toneBuffer;
};
[Constructor(DOMString type, RTCDTMFToneChangeEventInit eventInitDict)]
[ Constructor (DOMString type, RTCDTMFToneChangeEventInit eventInitDict), Exposed=Window]
interface RTCDTMFToneChangeEvent : Event {
readonly attribute DOMString tone;
readonly attribute DOMString tone;
};
dictionary RTCDTMFToneChangeEventInit : EventInit {
required DOMString tone;
required DOMString tone;
};
partial interface RTCPeerConnection {
Promise<RTCStatsReport> getStats(optional MediaStreamTrack? selector = null);
};
Promise<RTCStatsReport> getStats (optional MediaStreamTrack? selector = null);
attribute EventHandler onstatsended;
};
interface RTCStatsReport {
[Exposed=Window] interface RTCStatsReport {
readonly maplike<DOMString, object>;
};
dictionary RTCStats {
DOMHighResTimeStamp timestamp;
RTCStatsType type;
DOMString id;
required DOMHighResTimeStamp timestamp;
required RTCStatsType type;
required DOMString id;
};
[Global,
Exposed=RTCIdentityProviderGlobalScope]
[ Constructor (DOMString type, RTCStatsEventInit
eventInitDict), Exposed=Window]
interface RTCStatsEvent : Event {
readonly attribute RTCStatsReport report;
};
[Global, Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderGlobalScope : WorkerGlobalScope {
readonly attribute RTCIdentityProviderRegistrar rtcIdentityProvider;
readonly attribute RTCIdentityProviderRegistrar rtcIdentityProvider;
};
[Exposed=RTCIdentityProviderGlobalScope]
interface RTCIdentityProviderRegistrar {
void register(RTCIdentityProvider idp);
void register (RTCIdentityProvider idp);
};
dictionary RTCIdentityProvider {
@ -613,12 +602,11 @@ dictionary RTCIdentityProvider {
required ValidateAssertionCallback validateAssertion;
};
callback GenerateAssertionCallback = Promise<RTCIdentityAssertionResult> (DOMString contents,
DOMString origin,
RTCIdentityProviderOptions options);
callback GenerateAssertionCallback = Promise<RTCIdentityAssertionResult>
(DOMString contents, DOMString origin, RTCIdentityProviderOptions options);
callback ValidateAssertionCallback = Promise<RTCIdentityValidationResult> (DOMString assertion,
DOMString origin);
callback ValidateAssertionCallback = Promise<RTCIdentityValidationResult>
(DOMString assertion, DOMString origin);
dictionary RTCIdentityAssertionResult {
required RTCIdentityProviderDetails idp;
@ -636,12 +624,11 @@ dictionary RTCIdentityValidationResult {
};
partial interface RTCPeerConnection {
void setIdentityProvider(DOMString provider,
optional RTCIdentityProviderOptions options);
Promise<DOMString> getIdentityAssertion();
readonly attribute Promise<RTCIdentityAssertion> peerIdentity;
readonly attribute DOMString? idpLoginUrl;
readonly attribute DOMString? idpErrorInfo;
void setIdentityProvider (DOMString provider, optional RTCIdentityProviderOptions options);
Promise<DOMString> getIdentityAssertion ();
readonly attribute Promise<RTCIdentityAssertion> peerIdentity;
readonly attribute DOMString? idpLoginUrl;
readonly attribute DOMString? idpErrorInfo;
};
dictionary RTCIdentityProviderOptions {
@ -650,41 +637,45 @@ dictionary RTCIdentityProviderOptions {
DOMString peerIdentity;
};
[Constructor(DOMString idp, DOMString name)]
[Constructor(DOMString idp, DOMString name), Exposed=Window]
interface RTCIdentityAssertion {
attribute DOMString idp;
attribute DOMString name;
};
partial dictionary MediaStreamConstraints {
DOMString peerIdentity;
DOMString peerIdentity;
};
partial interface MediaStreamTrack {
readonly attribute boolean isolated;
attribute EventHandler onisolationchange;
readonly attribute boolean isolated;
attribute EventHandler onisolationchange;
};
enum RTCErrorDetailType {
"data-channel-failure",
"idp-bad-script-failure",
"idp-execution-failure",
"idp-load-failure",
"idp-need-login",
"idp-timeout",
"idp-tls-failure",
"idp-token-expired",
"idp-token-invalid",
"sctp-failure",
"sdp-syntax-error"
};
"data-channel-failure",
"dtls-failure",
"fingerprint-failure",
"idp-bad-script-failure",
"idp-execution-failure",
"idp-load-failure",
"idp-need-login",
"idp-timeout",
"idp-tls-failure",
"idp-token-expired",
"idp-token-invalid",
"sctp-failure",
"sdp-syntax-error",
"hardware-encoder-not-available",
"hardware-encoder-error"
};
[Exposed=Window,
Constructor(DOMString type, RTCErrorEventInit eventInitDict)]
Constructor (DOMString type, RTCErrorEventInit eventInitDict)]
interface RTCErrorEvent : Event {
readonly attribute RTCError? error;
readonly attribute RTCError? error;
};
dictionary RTCErrorEventInit : EventInit {
RTCError? error = null;
RTCError? error = null;
};

18
tests/wpt/web-platform-tests/service-workers/service-worker/resources/fetch-request-xhr-iframe.https.html
View file

@ -19,24 +19,6 @@ function get_boundary(headers) {
return '';
}
function create_file_system_file(file_name, data) {
return new Promise(function(resolve, reject) {
webkitRequestFileSystem(TEMPORARY, 1024, function(fs) {
fs.root.getFile(
file_name, {create: true, exclusive: true},
function(fileEntry) {
fileEntry.createWriter(function(fileWriter) {
fileWriter.onwriteend = function(e) {
fileEntry.file(function(file) { resolve(file); });
};
var blob = new Blob([data], {type: 'text/plain'});
fileWriter.write(blob);
});
}, function(e) { reject(e); });
}, function(e) { reject(e); });
});
}
function xhr_send(url_base, method, data, with_credentials) {
return new Promise(function(resolve, reject) {
var xhr = new XMLHttpRequest();

8
tests/wpt/web-platform-tests/tools/wpt/run.py
View file

@ -117,13 +117,13 @@ def check_environ(product):
if platform.uname()[0] != "Windows":
message = """Missing hosts file configuration. Run
python wpt make-hosts-file >> %s
from a shell with Administrator privileges.""" % hosts_path
./wpt make-hosts-file | sudo tee -a %s""" % hosts_path
else:
message = """Missing hosts file configuration. Run
./wpt make-hosts-file | sudo tee -a %s""" % hosts_path
python wpt make-hosts-file >> %s
from a shell with Administrator privileges.""" % hosts_path
raise WptrunError(message)

36
tests/wpt/web-platform-tests/uievents/mouse/mouse_buttons_back_forward-manual.html Normal file
View file

@ -0,0 +1,36 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title>Mouse Button Back/Forward</title>
<link rel="author" title="Google" href="http://www.google.com/" />
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>
var testMouseUp = async_test('Tests that the mouseup is preventable.');
var received_back = false;
var received_forward = false;
window.addEventListener('mouseup', function(e) {
if (e.button == 3) {
received_back = true;
e.preventDefault();
} else if (e.button == 4) {
received_forward = true;
e.preventDefault();
}
if (received_back && received_forward) {
testMouseUp.done();
}
});
</script>
</head>
<body id="target">
<h4>Test Description: Tests that the mouseup event is prevented.
<ol>
<li>Click the back mouse button</li>
<li>Click the back mouse forward</li>
</ol>
</h4>
</body>
</html>

19
tests/wpt/web-platform-tests/wasm/many-memories.window.js
View file

@ -1,19 +0,0 @@
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This test makes sure browsers behave reasonably when asked to allocate a
// larger number of WebAssembly.Memory objects at once.
test(function() {
let memories = [];
try {
for (let i = 0; i < 20; i++) {
memories.push(new WebAssembly.Memory({initial: 1}));
}
} catch (e) {
if (e instanceof RangeError) {
return;
}
throw e;
}
}, "WebAssembly#CreateManyMemories");

2
tests/wpt/web-platform-tests/webaudio/idlharness.https.html
View file

@ -20,7 +20,7 @@ promise_test(async t => {
// Needed for MediaStream, MediaStreamTrack
'/interfaces/mediacapture-main.idl',
'/interfaces/webaudio.idl'
'/interfaces/web-audio-api.idl'
].map(url => fetch(url).then(response => response.text())));
const idl_array = new IdlArray();

30
tests/wpt/web-platform-tests/webauthn/interfaces.https.any.js Normal file
View file

@ -0,0 +1,30 @@
// META: script=/resources/WebIDLParser.js
// META: script=/resources/idlharness.js
'use strict';
if (self.importScripts) {
importScripts('/resources/testharness.js');
importScripts('/resources/WebIDLParser.js', '/resources/idlharness.js');
}
// https://w3c.github.io/webauthn/
promise_test(async () => {
const webauthnIdl = await fetch('/interfaces/webauthn.idl').then(r => r.text());
const idlArray = new IdlArray();
idlArray.add_idls(webauthnIdl);
// static IDL tests
idlArray.add_untested_idls('interface CredentialCreationOptions {};');
idlArray.add_untested_idls('interface CredentialRequestOptions {};');
idlArray.add_untested_idls("interface Navigator { };");
// TODO: change to "tested" for real browsers?
idlArray.add_untested_idls("partial interface Navigator { readonly attribute WebAuthentication authentication; };");
idlArray.add_objects({
WebAuthentication: ["navigator.authentication"]
});
idlArray.test();
done();
}, 'WebAuthn interfaces.');

60
tests/wpt/web-platform-tests/webauthn/interfaces.https.html
View file

@ -1,60 +0,0 @@
<!DOCTYPE html>
<meta charset="utf-8">
<title>WebAuthn WebIDL Tests</title>
<link rel="author" title="Adam Powers" href="mailto:adam@fidoalliance.org">
<link rel="help" href="https://w3c.github.io/webauthn/#iface-credential">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src=helpers.js></script>
<!-- for testing WebIDL -->
<script src=/resources/WebIDLParser.js></script>
<script src=/resources/idlharness.js></script>
<body></body>
<script>
standardSetup(function() {
"use strict";
// loads an IDL file from the webserver
function fetchIdl(idlUrl) {
return new Promise(function(resolve, reject) {
if (typeof idlUrl !== "string") {
return reject("fetchIdl: expected argument to be URL string");
}
var request = new XMLHttpRequest();
request.open("GET", idlUrl);
request.send();
request.onload = function() {
var idls = request.responseText;
return resolve(idls);
};
});
}
// this does the real work of running the IDL tests
function runIdlTests(idls) {
return new Promise(function(resolve, reject) {
var idlArray = new window.IdlArray();
// static IDL tests
idlArray.add_untested_idls("interface Navigator { };");
// TODO: change to "tested" for real browsers?
idlArray.add_untested_idls("partial interface Navigator { readonly attribute WebAuthentication authentication; };");
idlArray.add_objects({
WebAuthentication: ["navigator.authentication"]
});
// run test WebIDL tests loaded from the idls file
idlArray.add_idls(idls);
return resolve(idlArray.test());
});
}
// test harness function
window.promise_test(function() {
return fetchIdl("/interfaces/webauthn.idl") // load the IDL file ...
.then(function(idls) {
return runIdlTests(idls); // ... then run the tests.
});
}, "Validate WebAuthn IDL");
});
</script>

46
tests/wpt/web-platform-tests/webrtc/RTCPeerConnection-track-stats.https.html
View file

@ -424,6 +424,52 @@
'senderReport should contain remote-candidate stats');
}, 'RTCRtpSender.getStats() contains only outbound-rtp and related stats');
promise_test(async function() {
const caller = new RTCPeerConnection();
const callee = new RTCPeerConnection();
let [tracks, streams] = await getUserMediaTracksAndStreams(2);
let sender = caller.addTrack(tracks[0], streams[0]);
callee.addTrack(tracks[1], streams[1]);
exchangeIceCandidates(caller, callee);
await doSignalingHandshake(caller, callee);
await onIceConnectionStateCompleted(caller);
let receiver = caller.getReceivers()[0];
// Obtain inbound and outbound RTP stream stats on a full stats report.
let fullReport = await caller.getStats();
let outboundTrackStats = findStatsByTypeAndId(
fullReport, 'track', sender.track.id);
let outboundStats = findStatsByTypeAndMember(
fullReport, 'outbound-rtp', 'trackId', outboundTrackStats.id);
assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
let inboundTrackStats = findStatsByTypeAndId(
fullReport, 'track', receiver.track.id);
let inboundStats = findStatsByTypeAndMember(
fullReport, 'inbound-rtp', 'trackId', inboundTrackStats.id);
assert_true(inboundStats != null, 'Has stats for inbound RTP stream');
// Perform stats selection algorithm with receiver selector. The result
// should contain the inbound-rtp but not the outbound-rtp.
let receiverReport = await receiver.getStats();
assert_true(receiverReport.has(inboundStats.id));
assert_false(receiverReport.has(outboundStats.id));
// Validate the stats graph, ensuring all stats objects are reachable and
// valid from the outbound-rtp stats.
validateStatsGraph(receiverReport, receiverReport.get(inboundStats.id));
// Ensure that the stats graph contains some expected dictionaries.
assert_equals(findStatsOfType(receiverReport, 'track').length, 1,
'receiverReport should contain track stats');
assert_equals(findStatsOfType(receiverReport, 'transport').length, 1,
'receiverReport should contain transport stats');
assert_equals(findStatsOfType(receiverReport, 'candidate-pair').length, 1,
'receiverReport should contain candidate-pair stats');
assert_equals(findStatsOfType(receiverReport, 'local-candidate').length, 1,
'receiverReport should contain local-candidate stats');
assert_equals(findStatsOfType(receiverReport, 'remote-candidate').length, 1,
'receiverReport should contain remote-candidate stats');
}, 'RTCRtpReceiver.getStats() contains only inbound-rtp and related stats');
// Helpers.
function findStatsByTypeAndId(report, type, identifier) {

36
tests/wpt/web-platform-tests/webrtc/RTCRtpReceiver-getStats.html → tests/wpt/web-platform-tests/webrtc/RTCRtpReceiver-getStats.https.html
View file

@ -3,6 +3,7 @@
<title>RTCRtpReceiver.prototype.getStats</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="RTCPeerConnection-helper.js"></script>
<script src="dictionary-helper.js"></script>
<script src="RTCStats-helper.js"></script>
<script>
@ -12,6 +13,9 @@
// https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
// https://w3c.github.io/webrtc-stats/archives/20170614/webrtc-stats.html
// The following helper functions are called from RTCPeerConnection-helper.js:
// doSignalingHandshake
// The following helper function is called from RTCStats-helper.js
// validateStatsReport
// assert_stats_report_has_stats
@ -40,15 +44,29 @@
added.
*/
promise_test(() => {
const pc = new RTCPeerConnection();
const { receiver } = pc.addTransceiver('audio');
promise_test(async () => {
const caller = new RTCPeerConnection();
const callee = new RTCPeerConnection();
const { receiver } = caller.addTransceiver('audio');
return receiver.getStats()
.then(statsReport => {
validateStatsReport(statsReport);
assert_stats_report_has_stats(statsReport, ['inbound-rtp']);
});
}, 'receiver.getStats() should return stats report containing inbound-rtp stats');
await doSignalingHandshake(caller, callee);
const statsReport = await receiver.getStats();
validateStatsReport(statsReport);
assert_stats_report_has_stats(statsReport, ['inbound-rtp']);
}, 'receiver.getStats() via addTransceiver should return stats report containing inbound-rtp stats');
promise_test(async () => {
const caller = new RTCPeerConnection();
const callee = new RTCPeerConnection();
const stream = await navigator.mediaDevices.getUserMedia({audio:true});
const [track] = stream.getTracks();
caller.addTrack(track, stream);
await doSignalingHandshake(caller, callee);
const receiver = callee.getReceivers()[0];
const statsReport = await receiver.getStats();
validateStatsReport(statsReport);
assert_stats_report_has_stats(statsReport, ['inbound-rtp']);
}, 'receiver.getStats() via addTrack should return stats report containing inbound-rtp stats');
</script>

20
tests/wpt/web-platform-tests/webrtc/interfaces.https.html
View file

@ -107,13 +107,20 @@
}));
}
// Main function to do the IDL test, using fetched IDL text
function doIdlTest(idlText) {
promise_test(async t => {
await asyncInit();
const idlArray = new IdlArray();
let webrtcIdl = fetch('/interfaces/webrtc-pc.idl').then(r => r.text());
let mediacaptureMainIdl = fetch('/interfaces/mediacapture-main.idl').then(r => r.text());
idlArray.add_untested_idls(mediacaptureMainIdl, { only: ['MediaStreamConstraints'] });
idlArray.add_idls(webrtcIdl);
idlArray.add_untested_idls('interface EventHandler {};');
idlArray.add_idls('interface EventTarget {};');
idlArray.add_idls('interface MediaStreamTrack : EventTarget {};');
idlArray.add_idls(idlText);
idlArray.add_objects({
'RTCPeerConnection': [`new RTCPeerConnection()`],
@ -159,13 +166,6 @@
});
idlArray.test();
}
promise_test(t => {
return asyncInit()
.then(() => fetch('/interfaces/webrtc-pc.idl'))
.then(response => response.text())
.then(doIdlTest);
}, 'Main test driver');
/*