chromium/src/third_party/blink/web_tests/external/wpt/webrtc/RTCPeerConnection-track-stats.https.html - manifest_repos/chromium_src - Git at Google

 <!doctype html>
 <meta charset=utf-8>
 <meta name="timeout" content="long">
 <title>RTCPeerConnection.prototype.getStats</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';

   // The following helper functions are called from RTCPeerConnection-helper.js:
   //   exchangeOfferAnswer
   //   getUserMediaTracksAndStreams
   //   waitForRtpAndRtcpStats

   // The following helper functions are called from RTCStats-helper.js
   // (depends on dictionary-helper.js):
   //   validateRtcStats

   async_test(t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());
     let track;
     getUserMediaTracksAndStreams(1)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       track = tracks[0];
       pc.addTrack(track, streams[0]);
       return pc.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', track.id);
       assert_true(trackStats != null, 'Has stats for track');
       // TODO(hbos): Here and elsewhere, validateRtcStats() only tests id,
       // timestamp and type is correct type. Should validate based on stats type
       // but it expects both audio and video members.
       // https://github.com/web-platform-tests/wpt/issues/9010
       validateRtcStats(report, trackStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'addTrack() without setLocalDescription() yields track stats');

   async_test(t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());

     let track;
     getUserMediaTracksAndStreams(1)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       track = tracks[0];
       pc.addTrack(track, streams[0]);
       return pc.createOffer();
     }))
     .then(t.step_func(offer => {
       return pc.setLocalDescription(offer);
     }))
     .then(t.step_func(() => {
       return pc.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', track.id);
       assert_true(trackStats != null, 'Has stats for track');
       validateRtcStats(report, trackStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'addTrack() with setLocalDescription() yields track stats');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let sendingTrack;
     getUserMediaTracksAndStreams(1)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       sendingTrack = tracks[0];
       caller.addTrack(sendingTrack, streams[0]);
       return exchangeOfferAnswer(caller, callee);
     }))
     .then(t.step_func(() => {
       return caller.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack.id);
       assert_true(trackStats != null, 'Has stats for sending track');
       let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
                                                    'trackId', trackStats.id);
       assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
       validateRtcStats(report, trackStats);
       validateRtcStats(report, outboundStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'O/A exchange yields outbound RTP stream stats for sending track');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let receivingTrack;
     callee.ontrack = trackEvent => {
       assert_equals(receivingTrack, undefined, 'ontrack has not fired before');
       receivingTrack = trackEvent.track;
     };
     getUserMediaTracksAndStreams(1)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       caller.addTrack(tracks[0], streams[0]);
       return exchangeOfferAnswer(caller, callee);
     }))
     .then(t.step_func(() => {
       return callee.getStats();
     }))
     .then(t.step_func(report => {
       assert_true(receivingTrack != null, 'Has a receiving track');
       let trackStats = findStatsByTypeAndId(report, 'track', receivingTrack.id);
       assert_true(trackStats != null, 'Has stats for receiving track');
       let inboundStats = findStatsByTypeAndMember(report, 'inbound-rtp',
                                                   'trackId', trackStats.id);
       assert_true(inboundStats != null, 'Has stats for outbound RTP stream');
       validateRtcStats(report, trackStats);
       validateRtcStats(report, inboundStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'O/A exchange yields inbound RTP stream stats for receiving track');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let sendingTrack1;
     let sendingTrack2;
     let sender;
     getUserMediaTracksAndStreams(2)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       sendingTrack1 = tracks[0];
       sendingTrack2 = tracks[1];
       sender = caller.addTrack(sendingTrack1, streams[0]);
       return sender.replaceTrack(sendingTrack2);
     }))
     .then(t.step_func(() => {
       return caller.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
       assert_true(trackStats != null, 'Has stats for replaced track');
       validateRtcStats(report, trackStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'replaceTrack() before offer: new track attachment stats present');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let sendingTrack1;
     let sendingTrack2;
     let sender;
     getUserMediaTracksAndStreams(2)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       sendingTrack1 = tracks[0];
       sendingTrack2 = tracks[1];
       sender = caller.addTrack(sendingTrack1, streams[0]);
       return exchangeOffer(caller, callee);
     }))
     .then(t.step_func(() => {
       return sender.replaceTrack(sendingTrack2);
     }))
     .then(t.step_func(() => {
       return caller.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
       assert_true(trackStats != null, 'Has stats for replaced track');
       let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
                                                    'trackId', trackStats.id);
       assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
       validateRtcStats(report, trackStats);
       validateRtcStats(report, outboundStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'replaceTrack() after offer, before answer: new track attachment stats ' +
      'present');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let sendingTrack1;
     let sendingTrack2;
     let sender;
     getUserMediaTracksAndStreams(2)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       sendingTrack1 = tracks[0];
       sendingTrack2 = tracks[1];
       sender = caller.addTrack(sendingTrack1, streams[0]);
       return exchangeOfferAnswer(caller, callee);
     }))
     .then(t.step_func(() => {
       return sender.replaceTrack(sendingTrack2);
     }))
     .then(t.step_func(() => {
       return caller.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
       assert_true(trackStats != null, 'Has stats for replaced track');
       let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
                                                    'trackId', trackStats.id);
       assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
       validateRtcStats(report, trackStats);
       validateRtcStats(report, outboundStats);
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'replaceTrack() after answer: new track attachment stats present');

   async_test(t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let sendingTrack1;
     let sendingTrack2;
     let sender;
     getUserMediaTracksAndStreams(2)
     .then(t.step_func(([tracks, streams]) => {
       t.add_cleanup(() => tracks.forEach(track => track.stop()));
       sendingTrack1 = tracks[0];
       sendingTrack2 = tracks[1];
       sender = caller.addTrack(sendingTrack1, streams[0]);
       return exchangeOfferAnswer(caller, callee);
     }))
     .then(t.step_func(() => {
       return sender.replaceTrack(sendingTrack2);
     }))
     .then(t.step_func(() => {
       return caller.getStats();
     }))
     .then(t.step_func(report => {
       let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack1.id);
       assert_true(trackStats != null, 'Has stats for original track');
       assert_true(trackStats.objectDeleted);
       let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
                                                    'trackId', trackStats.id);
       assert_equals(outboundStats, null,
                   'The outbound RTP stream should no longer reference the ' +
                   'original attachment');
       t.done();
     }))
     .catch(t.step_func(reason => {
       assert_unreached(reason);
     }));
   }, 'replaceTrack(): original track attachment stats present after replacing');

   promise_test(async t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(2);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     let sender = caller.addTrack(tracks[0], streams[0]);
     callee.addTrack(tracks[1], streams[1]);
     exchangeIceCandidates(caller, callee);
     await exchangeOfferAnswer(caller, callee);
     await listenToConnected(caller);
     let receiver = caller.getReceivers()[0];

     // Obtain inbound and outbound RTP stream stats on a full stats report.
     let fullReport = await caller.getStats();
     let outboundTrackStats = findStatsByTypeAndId(
         fullReport, 'track', sender.track.id);
     let outboundStats = findStatsByTypeAndMember(
         fullReport, 'outbound-rtp', 'trackId', outboundTrackStats.id);
     assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
     let inboundTrackStats = findStatsByTypeAndId(
         fullReport, 'track', receiver.track.id);
     let inboundStats = findStatsByTypeAndMember(
         fullReport, 'inbound-rtp', 'trackId', inboundTrackStats.id);
     assert_true(inboundStats != null, 'Has stats for inbound RTP stream');

     // Perform stats selection algorithm with sender selector. The result should
     // contain the outbound-rtp but not the inbound-rtp.
     let senderReport = await sender.getStats();
     assert_true(senderReport.has(outboundStats.id));
     assert_false(senderReport.has(inboundStats.id));

     // Validate the stats graph, ensuring all stats objects are reachable and
     // valid from the outbound-rtp stats.
     validateStatsGraph(senderReport, senderReport.get(outboundStats.id));
     // Ensure that the stats graph contains some expected dictionaries.
     assert_equals(findStatsOfType(senderReport, 'track').length, 1,
         'senderReport should contain track stats');
     assert_equals(findStatsOfType(senderReport, 'transport').length, 1,
         'senderReport should contain transport stats');
     assert_equals(findStatsOfType(senderReport, 'candidate-pair').length, 1,
         'senderReport should contain candidate-pair stats');
     assert_equals(findStatsOfType(senderReport, 'local-candidate').length, 1,
         'senderReport should contain local-candidate stats');
     assert_equals(findStatsOfType(senderReport, 'remote-candidate').length, 1,
         'senderReport should contain remote-candidate stats');
   }, 'RTCRtpSender.getStats() contains only outbound-rtp and related stats');

   promise_test(async t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(2);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     let sender = caller.addTrack(tracks[0], streams[0]);
     callee.addTrack(tracks[1], streams[1]);
     exchangeIceCandidates(caller, callee);
     await exchangeOfferAnswer(caller, callee);
     await listenToConnected(caller);
     let receiver = caller.getReceivers()[0];

     // Obtain inbound and outbound RTP stream stats on a full stats report.
     let fullReport = await caller.getStats();
     let outboundTrackStats = findStatsByTypeAndId(
         fullReport, 'track', sender.track.id);
     let outboundStats = findStatsByTypeAndMember(
         fullReport, 'outbound-rtp', 'trackId', outboundTrackStats.id);
     assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
     let inboundTrackStats = findStatsByTypeAndId(
         fullReport, 'track', receiver.track.id);
     let inboundStats = findStatsByTypeAndMember(
         fullReport, 'inbound-rtp', 'trackId', inboundTrackStats.id);
     assert_true(inboundStats != null, 'Has stats for inbound RTP stream');

     // Perform stats selection algorithm with receiver selector. The result
     // should contain the inbound-rtp but not the outbound-rtp.
     let receiverReport = await receiver.getStats();
     assert_true(receiverReport.has(inboundStats.id));
     assert_false(receiverReport.has(outboundStats.id));

     // Validate the stats graph, ensuring all stats objects are reachable and
     // valid from the outbound-rtp stats.
     validateStatsGraph(receiverReport, receiverReport.get(inboundStats.id));
     // Ensure that the stats graph contains some expected dictionaries.
     assert_equals(findStatsOfType(receiverReport, 'track').length, 1,
         'receiverReport should contain track stats');
     assert_equals(findStatsOfType(receiverReport, 'transport').length, 1,
         'receiverReport should contain transport stats');
     assert_equals(findStatsOfType(receiverReport, 'candidate-pair').length, 1,
         'receiverReport should contain candidate-pair stats');
     assert_equals(findStatsOfType(receiverReport, 'local-candidate').length, 1,
         'receiverReport should contain local-candidate stats');
     assert_equals(findStatsOfType(receiverReport, 'remote-candidate').length, 1,
         'receiverReport should contain remote-candidate stats');
   }, 'RTCRtpReceiver.getStats() contains only inbound-rtp and related stats');

   promise_test(async t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(2);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     let sender = caller.addTrack(tracks[0], streams[0]);
     callee.addTrack(tracks[1], streams[1]);
     exchangeIceCandidates(caller, callee);
     await exchangeOfferAnswer(caller, callee);
     await listenToIceConnected(caller);

     // Wait until RTCP has arrived so that it can not arrive between
     // the two get stats calls.
     await waitForRtpAndRtcpStats(caller);

     let senderReport = await sender.getStats();
     let trackReport = await caller.getStats(sender.track);

     // Verify the same stats objects are returned but don't compare each
     // individual metric because timestamps and counters could have gone up
     // between the two getStats() calls.
     senderReport.forEach(senderReportStat => {
       assert_true(trackReport.has(senderReportStat.id));
     });
     trackReport.forEach(trackReportStat => {
       assert_true(senderReport.has(trackReportStat.id));
     });
   }, 'RTCPeerConnection.getStats(sendingTrack) is the same as ' +
      'RTCRtpSender.getStats()');

   promise_test(async t => {
     const caller = new RTCPeerConnection();
     t.add_cleanup(() => caller.close());
     const callee = new RTCPeerConnection();
     t.add_cleanup(() => callee.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(2);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     let sender = caller.addTrack(tracks[0], streams[0]);
     callee.addTrack(tracks[1], streams[1]);
     exchangeIceCandidates(caller, callee);
     await exchangeOfferAnswer(caller, callee);
     await listenToIceConnected(caller);
     let receiver = caller.getReceivers()[0];

     // Wait until RTCP has arrived so that it can not arrive between
     // the two get stats calls.
     await waitForRtpAndRtcpStats(caller);

     let receiverReport = await receiver.getStats();
     let trackReport = await caller.getStats(receiver.track);

     // Verify the same stats objects are returned but don't compare each
     // individual metric because timestamps and counters could have gone up
     // between the two getStats() calls.
     receiverReport.forEach(receiverReportStat => {
       assert_true(trackReport.has(receiverReportStat.id));
     });
     trackReport.forEach(trackReportStat => {
       assert_true(receiverReport.has(trackReportStat.id));
     });
   }, 'RTCPeerConnection.getStats(receivingTrack) is the same as ' +
      'RTCRtpReceiver.getStats()');

   promise_test(async t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(1);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     await promise_rejects_dom(t, 'InvalidAccessError', pc.getStats(tracks[0]));
   }, 'RTCPeerConnection.getStats(track) throws InvalidAccessError when there ' +
      'are zero senders or receivers for the track');

   promise_test(async t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());
     let [tracks, streams] = await getUserMediaTracksAndStreams(2);
     t.add_cleanup(() => tracks.forEach(track => track.stop()));
     let sender1 = pc.addTrack(tracks[0], streams[0]);
     let sender2 = pc.addTrack(tracks[1], streams[1]);
     await sender2.replaceTrack(sender1.track);
     await promise_rejects_dom(t, 'InvalidAccessError', pc.getStats(sender1.track));
   }, 'RTCPeerConnection.getStats(track) throws InvalidAccessError when there ' +
      'are multiple senders for the track');

   // Helpers.

   function findStatsByTypeAndId(report, type, identifier) {
     return findStats(report, stats => {
       return stats.type == type && stats[type + 'Identifier'] == identifier;
     });
   }

   function findStatsByTypeAndMember(report, type, member, value) {
     return findStats(report, stats => {
       return stats.type == type && stats[member] == value;
     });
   }

   function findStats(report, findFunc) {
     for (let it = report.values(), n = it.next(); !n.done; n = it.next()) {
       if (findFunc(n.value))
         return n.value;
     }
     return null;
   }

   function findStatsOfType(report, type) {
     let stats = [];
     for (let it = report.values(), n = it.next(); !n.done; n = it.next()) {
       if (n.value.type == type)
         stats.push(n.value);
     }
     return stats;
   }

   // Explores the stats graph starting from |stat|, validating each stat
   // (validateRtcStats) and asserting that all stats of the report were visited.
   function validateStatsGraph(report, stat) {
     let visitedIds = new Set();
     validateStatsGraphRecursively(report, stat.id, visitedIds);
     assert_equals(visitedIds.size, report.size,
                   'Entire stats graph should have been explored.')
   }

   function validateStatsGraphRecursively(report, currentId, visitedIds) {
     if (visitedIds.has(currentId))
       return;
     visitedIds.add(currentId);
     assert_true(report.has(currentId), 'Broken reference.');
     let stat = report.get(currentId);
     validateRtcStats(report, stat);
     for (let member in stat) {
       if (member.endsWith('Id')) {
         validateStatsGraphRecursively(report, stat[member], visitedIds);
       } else if (member.endsWith('Ids')) {
         let ids = stat[member];
         for (let i = 0; i < ids.length; ++i) {
           validateStatsGraphRecursively(report, ids[i], visitedIds);
         }
       }
     }
   }
 </script>
	<!doctype html>
	<meta charset=utf-8>
	<meta name="timeout" content="long">
	<title>RTCPeerConnection.prototype.getStats</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';

	// The following helper functions are called from RTCPeerConnection-helper.js:
	// exchangeOfferAnswer
	// getUserMediaTracksAndStreams
	// waitForRtpAndRtcpStats

	// The following helper functions are called from RTCStats-helper.js
	// (depends on dictionary-helper.js):
	// validateRtcStats

	async_test(t => {
	const pc = new RTCPeerConnection();
	t.add_cleanup(() => pc.close());
	let track;
	getUserMediaTracksAndStreams(1)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	track = tracks[0];
	pc.addTrack(track, streams[0]);
	return pc.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', track.id);
	assert_true(trackStats != null, 'Has stats for track');
	// TODO(hbos): Here and elsewhere, validateRtcStats() only tests id,
	// timestamp and type is correct type. Should validate based on stats type
	// but it expects both audio and video members.
	// https://github.com/web-platform-tests/wpt/issues/9010
	validateRtcStats(report, trackStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'addTrack() without setLocalDescription() yields track stats');

	async_test(t => {
	const pc = new RTCPeerConnection();
	t.add_cleanup(() => pc.close());

	let track;
	getUserMediaTracksAndStreams(1)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	track = tracks[0];
	pc.addTrack(track, streams[0]);
	return pc.createOffer();
	}))
	.then(t.step_func(offer => {
	return pc.setLocalDescription(offer);
	}))
	.then(t.step_func(() => {
	return pc.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', track.id);
	assert_true(trackStats != null, 'Has stats for track');
	validateRtcStats(report, trackStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'addTrack() with setLocalDescription() yields track stats');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let sendingTrack;
	getUserMediaTracksAndStreams(1)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	sendingTrack = tracks[0];
	caller.addTrack(sendingTrack, streams[0]);
	return exchangeOfferAnswer(caller, callee);
	}))
	.then(t.step_func(() => {
	return caller.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack.id);
	assert_true(trackStats != null, 'Has stats for sending track');
	let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
	'trackId', trackStats.id);
	assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
	validateRtcStats(report, trackStats);
	validateRtcStats(report, outboundStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'O/A exchange yields outbound RTP stream stats for sending track');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let receivingTrack;
	callee.ontrack = trackEvent => {
	assert_equals(receivingTrack, undefined, 'ontrack has not fired before');
	receivingTrack = trackEvent.track;
	};
	getUserMediaTracksAndStreams(1)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	caller.addTrack(tracks[0], streams[0]);
	return exchangeOfferAnswer(caller, callee);
	}))
	.then(t.step_func(() => {
	return callee.getStats();
	}))
	.then(t.step_func(report => {
	assert_true(receivingTrack != null, 'Has a receiving track');
	let trackStats = findStatsByTypeAndId(report, 'track', receivingTrack.id);
	assert_true(trackStats != null, 'Has stats for receiving track');
	let inboundStats = findStatsByTypeAndMember(report, 'inbound-rtp',
	'trackId', trackStats.id);
	assert_true(inboundStats != null, 'Has stats for outbound RTP stream');
	validateRtcStats(report, trackStats);
	validateRtcStats(report, inboundStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'O/A exchange yields inbound RTP stream stats for receiving track');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let sendingTrack1;
	let sendingTrack2;
	let sender;
	getUserMediaTracksAndStreams(2)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	sendingTrack1 = tracks[0];
	sendingTrack2 = tracks[1];
	sender = caller.addTrack(sendingTrack1, streams[0]);
	return sender.replaceTrack(sendingTrack2);
	}))
	.then(t.step_func(() => {
	return caller.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
	assert_true(trackStats != null, 'Has stats for replaced track');
	validateRtcStats(report, trackStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'replaceTrack() before offer: new track attachment stats present');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let sendingTrack1;
	let sendingTrack2;
	let sender;
	getUserMediaTracksAndStreams(2)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	sendingTrack1 = tracks[0];
	sendingTrack2 = tracks[1];
	sender = caller.addTrack(sendingTrack1, streams[0]);
	return exchangeOffer(caller, callee);
	}))
	.then(t.step_func(() => {
	return sender.replaceTrack(sendingTrack2);
	}))
	.then(t.step_func(() => {
	return caller.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
	assert_true(trackStats != null, 'Has stats for replaced track');
	let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
	'trackId', trackStats.id);
	assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
	validateRtcStats(report, trackStats);
	validateRtcStats(report, outboundStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'replaceTrack() after offer, before answer: new track attachment stats ' +
	'present');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let sendingTrack1;
	let sendingTrack2;
	let sender;
	getUserMediaTracksAndStreams(2)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	sendingTrack1 = tracks[0];
	sendingTrack2 = tracks[1];
	sender = caller.addTrack(sendingTrack1, streams[0]);
	return exchangeOfferAnswer(caller, callee);
	}))
	.then(t.step_func(() => {
	return sender.replaceTrack(sendingTrack2);
	}))
	.then(t.step_func(() => {
	return caller.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack2.id);
	assert_true(trackStats != null, 'Has stats for replaced track');
	let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
	'trackId', trackStats.id);
	assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
	validateRtcStats(report, trackStats);
	validateRtcStats(report, outboundStats);
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'replaceTrack() after answer: new track attachment stats present');

	async_test(t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let sendingTrack1;
	let sendingTrack2;
	let sender;
	getUserMediaTracksAndStreams(2)
	.then(t.step_func(([tracks, streams]) => {
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	sendingTrack1 = tracks[0];
	sendingTrack2 = tracks[1];
	sender = caller.addTrack(sendingTrack1, streams[0]);
	return exchangeOfferAnswer(caller, callee);
	}))
	.then(t.step_func(() => {
	return sender.replaceTrack(sendingTrack2);
	}))
	.then(t.step_func(() => {
	return caller.getStats();
	}))
	.then(t.step_func(report => {
	let trackStats = findStatsByTypeAndId(report, 'track', sendingTrack1.id);
	assert_true(trackStats != null, 'Has stats for original track');
	assert_true(trackStats.objectDeleted);
	let outboundStats = findStatsByTypeAndMember(report, 'outbound-rtp',
	'trackId', trackStats.id);
	assert_equals(outboundStats, null,
	'The outbound RTP stream should no longer reference the ' +
	'original attachment');
	t.done();
	}))
	.catch(t.step_func(reason => {
	assert_unreached(reason);
	}));
	}, 'replaceTrack(): original track attachment stats present after replacing');

	promise_test(async t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(2);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	let sender = caller.addTrack(tracks[0], streams[0]);
	callee.addTrack(tracks[1], streams[1]);
	exchangeIceCandidates(caller, callee);
	await exchangeOfferAnswer(caller, callee);
	await listenToConnected(caller);
	let receiver = caller.getReceivers()[0];

	// Obtain inbound and outbound RTP stream stats on a full stats report.
	let fullReport = await caller.getStats();
	let outboundTrackStats = findStatsByTypeAndId(
	fullReport, 'track', sender.track.id);
	let outboundStats = findStatsByTypeAndMember(
	fullReport, 'outbound-rtp', 'trackId', outboundTrackStats.id);
	assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
	let inboundTrackStats = findStatsByTypeAndId(
	fullReport, 'track', receiver.track.id);
	let inboundStats = findStatsByTypeAndMember(
	fullReport, 'inbound-rtp', 'trackId', inboundTrackStats.id);
	assert_true(inboundStats != null, 'Has stats for inbound RTP stream');

	// Perform stats selection algorithm with sender selector. The result should
	// contain the outbound-rtp but not the inbound-rtp.
	let senderReport = await sender.getStats();
	assert_true(senderReport.has(outboundStats.id));
	assert_false(senderReport.has(inboundStats.id));

	// Validate the stats graph, ensuring all stats objects are reachable and
	// valid from the outbound-rtp stats.
	validateStatsGraph(senderReport, senderReport.get(outboundStats.id));
	// Ensure that the stats graph contains some expected dictionaries.
	assert_equals(findStatsOfType(senderReport, 'track').length, 1,
	'senderReport should contain track stats');
	assert_equals(findStatsOfType(senderReport, 'transport').length, 1,
	'senderReport should contain transport stats');
	assert_equals(findStatsOfType(senderReport, 'candidate-pair').length, 1,
	'senderReport should contain candidate-pair stats');
	assert_equals(findStatsOfType(senderReport, 'local-candidate').length, 1,
	'senderReport should contain local-candidate stats');
	assert_equals(findStatsOfType(senderReport, 'remote-candidate').length, 1,
	'senderReport should contain remote-candidate stats');
	}, 'RTCRtpSender.getStats() contains only outbound-rtp and related stats');

	promise_test(async t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(2);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	let sender = caller.addTrack(tracks[0], streams[0]);
	callee.addTrack(tracks[1], streams[1]);
	exchangeIceCandidates(caller, callee);
	await exchangeOfferAnswer(caller, callee);
	await listenToConnected(caller);
	let receiver = caller.getReceivers()[0];

	// Obtain inbound and outbound RTP stream stats on a full stats report.
	let fullReport = await caller.getStats();
	let outboundTrackStats = findStatsByTypeAndId(
	fullReport, 'track', sender.track.id);
	let outboundStats = findStatsByTypeAndMember(
	fullReport, 'outbound-rtp', 'trackId', outboundTrackStats.id);
	assert_true(outboundStats != null, 'Has stats for outbound RTP stream');
	let inboundTrackStats = findStatsByTypeAndId(
	fullReport, 'track', receiver.track.id);
	let inboundStats = findStatsByTypeAndMember(
	fullReport, 'inbound-rtp', 'trackId', inboundTrackStats.id);
	assert_true(inboundStats != null, 'Has stats for inbound RTP stream');

	// Perform stats selection algorithm with receiver selector. The result
	// should contain the inbound-rtp but not the outbound-rtp.
	let receiverReport = await receiver.getStats();
	assert_true(receiverReport.has(inboundStats.id));
	assert_false(receiverReport.has(outboundStats.id));

	// Validate the stats graph, ensuring all stats objects are reachable and
	// valid from the outbound-rtp stats.
	validateStatsGraph(receiverReport, receiverReport.get(inboundStats.id));
	// Ensure that the stats graph contains some expected dictionaries.
	assert_equals(findStatsOfType(receiverReport, 'track').length, 1,
	'receiverReport should contain track stats');
	assert_equals(findStatsOfType(receiverReport, 'transport').length, 1,
	'receiverReport should contain transport stats');
	assert_equals(findStatsOfType(receiverReport, 'candidate-pair').length, 1,
	'receiverReport should contain candidate-pair stats');
	assert_equals(findStatsOfType(receiverReport, 'local-candidate').length, 1,
	'receiverReport should contain local-candidate stats');
	assert_equals(findStatsOfType(receiverReport, 'remote-candidate').length, 1,
	'receiverReport should contain remote-candidate stats');
	}, 'RTCRtpReceiver.getStats() contains only inbound-rtp and related stats');

	promise_test(async t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(2);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	let sender = caller.addTrack(tracks[0], streams[0]);
	callee.addTrack(tracks[1], streams[1]);
	exchangeIceCandidates(caller, callee);
	await exchangeOfferAnswer(caller, callee);
	await listenToIceConnected(caller);

	// Wait until RTCP has arrived so that it can not arrive between
	// the two get stats calls.
	await waitForRtpAndRtcpStats(caller);

	let senderReport = await sender.getStats();
	let trackReport = await caller.getStats(sender.track);

	// Verify the same stats objects are returned but don't compare each
	// individual metric because timestamps and counters could have gone up
	// between the two getStats() calls.
	senderReport.forEach(senderReportStat => {
	assert_true(trackReport.has(senderReportStat.id));
	});
	trackReport.forEach(trackReportStat => {
	assert_true(senderReport.has(trackReportStat.id));
	});
	}, 'RTCPeerConnection.getStats(sendingTrack) is the same as ' +
	'RTCRtpSender.getStats()');

	promise_test(async t => {
	const caller = new RTCPeerConnection();
	t.add_cleanup(() => caller.close());
	const callee = new RTCPeerConnection();
	t.add_cleanup(() => callee.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(2);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	let sender = caller.addTrack(tracks[0], streams[0]);
	callee.addTrack(tracks[1], streams[1]);
	exchangeIceCandidates(caller, callee);
	await exchangeOfferAnswer(caller, callee);
	await listenToIceConnected(caller);
	let receiver = caller.getReceivers()[0];

	// Wait until RTCP has arrived so that it can not arrive between
	// the two get stats calls.
	await waitForRtpAndRtcpStats(caller);

	let receiverReport = await receiver.getStats();
	let trackReport = await caller.getStats(receiver.track);

	// Verify the same stats objects are returned but don't compare each
	// individual metric because timestamps and counters could have gone up
	// between the two getStats() calls.
	receiverReport.forEach(receiverReportStat => {
	assert_true(trackReport.has(receiverReportStat.id));
	});
	trackReport.forEach(trackReportStat => {
	assert_true(receiverReport.has(trackReportStat.id));
	});
	}, 'RTCPeerConnection.getStats(receivingTrack) is the same as ' +
	'RTCRtpReceiver.getStats()');

	promise_test(async t => {
	const pc = new RTCPeerConnection();
	t.add_cleanup(() => pc.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(1);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	await promise_rejects_dom(t, 'InvalidAccessError', pc.getStats(tracks[0]));
	}, 'RTCPeerConnection.getStats(track) throws InvalidAccessError when there ' +
	'are zero senders or receivers for the track');

	promise_test(async t => {
	const pc = new RTCPeerConnection();
	t.add_cleanup(() => pc.close());
	let [tracks, streams] = await getUserMediaTracksAndStreams(2);
	t.add_cleanup(() => tracks.forEach(track => track.stop()));
	let sender1 = pc.addTrack(tracks[0], streams[0]);
	let sender2 = pc.addTrack(tracks[1], streams[1]);
	await sender2.replaceTrack(sender1.track);
	await promise_rejects_dom(t, 'InvalidAccessError', pc.getStats(sender1.track));
	}, 'RTCPeerConnection.getStats(track) throws InvalidAccessError when there ' +
	'are multiple senders for the track');

	// Helpers.

	function findStatsByTypeAndId(report, type, identifier) {
	return findStats(report, stats => {
	return stats.type == type && stats[type + 'Identifier'] == identifier;
	});
	}

	function findStatsByTypeAndMember(report, type, member, value) {
	return findStats(report, stats => {
	return stats.type == type && stats[member] == value;
	});
	}

	function findStats(report, findFunc) {
	for (let it = report.values(), n = it.next(); !n.done; n = it.next()) {
	if (findFunc(n.value))
	return n.value;
	}
	return null;
	}

	function findStatsOfType(report, type) {
	let stats = [];
	for (let it = report.values(), n = it.next(); !n.done; n = it.next()) {
	if (n.value.type == type)
	stats.push(n.value);
	}
	return stats;
	}

	// Explores the stats graph starting from \|stat\|, validating each stat
	// (validateRtcStats) and asserting that all stats of the report were visited.
	function validateStatsGraph(report, stat) {
	let visitedIds = new Set();
	validateStatsGraphRecursively(report, stat.id, visitedIds);
	assert_equals(visitedIds.size, report.size,
	'Entire stats graph should have been explored.')
	}

	function validateStatsGraphRecursively(report, currentId, visitedIds) {
	if (visitedIds.has(currentId))
	return;
	visitedIds.add(currentId);
	assert_true(report.has(currentId), 'Broken reference.');
	let stat = report.get(currentId);
	validateRtcStats(report, stat);
	for (let member in stat) {
	if (member.endsWith('Id')) {
	validateStatsGraphRecursively(report, stat[member], visitedIds);
	} else if (member.endsWith('Ids')) {
	let ids = stat[member];
	for (let i = 0; i < ids.length; ++i) {
	validateStatsGraphRecursively(report, ids[i], visitedIds);
	}
	}
	}
	}
	</script>