webmessaging/broadcastchannel/workers.html

<!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:
              // https://github.com/whatwg/html/issues/7267
              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:
      // https://github.com/whatwg/html/issues/7267
      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>