Update web-platform-tests to revision 4a5223502fa660ce03e470af6a61c8bc26c5a8ee

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

@@ -0,0 +1,28 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the Web Background Synchronization spec.
+// See https://wicg.github.io/BackgroundSync/spec/
+
+partial interface ServiceWorkerRegistration {
+  readonly attribute SyncManager sync;
+};
+
+[Exposed=(Window,Worker)]
+interface SyncManager {
+  Promise<void> register(DOMString tag);
+  Promise<sequence<DOMString>> getTags();
+};
+
+partial interface ServiceWorkerGlobalScope {
+  attribute EventHandler onsync;
+};
+
+[Constructor(DOMString type, SyncEventInit init), Exposed=ServiceWorker]
+interface SyncEvent : ExtendableEvent {
+  readonly attribute DOMString tag;
+  readonly attribute boolean lastChance;
+};
+
+dictionary SyncEventInit : ExtendableEventInit {
+  required DOMString tag;
+  boolean lastChance = false;
+};

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

@@ -1,29 +1,34 @@
-// https://w3c.github.io/FileAPI/#idl-index
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the FileAPI spec.
+// See https://w3c.github.io/FileAPI/
 
-[Constructor(optional sequence<BlobPart> blobParts, optional BlobPropertyBag options),
-Exposed=(Window,Worker)]
+[Constructor(optional sequence<BlobPart> blobParts,
+             optional BlobPropertyBag options),
+ Exposed=(Window,Worker), Serializable]
 interface Blob {
 
   readonly attribute unsigned long long size;
   readonly attribute DOMString type;
 
-  //slice Blob into byte-ranged chunks
-
+  // slice Blob into byte-ranged chunks
   Blob slice([Clamp] optional long long start,
             [Clamp] optional long long end,
             optional DOMString contentType);
 };
 
