webrtc/RTCPeerConnection-operations.https.html

<!doctype html>
<meta charset=utf-8>
<title></title>
<script src=/resources/testharness.js></script>
<script src=/resources/testharnessreport.js></script>
<script>
'use strict';

// Helpers to test APIs "return a promise rejected with a newly created" error.
// Strictly speaking this means already-rejected upon return.
function promiseState(p) {
  const t = {};
  return Promise.race([p, t])
    .then(v => (v === t)? "pending" : "fulfilled", () => "rejected");
}

// However, to allow promises to be used in implementations, this helper adds
// some slack: returning a pending promise will pass, provided it is rejected
// before the end of the current run of the event loop (i.e. on microtask queue
// before next task).
async function promiseStateFinal(p) {
  for (let i = 0; i < 20; i++) {
    await promiseState(p);
  }
  return promiseState(p);
}

[promiseState, promiseStateFinal].forEach(f => promise_test(async t => {
  assert_equals(await f(Promise.resolve()), "fulfilled");
  assert_equals(await f(Promise.reject()), "rejected");
  assert_equals(await f(new Promise(() => {})), "pending");
}, `${f.name} helper works`));

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  await pc.setRemoteDescription(await pc.createOffer());
  const p = pc.createOffer();
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "createOffer must detect InvalidStateError synchronously when chain is empty (prerequisite)");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const p = pc.createAnswer();
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "createAnswer must detect InvalidStateError synchronously when chain is empty (prerequisite)");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const p = pc.setLocalDescription({type: "rollback"});
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "SLD(rollback) must detect InvalidStateError synchronously when chain is empty");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const p = pc.addIceCandidate();
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(pc.remoteDescription, null, "no remote desciption");
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "addIceCandidate must detect InvalidStateError synchronously when chain is empty");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const transceiver = pc.addTransceiver("audio");
  transceiver.stop();
  const p = transceiver.sender.replaceTrack(null);
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "replaceTrack must detect InvalidStateError synchronously when chain is empty and transceiver is stopped");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const transceiver = pc.addTransceiver("audio");
  transceiver.stop();
  const parameters = transceiver.sender.getParameters();
  const p = transceiver.sender.setParameters(parameters);
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "setParameters must detect InvalidStateError synchronously always when transceiver is stopped");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const {track} = new RTCPeerConnection().addTransceiver("audio").receiver;
  assert_not_equals(track, null);
  const p = pc.getStats(track);
  const haveState = promiseStateFinal(p);
  try {
    await p;
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidAccessError");
  }
  assert_equals(await haveState, "rejected", "promise rejected on same task");
}, "pc.getStats must detect InvalidAccessError synchronously always");

// Helper builds on above tests to check if operations queue is empty or not.
//
// Meaning of "empty": Because this helper uses the sloppy promiseStateFinal,
// it may not detect operations on the chain unless they block the current run
// of the event loop. In other words, it may not detect operations on the chain
// that resolve on the emptying of the microtask queue at the end of this run of
// the event loop.

async function isOperationsChainEmpty(pc) {
  let p, error;
  const signalingState = pc.signalingState;
  if (signalingState == "have-remote-offer") {
    p = pc.createOffer();
  } else {
    p = pc.createAnswer();
  }
  const state = await promiseStateFinal(p);
  try {
    await p;
    // This helper tries to avoid side-effects by always failing,
    // but createAnswer above may succeed if chained after an SRD
    // that changes the signaling state on us. Ignore that success.
    if (signalingState == pc.signalingState) {
      assert_unreached("Control. Must not succeed");
    }
  } catch (e) {
    assert_equals(e.name, "InvalidStateError",
                  "isOperationsChainEmpty is working");
  }
  return state == "rejected";
}

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  assert_true(await isOperationsChainEmpty(pc), "Empty to start");
}, "isOperationsChainEmpty detects empty in stable");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  await pc.setLocalDescription(await pc.createOffer());
  assert_true(await isOperationsChainEmpty(pc), "Empty to start");
}, "isOperationsChainEmpty detects empty in have-local-offer");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  await pc.setRemoteDescription(await pc.createOffer());
  assert_true(await isOperationsChainEmpty(pc), "Empty to start");
}, "isOperationsChainEmpty detects empty in have-remote-offer");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const p = pc.createOffer();
  assert_false(await isOperationsChainEmpty(pc), "Non-empty chain");
  await p;
}, "createOffer uses operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  await pc.setRemoteDescription(await pc.createOffer());
  const p = pc.createAnswer();
  assert_false(await isOperationsChainEmpty(pc), "Non-empty chain");
  await p;
}, "createAnswer uses operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const offer = await pc.createOffer();
  assert_true(await isOperationsChainEmpty(pc), "Empty before");
  const p = pc.setLocalDescription(offer);
  assert_false(await isOperationsChainEmpty(pc), "Non-empty chain");
  await p;
}, "setLocalDescription uses operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const offer = await pc.createOffer();
  assert_true(await isOperationsChainEmpty(pc), "Empty before");
  const p = pc.setRemoteDescription(offer);
  assert_false(await isOperationsChainEmpty(pc), "Non-empty chain");
  await p;
}, "setRemoteDescription uses operations chain");

