602 lines
26 KiB
HTML
602 lines
26 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>RTCPeerConnection.prototype.setRemoteDescription rollback</title>
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="RTCPeerConnection-helper.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
// Test is based on the following editor draft:
|
|
// https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
|
|
|
|
// The following helper functions are called from RTCPeerConnection-helper.js:
|
|
// assert_session_desc_similar
|
|
// generateAudioReceiveOnlyOffer
|
|
// generateDataChannelOffer
|
|
|
|
/*
|
|
4.3.2. Interface Definition
|
|
[Constructor(optional RTCConfiguration configuration)]
|
|
interface RTCPeerConnection : EventTarget {
|
|
Promise<void> setLocalDescription(
|
|
RTCSessionDescriptionInit description);
|
|
|
|
readonly attribute RTCSessionDescription? localDescription;
|
|
readonly attribute RTCSessionDescription? currentLocalDescription;
|
|
readonly attribute RTCSessionDescription? pendingLocalDescription;
|
|
|
|
Promise<void> setRemoteDescription(
|
|
RTCSessionDescriptionInit description);
|
|
|
|
readonly attribute RTCSessionDescription? remoteDescription;
|
|
readonly attribute RTCSessionDescription? currentRemoteDescription;
|
|
readonly attribute RTCSessionDescription? pendingRemoteDescription;
|
|
...
|
|
};
|
|
|
|
4.6.2. RTCSessionDescription Class
|
|
dictionary RTCSessionDescriptionInit {
|
|
required RTCSdpType type;
|
|
DOMString sdp = "";
|
|
};
|
|
|
|
4.6.1. RTCSdpType
|
|
enum RTCSdpType {
|
|
"offer",
|
|
"pranswer",
|
|
"answer",
|
|
"rollback"
|
|
};
|
|
*/
|
|
|
|
/*
|
|
4.3.1.6. Set the RTCSessionSessionDescription
|
|
2.2.3. Otherwise, if description is set as a remote description, then run one
|
|
of the following steps:
|
|
- If description is of type "rollback", then this is a rollback.
|
|
Set connection.pendingRemoteDescription to null and signaling state to stable.
|
|
*/
|
|
promise_test(t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
const states = [];
|
|
pc.addEventListener('signalingstatechange', () => states.push(pc.signalingState));
|
|
|
|
return generateDataChannelOffer(pc)
|
|
.then(offer => pc.setRemoteDescription(offer))
|
|
.then(() => {
|
|
assert_equals(pc.signalingState, 'have-remote-offer');
|
|
assert_not_equals(pc.remoteDescription, null);
|
|
assert_equals(pc.pendingRemoteDescription, pc.remoteDescription);
|
|
assert_equals(pc.currentRemoteDescription, null);
|
|
|
|
return pc.setRemoteDescription({type: 'rollback'});
|
|
})
|
|
.then(() => {
|
|
assert_equals(pc.signalingState, 'stable');
|
|
assert_equals(pc.remoteDescription, null);
|
|
assert_equals(pc.pendingRemoteDescription, null);
|
|
assert_equals(pc.currentRemoteDescription, null);
|
|
|
|
assert_array_equals(states, ['have-remote-offer', 'stable']);
|
|
});
|
|
}, 'setRemoteDescription(rollback) in have-remote-offer state should revert to stable state');
|
|
|
|
/*
|
|
4.3.1.6. Set the RTCSessionSessionDescription
|
|
2.3. If the description's type is invalid for the current signaling state of
|
|
connection, then reject p with a newly created InvalidStateError and abort
|
|
these steps.
|
|
|
|
[jsep]
|
|
4.1.8.2. Rollback
|
|
- Rollback can only be used to cancel proposed changes;
|
|
there is no support for rolling back from a stable state to a
|
|
previous stable state
|
|
*/
|
|
promise_test(t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
return promise_rejects_dom(t, 'InvalidStateError',
|
|
pc.setRemoteDescription({type: 'rollback'}));
|
|
}, `setRemoteDescription(rollback) from stable state should reject with InvalidStateError`);
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
await pc.setLocalDescription();
|
|
await promise_rejects_dom(t, 'InvalidStateError', pc.setRemoteDescription({ type: 'rollback' }));
|
|
}, `setRemoteDescription(rollback) after setting a local offer should reject with InvalidStateError`);
|
|
|
|
promise_test(t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
return generateAudioReceiveOnlyOffer(pc)
|
|
.then(offer => pc.setRemoteDescription(offer))
|
|
.then(() => pc.setRemoteDescription({
|
|
type: 'rollback',
|
|
sdp: '!<Invalid SDP Content>;'
|
|
}));
|
|
}, `setRemoteDescription(rollback) should ignore invalid sdp content and succeed`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
// We don't use this right away
|
|
pc1.addTransceiver('audio', { direction: 'recvonly' });
|
|
const offer1 = await pc1.createOffer();
|
|
|
|
// Create offer from pc2, apply and rollback on pc1
|
|
pc2.addTransceiver('audio', { direction: 'recvonly' });
|
|
const offer2 = await pc2.createOffer();
|
|
await pc1.setRemoteDescription(offer2);
|
|
await pc1.setRemoteDescription({type: "rollback"});
|
|
|
|
// Then try applying pc1's old offer
|
|
await pc1.setLocalDescription(offer1);
|
|
}, `local offer created before setRemoteDescription(remote offer) then rollback should still be usable`);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
// We don't use this right away. pc1 has provisionally decided that the
|
|
// (only) transceiver is bound to level 0.
|
|
const offer1 = await pc1.createOffer();
|
|
|
|
// Create offer from pc2, apply and rollback on pc1
|
|
pc2.addTransceiver('audio', { direction: 'recvonly' });
|
|
pc2.addTransceiver('video', { direction: 'recvonly' });
|
|
const offer2 = await pc2.createOffer();
|
|
// pc1 now should change its mind about what level its video transceiver is
|
|
// bound to. It was 0, now it is 1.
|
|
await pc1.setRemoteDescription(offer2);
|
|
|
|
// Rolling back should put things back the way they were.
|
|
await pc1.setRemoteDescription({type: "rollback"});
|
|
|
|
// Then try applying pc1's old offer
|
|
await pc1.setLocalDescription(offer1);
|
|
}, "local offer created before setRemoteDescription(remote offer) with different transceiver level assignments then rollback should still be usable");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 0);
|
|
}, "rollback of a remote offer should remove a transceiver");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
const track = stream2.getVideoTracks()[0];
|
|
await pc2.getTransceivers()[0].sender.replaceTrack(track);
|
|
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 0);
|
|
}, "rollback of a remote offer should remove touched transceiver");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
assert_equals(pc2.getTransceivers()[0].mid, null);
|
|
assert_equals(pc2.getTransceivers()[0].receiver.transport, null);
|
|
}, "rollback of a remote offer should keep a transceiver");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
assert_equals(pc2.getTransceivers()[0].mid, null);
|
|
assert_equals(pc2.getTransceivers()[0].receiver.transport, null);
|
|
}, "rollback of a remote offer should keep a transceiver created by addtrack");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
await pc2.getTransceivers()[0].sender.replaceTrack(null);
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
}, "rollback of a remote offer should keep a transceiver without tracks");
|
|
|
|
promise_test(async t => {
|
|
const pc = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc.close());
|
|
|
|
const stream = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc.addTrack(stream.getTracks()[0], stream);
|
|
|
|
const states = [];
|
|
const signalingstatechangeResolver = new Resolver();
|
|
pc.onsignalingstatechange = () => {
|
|
states.push(pc.signalingState);
|
|
signalingstatechangeResolver.resolve();
|
|
};
|
|
|
|
const offer = await pc.createOffer();
|
|
await pc.setLocalDescription(offer);
|
|
assert_not_equals(pc.getTransceivers()[0].sender.transport, null);
|
|
await pc.setLocalDescription({type: "rollback"});
|
|
assert_equals(pc.getTransceivers().length, 1);
|
|
assert_equals(pc.getTransceivers()[0].mid, null)
|
|
assert_equals(pc.getTransceivers()[0].sender.transport, null);
|
|
await pc.setLocalDescription(offer);
|
|
assert_equals(pc.getTransceivers().length, 1);
|
|
await signalingstatechangeResolver.promise;
|
|
assert_array_equals(states, ['have-local-offer', 'stable', 'have-local-offer']);
|
|
}, "explicit rollback of local offer should remove transceivers and transport");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const states = [];
|
|
const signalingstatechangeResolver = new Resolver();
|
|
pc1.onsignalingstatechange = () => {
|
|
states.push(pc1.signalingState);
|
|
signalingstatechangeResolver.resolve();
|
|
};
|
|
const stream1 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTransceiver(stream1.getTracks()[0], stream1);
|
|
|
|
const stream2 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTransceiver(stream2.getTracks()[0], stream2);
|
|
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
pc1.onnegotiationneeded = t.step_func(() => assert_true(false, "There should be no negotiationneeded event right now"));
|
|
await pc1.setRemoteDescription(await pc2.createOffer());
|
|
await pc1.setLocalDescription(await pc1.createAnswer());
|
|
await signalingstatechangeResolver.promise;
|
|
assert_array_equals(states, ['have-local-offer', 'stable', 'have-remote-offer', 'stable']);
|
|
await new Promise(r => pc1.onnegotiationneeded = r);
|
|
}, "when using addTransceiver, implicit rollback of a local offer should visit stable state, but not fire negotiationneeded until we settle in stable");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const states = [];
|
|
const signalingstatechangeResolver = new Resolver();
|
|
pc1.onsignalingstatechange = () => {
|
|
states.push(pc1.signalingState);
|
|
signalingstatechangeResolver.resolve();
|
|
};
|
|
const stream1 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream1.getTracks()[0], stream1);
|
|
|
|
const stream2 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
pc1.onnegotiationneeded = t.step_func(() => assert_true(false, "There should be no negotiationneeded event in this test"));
|
|
await pc1.setRemoteDescription(await pc2.createOffer());
|
|
await pc1.setLocalDescription(await pc1.createAnswer());
|
|
assert_array_equals(states, ['have-local-offer', 'stable', 'have-remote-offer', 'stable']);
|
|
await new Promise(r => t.step_timeout(r, 0));
|
|
}, "when using addTrack, implicit rollback of a local offer should visit stable state, but not fire negotiationneeded");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
|
|
await pc2.setLocalDescription(await pc2.createAnswer());
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
|
|
// In stable state add video on both end and make sure video transceiver is not killed.
|
|
|
|
const stream1 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream1.getTracks()[0], stream1);
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
const offer2 = await pc2.createOffer();
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 2);
|
|
await pc2.setLocalDescription(offer2);
|
|
}, "rollback of a remote offer to negotiated stable state should enable " +
|
|
"applying of a local offer");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
|
|
await pc2.setLocalDescription(await pc2.createAnswer());
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
|
|
// Both ends want to add video at the same time. pc2 rolls back.
|
|
|
|
const stream2 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
await pc2.setLocalDescription(await pc2.createOffer());
|
|
assert_equals(pc2.getTransceivers().length, 2);
|
|
assert_not_equals(pc2.getTransceivers()[1].sender.transport, null);
|
|
await pc2.setLocalDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 2);
|
|
// Rollback didn't touch audio transceiver and transport is intact.
|
|
assert_not_equals(pc2.getTransceivers()[0].sender.transport, null);
|
|
// Video transport got killed.
|
|
assert_equals(pc2.getTransceivers()[1].sender.transport, null);
|
|
const stream1 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream1.getTracks()[0], stream1);
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
}, "rollback of a local offer to negotiated stable state should enable " +
|
|
"applying of a remote offer");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream.getTracks()[0], stream);
|
|
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
|
|
await pc2.setLocalDescription(await pc2.createAnswer());
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
|
|
// pc1 adds video and pc2 adds audio. pc2 rolls back.
|
|
assert_equals(pc2.getTransceivers()[0].direction, "recvonly");
|
|
const stream2 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc2.addTrack(stream2.getTracks()[0], stream2);
|
|
assert_equals(pc2.getTransceivers()[0].direction, "sendrecv");
|
|
await pc2.setLocalDescription(await pc2.createOffer());
|
|
assert_equals(pc2.getTransceivers()[0].direction, "sendrecv");
|
|
await pc2.setLocalDescription({type: "rollback"});
|
|
assert_equals(pc2.getTransceivers().length, 1);
|
|
// setLocalDescription didn't change direction. So direction remains "sendrecv"
|
|
assert_equals(pc2.getTransceivers()[0].direction, "sendrecv");
|
|
// Rollback didn't touch audio transceiver and transport is intact. Still can receive audio.
|
|
assert_not_equals(pc2.getTransceivers()[0].receiver.transport, null);
|
|
const stream1 = await getNoiseStream({video: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream1.getTracks()[0], stream1);
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
}, "rollback a local offer with audio direction change to negotiated " +
|
|
"stable state and then add video receiver");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.addTransceiver('video', {direction: 'sendonly'});
|
|
pc2.addTransceiver('video', {direction: 'sendonly'});
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
const pc1FirstMid = pc1.getTransceivers()[0].mid;
|
|
await pc2.setLocalDescription(await pc2.createOffer());
|
|
const pc2FirstMid = pc2.getTransceivers()[0].mid;
|
|
// I don't think it is mandated that this has to be true, but any implementation I know of would
|
|
// have predictable mids (e.g. 0, 1, 2...) so pc1 and pc2 should offer with the same mids.
|
|
assert_equals(pc1FirstMid, pc2FirstMid);
|
|
await pc1.setRemoteDescription(pc2.pendingLocalDescription);
|
|
// We've implicitly rolled back and the SRD caused a second transceiver to be created.
|
|
// As such, the first transceiver's mid will now be null, and the second transceiver's mid will
|
|
// match the remote offer.
|
|
assert_equals(pc1.getTransceivers().length, 2);
|
|
assert_equals(pc1.getTransceivers()[0].mid, null);
|
|
assert_equals(pc1.getTransceivers()[1].mid, pc2FirstMid);
|
|
// If we now do an offer the first transceiver will get a different mid than in the first
|
|
// pc1.createOffer()!
|
|
pc1.setLocalDescription(await pc1.createAnswer());
|
|
await pc1.setLocalDescription(await pc1.createOffer());
|
|
assert_not_equals(pc1.getTransceivers()[0].mid, pc1FirstMid);
|
|
}, "two transceivers with same mids");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
t.add_cleanup(() => pc2.close());
|
|
const stream = await getNoiseStream({audio: true, video: true});
|
|
t.add_cleanup(() => stream.getTracks().forEach(track => track.stop()));
|
|
const audio = stream.getAudioTracks()[0];
|
|
pc1.addTrack(audio, stream);
|
|
const video = stream.getVideoTracks()[0];
|
|
pc1.addTrack(video, stream);
|
|
|
|
let remoteStream = null;
|
|
pc2.ontrack = e => { remoteStream = e.streams[0]; }
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_true(remoteStream != null);
|
|
let remoteTracks = remoteStream.getTracks();
|
|
const removedTracks = [];
|
|
remoteStream.onremovetrack = e => { removedTracks.push(e.track.id); }
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(removedTracks.length, 2,
|
|
"Rollback should have removed two tracks");
|
|
assert_true(removedTracks.includes(remoteTracks[0].id),
|
|
"First track should be removed");
|
|
assert_true(removedTracks.includes(remoteTracks[1].id),
|
|
"Second track should be removed");
|
|
|
|
}, "onremovetrack fires during remote rollback");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
const stream1 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream1.getTracks().forEach(track => track.stop()));
|
|
pc1.addTrack(stream1.getTracks()[0], stream1);
|
|
|
|
const offer1 = await pc1.createOffer();
|
|
|
|
const remoteStreams = [];
|
|
pc2.ontrack = e => { remoteStreams.push(e.streams[0]); }
|
|
|
|
await pc1.setLocalDescription(offer1);
|
|
await pc2.setRemoteDescription(pc1.pendingLocalDescription);
|
|
await pc2.setLocalDescription(await pc2.createAnswer());
|
|
await pc1.setRemoteDescription(pc2.localDescription);
|
|
|
|
assert_equals(remoteStreams.length, 1, "Number of remote streams");
|
|
assert_equals(remoteStreams[0].getTracks().length, 1, "Number of remote tracks");
|
|
const track = remoteStreams[0].getTracks()[0];
|
|
|
|
const stream2 = await getNoiseStream({audio: true});
|
|
t.add_cleanup(() => stream2.getTracks().forEach(track => track.stop()));
|
|
pc1.getTransceivers()[0].sender.setStreams(stream2);
|
|
|
|
const offer2 = await pc1.createOffer();
|
|
await pc2.setRemoteDescription(offer2);
|
|
|
|
assert_equals(remoteStreams.length, 2);
|
|
assert_equals(remoteStreams[0].getTracks().length, 0);
|
|
assert_equals(remoteStreams[1].getTracks()[0].id, track.id);
|
|
await pc2.setRemoteDescription({type: "rollback"});
|
|
assert_equals(remoteStreams.length, 3);
|
|
assert_equals(remoteStreams[0].id, remoteStreams[2].id);
|
|
assert_equals(remoteStreams[1].getTracks().length, 0);
|
|
assert_equals(remoteStreams[2].getTracks().length, 1);
|
|
assert_equals(remoteStreams[2].getTracks()[0].id, track.id);
|
|
|
|
}, "rollback of a remote offer with stream changes");
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
pc2.addTransceiver('audio');
|
|
const offer = await pc2.createOffer();
|
|
await pc1.setRemoteDescription(offer);
|
|
const [transceiver] = pc1.getTransceivers();
|
|
pc1.setRemoteDescription({type:'rollback'});
|
|
pc1.removeTrack(transceiver.sender);
|
|
}, 'removeTrack() with a sender being rolled back does not crash or throw');
|
|
|
|
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 channel = pc2.createDataChannel('dummy');
|
|
await pc2.setLocalDescription(await pc2.createOffer());
|
|
await pc2.setRemoteDescription(await pc1.createOffer());
|
|
assert_equals(pc2.signalingState, 'have-remote-offer');
|
|
await pc2.setLocalDescription(await pc2.createAnswer());
|
|
await pc2.setLocalDescription(await pc2.createOffer());
|
|
assert_equals(channel.readyState, 'connecting');
|
|
}, 'Implicit rollback with only a datachannel works');
|
|
|
|
</script>
|