+enum EndingType { "transparent", "native" };
+
 dictionary BlobPropertyBag {
   DOMString type = "";
+  EndingType endings = "transparent";
 };
 
 typedef (BufferSource or Blob or USVString) BlobPart;
 
 [Constructor(sequence<BlobPart> fileBits,
-            [EnsureUTF16] DOMString fileName,
-            optional FilePropertyBag options),
-Exposed=(Window,Worker)]
+             USVString fileName,
+             optional FilePropertyBag options),
+ Exposed=(Window,Worker), Serializable]
 interface File : Blob {
   readonly attribute DOMString name;
   readonly attribute long long lastModified;
@@ -33,7 +38,7 @@ dictionary FilePropertyBag : BlobPropertyBag {
   long long lastModified;
 };
 
-[Exposed=(Window,Worker)]
+[Exposed=(Window,Worker), Serializable]
 interface FileList {
   getter File? item(unsigned long index);
   readonly attribute unsigned long length;
@@ -55,7 +60,6 @@ interface FileReader: EventTarget {
   const unsigned short LOADING = 1;
   const unsigned short DONE = 2;
 
-
   readonly attribute unsigned short readyState;
 
   // File or Blob data
@@ -73,7 +77,7 @@ interface FileReader: EventTarget {
 
 };
 
-[Constructor, Exposed=Worker]
+[Constructor, Exposed=(DedicatedWorker,SharedWorker)]
 interface FileReaderSync {
   // Synchronously return strings
 

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

@@ -0,0 +1,220 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the Service Workers spec.
+// See https://w3c.github.io/ServiceWorker/
+
+[SecureContext, Exposed=(Window,Worker)]
+interface ServiceWorker : EventTarget {
+  readonly attribute USVString scriptURL;
+  readonly attribute ServiceWorkerState state;
+  void postMessage(any message, optional sequence<object> transfer = []);
+
+  // event
+  attribute EventHandler onstatechange;
+};
+ServiceWorker includes AbstractWorker;
+
+enum ServiceWorkerState {
+  "installing",
+  "installed",
+  "activating",
+  "activated",
+  "redundant"
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface ServiceWorkerRegistration : EventTarget {
+  readonly attribute ServiceWorker? installing;
+  readonly attribute ServiceWorker? waiting;
+  readonly attribute ServiceWorker? active;
+  [SameObject] readonly attribute NavigationPreloadManager navigationPreload;
+
+  readonly attribute USVString scope;
+  readonly attribute ServiceWorkerUpdateViaCache updateViaCache;
+
+  [NewObject] Promise<void> update();
+  [NewObject] Promise<boolean> unregister();
+
+  // event
+  attribute EventHandler onupdatefound;
+};
+
+enum ServiceWorkerUpdateViaCache {
+  "imports",
+  "all",
+  "none"
+};
+
+partial interface Navigator {
+  [SecureContext, SameObject] readonly attribute ServiceWorkerContainer serviceWorker;
+};
+
+partial interface WorkerNavigator {
+  [SecureContext, SameObject] readonly attribute ServiceWorkerContainer serviceWorker;
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface ServiceWorkerContainer : EventTarget {
+  readonly attribute ServiceWorker? controller;
+  readonly attribute Promise<ServiceWorkerRegistration> ready;
+
+  [NewObject] Promise<ServiceWorkerRegistration> register(USVString scriptURL, optional RegistrationOptions options);
+
+  [NewObject] Promise<any> getRegistration(optional USVString clientURL = "");
+  [NewObject] Promise<FrozenArray<ServiceWorkerRegistration>> getRegistrations();
+
+  void startMessages();
+
+  // events
+  attribute EventHandler oncontrollerchange;
+  attribute EventHandler onmessage; // event.source of message events is ServiceWorker object
+  attribute EventHandler onmessageerror;
+};
+
+dictionary RegistrationOptions {
+  USVString scope;
+  WorkerType type = "classic";
+  ServiceWorkerUpdateViaCache updateViaCache = "imports";
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface NavigationPreloadManager {
+  Promise<void> enable();
+  Promise<void> disable();
+  Promise<void> setHeaderValue(ByteString value);
+  Promise<NavigationPreloadState> getState();
+};
+
+dictionary NavigationPreloadState {
+  boolean enabled = false;
+  ByteString headerValue;
+};
+
+[Global=(Worker,ServiceWorker), Exposed=ServiceWorker]
+interface ServiceWorkerGlobalScope : WorkerGlobalScope {
+  [SameObject] readonly attribute Clients clients;
+  [SameObject] readonly attribute ServiceWorkerRegistration registration;
+
+  [NewObject] Promise<void> skipWaiting();
+
+  attribute EventHandler oninstall;
+  attribute EventHandler onactivate;
+  attribute EventHandler onfetch;
+
+  // event
+  attribute EventHandler onmessage; // event.source of the message events is Client object
+  attribute EventHandler onmessageerror;
+};
+
+[Exposed=ServiceWorker]
+interface Client {
+  readonly attribute USVString url;
+  readonly attribute DOMString id;
+  readonly attribute ClientType type;
+  void postMessage(any message, optional sequence<object> transfer = []);
+};
+
+[Exposed=ServiceWorker]
+interface WindowClient : Client {
+  readonly attribute VisibilityState visibilityState;
+  readonly attribute boolean focused;
+  [SameObject] readonly attribute FrozenArray<USVString> ancestorOrigins;
+  [NewObject] Promise<WindowClient> focus();
+  [NewObject] Promise<WindowClient?> navigate(USVString url);
+};
+
+[Exposed=ServiceWorker]
+interface Clients {
+  // The objects returned will be new instances every time
+  [NewObject] Promise<any> get(DOMString id);
+  [NewObject] Promise<FrozenArray<Client>> matchAll(optional ClientQueryOptions options);
+  [NewObject] Promise<WindowClient?> openWindow(USVString url);
+  [NewObject] Promise<void> claim();
+};
+
+dictionary ClientQueryOptions {
+  boolean includeUncontrolled = false;
+  ClientType type = "window";
+};
+
+enum ClientType {
+  "window",
+  "worker",
+  "sharedworker",
+  "all"
+};
+
+[Constructor(DOMString type, optional ExtendableEventInit eventInitDict), Exposed=ServiceWorker]
+interface ExtendableEvent : Event {
+  void waitUntil(Promise<any> f);
+};
+
+dictionary ExtendableEventInit : EventInit {
+  // Defined for the forward compatibility across the derived events
+};
+
+[Constructor(DOMString type, FetchEventInit eventInitDict), Exposed=ServiceWorker]
+interface FetchEvent : ExtendableEvent {
+  [SameObject] readonly attribute Request request;
+  readonly attribute Promise<any> preloadResponse;
+  readonly attribute DOMString clientId;
+  readonly attribute DOMString resultingClientId;
+  readonly attribute DOMString targetClientId;
+
+  void respondWith(Promise<Response> r);
+};
+
+dictionary FetchEventInit : ExtendableEventInit {
+  required Request request;
+  required Promise<any> preloadResponse;
+  DOMString clientId = "";
+  DOMString resultingClientId = "";
+  DOMString targetClientId = "";
+};
+
+[Constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict), Exposed=ServiceWorker]
+interface ExtendableMessageEvent : ExtendableEvent {
+  readonly attribute any data;
+  readonly attribute USVString origin;
+  readonly attribute DOMString lastEventId;
+  [SameObject] readonly attribute (Client or ServiceWorker or MessagePort)? source;
+  readonly attribute FrozenArray<MessagePort> ports;
+};
+
+dictionary ExtendableMessageEventInit : ExtendableEventInit {
+  any data = null;
+  USVString origin = "";
+  DOMString lastEventId = "";
+  (Client or ServiceWorker or MessagePort)? source = null;
+  sequence<MessagePort> ports = [];
+};
+
+partial interface WindowOrWorkerGlobalScope {
+  [SecureContext, SameObject] readonly attribute CacheStorage caches;
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface Cache {
+  [NewObject] Promise<any> match(RequestInfo request, optional CacheQueryOptions options);
+  [NewObject] Promise<FrozenArray<Response>> matchAll(optional RequestInfo request, optional CacheQueryOptions options);
+  [NewObject] Promise<void> add(RequestInfo request);
+  [NewObject] Promise<void> addAll(sequence<RequestInfo> requests);
+  [NewObject] Promise<void> put(RequestInfo request, Response response);
+  [NewObject] Promise<boolean> delete(RequestInfo request, optional CacheQueryOptions options);
+  [NewObject] Promise<FrozenArray<Request>> keys(optional RequestInfo request, optional CacheQueryOptions options);
+};
+
+dictionary CacheQueryOptions {
+  boolean ignoreSearch = false;
+  boolean ignoreMethod = false;
+  boolean ignoreVary = false;
+  DOMString cacheName;
+};
+
+[SecureContext, Exposed=(Window,Worker)]
+interface CacheStorage {
+  [NewObject] Promise<any> match(RequestInfo request, optional CacheQueryOptions options);
+  [NewObject] Promise<boolean> has(DOMString cacheName);
+  [NewObject] Promise<Cache> open(DOMString cacheName);
+  [NewObject] Promise<boolean> delete(DOMString cacheName);
+  [NewObject] Promise<sequence<DOMString>> keys();
+};

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

@@ -0,0 +1,31 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the budget-api spec.
+// See https://wicg.github.io/budget-api/
+
+[Exposed=Window]
+partial interface Navigator {
+    [SameObject] readonly attribute BudgetService budget;
+};
+
+[Exposed=Worker]
+partial interface WorkerNavigator {
+    [SameObject] readonly attribute BudgetService budget;
+};
+
+[Exposed=(Window,Worker)]
+interface BudgetService {
+    Promise<double> getCost(OperationType operation);
+    Promise<sequence<BudgetState>> getBudget();
+
+    Promise<boolean> reserve(OperationType operation);
+};
+
+[Exposed=(Window,Worker)]
+interface BudgetState {
+  readonly attribute double budgetAt;
+  readonly attribute DOMTimeStamp time;
+};
+
+enum OperationType {
+  "silent-push"
+};

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

@@ -0,0 +1,12 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the compat spec.
+// See https://compat.spec.whatwg.org/
+
+partial interface Window {
+    readonly attribute short orientation;
+    attribute EventHandler onorientationchange;
+};
+
+partial interface HTMLBodyElement {
+    attribute EventHandler onorientationchange;
+};

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

@@ -1,3 +1,7 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the CSS Object Model (CSSOM) spec.
+// See https://drafts.csswg.org/cssom/
+
 typedef USVString CSSOMString;
 
 [Exposed=Window,
@@ -47,6 +51,7 @@ interface LinkStyle {
 };
 
 ProcessingInstruction implements LinkStyle;
+
 [Exposed=Window,
  LegacyArrayClass]
 interface CSSRuleList {

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

@@ -3,7 +3,9 @@
 interface Event {
   readonly attribute DOMString type;
   readonly attribute EventTarget? target;
+  readonly attribute EventTarget? srcElement;
   readonly attribute EventTarget? currentTarget;
+  sequence<EventTarget> composedPath();
 
   const unsigned short NONE = 0;
   const unsigned short CAPTURING_PHASE = 1;
@@ -16,8 +18,10 @@ interface Event {
 
   readonly attribute boolean bubbles;
   readonly attribute boolean cancelable;
+           attribute boolean returnValue;
   void preventDefault();
   readonly attribute boolean defaultPrevented;
+  readonly attribute boolean composed;
 
   [Unforgeable] readonly attribute boolean isTrusted;
   readonly attribute DOMTimeStamp timeStamp;

tests/wpt/web-platform-tests/interfaces/filter-effects.idl

@@ -0,0 +1,301 @@
+// GENERATED CONTENT - DO NOT EDIT
+// Content of this file was automatically extracted from the Filter Effects spec.
+// See https://drafts.fxtf.org/filter-effects/
+
+interface SVGFilterElement : SVGElement {
+  readonly attribute SVGAnimatedEnumeration filterUnits;
+  readonly attribute SVGAnimatedEnumeration primitiveUnits;
+  readonly attribute SVGAnimatedLength x;
+  readonly attribute SVGAnimatedLength y;
+  readonly attribute SVGAnimatedLength width;
+  readonly attribute SVGAnimatedLength height;
+};
+
+SVGFilterElement implements SVGURIReference;
+
+interface mixin SVGFilterPrimitiveStandardAttributes {
+  readonly attribute SVGAnimatedLength x;
+  readonly attribute SVGAnimatedLength y;
+  readonly attribute SVGAnimatedLength width;
+  readonly attribute SVGAnimatedLength height;
+  readonly attribute SVGAnimatedString result;
+};
+
+interface SVGFEBlendElement : SVGElement {
+
+  // Blend Mode Types
+  const unsigned short SVG_FEBLEND_MODE_UNKNOWN = 0;
+  const unsigned short SVG_FEBLEND_MODE_NORMAL = 1;
+  const unsigned short SVG_FEBLEND_MODE_MULTIPLY = 2;
+  const unsigned short SVG_FEBLEND_MODE_SCREEN = 3;
+  const unsigned short SVG_FEBLEND_MODE_DARKEN = 4;
+  const unsigned short SVG_FEBLEND_MODE_LIGHTEN = 5;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedString in2;
+  readonly attribute SVGAnimatedEnumeration mode;
+};
+
+SVGFEBlendElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEColorMatrixElement : SVGElement {
+
+  // Color Matrix Types
+  const unsigned short SVG_FECOLORMATRIX_TYPE_UNKNOWN = 0;
+  const unsigned short SVG_FECOLORMATRIX_TYPE_MATRIX = 1;
+  const unsigned short SVG_FECOLORMATRIX_TYPE_SATURATE = 2;
+  const unsigned short SVG_FECOLORMATRIX_TYPE_HUEROTATE = 3;
+  const unsigned short SVG_FECOLORMATRIX_TYPE_LUMINANCETOALPHA = 4;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedEnumeration type;
+  readonly attribute SVGAnimatedNumberList values;
+};
+
+SVGFEColorMatrixElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEComponentTransferElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+};
+
+SVGFEComponentTransferElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGComponentTransferFunctionElement : SVGElement {
+
+  // Component Transfer Types
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN = 0;
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1;
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_TABLE = 2;
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE = 3;
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_LINEAR = 4;
+  const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_GAMMA = 5;
+
+  readonly attribute SVGAnimatedEnumeration type;
+  readonly attribute SVGAnimatedNumberList tableValues;
+  readonly attribute SVGAnimatedNumber slope;
+  readonly attribute SVGAnimatedNumber intercept;
+  readonly attribute SVGAnimatedNumber amplitude;
+  readonly attribute SVGAnimatedNumber exponent;
+  readonly attribute SVGAnimatedNumber offset;
+};
+
+interface SVGFEFuncRElement : SVGComponentTransferFunctionElement {
+};
+
+interface SVGFEFuncGElement : SVGComponentTransferFunctionElement {
+};
+
+interface SVGFEFuncBElement : SVGComponentTransferFunctionElement {
+};
+
+interface SVGFEFuncAElement : SVGComponentTransferFunctionElement {
+};
+
+interface SVGFECompositeElement : SVGElement {
+
+  // Composite Operators
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_UNKNOWN = 0;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_OVER = 1;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_IN = 2;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_OUT = 3;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_ATOP = 4;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_XOR = 5;
+  const unsigned short SVG_FECOMPOSITE_OPERATOR_ARITHMETIC = 6;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedString in2;
+  readonly attribute SVGAnimatedEnumeration operator;
+  readonly attribute SVGAnimatedNumber k1;
+  readonly attribute SVGAnimatedNumber k2;
+  readonly attribute SVGAnimatedNumber k3;
+  readonly attribute SVGAnimatedNumber k4;
+};
+
+SVGFECompositeElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEConvolveMatrixElement : SVGElement {
+
+  // Edge Mode Values
+  const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
+  const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
+  const unsigned short SVG_EDGEMODE_WRAP = 2;
+  const unsigned short SVG_EDGEMODE_NONE = 3;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedInteger orderX;
+  readonly attribute SVGAnimatedInteger orderY;
+  readonly attribute SVGAnimatedNumberList kernelMatrix;
+  readonly attribute SVGAnimatedNumber divisor;
+  readonly attribute SVGAnimatedNumber bias;
+  readonly attribute SVGAnimatedInteger targetX;
+  readonly attribute SVGAnimatedInteger targetY;
+  readonly attribute SVGAnimatedEnumeration edgeMode;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
+};
+
+SVGFEConvolveMatrixElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEDiffuseLightingElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedNumber surfaceScale;
+  readonly attribute SVGAnimatedNumber diffuseConstant;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
+};
+
+SVGFEDiffuseLightingElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEDistantLightElement : SVGElement {
+  readonly attribute SVGAnimatedNumber azimuth;
+  readonly attribute SVGAnimatedNumber elevation;
+};
+
+interface SVGFEPointLightElement : SVGElement {
+  readonly attribute SVGAnimatedNumber x;
+  readonly attribute SVGAnimatedNumber y;
+  readonly attribute SVGAnimatedNumber z;
+};
+
+interface SVGFESpotLightElement : SVGElement {
+  readonly attribute SVGAnimatedNumber x;
+  readonly attribute SVGAnimatedNumber y;
+  readonly attribute SVGAnimatedNumber z;
+  readonly attribute SVGAnimatedNumber pointsAtX;
+  readonly attribute SVGAnimatedNumber pointsAtY;
+  readonly attribute SVGAnimatedNumber pointsAtZ;
+  readonly attribute SVGAnimatedNumber specularExponent;
+  readonly attribute SVGAnimatedNumber limitingConeAngle;
+};
+
+interface SVGFEDisplacementMapElement : SVGElement {
+
+  // Channel Selectors
+  const unsigned short SVG_CHANNEL_UNKNOWN = 0;
+  const unsigned short SVG_CHANNEL_R = 1;
+  const unsigned short SVG_CHANNEL_G = 2;
+  const unsigned short SVG_CHANNEL_B = 3;
+  const unsigned short SVG_CHANNEL_A = 4;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedString in2;
+  readonly attribute SVGAnimatedNumber scale;
+  readonly attribute SVGAnimatedEnumeration xChannelSelector;
+  readonly attribute SVGAnimatedEnumeration yChannelSelector;
+};
+
+SVGFEDisplacementMapElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEDropShadowElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedNumber dx;
+  readonly attribute SVGAnimatedNumber dy;
+  readonly attribute SVGAnimatedNumber stdDeviationX;
+  readonly attribute SVGAnimatedNumber stdDeviationY;
+
+  void setStdDeviation(float stdDeviationX, float stdDeviationY);
+};
+
+SVGFEDropShadowElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEFloodElement : SVGElement {
+};
+
+SVGFEFloodElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEGaussianBlurElement : SVGElement {
+
+  // Edge Mode Values
+  const unsigned short SVG_EDGEMODE_UNKNOWN = 0;
+  const unsigned short SVG_EDGEMODE_DUPLICATE = 1;
+  const unsigned short SVG_EDGEMODE_WRAP = 2;
+  const unsigned short SVG_EDGEMODE_NONE = 3;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedNumber stdDeviationX;
+  readonly attribute SVGAnimatedNumber stdDeviationY;
+  readonly attribute SVGAnimatedEnumeration edgeMode;
+
+  void setStdDeviation(float stdDeviationX, float stdDeviationY);
+};
+
+SVGFEGaussianBlurElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEImageElement : SVGElement {
+  readonly attribute SVGAnimatedPreserveAspectRatio preserveAspectRatio;
+  readonly attribute SVGAnimatedString crossOrigin;
+};
+
+SVGFEImageElement includes SVGFilterPrimitiveStandardAttributes;
+SVGFEImageElement implements SVGURIReference;
+
+interface SVGFEMergeElement : SVGElement {
+};
+
+SVGFEMergeElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEMergeNodeElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+};
+
+interface SVGFEMorphologyElement : SVGElement {
+
+  // Morphology Operators
+  const unsigned short SVG_MORPHOLOGY_OPERATOR_UNKNOWN = 0;
+  const unsigned short SVG_MORPHOLOGY_OPERATOR_ERODE = 1;
+  const unsigned short SVG_MORPHOLOGY_OPERATOR_DILATE = 2;
+
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedEnumeration operator;
+  readonly attribute SVGAnimatedNumber radiusX;
+  readonly attribute SVGAnimatedNumber radiusY;
+};
+
+SVGFEMorphologyElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFEOffsetElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedNumber dx;
+  readonly attribute SVGAnimatedNumber dy;
+};
+
+SVGFEOffsetElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFESpecularLightingElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+  readonly attribute SVGAnimatedNumber surfaceScale;
+  readonly attribute SVGAnimatedNumber specularConstant;
+  readonly attribute SVGAnimatedNumber specularExponent;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthX;
+  readonly attribute SVGAnimatedNumber kernelUnitLengthY;
+};
+
+SVGFESpecularLightingElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFETileElement : SVGElement {
+  readonly attribute SVGAnimatedString in1;
+};
+
+SVGFETileElement includes SVGFilterPrimitiveStandardAttributes;
+
+interface SVGFETurbulenceElement : SVGElement {
+
+  // Turbulence Types
+  const unsigned short SVG_TURBULENCE_TYPE_UNKNOWN = 0;
+  const unsigned short SVG_TURBULENCE_TYPE_FRACTALNOISE = 1;
+  const unsigned short SVG_TURBULENCE_TYPE_TURBULENCE = 2;
+
+  // Stitch Options
+  const unsigned short SVG_STITCHTYPE_UNKNOWN = 0;
+  const unsigned short SVG_STITCHTYPE_STITCH = 1;
+  const unsigned short SVG_STITCHTYPE_NOSTITCH = 2;
+
+  readonly attribute SVGAnimatedNumber baseFrequencyX;
+  readonly attribute SVGAnimatedNumber baseFrequencyY;
+  readonly attribute SVGAnimatedInteger numOctaves;
+  readonly attribute SVGAnimatedNumber seed;
+  readonly attribute SVGAnimatedEnumeration stitchTiles;
+  readonly attribute SVGAnimatedEnumeration type;
+};
+
+SVGFETurbulenceElement includes SVGFilterPrimitiveStandardAttributes;

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

@@ -1437,6 +1437,7 @@ interface CustomElementRegistry {
   [CEReactions] void define(DOMString name, Function constructor, optional ElementDefinitionOptions options);
   any get(DOMString name);
   Promise<void> whenDefined(DOMString name);
+  [CEReactions] void upgrade(Node root);
 };
 
 dictionary ElementDefinitionOptions {

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

@@ -1,60 +1,63 @@
+dictionary NFCMessage {
+    sequence<NFCRecord> records;
+    USVString           url;
+};
 
-      dictionary NFCMessage {
-        sequence<NFCRecord> records;
-        USVString url;
-      };
+typedef (DOMString or unrestricted double or ArrayBuffer or Dictionary) NFCRecordData;
 
-      typedef (DOMString or unrestricted double or ArrayBuffer or Dictionary) NFCRecordData;
+dictionary NFCRecord {
+    NFCRecordType recordType;
+    USVString     mediaType;
+    NFCRecordData data;
+};
 
-      dictionary NFCRecord {
-        NFCRecordType recordType;
-        USVString mediaType;
-        NFCRecordData data;
-      };
+enum NFCRecordType {
+    "empty",
+    "text",
+    "url",
+    "json",
+    "opaque"
+};
 
-        enum NFCRecordType {
-          "empty",
-          "text",
-          "url",
-          "json",
-          "opaque"
-        };
+partial interface Navigator {
+    [SecureContext,
+     SameObject]
+    readonly attribute NFC nfc;
+};
 
-    partial interface Navigator {
-      readonly attribute NFC nfc;
-    };
+typedef (DOMString or ArrayBuffer or NFCMessage) NFCPushMessage;
 
-    typedef (DOMString or ArrayBuffer or NFCMessage) NFCPushMessage;
+[SecureContext]
+interface NFC {
+    Promise<void> push(NFCPushMessage message, optional NFCPushOptions options);
+    Promise<void> cancelPush(optional NFCPushTarget target = "any");
+    Promise<long> watch(MessageCallback callback,
+                        optional NFCWatchOptions options);
+    Promise<void> cancelWatch(optional long id);
+};
 
-    interface NFC {
-      Promise<void> push(NFCPushMessage message, optional NFCPushOptions options);
-      Promise<void> cancelPush(optional NFCPushTarget target="any");
-      Promise<long> watch(MessageCallback callback, optional NFCWatchOptions options);
-      Promise<void> cancelWatch(optional long id);
-    };
+callback MessageCallback = void (NFCMessage message);
 
-    callback MessageCallback = void (NFCMessage message);
+dictionary NFCPushOptions {
+    NFCPushTarget       target = "any";
+    unrestricted double timeout = Infinity;
+    boolean             ignoreRead = true;
+};
 
-      dictionary NFCPushOptions {
-        NFCPushTarget target = "any";
-        unrestricted double timeout = Infinity;
-        boolean ignoreRead = true;
-      };
+enum NFCPushTarget {
+    "tag",
+    "peer",
+    "any"
+};
 
-      enum NFCPushTarget {
-        "tag",
-        "peer",
-        "any"
-      };
+dictionary NFCWatchOptions {
+    USVString      url = "";
+    NFCRecordType? recordType;
+    USVString      mediaType = "";
+    NFCWatchMode   mode = "web-nfc-only";
+};
 
-        dictionary NFCWatchOptions {
-          USVString url = "";
-          NFCRecordType? recordType;
-          USVString mediaType = "";
-          NFCWatchMode mode = "web-nfc-only";
-        };
-
-      enum NFCWatchMode {
-        "web-nfc-only",
-        "any"
-      };
+enum NFCWatchMode {
+    "web-nfc-only",
+    "any"
+};