| 'use strict'; |
| |
| // Test is based on the following editor draft: |
| // webrtc-pc 20171130 |
| // webrtc-stats 20171122 |
| |
| // This file depends on dictionary-helper.js which should |
| // be loaded from the main HTML file. |
| |
| /* |
| [webrtc-stats] |
| 6.1. RTCStatsType enum |
| enum RTCStatsType { |
| "codec", |
| "inbound-rtp", |
| "outbound-rtp", |
| "remote-inbound-rtp", |
| "remote-outbound-rtp", |
| "csrc", |
| "peer-connection", |
| "data-channel", |
| "stream", |
| "track", |
| "transport", |
| "candidate-pair", |
| "local-candidate", |
| "remote-candidate", |
| "certificate" |
| }; |
| */ |
| const statsValidatorTable = { |
| 'codec': validateCodecStats, |
| 'inbound-rtp': validateInboundRtpStreamStats, |
| 'outbound-rtp': validateOutboundRtpStreamStats, |
| 'remote-inbound-rtp': validateRemoteInboundRtpStreamStats, |
| 'remote-outbound-rtp': validateRemoteOutboundRtpStreamStats, |
| 'csrc': validateContributingSourceStats, |
| 'peer-connection': validatePeerConnectionStats, |
| 'data-channel': validateDataChannelStats, |
| 'stream': validateMediaStreamStats, |
| 'track': validateMediaStreamTrackStats, |
| 'transport': validateTransportStats, |
| 'candidate-pair': validateIceCandidatePairStats, |
| 'local-candidate': validateIceCandidateStats, |
| 'remote-candidate': validateIceCandidateStats, |
| 'certificate': validateCertificateStats |
| }; |
| |
| // Validate that the stats objects in a stats report |
| // follows the respective definitions. |
| // Stats objects with unknown type are ignored and |
| // only basic validation is done. |
| function validateStatsReport(statsReport) { |
| for(const [id, stats] of statsReport.entries()) { |
| assert_equals(stats.id, id, |
| 'expect stats.id to be the same as the key in statsReport'); |
| |
| const validator = statsValidatorTable[stats.type]; |
| if(validator) { |
| validator(statsReport, stats); |
| } else { |
| validateRtcStats(statsReport, stats); |
| } |
| } |
| } |
| |
| // Assert that the stats report have stats objects of |
| // given types |
| function assert_stats_report_has_stats(statsReport, statsTypes) { |
| const hasTypes = new Set([...statsReport.values()] |
| .map(stats => stats.type)); |
| |
| for(const type of statsTypes) { |
| assert_true(hasTypes.has(type), |
| `Expect statsReport to contain stats object of type ${type}`); |
| } |
| } |
| |
| function findStatsFromReport(statsReport, predicate, message) { |
| for (const stats of statsReport.values()) { |
| if (predicate(stats)) { |
| return stats; |
| } |
| } |
| |
| assert_unreached(message || 'none of stats in statsReport satisfy given condition') |
| } |
| |
| // Get stats object of type that is expected to be |
| // found in the statsReport |
| function getRequiredStats(statsReport, type) { |
| for(const stats of statsReport.values()) { |
| if(stats.type === type) { |
| return stats; |
| } |
| } |
| |
| assert_unreached(`required stats of type ${type} is not found in stats report`); |
| } |
| |
| // Get stats object by the stats ID. |
| // This is used to retreive other stats objects |
| // linked to a stats object |
| function getStatsById(statsReport, statsId) { |
| assert_true(statsReport.has(statsId), |
| `Expect stats report to have stats object with id ${statsId}`); |
| |
| return statsReport.get(statsId); |
| } |
| |
| // Validate an ID field in a stats object by making sure |
| // that the linked stats object is found in the stats report |
| // and have the type field value same as expected type |
| // It doesn't validate the other fields of the linked stats |
| // as validateStatsReport already does all validations |
| function validateIdField(statsReport, stats, field, type) { |
| assert_string_field(stats, field); |
| const linkedStats = getStatsById(statsReport, stats[field]); |
| assert_equals(linkedStats.type, type, |
| `Expect linked stats object to have type ${type}`); |
| } |
| |
| function validateOptionalIdField(statsReport, stats, field, type) { |
| if(stats[field] !== undefined) { |
| validateIdField(statsReport, stats, field, type); |
| } |
| } |
| |
| /* |
| [webrtc-pc] |
| 8.4. RTCStats Dictionary |
| dictionary RTCStats { |
| required DOMHighResTimeStamp timestamp; |
| required RTCStatsType type; |
| required DOMString id; |
| }; |
| */ |
| function validateRtcStats(statsReport, stats) { |
| assert_number_field(stats, 'timestamp'); |
| assert_string_field(stats, 'type'); |
| assert_string_field(stats, 'id'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.1. RTCRTPStreamStats dictionary |
| dictionary RTCRTPStreamStats : RTCStats { |
| unsigned long ssrc; |
| DOMString mediaType; |
| DOMString trackId; |
| DOMString transportId; |
| DOMString codecId; |
| unsigned long firCount; |
| unsigned long pliCount; |
| unsigned long nackCount; |
| unsigned long sliCount; |
| unsigned long long qpSum; |
| }; |
| |
| mediaType of type DOMString |
| Either "audio" or "video". |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCRTPStreamStats, with attributes ssrc, mediaType, trackId, |
| transportId, codecId, nackCount |
| */ |
| function validateRtpStreamStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_unsigned_int_field(stats, 'ssrc'); |
| assert_string_field(stats, 'mediaType'); |
| assert_enum_field(stats, 'mediaType', ['audio', 'video']) |
| |
| validateIdField(statsReport, stats, 'trackId', 'track'); |
| validateIdField(statsReport, stats, 'transportId', 'transport'); |
| validateIdField(statsReport, stats, 'codecId', 'codec'); |
| |
| assert_optional_unsigned_int_field(stats, 'firCount'); |
| assert_optional_unsigned_int_field(stats, 'pliCount'); |
| assert_optional_unsigned_int_field(stats, 'nackCount'); |
| assert_optional_unsigned_int_field(stats, 'sliCount'); |
| assert_optional_unsigned_int_field(stats, 'qpSum'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.2. RTCCodecStats dictionary |
| dictionary RTCCodecStats : RTCStats { |
| unsigned long payloadType; |
| RTCCodecType codecType; |
| DOMString transportId; |
| DOMString mimeType; |
| unsigned long clockRate; |
| unsigned long channels; |
| DOMString sdpFmtpLine; |
| DOMString implementation; |
| }; |
| |
| enum RTCCodecType { |
| "encode", |
| "decode", |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCCodecStats, with attributes payloadType, codec, clockRate, channels, sdpFmtpLine |
| */ |
| |
| function validateCodecStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_unsigned_int_field(stats, 'payloadType'); |
| assert_optional_enum_field(stats, 'codecType', ['encode', 'decode']); |
| |
| validateOptionalIdField(statsReport, stats, 'transportId', 'transport'); |
| |
| assert_optional_string_field(stats, 'mimeType'); |
| assert_unsigned_int_field(stats, 'clockRate'); |
| assert_optional_unsigned_int_field(stats, 'channels'); |
| |
| assert_optional_string_field(stats, 'sdpFmtpLine'); |
| assert_optional_string_field(stats, 'implementation'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.3. RTCReceivedRTPStreamStats dictionary |
| dictionary RTCReceivedRTPStreamStats : RTCRTPStreamStats { |
| unsigned long packetsReceived; |
| unsigned long long bytesReceived; |
| long packetsLost; |
| double jitter; |
| double fractionLost; |
| unsigned long packetsDiscarded; |
| unsigned long packetsFailedDecryption; |
| unsigned long packetsRepaired; |
| unsigned long burstPacketsLost; |
| unsigned long burstPacketsDiscarded; |
| unsigned long burstLossCount; |
| unsigned long burstDiscardCount; |
| double burstLossRate; |
| double burstDiscardRate; |
| double gapLossRate; |
| double gapDiscardRate; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCReceivedRTPStreamStats, with all required attributes from its |
| inherited dictionaries, and also attributes packetsReceived, |
| bytesReceived, packetsLost, jitter, packetsDiscarded |
| */ |
| function validateReceivedRtpStreamStats(statsReport, stats) { |
| validateRtpStreamStats(statsReport, stats); |
| |
| assert_unsigned_int_field(stats, 'packetsReceived'); |
| assert_unsigned_int_field(stats, 'bytesReceived'); |
| assert_unsigned_int_field(stats, 'packetsLost'); |
| |
| assert_number_field(stats, 'jitter'); |
| assert_optional_number_field(stats, 'fractionLost'); |
| |
| assert_unsigned_int_field(stats, 'packetsDiscarded'); |
| assert_optional_unsigned_int_field(stats, 'packetsFailedDecryption'); |
| assert_optional_unsigned_int_field(stats, 'packetsRepaired'); |
| assert_optional_unsigned_int_field(stats, 'burstPacketsLost'); |
| assert_optional_unsigned_int_field(stats, 'burstPacketsDiscarded'); |
| assert_optional_unsigned_int_field(stats, 'burstLossCount'); |
| assert_optional_unsigned_int_field(stats, 'burstDiscardCount'); |
| |
| assert_optional_number_field(stats, 'burstLossRate'); |
| assert_optional_number_field(stats, 'burstDiscardRate'); |
| assert_optional_number_field(stats, 'gapLossRate'); |
| assert_optional_number_field(stats, 'gapDiscardRate'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.4. RTCInboundRTPStreamStats dictionary |
| dictionary RTCInboundRTPStreamStats : RTCReceivedRTPStreamStats { |
| DOMString remoteId; |
| unsigned long framesDecoded; |
| DOMHighResTimeStamp lastPacketReceivedTimestamp; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCInboundRTPStreamStats, with all required attributes from its inherited |
| dictionaries, and also attributes remoteId, framesDecoded |
| */ |
| function validateInboundRtpStreamStats(statsReport, stats) { |
| validateReceivedRtpStreamStats(statsReport, stats); |
| |
| validateIdField(statsReport, stats, 'remoteId', 'remote-outbound-rtp'); |
| assert_unsigned_int_field(stats, 'framesDecoded'); |
| assert_optional_number_field(stats, 'lastPacketReceivedTimeStamp'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.5. RTCRemoteInboundRTPStreamStats dictionary |
| dictionary RTCRemoteInboundRTPStreamStats : RTCReceivedRTPStreamStats { |
| DOMString localId; |
| double roundTripTime; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCRemoteInboundRTPStreamStats, with all required attributes from its |
| inherited dictionaries, and also attributes localId, roundTripTime |
| */ |
| function validateRemoteInboundRtpStreamStats(statsReport, stats) { |
| validateReceivedRtpStreamStats(statsReport, stats); |
| |
| validateIdField(statsReport, stats, 'localId', 'outbound-rtp'); |
| assert_number_field(stats, 'roundTripTime'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.6. RTCSentRTPStreamStats dictionary |
| dictionary RTCSentRTPStreamStats : RTCRTPStreamStats { |
| unsigned long packetsSent; |
| unsigned long packetsDiscardedOnSend; |
| unsigned long long bytesSent; |
| unsigned long long bytesDiscardedOnSend; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCSentRTPStreamStats, with all required attributes from its inherited |
| dictionaries, and also attributes packetsSent, bytesSent |
| */ |
| function validateSentRtpStreamStats(statsReport, stats) { |
| validateRtpStreamStats(statsReport, stats); |
| |
| assert_unsigned_int_field(stats, 'packetsSent'); |
| assert_optional_unsigned_int_field(stats, 'packetsDiscardedOnSend'); |
| assert_unsigned_int_field(stats, 'bytesSent'); |
| assert_optional_unsigned_int_field(stats, 'bytesDiscardedOnSend'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.7. RTCOutboundRTPStreamStats dictionary |
| dictionary RTCOutboundRTPStreamStats : RTCSentRTPStreamStats { |
| DOMString remoteId; |
| DOMHighResTimeStamp lastPacketSentTimestamp; |
| double targetBitrate; |
| unsigned long framesEncoded; |
| double totalEncodeTime; |
| double averageRTCPInterval; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCOutboundRTPStreamStats, with all required attributes from its |
| inherited dictionaries, and also attributes remoteId, framesEncoded |
| */ |
| function validateOutboundRtpStreamStats(statsReport, stats) { |
| validateSentRtpStreamStats(statsReport, stats) |
| |
| validateIdField(statsReport, stats, 'remoteId', 'remote-inbound-rtp'); |
| |
| assert_optional_number_field(stats, 'lastPacketSentTimestamp'); |
| assert_optional_number_field(stats, 'targetBitrate'); |
| if (stats['mediaType'] == 'video') { |
| assert_unsigned_int_field(stats, 'framesEncoded'); |
| } |
| assert_optional_number_field(stats, 'totalEncodeTime'); |
| assert_optional_number_field(stats, 'averageRTCPInterval'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.8. RTCRemoteOutboundRTPStreamStats dictionary |
| dictionary RTCRemoteOutboundRTPStreamStats : RTCSentRTPStreamStats { |
| DOMString localId; |
| DOMHighResTimeStamp remoteTimestamp; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCRemoteOutboundRTPStreamStats, with all required attributes from its |
| inherited dictionaries, and also attributes localId, remoteTimestamp |
| */ |
| function validateRemoteOutboundRtpStreamStats(statsReport, stats) { |
| validateSentRtpStreamStats(statsReport, stats); |
| |
| validateIdField(statsReport, stats, 'localId', 'inbound-rtp'); |
| assert_number_field(stats, 'remoteTimeStamp'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.9. RTCRTPContributingSourceStats |
| dictionary RTCRTPContributingSourceStats : RTCStats { |
| unsigned long contributorSsrc; |
| DOMString inboundRtpStreamId; |
| unsigned long packetsContributedTo; |
| double audioLevel; |
| }; |
| */ |
| function validateContributingSourceStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_optional_unsigned_int_field(stats, 'contributorSsrc'); |
| |
| validateOptionalIdField(statsReport, stats, 'inboundRtpStreamId', 'inbound-rtp'); |
| assert_optional_unsigned_int_field(stats, 'packetsContributedTo'); |
| assert_optional_number_field(stats, 'audioLevel'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.10. RTCPeerConnectionStats dictionary |
| dictionary RTCPeerConnectionStats : RTCStats { |
| unsigned long dataChannelsOpened; |
| unsigned long dataChannelsClosed; |
| unsigned long dataChannelsRequested; |
| unsigned long dataChannelsAccepted; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCPeerConnectionStats, with attributes dataChannelsOpened, dataChannelsClosed |
| */ |
| function validatePeerConnectionStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_unsigned_int_field(stats, 'dataChannelsOpened'); |
| assert_unsigned_int_field(stats, 'dataChannelsClosed'); |
| assert_optional_unsigned_int_field(stats, 'dataChannelsRequested'); |
| assert_optional_unsigned_int_field(stats, 'dataChannelsAccepted'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.11. RTCMediaStreamStats dictionary |
| dictionary RTCMediaStreamStats : RTCStats { |
| DOMString streamIdentifier; |
| sequence<DOMString> trackIds; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCMediaStreamStats, with attributes streamIdentifer, trackIds |
| */ |
| function validateMediaStreamStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_string_field(stats, 'streamIdentifier'); |
| assert_array_field(stats, 'trackIds'); |
| |
| for(const trackId of stats.trackIds) { |
| assert_equals(typeof trackId, 'string', |
| 'Expect trackId elements to be string'); |
| |
| assert_true(statsReport.has(trackId), |
| `Expect stats report to have stats object with id ${trackId}`); |
| |
| const trackStats = statsReport.get(trackId); |
| assert_equals(trackStats.type, 'track', |
| `Expect track stats object to have type 'track'`); |
| } |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.12. RTCMediaStreamTrackStats dictionary |
| dictionary RTCMediaStreamTrackStats : RTCStats { |
| DOMString trackIdentifier; |
| boolean remoteSource; |
| boolean ended; |
| boolean detached; |
| DOMString kind; |
| DOMHighResTimeStamp estimatedPlayoutTimestamp; |
| unsigned long frameWidth; |
| unsigned long frameHeight; |
| double framesPerSecond; |
| unsigned long framesCaptured; |
| unsigned long framesSent; |
| unsigned long keyFramesSent; |
| unsigned long framesReceived; |
| unsigned long keyFramesReceived; |
| unsigned long framesDecoded; |
| unsigned long framesDropped; |
| unsigned long framesCorrupted; |
| unsigned long partialFramesLost; |
| unsigned long fullFramesLost; |
| double audioLevel; |
| double totalAudioEnergy; |
| boolean voiceActivityFlag; |
| double echoReturnLoss; |
| double echoReturnLossEnhancement; |
| unsigned long long totalSamplesSent; |
| unsigned long long totalSamplesReceived; |
| double totalSamplesDuration; |
| unsigned long long concealedSamples; |
| unsigned long long concealmentEvents; |
| double jitterBufferDelay; |
| RTCPriorityType priority; |
| }; |
| |
| [webrtc-pc] |
| 4.9.1. RTCPriorityType Enum |
| enum RTCPriorityType { |
| "very-low", |
| "low", |
| "medium", |
| "high" |
| }; |
| |
| 8.6. Mandatory To Implement Stats |
| - RTCMediaStreamTrackStats, with attributes trackIdentifier, remoteSource, |
| ended, detached, frameWidth, frameHeight, framesPerSecond, framesSent, |
| framesReceived, framesDecoded, framesDropped, framesCorrupted, audioLevel |
| */ |
| |
| function validateMediaStreamTrackStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_string_field(stats, 'trackIdentifier'); |
| assert_boolean_field(stats, 'remoteSource'); |
| assert_boolean_field(stats, 'ended'); |
| assert_boolean_field(stats, 'detached'); |
| |
| assert_optional_enum_field(stats, 'kind', ['audio', 'video']); |
| assert_optional_number_field(stats, 'estimatedPlayoutTimestamp'); |
| if (stats['kind'] === 'video') { |
| assert_unsigned_int_field(stats, 'frameWidth'); |
| assert_unsigned_int_field(stats, 'frameHeight'); |
| assert_number_field(stats, 'framesPerSecond'); |
| if (stats['framesSent']) { |
| assert_optional_unsigned_int_field(stats, 'framesCaptured'); |
| assert_unsigned_int_field(stats, 'framesSent'); |
| assert_optional_unsigned_int_field(stats, 'keyFramesSent'); |
| } else { |
| assert_unsigned_int_field(stats, 'framesReceived'); |
| assert_optional_unsigned_int_field(stats, 'keyFramesReceived'); |
| assert_unsigned_int_field(stats, 'framesDecoded'); |
| assert_unsigned_int_field(stats, 'framesDropped'); |
| assert_unsigned_int_field(stats, 'framesCorrupted'); |
| } |
| |
| assert_optional_unsigned_int_field(stats, 'partialFramesLost'); |
| assert_optional_unsigned_int_field(stats, 'fullFramesLost'); |
| } else { |
| assert_number_field(stats, 'audioLevel'); |
| assert_optional_number_field(stats, 'totalAudioEnergy'); |
| assert_optional_boolean_field(stats, 'voiceActivityFlag'); |
| assert_optional_number_field(stats, 'echoReturnLoss'); |
| assert_optional_number_field(stats, 'echoReturnLossEnhancement'); |
| |
| assert_optional_unsigned_int_field(stats, 'totalSamplesSent'); |
| assert_optional_unsigned_int_field(stats, 'totalSamplesReceived'); |
| assert_optional_number_field(stats, 'totalSamplesDuration'); |
| assert_optional_unsigned_int_field(stats, 'concealedSamples'); |
| assert_optional_unsigned_int_field(stats, 'concealmentEvents'); |
| assert_optional_number_field(stats, 'jitterBufferDelay'); |
| } |
| |
| assert_optional_enum_field(stats, 'priority', |
| ['very-low', 'low', 'medium', 'high']); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.13. RTCDataChannelStats dictionary |
| dictionary RTCDataChannelStats : RTCStats { |
| DOMString label; |
| DOMString protocol; |
| long dataChannelIdentifier; |
| DOMString transportId; |
| RTCDataChannelState state; |
| unsigned long messagesSent; |
| unsigned long long bytesSent; |
| unsigned long messagesReceived; |
| unsigned long long bytesReceived; |
| }; |
| |
| [webrtc-pc] |
| 6.2. RTCDataChannel |
| enum RTCDataChannelState { |
| "connecting", |
| "open", |
| "closing", |
| "closed" |
| }; |
| |
| 8.6. Mandatory To Implement Stats |
| - RTCDataChannelStats, with attributes label, protocol, datachannelId, state, |
| messagesSent, bytesSent, messagesReceived, bytesReceived |
| */ |
| function validateDataChannelStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_string_field(stats, 'label'); |
| assert_string_field(stats, 'protocol'); |
| assert_int_field(stats, 'dataChannelIdentifier'); |
| |
| validateOptionalIdField(statsReport, stats, 'transportId', 'transport'); |
| |
| assert_enum_field(stats, 'state', |
| ['connecting', 'open', 'closing', 'closed']); |
| |
| assert_unsigned_int_field(stats, 'messagesSent'); |
| assert_unsigned_int_field(stats, 'bytesSent'); |
| assert_unsigned_int_field(stats, 'messagesReceived'); |
| assert_unsigned_int_field(stats, 'bytesReceived'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.14. RTCTransportStats dictionary |
| dictionary RTCTransportStats : RTCStats { |
| unsigned long packetsSent; |
| unsigned long packetsReceived; |
| unsigned long long bytesSent; |
| unsigned long long bytesReceived; |
| DOMString rtcpTransportStatsId; |
| RTCIceRole iceRole; |
| RTCDtlsTransportState dtlsState; |
| DOMString selectedCandidatePairId; |
| DOMString localCertificateId; |
| DOMString remoteCertificateId; |
| }; |
| |
| [webrtc-pc] |
| 5.5. RTCDtlsTransportState Enum |
| enum RTCDtlsTransportState { |
| "new", |
| "connecting", |
| "connected", |
| "closed", |
| "failed" |
| }; |
| |
| 5.6. RTCIceRole Enum |
| enum RTCIceRole { |
| "controlling", |
| "controlled" |
| }; |
| |
| 8.6. Mandatory To Implement Stats |
| - RTCTransportStats, with attributes bytesSent, bytesReceived, |
| rtcpTransportStatsId, selectedCandidatePairId, localCertificateId, |
| remoteCertificateId |
| */ |
| function validateTransportStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_optional_unsigned_int_field(stats, 'packetsSent'); |
| assert_optional_unsigned_int_field(stats, 'packetsReceived'); |
| assert_unsigned_int_field(stats, 'bytesSent'); |
| assert_unsigned_int_field(stats, 'bytesReceived'); |
| |
| validateOptionalIdField(statsReport, stats, 'rtcpTransportStatsId', |
| 'transport'); |
| |
| assert_optional_enum_field(stats, 'iceRole', |
| ['controlling', 'controlled']); |
| |
| assert_optional_enum_field(stats, 'dtlsState', |
| ['new', 'connecting', 'connected', 'closed', 'failed']); |
| |
| validateIdField(statsReport, stats, 'selectedCandidatePairId', 'candidate-pair'); |
| validateIdField(statsReport, stats, 'localCertificateId', 'certificate'); |
| validateIdField(statsReport, stats, 'remoteCertificateId', 'certificate'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.15. RTCIceCandidateStats dictionary |
| dictionary RTCIceCandidateStats : RTCStats { |
| DOMString transportId; |
| boolean isRemote; |
| RTCNetworkType networkType; |
| DOMString ip; |
| long port; |
| DOMString protocol; |
| RTCIceCandidateType candidateType; |
| long priority; |
| DOMString url; |
| DOMString relayProtocol; |
| boolean deleted = false; |
| }; |
| |
| enum RTCNetworkType { |
| "bluetooth", |
| "cellular", |
| "ethernet", |
| "wifi", |
| "wimax", |
| "vpn", |
| "unknown" |
| }; |
| |
| [webrtc-pc] |
| 4.8.1.3. RTCIceCandidateType Enum |
| enum RTCIceCandidateType { |
| "host", |
| "srflx", |
| "prflx", |
| "relay" |
| }; |
| |
| 8.6. Mandatory To Implement Stats |
| - RTCIceCandidateStats, with attributes ip, port, protocol, candidateType, |
| priority, url |
| */ |
| function validateIceCandidateStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| validateOptionalIdField(statsReport, stats, 'transportId', 'transport'); |
| assert_optional_boolean_field(stats, 'isRemote'); |
| |
| assert_optional_enum_field(stats, 'networkType', |
| ['bluetooth', 'cellular', 'ethernet', 'wifi', 'wimax', 'vpn', 'unknown']) |
| |
| assert_string_field(stats, 'ip'); |
| assert_int_field(stats, 'port'); |
| assert_string_field(stats, 'protocol'); |
| |
| assert_enum_field(stats, 'candidateType', |
| ['host', 'srflx', 'prflx', 'relay']); |
| |
| assert_int_field(stats, 'priority'); |
| assert_optional_string_field(stats, 'url'); |
| assert_optional_string_field(stats, 'relayProtocol'); |
| assert_optional_boolean_field(stats, 'deleted'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.16. RTCIceCandidatePairStats dictionary |
| dictionary RTCIceCandidatePairStats : RTCStats { |
| DOMString transportId; |
| DOMString localCandidateId; |
| DOMString remoteCandidateId; |
| RTCStatsIceCandidatePairState state; |
| unsigned long long priority; |
| boolean nominated; |
| unsigned long packetsSent; |
| unsigned long packetsReceived; |
| unsigned long long bytesSent; |
| unsigned long long bytesReceived; |
| DOMHighResTimeStamp lastPacketSentTimestamp; |
| DOMHighResTimeStamp lastPacketReceivedTimestamp; |
| DOMHighResTimeStamp firstRequestTimestamp; |
| DOMHighResTimeStamp lastRequestTimestamp; |
| DOMHighResTimeStamp lastResponseTimestamp; |
| double totalRoundTripTime; |
| double currentRoundTripTime; |
| double availableOutgoingBitrate; |
| double availableIncomingBitrate; |
| unsigned long circuitBreakerTriggerCount; |
| unsigned long long requestsReceived; |
| unsigned long long requestsSent; |
| unsigned long long responsesReceived; |
| unsigned long long responsesSent; |
| unsigned long long retransmissionsReceived; |
| unsigned long long retransmissionsSent; |
| unsigned long long consentRequestsSent; |
| DOMHighResTimeStamp consentExpiredTimestamp; |
| }; |
| |
| enum RTCStatsIceCandidatePairState { |
| "frozen", |
| "waiting", |
| "in-progress", |
| "failed", |
| "succeeded" |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCIceCandidatePairStats, with attributes transportId, localCandidateId, |
| remoteCandidateId, state, priority, nominated, bytesSent, bytesReceived, totalRoundTripTime, currentRoundTripTime |
| */ |
| function validateIceCandidatePairStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| validateIdField(statsReport, stats, 'transportId', 'transport'); |
| validateIdField(statsReport, stats, 'localCandidateId', 'local-candidate'); |
| validateIdField(statsReport, stats, 'remoteCandidateId', 'remote-candidate'); |
| |
| assert_enum_field(stats, 'state', |
| ['frozen', 'waiting', 'in-progress', 'failed', 'succeeded']); |
| |
| assert_unsigned_int_field(stats, 'priority'); |
| assert_boolean_field(stats, 'nominated'); |
| assert_optional_unsigned_int_field(stats, 'packetsSent'); |
| assert_optional_unsigned_int_field(stats, 'packetsReceived'); |
| assert_unsigned_int_field(stats, 'bytesSent'); |
| assert_unsigned_int_field(stats, 'bytesReceived'); |
| |
| assert_optional_number_field(stats, 'lastPacketSentTimestamp'); |
| assert_optional_number_field(stats, 'lastPacketReceivedTimestamp'); |
| assert_optional_number_field(stats, 'firstRequestTimestamp'); |
| assert_optional_number_field(stats, 'lastRequestTimestamp'); |
| assert_optional_number_field(stats, 'lastResponseTimestamp'); |
| |
| assert_number_field(stats, 'totalRoundTripTime'); |
| assert_number_field(stats, 'currentRoundTripTime'); |
| |
| assert_optional_number_field(stats, 'availableOutgoingBitrate'); |
| assert_optional_number_field(stats, 'availableIncomingBitrate'); |
| |
| assert_optional_unsigned_int_field(stats, 'circuitBreakerTriggerCount'); |
| assert_optional_unsigned_int_field(stats, 'requestsReceived'); |
| assert_optional_unsigned_int_field(stats, 'requestsSent'); |
| assert_optional_unsigned_int_field(stats, 'responsesReceived'); |
| assert_optional_unsigned_int_field(stats, 'responsesSent'); |
| assert_optional_unsigned_int_field(stats, 'retransmissionsReceived'); |
| assert_optional_unsigned_int_field(stats, 'retransmissionsSent'); |
| assert_optional_unsigned_int_field(stats, 'consentRequestsSent'); |
| assert_optional_number_field(stats, 'consentExpiredTimestamp'); |
| } |
| |
| /* |
| [webrtc-stats] |
| 7.17. RTCCertificateStats dictionary |
| dictionary RTCCertificateStats : RTCStats { |
| DOMString fingerprint; |
| DOMString fingerprintAlgorithm; |
| DOMString base64Certificate; |
| DOMString issuerCertificateId; |
| }; |
| |
| [webrtc-pc] |
| 8.6. Mandatory To Implement Stats |
| - RTCCertificateStats, with attributes fingerprint, fingerprintAlgorithm, |
| base64Certificate, issuerCertificateId |
| */ |
| function validateCertificateStats(statsReport, stats) { |
| validateRtcStats(statsReport, stats); |
| |
| assert_string_field(stats, 'fingerprint'); |
| assert_string_field(stats, 'fingerprintAlgorithm'); |
| assert_string_field(stats, 'base64Certificate'); |
| assert_optional_string_field(stats, 'issuerCertificateId'); |
| } |
