Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- This WPT test may be referenced by the following Test IDs:
- /webmessaging/broadcastchannel/workers.html - WPT Dashboard Interop Dashboard
<!DOCTYPE html>
<meta charset=utf-8>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script>
async_test(t => {
let c1 = new BroadcastChannel('worker');
let c2 = new BroadcastChannel('worker');
let events = [];
c1.onmessage = e => events.push(e);
c2.onmessage = e => events.push(e);
let doneCount = 0;
c2.addEventListener('message', t.step_func(e => {
if (e.data == 'from worker') {
c2.postMessage('from c2');
c1.postMessage('done');
} else if (e.data == 'done') {
assert_equals(events.length, 4);
assert_equals(events[0].data, 'from worker');
assert_equals(events[0].target, c1);
assert_equals(events[1].data, 'from worker');
assert_equals(events[1].target, c2);
assert_equals(events[2].data, 'from c2');
assert_equals(events[3].data, 'done');
if (++doneCount == 2) t.done();
}
}));
let worker = new Worker('resources/worker.js');
worker.onmessage = t.step_func(e => {
assert_array_equals(e.data, ['from c2', 'done']);
if (++doneCount == 2) t.done();
});
worker.postMessage({channel: 'worker'});
}, 'BroadcastChannel works in workers');
async_test(t => {
let c1 = new BroadcastChannel('shared worker');
let c2 = new BroadcastChannel('shared worker');
let events = [];
c1.onmessage = e => events.push(e);
c2.onmessage = e => events.push(e);
let doneCount = 0;
c2.addEventListener('message', t.step_func(e => {
if (e.data == 'from worker') {
c2.postMessage('from c2');
c1.postMessage('done');
} else if (e.data == 'done') {
assert_equals(events.length, 4);
assert_equals(events[0].data, 'from worker');
assert_equals(events[0].target, c1);
assert_equals(events[1].data, 'from worker');
assert_equals(events[1].target, c2);
assert_equals(events[2].data, 'from c2');
assert_equals(events[3].data, 'done');
if (++doneCount == 2) t.done();
}
}));
let worker = new SharedWorker('resources/worker.js');
worker.port.onmessage = t.step_func(e => {
assert_array_equals(e.data, ['from c2', 'done']);
if (++doneCount == 2) t.done();
});
worker.port.postMessage({channel: 'shared worker'});
}, 'BroadcastChannel works in shared workers');
async_test(t => {
let c = new BroadcastChannel('worker-close');
let events = [];
c.onmessage = e => events.push('c1: ' + e.data);
let worker = new Worker('resources/worker.js');
worker.onmessage = t.step_func(e => {
assert_array_equals(events,
['c1: from worker', 'c2: ready', 'c2: echo'],
'messages in document');
assert_array_equals(e.data, ['done'], 'messages in worker');
t.done();
});
worker.onmessagerror =
t.unreached_func('Worker\'s onmessageerror handler called');
c.addEventListener('message', e => {
if (e.data == 'from worker') {
c.close();
if (self.gc) self.gc();
window.setTimeout(() => {
let c2 = new BroadcastChannel('worker-close');
c2.onmessage = e => {
events.push('c2: ' + e.data);
if (e.data === 'ready') {
worker.postMessage({ping: 'echo'});
} else {
c2.postMessage('done');
c2.close();
}
};
// For some implementations there may be a race condition between
// when the BroadcastChannel instance above is created / ready to
// receive messages and when the worker calls postMessage on it's
// BroadcastChannel instance. To avoid this, confirm that our
// instance can receive a message before indicating to the other
// thread that we are ready. For more details, see:
let c3 = new BroadcastChannel('worker-close');
c3.postMessage('ready');
c3.close();
}, 1);
}
});
worker.postMessage({channel: 'worker-close'});
t.add_cleanup(() => worker.terminate());
}, 'Closing and re-opening a channel works.');
async_test(t => {
function workerCode() {
close();
try {
var bc = new BroadcastChannel('worker-create-after-close');
} catch (e) {
postMessage(e);
return;
}
postMessage(true);
}
var workerBlob = new Blob(
[workerCode.toString() + ';workerCode();'],
{type: 'application/javascript'});
var w = new Worker(URL.createObjectURL(workerBlob));
w.onmessage = t.step_func_done(function(e) {
assert_equals(
e.data, true,
'BroadcastChannel creation in closed worker triggered exception: ' +
e.data.message);
});
t.add_cleanup(() => w.terminate());
}, 'BroadcastChannel created after a worker self.close()');
function postMessageFromWorkerWorkerCode(workerName, channelName) {
if (workerName === 'close-before-create-worker') {
close();
}
let bc = new BroadcastChannel(channelName);
if (workerName === 'close-after-create-worker') {
close();
}
bc.postMessage(workerName + ' done');
postMessage(true);
}
function doPostMessageFromWorkerTest(t, workerName, channelName) {
var bc = new BroadcastChannel(channelName);
bc.onmessage = t.step_func_done(function(e) {
assert_equals(
e.data, 'done-worker done',
'BroadcastChannel message should only be received from the second worker');
});
t.add_cleanup(() => bc.close());
var testMessageHandler = t.step_func(function(e) {
assert_equals(
e.data, true,
'Worker sent postMessage indicating it sent a BroadcastChannel message');
var w = createWorker(
postMessageFromWorkerWorkerCode, 'done-worker', channelName);
t.add_cleanup(() => w.terminate());
});
createWorker(
postMessageFromWorkerWorkerCode, workerName, channelName,
testMessageHandler);
// To avoid calling t.step_timeout here, have the worker postMessage(true)
// once it is finished and then we'll instantiate another worker that
// performs the same test steps but doesn't close. By the time the
// BroadcastChannel message in that worker gets sent successfully it should
// be safe to assume that any BroadcastChannel messages from the previous
// worker would have been sent if they were going to be.
}
function createWorker(workerCode, workerName, channelName, handler = null) {
var workerCodeStr = workerCode.toString() +
`;${workerCode.name}("${workerName}", "${channelName}");`;
var workerBlob = new Blob([workerCodeStr], {type: 'application/javascript'});
var w = new Worker(URL.createObjectURL(workerBlob));
if (handler !== null) {
w.onmessage = handler;
}
return w;
}
async_test(t => {
const workerName = 'close-after-create-worker';
const channelName = workerName + '-postmessage-from-worker';
doPostMessageFromWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages from closed worker to parent should be ignored (BC created before closing)');
async_test(t => {
const workerName = 'close-before-create-worker';
const channelName = workerName + '-postmessage-from-worker';
doPostMessageFromWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages from closed worker to parent should be ignored (BC created after closing)');
function postMessageToWorkerWorkerCode(workerName, channelName) {
self.addEventListener('message', () => {
if (workerName === 'close-before-create-worker') {
close();
}
try {
let bc1 = new BroadcastChannel(channelName);
bc1.onmessage = e => {
if (e.data === 'ready') {
postMessage(e.data);
} else if (e.data === 'test') {
postMessage(workerName + ' done');
}
};
bc1.onmessageerror = () => {
postMessage('onmessageerror called from worker BroadcastChannel');
};
if (workerName === 'close-after-create-worker') {
close();
}
} catch (e) {
postMessage(e);
return;
}
if (workerName === 'done-worker') {
// For some implementations there may be a race condition between when
// the BroadcastChannel instance above is created / ready to receive
// messages and when the parent calls postMessage on it's
// BroadcastChannel instance. To avoid this, confirm that our instance
// can receive a message before indicating to the other thread that we
// are ready. For more details, see:
let bc2 = new BroadcastChannel(channelName);
bc2.postMessage('ready');
bc2.close();
} else {
// Since the worker has closed, it's not expected that the
// BroadcastChannel will receive messages (there's a separate test for
// that), so just indicate directly that it's ready to test receiving
// a message from the parent dispite the possibility of a race condition.
postMessage('ready');
}
});
self.addEventListener('messageerror', () => {
postMessage('onmessageerror called from worker');
});
}
function doPostMessageToWorkerTest(t, workerName, channelName) {
var bc = new BroadcastChannel(channelName);
t.add_cleanup(() => bc.close());
var doneMessageHandler = t.step_func(function(e) {
if (e.data === 'ready') {
bc.postMessage('test');
} else if (e.data === 'done-worker done') {
t.done();
} else {
assert_unreached(
'BroadcastChannel.postMessage triggered exception within second worker: ' +
e.data.message);
}
});
var testMessageHandler = t.step_func(function(e) {
assert_equals(
e.data, 'ready',
'Worker sent postMessage indicating its BroadcastChannel instance is ready');
bc.postMessage('test');
var doneWorker = createWorker(
postMessageToWorkerWorkerCode, 'done-worker', channelName,
doneMessageHandler);
t.add_cleanup(() => {
doneWorker.terminate();
});
doneWorker.postMessage('start');
});
var testWorker = createWorker(
postMessageToWorkerWorkerCode, workerName, channelName,
testMessageHandler);
testWorker.postMessage('start');
}
async_test(t => {
const workerName = 'close-after-create-worker';
const channelName = workerName + '-postmessage-to-worker';
doPostMessageToWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages from parent to closed worker should be ignored (BC created before closing)');
async_test(t => {
const workerName = 'close-before-create-worker';
const channelName = workerName + '-postmessage-to-worker';
doPostMessageToWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages from parent to closed worker should be ignored (BC created after closing)');
function postMessageWithinWorkerWorkerCode(workerName, channelName) {
if (workerName === 'close-before-create-worker') {
close();
}
try {
let bc1 = new BroadcastChannel(channelName);
let bc2 = new BroadcastChannel(channelName);
bc1.onmessage = e => {
postMessage(workerName + ' done')
};
if (workerName === 'close-after-create-worker') {
close();
}
bc2.postMessage(true);
postMessage(true);
} catch (e) {
postMessage(e);
}
}
function doPostMessageWithinWorkerTest(t, workerName, channelName) {
var doneMessageHandler = t.step_func(function(e) {
if (e.data === true) {
// Done worker has finished - no action needed
} else if (e.data === 'done-worker done') {
t.done();
} else {
assert_unreached(
'BroadcastChannel.postMessage triggered exception within second worker: ' +
e.data.message);
}
});
var testMessageHandler = t.step_func(function(e) {
assert_equals(
e.data, true,
'Worker indicated that the test procedures were executed successfully');
var w = createWorker(
postMessageWithinWorkerWorkerCode, 'done-worker', channelName,
doneMessageHandler);
t.add_cleanup(() => w.terminate());
});
createWorker(
postMessageWithinWorkerWorkerCode, workerName, channelName,
testMessageHandler);
}
async_test(t => {
const workerName = 'close-after-create-worker';
const channelName = workerName + '-postmessage-within-worker';
doPostMessageWithinWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages within closed worker should be ignored (BCs created before closing)');
async_test(t => {
const workerName = 'close-before-create-worker';
const channelName = workerName + '-postmessage-within-worker';
doPostMessageWithinWorkerTest(t, workerName, channelName);
}, 'BroadcastChannel messages within closed worker should be ignored (BCs created after closing)');
</script>