mirror of
https://github.com/servo/servo.git
synced 2025-07-22 23:03:42 +01:00
308 lines
13 KiB
HTML
308 lines
13 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>RTCPeerConnection.prototype.setRemoteDescription - add/remove remote tracks</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/20171002/webrtc.html
|
|
|
|
// The following helper functions are called from RTCPeerConnection-helper.js:
|
|
// getUserMediaTracksAndStreams
|
|
// performOffer
|
|
// Resolver
|
|
|
|
// These tests are concerned with the observable consequences of processing
|
|
// the addition or removal of remote tracks, including events firing and the
|
|
// states of RTCPeerConnection, MediaStream and MediaStreamTrack.
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let localTrack = tracks[0];
|
|
caller.addTrack(localTrack);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
let remoteTrack = trackEvent.track;
|
|
assert_equals(remoteTrack.id, localTrack.id,
|
|
'Expected local and remote track IDs to match.');
|
|
assert_equals(trackEvent.streams.length, 0,
|
|
'Expected remote track not to belong to a stream.');
|
|
t.done();
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'addTrack() with a track and no stream makes ontrack fire with a track and no stream.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let localTrack = tracks[0];
|
|
let localStream = streams[0];
|
|
caller.addTrack(localTrack, localStream);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_equals(trackEvent.streams.length, 1,
|
|
'Expected track event to fire with a single stream.');
|
|
let remoteTrack = trackEvent.track;
|
|
let remoteStream = trackEvent.streams[0];
|
|
assert_equals(remoteTrack.id, localTrack.id,
|
|
'Expected local and remote track IDs to match.');
|
|
assert_equals(remoteStream.id, localStream.id,
|
|
'Expected local and remote stream IDs to match.');
|
|
assert_array_equals(remoteStream.getTracks(), [remoteTrack],
|
|
'Expected the remote stream\'s tracks to be the remote track.');
|
|
t.done();
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'addTrack() with a track and a stream makes ontrack fire with a track and a stream.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(2)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let localTrack1 = tracks[0];
|
|
let localTrack2 = tracks[1];
|
|
let localStream = streams[0];
|
|
caller.addTrack(localTrack1, localStream);
|
|
caller.addTrack(localTrack2, localStream);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_equals(trackEvent.streams.length, 1,
|
|
'Expected track event to fire with a single stream.');
|
|
let remoteTrack1 = trackEvent.track;
|
|
let remoteStream = trackEvent.streams[0];
|
|
assert_equals(remoteTrack1.id, localTrack1.id,
|
|
'Expected first remote track ID to match first local track ID.');
|
|
assert_equals(remoteStream.getTracks().length, 2,
|
|
'Expected the remote stream to contain two tracks.');
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_equals(trackEvent.streams.length, 1,
|
|
'Expected track event to fire with a single stream.');
|
|
let remoteTrack2 = trackEvent.track;
|
|
assert_equals(trackEvent.streams[0], remoteStream,
|
|
'Expected both track events to fire with the same remote stream.');
|
|
assert_equals(remoteTrack2.id, localTrack2.id,
|
|
'Expected second remote track ID to match second local track ID.');
|
|
assert_equals(remoteStream.getTracks().length, 2,
|
|
'Expected the remote stream to contain two tracks.');
|
|
assert_array_equals(remoteStream.getTracks(), [remoteTrack1, remoteTrack2],
|
|
'Expected the remote stream\'s tracks to be the [first, second] remote tracks.');
|
|
t.done();
|
|
});
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'addTrack() with two tracks and one stream makes ontrack fire twice with the tracks and shared stream.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(2)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
const localTracks = tracks;
|
|
const localStream = streams[0];
|
|
caller.addTrack(localTracks[0], localStream);
|
|
const offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_equals(trackEvent.streams.length, 1,
|
|
'Expected track event to fire with a single stream.');
|
|
const remoteTracks = [ trackEvent.track ];
|
|
const remoteStream = trackEvent.streams[0];
|
|
assert_equals(remoteTracks[0].id, localTracks[0].id, 'Remote track ID.');
|
|
assert_equals(remoteStream.id, localStream.id, 'Remote stream ID.');
|
|
assert_array_equals(remoteStream.getTracks(), remoteTracks,
|
|
'Expected the remote stream\'s tracks to be the remote track.');
|
|
caller.addTrack(localTracks[1], localStream);
|
|
performOffer(caller, callee);
|
|
remoteStream.onaddtrack = t.step_func(trackEvent => {
|
|
remoteTracks.push(trackEvent.track);
|
|
assert_equals(remoteTracks[1].id, localTracks[1].id, 'Remote track ID.');
|
|
assert_array_equals(remoteStream.getTracks(), remoteTracks,
|
|
'Expected the remote stream\'s tracks to be the remote tracks.');
|
|
t.done();
|
|
});
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'addTrack() for an existing stream makes stream.onaddtrack fire.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(2)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let localTrack = tracks[0];
|
|
let localStreams = streams;
|
|
caller.addTrack(localTrack, localStreams[0], localStreams[1]);
|
|
let performOffer = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_equals(trackEvent.streams.length, 2,
|
|
'Expected the track event to fire with two streams.');
|
|
let remoteTrack = trackEvent.track;
|
|
let remoteStreams = trackEvent.streams;
|
|
assert_equals(remoteTrack.id, localTrack.id,
|
|
'Expected local and remote track IDs to match.');
|
|
assert_equals(remoteStreams[0].id, localStreams[0].id,
|
|
'Expected the first remote stream ID to match the first local stream ID.');
|
|
assert_equals(remoteStreams[1].id, localStreams[1].id,
|
|
'Expected the second remote stream ID to match the second local stream ID.');
|
|
assert_array_equals(remoteStreams[0].getTracks(), [remoteTrack],
|
|
'Expected the remote stream\'s tracks to be the remote track.');
|
|
assert_array_equals(remoteStreams[1].getTracks(), [remoteTrack],
|
|
'Expected the remote stream\'s tracks to be the remote track.');
|
|
t.done();
|
|
});
|
|
return performOffer;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'addTrack() with a track and two streams makes ontrack fire with a track and two streams.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
let eventSequence = '';
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
caller.addTrack(tracks[0]);
|
|
let ontrackResolver = new Resolver();
|
|
callee.ontrack = () => {
|
|
eventSequence += 'ontrack;';
|
|
ontrackResolver.resolve();
|
|
}
|
|
return Promise.all([
|
|
ontrackResolver.promise,
|
|
performOffer(caller, callee).then(() => {
|
|
eventSequence += 'setRemoteDescription;';
|
|
})
|
|
]);
|
|
}))
|
|
.then(t.step_func(() => {
|
|
assert_equals(eventSequence, 'ontrack;setRemoteDescription;');
|
|
t.done();
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'ontrack fires before setRemoteDescription resolves.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
caller.addTrack(tracks[0]);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_array_equals(callee.getReceivers(), [trackEvent.receiver]);
|
|
t.done();
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'ontrack\'s receiver matches getReceivers().');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let sender = caller.addTrack(tracks[0]);
|
|
assert_true(sender != null);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
let receivers = callee.getReceivers();
|
|
assert_equals(receivers.length, 1,
|
|
'Expected getReceivers() to be the track event\'s receiver.');
|
|
caller.removeTrack(sender);
|
|
performOffer(caller, callee)
|
|
.then(t.step_func(() => {
|
|
assert_array_equals(callee.getReceivers(), receivers,
|
|
'Expected the set of receivers to remain the same.');
|
|
t.done();
|
|
}));
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'removeTrack() does not remove the receiver.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let sender = caller.addTrack(tracks[0], streams[0]);
|
|
assert_true(sender != null);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_not_equals(trackEvent.track, null);
|
|
assert_equals(trackEvent.streams.length, 1);
|
|
assert_true(trackEvent.streams[0].getTracks().includes(trackEvent.track));
|
|
caller.removeTrack(sender);
|
|
performOffer(caller, callee);
|
|
trackEvent.streams[0].onremovetrack = t.step_func(removeEvent => {
|
|
assert_equals(removeEvent.track, trackEvent.track);
|
|
assert_false(trackEvent.streams[0].getTracks().includes(trackEvent.track));
|
|
t.done();
|
|
});
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'removeTrack() causes onremovetrack and the track to be removed from the stream.');
|
|
|
|
async_test(t => {
|
|
const caller = new RTCPeerConnection();
|
|
const callee = new RTCPeerConnection();
|
|
return getUserMediaTracksAndStreams(1)
|
|
.then(t.step_func(([tracks, streams]) => {
|
|
let sender = caller.addTrack(tracks[0]);
|
|
assert_true(sender != null);
|
|
let offerPromise = performOffer(caller, callee);
|
|
callee.ontrack = t.step_func(trackEvent => {
|
|
assert_not_equals(trackEvent.track, null);
|
|
caller.removeTrack(sender);
|
|
performOffer(caller, callee);
|
|
trackEvent.track.onmute = t.step_func(() => {
|
|
assert_true(trackEvent.track.muted);
|
|
t.done();
|
|
});
|
|
});
|
|
return offerPromise;
|
|
}))
|
|
.catch(t.step_func(reason => {
|
|
assert_unreached(reason);
|
|
}));
|
|
}, 'removeTrack() causes onmute and the track to be muted.');
|
|
|
|
</script>
|