<!DOCTYPE html>
<title>Service Worker: controlling Worker/SharedWorker</title>
<meta name="timeout" content="long">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/test-helpers.sub.js"></script>
<body>
<script>
// This tests service worker interception for worker clients, when the request
// for the worker script goes through redirects. For example, a request can go
// through a chain of URLs like A -> B -> C -> D and each URL might fall in the
// scope of a different service worker, if any.
// The two key questions are:
// 1. Upon a redirect from A -> B, should a service worker for scope B
// intercept the request?
// 2. After the final response, which service worker controls the resulting
// client?
//
// The standard prescribes the following:
// 1. The service worker for scope B intercepts the redirect. *However*, once a
// request falls back to network (i.e., a service worker did not call
// respondWith()) and a redirect is then received from network, no service
// worker should intercept that redirect or any subsequent redirects.
// 2. The final service worker that got a fetch event (or would have, in the
// case of a non-fetch-event worker) becomes the controller of the client.
//
// The standard may change later, see:
// https://github.com/w3c/ServiceWorker/issues/1289
//
// The basic test setup is:
// 1. Page registers service workers for scope1 and scope2.
// 2. Page requests a worker from scope1.
// 3. The request is redirected to scope2 or out-of-scope.
// 4. The worker posts message to the page describing where the final response
// was served from (service worker or network).
// 5. The worker does an importScripts() and fetch(), and posts back the
// responses, which describe where the responses where served from.
// Globals for easier cleanup.
const scope1 = 'resources/scope1';
const scope2 = 'resources/scope2';
let frame;
function get_message_from_worker(port) {
return new Promise(resolve => {
port.onmessage = evt => {
resolve(evt.data);
}
});
}
async function cleanup() {
if (frame)
frame.remove();
const reg1 = await navigator.serviceWorker.getRegistration(scope1);
if (reg1)
await reg1.unregister();
const reg2 = await navigator.serviceWorker.getRegistration(scope2);
if (reg2)
await reg2.unregister();
}
// Builds the worker script URL, which encodes information about where
// to redirect to. The URL falls in sw1's scope.
//
// - |redirector| is "network" or "serviceworker". If "serviceworker", sw1 will
// respondWith() a redirect. Otherwise, it falls back to network and the server
// responds with a redirect.
// - |redirect_location| is "scope2" or "out-of-scope". If "scope2", the
// redirect ends up in sw2's scope2. Otherwise it's out of scope.
function build_worker_url(redirector, redirect_location) {
let redirect_path;
// Set path to redirect.py, a file on the server that serves
// a redirect. When sw1 sees this URL, it falls back to network.
if (redirector == 'network')
redirector_path = 'redirect.py';
// Set path to 'sw-redirect', to tell the service worker
// to respond with redirect.
else if (redirector == 'serviceworker')
redirector_path = 'sw-redirect';
let redirect_to = base_path() + 'resources/';
// Append "scope2/" to redirect_to, so the redirect falls in scope2.
// Otherwise no change is needed, as the parent "resources/" directory is
// used, and is out-of-scope.
if (redirect_location == 'scope2')
redirect_to += 'scope2/';
// Append the name of the file which serves the worker script.
redirect_to += 'worker_interception_redirect_webworker.py';
return `scope1/${redirector_path}?Redirect=${redirect_to}`
}
promise_test(async t => {
await cleanup();
const service_worker = 'resources/worker-interception-redirect-serviceworker.js';
const registration1 = await navigator.serviceWorker.register(service_worker, {scope: scope1});
await wait_for_state(t, registration1.installing, 'activated');
const registration2 = await navigator.serviceWorker.register(service_worker, {scope: scope2});
await wait_for_state(t, registration2.installing, 'activated');
promise_test(t => {
return cleanup();
}, 'cleanup global state');
}, 'initialize global state');
async function worker_redirect_test(worker_request_url,
worker_expected_url,
expected_main_resource_message,
expected_import_scripts_message,
expected_fetch_message,
description) {
for (const workerType of ['DedicatedWorker', 'SharedWorker']) {
for (const type of ['classic', 'module']) {
promise_test(async t => {
// Create a frame to load the worker from. This way we can remove the
// frame to destroy the worker client when the test is done.
frame = await with_iframe('resources/blank.html');
t.add_cleanup(() => { frame.remove(); });
// Start the worker.
let w;
let port;
if (workerType === 'DedicatedWorker') {
w = new frame.contentWindow.Worker(worker_request_url, {type});
port = w;
} else {
w = new frame.contentWindow.SharedWorker(worker_request_url, {type});
port = w.port;
w.port.start();
}
w.onerror = t.unreached_func('Worker error');
// Expect a message from the worker indicating which service worker
// provided the response for the worker script request, if any.
const data = await get_message_from_worker(port);
// The worker does an importScripts(). Expect a message from the worker
// indicating which service worker provided the response for the
// importScripts(), if any.
const import_scripts_message = await get_message_from_worker(port);
test(() => {
if (type === 'classic') {
assert_equals(import_scripts_message,
expected_import_scripts_message);
} else {
assert_equals(import_scripts_message, 'importScripts failed');
}
}, `${description} (${type} ${workerType}, importScripts())`);
// The worker does a fetch(). Expect a message from the worker
// indicating which service worker provided the response for the
// fetch(), if any.
const fetch_message = await get_message_from_worker(port);
test(() => {
assert_equals(fetch_message, expected_fetch_message);
}, `${description} (${type} ${workerType}, fetch())`);
// Expect a message from the worker indicating |self.location|.
const worker_actual_url = await get_message_from_worker(port);
test(() => {
assert_equals(
worker_actual_url,
(new URL(worker_expected_url, location.href)).toString(),
'location.href');
}, `${description} (${type} ${workerType}, location.href)`);
assert_equals(data, expected_main_resource_message);
}, `${description} (${type} ${workerType})`);
}
}
}
// request to sw1 scope gets network redirect to sw2 scope
worker_redirect_test(
build_worker_url('network', 'scope2'),
'resources/scope2/worker_interception_redirect_webworker.py',
'the worker script was served from network',
'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/scope2/import-scripts-echo.py',
'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/scope2/simple.txt',
'Case #1: network scope1->scope2');
// request to sw1 scope gets network redirect to out-of-scope
worker_redirect_test(
build_worker_url('network', 'out-scope'),
'resources/worker_interception_redirect_webworker.py',
'the worker script was served from network',
'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/import-scripts-echo.py',
'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/simple.txt',
'Case #2: network scope1->out-scope');
// request to sw1 scope gets service-worker redirect to sw2 scope
worker_redirect_test(
build_worker_url('serviceworker', 'scope2'),
'resources/subdir/worker_interception_redirect_webworker.py?greeting=sw2%20saw%20the%20request%20for%20the%20worker%20script',
'sw2 saw the request for the worker script',
'sw2 saw importScripts from the worker: /service-workers/service-worker/resources/subdir/import-scripts-echo.py',
'fetch(): sw2 saw the fetch from the worker: /service-workers/service-worker/resources/subdir/simple.txt',
'Case #3: sw scope1->scope2');
// request to sw1 scope gets service-worker redirect to out-of-scope
worker_redirect_test(
build_worker_url('serviceworker', 'out-scope'),
'resources/worker_interception_redirect_webworker.py',
'the worker script was served from network',
'sw1 saw importScripts from the worker: /service-workers/service-worker/resources/import-scripts-echo.py',
'fetch(): sw1 saw the fetch from the worker: /service-workers/service-worker/resources/simple.txt',
'Case #4: sw scope1->out-scope');
</script>
</body>
Codebase Browser
chromium