Update web-platform-tests to revision f1e1bd6bfa544af8059ff8ef79d622281f9ec0a8

tests/wpt/web-platform-tests/interfaces/css-animation-worklet.idl

@@ -22,12 +22,12 @@ interface WorkletAnimationEffect {
     attribute double? localTime;
 };
 
-[Exposed=Window,
- Constructor (DOMString animatorName,
+[Exposed=Window]
+interface WorkletAnimation : Animation {
+        constructor(DOMString animatorName,
               optional (AnimationEffect or sequence<AnimationEffect>)? effects = null,
               optional AnimationTimeline? timeline,
-              optional any options)]
-interface WorkletAnimation : Animation {
+              optional any options);
         readonly attribute DOMString animatorName;
 };
 

tests/wpt/web-platform-tests/interfaces/css-animations.idl

@@ -3,9 +3,9 @@
 // (https://github.com/tidoust/reffy-reports)
 // Source: CSS Animations Level 1 (https://drafts.csswg.org/css-animations/)
 
-[Exposed=Window,
- Constructor(CSSOMString type, optional AnimationEventInit animationEventInitDict = {})]
+[Exposed=Window]
 interface AnimationEvent : Event {
+  constructor(CSSOMString type, optional AnimationEventInit animationEventInitDict = {});
   readonly attribute CSSOMString animationName;
   readonly attribute double elapsedTime;
   readonly attribute CSSOMString pseudoElement;

tests/wpt/web-platform-tests/interfaces/css-transitions.idl

@@ -3,9 +3,9 @@
 // (https://github.com/tidoust/reffy-reports)
 // Source: CSS Transitions (https://drafts.csswg.org/css-transitions/)
 
-[Exposed=Window,
- Constructor(CSSOMString type, optional TransitionEventInit transitionEventInitDict = {})]
+[Exposed=Window]
 interface TransitionEvent : Event {
+  constructor(CSSOMString type, optional TransitionEventInit transitionEventInitDict = {});
   readonly attribute CSSOMString propertyName;
   readonly attribute double elapsedTime;
   readonly attribute CSSOMString pseudoElement;

tests/wpt/web-platform-tests/interfaces/entries-api.idl

@@ -18,6 +18,7 @@ partial interface DataTransferItem {
 
 callback ErrorCallback = void (DOMException err);
 
+[Exposed=Window]
 interface FileSystemEntry {
     readonly attribute boolean isFile;
     readonly attribute boolean isDirectory;
@@ -29,6 +30,7 @@ interface FileSystemEntry {
                    optional ErrorCallback errorCallback);
 };
 
+[Exposed=Window]
 interface FileSystemDirectoryEntry : FileSystemEntry {
     FileSystemDirectoryReader createReader();
     void getFile(optional USVString? path,
@@ -48,18 +50,21 @@ dictionary FileSystemFlags {
 
 callback FileSystemEntryCallback = void (FileSystemEntry entry);
 
+[Exposed=Window]
 interface FileSystemDirectoryReader {
     void readEntries(FileSystemEntriesCallback successCallback,
                      optional ErrorCallback errorCallback);
 };
 callback FileSystemEntriesCallback = void (sequence<FileSystemEntry> entries);
 
+[Exposed=Window]
 interface FileSystemFileEntry : FileSystemEntry {
     void file(FileCallback successCallback,
               optional ErrorCallback errorCallback);
 };
 callback FileCallback = void (File file);
 
+[Exposed=Window]
 interface FileSystem {
     readonly attribute USVString name;
     readonly attribute FileSystemDirectoryEntry root;

tests/wpt/web-platform-tests/interfaces/presentation-api.idl

@@ -48,7 +48,6 @@ dictionary PresentationConnectionAvailableEventInit : EventInit {
 };
 
 enum PresentationConnectionState { "connecting", "connected", "closed", "terminated" };
-enum BinaryType { "blob", "arraybuffer" };
 
 [SecureContext, Exposed=Window]
 interface PresentationConnection : EventTarget {

tests/wpt/web-platform-tests/interfaces/shape-detection-api.idl

@@ -4,9 +4,9 @@
 // Source: Accelerated Shape Detection in Images (https://wicg.github.io/shape-detection-api/)
 
 [Exposed=(Window,Worker),
- SecureContext,
- Constructor(optional FaceDetectorOptions faceDetectorOptions = {})]
+ SecureContext]
 interface FaceDetector {
+  constructor(optional FaceDetectorOptions faceDetectorOptions = {});
   Promise<sequence<DetectedFace>> detect(ImageBitmapSource image);
 };
 
@@ -35,9 +35,9 @@ enum LandmarkType {
 };
 
 [Exposed=(Window,Worker),
- SecureContext,
- Constructor(optional BarcodeDetectorOptions barcodeDetectorOptions = {})]
+ SecureContext]
 interface BarcodeDetector {
+  constructor(optional BarcodeDetectorOptions barcodeDetectorOptions = {});
   static Promise<sequence<BarcodeFormat>> getSupportedFormats();
 
   Promise<sequence<DetectedBarcode>> detect(ImageBitmapSource image);

tests/wpt/web-platform-tests/interfaces/web-animations.idl

@@ -12,15 +12,15 @@ dictionary DocumentTimelineOptions {
   DOMHighResTimeStamp originTime = 0;
 };
 
-[Exposed=Window,
- Constructor(optional DocumentTimelineOptions options = {})]
+[Exposed=Window]
 interface DocumentTimeline : AnimationTimeline {
+  constructor(optional DocumentTimelineOptions options = {});
 };
 
-[Exposed=Window,
- Constructor(optional AnimationEffect? effect = null,
-             optional AnimationTimeline? timeline)]
+[Exposed=Window]
 interface Animation : EventTarget {
+    constructor(optional AnimationEffect? effect = null,
+                optional AnimationTimeline? timeline);
              attribute DOMString                id;
              attribute AnimationEffect?         effect;
     readonly attribute AnimationTimeline?       timeline;
@@ -90,12 +90,12 @@ dictionary ComputedEffectTiming : EffectTiming {
     unrestricted double? currentIteration;
 };
 
-[Exposed=Window,
- Constructor((Element or CSSPseudoElement)? target,
-             object? keyframes,
-             optional (unrestricted double or KeyframeEffectOptions) options = {}),
- Constructor(KeyframeEffect source)]
+[Exposed=Window]
 interface KeyframeEffect : AnimationEffect {
+    constructor((Element or CSSPseudoElement)? target,
+                object? keyframes,
+                optional (unrestricted double or KeyframeEffectOptions) options = {});
+    constructor(KeyframeEffect source);
     attribute (Element or CSSPseudoElement)? target;
     attribute CompositeOperation             composite;
     sequence<object> getKeyframes();
@@ -155,9 +155,9 @@ Element includes Animatable;
 
 CSSPseudoElement includes Animatable;
 
-[Exposed=Window,
- Constructor(DOMString type, optional AnimationPlaybackEventInit eventInitDict = {})]
+[Exposed=Window]
 interface AnimationPlaybackEvent : Event {
+    constructor(DOMString type, optional AnimationPlaybackEventInit eventInitDict = {});
     readonly attribute double? currentTime;
     readonly attribute double? timelineTime;
 };

tests/wpt/web-platform-tests/interfaces/web-bluetooth.idl

@@ -60,10 +60,10 @@ interface BluetoothPermissionResult : PermissionStatus {
 
 [
   Exposed=Window,
-  Constructor(DOMString type, optional ValueEventInit initDict = {}),
   SecureContext
 ]
 interface ValueEvent : Event {
+  constructor(DOMString type, optional ValueEventInit initDict = {});
   readonly attribute any value;
 };
 
@@ -95,10 +95,10 @@ interface BluetoothServiceDataMap {
 };
 [
   Exposed=Window,
-  Constructor(DOMString type, BluetoothAdvertisingEventInit init),
   SecureContext
 ]
 interface BluetoothAdvertisingEvent : Event {
+  constructor(DOMString type, BluetoothAdvertisingEventInit init);
   [SameObject]
   readonly attribute BluetoothDevice device;
   readonly attribute FrozenArray<UUID> uuids;

tests/wpt/web-platform-tests/interfaces/webaudio.idl

@@ -38,7 +38,7 @@ interface BaseAudioContext : EventTarget {
   IIRFilterNode createIIRFilter (sequence<double> feedforward, sequence<double> feedback);
   OscillatorNode createOscillator ();
   PannerNode createPanner ();
-  PeriodicWave createPeriodicWave (sequence<float> real, sequence<float> imag, optional PeriodicWaveConstraints constraints);
+  PeriodicWave createPeriodicWave (sequence<float> real, sequence<float> imag, optional PeriodicWaveConstraints constraints = {});
   ScriptProcessorNode createScriptProcessor(optional unsigned long bufferSize = 0,
                                             optional unsigned long numberOfInputChannels = 2,
                                             optional unsigned long numberOfOutputChannels = 2);
@@ -56,19 +56,19 @@ enum AudioContextLatencyCategory {
     "playback"
 };
 
-[Exposed=Window,
- Constructor (optional AudioContextOptions contextOptions)]
+[Exposed=Window]
 interface AudioContext : BaseAudioContext {
-    readonly attribute double baseLatency;
-    readonly attribute double outputLatency;
-    AudioTimestamp getOutputTimestamp ();
-    Promise<void> resume ();
-    Promise<void> suspend ();
-    Promise<void> close ();
-    MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
-    MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
-    MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (MediaStreamTrack mediaStreamTrack);
-    MediaStreamAudioDestinationNode createMediaStreamDestination ();
+  constructor (optional AudioContextOptions contextOptions = {});
+  readonly attribute double baseLatency;
+  readonly attribute double outputLatency;
+  AudioTimestamp getOutputTimestamp ();
+  Promise<void> resume ();
+  Promise<void> suspend ();
+  Promise<void> close ();
+  MediaElementAudioSourceNode createMediaElementSource (HTMLMediaElement mediaElement);
+  MediaStreamAudioSourceNode createMediaStreamSource (MediaStream mediaStream);
+  MediaStreamTrackAudioSourceNode createMediaStreamTrackSource (MediaStreamTrack mediaStreamTrack);
+  MediaStreamAudioDestinationNode createMediaStreamDestination ();
 };
 
 dictionary AudioContextOptions {
@@ -81,10 +81,10 @@ dictionary AudioTimestamp {
   DOMHighResTimeStamp performanceTime;
 };
 
-[Exposed=Window,
- Constructor (OfflineAudioContextOptions contextOptions),
- Constructor (unsigned long numberOfChannels, unsigned long length, float sampleRate)]
+[Exposed=Window]
 interface OfflineAudioContext : BaseAudioContext {
+  constructor(OfflineAudioContextOptions contextOptions);
+  constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
   Promise<AudioBuffer> startRendering();
   Promise<void> resume();
   Promise<void> suspend(double suspendTime);
@@ -98,9 +98,9 @@ dictionary OfflineAudioContextOptions {
   required float sampleRate;
 };
 
-[Exposed=Window,
- Constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict)]
+[Exposed=Window]
 interface OfflineAudioCompletionEvent : Event {
+  constructor (DOMString type, OfflineAudioCompletionEventInit eventInitDict);
   readonly attribute AudioBuffer renderedBuffer;
 };
 
@@ -108,9 +108,9 @@ dictionary OfflineAudioCompletionEventInit : EventInit {
   required AudioBuffer renderedBuffer;
 };
 
-[Exposed=Window,
- Constructor (AudioBufferOptions options)]
+[Exposed=Window]
 interface AudioBuffer {
+  constructor (AudioBufferOptions options);
   readonly attribute float sampleRate;
   readonly attribute unsigned long length;
   readonly attribute double duration;
@@ -192,9 +192,9 @@ interface AudioScheduledSourceNode : AudioNode {
   void stop(optional double when = 0);
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional AnalyserOptions options = {})]
+[Exposed=Window]
 interface AnalyserNode : AudioNode {
+  constructor (BaseAudioContext context, optional AnalyserOptions options = {});
   void getFloatFrequencyData (Float32Array array);
   void getByteFrequencyData (Uint8Array array);
   void getFloatTimeDomainData (Float32Array array);
@@ -213,9 +213,9 @@ dictionary AnalyserOptions : AudioNodeOptions {
   double smoothingTimeConstant = 0.8;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional AudioBufferSourceOptions options = {})]
+[Exposed=Window]
 interface AudioBufferSourceNode : AudioScheduledSourceNode {
+  constructor (BaseAudioContext context, optional AudioBufferSourceOptions options = {});
   attribute AudioBuffer? buffer;
   readonly attribute AudioParam playbackRate;
   readonly attribute AudioParam detune;
@@ -256,9 +256,9 @@ interface AudioListener {
   void setOrientation (float x, float y, float z, float xUp, float yUp, float zUp);
 };
 
-[Exposed=Window,
- Constructor (DOMString type, AudioProcessingEventInit eventInitDict)]
+[Exposed=Window]
 interface AudioProcessingEvent : Event {
+  constructor (DOMString type, AudioProcessingEventInit eventInitDict);
   readonly attribute double playbackTime;
   readonly attribute AudioBuffer inputBuffer;
   readonly attribute AudioBuffer outputBuffer;
@@ -281,9 +281,9 @@ enum BiquadFilterType {
   "allpass"
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional BiquadFilterOptions options = {})]
+[Exposed=Window]
 interface BiquadFilterNode : AudioNode {
+  constructor (BaseAudioContext context, optional BiquadFilterOptions options = {});
   attribute BiquadFilterType type;
   readonly attribute AudioParam frequency;
   readonly attribute AudioParam detune;
@@ -300,27 +300,27 @@ dictionary BiquadFilterOptions : AudioNodeOptions {
   float gain = 0;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional ChannelMergerOptions options = {})]
+[Exposed=Window]
 interface ChannelMergerNode : AudioNode {
+  constructor (BaseAudioContext context, optional ChannelMergerOptions options = {});
 };
 
 dictionary ChannelMergerOptions : AudioNodeOptions {
   unsigned long numberOfInputs = 6;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {})]
+[Exposed=Window]
 interface ChannelSplitterNode : AudioNode {
+  constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {});
 };
 
 dictionary ChannelSplitterOptions : AudioNodeOptions {
   unsigned long numberOfOutputs = 6;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional ConstantSourceOptions options = {})]
+[Exposed=Window]
 interface ConstantSourceNode : AudioScheduledSourceNode {
+  constructor (BaseAudioContext context, optional ConstantSourceOptions options = {});
   readonly attribute AudioParam offset;
 };
 
@@ -328,9 +328,9 @@ dictionary ConstantSourceOptions {
   float offset = 1;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional ConvolverOptions options = {})]
+[Exposed=Window]
 interface ConvolverNode : AudioNode {
+  constructor (BaseAudioContext context, optional ConvolverOptions options = {});
   attribute AudioBuffer? buffer;
   attribute boolean normalize;
 };
@@ -340,9 +340,9 @@ dictionary ConvolverOptions : AudioNodeOptions {
   boolean disableNormalization = false;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional DelayOptions options = {})]
+[Exposed=Window]
 interface DelayNode : AudioNode {
+  constructor (BaseAudioContext context, optional DelayOptions options = {});
   readonly attribute AudioParam delayTime;
 };
 
@@ -351,9 +351,9 @@ dictionary DelayOptions : AudioNodeOptions {
   double delayTime = 0;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional DynamicsCompressorOptions options = {})]
+[Exposed=Window]
 interface DynamicsCompressorNode : AudioNode {
+  constructor (BaseAudioContext context, optional DynamicsCompressorOptions options = {});
   readonly attribute AudioParam threshold;
   readonly attribute AudioParam knee;
   readonly attribute AudioParam ratio;
@@ -370,9 +370,9 @@ dictionary DynamicsCompressorOptions : AudioNodeOptions {
   float threshold = -24;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional GainOptions options = {})]
+[Exposed=Window]
 interface GainNode : AudioNode {
+  constructor (BaseAudioContext context, optional GainOptions options = {});
   readonly attribute AudioParam gain;
 };
 
@@ -380,9 +380,9 @@ dictionary GainOptions : AudioNodeOptions {
   float gain = 1.0;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, IIRFilterOptions options)]
+[Exposed=Window]
 interface IIRFilterNode : AudioNode {
+  constructor (BaseAudioContext context, IIRFilterOptions options);
   void getFrequencyResponse (Float32Array frequencyHz, Float32Array magResponse, Float32Array phaseResponse);
 };
 
@@ -391,9 +391,9 @@ dictionary IIRFilterOptions : AudioNodeOptions {
   required sequence<double> feedback;
 };
 
-[Exposed=Window,
- Constructor (AudioContext context, MediaElementAudioSourceOptions options)]
+[Exposed=Window]
 interface MediaElementAudioSourceNode : AudioNode {
+  constructor (AudioContext context, MediaElementAudioSourceOptions options);
   [SameObject] readonly attribute HTMLMediaElement mediaElement;
 };
 
@@ -401,15 +401,15 @@ dictionary MediaElementAudioSourceOptions {
   required HTMLMediaElement mediaElement;
 };
 
-[Exposed=Window,
- Constructor (AudioContext context, optional AudioNodeOptions options = {})]
+[Exposed=Window]
 interface MediaStreamAudioDestinationNode : AudioNode {
+  constructor (AudioContext context, optional AudioNodeOptions options = {});
   readonly attribute MediaStream stream;
 };
 
-[Exposed=Window,
- Constructor (AudioContext context, MediaStreamAudioSourceOptions options)]
+[Exposed=Window]
 interface MediaStreamAudioSourceNode : AudioNode {
+  constructor (AudioContext context, MediaStreamAudioSourceOptions options);
   [SameObject] readonly attribute MediaStream mediaStream;
 };
 
@@ -417,9 +417,9 @@ dictionary MediaStreamAudioSourceOptions {
   required MediaStream mediaStream;
 };
 
-[Exposed=Window,
- Constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options)]
+[Exposed=Window]
 interface MediaStreamTrackAudioSourceNode : AudioNode {
+  constructor (AudioContext context, MediaStreamTrackAudioSourceOptions options);
 };
 
 dictionary MediaStreamTrackAudioSourceOptions {
@@ -434,9 +434,9 @@ enum OscillatorType {
   "custom"
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional OscillatorOptions options = {})]
+[Exposed=Window]
 interface OscillatorNode : AudioScheduledSourceNode {
+  constructor (BaseAudioContext context, optional OscillatorOptions options = {});
   attribute OscillatorType type;
   readonly attribute AudioParam frequency;
   readonly attribute AudioParam detune;
@@ -461,9 +461,9 @@ enum DistanceModelType {
   "exponential"
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional PannerOptions options = {})]
+[Exposed=Window]
 interface PannerNode : AudioNode {
+  constructor (BaseAudioContext context, optional PannerOptions options = {});
   attribute PanningModelType panningModel;
   readonly attribute AudioParam positionX;
   readonly attribute AudioParam positionY;
@@ -499,9 +499,9 @@ dictionary PannerOptions : AudioNodeOptions {
   double coneOuterGain = 0;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional PeriodicWaveOptions options = {})]
+[Exposed=Window]
 interface PeriodicWave {
+  constructor (BaseAudioContext context, optional PeriodicWaveOptions options = {});
 };
 
 dictionary PeriodicWaveConstraints {
@@ -519,9 +519,9 @@ interface ScriptProcessorNode : AudioNode {
   readonly attribute long bufferSize;
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional StereoPannerOptions options = {})]
+[Exposed=Window]
 interface StereoPannerNode : AudioNode {
+  constructor (BaseAudioContext context, optional StereoPannerOptions options = {});
   readonly attribute AudioParam pan;
 };
 
@@ -535,9 +535,9 @@ enum OverSampleType {
   "4x"
 };
 
-[Exposed=Window,
- Constructor (BaseAudioContext context, optional WaveShaperOptions options = {})]
+[Exposed=Window]
 interface WaveShaperNode : AudioNode {
+  constructor (BaseAudioContext context, optional WaveShaperOptions options = {});
   attribute Float32Array? curve;
   attribute OverSampleType oversample;
 };
@@ -566,11 +566,10 @@ interface AudioParamMap {
   readonly maplike<DOMString, AudioParam>;
 };
 
-[Exposed=Window,
- SecureContext,
- Constructor (BaseAudioContext context, DOMString name,
-              optional AudioWorkletNodeOptions options = {})]
+[Exposed=Window, SecureContext]
 interface AudioWorkletNode : AudioNode {
+  constructor (BaseAudioContext context, DOMString name,
+               optional AudioWorkletNodeOptions options = {});
   readonly attribute AudioParamMap parameters;
   readonly attribute MessagePort port;
   attribute EventHandler onprocessorerror;
@@ -584,9 +583,9 @@ dictionary AudioWorkletNodeOptions : AudioNodeOptions {
   object processorOptions;
 };
 
-[Exposed=AudioWorklet,
-Constructor (optional AudioWorkletNodeOptions options = {})]
+[Exposed=AudioWorklet]
 interface AudioWorkletProcessor {
+  constructor (optional AudioWorkletNodeOptions options = {});
   readonly attribute MessagePort port;
 };
 

tests/wpt/web-platform-tests/interfaces/webrtc-identity.idl

@@ -0,0 +1,67 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content was automatically extracted by Reffy into reffy-reports
+// (https://github.com/tidoust/reffy-reports)
+// Source: Identity for WebRTC 1.0 (https://w3c.github.io/webrtc-identity/identity.html)
+
+[Global, Exposed=RTCIdentityProviderGlobalScope]
+interface RTCIdentityProviderGlobalScope : WorkerGlobalScope {
+    readonly        attribute RTCIdentityProviderRegistrar rtcIdentityProvider;
+};
+
+[Exposed=RTCIdentityProviderGlobalScope]
+interface RTCIdentityProviderRegistrar {
+    void register(RTCIdentityProvider idp);
+};
+
+dictionary RTCIdentityProvider {
+    required GenerateAssertionCallback generateAssertion;
+    required ValidateAssertionCallback validateAssertion;
+};
+
+callback GenerateAssertionCallback = Promise<RTCIdentityAssertionResult> (DOMString contents, DOMString origin, RTCIdentityProviderOptions options);
+
+callback ValidateAssertionCallback = Promise<RTCIdentityValidationResult> (DOMString assertion, DOMString origin);
+
+dictionary RTCIdentityAssertionResult {
+    required RTCIdentityProviderDetails idp;
+    required DOMString assertion;
+};
+
+dictionary RTCIdentityProviderDetails {
+    required DOMString domain;
+             DOMString protocol = "default";
+};
+
+dictionary RTCIdentityValidationResult {
+    required DOMString identity;
+    required DOMString contents;
+};
+
+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;
+};
+
+dictionary RTCIdentityProviderOptions {
+    DOMString protocol = "default";
+    DOMString usernameHint;
+    DOMString peerIdentity;
+};
+
+[Constructor(DOMString idp, DOMString name), Exposed=Window]
+interface RTCIdentityAssertion {
+    attribute DOMString idp;
+    attribute DOMString name;
+};
+
+partial dictionary MediaStreamConstraints {
+             DOMString peerIdentity;
+};
+
+partial interface MediaStreamTrack {
+    readonly        attribute boolean isolated;
+                    attribute EventHandler onisolationchange;
+};

tests/wpt/web-platform-tests/interfaces/webusb.idl

@@ -39,11 +39,11 @@ dictionary USBConnectionEventInit : EventInit {
 };
 
 [
-  Constructor(DOMString type, USBConnectionEventInit eventInitDict),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBConnectionEvent : Event {
+  constructor(DOMString type, USBConnectionEventInit eventInitDict);
   [SameObject] readonly attribute USBDevice device;
 };
 
@@ -110,81 +110,81 @@ dictionary USBControlTransferParameters {
 };
 
 [
-  Constructor(USBTransferStatus status, optional DataView? data),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBInTransferResult {
+  constructor(USBTransferStatus status, optional DataView? data);
   readonly attribute DataView? data;
   readonly attribute USBTransferStatus status;
 };
 
 [
-  Constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBOutTransferResult {
+  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
   readonly attribute unsigned long bytesWritten;
   readonly attribute USBTransferStatus status;
 };
 
 [
-  Constructor(USBTransferStatus status, optional DataView? data),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBIsochronousInTransferPacket {
+  constructor(USBTransferStatus status, optional DataView? data);
   readonly attribute DataView? data;
   readonly attribute USBTransferStatus status;
 };
 
 [
-  Constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBIsochronousInTransferResult {
+  constructor(sequence<USBIsochronousInTransferPacket> packets, optional DataView? data);
   readonly attribute DataView? data;
   readonly attribute FrozenArray<USBIsochronousInTransferPacket> packets;
 };
 
 [
-  Constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBIsochronousOutTransferPacket {
+  constructor(USBTransferStatus status, optional unsigned long bytesWritten = 0);
   readonly attribute unsigned long bytesWritten;
   readonly attribute USBTransferStatus status;
 };
 
 [
-  Constructor(sequence<USBIsochronousOutTransferPacket> packets),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBIsochronousOutTransferResult {
+  constructor(sequence<USBIsochronousOutTransferPacket> packets);
   readonly attribute FrozenArray<USBIsochronousOutTransferPacket> packets;
 };
 
 [
-  Constructor(USBDevice device, octet configurationValue),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBConfiguration {
+  constructor(USBDevice device, octet configurationValue);
   readonly attribute octet configurationValue;
   readonly attribute DOMString? configurationName;
   readonly attribute FrozenArray<USBInterface> interfaces;
 };
 
 [
-  Constructor(USBConfiguration configuration, octet interfaceNumber),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBInterface {
+  constructor(USBConfiguration configuration, octet interfaceNumber);
   readonly attribute octet interfaceNumber;
   readonly attribute USBAlternateInterface alternate;
   readonly attribute FrozenArray<USBAlternateInterface> alternates;
@@ -192,11 +192,11 @@ interface USBInterface {
 };
 
 [
-  Constructor(USBInterface deviceInterface, octet alternateSetting),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBAlternateInterface {
+  constructor(USBInterface deviceInterface, octet alternateSetting);
   readonly attribute octet alternateSetting;
   readonly attribute octet interfaceClass;
   readonly attribute octet interfaceSubclass;
@@ -217,11 +217,11 @@ enum USBEndpointType {
 };
 
 [
-  Constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction),
   Exposed=(DedicatedWorker,SharedWorker,Window),
   SecureContext
 ]
 interface USBEndpoint {
+  constructor(USBAlternateInterface alternate, octet endpointNumber, USBDirection direction);
   readonly attribute octet endpointNumber;
   readonly attribute USBDirection direction;
   readonly attribute USBEndpointType type;
@@ -242,6 +242,7 @@ dictionary USBPermissionStorage {
   sequence<AllowedUSBDevice> allowedDevices = [];
 };
 
+[Exposed=(DedicatedWorker,SharedWorker,Window)]
 interface USBPermissionResult : PermissionStatus {
   attribute FrozenArray<USBDevice> devices;
 };