Bug 1573006 [wpt PR 18379] - Update interfaces/html.idl, a=testonly
authorautofoolip <auto@foolip.org>
Wed, 14 Aug 2019 10:55:34 +0000
changeset 488101 83e130c40711adbc4217beaee478ff8ac8b4a6a8
parent 488100 371d397dd98a37ffeec153357a1f95810e13dce5
child 488102 ba403caff520d01477d8eddd34e8253e3bb7904e
push id36435
push usercbrindusan@mozilla.com
push dateThu, 15 Aug 2019 09:46:49 +0000
treeherdermozilla-central@0db07ff50ab5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerstestonly
bugs1573006, 18379
milestone70.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1573006 [wpt PR 18379] - Update interfaces/html.idl, a=testonly Automatic update from web-platform-tests Update interfaces/html.idl (#18379) Source: https://github.com/tidoust/reffy-reports/blob/3336bd0/whatwg/idl/html.idl Build: https://travis-ci.org/tidoust/reffy-reports/builds/570123391 -- wpt-commits: 452b8915b55143011c4c2a551fc06b3957ac4eb8 wpt-pr: 18379
testing/web-platform/tests/interfaces/html.idl
--- a/testing/web-platform/tests/interfaces/html.idl
+++ b/testing/web-platform/tests/interfaces/html.idl
@@ -129,17 +129,17 @@ HTMLElement includes HTMLOrSVGElement;
 [Exposed=Window]
 interface HTMLUnknownElement : HTMLElement { };
 
 interface mixin HTMLOrSVGElement {
   [SameObject] readonly attribute DOMStringMap dataset;
   attribute DOMString nonce; // intentionally no [CEReactions]
 
   [CEReactions] attribute long tabIndex;
-  void focus(optional FocusOptions options);
+  void focus(optional FocusOptions options = {});
   void blur();
 };
 
 [Exposed=Window,
  OverrideBuiltins]
 interface DOMStringMap {
   getter DOMString (DOMString name);
   [CEReactions] setter void (DOMString name, DOMString value);
@@ -661,17 +661,17 @@ interface TextTrackCue : EventTarget {
 [Exposed=Window]
 interface TimeRanges {
   readonly attribute unsigned long length;
   double start(unsigned long index);
   double end(unsigned long index);
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional TrackEventInit eventInitDict)]
+ Constructor(DOMString type, optional TrackEventInit eventInitDict = {})]
 interface TrackEvent : Event {
   readonly attribute (VideoTrack or AudioTrack or TextTrack)? track;
 };
 
 dictionary TrackEventInit : EventInit {
   (VideoTrack or AudioTrack or TextTrack)? track = null;
 };
 
@@ -1093,17 +1093,17 @@ interface ValidityState {
   readonly attribute boolean rangeOverflow;
   readonly attribute boolean stepMismatch;
   readonly attribute boolean badInput;
   readonly attribute boolean customError;
   readonly attribute boolean valid;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional FormDataEventInit eventInitDict)]
+ Constructor(DOMString type, optional FormDataEventInit eventInitDict = {})]
 interface FormDataEvent : Event {
   readonly attribute FormData formData;
 };
 
 dictionary FormDataEventInit : EventInit {
   required FormData formData;
 };
 
@@ -1144,18 +1144,18 @@ interface HTMLScriptElement : HTMLElemen
 interface HTMLTemplateElement : HTMLElement {
   readonly attribute DocumentFragment content;
 };
 
 [Exposed=Window,
  HTMLConstructor]
 interface HTMLSlotElement : HTMLElement {
   [CEReactions] attribute DOMString name;
-  sequence<Node> assignedNodes(optional AssignedNodesOptions options);
-  sequence<Element> assignedElements(optional AssignedNodesOptions options);
+  sequence<Node> assignedNodes(optional AssignedNodesOptions options = {});
+  sequence<Element> assignedElements(optional AssignedNodesOptions options = {});
 };
 
 dictionary AssignedNodesOptions {
   boolean flatten = false;
 };
 
 typedef (CanvasRenderingContext2D or ImageBitmapRenderingContext or WebGLRenderingContext or WebGL2RenderingContext) RenderingContext;
 
