RTCStats-helper.js

'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 {
    if (stats['remoteSource']) {
      assert_number_field(stats, 'audioLevel');
      assert_optional_number_field(stats, 'totalAudioEnergy');
      assert_optional_number_field(stats, 'totalSamplesDuration');
    }
    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_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');
}