promise_test(async t => {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  pc1.addTransceiver("video");
  const offer = await pc1.createOffer();
  await pc1.setLocalDescription(offer);
  const {candidate} = await new Promise(r => pc1.onicecandidate = r);
  await pc2.setRemoteDescription(offer);
  const p = pc2.addIceCandidate(candidate);
  assert_false(await isOperationsChainEmpty(pc2), "Non-empty chain");
  await p;
}, "addIceCandidate uses operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const transceiver = pc.addTransceiver("audio");
  await new Promise(r => pc.onnegotiationneeded = r);
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
}, "Firing of negotiationneeded does NOT use operations chain");

promise_test(async t => {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  pc1.addTransceiver("audio");
  pc1.addTransceiver("video");
  const offer = await pc1.createOffer();
  await pc1.setLocalDescription(offer);
  const candidates = [];
  for (let c; (c = (await new Promise(r => pc1.onicecandidate = r)).candidate);) {
    candidates.push(c);
  }
  pc2.addTransceiver("video");
  let fired = false;
  const p = new Promise(r => pc2.onnegotiationneeded = () => r(fired = true));
  await Promise.all([
    pc2.setRemoteDescription(offer),
    ...candidates.map(candidate => pc2.addIceCandidate(candidate)),
    pc2.setLocalDescription()
  ]);
  assert_false(fired, "Negotiationneeded mustn't have fired yet.");
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(fired, "Negotiationneeded must have fired by now.");
  await p;
}, "Negotiationneeded only fires once operations chain is empty");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const transceiver = pc.addTransceiver("audio");
  await new Promise(r => pc.onnegotiationneeded = r);
  // Note: since the negotiationneeded event is fired from a chained synchronous
  // function in the spec, queue a task before doing our precheck.
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  const p = transceiver.sender.replaceTrack(null);
  assert_false(await isOperationsChainEmpty(pc), "Non-empty chain");
  await p;
}, "replaceTrack uses operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const transceiver = pc.addTransceiver("audio");
  await new Promise(r => pc.onnegotiationneeded = r);
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  const parameters = transceiver.sender.getParameters();
  const p = transceiver.sender.setParameters(parameters);
  const haveState = promiseStateFinal(p);
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  assert_equals(await haveState, "pending", "Method is async");
  await p;
}, "setParameters does NOT use the operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const p = pc.getStats();
  const haveState = promiseStateFinal(p);
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  assert_equals(await haveState, "pending", "Method is async");
  await p;
}, "pc.getStats does NOT use the operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const {sender} = pc.addTransceiver("audio");
  await new Promise(r => pc.onnegotiationneeded = r);
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  const p = sender.getStats();
  const haveState = promiseStateFinal(p);
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  assert_equals(await haveState, "pending", "Method is async");
  await p;
}, "sender.getStats does NOT use the operations chain");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());
  const {receiver} = pc.addTransceiver("audio");
  await new Promise(r => pc.onnegotiationneeded = r);
  await new Promise(r => t.step_timeout(r, 0));
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  const p = receiver.getStats();
  const haveState = promiseStateFinal(p);
  assert_true(await isOperationsChainEmpty(pc), "Empty chain");
  assert_equals(await haveState, "pending", "Method is async");
  await p;
}, "receiver.getStats does NOT use the operations chain");

promise_test(async t => {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  pc1.addTransceiver("video");
  const offer = await pc1.createOffer();
  await pc1.setLocalDescription(offer);
  const {candidate} = await new Promise(r => pc1.onicecandidate = r);
  try {
    await pc2.addIceCandidate(candidate);
    assert_unreached("Control. Must not succeed");
  } catch (e) {
    assert_equals(e.name, "InvalidStateError");
  }
  const p = pc2.setRemoteDescription(offer);
  await pc2.addIceCandidate(candidate);
  await p;
}, "addIceCandidate chains onto SRD, fails before");

promise_test(async t => {
  const pc = new RTCPeerConnection();
  t.add_cleanup(() => pc.close());

  const offer = await pc.createOffer();
  pc.addTransceiver("video");
  await new Promise(r => pc.onnegotiationneeded = r);
  const p = (async () => {
    await pc.setLocalDescription();
  })();
  await new Promise(r => t.step_timeout(r, 0));
  await pc.setRemoteDescription(offer);
  await p;
}, "Operations queue not vulnerable to recursion by chained negotiationneeded");

promise_test(async t => {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  pc1.addTransceiver("video");
  await Promise.all([
    pc1.createOffer(),
    pc1.setLocalDescription({type: "offer"})
  ]);
  await Promise.all([
    pc2.setRemoteDescription(pc1.localDescription),
    pc2.createAnswer(),
    pc2.setLocalDescription({type: "answer"})
  ]);
  await pc1.setRemoteDescription(pc2.localDescription);
}, "Pack operations queue with implicit offer and answer");

promise_test(async t => {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  const state = (pc, s) => new Promise(r => pc.onsignalingstatechange =
                                       () => pc.signalingState == s && r());
  pc1.addTransceiver("video");
  pc1.createOffer();
  pc1.setLocalDescription({type: "offer"});
  await state(pc1, "have-local-offer");
  pc2.setRemoteDescription(pc1.localDescription);
  pc2.createAnswer();
  pc2.setLocalDescription({type: "answer"});
  await state(pc2, "stable");
  await pc1.setRemoteDescription(pc2.localDescription);
}, "Negotiate solely by operations queue and signaling state");

</script>