@@ -1226,17 +1226,17 @@ interface mixin CanvasTransform {
   // transformations (default transform is the identity matrix)
   void scale(unrestricted double x, unrestricted double y);
   void rotate(unrestricted double angle);
   void translate(unrestricted double x, unrestricted double y);
   void transform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
 
   [NewObject] DOMMatrix getTransform();
   void setTransform(unrestricted double a, unrestricted double b, unrestricted double c, unrestricted double d, unrestricted double e, unrestricted double f);
-  void setTransform(optional DOMMatrix2DInit transform);
+  void setTransform(optional DOMMatrix2DInit transform = {});
   void resetTransform();
 
 };
 
 interface mixin CanvasCompositing {
   // compositing
   attribute unrestricted double globalAlpha; // (default 1.0)
   attribute DOMString globalCompositeOperation; // (default source-over)
@@ -1368,17 +1368,17 @@ interface mixin CanvasPath {
 interface CanvasGradient {
   // opaque object
   void addColorStop(double offset, DOMString color);
 };
 
 [Exposed=(Window,Worker)]
 interface CanvasPattern {
   // opaque object
-  void setTransform(optional DOMMatrix2DInit transform);
+  void setTransform(optional DOMMatrix2DInit transform = {});
 };
 
 [Exposed=(Window,Worker)]
 interface TextMetrics {
   // x-direction
   readonly attribute double width; // advance width
   readonly attribute double actualBoundingBoxLeft;
   readonly attribute double actualBoundingBoxRight;
@@ -1403,17 +1403,17 @@ interface ImageData {
   readonly attribute unsigned long width;
   readonly attribute unsigned long height;
   readonly attribute Uint8ClampedArray data;
 };
 
 [Constructor(optional (Path2D or DOMString) path),
  Exposed=(Window,Worker)]
 interface Path2D {
-  void addPath(Path2D path, optional DOMMatrix2DInit transform);
+  void addPath(Path2D path, optional DOMMatrix2DInit transform = {});
 };
 Path2D includes CanvasPath;
 
 [Exposed=(Window,Worker)]
 interface ImageBitmapRenderingContext {
   readonly attribute (HTMLCanvasElement or OffscreenCanvas) canvas;
   void transferFromImageBitmap(ImageBitmap? bitmap);
 };
@@ -1433,17 +1433,17 @@ enum OffscreenRenderingContextId { "2d",
 
 [Constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height), Exposed=(Window,Worker), Transferable]
 interface OffscreenCanvas : EventTarget {
   attribute [EnforceRange] unsigned long long width;
   attribute [EnforceRange] unsigned long long height;
 
   OffscreenRenderingContext? getContext(OffscreenRenderingContextId contextId, optional any options = null);
   ImageBitmap transferToImageBitmap();
-  Promise<Blob> convertToBlob(optional ImageEncodeOptions options);
+  Promise<Blob> convertToBlob(optional ImageEncodeOptions options = {});
 };
 
 [Exposed=(Window,Worker)]
 interface OffscreenCanvasRenderingContext2D {
   void commit();
   readonly attribute OffscreenCanvas canvas;
 };
 
@@ -1460,17 +1460,17 @@ OffscreenCanvasRenderingContext2D includ
 OffscreenCanvasRenderingContext2D includes CanvasDrawImage;
 OffscreenCanvasRenderingContext2D includes CanvasImageData;
 OffscreenCanvasRenderingContext2D includes CanvasPathDrawingStyles;
 OffscreenCanvasRenderingContext2D includes CanvasTextDrawingStyles;
 OffscreenCanvasRenderingContext2D includes CanvasPath;
 
 [Exposed=Window]
 interface CustomElementRegistry {
-  [CEReactions] void define(DOMString name, CustomElementConstructor constructor, optional ElementDefinitionOptions options);
+  [CEReactions] void define(DOMString name, CustomElementConstructor constructor, optional ElementDefinitionOptions options = {});
   any get(DOMString name);
   Promise<void> whenDefined(DOMString name);
   [CEReactions] void upgrade(Node root);
 };
 
 callback CustomElementConstructor = HTMLElement ();
 
 dictionary ElementDefinitionOptions {
@@ -1556,17 +1556,17 @@ interface DataTransferItem {
   readonly attribute DOMString type;
   void getAsString(FunctionStringCallback? _callback);
   File? getAsFile();
 };
 
 callback FunctionStringCallback = void (DOMString data);
 
 [Exposed=Window,
- Constructor(DOMString type, optional DragEventInit eventInitDict)]
+ Constructor(DOMString type, optional DragEventInit eventInitDict = {})]
 interface DragEvent : MouseEvent {
   readonly attribute DataTransfer? dataTransfer;
 };
 
 dictionary DragEventInit : MouseEventInit {
   DataTransfer? dataTransfer = null;
 };
 
@@ -1615,17 +1615,17 @@ interface Window : EventTarget {
   // user prompts
   void alert();
   void alert(DOMString message);
   boolean confirm(optional DOMString message = "");
   DOMString? prompt(optional DOMString message = "", optional DOMString default = "");
   void print();
 
   void postMessage(any message, USVString targetOrigin, optional sequence<object> transfer = []);
-  void postMessage(any message, optional WindowPostMessageOptions options);
+  void postMessage(any message, optional WindowPostMessageOptions options = {});
 };
 Window includes GlobalEventHandlers;
 Window includes WindowEventHandlers;
 
 dictionary WindowPostMessageOptions : PostMessageOptions {
   USVString targetOrigin = "/";
 };
 
@@ -1663,39 +1663,39 @@ interface Location { // but see also add
   [Unforgeable] void assign(USVString url);
   [Unforgeable] void replace(USVString url);
   [Unforgeable] void reload();
 
   [Unforgeable, SameObject] readonly attribute DOMStringList ancestorOrigins;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional PopStateEventInit eventInitDict)]
+ Constructor(DOMString type, optional PopStateEventInit eventInitDict = {})]
 interface PopStateEvent : Event {
   readonly attribute any state;
 };
 
 dictionary PopStateEventInit : EventInit {
   any state = null;
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional HashChangeEventInit eventInitDict)]
+ Constructor(DOMString type, optional HashChangeEventInit eventInitDict = {})]
 interface HashChangeEvent : Event {
   readonly attribute USVString oldURL;
   readonly attribute USVString newURL;
 };
 
 dictionary HashChangeEventInit : EventInit {
   USVString oldURL = "";
   USVString newURL = "";
 };
 
 [Exposed=Window,
- Constructor(DOMString type, optional PageTransitionEventInit eventInitDict)]
+ Constructor(DOMString type, optional PageTransitionEventInit eventInitDict = {})]
 interface PageTransitionEvent : Event {
   readonly attribute boolean persisted;
 };
 
 dictionary PageTransitionEventInit : EventInit {
   boolean persisted = false;
 };
 
