webcodecs/serialization-to-shared-and-service-workers.https.html

<!DOCTYPE html>
<meta charset=utf-8>
<title>WebCodecs objects cannot be deserialized in shared and service workers</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/service-workers/service-worker/resources/test-helpers.sub.js"></script>
<script>
const WORKER = 'serialization-to-shared-and-service-workers-helper.js';
const SCOPE = 'serialization-to-shared-and-service-workers-scope/';

function postToSharedWorker(t, value, transfer = []) {
  const worker = new SharedWorker(WORKER, { name: `${t.name}` });
  const result = new Promise(resolve => worker.port.onmessage = e => resolve(e.data));
  worker.port.postMessage(value, transfer);
  return result;
}

async function postToServiceWorker(t, value, transfer = []) {
  const registration = await service_worker_unregister_and_register(t, WORKER, SCOPE);
  t.add_cleanup(() => registration.unregister());
  await wait_for_state(t, registration.installing, 'activated');
  const result = new Promise(resolve => navigator.serviceWorker.onmessage = e => resolve(e.data));
  registration.active.postMessage(value, transfer);
  return result;
}

const types = [
  {
    name: 'EncodedVideoChunk',
    create: () => new EncodedVideoChunk({ type: 'key', timestamp: 0, data: new Uint8Array([1, 2, 3]) })
  },
  {
    name: 'VideoFrame',
    create: () => new VideoFrame(new Uint8Array(4 * 4 * 4), { format: 'RGBA', codedWidth: 4, codedHeight: 4, timestamp: 0 }),
    transferable: true
  },
  {
    name: 'EncodedAudioChunk',
    create: () => new EncodedAudioChunk({ type: 'key', timestamp: 0, data: new Uint8Array([1, 2, 3]) })
  },
  {
    name: 'AudioData',
    create: () => new AudioData({ format: 'f32', sampleRate: 8000, numberOfFrames: 4, numberOfChannels: 1, timestamp: 0, data: new Float32Array(4) }),
    transferable: true
  },
];

const workers = [
  { name: 'shared worker', post: postToSharedWorker },
  { name: 'service worker', post: postToServiceWorker },
];

for (const worker of workers) {
  promise_test(async t => {
    assert_equals(await worker.post(t, { value: 1 }), 'message');
  }, `A plain object can be posted to a ${worker.name}`);

  for (const type of types) {
    promise_test(async t => {
      const object = type.create();
      t.add_cleanup(() => object.close?.());
      assert_equals(await worker.post(t, object), 'messageerror');
    }, `${type.name} cannot be cloned to a ${worker.name}`);

    if (type.transferable) {
      promise_test(async t => {
        const object = type.create();
        t.add_cleanup(() => object.close());
        assert_equals(await worker.post(t, object, [object]), 'messageerror');
      }, `${type.name} cannot be transferred to a ${worker.name}`);
    }
  }
}
</script>