Bug 1452643 [wpt PR 9886] - Updated ServiceWorker IDL file, a=testonly

Automatic update from web-platform-testsUpdated ServiceWorker IDL file (#9886)

* Updated ServiceWorker IDL file

wpt-commits: 51b2242a8a064a83f1a993036a3f29848b933991
wpt-pr: 9886
wpt-commits: 51b2242a8a064a83f1a993036a3f29848b933991
wpt-pr: 9886

testing/web-platform/meta/MANIFEST.json

@@ -286095,6 +286095,11 @@
      {}
     ]
    ],
+   "interfaces/ServiceWorker.idl": [
+    [
+     {}
+    ]
+   ],
    "interfaces/WebCryptoAPI.idl": [
     [
      {}
@@ -574108,6 +574113,10 @@
    "389275a34cb76282af66797b3cd06b72a3b9ddbe",
    "support"
   ],
+  "interfaces/ServiceWorker.idl": [
+   "7884feabcb4c9d0a447cccfa2359e3c45eef5455",
+   "support"
+  ],
   "interfaces/WebCryptoAPI.idl": [
    "1fa169a6badb1c21608f1e1a68075939e913603f",
    "support"
@@ -594753,7 +594762,7 @@
    "testharness"
   ],
   "service-workers/service-worker/interfaces-window.https.html": [
-   "c596bb509623d00646cd8c1420394f7de8ff742d",
+   "5c604b248656dae755f0b4107c6ab4f19f3e5c08",
    "testharness"
   ],
   "service-workers/service-worker/invalid-blobtype.https.html": [
@@ -595585,11 +595594,11 @@
    "support"
   ],
   "service-workers/service-worker/resources/interfaces-idls.js": [
-   "c14274bca020d4dfe3df95e0fd36eedae403f99d",
+   "2d3ae3bdd1be17a2871aa3af2009daaacf43d3db",
    "support"
   ],
   "service-workers/service-worker/resources/interfaces-worker.sub.js": [
-   "229dd043c0e98e9f70f54277bba7c4c3db6d000d",
+   "1e30c1df9970486b5dea379f2430a871d5f270ed",
    "support"
   ],
   "service-workers/service-worker/resources/invalid-blobtype-iframe.https.html": [

testing/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();
+};

testing/web-platform/tests/service-workers/service-worker/interfaces-window.https.html

@@ -9,29 +9,43 @@
 <script>
 'use strict';
 
-var idlArray = new IdlArray();
-idlArray.add_untested_idls(idls.untested);
-idlArray.add_idls(idls.tested);
-idlArray.add_objects({
+promise_test(async (t) => {
+  var idlArray = new IdlArray();
+  let serviceWorkerIdl = await fetch('/interfaces/ServiceWorker.idl').then(r => r.text());
+
+  idlArray.add_untested_idls(idls.untested);
+  idlArray.add_idls(serviceWorkerIdl, { only: [
+    'ServiceWorkerGlobalScope',
+    'Client',
+    'WindowClient',
+    'Clients',
+    'ServiceWorker',
+    'ServiceWorkerState',
+    'ServiceWorkerUpdateViaCache',
+    'ServiceWorkerRegistration',
+    'EventTarget',
+    'NavigationPreloadManager',
+    'Cache',
+    'CacheStorage',
+  ]});
+  idlArray.add_objects({
     ServiceWorkerContainer: ['navigator.serviceWorker']
   });
+  var scope = 'resources/scope/interfaces-and-attributes';
 
-promise_test(function(t) {
-    var scope = 'resources/scope/interfaces-and-attributes';
+  return service_worker_unregister_and_register(
+      t, 'resources/empty-worker.js', scope)
+    .then(function(registration) {
+        t.add_cleanup(function() {
+            registration.unregister();
+          });
 
-    return service_worker_unregister_and_register(
-        t, 'resources/empty-worker.js', scope)
-      .then(function(registration) {
-          t.add_cleanup(function() {
-              registration.unregister();
-            });
-
-          window.registrationInstance = registration;
-          idlArray.add_objects({
-              ServiceWorkerRegistration: ['window.registrationInstance'],
-              ServiceWorker: ['window.registrationInstance.installing']
-            });
-          idlArray.test();
-        });
-  }, 'test setup (worker registration)');
+        window.registrationInstance = registration;
+        idlArray.add_objects({
+            ServiceWorkerRegistration: ['window.registrationInstance'],
+            ServiceWorker: ['window.registrationInstance.installing']
+          });
+        idlArray.test();
+      });
+}, 'test setup (worker registration)');
 </script>

testing/web-platform/tests/service-workers/service-worker/resources/interfaces-idls.js

@@ -12,124 +12,3 @@ interface AbstractWorker {
   attribute EventHandler onerror;
 };
 `;
-idls.tested = `
-[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;
-  readonly attribute boolean reserved;
-  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<sequence<Client>> matchAll(optional ClientQueryOptions options);
-  [NewObject] Promise<WindowClient?> openWindow(USVString url);
-  [NewObject] Promise<void> claim();
-};
-
-[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 implements AbstractWorker;
-
-enum ServiceWorkerState {
-  "installing",
-  "installed",
-  "activating",
-  "activated",
-  "redundant"
-};
-
-enum ServiceWorkerUpdateViaCache {
-    "imports",
-    "all",
-    "none"
-};
-
-[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;
-};
-
-[Constructor(), Exposed=(Window,Worker)]
-interface EventTarget {
-  void addEventListener(DOMString type, EventListener? callback, optional (AddEventListenerOptions or boolean) options);
-  void removeEventListener(DOMString type, EventListener? callback, optional (EventListenerOptions or boolean) options);
-  boolean dispatchEvent(Event event);
-};
-
-[SecureContext, Exposed=(Window,Worker)]
-interface NavigationPreloadManager {
-  Promise<void> enable();
-  Promise<void> disable();
-  Promise<void> setHeaderValue(ByteString value);
-  Promise<NavigationPreloadState> getState();
-};
-
-[SecureContext, Exposed=(Window,Worker)]
-interface Cache {
-  [NewObject] Promise<any> match(RequestInfo request, optional CacheQueryOptions options);
-  [NewObject] Promise<sequence<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<sequence<Request>> keys(optional RequestInfo request, optional CacheQueryOptions options);
-};
-
-[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();
-};
-`;

testing/web-platform/tests/service-workers/service-worker/resources/interfaces-worker.sub.js

@@ -5,10 +5,26 @@ importScripts('worker-testharness.js');
 importScripts('/resources/WebIDLParser.js');
 importScripts('/resources/idlharness.js');
 
-var idlArray = new IdlArray();
-idlArray.add_untested_idls(idls.untested);
-idlArray.add_idls(idls.tested);
-idlArray.add_objects({
+promise_test(async (t) => {
+  var idlArray = new IdlArray();
+  let serviceWorkerIdl = await fetch('/interfaces/ServiceWorker.idl').then(r => r.text());
+
+  idlArray.add_untested_idls(idls.untested);
+  idlArray.add_idls(serviceWorkerIdl, { only: [
+    'ServiceWorkerGlobalScope',
+    'Client',
+    'WindowClient',
+    'Clients',
+    'ServiceWorker',
+    'ServiceWorkerState',
+    'ServiceWorkerUpdateViaCache',
+    'ServiceWorkerRegistration',
+    'EventTarget',
+    'NavigationPreloadManager',
+    'Cache',
+    'CacheStorage',
+  ]});
+  idlArray.add_objects({
     ServiceWorkerGlobalScope: ['self'],
     Clients: ['self.clients'],
     ServiceWorkerRegistration: ['self.registration'],
@@ -17,16 +33,14 @@ idlArray.add_objects({
     // Client: ['self.clientInstance'],
     // WindowClient: ['self.windowClientInstance']
   });
+  return create_temporary_cache(t)
+    .then(function(cache) {
+        self.cacheInstance = cache;
 
-promise_test(function(t) {
-    return create_temporary_cache(t)
-      .then(function(cache) {
-          self.cacheInstance = cache;
-
-          idlArray.add_objects({ Cache: ['self.cacheInstance'] });
-          idlArray.test();
-        });
-  }, 'test setup (cache creation)');
+        idlArray.add_objects({ Cache: ['self.cacheInstance'] });
+        idlArray.test();
+      });
+}, 'test setup (cache creation)');
 
 test(function() {
     var req = new Request('http://{{host}}/',