@@ -1732,17 +1732,18 @@ interface ApplicationCache : EventTarget
   attribute EventHandler oncached;
   attribute EventHandler onobsolete;
 };
 
 interface mixin NavigatorOnLine {
   readonly attribute boolean onLine;
 };
 
-[Constructor(DOMString type, optional ErrorEventInit eventInitDict), Exposed=(Window,Worker)]
+[Constructor(DOMString type, optional ErrorEventInit eventInitDict = {}),
+ Exposed=(Window,Worker)]
 interface ErrorEvent : Event {
   readonly attribute DOMString message;
   readonly attribute USVString filename;
   readonly attribute unsigned long lineno;
   readonly attribute unsigned long colno;
   readonly attribute any error;
 };
 
@@ -1882,18 +1883,18 @@ interface mixin WindowOrWorkerGlobalScop
   void clearTimeout(optional long handle = 0);
   long setInterval(TimerHandler handler, optional long timeout = 0, any... arguments);
   void clearInterval(optional long handle = 0);
 
   // microtask queuing
   void queueMicrotask(VoidFunction callback);
 
   // ImageBitmap
-  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, optional ImageBitmapOptions options);
-  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, long sx, long sy, long sw, long sh, optional ImageBitmapOptions options);
+  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, optional ImageBitmapOptions options = {});
+  Promise<ImageBitmap> createImageBitmap(ImageBitmapSource image, long sx, long sy, long sw, long sh, optional ImageBitmapOptions options = {});
 };
 Window includes WindowOrWorkerGlobalScope;
 WorkerGlobalScope includes WindowOrWorkerGlobalScope;
 
 [Exposed=Window]
 interface Navigator {
   // objects implementing this interface also implement the interfaces given below
 };
@@ -2007,17 +2008,18 @@ callback FrameRequestCallback = void (DO
 
 interface mixin AnimationFrameProvider {
   unsigned long requestAnimationFrame(FrameRequestCallback callback);
   void cancelAnimationFrame(unsigned long handle);
 };
 Window includes AnimationFrameProvider;
 DedicatedWorkerGlobalScope includes AnimationFrameProvider;
 
-[Constructor(DOMString type, optional MessageEventInit eventInitDict), Exposed=(Window,Worker,AudioWorklet)]
+[Constructor(DOMString type, optional MessageEventInit eventInitDict = {}),
+ Exposed=(Window,Worker,AudioWorklet)]
 interface MessageEvent : Event {
   readonly attribute any data;
   readonly attribute USVString origin;
   readonly attribute DOMString lastEventId;
   readonly attribute MessageEventSource? source;
   readonly attribute FrozenArray<MessagePort> ports;
 
   void initMessageEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional any data = null, optional USVString origin = "", optional DOMString lastEventId = "", optional MessageEventSource? source = null, optional sequence<MessagePort> ports = []);
@@ -2028,17 +2030,17 @@ dictionary MessageEventInit : EventInit 
   USVString origin = "";
   DOMString lastEventId = "";
   MessageEventSource? source = null;
   sequence<MessagePort> ports = [];
 };
 
 typedef (WindowProxy or MessagePort or ServiceWorker) MessageEventSource;
 
