mirror of
https://github.com/servo/servo.git
synced 2025-07-30 10:40:27 +01:00
266 lines
7.2 KiB
HTML
266 lines
7.2 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<meta name="timeout" content="long">
|
|
<title>Mandatory-to-implement stats compliance (a subset of webrtc-stats)</title>
|
|
<script src=/resources/testharness.js></script>
|
|
<script src=/resources/testharnessreport.js></script>
|
|
<script src="RTCPeerConnection-helper.js"></script>
|
|
<script src="dictionary-helper.js"></script>
|
|
<script src="RTCStats-helper.js"></script>
|
|
<script>
|
|
'use strict';
|
|
|
|
// From https://w3c.github.io/webrtc-pc/#mandatory-to-implement-stats
|
|
|
|
const mandatory = {
|
|
RTCRtpStreamStats: [
|
|
"ssrc",
|
|
"kind",
|
|
"transportId",
|
|
"codecId",
|
|
],
|
|
RTCReceivedRtpStreamStats: [
|
|
"packetsReceived",
|
|
"packetsLost",
|
|
"jitter",
|
|
"packetsDiscarded",
|
|
],
|
|
RTCInboundRtpStreamStats: [
|
|
"trackId",
|
|
"receiverId",
|
|
"remoteId",
|
|
"framesDecoded",
|
|
],
|
|
RTCRemoteInboundRtpStreamStats: [
|
|
"localId",
|
|
"roundTripTime",
|
|
],
|
|
RTCSentRtpStreamStats: [
|
|
"packetsSent",
|
|
"bytesSent"
|
|
],
|
|
RTCOutboundRtpStreamStats: [
|
|
"trackId",
|
|
"senderId",
|
|
"remoteId",
|
|
"framesEncoded",
|
|
],
|
|
RTCRemoteOutboundRtpStreamStats: [
|
|
"localId",
|
|
"remoteTimestamp",
|
|
],
|
|
RTCPeerConnectionStats: [
|
|
"dataChannelsOpened",
|
|
"dataChannelsClosed",
|
|
],
|
|
RTCDataChannelStats: [
|
|
"protocol",
|
|
"dataChannelIdentifier",
|
|
"state",
|
|
"messagesSent",
|
|
"bytesSent",
|
|
"messagesReceived",
|
|
"bytesReceived",
|
|
],
|
|
RTCMediaStreamStats: [
|
|
"streamIdentifer",
|
|
"trackIds",
|
|
],
|
|
RTCMediaHandlerStats: [
|
|
"trackIdentifier",
|
|
"remoteSource",
|
|
"ended",
|
|
],
|
|
RTCAudioHandlerStats: [
|
|
"audioLevel",
|
|
],
|
|
RTCVideoHandlerStats: [
|
|
"frameWidth",
|
|
"frameHeight",
|
|
"framesPerSecond",
|
|
],
|
|
RTCVideoSenderStats: [
|
|
"framesSent",
|
|
],
|
|
RTCVideoReceiverStats: [
|
|
"framesReceived",
|
|
"framesDecoded",
|
|
"framesDropped",
|
|
"partialFramesLost",
|
|
],
|
|
RTCCodecStats: [
|
|
"payloadType",
|
|
"codecType",
|
|
"clockRate",
|
|
"channels",
|
|
"sdpFmtpLine",
|
|
],
|
|
RTCTransportStats: [
|
|
"bytesSent",
|
|
"bytesReceived",
|
|
"rtcpTransportStatsId",
|
|
"selectedCandidatePairId",
|
|
"localCertificateId",
|
|
"remoteCertificateId",
|
|
],
|
|
RTCIceCandidatePairStats: [
|
|
"transportId",
|
|
"localCandidateId",
|
|
"remoteCandidateId",
|
|
"state",
|
|
"priority",
|
|
"nominated",
|
|
"bytesSent",
|
|
"bytesReceived",
|
|
"totalRoundTripTime",
|
|
"currentRoundTripTime",
|
|
],
|
|
RTCIceCandidateStats: [
|
|
"address",
|
|
"port",
|
|
"protocol",
|
|
"candidateType",
|
|
"url",
|
|
],
|
|
RTCCertificateStats: [
|
|
"fingerprint",
|
|
"fingerprintAlgorithm",
|
|
"base64Certificate",
|
|
"issuerCertificateId",
|
|
],
|
|
};
|
|
|
|
// From https://w3c.github.io/webrtc-stats/webrtc-stats.html#rtcstatstype-str*
|
|
|
|
const dictionaryNames = {
|
|
"codec": "RTCCodecStats",
|
|
"inbound-rtp": "RTCInboundRtpStreamStats",
|
|
"outbound-rtp": "RTCOutboundRtpStreamStats",
|
|
"remote-inbound-rtp": "RTCRemoteInboundRtpStreamStats",
|
|
"remote-outbound-rtp": "RTCRemoteOutboundRtpStreamStats",
|
|
"csrc": "RTCRtpContributingSourceStats",
|
|
"peer-connection": "RTCPeerConnectionStats",
|
|
"data-channel": "RTCDataChannelStats",
|
|
"stream": "RTCMediaStreamStats",
|
|
"track": {
|
|
video: "RTCSenderVideoTrackAttachmentStats",
|
|
audio: "RTCSenderAudioTrackAttachmentStats"
|
|
},
|
|
"sender": {
|
|
audio: "RTCAudioSenderStats",
|
|
video: "RTCVideoSenderStats"
|
|
},
|
|
"receiver": {
|
|
audio: "RTCAudioReceiverStats",
|
|
video: "RTCVideoReceiverStats",
|
|
},
|
|
"transport": "RTCTransportStats",
|
|
"candidate-pair": "RTCIceCandidatePairStats",
|
|
"local-candidate": "RTCIceCandidateStats",
|
|
"remote-candidate": "RTCIceCandidateStats",
|
|
"certificate": "RTCCertificateStats",
|
|
};
|
|
|
|
// From https://w3c.github.io/webrtc-stats/webrtc-stats.html (webidl)
|
|
|
|
const parents = {
|
|
RTCVideoHandlerStats: "RTCMediaHandlerStats",
|
|
RTCVideoSenderStats: "RTCVideoHandlerStats",
|
|
RTCSenderVideoTrackAttachmentStats: "RTCVideoSenderStats",
|
|
RTCVideoReceiverStats: "RTCVideoHandlerStats",
|
|
RTCAudioHandlerStats: "RTCMediaHandlerStats",
|
|
RTCAudioSenderStats: "RTCAudioHandlerStats",
|
|
RTCSenderAudioTrackAttachmentStats: "RTCAudioSenderStats",
|
|
RTCAudioReceiverStats: "RTCAudioHandlerStats",
|
|
RTCReceivedRtpStreamStats: "RTCRtpStreamStats",
|
|
RTCInboundRtpStreamStats: "RTCReceivedRtpStreamStats",
|
|
RTCRemoteInboundRtpStreamStats: "RTCReceivedRtpStreamStats",
|
|
RTCSentRtpStreamStats: "RTCRtpStreamStats",
|
|
RTCOutboundRtpStreamStats: "RTCSentRtpStreamStats",
|
|
RTCRemoteOutboundRtpStreamStats : "RTCSentRtpStreamStats",
|
|
};
|
|
|
|
const remaining = JSON.parse(JSON.stringify(mandatory));
|
|
for (const dictName in remaining) {
|
|
remaining[dictName] = new Set(remaining[dictName]);
|
|
}
|
|
|
|
async function getAllStats(t, pc) {
|
|
// Try to obtain as many stats as possible, waiting up to 20 seconds for
|
|
// roundTripTime which can take several RTCP messages to calculate.
|
|
let stats;
|
|
for (let i = 0; i < 20; i++) {
|
|
stats = await pc.getStats();
|
|
const values = [...stats.values()];
|
|
const [audio, video] = ["audio", "video"].map(kind =>
|
|
values.find(s => s.type == "remote-inbound-rtp" && s.kind == kind));
|
|
if (audio && "roundTripTime" in audio &&
|
|
video && "roundTripTime" in video) {
|
|
return stats;
|
|
}
|
|
await new Promise(r => t.step_timeout(r, 1000));
|
|
}
|
|
return stats;
|
|
}
|
|
|
|
let succeed;
|
|
const success = new Promise(r => succeed = r);
|
|
|
|
promise_test(async t => {
|
|
const pc1 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc1.close());
|
|
const pc2 = new RTCPeerConnection();
|
|
t.add_cleanup(() => pc2.close());
|
|
|
|
pc1.createDataChannel("dummy", {negotiated: true, id: 0});
|
|
pc2.createDataChannel("dummy", {negotiated: true, id: 0});
|
|
const stream = await getNoiseStream({video: true, audio:true});
|
|
for (const track of stream.getTracks()) {
|
|
pc1.addTrack(track, stream);
|
|
pc2.addTrack(track, stream);
|
|
t.add_cleanup(() => track.stop());
|
|
}
|
|
exchangeIceCandidates(pc1, pc2);
|
|
await doSignalingHandshake(pc1, pc2);
|
|
const stats = await getAllStats(t, pc1);
|
|
|
|
// The focus of this test is not API correctness, but rather to provide an
|
|
// accessible metric of implementation progress by dictionary member. We count
|
|
// whether we've seen each dictionary's mandatory members in getStats().
|
|
|
|
for (const stat of stats.values()) {
|
|
let dictName = dictionaryNames[stat.type];
|
|
if (!dictName) continue;
|
|
if (typeof dictName == "object") {
|
|
dictName = dictName[stat.kind];
|
|
}
|
|
assert_equals(typeof dictName, "string", "Test error. String.");
|
|
if (dictName && mandatory[dictName]) {
|
|
do {
|
|
const memberNames = mandatory[dictName];
|
|
const remainingNames = remaining[dictName];
|
|
assert_true(memberNames.length > 0, "Test error. Parent not found.");
|
|
for (const memberName of memberNames) {
|
|
if (memberName in stat) {
|
|
assert_not_equals(stat[memberName], undefined, "Not undefined");
|
|
remainingNames.delete(memberName);
|
|
}
|
|
}
|
|
dictName = parents[dictName];
|
|
} while (dictName);
|
|
}
|
|
}
|
|
succeed();
|
|
}, 'getStats succeeds');
|
|
|
|
for (const dictName in mandatory) {
|
|
for (const memberName of mandatory[dictName]) {
|
|
promise_test(async t => {
|
|
await success;
|
|
assert_true(!remaining[dictName].has(memberName),
|
|
`Is ${memberName} present`);
|
|
}, `${dictName}'s ${memberName}`);
|
|
}
|
|
}
|
|
|
|
</script>
|