chromium/src/third_party/blink/web_tests/http/tests/serviceworker/usecounter.html - manifest_repos/chromium_src - Git at Google

 <!DOCTYPE html>
 <title>Service Worker: UseCounter</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="resources/test-helpers.js"></script>
 <script>
 // Dummy values for features.
 const kFeature = 675;
 const kDeprecatedFeature = 166;

 function isUseCounted(win, feature) {
   return win.internals.isUseCounted(win.document, feature);
 }

 function observeUseCounter(win, feature) {
   return win.internals.observeUseCounter(win.document, feature);
 }

 // Use a window instead of an iframe because UseCounter is shared among frames
 // in a document and these tests cannot be conducted in such an environment.
 // A window has its own UseCounter.
 function openWindow(url) {
   return new Promise(resolve => {
       const win = window.open(url, '_blank');
       add_completion_callback(() => win.close());
       window.onmessage = e => {
         assert_equals(e.data, 'LOADED');
         resolve(win);
       };
     });
 }

 promise_test(async t => {
   const kUrl = 'resources/usecounter-worker.js';
   const kScope = 'resources/usecounter-window.html?basic';

   const registration =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   t.add_cleanup(() => registration.unregister());
   const worker = registration.installing;
   await wait_for_state(t, registration.installing, 'activated');
   const win1 = await openWindow(kScope);
   const win2 = await openWindow(kScope);
   assert_false(isUseCounted(win1, kFeature));
   assert_false(isUseCounted(win2, kFeature));

   // Request to count a feature.
   worker.postMessage({ type: 'COUNT_FEATURE', feature: kFeature });
   await observeUseCounter(win1, kFeature);
   await observeUseCounter(win2, kFeature);

   // API use on ServiceWorkerGlobalScope should be recorded in all controlled
   // windows.
   assert_true(isUseCounted(win1, kFeature));
   assert_true(isUseCounted(win2, kFeature));

   assert_false(isUseCounted(win1, kDeprecatedFeature));
   assert_false(isUseCounted(win2, kDeprecatedFeature));

   // Request to count a deprecated feature.
   worker.postMessage(
       { type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
   await observeUseCounter(win1, kDeprecatedFeature);
   await observeUseCounter(win2, kDeprecatedFeature);

   // Deprecated API use on ServiceWorkerGlobalScope should be recorded in all
   // controlled windows.
   assert_true(isUseCounted(win1, kDeprecatedFeature));
   assert_true(isUseCounted(win2, kDeprecatedFeature));

   // Check UseCounters have been sent to the new window. Since this can happen
   // after the new window's document load, an observer is used to wait until it
   // happens.
   const win = await openWindow(kScope);
   await observeUseCounter(win, kFeature);
   await observeUseCounter(win, kDeprecatedFeature);
 }, 'UseCounter on ServiceWorkerGlobalScope');

 promise_test(async t => {
   const kUrl = 'resources/usecounter-worker.js';
   const kScope = 'resources/usecounter-window.html?claim';

   const win1 = await openWindow(kScope);
   const win2 = await openWindow(kScope);
   const registration =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   t.add_cleanup(() => registration.unregister());
   const worker = registration.installing;
   await wait_for_state(t, registration.installing, 'activated');

   // Request to count a feature.
   worker.postMessage({type: 'COUNT_FEATURE', feature: kFeature});
   let msgEvent = await new Promise(resolve => {
     navigator.serviceWorker.onmessage = resolve;
     // There is no way to verify that API use is never counted. As a workaround,
     // wait for only one round-trip.
     worker.postMessage({type: 'PING'});
   });
   assert_equals(msgEvent.data.type, 'PONG');

   // API use on ServiceWorkerGlobalScope should not be recorded in windows
   // because they are not controlled yet.
   assert_false(isUseCounted(win1, kFeature));
   assert_false(isUseCounted(win2, kFeature));

   // Request to count a deprecated feature.
   worker.postMessage(
       { type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
   msgEvent = await new Promise(resolve => {
     navigator.serviceWorker.onmessage = resolve;
     // There is no way to verify that API use is never counted. As a workaround,
     // wait for only one round-trip.
     worker.postMessage({type: 'PING'});
   });
   assert_equals(msgEvent.data.type, 'PONG');

   // Deprecated API use on ServiceWorkerGlobalScope should not be recorded in
   // windows because they are not controlled yet.
   assert_false(isUseCounted(win1, kDeprecatedFeature));
   assert_false(isUseCounted(win2, kDeprecatedFeature));

   assert_equals(win1.navigator.serviceWorker.controller, null);
   assert_equals(win2.navigator.serviceWorker.controller, null);

   // Request to claim.
   msgEvent = await new Promise(resolve => {
     navigator.serviceWorker.onmessage = resolve;
     worker.postMessage({type: 'CLAIM'});
   });

   assert_equals(msgEvent.data.type, 'CLAIMED');
   assert_false(msgEvent.data.restarted);
   assert_not_equals(win1.navigator.serviceWorker.controller, null);
   assert_not_equals(win2.navigator.serviceWorker.controller, null);

   // The windows are now controlled by the service worker. Their UseCounter
   // should be synchronized with worker's counter.
   assert_true(isUseCounted(win1, kFeature));
   assert_true(isUseCounted(win2, kFeature));
   assert_true(isUseCounted(win1, kDeprecatedFeature));
   assert_true(isUseCounted(win2, kDeprecatedFeature));
 }, 'UseCounter on ServiceWorkerGlobalScope - A use counter owned by newly ' +
    'controlled window should be synchronized with worker\'s counter');

 // Test that features used during service worker installation are persisted.
 // This test could be non-deterministic because there is no handy way to sweep
 // out on-memory representation of ServiceWorker in the browser process and make
 // sure to restore it from the storage.
 promise_test(async t => {
   const kUrl = 'resources/usecounter-worker.js';
   const kScope = 'resources/usecounter-window.html' +
                  '?type=features-during-install' +
                  '&feature=' + kFeature +
                  '&deprecated=' + kDeprecatedFeature;

   const win1 = await openWindow(kScope);
   const win2 = await openWindow(kScope);

   // A service worker will call some APIs during the install event.
   const registration =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   t.add_cleanup(() => registration.unregister());
   const worker = registration.installing;
   await wait_for_state(t, registration.installing, 'activated');

   assert_equals(win1.navigator.serviceWorker.controller, null);
   assert_equals(win2.navigator.serviceWorker.controller, null);

   // API use on ServiceWorkerGlobalScope should not be recorded in windows
   // because they are not controlled yet.
   assert_false(isUseCounted(win1, kFeature));
   assert_false(isUseCounted(win2, kFeature));
   assert_false(isUseCounted(win1, kDeprecatedFeature));
   assert_false(isUseCounted(win2, kDeprecatedFeature));

   // Terminate the service worker.
   await internals.terminateServiceWorker(worker);

   // Request to claim. This will restart the service worker.
   const msgEvent = await new Promise(resolve => {
     navigator.serviceWorker.onmessage = resolve;
     worker.postMessage({type: 'CLAIM'});
   });

   assert_equals(msgEvent.data.type, 'CLAIMED');
   assert_true(msgEvent.data.restarted);
   assert_not_equals(win1.navigator.serviceWorker.controller, null);
   assert_not_equals(win2.navigator.serviceWorker.controller, null);

   // The windows are now controlled by the service worker. Their UseCounter
   // should be synchronized with worker's counter retrieved from the storage.
   assert_true(isUseCounted(win1, kFeature));
   assert_true(isUseCounted(win2, kFeature));
   assert_true(isUseCounted(win1, kDeprecatedFeature));
   assert_true(isUseCounted(win2, kDeprecatedFeature));
 }, 'UseCounter on ServiceWorkerGlobalScope - counts during the install ' +
    'event should be persisted');

 // TODO(nhiroki): Test that features used after service worker installation are
 // not persisted. This could be impossible because there is no handy way to
 // sweep out on-memory representation of ServiceWorker in the browser process
 // and make sure to restore it from the storage.

 promise_test(async t => {
   const kUrl = 'resources/usecounter-worker.js';
   const kScope = 'resources/usecounter-window.html?type=skip-waiting';

   const registration1 =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   t.add_cleanup(() => registration1.unregister());
   const worker1 = registration1.installing;
   await wait_for_state(t, registration1.installing, 'activated');
   const win1 = await openWindow(kScope);
   assert_false(isUseCounted(win1, kFeature));

   // Request to count a feature.
   worker1.postMessage({type: 'COUNT_FEATURE', feature: kFeature});
   await observeUseCounter(win1, kFeature);

   // API use on ServiceWorkerGlobalScope should be recorded in a controlled
   // window.
   assert_true(isUseCounted(win1, kFeature));

   // Update a controller using skipWaiting().
   const registration2 = await navigator.serviceWorker.register(
       kUrl + '?skip-waiting', {scope: kScope});
   t.add_cleanup(() => registration2.unregister());
   const worker2 = registration2.installing;

   // Wait until the new worker gets activated.
   await wait_for_state(t, worker2, 'activated');
   const win2 = await openWindow(kScope);

   // This window wasn't controlled by the previous worker.
   assert_not_equals(win2.navigator.serviceWorker.controller, undefined);

   // An updated worker does not take over the previous counter, so API use on
   // the previous worker should not be recorded in the newly controlled window.
   assert_true(isUseCounted(win1, kFeature));
   assert_false(isUseCounted(win2, kFeature));

   assert_false(isUseCounted(win1, kDeprecatedFeature));
   assert_false(isUseCounted(win2, kDeprecatedFeature));

   // Request to count a deprecated feature.
   worker2.postMessage(
       { type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
   await observeUseCounter(win1, kDeprecatedFeature);
   await observeUseCounter(win2, kDeprecatedFeature);

   // Deprecated API use on the updated worker should be recorded in all
   // controlled windows.
   assert_true(isUseCounted(win1, kFeature));
   assert_false(isUseCounted(win2, kFeature));
   assert_true(isUseCounted(win1, kDeprecatedFeature));
   assert_true(isUseCounted(win2, kDeprecatedFeature));
 }, 'UseCounter on ServiceWorkerGlobalScope - an updated worker should not ' +
    'take over a previous counter');

 promise_test(async t => {
   const kFetchEventIsReload = 2032;  // from web_feature.mojom
   const kUrl = 'resources/use-isReload-worker.js';
   const kScope = 'resources/usecounter-window.html?isReload';

   const registration =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   add_result_callback(() => registration.unregister());
   await wait_for_state(t, registration.installing, 'activated');

   const win = await openWindow(kScope);
   await observeUseCounter(win, kFetchEventIsReload);
   assert_true(isUseCounted(win, kFetchEventIsReload));
 }, 'FetchEvent.isReload is counted');

 promise_test(async t => {
   const kServiceWorkerFrameType = 2033;  // from web_feature.mojom
   const kUrl = 'resources/feature-worker.js';
   const kScope = 'resources/usecounter-window.html?frameType';

   const registration =
       await service_worker_unregister_and_register(t, kUrl, kScope);
   add_result_callback(() => registration.unregister());
   const worker = registration.installing;
   await wait_for_state(t, worker, 'activated');

   const win = await openWindow(kScope);
   worker.postMessage('use-frameType');
   await observeUseCounter(win, kServiceWorkerFrameType);
   assert_true(isUseCounted(win, kServiceWorkerFrameType));
 }, 'Client.frameType is counted');

 // TODO(nhiroki): Test a case where ServiceWorker controls SharedWorker that is
 // connected from multiple windows. In such a case, API use on ServiceWorker
 // should be propagated to all connecting windows via SharedWorker.

 </script>
 </html>
	<!DOCTYPE html>
	<title>Service Worker: UseCounter</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="resources/test-helpers.js"></script>
	<script>
	// Dummy values for features.
	const kFeature = 675;
	const kDeprecatedFeature = 166;

	function isUseCounted(win, feature) {
	return win.internals.isUseCounted(win.document, feature);
	}

	function observeUseCounter(win, feature) {
	return win.internals.observeUseCounter(win.document, feature);
	}

	// Use a window instead of an iframe because UseCounter is shared among frames
	// in a document and these tests cannot be conducted in such an environment.
	// A window has its own UseCounter.
	function openWindow(url) {
	return new Promise(resolve => {
	const win = window.open(url, '_blank');
	add_completion_callback(() => win.close());
	window.onmessage = e => {
	assert_equals(e.data, 'LOADED');
	resolve(win);
	};
	});
	}

	promise_test(async t => {
	const kUrl = 'resources/usecounter-worker.js';
	const kScope = 'resources/usecounter-window.html?basic';

	const registration =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	t.add_cleanup(() => registration.unregister());
	const worker = registration.installing;
	await wait_for_state(t, registration.installing, 'activated');
	const win1 = await openWindow(kScope);
	const win2 = await openWindow(kScope);
	assert_false(isUseCounted(win1, kFeature));
	assert_false(isUseCounted(win2, kFeature));

	// Request to count a feature.
	worker.postMessage({ type: 'COUNT_FEATURE', feature: kFeature });
	await observeUseCounter(win1, kFeature);
	await observeUseCounter(win2, kFeature);

	// API use on ServiceWorkerGlobalScope should be recorded in all controlled
	// windows.
	assert_true(isUseCounted(win1, kFeature));
	assert_true(isUseCounted(win2, kFeature));

	assert_false(isUseCounted(win1, kDeprecatedFeature));
	assert_false(isUseCounted(win2, kDeprecatedFeature));

	// Request to count a deprecated feature.
	worker.postMessage(
	{ type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
	await observeUseCounter(win1, kDeprecatedFeature);
	await observeUseCounter(win2, kDeprecatedFeature);

	// Deprecated API use on ServiceWorkerGlobalScope should be recorded in all
	// controlled windows.
	assert_true(isUseCounted(win1, kDeprecatedFeature));
	assert_true(isUseCounted(win2, kDeprecatedFeature));

	// Check UseCounters have been sent to the new window. Since this can happen
	// after the new window's document load, an observer is used to wait until it
	// happens.
	const win = await openWindow(kScope);
	await observeUseCounter(win, kFeature);
	await observeUseCounter(win, kDeprecatedFeature);
	}, 'UseCounter on ServiceWorkerGlobalScope');

	promise_test(async t => {
	const kUrl = 'resources/usecounter-worker.js';
	const kScope = 'resources/usecounter-window.html?claim';

	const win1 = await openWindow(kScope);
	const win2 = await openWindow(kScope);
	const registration =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	t.add_cleanup(() => registration.unregister());
	const worker = registration.installing;
	await wait_for_state(t, registration.installing, 'activated');

	// Request to count a feature.
	worker.postMessage({type: 'COUNT_FEATURE', feature: kFeature});
	let msgEvent = await new Promise(resolve => {
	navigator.serviceWorker.onmessage = resolve;
	// There is no way to verify that API use is never counted. As a workaround,
	// wait for only one round-trip.
	worker.postMessage({type: 'PING'});
	});
	assert_equals(msgEvent.data.type, 'PONG');

	// API use on ServiceWorkerGlobalScope should not be recorded in windows
	// because they are not controlled yet.
	assert_false(isUseCounted(win1, kFeature));
	assert_false(isUseCounted(win2, kFeature));

	// Request to count a deprecated feature.
	worker.postMessage(
	{ type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
	msgEvent = await new Promise(resolve => {
	navigator.serviceWorker.onmessage = resolve;
	// There is no way to verify that API use is never counted. As a workaround,
	// wait for only one round-trip.
	worker.postMessage({type: 'PING'});
	});
	assert_equals(msgEvent.data.type, 'PONG');

	// Deprecated API use on ServiceWorkerGlobalScope should not be recorded in
	// windows because they are not controlled yet.
	assert_false(isUseCounted(win1, kDeprecatedFeature));
	assert_false(isUseCounted(win2, kDeprecatedFeature));

	assert_equals(win1.navigator.serviceWorker.controller, null);
	assert_equals(win2.navigator.serviceWorker.controller, null);

	// Request to claim.
	msgEvent = await new Promise(resolve => {
	navigator.serviceWorker.onmessage = resolve;
	worker.postMessage({type: 'CLAIM'});
	});

	assert_equals(msgEvent.data.type, 'CLAIMED');
	assert_false(msgEvent.data.restarted);
	assert_not_equals(win1.navigator.serviceWorker.controller, null);
	assert_not_equals(win2.navigator.serviceWorker.controller, null);

	// The windows are now controlled by the service worker. Their UseCounter
	// should be synchronized with worker's counter.
	assert_true(isUseCounted(win1, kFeature));
	assert_true(isUseCounted(win2, kFeature));
	assert_true(isUseCounted(win1, kDeprecatedFeature));
	assert_true(isUseCounted(win2, kDeprecatedFeature));
	}, 'UseCounter on ServiceWorkerGlobalScope - A use counter owned by newly ' +
	'controlled window should be synchronized with worker\'s counter');

	// Test that features used during service worker installation are persisted.
	// This test could be non-deterministic because there is no handy way to sweep
	// out on-memory representation of ServiceWorker in the browser process and make
	// sure to restore it from the storage.
	promise_test(async t => {
	const kUrl = 'resources/usecounter-worker.js';
	const kScope = 'resources/usecounter-window.html' +
	'?type=features-during-install' +
	'&feature=' + kFeature +
	'&deprecated=' + kDeprecatedFeature;

	const win1 = await openWindow(kScope);
	const win2 = await openWindow(kScope);

	// A service worker will call some APIs during the install event.
	const registration =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	t.add_cleanup(() => registration.unregister());
	const worker = registration.installing;
	await wait_for_state(t, registration.installing, 'activated');

	assert_equals(win1.navigator.serviceWorker.controller, null);
	assert_equals(win2.navigator.serviceWorker.controller, null);

	// API use on ServiceWorkerGlobalScope should not be recorded in windows
	// because they are not controlled yet.
	assert_false(isUseCounted(win1, kFeature));
	assert_false(isUseCounted(win2, kFeature));
	assert_false(isUseCounted(win1, kDeprecatedFeature));
	assert_false(isUseCounted(win2, kDeprecatedFeature));

	// Terminate the service worker.
	await internals.terminateServiceWorker(worker);

	// Request to claim. This will restart the service worker.
	const msgEvent = await new Promise(resolve => {
	navigator.serviceWorker.onmessage = resolve;
	worker.postMessage({type: 'CLAIM'});
	});

	assert_equals(msgEvent.data.type, 'CLAIMED');
	assert_true(msgEvent.data.restarted);
	assert_not_equals(win1.navigator.serviceWorker.controller, null);
	assert_not_equals(win2.navigator.serviceWorker.controller, null);

	// The windows are now controlled by the service worker. Their UseCounter
	// should be synchronized with worker's counter retrieved from the storage.
	assert_true(isUseCounted(win1, kFeature));
	assert_true(isUseCounted(win2, kFeature));
	assert_true(isUseCounted(win1, kDeprecatedFeature));
	assert_true(isUseCounted(win2, kDeprecatedFeature));
	}, 'UseCounter on ServiceWorkerGlobalScope - counts during the install ' +
	'event should be persisted');

	// TODO(nhiroki): Test that features used after service worker installation are
	// not persisted. This could be impossible because there is no handy way to
	// sweep out on-memory representation of ServiceWorker in the browser process
	// and make sure to restore it from the storage.

	promise_test(async t => {
	const kUrl = 'resources/usecounter-worker.js';
	const kScope = 'resources/usecounter-window.html?type=skip-waiting';

	const registration1 =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	t.add_cleanup(() => registration1.unregister());
	const worker1 = registration1.installing;
	await wait_for_state(t, registration1.installing, 'activated');
	const win1 = await openWindow(kScope);
	assert_false(isUseCounted(win1, kFeature));

	// Request to count a feature.
	worker1.postMessage({type: 'COUNT_FEATURE', feature: kFeature});
	await observeUseCounter(win1, kFeature);

	// API use on ServiceWorkerGlobalScope should be recorded in a controlled
	// window.
	assert_true(isUseCounted(win1, kFeature));

	// Update a controller using skipWaiting().
	const registration2 = await navigator.serviceWorker.register(
	kUrl + '?skip-waiting', {scope: kScope});
	t.add_cleanup(() => registration2.unregister());
	const worker2 = registration2.installing;

	// Wait until the new worker gets activated.
	await wait_for_state(t, worker2, 'activated');
	const win2 = await openWindow(kScope);

	// This window wasn't controlled by the previous worker.
	assert_not_equals(win2.navigator.serviceWorker.controller, undefined);

	// An updated worker does not take over the previous counter, so API use on
	// the previous worker should not be recorded in the newly controlled window.
	assert_true(isUseCounted(win1, kFeature));
	assert_false(isUseCounted(win2, kFeature));

	assert_false(isUseCounted(win1, kDeprecatedFeature));
	assert_false(isUseCounted(win2, kDeprecatedFeature));

	// Request to count a deprecated feature.
	worker2.postMessage(
	{ type: 'COUNT_DEPRECATION', feature: kDeprecatedFeature });
	await observeUseCounter(win1, kDeprecatedFeature);
	await observeUseCounter(win2, kDeprecatedFeature);

	// Deprecated API use on the updated worker should be recorded in all
	// controlled windows.
	assert_true(isUseCounted(win1, kFeature));
	assert_false(isUseCounted(win2, kFeature));
	assert_true(isUseCounted(win1, kDeprecatedFeature));
	assert_true(isUseCounted(win2, kDeprecatedFeature));
	}, 'UseCounter on ServiceWorkerGlobalScope - an updated worker should not ' +
	'take over a previous counter');

	promise_test(async t => {
	const kFetchEventIsReload = 2032; // from web_feature.mojom
	const kUrl = 'resources/use-isReload-worker.js';
	const kScope = 'resources/usecounter-window.html?isReload';

	const registration =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	add_result_callback(() => registration.unregister());
	await wait_for_state(t, registration.installing, 'activated');

	const win = await openWindow(kScope);
	await observeUseCounter(win, kFetchEventIsReload);
	assert_true(isUseCounted(win, kFetchEventIsReload));
	}, 'FetchEvent.isReload is counted');

	promise_test(async t => {
	const kServiceWorkerFrameType = 2033; // from web_feature.mojom
	const kUrl = 'resources/feature-worker.js';
	const kScope = 'resources/usecounter-window.html?frameType';

	const registration =
	await service_worker_unregister_and_register(t, kUrl, kScope);
	add_result_callback(() => registration.unregister());
	const worker = registration.installing;
	await wait_for_state(t, worker, 'activated');

	const win = await openWindow(kScope);
	worker.postMessage('use-frameType');
	await observeUseCounter(win, kServiceWorkerFrameType);
	assert_true(isUseCounted(win, kServiceWorkerFrameType));
	}, 'Client.frameType is counted');

	// TODO(nhiroki): Test a case where ServiceWorker controls SharedWorker that is
	// connected from multiple windows. In such a case, API use on ServiceWorker
	// should be propagated to all connecting windows via SharedWorker.

	</script>
	</html>