-[Constructor(USVString url, optional EventSourceInit eventSourceInitDict), Exposed=(Window,Worker)]
+[Constructor(USVString url, optional EventSourceInit eventSourceInitDict = {}), Exposed=(Window,Worker)]
 interface EventSource : EventTarget {
   readonly attribute USVString url;
   readonly attribute boolean withCredentials;
 
   // ready state
   const unsigned short CONNECTING = 0;
   const unsigned short OPEN = 1;
   const unsigned short CLOSED = 2;
@@ -2080,17 +2082,18 @@ interface WebSocket : EventTarget {
   attribute EventHandler onmessage;
   attribute BinaryType binaryType;
   void send(USVString data);
   void send(Blob data);
   void send(ArrayBuffer data);
   void send(ArrayBufferView data);
 };
 
-[Constructor(DOMString type, optional CloseEventInit eventInitDict), Exposed=(Window,Worker)]
+[Constructor(DOMString type, optional CloseEventInit eventInitDict = {}),
+ Exposed=(Window,Worker)]
 interface CloseEvent : Event {
   readonly attribute boolean wasClean;
   readonly attribute unsigned short code;
   readonly attribute USVString reason;
 };
 
 dictionary CloseEventInit : EventInit {
   boolean wasClean = false;
@@ -2102,17 +2105,17 @@ dictionary CloseEventInit : EventInit {
 interface MessageChannel {
   readonly attribute MessagePort port1;
   readonly attribute MessagePort port2;
 };
 
 [Exposed=(Window,Worker,AudioWorklet), Transferable]
 interface MessagePort : EventTarget {
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
   void start();
   void close();
 
   // event handlers
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
@@ -2144,17 +2147,17 @@ interface WorkerGlobalScope : EventTarge
   attribute EventHandler onunhandledrejection;
 };
 
 [Global=(Worker,DedicatedWorker),Exposed=DedicatedWorker]
 interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
   [Replaceable] readonly attribute DOMString name;
 
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
 
   void close();
 
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
 [Global=(Worker,SharedWorker),Exposed=SharedWorker]
@@ -2165,37 +2168,38 @@ interface SharedWorkerGlobalScope : Work
 
   attribute EventHandler onconnect;
 };
 
 interface mixin AbstractWorker {
   attribute EventHandler onerror;
 };
 
-[Constructor(USVString scriptURL, optional WorkerOptions options), Exposed=(Window,Worker)]
+[Constructor(USVString scriptURL, optional WorkerOptions options = {}),
+ Exposed=(Window,Worker)]
 interface Worker : EventTarget {
   void terminate();
 
   void postMessage(any message, sequence<object> transfer);
-  void postMessage(any message, optional PostMessageOptions options);
+  void postMessage(any message, optional PostMessageOptions options = {});
   attribute EventHandler onmessage;
   attribute EventHandler onmessageerror;
 };
 
 dictionary WorkerOptions {
   WorkerType type = "classic";
   RequestCredentials credentials = "same-origin"; // credentials is only used if type is "module"
   DOMString name = "";
 };
 
 enum WorkerType { "classic", "module" };
 
 Worker includes AbstractWorker;
 
-[Constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options),
+[Constructor(USVString scriptURL, optional (DOMString or WorkerOptions) options = {}),
  Exposed=(Window,Worker)]
 interface SharedWorker : EventTarget {
   readonly attribute MessagePort port;
 };
 SharedWorker includes AbstractWorker;
 
 interface mixin NavigatorConcurrentHardware {
   readonly attribute unsigned long long hardwareConcurrency;
@@ -2237,17 +2241,17 @@ interface mixin WindowSessionStorage {
 Window includes WindowSessionStorage;
 
 interface mixin WindowLocalStorage {
   readonly attribute Storage localStorage;
 };
 Window includes WindowLocalStorage;
 
 [Exposed=Window,
- Constructor(DOMString type, optional StorageEventInit eventInitDict)]
+ Constructor(DOMString type, optional StorageEventInit eventInitDict = {})]
 interface StorageEvent : Event {
   readonly attribute DOMString? key;
   readonly attribute DOMString? oldValue;
   readonly attribute DOMString? newValue;
   readonly attribute USVString url;
   readonly attribute Storage? storageArea;
 
   void initStorageEvent(DOMString type, optional boolean bubbles = false, optional boolean cancelable = false, optional DOMString? key = null, optional DOMString? oldValue = null, optional DOMString? newValue = null, optional USVString url = "", optional Storage? storageArea = null);