<!DOCTYPE html>
<title>Service Worker: intercepting Worker script loads</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>
// ========== Worker main resource interception tests ==========
async function setup_service_worker(t, service_worker_url, scope) {
const r = await service_worker_unregister_and_register(
t, service_worker_url, scope);
t.add_cleanup(() => service_worker_unregister(t, scope));
await wait_for_state(t, r.installing, 'activated');
return r.active;
}
promise_test(async t => {
const worker_url = 'resources/sample-synthesized-worker.js?dedicated';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
const serviceWorker = await setup_service_worker(t, service_worker_url, scope);
const channels = new MessageChannel();
serviceWorker.postMessage({port: channels.port1}, [channels.port1]);
const clientId = await new Promise(resolve => channels.port2.onmessage = (e) => resolve(e.data.id));
const resultPromise = new Promise(resolve => channels.port2.onmessage = (e) => resolve(e.data));
const w = new Worker(worker_url);
const data = await new Promise((resolve, reject) => {
w.onmessage = e => resolve(e.data);
w.onerror = e => reject(e.message);
});
assert_equals(data, 'worker loading intercepted by service worker');
const results = await resultPromise;
assert_equals(results.clientId, clientId);
assert_true(!!results.resultingClientId.length);
channels.port2.postMessage("done");
}, `Verify a dedicated worker script request gets correct client Ids`);
promise_test(async t => {
const worker_url = 'resources/sample-synthesized-worker.js?dedicated';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new Worker(worker_url);
const data = await new Promise((resolve, reject) => {
w.onmessage = e => resolve(e.data);
w.onerror = e => reject(e.message);
});
assert_equals(data, 'worker loading intercepted by service worker');
}, `Verify a dedicated worker script request issued from a uncontrolled ` +
`document is intercepted by worker's own service worker.`);
promise_test(async t => {
const frame_url = 'resources/create-out-of-scope-worker.html';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = frame_url;
const registration = await service_worker_unregister_and_register(
t, service_worker_url, scope);
t.add_cleanup(() => service_worker_unregister(t, scope));
await wait_for_state(t, registration.installing, 'activated');
const frame = await with_iframe(frame_url);
t.add_cleanup(_ => frame.remove());
assert_equals(
frame.contentWindow.navigator.serviceWorker.controller.scriptURL,
get_newest_worker(registration).scriptURL,
'the frame should be controlled by a service worker'
);
const result = await frame.contentWindow.getWorkerPromise();
assert_equals(result,
'worker loading was not intercepted by service worker');
}, `Verify an out-of-scope dedicated worker script request issued from a ` +
`controlled document should not be intercepted by document's service ` +
`worker.`);
promise_test(async t => {
const worker_url = 'resources/sample-synthesized-worker.js?shared';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new SharedWorker(worker_url);
const data = await new Promise((resolve, reject) => {
w.port.onmessage = e => resolve(e.data);
w.onerror = e => reject(e.message);
});
assert_equals(data, 'worker loading intercepted by service worker');
}, `Verify a shared worker script request issued from a uncontrolled ` +
`document is intercepted by worker's own service worker.`);
promise_test(async t => {
const worker_url = 'resources/sample-same-origin-worker.js?dedicated';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new Worker(worker_url);
const data = await new Promise((resolve, reject) => {
w.onmessage = e => resolve(e.data);
w.onerror = e => reject(e.message);
});
assert_equals(data, 'dedicated worker script loaded');
}, 'Verify a same-origin worker script served by a service worker succeeds ' +
'in starting a dedicated worker.');
promise_test(async t => {
const worker_url = 'resources/sample-same-origin-worker.js?shared';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new SharedWorker(worker_url);
const data = await new Promise((resolve, reject) => {
w.port.onmessage = e => resolve(e.data);
w.onerror = e => reject(e.message);
});
assert_equals(data, 'shared worker script loaded');
}, 'Verify a same-origin worker script served by a service worker succeeds ' +
'in starting a shared worker.');
promise_test(async t => {
const worker_url = 'resources/sample-cors-worker.js?dedicated';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new Worker(worker_url);
const watcher = new EventWatcher(t, w, ['message', 'error']);
await watcher.wait_for('error');
}, 'Verify a cors worker script served by a service worker fails dedicated ' +
'worker start.');
promise_test(async t => {
const worker_url = 'resources/sample-cors-worker.js?shared';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new SharedWorker(worker_url);
const watcher = new EventWatcher(t, w, ['message', 'error']);
await watcher.wait_for('error');
}, 'Verify a cors worker script served by a service worker fails shared ' +
'worker start.');
promise_test(async t => {
const worker_url = 'resources/sample-no-cors-worker.js?dedicated';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new Worker(worker_url);
const watcher = new EventWatcher(t, w, ['message', 'error']);
await watcher.wait_for('error');
}, 'Verify a no-cors cross-origin worker script served by a service worker ' +
'fails dedicated worker start.');
promise_test(async t => {
const worker_url = 'resources/sample-no-cors-worker.js?shared';
const service_worker_url = 'resources/sample-worker-interceptor.js';
const scope = worker_url;
await setup_service_worker(t, service_worker_url, scope);
const w = new SharedWorker(worker_url);
const watcher = new EventWatcher(t, w, ['message', 'error']);
await watcher.wait_for('error');
}, 'Verify a no-cors cross-origin worker script served by a service worker ' +
'fails shared worker start.');
// ========== Worker subresource interception tests ==========
const scope_for_subresource_interception = 'resources/load_worker.js';
promise_test(async t => {
const service_worker_url = 'resources/worker-load-interceptor.js';
const r = await service_worker_unregister_and_register(
t, service_worker_url, scope_for_subresource_interception);
await wait_for_state(t, r.installing, 'activated');
}, 'Register a service worker for worker subresource interception tests.');
// Do not call this function multiple times without waiting for the promise
// resolution because this sets new event handlers on |worker|.
// TODO(nhiroki): To isolate multiple function calls, use MessagePort instead of
// worker's onmessage event handler.
async function request_on_worker(worker, resource_type) {
const data = await new Promise((resolve, reject) => {
if (worker instanceof Worker) {
worker.onmessage = e => resolve(e.data);
worker.onerror = e => reject(e);
worker.postMessage(resource_type);
} else if (worker instanceof SharedWorker) {
worker.port.onmessage = e => resolve(e.data);
worker.onerror = e => reject(e);
worker.port.postMessage(resource_type);
} else {
reject('Unexpected worker type!');
}
});
assert_equals(data, 'This load was successfully intercepted.');
}
async function subresource_test(worker) {
await request_on_worker(worker, 'xhr');
await request_on_worker(worker, 'fetch');
await request_on_worker(worker, 'importScripts');
}
promise_test(async t => {
await subresource_test(new Worker('resources/load_worker.js'));
}, 'Requests on a dedicated worker controlled by a service worker.');
promise_test(async t => {
await subresource_test(new SharedWorker('resources/load_worker.js'));
}, 'Requests on a shared worker controlled by a service worker.');
promise_test(async t => {
await subresource_test(new Worker('resources/nested_load_worker.js'));
}, 'Requests on a dedicated worker nested in a dedicated worker and ' +
'controlled by a service worker');
promise_test(async t => {
await subresource_test(new SharedWorker('resources/nested_load_worker.js'));
}, 'Requests on a dedicated worker nested in a shared worker and controlled ' +
'by a service worker');
promise_test(async t => {
await service_worker_unregister(t, scope_for_subresource_interception);
}, 'Unregister a service worker for subresource interception tests.');
</script>
</body>
Codebase Browser
chromium