mirror of
https://github.com/servo/servo.git
synced 2025-06-28 11:03:39 +01:00
482 lines
20 KiB
HTML
482 lines
20 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title></title>
|
|
<script src=/resources/testharness.js></script>
|
|
<script src=/resources/testharnessreport.js></script>
|
|
<script src="RTCPeerConnection-helper.js"></script>
|
|
<script>
|
|
"use strict";
|
|
|
|
function getLines(sdp, startsWith) {
|
|
const lines = sdp.split("\r\n").filter(l => l.startsWith(startsWith));
|
|
assert_true(lines.length > 0, `One or more ${startsWith} in sdp`);
|
|
return lines;
|
|
}
|
|
|
|
const getUfrags = ({sdp}) => getLines(sdp, "a=ice-ufrag:");
|
|
const getPwds = ({sdp}) => getLines(sdp, "a=ice-pwd:");
|
|
|
|
const negotiators = [
|
|
{
|
|
tag: "",
|
|
async setOffer(pc) {
|
|
await pc.setLocalDescription(await pc.createOffer());
|
|
},
|
|
async setAnswer(pc) {
|
|
await pc.setLocalDescription(await pc.createAnswer());
|
|
},
|
|
},
|
|
{
|
|
tag: " (perfect negotiation)",
|
|
async setOffer(pc) {
|
|
await pc.setLocalDescription();
|
|
},
|
|
async setAnswer(pc) {
|
|
await pc.setLocalDescription();
|
|
},
|
|
},
|
|
];
|
|
|
|
async function exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator) {
|
|
await negotiator.setOffer(pc1);
|
|
await pc2.setRemoteDescription(pc1.localDescription);
|
|
await negotiator.setAnswer(pc2);
|
|
await pc1.setRemoteDescription(pc2.localDescription); // End on pc1. No race
|
|
}
|
|
|
|
async function exchangeOfferAnswerEndOnSecond(pc1, pc2, negotiator) {
|
|
await negotiator.setOffer(pc1);
|
|
await pc2.setRemoteDescription(pc1.localDescription);
|
|
await pc1.setRemoteDescription(await pc2.createAnswer());
|
|
await pc2.setLocalDescription(pc1.remoteDescription); // End on pc2. No race
|
|
}
|
|
|
|
async function assertNoNegotiationNeeded(t, pc, state = "stable") {
|
|
assert_equals(pc.signalingState, state, `In ${state} state`);
|
|
const event = await Promise.race([
|
|
new Promise(r => pc.onnegotiationneeded = r),
|
|
new Promise(r => t.step_timeout(r, 10))
|
|
]);
|
|
assert_equals(event, undefined, "No negotiationneeded event");
|
|
}
|
|
|
|
// In Chromium, assert_equals() produces test expectations with the values
|
|
// compared. Because ufrags are different on each run, this would make Chromium
|
|
// test expectations different on each run on tests that failed when comparing
|
|
// ufrags. To work around this problem, assert_ufrags_equals() and
|
|
// assert_ufrags_not_equals() should be preferred over assert_equals() and
|
|
// assert_not_equals().
|
|
function assert_ufrags_equals(x, y, description) {
|
|
assert_true(x === y, description);
|
|
}
|
|
function assert_ufrags_not_equals(x, y, description) {
|
|
assert_false(x === y, description);
|
|
}
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
pc.close();
|
|
pc.restartIce();
|
|
await assertNoNegotiationNeeded(t, pc, "closed");
|
|
}, "restartIce() has no effect on a closed peer connection");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.restartIce();
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, "restartIce() does not trigger negotiation ahead of initial negotiation");
|
|
|
|
// Run remaining tests twice: once for each negotiator
|
|
|
|
for (const negotiator of negotiators) {
|
|
const {tag} = negotiator;
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
pc1.restartIce();
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() has no effect on initial negotiation${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
}, `restartIce() fires negotiationneeded after initial negotiation${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], oldUfrag1, "control 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], oldUfrag2, "control 2");
|
|
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], newUfrag1, "Unchanged 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], newUfrag2, "Unchanged 2");
|
|
}, `restartIce() causes fresh ufrags${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const config = {bundlePolicy: "max-bundle"};
|
|
const pc1 = new RTCPeerConnection(config);
|
|
const pc2 = new RTCPeerConnection(config);
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate);
|
|
pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate);
|
|
|
|
// See the explanation below about Chrome's onnegotiationneeded firing
|
|
// too early.
|
|
const negotiationNeededPromise1 =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
pc1.addTransceiver("video");
|
|
pc1.addTransceiver("audio");
|
|
await negotiationNeededPromise1;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [videoTc, audioTc] = pc1.getTransceivers();
|
|
const [videoTp, audioTp] =
|
|
pc1.getTransceivers().map(tc => tc.sender.transport);
|
|
assert_equals(pc1.getTransceivers().length, 2, 'transceiver count');
|
|
|
|
// On Chrome, it is possible (likely, even) that videoTc.sender.transport.state
|
|
// will be 'connected' by the time we get here. We'll race 2 promises here:
|
|
// 1. Resolve after onstatechange is called with connected state.
|
|
// 2. If already connected, resolve immediately.
|
|
await Promise.race([
|
|
new Promise(r => videoTc.sender.transport.onstatechange =
|
|
() => videoTc.sender.transport.state == "connected" && r()),
|
|
new Promise(r => videoTc.sender.transport.state == "connected" && r())
|
|
]);
|
|
assert_equals(videoTc.sender.transport.state, "connected");
|
|
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
assert_equals(videoTp, pc1.getTransceivers()[0].sender.transport,
|
|
'offer/answer retains dtls transport');
|
|
assert_equals(audioTp, pc1.getTransceivers()[1].sender.transport,
|
|
'offer/answer retains dtls transport');
|
|
|
|
const negotiationNeededPromise2 =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
pc1.restartIce();
|
|
await negotiationNeededPromise2;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [newVideoTp, newAudioTp] =
|
|
pc1.getTransceivers().map(tc => tc.sender.transport);
|
|
assert_equals(videoTp, newVideoTp, 'ice restart retains dtls transport');
|
|
assert_equals(audioTp, newAudioTp, 'ice restart retains dtls transport');
|
|
}, `restartIce() retains dtls transports${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
await negotiator.setOffer(pc1);
|
|
pc1.restartIce();
|
|
await pc2.setRemoteDescription(pc1.localDescription);
|
|
await negotiator.setAnswer(pc2);
|
|
// Several tests in this file initializes the onnegotiationneeded listener
|
|
// before the setLocalDescription() or setRemoteDescription() that we expect
|
|
// to trigger negotiation needed. This allows Chrome to exercise these tests
|
|
// without timing out due to a bug that causes onnegotiationneeded to fire too
|
|
// early.
|
|
// TODO(https://crbug.com/985797): Once Chrome does not fire ONN too early,
|
|
// simply do "await new Promise(...)" instead of
|
|
// "await negotiationNeededPromise" here and in other tests in this file.
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], oldUfrag1, "Unchanged 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], oldUfrag2, "Unchanged 2");
|
|
await negotiationNeededPromise;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() works in have-local-offer${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await negotiator.setOffer(pc1);
|
|
pc1.restartIce();
|
|
await pc2.setRemoteDescription(pc1.localDescription);
|
|
await negotiator.setAnswer(pc2);
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
await negotiationNeededPromise;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() works in initial have-local-offer${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
await negotiator.setOffer(pc2);
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
pc1.restartIce();
|
|
await pc2.setRemoteDescription(await pc1.createAnswer());
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await pc1.setLocalDescription(pc2.remoteDescription); // End on pc1. No race
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], oldUfrag1, "Unchanged 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], oldUfrag2, "Unchanged 2");
|
|
await negotiationNeededPromise;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() works in have-remote-offer${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc2.addTransceiver("audio");
|
|
await negotiator.setOffer(pc2);
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
pc1.restartIce();
|
|
await pc2.setRemoteDescription(await pc1.createAnswer());
|
|
await pc1.setLocalDescription(pc2.remoteDescription); // End on pc1. No race
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() does nothing in initial have-remote-offer${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnSecond(pc2, pc1, negotiator);
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], oldUfrag1, "nothing yet 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], oldUfrag2, "nothing yet 2");
|
|
await negotiationNeededPromise;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag2, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() survives remote offer${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
pc1.restartIce();
|
|
pc2.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnSecond(pc2, pc1, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
assert_ufrags_equals(getUfrags(pc1.localDescription)[0], newUfrag1, "Unchanged 1");
|
|
assert_ufrags_equals(getUfrags(pc2.localDescription)[0], newUfrag2, "Unchanged 2");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() is satisfied by remote ICE restart${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await pc1.setLocalDescription(await pc1.createOffer({iceRestart: false}));
|
|
await pc2.setRemoteDescription(pc1.localDescription);
|
|
await negotiator.setAnswer(pc2);
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() trumps {iceRestart: false}${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const [oldUfrag1] = getUfrags(pc1.localDescription);
|
|
const [oldUfrag2] = getUfrags(pc2.localDescription);
|
|
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await negotiator.setOffer(pc1);
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await pc1.setLocalDescription({type: "rollback"});
|
|
await negotiationNeededPromise;
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
const [newUfrag1] = getUfrags(pc1.localDescription);
|
|
const [newUfrag2] = getUfrags(pc2.localDescription);
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag1, "ufrag 1 changed");
|
|
assert_ufrags_not_equals(newUfrag1, oldUfrag2, "ufrag 2 changed");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() survives rollback${tag}`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection({bundlePolicy: "max-compat"});
|
|
const pc2 = new RTCPeerConnection({bundlePolicy: "max-compat"});
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver("audio");
|
|
pc1.addTransceiver("video");
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
await exchangeOfferAnswerEndOnFirst(pc1, pc2, negotiator);
|
|
|
|
const oldUfrags1 = getUfrags(pc1.localDescription);
|
|
const oldUfrags2 = getUfrags(pc2.localDescription);
|
|
const oldPwds2 = getPwds(pc2.localDescription);
|
|
|
|
pc1.restartIce();
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
|
|
// Engineer a partial ICE restart from pc2
|
|
pc2.restartIce();
|
|
await negotiator.setOffer(pc2);
|
|
{
|
|
let {type, sdp} = pc2.localDescription;
|
|
// Restore both old ice-ufrag and old ice-pwd to trigger a partial restart
|
|
sdp = sdp.replace(getUfrags({sdp})[0], oldUfrags2[0]);
|
|
sdp = sdp.replace(getPwds({sdp})[0], oldPwds2[0]);
|
|
const newUfrags2 = getUfrags({sdp});
|
|
const newPwds2 = getPwds({sdp});
|
|
assert_ufrags_equals(newUfrags2[0], oldUfrags2[0], "control ufrag match");
|
|
assert_ufrags_equals(newPwds2[0], oldPwds2[0], "control pwd match");
|
|
assert_ufrags_not_equals(newUfrags2[1], oldUfrags2[1], "control ufrag non-match");
|
|
assert_ufrags_not_equals(newPwds2[1], oldPwds2[1], "control pwd non-match");
|
|
await pc1.setRemoteDescription({type, sdp});
|
|
}
|
|
const negotiationNeededPromise =
|
|
new Promise(r => pc1.onnegotiationneeded = r);
|
|
await negotiator.setAnswer(pc1);
|
|
const newUfrags1 = getUfrags(pc1.localDescription);
|
|
assert_ufrags_equals(newUfrags1[0], oldUfrags1[0], "Unchanged 1");
|
|
assert_ufrags_not_equals(newUfrags1[1], oldUfrags1[1], "Restarted 2");
|
|
await negotiationNeededPromise;
|
|
await negotiator.setOffer(pc1);
|
|
const newestUfrags1 = getUfrags(pc1.localDescription);
|
|
assert_ufrags_not_equals(newestUfrags1[0], oldUfrags1[0], "Restarted 1");
|
|
assert_ufrags_not_equals(newestUfrags1[1], oldUfrags1[1], "Restarted 2");
|
|
await assertNoNegotiationNeeded(t, pc1);
|
|
}, `restartIce() survives remote offer containing partial restart${tag}`);
|
|
|
|
}
|
|
|
|
</script>
|