<!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>
Codebase Browser
chromium