Update web-platform-tests to revision 2660fc486f7027c913863d48a8843942f0c0365e

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

@@ -3,10 +3,10 @@
 // (https://github.com/tidoust/reffy-reports)
 // Source: File API (https://w3c.github.io/FileAPI/)
 
-[Constructor(optional sequence<BlobPart> blobParts,
-             optional BlobPropertyBag options = {}),
- Exposed=(Window,Worker), Serializable]
+[Exposed=(Window,Worker), Serializable]
 interface Blob {
+  constructor(optional sequence<BlobPart> blobParts,
+              optional BlobPropertyBag options = {});
 
   readonly attribute unsigned long long size;
   readonly attribute DOMString type;
@@ -31,11 +31,11 @@ dictionary BlobPropertyBag {
 
 typedef (BufferSource or Blob or USVString) BlobPart;
 
-[Constructor(sequence<BlobPart> fileBits,
-             USVString fileName,
-             optional FilePropertyBag options = {}),
- Exposed=(Window,Worker), Serializable]
+[Exposed=(Window,Worker), Serializable]
 interface File : Blob {
+  constructor(sequence<BlobPart> fileBits,
+              USVString fileName,
+              optional FilePropertyBag options = {});
   readonly attribute DOMString name;
   readonly attribute long long lastModified;
 };
@@ -50,9 +50,9 @@ interface FileList {
   readonly attribute unsigned long length;
 };
 
-[Constructor, Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface FileReader: EventTarget {
-
+  constructor();
   // async read methods
   void readAsArrayBuffer(Blob blob);
   void readAsBinaryString(Blob blob);
@@ -82,8 +82,9 @@ interface FileReader: EventTarget {
   attribute EventHandler onloadend;
 };
 
-[Constructor, Exposed=(DedicatedWorker,SharedWorker)]
+[Exposed=(DedicatedWorker,SharedWorker)]
 interface FileReaderSync {
+  constructor();
   // Synchronously return strings
 
   ArrayBuffer readAsArrayBuffer(Blob blob);

tests/wpt/web-platform-tests/interfaces/background-fetch.idl

@@ -16,7 +16,7 @@ partial interface ServiceWorkerRegistration {
 
 [Exposed=(Window,Worker)]
 interface BackgroundFetchManager {
-  Promise<BackgroundFetchRegistration> fetch(DOMString id, (RequestInfo or sequence<RequestInfo>) requests, optional BackgroundFetchOptions options);
+  Promise<BackgroundFetchRegistration> fetch(DOMString id, (RequestInfo or sequence<RequestInfo>) requests, optional BackgroundFetchOptions options = {});
   Promise<BackgroundFetchRegistration?> get(DOMString id);
   Promise<sequence<DOMString>> getIds();
 };
@@ -44,8 +44,8 @@ interface BackgroundFetchRegistration : EventTarget {
   attribute EventHandler onprogress;
 
   Promise<boolean> abort();
-  Promise<BackgroundFetchRecord> match(RequestInfo request, optional CacheQueryOptions options);
-  Promise<sequence<BackgroundFetchRecord>> matchAll(optional RequestInfo request, optional CacheQueryOptions options);
+  Promise<BackgroundFetchRecord> match(RequestInfo request, optional CacheQueryOptions options = {});
+  Promise<sequence<BackgroundFetchRecord>> matchAll(optional RequestInfo request, optional CacheQueryOptions options = {});
 };
 
 enum BackgroundFetchResult { "", "success", "failure" };
@@ -72,8 +72,9 @@ interface BackgroundFetchRecord {
   readonly attribute Promise<Response> responseReady;
 };
 
-[Constructor(DOMString type, BackgroundFetchEventInit init), Exposed=ServiceWorker]
+[Exposed=ServiceWorker]
 interface BackgroundFetchEvent : ExtendableEvent {
+  constructor(DOMString type, BackgroundFetchEventInit init);
   readonly attribute BackgroundFetchRegistration registration;
 };
 
@@ -81,7 +82,8 @@ dictionary BackgroundFetchEventInit : ExtendableEventInit {
   required BackgroundFetchRegistration registration;
 };
 
-[Constructor(DOMString type, BackgroundFetchEventInit init), Exposed=ServiceWorker]
+[Exposed=ServiceWorker]
 interface BackgroundFetchUpdateUIEvent : BackgroundFetchEvent {
-  Promise<void> updateUI(optional BackgroundFetchUIOptions options);
+  constructor(DOMString type, BackgroundFetchEventInit init);
+  Promise<void> updateUI(optional BackgroundFetchUIOptions options = {});
 };

tests/wpt/web-platform-tests/interfaces/geolocation-API.idl

@@ -1,28 +1,28 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into reffy-reports
 // (https://github.com/tidoust/reffy-reports)
-// Source: Geolocation API Specification 2nd Edition (https://www.w3.org/TR/geolocation-API/)
+// Source: Geolocation API Specification (https://w3c.github.io/geolocation-api/)
 
 partial interface Navigator {
-  readonly attribute Geolocation geolocation;
+  [SameObject] readonly attribute Geolocation geolocation;
 };
 
-[NoInterfaceObject]
+[Exposed=Window]
 interface Geolocation {
   void getCurrentPosition(PositionCallback successCallback,
                           optional PositionErrorCallback errorCallback,
-                          optional PositionOptions options);
+                          optional PositionOptions options = {});
 
   long watchPosition(PositionCallback successCallback,
                      optional PositionErrorCallback errorCallback,
-                     optional PositionOptions options);
+                     optional PositionOptions options = {});
 
   void clearWatch(long watchId);
 };
 
-callback PositionCallback = void (Position position);
+callback PositionCallback = void (GeolocationPosition position);
 
-callback PositionErrorCallback = void (PositionError positionError);
+callback PositionErrorCallback = void (GeolocationPositionError positionError);
 
 dictionary PositionOptions {
   boolean enableHighAccuracy = false;
@@ -30,14 +30,14 @@ dictionary PositionOptions {
   [Clamp] unsigned long maximumAge = 0;
 };
 
-[NoInterfaceObject]
-interface Position {
-  readonly attribute Coordinates coords;
+[Exposed=Window, SecureContext]
+interface GeolocationPosition {
+  readonly attribute GeolocationCoordinates coords;
   readonly attribute DOMTimeStamp timestamp;
 };
 
-[NoInterfaceObject]
-interface Coordinates {
+[Exposed=Window, SecureContext]
+interface GeolocationCoordinates {
   readonly attribute double latitude;
   readonly attribute double longitude;
   readonly attribute double? altitude;
@@ -47,8 +47,8 @@ interface Coordinates {
   readonly attribute double? speed;
 };
 
-[NoInterfaceObject]
-interface PositionError {
+[Exposed=Window]
+interface GeolocationPositionError {
   const unsigned short PERMISSION_DENIED = 1;
   const unsigned short POSITION_UNAVAILABLE = 2;
   const unsigned short TIMEOUT = 3;

tests/wpt/web-platform-tests/interfaces/orientation-event.idl

@@ -1,68 +1,85 @@
 // GENERATED CONTENT - DO NOT EDIT
 // Content was automatically extracted by Reffy into reffy-reports
 // (https://github.com/tidoust/reffy-reports)
-// Source: DeviceOrientation Event Specification (https://w3c.github.io/deviceorientation/spec-source-orientation.html)
+// Source: DeviceOrientation Event Specification (https://w3c.github.io/deviceorientation/)
 
 partial interface Window {
-      attribute EventHandler ondeviceorientation;
-    };
+    [SecureContext] attribute EventHandler ondeviceorientation;
+};
 
-    [Constructor(DOMString type, optional DeviceOrientationEventInit eventInitDict), Exposed=Window]
-    interface DeviceOrientationEvent : Event {
-      readonly attribute double? alpha;
-      readonly attribute double? beta;
-      readonly attribute double? gamma;
-      readonly attribute boolean absolute;
-    };
+[Constructor(DOMString type, optional DeviceOrientationEventInit eventInitDict = {}), Exposed=Window, SecureContext]
+interface DeviceOrientationEvent : Event {
+    readonly attribute double? alpha;
+    readonly attribute double? beta;
+    readonly attribute double? gamma;
+    readonly attribute boolean absolute;
 
-    dictionary DeviceOrientationEventInit : EventInit {
-      double? alpha = null;
-      double? beta = null;
-      double? gamma = null;
-      boolean absolute = false;
-    };
+    static Promise<PermissionState> requestPermission();
+};
+
+dictionary DeviceOrientationEventInit : EventInit {
+    double? alpha = null;
+    double? beta = null;
+    double? gamma = null;
+    boolean absolute = false;
+};
+
+enum PermissionState {
+    "granted",
+    "denied",
+};
 
 partial interface Window {
-      attribute EventHandler ondevicemotion;
-    };
+    [SecureContext] attribute EventHandler ondeviceorientationabsolute;
+};
 
-    [NoInterfaceObject]
-    interface DeviceAcceleration {
-      readonly attribute double? x;
-      readonly attribute double? y;
-      readonly attribute double? z;
-    };
+partial interface Window {
+    attribute EventHandler oncompassneedscalibration;
+};
 
-    [NoInterfaceObject]
-    interface DeviceRotationRate {
-      readonly attribute double? alpha;
-      readonly attribute double? beta;
-      readonly attribute double? gamma;
-    };
+partial interface Window {
+    [SecureContext] attribute EventHandler ondevicemotion;
+};
 
-    [Constructor(DOMString type, optional DeviceMotionEventInit eventInitDict), Exposed=Window]
-    interface DeviceMotionEvent : Event {
-      readonly attribute DeviceAcceleration? acceleration;
-      readonly attribute DeviceAcceleration? accelerationIncludingGravity;
-      readonly attribute DeviceRotationRate? rotationRate;
-      readonly attribute double interval;
-    };
+[SecureContext]
+interface DeviceMotionEventAcceleration {
+    readonly attribute double? x;
+    readonly attribute double? y;
+    readonly attribute double? z;
+};
 
-    dictionary DeviceAccelerationInit {
-      double? x = null;
-      double? y = null;
-      double? z = null;
-    };
+[SecureContext]
+interface DeviceMotionEventRotationRate {
+    readonly attribute double? alpha;
+    readonly attribute double? beta;
+    readonly attribute double? gamma;
+};
 
-    dictionary DeviceRotationRateInit {
-      double? alpha = null;
-      double? beta = null;
-      double? gamma = null;
-    };
+[Constructor(DOMString type, optional DeviceMotionEventInit eventInitDict = {}), Exposed=Window, SecureContext]
+interface DeviceMotionEvent : Event {
+    readonly attribute DeviceMotionEventAcceleration? acceleration;
+    readonly attribute DeviceMotionEventAcceleration? accelerationIncludingGravity;
+    readonly attribute DeviceMotionEventRotationRate? rotationRate;
+    readonly attribute double interval;
 
-    dictionary DeviceMotionEventInit : EventInit {
-      DeviceAccelerationInit? acceleration;
-      DeviceAccelerationInit? accelerationIncludingGravity;
-      DeviceRotationRateInit? rotationRate;
-      double interval = 0;
-    };
+    static Promise<PermissionState> requestPermission();
+};
+
+dictionary DeviceMotionEventAccelerationInit {
+    double? x = null;
+    double? y = null;
+    double? z = null;
+};
+
+dictionary DeviceMotionEventRotationRateInit {
+    double? alpha = null;
+    double? beta = null;
+    double? gamma = null;
+};
+
+dictionary DeviceMotionEventInit : EventInit {
+    DeviceMotionEventAccelerationInit acceleration;
+    DeviceMotionEventAccelerationInit accelerationIncludingGravity;
+    DeviceMotionEventRotationRateInit rotationRate;
+    double interval = 0;
+};

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

@@ -19,10 +19,10 @@ partial interface Presentation {
   readonly attribute PresentationReceiver? receiver;
 };
 
-[Constructor(USVString url),
- Constructor(sequence<USVString> urls),
- SecureContext, Exposed=Window]
+[SecureContext, Exposed=Window]
 interface PresentationRequest : EventTarget {
+  constructor(USVString url);
+  constructor(sequence<USVString> urls);
   Promise<PresentationConnection> start();
   Promise<PresentationConnection> reconnect(USVString presentationId);
   Promise<PresentationAvailability> getAvailability();
@@ -37,9 +37,9 @@ interface PresentationAvailability : EventTarget {
   attribute EventHandler onchange;
 };
 
-[Constructor(DOMString type, PresentationConnectionAvailableEventInit eventInitDict),
- SecureContext, Exposed=Window]
+[SecureContext, Exposed=Window]
 interface PresentationConnectionAvailableEvent : Event {
+  constructor(DOMString type, PresentationConnectionAvailableEventInit eventInitDict);
   [SameObject] readonly attribute PresentationConnection connection;
 };
 
@@ -64,17 +64,17 @@ interface PresentationConnection : EventTarget {
   // Communication
   attribute BinaryType binaryType;
   attribute EventHandler onmessage;
-  void send(DOMString message);
-  void send(Blob data);
-  void send(ArrayBuffer data);
-  void send(ArrayBufferView data);
+  void send (DOMString message);
+  void send (Blob data);
+  void send (ArrayBuffer data);
+  void send (ArrayBufferView data);
 };
 
 enum PresentationConnectionCloseReason { "error", "closed", "wentaway" };
 
-[Constructor(DOMString type, PresentationConnectionCloseEventInit eventInitDict),
- SecureContext, Exposed=Window]
+[SecureContext, Exposed=Window]
 interface PresentationConnectionCloseEvent : Event {
+  constructor(DOMString type, PresentationConnectionCloseEventInit eventInitDict);
   readonly attribute PresentationConnectionCloseReason reason;
   readonly attribute DOMString message;
 };

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

@@ -64,8 +64,9 @@ partial interface ServiceWorkerGlobalScope {
   attribute EventHandler onpushsubscriptionchange;
 };
 
-[Constructor(DOMString type, optional PushEventInit eventInitDict = {}), Exposed=ServiceWorker, SecureContext]
+[Exposed=ServiceWorker, SecureContext]
 interface PushEvent : ExtendableEvent {
+  constructor(DOMString type, optional PushEventInit eventInitDict = {});
   readonly attribute PushMessageData? data;
 };
 
@@ -75,8 +76,9 @@ dictionary PushEventInit : ExtendableEventInit {
   PushMessageDataInit data;
 };
 
-[Constructor(DOMString type, optional PushSubscriptionChangeEventInit eventInitDict = {}), Exposed=ServiceWorker, SecureContext]
+[Exposed=ServiceWorker, SecureContext]
 interface PushSubscriptionChangeEvent : ExtendableEvent {
+  constructor(DOMString type, optional PushSubscriptionChangeEventInit eventInitDict = {});
   readonly attribute PushSubscription? newSubscription;
   readonly attribute PushSubscription? oldSubscription;
 };

tests/wpt/web-platform-tests/interfaces/screen-capture.idl

@@ -4,43 +4,43 @@
 // Source: Screen Capture (https://w3c.github.io/mediacapture-screen-share/)
 
 partial interface MediaDevices {
-    Promise<MediaStream> getDisplayMedia (optional DisplayMediaStreamConstraints constraints = {});
+  Promise<MediaStream> getDisplayMedia(optional DisplayMediaStreamConstraints constraints = {});
 };
 
 dictionary DisplayMediaStreamConstraints {
-    (boolean or MediaTrackConstraints) video = true;
-    (boolean or MediaTrackConstraints) audio = false;
+  (boolean or MediaTrackConstraints) video = true;
+  (boolean or MediaTrackConstraints) audio = false;
 };
 
 partial dictionary MediaTrackSupportedConstraints {
-             boolean displaySurface = true;
-             boolean logicalSurface = true;
-             boolean cursor = true;
-             boolean restrictOwnAudio = true;
+  boolean displaySurface = true;
+  boolean logicalSurface = true;
+  boolean cursor = true;
+  boolean restrictOwnAudio = true;
 };
 
 partial dictionary MediaTrackConstraintSet {
-             ConstrainDOMString displaySurface;
-             ConstrainBoolean logicalSurface;
-             ConstrainDOMString cursor;
-             ConstrainBoolean restrictOwnAudio;
+  ConstrainDOMString displaySurface;
+  ConstrainBoolean logicalSurface;
+  ConstrainDOMString cursor;
+  ConstrainBoolean restrictOwnAudio;
 };
 
 partial dictionary MediaTrackSettings {
-             DOMString displaySurface;
-             boolean logicalSurface;
-             DOMString cursor;
+  DOMString displaySurface;
+  boolean logicalSurface;
+  DOMString cursor;
 };
 
 enum DisplayCaptureSurfaceType {
-    "monitor",
-    "window",
-    "application",
-    "browser"
+  "monitor",
+  "window",
+  "application",
+  "browser"
 };
 
 enum CursorCaptureConstraint {
-    "never",
-    "always",
-    "motion"
+  "never",
+  "always",
+  "motion"
 };

tests/wpt/web-platform-tests/interfaces/service-workers.idl

@@ -155,8 +155,9 @@ enum ClientType {
   "all"
 };
 
-[Constructor(DOMString type, optional ExtendableEventInit eventInitDict = {}), Exposed=ServiceWorker]
+[Exposed=ServiceWorker]
 interface ExtendableEvent : Event {
+  constructor(DOMString type, optional ExtendableEventInit eventInitDict = {});
   void waitUntil(Promise<any> f);
 };
 
@@ -164,8 +165,9 @@ dictionary ExtendableEventInit : EventInit {
   // Defined for the forward compatibility across the derived events
 };
 
-[Constructor(DOMString type, FetchEventInit eventInitDict), Exposed=ServiceWorker]
+[Exposed=ServiceWorker]
 interface FetchEvent : ExtendableEvent {
+  constructor(DOMString type, FetchEventInit eventInitDict);
   [SameObject] readonly attribute Request request;
   readonly attribute Promise<any> preloadResponse;
   readonly attribute DOMString clientId;
@@ -183,8 +185,9 @@ dictionary FetchEventInit : ExtendableEventInit {
   DOMString replacesClientId = "";
 };
 
-[Constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict = {}), Exposed=ServiceWorker]
+[Exposed=ServiceWorker]
 interface ExtendableMessageEvent : ExtendableEvent {
+  constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict = {});
   readonly attribute any data;
   readonly attribute USVString origin;
   readonly attribute DOMString lastEventId;

tests/wpt/web-platform-tests/interfaces/wasm-js-api.idl

@@ -99,12 +99,3 @@ interface Global {
   any valueOf();
   attribute any value;
 };
-
-[LegacyNamespace=WebAssembly]
-interface CompileError { };
-
-[LegacyNamespace=WebAssembly]
-interface LinkError { };
-
-[LegacyNamespace=WebAssembly]
-interface RuntimeError { };