blob: 2be4371f411033e939522d0577b7ad641cebb46b [file] [log] [blame]
hbosd565b732016-08-30 21:04:351/*
2 * Copyright 2016 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
hbos9e302742017-01-20 10:47:1011#include <initializer_list>
hbosd565b732016-08-30 21:04:3512#include <memory>
hbosda389e32016-10-25 17:55:0813#include <ostream>
hbosd565b732016-08-30 21:04:3514#include <string>
Steve Anton36b29d12017-10-30 16:57:4215#include <utility>
hbosd565b732016-08-30 21:04:3516#include <vector>
17
Karl Wiberg918f50c2018-07-05 09:40:3318#include "absl/memory/memory.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3119#include "api/rtpparameters.h"
20#include "api/stats/rtcstats_objects.h"
21#include "api/stats/rtcstatsreport.h"
Sebastian Jansson5f83cf02018-05-08 12:52:2222#include "api/units/time_delta.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3123#include "p2p/base/p2pconstants.h"
24#include "p2p/base/port.h"
25#include "pc/mediastream.h"
26#include "pc/mediastreamtrack.h"
Steve Anton5b387312018-02-03 00:00:2027#include "pc/rtcstatscollector.h"
28#include "pc/test/fakepeerconnectionforstats.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3129#include "pc/test/mock_datachannel.h"
Steve Anton57858b32018-02-15 23:19:5030#include "pc/test/mock_rtpreceiverinternal.h"
31#include "pc/test/mock_rtpsenderinternal.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3132#include "pc/test/rtcstatsobtainer.h"
33#include "rtc_base/checks.h"
34#include "rtc_base/fakeclock.h"
35#include "rtc_base/fakesslidentity.h"
36#include "rtc_base/gunit.h"
37#include "rtc_base/logging.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3138#include "rtc_base/timeutils.h"
hbosd565b732016-08-30 21:04:3539
Steve Anton57858b32018-02-15 23:19:5040using testing::AtLeast;
hbos6ab97ce02016-10-03 21:16:5641using testing::Invoke;
hbosd565b732016-08-30 21:04:3542using testing::Return;
hbosd565b732016-08-30 21:04:3543
44namespace webrtc {
45
hbosda389e32016-10-25 17:55:0846// These are used by gtest code, such as if |EXPECT_EQ| fails.
47void PrintTo(const RTCCertificateStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1248 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0849}
50
hbos0adb8282016-11-23 10:32:0651void PrintTo(const RTCCodecStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1252 *os << stats.ToJson();
hbos0adb8282016-11-23 10:32:0653}
54
hbosda389e32016-10-25 17:55:0855void PrintTo(const RTCDataChannelStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1256 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0857}
58
59void PrintTo(const RTCIceCandidatePairStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1260 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0861}
62
63void PrintTo(const RTCLocalIceCandidateStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1264 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0865}
66
67void PrintTo(const RTCRemoteIceCandidateStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1268 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0869}
70
71void PrintTo(const RTCPeerConnectionStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1272 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0873}
74
hbos09bc1282016-11-08 14:29:2275void PrintTo(const RTCMediaStreamStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1276 *os << stats.ToJson();
hbos09bc1282016-11-08 14:29:2277}
78
79void PrintTo(const RTCMediaStreamTrackStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1280 *os << stats.ToJson();
hbos09bc1282016-11-08 14:29:2281}
82
hboseeafe942016-11-01 10:00:1783void PrintTo(const RTCInboundRTPStreamStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1284 *os << stats.ToJson();
hboseeafe942016-11-01 10:00:1785}
86
hbos6ded1902016-11-01 08:50:4687void PrintTo(const RTCOutboundRTPStreamStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1288 *os << stats.ToJson();
hbos6ded1902016-11-01 08:50:4689}
90
hbosda389e32016-10-25 17:55:0891void PrintTo(const RTCTransportStats& stats, ::std::ostream* os) {
ehmaldonado35a872c2017-07-28 14:29:1292 *os << stats.ToJson();
hbosda389e32016-10-25 17:55:0893}
94
hbosc82f2e12016-09-05 08:36:5095namespace {
96
97const int64_t kGetStatsReportTimeoutMs = 1000;
98
hbos6ab97ce02016-10-03 21:16:5699struct CertificateInfo {
100 rtc::scoped_refptr<rtc::RTCCertificate> certificate;
101 std::vector<std::string> ders;
102 std::vector<std::string> pems;
103 std::vector<std::string> fingerprints;
104};
105
Harald Alvestranda3dab842018-01-14 08:18:58106// Return the ID for an object of the given type in a report.
107// The object must be present and be unique.
108template <typename T>
109std::string IdForType(const RTCStatsReport* report) {
110 auto stats_of_my_type = report->RTCStatsReport::GetStatsOfType<T>();
111 // We cannot use ASSERT here, since we're within a function.
Mirko Bonadeie12c1fe2018-07-03 10:53:23112 EXPECT_EQ(1U, stats_of_my_type.size())
Harald Alvestranda3dab842018-01-14 08:18:58113 << "Unexpected number of stats of this type";
114 if (stats_of_my_type.size() == 1) {
115 return stats_of_my_type[0]->id();
116 } else {
117 // Return something that is not going to be a valid stas ID.
118 return "Type not found";
119 }
120}
121
hbos6ab97ce02016-10-03 21:16:56122std::unique_ptr<CertificateInfo> CreateFakeCertificateAndInfoFromDers(
123 const std::vector<std::string>& ders) {
124 RTC_CHECK(!ders.empty());
125 std::unique_ptr<CertificateInfo> info(new CertificateInfo());
126 info->ders = ders;
127 for (const std::string& der : ders) {
128 info->pems.push_back(rtc::SSLIdentity::DerToPem(
Yves Gerey665174f2018-06-19 13:03:05129 "CERTIFICATE", reinterpret_cast<const unsigned char*>(der.c_str()),
hbos6ab97ce02016-10-03 21:16:56130 der.length()));
131 }
132 info->certificate =
133 rtc::RTCCertificate::Create(std::unique_ptr<rtc::FakeSSLIdentity>(
Taylor Brandstetterc3928662018-02-23 21:04:51134 new rtc::FakeSSLIdentity(info->pems)));
hbos6ab97ce02016-10-03 21:16:56135 // Strip header/footer and newline characters of PEM strings.
136 for (size_t i = 0; i < info->pems.size(); ++i) {
Yves Gerey665174f2018-06-19 13:03:05137 rtc::replace_substrs("-----BEGIN CERTIFICATE-----", 27, "", 0,
138 &info->pems[i]);
139 rtc::replace_substrs("-----END CERTIFICATE-----", 25, "", 0,
140 &info->pems[i]);
141 rtc::replace_substrs("\n", 1, "", 0, &info->pems[i]);
hbos6ab97ce02016-10-03 21:16:56142 }
Taylor Brandstetterc3928662018-02-23 21:04:51143 // Fingerprints for the whole certificate chain, starting with leaf
144 // certificate.
Benjamin Wright6c6c9df2018-10-25 08:16:26145 const rtc::SSLCertChain& chain = info->certificate->GetSSLCertificateChain();
Taylor Brandstetterc3928662018-02-23 21:04:51146 std::unique_ptr<rtc::SSLFingerprint> fp;
147 for (size_t i = 0; i < chain.GetSize(); i++) {
Steve Anton4905edb2018-10-16 02:27:44148 fp = rtc::SSLFingerprint::Create("sha-1", chain.Get(i));
Taylor Brandstetterc3928662018-02-23 21:04:51149 EXPECT_TRUE(fp);
150 info->fingerprints.push_back(fp->GetRfc4572Fingerprint());
hbos6ab97ce02016-10-03 21:16:56151 }
152 EXPECT_EQ(info->ders.size(), info->fingerprints.size());
153 return info;
154}
155
hbosab9f6e42016-10-07 09:18:47156std::unique_ptr<cricket::Candidate> CreateFakeCandidate(
157 const std::string& hostname,
158 int port,
159 const std::string& protocol,
Gary Liu37e489c2017-11-21 18:49:36160 const rtc::AdapterType adapter_type,
hbosab9f6e42016-10-07 09:18:47161 const std::string& candidate_type,
162 uint32_t priority) {
163 std::unique_ptr<cricket::Candidate> candidate(new cricket::Candidate());
164 candidate->set_address(rtc::SocketAddress(hostname, port));
165 candidate->set_protocol(protocol);
Gary Liu37e489c2017-11-21 18:49:36166 candidate->set_network_type(adapter_type);
hbosab9f6e42016-10-07 09:18:47167 candidate->set_type(candidate_type);
168 candidate->set_priority(priority);
169 return candidate;
170}
171
Yves Gerey665174f2018-06-19 13:03:05172class FakeAudioTrackForStats : public MediaStreamTrack<AudioTrackInterface> {
hbos09bc1282016-11-08 14:29:22173 public:
174 static rtc::scoped_refptr<FakeAudioTrackForStats> Create(
175 const std::string& id,
hbos9e302742017-01-20 10:47:10176 MediaStreamTrackInterface::TrackState state) {
hbos09bc1282016-11-08 14:29:22177 rtc::scoped_refptr<FakeAudioTrackForStats> audio_track_stats(
hbos9e302742017-01-20 10:47:10178 new rtc::RefCountedObject<FakeAudioTrackForStats>(id));
hbos09bc1282016-11-08 14:29:22179 audio_track_stats->set_state(state);
180 return audio_track_stats;
181 }
182
Steve Anton36b29d12017-10-30 16:57:42183 explicit FakeAudioTrackForStats(const std::string& id)
184 : MediaStreamTrack<AudioTrackInterface>(id) {}
hbos09bc1282016-11-08 14:29:22185
186 std::string kind() const override {
187 return MediaStreamTrackInterface::kAudioKind;
188 }
189 webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
190 void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
191 void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
hbos9e302742017-01-20 10:47:10192 bool GetSignalLevel(int* level) override { return false; }
hbos09bc1282016-11-08 14:29:22193 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
hbos9e302742017-01-20 10:47:10194 return nullptr;
hbos09bc1282016-11-08 14:29:22195 }
hbos09bc1282016-11-08 14:29:22196};
197
Yves Gerey665174f2018-06-19 13:03:05198class FakeVideoTrackForStats : public MediaStreamTrack<VideoTrackInterface> {
hbos09bc1282016-11-08 14:29:22199 public:
200 static rtc::scoped_refptr<FakeVideoTrackForStats> Create(
201 const std::string& id,
hbos9e302742017-01-20 10:47:10202 MediaStreamTrackInterface::TrackState state) {
hbos09bc1282016-11-08 14:29:22203 rtc::scoped_refptr<FakeVideoTrackForStats> video_track(
hbos9e302742017-01-20 10:47:10204 new rtc::RefCountedObject<FakeVideoTrackForStats>(id));
hbos09bc1282016-11-08 14:29:22205 video_track->set_state(state);
206 return video_track;
207 }
208
Steve Anton36b29d12017-10-30 16:57:42209 explicit FakeVideoTrackForStats(const std::string& id)
210 : MediaStreamTrack<VideoTrackInterface>(id) {}
hbos09bc1282016-11-08 14:29:22211
212 std::string kind() const override {
213 return MediaStreamTrackInterface::kVideoKind;
214 }
perkj773be362017-08-01 06:22:01215
216 void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
217 const rtc::VideoSinkWants& wants) override{};
218 void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override{};
219
hbos9e302742017-01-20 10:47:10220 VideoTrackSourceInterface* GetSource() const override { return nullptr; }
hbos09bc1282016-11-08 14:29:22221};
222
hbos84abeb12017-01-16 14:16:44223rtc::scoped_refptr<MediaStreamTrackInterface> CreateFakeTrack(
224 cricket::MediaType media_type,
hbos9e302742017-01-20 10:47:10225 const std::string& track_id,
226 MediaStreamTrackInterface::TrackState track_state) {
hbos84abeb12017-01-16 14:16:44227 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
hbos9e302742017-01-20 10:47:10228 return FakeAudioTrackForStats::Create(track_id, track_state);
hbos84abeb12017-01-16 14:16:44229 } else {
230 RTC_DCHECK_EQ(media_type, cricket::MEDIA_TYPE_VIDEO);
hbos9e302742017-01-20 10:47:10231 return FakeVideoTrackForStats::Create(track_id, track_state);
hbos84abeb12017-01-16 14:16:44232 }
233}
234
Steve Anton57858b32018-02-15 23:19:50235rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
Mirko Bonadeic61ce0d2017-11-21 16:04:20236 const rtc::scoped_refptr<MediaStreamTrackInterface>& track,
Harald Alvestrandc72af932018-01-11 16:18:19237 uint32_t ssrc,
Harald Alvestranda3dab842018-01-14 08:18:58238 int attachment_id,
239 std::vector<std::string> local_stream_ids) {
Steve Anton57858b32018-02-15 23:19:50240 rtc::scoped_refptr<MockRtpSenderInternal> sender(
241 new rtc::RefCountedObject<MockRtpSenderInternal>());
hbos9e302742017-01-20 10:47:10242 EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
243 EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
Yves Gerey665174f2018-06-19 13:03:05244 EXPECT_CALL(*sender, media_type())
245 .WillRepeatedly(
246 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
247 ? cricket::MEDIA_TYPE_AUDIO
248 : cricket::MEDIA_TYPE_VIDEO));
249 EXPECT_CALL(*sender, GetParameters()).WillRepeatedly(Invoke([ssrc]() {
250 RtpParameters params;
251 params.encodings.push_back(RtpEncodingParameters());
252 params.encodings[0].ssrc = ssrc;
253 return params;
254 }));
Harald Alvestrandc72af932018-01-11 16:18:19255 EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(Return(attachment_id));
Harald Alvestranda3dab842018-01-14 08:18:58256 EXPECT_CALL(*sender, stream_ids()).WillRepeatedly(Return(local_stream_ids));
hbos9e302742017-01-20 10:47:10257 return sender;
258}
259
Steve Anton57858b32018-02-15 23:19:50260rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
Mirko Bonadeic61ce0d2017-11-21 16:04:20261 const rtc::scoped_refptr<MediaStreamTrackInterface>& track,
Harald Alvestrandc72af932018-01-11 16:18:19262 uint32_t ssrc,
263 int attachment_id) {
Steve Anton57858b32018-02-15 23:19:50264 rtc::scoped_refptr<MockRtpReceiverInternal> receiver(
265 new rtc::RefCountedObject<MockRtpReceiverInternal>());
hbos9e302742017-01-20 10:47:10266 EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
Harald Alvestranda3dab842018-01-14 08:18:58267 EXPECT_CALL(*receiver, streams())
268 .WillRepeatedly(
269 Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>({})));
270
Yves Gerey665174f2018-06-19 13:03:05271 EXPECT_CALL(*receiver, media_type())
272 .WillRepeatedly(
273 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
274 ? cricket::MEDIA_TYPE_AUDIO
275 : cricket::MEDIA_TYPE_VIDEO));
276 EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly(Invoke([ssrc]() {
277 RtpParameters params;
278 params.encodings.push_back(RtpEncodingParameters());
279 params.encodings[0].ssrc = ssrc;
280 return params;
281 }));
Harald Alvestrandc72af932018-01-11 16:18:19282 EXPECT_CALL(*receiver, AttachmentId()).WillRepeatedly(Return(attachment_id));
hbos9e302742017-01-20 10:47:10283 return receiver;
284}
285
Steve Anton5b387312018-02-03 00:00:20286class RTCStatsCollectorWrapper {
hbosd565b732016-08-30 21:04:35287 public:
Steve Anton5b387312018-02-03 00:00:20288 explicit RTCStatsCollectorWrapper(
289 rtc::scoped_refptr<FakePeerConnectionForStats> pc)
290 : pc_(pc),
291 stats_collector_(
292 RTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec)) {
hbosd565b732016-08-30 21:04:35293 }
294
Steve Anton5b387312018-02-03 00:00:20295 rtc::scoped_refptr<RTCStatsCollector> stats_collector() {
296 return stats_collector_;
hbosd565b732016-08-30 21:04:35297 }
298
Henrik Boström5b3541f2018-03-19 12:52:56299 rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
300 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
301 stats_collector_->GetStatsReport(callback);
302 return WaitForReport(callback);
303 }
304
305 rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithSenderSelector(
306 rtc::scoped_refptr<RtpSenderInternal> selector) {
307 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
308 stats_collector_->GetStatsReport(selector, callback);
309 return WaitForReport(callback);
310 }
311
312 rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithReceiverSelector(
313 rtc::scoped_refptr<RtpReceiverInternal> selector) {
314 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
315 stats_collector_->GetStatsReport(selector, callback);
316 return WaitForReport(callback);
317 }
318
Steve Anton5b387312018-02-03 00:00:20319 rtc::scoped_refptr<const RTCStatsReport> GetFreshStatsReport() {
320 stats_collector_->ClearCachedStatsReport();
321 return GetStatsReport();
322 }
323
Henrik Boström5b3541f2018-03-19 12:52:56324 rtc::scoped_refptr<MockRtpSenderInternal> SetupLocalTrackAndSender(
325 cricket::MediaType media_type,
326 const std::string& track_id,
327 uint32_t ssrc,
328 bool add_stream) {
Harald Alvestrand89061872018-01-02 13:08:34329 rtc::scoped_refptr<MediaStream> local_stream;
330 if (add_stream) {
Seth Hampson845e8782018-03-02 19:34:10331 local_stream = MediaStream::Create("LocalStreamId");
Steve Anton5b387312018-02-03 00:00:20332 pc_->mutable_local_streams()->AddStream(local_stream);
Harald Alvestrand89061872018-01-02 13:08:34333 }
hbos84abeb12017-01-16 14:16:44334
335 rtc::scoped_refptr<MediaStreamTrackInterface> track;
336 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
hbos9e302742017-01-20 10:47:10337 track = CreateFakeTrack(media_type, track_id,
338 MediaStreamTrackInterface::kLive);
Harald Alvestrand89061872018-01-02 13:08:34339 if (add_stream) {
340 local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
341 }
hbos84abeb12017-01-16 14:16:44342 } else {
hbos9e302742017-01-20 10:47:10343 track = CreateFakeTrack(media_type, track_id,
344 MediaStreamTrackInterface::kLive);
Harald Alvestrand89061872018-01-02 13:08:34345 if (add_stream) {
346 local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
347 }
hbos84abeb12017-01-16 14:16:44348 }
349
Steve Anton57858b32018-02-15 23:19:50350 rtc::scoped_refptr<MockRtpSenderInternal> sender =
Harald Alvestranda3dab842018-01-14 08:18:58351 CreateMockSender(track, ssrc, 50, {});
Steve Anton5b387312018-02-03 00:00:20352 pc_->AddSender(sender);
Henrik Boström5b3541f2018-03-19 12:52:56353 return sender;
hbos84abeb12017-01-16 14:16:44354 }
355
Henrik Boström5b3541f2018-03-19 12:52:56356 rtc::scoped_refptr<MockRtpReceiverInternal> SetupRemoteTrackAndReceiver(
357 cricket::MediaType media_type,
358 const std::string& track_id,
359 const std::string& stream_id,
360 uint32_t ssrc) {
hbos84abeb12017-01-16 14:16:44361 rtc::scoped_refptr<MediaStream> remote_stream =
Henrik Boström5b3541f2018-03-19 12:52:56362 MediaStream::Create(stream_id);
Steve Anton5b387312018-02-03 00:00:20363 pc_->mutable_remote_streams()->AddStream(remote_stream);
hbos84abeb12017-01-16 14:16:44364
365 rtc::scoped_refptr<MediaStreamTrackInterface> track;
366 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
hbos9e302742017-01-20 10:47:10367 track = CreateFakeTrack(media_type, track_id,
368 MediaStreamTrackInterface::kLive);
hbos84abeb12017-01-16 14:16:44369 remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
370 } else {
hbos9e302742017-01-20 10:47:10371 track = CreateFakeTrack(media_type, track_id,
372 MediaStreamTrackInterface::kLive);
hbos84abeb12017-01-16 14:16:44373 remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
374 }
375
Steve Anton57858b32018-02-15 23:19:50376 rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
Harald Alvestrandc72af932018-01-11 16:18:19377 CreateMockReceiver(track, ssrc, 62);
Harald Alvestranda3dab842018-01-14 08:18:58378 EXPECT_CALL(*receiver, streams())
379 .WillRepeatedly(
380 Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>(
381 {remote_stream})));
Steve Anton5b387312018-02-03 00:00:20382 pc_->AddReceiver(receiver);
Henrik Boström5b3541f2018-03-19 12:52:56383 return receiver;
hbos84abeb12017-01-16 14:16:44384 }
385
hbos9e302742017-01-20 10:47:10386 // Attaches tracks to peer connections by configuring RTP senders and RTP
387 // receivers according to the tracks' pairings with
388 // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be
389 // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only
390 // be associated with one |[Voice/Video]ReceiverInfo|.
391 void CreateMockRtpSendersReceiversAndChannels(
Harald Alvestranda3dab842018-01-14 08:18:58392 std::initializer_list<
393 std::pair<MediaStreamTrackInterface*, cricket::VoiceSenderInfo>>
394 local_audio_track_info_pairs,
395 std::initializer_list<
396 std::pair<MediaStreamTrackInterface*, cricket::VoiceReceiverInfo>>
397 remote_audio_track_info_pairs,
398 std::initializer_list<
399 std::pair<MediaStreamTrackInterface*, cricket::VideoSenderInfo>>
400 local_video_track_info_pairs,
401 std::initializer_list<
402 std::pair<MediaStreamTrackInterface*, cricket::VideoReceiverInfo>>
403 remote_video_track_info_pairs,
404 std::vector<std::string> local_stream_ids,
405 std::vector<rtc::scoped_refptr<MediaStreamInterface>> remote_streams) {
Steve Anton5b387312018-02-03 00:00:20406 cricket::VoiceMediaInfo voice_media_info;
407 cricket::VideoMediaInfo video_media_info;
408
hbos9e302742017-01-20 10:47:10409 // Local audio tracks and voice sender infos
Harald Alvestrandc72af932018-01-11 16:18:19410 int attachment_id = 147;
hbos9e302742017-01-20 10:47:10411 for (auto& pair : local_audio_track_info_pairs) {
412 MediaStreamTrackInterface* local_audio_track = pair.first;
413 const cricket::VoiceSenderInfo& voice_sender_info = pair.second;
414 RTC_DCHECK_EQ(local_audio_track->kind(),
415 MediaStreamTrackInterface::kAudioKind);
416
Steve Anton5b387312018-02-03 00:00:20417 voice_media_info.senders.push_back(voice_sender_info);
Steve Anton57858b32018-02-15 23:19:50418 rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
Harald Alvestrandc72af932018-01-11 16:18:19419 rtc::scoped_refptr<MediaStreamTrackInterface>(local_audio_track),
Harald Alvestranda3dab842018-01-14 08:18:58420 voice_sender_info.local_stats[0].ssrc, attachment_id++,
421 local_stream_ids);
Steve Anton5b387312018-02-03 00:00:20422 pc_->AddSender(rtp_sender);
hbos9e302742017-01-20 10:47:10423 }
Steve Anton5b387312018-02-03 00:00:20424
hbos9e302742017-01-20 10:47:10425 // Remote audio tracks and voice receiver infos
Harald Alvestrandc72af932018-01-11 16:18:19426 attachment_id = 181;
hbos9e302742017-01-20 10:47:10427 for (auto& pair : remote_audio_track_info_pairs) {
428 MediaStreamTrackInterface* remote_audio_track = pair.first;
429 const cricket::VoiceReceiverInfo& voice_receiver_info = pair.second;
430 RTC_DCHECK_EQ(remote_audio_track->kind(),
431 MediaStreamTrackInterface::kAudioKind);
432
Steve Anton5b387312018-02-03 00:00:20433 voice_media_info.receivers.push_back(voice_receiver_info);
Steve Anton57858b32018-02-15 23:19:50434 rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
435 CreateMockReceiver(
436 rtc::scoped_refptr<MediaStreamTrackInterface>(remote_audio_track),
437 voice_receiver_info.local_stats[0].ssrc, attachment_id++);
Harald Alvestranda3dab842018-01-14 08:18:58438 EXPECT_CALL(*rtp_receiver, streams())
439 .WillRepeatedly(Return(remote_streams));
Steve Anton5b387312018-02-03 00:00:20440 pc_->AddReceiver(rtp_receiver);
hbos9e302742017-01-20 10:47:10441 }
Steve Anton5b387312018-02-03 00:00:20442
hbos9e302742017-01-20 10:47:10443 // Local video tracks and video sender infos
Harald Alvestrandc72af932018-01-11 16:18:19444 attachment_id = 151;
hbos9e302742017-01-20 10:47:10445 for (auto& pair : local_video_track_info_pairs) {
446 MediaStreamTrackInterface* local_video_track = pair.first;
447 const cricket::VideoSenderInfo& video_sender_info = pair.second;
448 RTC_DCHECK_EQ(local_video_track->kind(),
449 MediaStreamTrackInterface::kVideoKind);
450
Steve Anton5b387312018-02-03 00:00:20451 video_media_info.senders.push_back(video_sender_info);
Steve Anton57858b32018-02-15 23:19:50452 rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
Harald Alvestrandc72af932018-01-11 16:18:19453 rtc::scoped_refptr<MediaStreamTrackInterface>(local_video_track),
Harald Alvestranda3dab842018-01-14 08:18:58454 video_sender_info.local_stats[0].ssrc, attachment_id++,
455 local_stream_ids);
Steve Anton5b387312018-02-03 00:00:20456 pc_->AddSender(rtp_sender);
hbos9e302742017-01-20 10:47:10457 }
Steve Anton5b387312018-02-03 00:00:20458
hbos9e302742017-01-20 10:47:10459 // Remote video tracks and video receiver infos
Harald Alvestrandc72af932018-01-11 16:18:19460 attachment_id = 191;
hbos9e302742017-01-20 10:47:10461 for (auto& pair : remote_video_track_info_pairs) {
462 MediaStreamTrackInterface* remote_video_track = pair.first;
463 const cricket::VideoReceiverInfo& video_receiver_info = pair.second;
464 RTC_DCHECK_EQ(remote_video_track->kind(),
465 MediaStreamTrackInterface::kVideoKind);
466
Steve Anton5b387312018-02-03 00:00:20467 video_media_info.receivers.push_back(video_receiver_info);
Steve Anton57858b32018-02-15 23:19:50468 rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
469 CreateMockReceiver(
470 rtc::scoped_refptr<MediaStreamTrackInterface>(remote_video_track),
471 video_receiver_info.local_stats[0].ssrc, attachment_id++);
Harald Alvestranda3dab842018-01-14 08:18:58472 EXPECT_CALL(*rtp_receiver, streams())
473 .WillRepeatedly(Return(remote_streams));
Steve Anton5b387312018-02-03 00:00:20474 pc_->AddReceiver(rtp_receiver);
hbos9e302742017-01-20 10:47:10475 }
hbos9e302742017-01-20 10:47:10476
Steve Anton5b387312018-02-03 00:00:20477 auto* voice_media_channel = pc_->AddVoiceChannel("audio", "transport");
478 voice_media_channel->SetStats(voice_media_info);
hbos9e302742017-01-20 10:47:10479
Steve Anton5b387312018-02-03 00:00:20480 auto* video_media_channel = pc_->AddVideoChannel("video", "transport");
481 video_media_channel->SetStats(video_media_info);
hbos9e302742017-01-20 10:47:10482 }
483
hbosd565b732016-08-30 21:04:35484 private:
Henrik Boström5b3541f2018-03-19 12:52:56485 rtc::scoped_refptr<const RTCStatsReport> WaitForReport(
486 rtc::scoped_refptr<RTCStatsObtainer> callback) {
487 EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
488 int64_t after = rtc::TimeUTCMicros();
489 for (const RTCStats& stats : *callback->report()) {
490 EXPECT_LE(stats.timestamp_us(), after);
491 }
492 return callback->report();
493 }
494
Steve Anton5b387312018-02-03 00:00:20495 rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
496 rtc::scoped_refptr<RTCStatsCollector> stats_collector_;
hbosd565b732016-08-30 21:04:35497};
498
hbosc82f2e12016-09-05 08:36:50499class RTCStatsCollectorTest : public testing::Test {
500 public:
501 RTCStatsCollectorTest()
Steve Anton5b387312018-02-03 00:00:20502 : pc_(new rtc::RefCountedObject<FakePeerConnectionForStats>()),
503 stats_(new RTCStatsCollectorWrapper(pc_)) {}
hbosc82f2e12016-09-05 08:36:50504
hbos6ab97ce02016-10-03 21:16:56505 void ExpectReportContainsCertificateInfo(
506 const rtc::scoped_refptr<const RTCStatsReport>& report,
hbos23368e12016-12-21 12:29:17507 const CertificateInfo& certinfo) {
508 for (size_t i = 0; i < certinfo.fingerprints.size(); ++i) {
509 RTCCertificateStats expected_certificate_stats(
Yves Gerey665174f2018-06-19 13:03:05510 "RTCCertificate_" + certinfo.fingerprints[i], report->timestamp_us());
hbos23368e12016-12-21 12:29:17511 expected_certificate_stats.fingerprint = certinfo.fingerprints[i];
512 expected_certificate_stats.fingerprint_algorithm = "sha-1";
513 expected_certificate_stats.base64_certificate = certinfo.pems[i];
514 if (i + 1 < certinfo.fingerprints.size()) {
515 expected_certificate_stats.issuer_certificate_id =
516 "RTCCertificate_" + certinfo.fingerprints[i + 1];
hbos6ab97ce02016-10-03 21:16:56517 }
hbos23368e12016-12-21 12:29:17518 ASSERT_TRUE(report->Get(expected_certificate_stats.id()));
519 EXPECT_EQ(expected_certificate_stats,
Yves Gerey665174f2018-06-19 13:03:05520 report->Get(expected_certificate_stats.id())
521 ->cast_to<RTCCertificateStats>());
hbos6ab97ce02016-10-03 21:16:56522 }
523 }
524
Henrik Boström5b3541f2018-03-19 12:52:56525 struct ExampleStatsGraph {
526 rtc::scoped_refptr<RtpSenderInternal> sender;
527 rtc::scoped_refptr<RtpReceiverInternal> receiver;
528
529 rtc::scoped_refptr<const RTCStatsReport> full_report;
530 std::string send_codec_id;
531 std::string recv_codec_id;
532 std::string outbound_rtp_id;
533 std::string inbound_rtp_id;
534 std::string transport_id;
535 std::string sender_track_id;
536 std::string receiver_track_id;
537 std::string remote_stream_id;
538 std::string peer_connection_id;
539 };
540
541 // Sets up the example stats graph (see ASCII art below) used for testing the
542 // stats selection algorithm,
543 // https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm.
544 // These tests test the integration of the stats traversal algorithm inside of
545 // RTCStatsCollector. See rtcstatstraveral_unittest.cc for more stats
546 // traversal tests.
547 ExampleStatsGraph SetupExampleStatsGraphForSelectorTests() {
548 ExampleStatsGraph graph;
549
550 // codec (send)
551 graph.send_codec_id = "RTCCodec_VideoMid_Outbound_1";
552 cricket::VideoMediaInfo video_media_info;
553 RtpCodecParameters send_codec;
554 send_codec.payload_type = 1;
555 send_codec.clock_rate = 0;
556 video_media_info.send_codecs.insert(
557 std::make_pair(send_codec.payload_type, send_codec));
558 // codec (recv)
559 graph.recv_codec_id = "RTCCodec_VideoMid_Inbound_2";
560 RtpCodecParameters recv_codec;
561 recv_codec.payload_type = 2;
562 recv_codec.clock_rate = 0;
563 video_media_info.receive_codecs.insert(
564 std::make_pair(recv_codec.payload_type, recv_codec));
565 // outbound-rtp
566 graph.outbound_rtp_id = "RTCOutboundRTPVideoStream_3";
567 video_media_info.senders.push_back(cricket::VideoSenderInfo());
568 video_media_info.senders[0].local_stats.push_back(
569 cricket::SsrcSenderInfo());
570 video_media_info.senders[0].local_stats[0].ssrc = 3;
571 video_media_info.senders[0].codec_payload_type = send_codec.payload_type;
572 // inbound-rtp
573 graph.inbound_rtp_id = "RTCInboundRTPVideoStream_4";
574 video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
575 video_media_info.receivers[0].local_stats.push_back(
576 cricket::SsrcReceiverInfo());
577 video_media_info.receivers[0].local_stats[0].ssrc = 4;
578 video_media_info.receivers[0].codec_payload_type = recv_codec.payload_type;
579 // transport
580 graph.transport_id = "RTCTransport_TransportName_1";
581 auto* video_media_channel =
582 pc_->AddVideoChannel("VideoMid", "TransportName");
583 video_media_channel->SetStats(video_media_info);
584 // track (sender)
585 graph.sender = stats_->SetupLocalTrackAndSender(
586 cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID", 3, false);
587 graph.sender_track_id = "RTCMediaStreamTrack_sender_" +
Jonas Olsson6b1985d2018-07-05 09:59:48588 rtc::ToString(graph.sender->AttachmentId());
Henrik Boström5b3541f2018-03-19 12:52:56589 // track (receiver) and stream (remote stream)
590 graph.receiver = stats_->SetupRemoteTrackAndReceiver(
591 cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 4);
592 graph.receiver_track_id = "RTCMediaStreamTrack_receiver_" +
Jonas Olsson6b1985d2018-07-05 09:59:48593 rtc::ToString(graph.receiver->AttachmentId());
Henrik Boström5b3541f2018-03-19 12:52:56594 graph.remote_stream_id = "RTCMediaStream_RemoteStreamId";
595 // peer-connection
596 graph.peer_connection_id = "RTCPeerConnection";
597
598 // Expected stats graph:
599 //
600 // track (sender) stream (remote stream) ---> track (receiver)
601 // ^ ^
602 // | |
603 // outbound-rtp inbound-rtp ---------------+
604 // | | | |
605 // v v v v
606 // codec (send) transport codec (recv) peer-connection
607
608 // Verify the stats graph is set up correctly.
609 graph.full_report = stats_->GetStatsReport();
610 EXPECT_EQ(graph.full_report->size(), 9u);
611 EXPECT_TRUE(graph.full_report->Get(graph.send_codec_id));
612 EXPECT_TRUE(graph.full_report->Get(graph.recv_codec_id));
613 EXPECT_TRUE(graph.full_report->Get(graph.outbound_rtp_id));
614 EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id));
615 EXPECT_TRUE(graph.full_report->Get(graph.transport_id));
616 EXPECT_TRUE(graph.full_report->Get(graph.sender_track_id));
617 EXPECT_TRUE(graph.full_report->Get(graph.receiver_track_id));
618 EXPECT_TRUE(graph.full_report->Get(graph.remote_stream_id));
619 EXPECT_TRUE(graph.full_report->Get(graph.peer_connection_id));
620 const auto& outbound_rtp = graph.full_report->Get(graph.outbound_rtp_id)
621 ->cast_to<RTCOutboundRTPStreamStats>();
622 EXPECT_EQ(*outbound_rtp.codec_id, graph.send_codec_id);
623 EXPECT_EQ(*outbound_rtp.track_id, graph.sender_track_id);
624 EXPECT_EQ(*outbound_rtp.transport_id, graph.transport_id);
625 const auto& inbound_rtp = graph.full_report->Get(graph.inbound_rtp_id)
626 ->cast_to<RTCInboundRTPStreamStats>();
627 EXPECT_EQ(*inbound_rtp.codec_id, graph.recv_codec_id);
628 EXPECT_EQ(*inbound_rtp.track_id, graph.receiver_track_id);
629 EXPECT_EQ(*inbound_rtp.transport_id, graph.transport_id);
630
631 return graph;
632 }
633
hbosc82f2e12016-09-05 08:36:50634 protected:
Steve Anton5b387312018-02-03 00:00:20635 rtc::ScopedFakeClock fake_clock_;
636 rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
637 std::unique_ptr<RTCStatsCollectorWrapper> stats_;
hbosc82f2e12016-09-05 08:36:50638};
639
640TEST_F(RTCStatsCollectorTest, SingleCallback) {
641 rtc::scoped_refptr<const RTCStatsReport> result;
Steve Anton5b387312018-02-03 00:00:20642 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&result));
hbosc82f2e12016-09-05 08:36:50643 EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs);
644}
645
646TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
Steve Anton5b387312018-02-03 00:00:20647 rtc::scoped_refptr<const RTCStatsReport> a, b, c;
648 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
649 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
650 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
hbosc82f2e12016-09-05 08:36:50651 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
652 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
653 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
Steve Anton5b387312018-02-03 00:00:20654
hbosc82f2e12016-09-05 08:36:50655 EXPECT_EQ(a.get(), b.get());
656 EXPECT_EQ(b.get(), c.get());
657}
658
659TEST_F(RTCStatsCollectorTest, CachedStatsReports) {
hbosd565b732016-08-30 21:04:35660 // Caching should ensure |a| and |b| are the same report.
Steve Anton5b387312018-02-03 00:00:20661 rtc::scoped_refptr<const RTCStatsReport> a = stats_->GetStatsReport();
662 rtc::scoped_refptr<const RTCStatsReport> b = stats_->GetStatsReport();
hbosd565b732016-08-30 21:04:35663 EXPECT_EQ(a.get(), b.get());
664 // Invalidate cache by clearing it.
Steve Anton5b387312018-02-03 00:00:20665 stats_->stats_collector()->ClearCachedStatsReport();
666 rtc::scoped_refptr<const RTCStatsReport> c = stats_->GetStatsReport();
hbosd565b732016-08-30 21:04:35667 EXPECT_NE(b.get(), c.get());
668 // Invalidate cache by advancing time.
Sebastian Jansson5f83cf02018-05-08 12:52:22669 fake_clock_.AdvanceTime(TimeDelta::ms(51));
Steve Anton5b387312018-02-03 00:00:20670 rtc::scoped_refptr<const RTCStatsReport> d = stats_->GetStatsReport();
hbosd565b732016-08-30 21:04:35671 EXPECT_TRUE(d);
672 EXPECT_NE(c.get(), d.get());
673}
674
hbosc82f2e12016-09-05 08:36:50675TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) {
Steve Anton5b387312018-02-03 00:00:20676 rtc::scoped_refptr<const RTCStatsReport> a, b, c;
677 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
678 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
hbosc82f2e12016-09-05 08:36:50679 // Cache is invalidated after 50 ms.
Sebastian Jansson5f83cf02018-05-08 12:52:22680 fake_clock_.AdvanceTime(TimeDelta::ms(51));
Steve Anton5b387312018-02-03 00:00:20681 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
hbosc82f2e12016-09-05 08:36:50682 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
683 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
684 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
685 EXPECT_EQ(a.get(), b.get());
686 // The act of doing |AdvanceTime| processes all messages. If this was not the
687 // case we might not require |c| to be fresher than |b|.
688 EXPECT_NE(c.get(), b.get());
689}
690
hbos6ab97ce02016-10-03 21:16:56691TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) {
Steve Anton5b387312018-02-03 00:00:20692 const char kTransportName[] = "transport";
693
694 pc_->AddVoiceChannel("audio", kTransportName);
695
hbos6ab97ce02016-10-03 21:16:56696 std::unique_ptr<CertificateInfo> local_certinfo =
697 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05698 std::vector<std::string>({"(local) single certificate"}));
Steve Anton5b387312018-02-03 00:00:20699 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
700
hbos6ab97ce02016-10-03 21:16:56701 std::unique_ptr<CertificateInfo> remote_certinfo =
702 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05703 std::vector<std::string>({"(remote) single certificate"}));
Taylor Brandstetterc3928662018-02-23 21:04:51704 pc_->SetRemoteCertChain(
Benjamin Wright6c6c9df2018-10-25 08:16:26705 kTransportName,
706 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
hbos6ab97ce02016-10-03 21:16:56707
Steve Anton5b387312018-02-03 00:00:20708 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos6ab97ce02016-10-03 21:16:56709
hbos23368e12016-12-21 12:29:17710 ExpectReportContainsCertificateInfo(report, *local_certinfo);
711 ExpectReportContainsCertificateInfo(report, *remote_certinfo);
hbos6ab97ce02016-10-03 21:16:56712}
713
hbos0adb8282016-11-23 10:32:06714TEST_F(RTCStatsCollectorTest, CollectRTCCodecStats) {
hbos0adb8282016-11-23 10:32:06715 // Audio
716 cricket::VoiceMediaInfo voice_media_info;
717
718 RtpCodecParameters inbound_audio_codec;
719 inbound_audio_codec.payload_type = 1;
deadbeefe702b302017-02-04 20:09:01720 inbound_audio_codec.kind = cricket::MEDIA_TYPE_AUDIO;
721 inbound_audio_codec.name = "opus";
Oskar Sundbomcbc71b22017-11-16 09:56:07722 inbound_audio_codec.clock_rate = 1337;
hbos0adb8282016-11-23 10:32:06723 voice_media_info.receive_codecs.insert(
724 std::make_pair(inbound_audio_codec.payload_type, inbound_audio_codec));
725
726 RtpCodecParameters outbound_audio_codec;
727 outbound_audio_codec.payload_type = 2;
deadbeefe702b302017-02-04 20:09:01728 outbound_audio_codec.kind = cricket::MEDIA_TYPE_AUDIO;
729 outbound_audio_codec.name = "isac";
Oskar Sundbomcbc71b22017-11-16 09:56:07730 outbound_audio_codec.clock_rate = 1338;
hbos0adb8282016-11-23 10:32:06731 voice_media_info.send_codecs.insert(
732 std::make_pair(outbound_audio_codec.payload_type, outbound_audio_codec));
733
Steve Anton57858b32018-02-15 23:19:50734 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:20735 voice_media_channel->SetStats(voice_media_info);
hbos0adb8282016-11-23 10:32:06736
737 // Video
738 cricket::VideoMediaInfo video_media_info;
739
740 RtpCodecParameters inbound_video_codec;
741 inbound_video_codec.payload_type = 3;
deadbeefe702b302017-02-04 20:09:01742 inbound_video_codec.kind = cricket::MEDIA_TYPE_VIDEO;
743 inbound_video_codec.name = "H264";
Oskar Sundbomcbc71b22017-11-16 09:56:07744 inbound_video_codec.clock_rate = 1339;
hbos0adb8282016-11-23 10:32:06745 video_media_info.receive_codecs.insert(
746 std::make_pair(inbound_video_codec.payload_type, inbound_video_codec));
747
748 RtpCodecParameters outbound_video_codec;
749 outbound_video_codec.payload_type = 4;
deadbeefe702b302017-02-04 20:09:01750 outbound_video_codec.kind = cricket::MEDIA_TYPE_VIDEO;
751 outbound_video_codec.name = "VP8";
Oskar Sundbomcbc71b22017-11-16 09:56:07752 outbound_video_codec.clock_rate = 1340;
hbos0adb8282016-11-23 10:32:06753 video_media_info.send_codecs.insert(
754 std::make_pair(outbound_video_codec.payload_type, outbound_video_codec));
755
Steve Anton57858b32018-02-15 23:19:50756 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:20757 video_media_channel->SetStats(video_media_info);
hbos0adb8282016-11-23 10:32:06758
Steve Anton5b387312018-02-03 00:00:20759 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos0adb8282016-11-23 10:32:06760
Steve Anton57858b32018-02-15 23:19:50761 RTCCodecStats expected_inbound_audio_codec("RTCCodec_AudioMid_Inbound_1",
762 report->timestamp_us());
hbos0adb8282016-11-23 10:32:06763 expected_inbound_audio_codec.payload_type = 1;
hbos13f54b22017-02-28 14:56:04764 expected_inbound_audio_codec.mime_type = "audio/opus";
hbos0adb8282016-11-23 10:32:06765 expected_inbound_audio_codec.clock_rate = 1337;
766
Steve Anton57858b32018-02-15 23:19:50767 RTCCodecStats expected_outbound_audio_codec("RTCCodec_AudioMid_Outbound_2",
768 report->timestamp_us());
hbos0adb8282016-11-23 10:32:06769 expected_outbound_audio_codec.payload_type = 2;
hbos13f54b22017-02-28 14:56:04770 expected_outbound_audio_codec.mime_type = "audio/isac";
hbos0adb8282016-11-23 10:32:06771 expected_outbound_audio_codec.clock_rate = 1338;
772
Steve Anton57858b32018-02-15 23:19:50773 RTCCodecStats expected_inbound_video_codec("RTCCodec_VideoMid_Inbound_3",
774 report->timestamp_us());
hbos0adb8282016-11-23 10:32:06775 expected_inbound_video_codec.payload_type = 3;
hbos13f54b22017-02-28 14:56:04776 expected_inbound_video_codec.mime_type = "video/H264";
hbos0adb8282016-11-23 10:32:06777 expected_inbound_video_codec.clock_rate = 1339;
778
Steve Anton57858b32018-02-15 23:19:50779 RTCCodecStats expected_outbound_video_codec("RTCCodec_VideoMid_Outbound_4",
780 report->timestamp_us());
hbos0adb8282016-11-23 10:32:06781 expected_outbound_video_codec.payload_type = 4;
hbos13f54b22017-02-28 14:56:04782 expected_outbound_video_codec.mime_type = "video/VP8";
hbos0adb8282016-11-23 10:32:06783 expected_outbound_video_codec.clock_rate = 1340;
784
nissec8ee8822017-01-18 15:20:55785 ASSERT_TRUE(report->Get(expected_inbound_audio_codec.id()));
Yves Gerey665174f2018-06-19 13:03:05786 EXPECT_EQ(
787 expected_inbound_audio_codec,
788 report->Get(expected_inbound_audio_codec.id())->cast_to<RTCCodecStats>());
hbos0adb8282016-11-23 10:32:06789
nissec8ee8822017-01-18 15:20:55790 ASSERT_TRUE(report->Get(expected_outbound_audio_codec.id()));
hbos0adb8282016-11-23 10:32:06791 EXPECT_EQ(expected_outbound_audio_codec,
Yves Gerey665174f2018-06-19 13:03:05792 report->Get(expected_outbound_audio_codec.id())
793 ->cast_to<RTCCodecStats>());
hbos0adb8282016-11-23 10:32:06794
nissec8ee8822017-01-18 15:20:55795 ASSERT_TRUE(report->Get(expected_inbound_video_codec.id()));
Yves Gerey665174f2018-06-19 13:03:05796 EXPECT_EQ(
797 expected_inbound_video_codec,
798 report->Get(expected_inbound_video_codec.id())->cast_to<RTCCodecStats>());
hbos0adb8282016-11-23 10:32:06799
nissec8ee8822017-01-18 15:20:55800 ASSERT_TRUE(report->Get(expected_outbound_video_codec.id()));
hbos0adb8282016-11-23 10:32:06801 EXPECT_EQ(expected_outbound_video_codec,
Yves Gerey665174f2018-06-19 13:03:05802 report->Get(expected_outbound_video_codec.id())
803 ->cast_to<RTCCodecStats>());
hbos0adb8282016-11-23 10:32:06804}
805
hbos6ab97ce02016-10-03 21:16:56806TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsMultiple) {
Steve Anton5b387312018-02-03 00:00:20807 const char kAudioTransport[] = "audio";
808 const char kVideoTransport[] = "video";
809
810 pc_->AddVoiceChannel("audio", kAudioTransport);
hbos6ab97ce02016-10-03 21:16:56811 std::unique_ptr<CertificateInfo> audio_local_certinfo =
812 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05813 std::vector<std::string>({"(local) audio"}));
Steve Anton5b387312018-02-03 00:00:20814 pc_->SetLocalCertificate(kAudioTransport, audio_local_certinfo->certificate);
hbos6ab97ce02016-10-03 21:16:56815 std::unique_ptr<CertificateInfo> audio_remote_certinfo =
816 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05817 std::vector<std::string>({"(remote) audio"}));
Taylor Brandstetterc3928662018-02-23 21:04:51818 pc_->SetRemoteCertChain(
819 kAudioTransport,
Benjamin Wright6c6c9df2018-10-25 08:16:26820 audio_remote_certinfo->certificate->GetSSLCertificateChain().Clone());
hbos6ab97ce02016-10-03 21:16:56821
Steve Anton5b387312018-02-03 00:00:20822 pc_->AddVideoChannel("video", kVideoTransport);
hbos6ab97ce02016-10-03 21:16:56823 std::unique_ptr<CertificateInfo> video_local_certinfo =
824 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05825 std::vector<std::string>({"(local) video"}));
Steve Anton5b387312018-02-03 00:00:20826 pc_->SetLocalCertificate(kVideoTransport, video_local_certinfo->certificate);
hbos6ab97ce02016-10-03 21:16:56827 std::unique_ptr<CertificateInfo> video_remote_certinfo =
828 CreateFakeCertificateAndInfoFromDers(
Yves Gerey665174f2018-06-19 13:03:05829 std::vector<std::string>({"(remote) video"}));
Taylor Brandstetterc3928662018-02-23 21:04:51830 pc_->SetRemoteCertChain(
831 kVideoTransport,
Benjamin Wright6c6c9df2018-10-25 08:16:26832 video_remote_certinfo->certificate->GetSSLCertificateChain().Clone());
hbos6ab97ce02016-10-03 21:16:56833
Steve Anton5b387312018-02-03 00:00:20834 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos23368e12016-12-21 12:29:17835 ExpectReportContainsCertificateInfo(report, *audio_local_certinfo);
836 ExpectReportContainsCertificateInfo(report, *audio_remote_certinfo);
837 ExpectReportContainsCertificateInfo(report, *video_local_certinfo);
838 ExpectReportContainsCertificateInfo(report, *video_remote_certinfo);
hbos6ab97ce02016-10-03 21:16:56839}
840
841TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) {
Steve Anton5b387312018-02-03 00:00:20842 const char kTransportName[] = "transport";
843
844 pc_->AddVoiceChannel("audio", kTransportName);
845
hbos6ab97ce02016-10-03 21:16:56846 std::unique_ptr<CertificateInfo> local_certinfo =
Steve Anton5b387312018-02-03 00:00:20847 CreateFakeCertificateAndInfoFromDers(
848 {"(local) this", "(local) is", "(local) a", "(local) chain"});
849 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
850
hbos6ab97ce02016-10-03 21:16:56851 std::unique_ptr<CertificateInfo> remote_certinfo =
Steve Anton5b387312018-02-03 00:00:20852 CreateFakeCertificateAndInfoFromDers({"(remote) this", "(remote) is",
853 "(remote) another",
854 "(remote) chain"});
Taylor Brandstetterc3928662018-02-23 21:04:51855 pc_->SetRemoteCertChain(
Benjamin Wright6c6c9df2018-10-25 08:16:26856 kTransportName,
857 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
hbos6ab97ce02016-10-03 21:16:56858
Steve Anton5b387312018-02-03 00:00:20859 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos23368e12016-12-21 12:29:17860 ExpectReportContainsCertificateInfo(report, *local_certinfo);
861 ExpectReportContainsCertificateInfo(report, *remote_certinfo);
hbos6ab97ce02016-10-03 21:16:56862}
863
hboscc555c52016-10-18 19:48:31864TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
Steve Anton5b387312018-02-03 00:00:20865 pc_->AddSctpDataChannel(new MockDataChannel(0, "MockDataChannel0",
866 DataChannelInterface::kConnecting,
867 "udp", 1, 2, 3, 4));
hbosdbb64d82016-12-21 09:57:46868 RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
869 expected_data_channel0.label = "MockDataChannel0";
870 expected_data_channel0.protocol = "udp";
871 expected_data_channel0.datachannelid = 0;
872 expected_data_channel0.state = "connecting";
873 expected_data_channel0.messages_sent = 1;
874 expected_data_channel0.bytes_sent = 2;
875 expected_data_channel0.messages_received = 3;
876 expected_data_channel0.bytes_received = 4;
877
Steve Anton5b387312018-02-03 00:00:20878 pc_->AddSctpDataChannel(new MockDataChannel(
Steve Antonbe5e2082018-01-24 23:29:17879 1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp", 5, 6, 7, 8));
hbosdbb64d82016-12-21 09:57:46880 RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
881 expected_data_channel1.label = "MockDataChannel1";
882 expected_data_channel1.protocol = "tcp";
883 expected_data_channel1.datachannelid = 1;
884 expected_data_channel1.state = "open";
885 expected_data_channel1.messages_sent = 5;
886 expected_data_channel1.bytes_sent = 6;
887 expected_data_channel1.messages_received = 7;
888 expected_data_channel1.bytes_received = 8;
889
Steve Anton5b387312018-02-03 00:00:20890 pc_->AddSctpDataChannel(new MockDataChannel(2, "MockDataChannel2",
891 DataChannelInterface::kClosing,
892 "udp", 9, 10, 11, 12));
hbosdbb64d82016-12-21 09:57:46893 RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
894 expected_data_channel2.label = "MockDataChannel2";
895 expected_data_channel2.protocol = "udp";
896 expected_data_channel2.datachannelid = 2;
897 expected_data_channel2.state = "closing";
898 expected_data_channel2.messages_sent = 9;
899 expected_data_channel2.bytes_sent = 10;
900 expected_data_channel2.messages_received = 11;
901 expected_data_channel2.bytes_received = 12;
902
Steve Anton5b387312018-02-03 00:00:20903 pc_->AddSctpDataChannel(new MockDataChannel(3, "MockDataChannel3",
904 DataChannelInterface::kClosed,
905 "tcp", 13, 14, 15, 16));
hbosdbb64d82016-12-21 09:57:46906 RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
907 expected_data_channel3.label = "MockDataChannel3";
908 expected_data_channel3.protocol = "tcp";
909 expected_data_channel3.datachannelid = 3;
910 expected_data_channel3.state = "closed";
911 expected_data_channel3.messages_sent = 13;
912 expected_data_channel3.bytes_sent = 14;
913 expected_data_channel3.messages_received = 15;
914 expected_data_channel3.bytes_received = 16;
hboscc555c52016-10-18 19:48:31915
Steve Anton5b387312018-02-03 00:00:20916 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
917
hbosdbb64d82016-12-21 09:57:46918 ASSERT_TRUE(report->Get(expected_data_channel0.id()));
Yves Gerey665174f2018-06-19 13:03:05919 EXPECT_EQ(
920 expected_data_channel0,
921 report->Get(expected_data_channel0.id())->cast_to<RTCDataChannelStats>());
hbosdbb64d82016-12-21 09:57:46922 ASSERT_TRUE(report->Get(expected_data_channel1.id()));
Yves Gerey665174f2018-06-19 13:03:05923 EXPECT_EQ(
924 expected_data_channel1,
925 report->Get(expected_data_channel1.id())->cast_to<RTCDataChannelStats>());
hbosdbb64d82016-12-21 09:57:46926 ASSERT_TRUE(report->Get(expected_data_channel2.id()));
Yves Gerey665174f2018-06-19 13:03:05927 EXPECT_EQ(
928 expected_data_channel2,
929 report->Get(expected_data_channel2.id())->cast_to<RTCDataChannelStats>());
hbosdbb64d82016-12-21 09:57:46930 ASSERT_TRUE(report->Get(expected_data_channel3.id()));
Yves Gerey665174f2018-06-19 13:03:05931 EXPECT_EQ(
932 expected_data_channel3,
933 report->Get(expected_data_channel3.id())->cast_to<RTCDataChannelStats>());
hboscc555c52016-10-18 19:48:31934}
935
hbosab9f6e42016-10-07 09:18:47936TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
937 // Candidates in the first transport stats.
Gary Liu37e489c2017-11-21 18:49:36938 std::unique_ptr<cricket::Candidate> a_local_host =
939 CreateFakeCandidate("1.2.3.4", 5, "a_local_host's protocol",
940 rtc::ADAPTER_TYPE_VPN, cricket::LOCAL_PORT_TYPE, 0);
hbosc42ba322016-12-21 11:31:45941 RTCLocalIceCandidateStats expected_a_local_host(
942 "RTCIceCandidate_" + a_local_host->id(), 0);
hbosb4e426e2017-01-02 17:59:31943 expected_a_local_host.transport_id = "RTCTransport_a_0";
Gary Liu37e489c2017-11-21 18:49:36944 expected_a_local_host.network_type = "vpn";
hbosc42ba322016-12-21 11:31:45945 expected_a_local_host.ip = "1.2.3.4";
946 expected_a_local_host.port = 5;
947 expected_a_local_host.protocol = "a_local_host's protocol";
948 expected_a_local_host.candidate_type = "host";
949 expected_a_local_host.priority = 0;
hbosc3a2b7f2017-01-02 12:46:15950 EXPECT_FALSE(*expected_a_local_host.is_remote);
hbosc42ba322016-12-21 11:31:45951
hbosab9f6e42016-10-07 09:18:47952 std::unique_ptr<cricket::Candidate> a_remote_srflx = CreateFakeCandidate(
Gary Liu37e489c2017-11-21 18:49:36953 "6.7.8.9", 10, "remote_srflx's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
954 cricket::STUN_PORT_TYPE, 1);
hbosc42ba322016-12-21 11:31:45955 RTCRemoteIceCandidateStats expected_a_remote_srflx(
956 "RTCIceCandidate_" + a_remote_srflx->id(), 0);
hbosb4e426e2017-01-02 17:59:31957 expected_a_remote_srflx.transport_id = "RTCTransport_a_0";
hbosc42ba322016-12-21 11:31:45958 expected_a_remote_srflx.ip = "6.7.8.9";
959 expected_a_remote_srflx.port = 10;
960 expected_a_remote_srflx.protocol = "remote_srflx's protocol";
961 expected_a_remote_srflx.candidate_type = "srflx";
962 expected_a_remote_srflx.priority = 1;
hbosd17a5a72017-01-02 16:09:59963 expected_a_remote_srflx.deleted = false;
hbosc3a2b7f2017-01-02 12:46:15964 EXPECT_TRUE(*expected_a_remote_srflx.is_remote);
hbosc42ba322016-12-21 11:31:45965
hbosab9f6e42016-10-07 09:18:47966 std::unique_ptr<cricket::Candidate> a_local_prflx = CreateFakeCandidate(
Gary Liu37e489c2017-11-21 18:49:36967 "11.12.13.14", 15, "a_local_prflx's protocol", rtc::ADAPTER_TYPE_CELLULAR,
968 cricket::PRFLX_PORT_TYPE, 2);
hbosc42ba322016-12-21 11:31:45969 RTCLocalIceCandidateStats expected_a_local_prflx(
970 "RTCIceCandidate_" + a_local_prflx->id(), 0);
hbosb4e426e2017-01-02 17:59:31971 expected_a_local_prflx.transport_id = "RTCTransport_a_0";
Gary Liu37e489c2017-11-21 18:49:36972 expected_a_local_prflx.network_type = "cellular";
hbosc42ba322016-12-21 11:31:45973 expected_a_local_prflx.ip = "11.12.13.14";
974 expected_a_local_prflx.port = 15;
975 expected_a_local_prflx.protocol = "a_local_prflx's protocol";
976 expected_a_local_prflx.candidate_type = "prflx";
977 expected_a_local_prflx.priority = 2;
hbosd17a5a72017-01-02 16:09:59978 expected_a_local_prflx.deleted = false;
hbosc3a2b7f2017-01-02 12:46:15979 EXPECT_FALSE(*expected_a_local_prflx.is_remote);
hbosc42ba322016-12-21 11:31:45980
hbosab9f6e42016-10-07 09:18:47981 std::unique_ptr<cricket::Candidate> a_remote_relay = CreateFakeCandidate(
Gary Liu37e489c2017-11-21 18:49:36982 "16.17.18.19", 20, "a_remote_relay's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
983 cricket::RELAY_PORT_TYPE, 3);
hbosc42ba322016-12-21 11:31:45984 RTCRemoteIceCandidateStats expected_a_remote_relay(
985 "RTCIceCandidate_" + a_remote_relay->id(), 0);
hbosb4e426e2017-01-02 17:59:31986 expected_a_remote_relay.transport_id = "RTCTransport_a_0";
hbosc42ba322016-12-21 11:31:45987 expected_a_remote_relay.ip = "16.17.18.19";
988 expected_a_remote_relay.port = 20;
989 expected_a_remote_relay.protocol = "a_remote_relay's protocol";
990 expected_a_remote_relay.candidate_type = "relay";
991 expected_a_remote_relay.priority = 3;
hbosd17a5a72017-01-02 16:09:59992 expected_a_remote_relay.deleted = false;
hbosc3a2b7f2017-01-02 12:46:15993 EXPECT_TRUE(*expected_a_remote_relay.is_remote);
hbosc42ba322016-12-21 11:31:45994
Philipp Hancke95513752018-09-27 12:40:08995 std::unique_ptr<cricket::Candidate> a_local_relay = CreateFakeCandidate(
996 "16.17.18.19", 21, "a_local_relay's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
997 cricket::RELAY_PORT_TYPE, 1);
998 a_local_relay->set_relay_protocol("tcp");
999
1000 RTCRemoteIceCandidateStats expected_a_local_relay(
1001 "RTCIceCandidate_" + a_local_relay->id(), 0);
1002 expected_a_local_relay.transport_id = "RTCTransport_a_0";
1003 expected_a_local_relay.ip = "16.17.18.19";
1004 expected_a_local_relay.port = 21;
1005 expected_a_local_relay.protocol = "a_local_relay's protocol";
1006 expected_a_local_relay.relay_protocol = "tcp";
1007 expected_a_local_relay.candidate_type = "relay";
1008 expected_a_local_relay.priority = 1;
1009 expected_a_local_relay.deleted = false;
1010 EXPECT_TRUE(*expected_a_local_relay.is_remote);
1011
hbosab9f6e42016-10-07 09:18:471012 // Candidates in the second transport stats.
Gary Liu37e489c2017-11-21 18:49:361013 std::unique_ptr<cricket::Candidate> b_local =
1014 CreateFakeCandidate("42.42.42.42", 42, "b_local's protocol",
1015 rtc::ADAPTER_TYPE_WIFI, cricket::LOCAL_PORT_TYPE, 42);
Yves Gerey665174f2018-06-19 13:03:051016 RTCLocalIceCandidateStats expected_b_local("RTCIceCandidate_" + b_local->id(),
1017 0);
hbosb4e426e2017-01-02 17:59:311018 expected_b_local.transport_id = "RTCTransport_b_0";
Gary Liu37e489c2017-11-21 18:49:361019 expected_b_local.network_type = "wifi";
hbosc42ba322016-12-21 11:31:451020 expected_b_local.ip = "42.42.42.42";
1021 expected_b_local.port = 42;
1022 expected_b_local.protocol = "b_local's protocol";
1023 expected_b_local.candidate_type = "host";
1024 expected_b_local.priority = 42;
hbosd17a5a72017-01-02 16:09:591025 expected_b_local.deleted = false;
hbosc3a2b7f2017-01-02 12:46:151026 EXPECT_FALSE(*expected_b_local.is_remote);
hbosc42ba322016-12-21 11:31:451027
hbosab9f6e42016-10-07 09:18:471028 std::unique_ptr<cricket::Candidate> b_remote = CreateFakeCandidate(
Gary Liu37e489c2017-11-21 18:49:361029 "42.42.42.42", 42, "b_remote's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1030 cricket::LOCAL_PORT_TYPE, 42);
hbosc42ba322016-12-21 11:31:451031 RTCRemoteIceCandidateStats expected_b_remote(
1032 "RTCIceCandidate_" + b_remote->id(), 0);
hbosb4e426e2017-01-02 17:59:311033 expected_b_remote.transport_id = "RTCTransport_b_0";
hbosc42ba322016-12-21 11:31:451034 expected_b_remote.ip = "42.42.42.42";
1035 expected_b_remote.port = 42;
1036 expected_b_remote.protocol = "b_remote's protocol";
1037 expected_b_remote.candidate_type = "host";
1038 expected_b_remote.priority = 42;
hbosd17a5a72017-01-02 16:09:591039 expected_b_remote.deleted = false;
hbosc3a2b7f2017-01-02 12:46:151040 EXPECT_TRUE(*expected_b_remote.is_remote);
hbosab9f6e42016-10-07 09:18:471041
Philipp Hancke95513752018-09-27 12:40:081042 // Add candidate pairs to connection.
hbosab9f6e42016-10-07 09:18:471043 cricket::TransportChannelStats a_transport_channel_stats;
1044 a_transport_channel_stats.connection_infos.push_back(
1045 cricket::ConnectionInfo());
1046 a_transport_channel_stats.connection_infos[0].local_candidate =
1047 *a_local_host.get();
1048 a_transport_channel_stats.connection_infos[0].remote_candidate =
1049 *a_remote_srflx.get();
1050 a_transport_channel_stats.connection_infos.push_back(
1051 cricket::ConnectionInfo());
1052 a_transport_channel_stats.connection_infos[1].local_candidate =
1053 *a_local_prflx.get();
1054 a_transport_channel_stats.connection_infos[1].remote_candidate =
1055 *a_remote_relay.get();
Philipp Hancke95513752018-09-27 12:40:081056 a_transport_channel_stats.connection_infos.push_back(
1057 cricket::ConnectionInfo());
1058 a_transport_channel_stats.connection_infos[2].local_candidate =
1059 *a_local_relay.get();
1060 a_transport_channel_stats.connection_infos[2].remote_candidate =
1061 *a_remote_relay.get();
Steve Anton5b387312018-02-03 00:00:201062
1063 pc_->AddVoiceChannel("audio", "a");
1064 pc_->SetTransportStats("a", a_transport_channel_stats);
hbosab9f6e42016-10-07 09:18:471065
1066 cricket::TransportChannelStats b_transport_channel_stats;
1067 b_transport_channel_stats.connection_infos.push_back(
1068 cricket::ConnectionInfo());
1069 b_transport_channel_stats.connection_infos[0].local_candidate =
1070 *b_local.get();
1071 b_transport_channel_stats.connection_infos[0].remote_candidate =
1072 *b_remote.get();
hbosab9f6e42016-10-07 09:18:471073
Steve Anton5b387312018-02-03 00:00:201074 pc_->AddVideoChannel("video", "b");
1075 pc_->SetTransportStats("b", b_transport_channel_stats);
hbosab9f6e42016-10-07 09:18:471076
Steve Anton5b387312018-02-03 00:00:201077 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbosc42ba322016-12-21 11:31:451078
hbosb4e426e2017-01-02 17:59:311079 ASSERT_TRUE(report->Get(expected_a_local_host.id()));
Yves Gerey665174f2018-06-19 13:03:051080 EXPECT_EQ(expected_a_local_host, report->Get(expected_a_local_host.id())
1081 ->cast_to<RTCLocalIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311082 ASSERT_TRUE(report->Get(expected_a_remote_srflx.id()));
hbosc42ba322016-12-21 11:31:451083 EXPECT_EQ(expected_a_remote_srflx,
Yves Gerey665174f2018-06-19 13:03:051084 report->Get(expected_a_remote_srflx.id())
1085 ->cast_to<RTCRemoteIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311086 ASSERT_TRUE(report->Get(expected_a_local_prflx.id()));
Yves Gerey665174f2018-06-19 13:03:051087 EXPECT_EQ(expected_a_local_prflx, report->Get(expected_a_local_prflx.id())
1088 ->cast_to<RTCLocalIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311089 ASSERT_TRUE(report->Get(expected_a_remote_relay.id()));
hbosc42ba322016-12-21 11:31:451090 EXPECT_EQ(expected_a_remote_relay,
Yves Gerey665174f2018-06-19 13:03:051091 report->Get(expected_a_remote_relay.id())
1092 ->cast_to<RTCRemoteIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311093 ASSERT_TRUE(report->Get(expected_b_local.id()));
Yves Gerey665174f2018-06-19 13:03:051094 EXPECT_EQ(
1095 expected_b_local,
1096 report->Get(expected_b_local.id())->cast_to<RTCLocalIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311097 ASSERT_TRUE(report->Get(expected_b_remote.id()));
Yves Gerey665174f2018-06-19 13:03:051098 EXPECT_EQ(expected_b_remote, report->Get(expected_b_remote.id())
1099 ->cast_to<RTCRemoteIceCandidateStats>());
hbosb4e426e2017-01-02 17:59:311100 EXPECT_TRUE(report->Get("RTCTransport_a_0"));
1101 EXPECT_TRUE(report->Get("RTCTransport_b_0"));
hbosab9f6e42016-10-07 09:18:471102}
1103
hbosc47a0c32016-10-11 21:54:491104TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
Steve Anton5b387312018-02-03 00:00:201105 const char kTransportName[] = "transport";
hbos338f78a2017-02-07 14:41:211106
Gary Liu37e489c2017-11-21 18:49:361107 std::unique_ptr<cricket::Candidate> local_candidate =
1108 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
1109 cricket::LOCAL_PORT_TYPE, 42);
hbosc47a0c32016-10-11 21:54:491110 std::unique_ptr<cricket::Candidate> remote_candidate = CreateFakeCandidate(
Gary Liu37e489c2017-11-21 18:49:361111 "42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1112 cricket::LOCAL_PORT_TYPE, 42);
hbosc47a0c32016-10-11 21:54:491113
hbosc47a0c32016-10-11 21:54:491114 cricket::ConnectionInfo connection_info;
hbos338f78a2017-02-07 14:41:211115 connection_info.best_connection = false;
hbosc47a0c32016-10-11 21:54:491116 connection_info.local_candidate = *local_candidate.get();
1117 connection_info.remote_candidate = *remote_candidate.get();
1118 connection_info.writable = true;
1119 connection_info.sent_total_bytes = 42;
1120 connection_info.recv_total_bytes = 1234;
hbosbf8d3e52017-02-28 14:34:471121 connection_info.total_round_trip_time_ms = 0;
Danil Chapovalov66cadcc2018-06-19 14:47:431122 connection_info.current_round_trip_time_ms = absl::nullopt;
hbosd82f5122016-12-09 12:12:391123 connection_info.recv_ping_requests = 2020;
hbose448dd52016-12-12 09:22:531124 connection_info.sent_ping_requests_total = 2020;
1125 connection_info.sent_ping_requests_before_first_response = 2000;
hbosc47a0c32016-10-11 21:54:491126 connection_info.recv_ping_responses = 4321;
1127 connection_info.sent_ping_responses = 1000;
hbos06495bc2017-01-02 16:08:181128 connection_info.state = cricket::IceCandidatePairState::IN_PROGRESS;
1129 connection_info.priority = 5555;
hbos92eaec62017-02-27 09:38:081130 connection_info.nominated = false;
hbosc47a0c32016-10-11 21:54:491131
1132 cricket::TransportChannelStats transport_channel_stats;
hbos0583b282016-11-30 09:50:141133 transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
hbosc47a0c32016-10-11 21:54:491134 transport_channel_stats.connection_infos.push_back(connection_info);
hbosc47a0c32016-10-11 21:54:491135
Steve Anton5b387312018-02-03 00:00:201136 pc_->AddVideoChannel("video", kTransportName);
1137 pc_->SetTransportStats(kTransportName, transport_channel_stats);
hbosc47a0c32016-10-11 21:54:491138
Steve Anton5b387312018-02-03 00:00:201139 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos0583b282016-11-30 09:50:141140
1141 RTCIceCandidatePairStats expected_pair("RTCIceCandidatePair_" +
1142 local_candidate->id() + "_" +
1143 remote_candidate->id(),
1144 report->timestamp_us());
1145 expected_pair.transport_id =
1146 "RTCTransport_transport_" +
Jonas Olsson6b1985d2018-07-05 09:59:481147 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP);
hbos0583b282016-11-30 09:50:141148 expected_pair.local_candidate_id = "RTCIceCandidate_" + local_candidate->id();
1149 expected_pair.remote_candidate_id =
1150 "RTCIceCandidate_" + remote_candidate->id();
hbos06495bc2017-01-02 16:08:181151 expected_pair.state = RTCStatsIceCandidatePairState::kInProgress;
1152 expected_pair.priority = 5555;
hbos92eaec62017-02-27 09:38:081153 expected_pair.nominated = false;
hbos0583b282016-11-30 09:50:141154 expected_pair.writable = true;
1155 expected_pair.bytes_sent = 42;
1156 expected_pair.bytes_received = 1234;
hbosbf8d3e52017-02-28 14:34:471157 expected_pair.total_round_trip_time = 0.0;
hbosd82f5122016-12-09 12:12:391158 expected_pair.requests_received = 2020;
hbose448dd52016-12-12 09:22:531159 expected_pair.requests_sent = 2000;
hbos0583b282016-11-30 09:50:141160 expected_pair.responses_received = 4321;
1161 expected_pair.responses_sent = 1000;
hbose448dd52016-12-12 09:22:531162 expected_pair.consent_requests_sent = (2020 - 2000);
hbosbf8d3e52017-02-28 14:34:471163 // |expected_pair.current_round_trip_time| should be undefined because the
1164 // current RTT is not set.
hbos338f78a2017-02-07 14:41:211165 // |expected_pair.available_[outgoing/incoming]_bitrate| should be undefined
1166 // because is is not the current pair.
hbos0583b282016-11-30 09:50:141167
hbosdbb64d82016-12-21 09:57:461168 ASSERT_TRUE(report->Get(expected_pair.id()));
hbos0583b282016-11-30 09:50:141169 EXPECT_EQ(
1170 expected_pair,
1171 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
hbosb4e426e2017-01-02 17:59:311172 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
hbos0583b282016-11-30 09:50:141173
hbos92eaec62017-02-27 09:38:081174 // Set nominated and "GetStats" again.
Steve Anton5b387312018-02-03 00:00:201175 transport_channel_stats.connection_infos[0].nominated = true;
1176 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1177 report = stats_->GetFreshStatsReport();
hbos92eaec62017-02-27 09:38:081178 expected_pair.nominated = true;
1179 ASSERT_TRUE(report->Get(expected_pair.id()));
1180 EXPECT_EQ(
1181 expected_pair,
1182 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1183 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1184
hbosbf8d3e52017-02-28 14:34:471185 // Set round trip times and "GetStats" again.
Steve Anton5b387312018-02-03 00:00:201186 transport_channel_stats.connection_infos[0].total_round_trip_time_ms = 7331;
1187 transport_channel_stats.connection_infos[0].current_round_trip_time_ms = 1337;
1188 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1189 report = stats_->GetFreshStatsReport();
hbosbf8d3e52017-02-28 14:34:471190 expected_pair.total_round_trip_time = 7.331;
1191 expected_pair.current_round_trip_time = 1.337;
1192 ASSERT_TRUE(report->Get(expected_pair.id()));
1193 EXPECT_EQ(
1194 expected_pair,
1195 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1196 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1197
hbos338f78a2017-02-07 14:41:211198 // Make pair the current pair, clear bandwidth and "GetStats" again.
Steve Anton5b387312018-02-03 00:00:201199 transport_channel_stats.connection_infos[0].best_connection = true;
1200 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1201 report = stats_->GetFreshStatsReport();
hbos338f78a2017-02-07 14:41:211202 // |expected_pair.available_[outgoing/incoming]_bitrate| should still be
1203 // undefined because bandwidth is not set.
1204 ASSERT_TRUE(report->Get(expected_pair.id()));
1205 EXPECT_EQ(
1206 expected_pair,
1207 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1208 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1209
1210 // Set bandwidth and "GetStats" again.
stefanf79ade12017-06-02 13:44:031211 webrtc::Call::Stats call_stats;
1212 const int kSendBandwidth = 888;
1213 call_stats.send_bandwidth_bps = kSendBandwidth;
1214 const int kRecvBandwidth = 999;
1215 call_stats.recv_bandwidth_bps = kRecvBandwidth;
Steve Anton5b387312018-02-03 00:00:201216 pc_->SetCallStats(call_stats);
1217 report = stats_->GetFreshStatsReport();
stefanf79ade12017-06-02 13:44:031218 expected_pair.available_outgoing_bitrate = kSendBandwidth;
1219 expected_pair.available_incoming_bitrate = kRecvBandwidth;
hbos338f78a2017-02-07 14:41:211220 ASSERT_TRUE(report->Get(expected_pair.id()));
1221 EXPECT_EQ(
1222 expected_pair,
1223 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1224 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1225
hbosc42ba322016-12-21 11:31:451226 RTCLocalIceCandidateStats expected_local_candidate(
1227 *expected_pair.local_candidate_id, report->timestamp_us());
hbosb4e426e2017-01-02 17:59:311228 expected_local_candidate.transport_id = *expected_pair.transport_id;
Gary Liu37e489c2017-11-21 18:49:361229 expected_local_candidate.network_type = "wifi";
hbosc42ba322016-12-21 11:31:451230 expected_local_candidate.ip = "42.42.42.42";
1231 expected_local_candidate.port = 42;
1232 expected_local_candidate.protocol = "protocol";
1233 expected_local_candidate.candidate_type = "host";
1234 expected_local_candidate.priority = 42;
hbosd17a5a72017-01-02 16:09:591235 expected_local_candidate.deleted = false;
hbosc3a2b7f2017-01-02 12:46:151236 EXPECT_FALSE(*expected_local_candidate.is_remote);
hbosc42ba322016-12-21 11:31:451237 ASSERT_TRUE(report->Get(expected_local_candidate.id()));
1238 EXPECT_EQ(expected_local_candidate,
Yves Gerey665174f2018-06-19 13:03:051239 report->Get(expected_local_candidate.id())
1240 ->cast_to<RTCLocalIceCandidateStats>());
hbosc42ba322016-12-21 11:31:451241
1242 RTCRemoteIceCandidateStats expected_remote_candidate(
1243 *expected_pair.remote_candidate_id, report->timestamp_us());
hbosb4e426e2017-01-02 17:59:311244 expected_remote_candidate.transport_id = *expected_pair.transport_id;
hbosc42ba322016-12-21 11:31:451245 expected_remote_candidate.ip = "42.42.42.42";
1246 expected_remote_candidate.port = 42;
1247 expected_remote_candidate.protocol = "protocol";
1248 expected_remote_candidate.candidate_type = "host";
1249 expected_remote_candidate.priority = 42;
hbosd17a5a72017-01-02 16:09:591250 expected_remote_candidate.deleted = false;
hbosc3a2b7f2017-01-02 12:46:151251 EXPECT_TRUE(*expected_remote_candidate.is_remote);
hbosc42ba322016-12-21 11:31:451252 ASSERT_TRUE(report->Get(expected_remote_candidate.id()));
1253 EXPECT_EQ(expected_remote_candidate,
Yves Gerey665174f2018-06-19 13:03:051254 report->Get(expected_remote_candidate.id())
1255 ->cast_to<RTCRemoteIceCandidateStats>());
hbosc47a0c32016-10-11 21:54:491256}
1257
hbosd565b732016-08-30 21:04:351258TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
hbosd565b732016-08-30 21:04:351259 {
Steve Anton5b387312018-02-03 00:00:201260 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos82ebe022016-11-14 09:41:091261 RTCPeerConnectionStats expected("RTCPeerConnection",
1262 report->timestamp_us());
1263 expected.data_channels_opened = 0;
1264 expected.data_channels_closed = 0;
hbosdbb64d82016-12-21 09:57:461265 ASSERT_TRUE(report->Get("RTCPeerConnection"));
Yves Gerey665174f2018-06-19 13:03:051266 EXPECT_EQ(
1267 expected,
1268 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
hbosd565b732016-08-30 21:04:351269 }
1270
hbos82ebe022016-11-14 09:41:091271 rtc::scoped_refptr<DataChannel> dummy_channel_a = DataChannel::Create(
1272 nullptr, cricket::DCT_NONE, "DummyChannelA", InternalDataChannelInit());
Steve Anton5b387312018-02-03 00:00:201273 pc_->SignalDataChannelCreated()(dummy_channel_a.get());
hbos82ebe022016-11-14 09:41:091274 rtc::scoped_refptr<DataChannel> dummy_channel_b = DataChannel::Create(
1275 nullptr, cricket::DCT_NONE, "DummyChannelB", InternalDataChannelInit());
Steve Anton5b387312018-02-03 00:00:201276 pc_->SignalDataChannelCreated()(dummy_channel_b.get());
hbosd565b732016-08-30 21:04:351277
hbos82ebe022016-11-14 09:41:091278 dummy_channel_a->SignalOpened(dummy_channel_a.get());
1279 // Closing a channel that is not opened should not affect the counts.
1280 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1281
hbosd565b732016-08-30 21:04:351282 {
Steve Anton5b387312018-02-03 00:00:201283 rtc::scoped_refptr<const RTCStatsReport> report =
1284 stats_->GetFreshStatsReport();
hbos82ebe022016-11-14 09:41:091285 RTCPeerConnectionStats expected("RTCPeerConnection",
1286 report->timestamp_us());
1287 expected.data_channels_opened = 1;
1288 expected.data_channels_closed = 0;
hbosdbb64d82016-12-21 09:57:461289 ASSERT_TRUE(report->Get("RTCPeerConnection"));
Yves Gerey665174f2018-06-19 13:03:051290 EXPECT_EQ(
1291 expected,
1292 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
hbos82ebe022016-11-14 09:41:091293 }
1294
1295 dummy_channel_b->SignalOpened(dummy_channel_b.get());
1296 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1297
1298 {
Steve Anton5b387312018-02-03 00:00:201299 rtc::scoped_refptr<const RTCStatsReport> report =
1300 stats_->GetFreshStatsReport();
hbos82ebe022016-11-14 09:41:091301 RTCPeerConnectionStats expected("RTCPeerConnection",
1302 report->timestamp_us());
1303 expected.data_channels_opened = 2;
1304 expected.data_channels_closed = 1;
hbosdbb64d82016-12-21 09:57:461305 ASSERT_TRUE(report->Get("RTCPeerConnection"));
Yves Gerey665174f2018-06-19 13:03:051306 EXPECT_EQ(
1307 expected,
1308 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
hbosd565b732016-08-30 21:04:351309 }
hbos5bf9def2017-03-20 10:14:141310
1311 // Re-opening a data channel (or opening a new data channel that is re-using
1312 // the same address in memory) should increase the opened count.
1313 dummy_channel_b->SignalOpened(dummy_channel_b.get());
1314
1315 {
Steve Anton5b387312018-02-03 00:00:201316 rtc::scoped_refptr<const RTCStatsReport> report =
1317 stats_->GetFreshStatsReport();
hbos5bf9def2017-03-20 10:14:141318 RTCPeerConnectionStats expected("RTCPeerConnection",
1319 report->timestamp_us());
1320 expected.data_channels_opened = 3;
1321 expected.data_channels_closed = 1;
1322 ASSERT_TRUE(report->Get("RTCPeerConnection"));
Yves Gerey665174f2018-06-19 13:03:051323 EXPECT_EQ(
1324 expected,
1325 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
hbos5bf9def2017-03-20 10:14:141326 }
1327
1328 dummy_channel_a->SignalClosed(dummy_channel_a.get());
1329 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1330
1331 {
Steve Anton5b387312018-02-03 00:00:201332 rtc::scoped_refptr<const RTCStatsReport> report =
1333 stats_->GetFreshStatsReport();
hbos5bf9def2017-03-20 10:14:141334 RTCPeerConnectionStats expected("RTCPeerConnection",
1335 report->timestamp_us());
1336 expected.data_channels_opened = 3;
1337 expected.data_channels_closed = 3;
1338 ASSERT_TRUE(report->Get("RTCPeerConnection"));
Yves Gerey665174f2018-06-19 13:03:051339 EXPECT_EQ(
1340 expected,
1341 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
hbos5bf9def2017-03-20 10:14:141342 }
hbosd565b732016-08-30 21:04:351343}
1344
hbos09bc1282016-11-08 14:29:221345TEST_F(RTCStatsCollectorTest,
Harald Alvestranda3dab842018-01-14 08:18:581346 CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio) {
hbos09bc1282016-11-08 14:29:221347 rtc::scoped_refptr<MediaStream> local_stream =
Seth Hampson845e8782018-03-02 19:34:101348 MediaStream::Create("LocalStreamId");
Steve Anton5b387312018-02-03 00:00:201349 pc_->mutable_local_streams()->AddStream(local_stream);
hbos09bc1282016-11-08 14:29:221350
1351 // Local audio track
hbos9e302742017-01-20 10:47:101352 rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
1353 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
1354 MediaStreamTrackInterface::kEnded);
Yves Gerey665174f2018-06-19 13:03:051355 local_stream->AddTrack(
1356 static_cast<AudioTrackInterface*>(local_audio_track.get()));
hbos9e302742017-01-20 10:47:101357
1358 cricket::VoiceSenderInfo voice_sender_info_ssrc1;
1359 voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
1360 voice_sender_info_ssrc1.local_stats[0].ssrc = 1;
1361 voice_sender_info_ssrc1.audio_level = 32767;
zsteine76bd3a2017-07-14 19:17:491362 voice_sender_info_ssrc1.total_input_energy = 0.25;
1363 voice_sender_info_ssrc1.total_input_duration = 0.5;
Ivo Creusen56d460902017-11-24 16:29:591364 voice_sender_info_ssrc1.apm_statistics.echo_return_loss = 42.0;
1365 voice_sender_info_ssrc1.apm_statistics.echo_return_loss_enhancement = 52.0;
hbos9e302742017-01-20 10:47:101366
Steve Anton5b387312018-02-03 00:00:201367 stats_->CreateMockRtpSendersReceiversAndChannels(
Harald Alvestranda3dab842018-01-14 08:18:581368 {std::make_pair(local_audio_track.get(), voice_sender_info_ssrc1)}, {},
Seth Hampson13b8bad2018-03-13 23:05:281369 {}, {}, {local_stream->id()}, {});
Harald Alvestranda3dab842018-01-14 08:18:581370
Steve Anton5b387312018-02-03 00:00:201371 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
Harald Alvestranda3dab842018-01-14 08:18:581372
1373 RTCMediaStreamStats expected_local_stream(
1374 IdForType<RTCMediaStreamStats>(report), report->timestamp_us());
Seth Hampson13b8bad2018-03-13 23:05:281375 expected_local_stream.stream_identifier = local_stream->id();
Harald Alvestranda3dab842018-01-14 08:18:581376 expected_local_stream.track_ids = {
1377 IdForType<RTCMediaStreamTrackStats>(report)};
1378 ASSERT_TRUE(report->Get(expected_local_stream.id()))
1379 << "Did not find " << expected_local_stream.id() << " in "
1380 << report->ToJson();
1381 EXPECT_EQ(
1382 expected_local_stream,
1383 report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>());
1384
1385 RTCMediaStreamTrackStats expected_local_audio_track_ssrc1(
1386 IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(),
1387 RTCMediaStreamTrackKind::kAudio);
1388 expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id();
1389 expected_local_audio_track_ssrc1.remote_source = false;
1390 expected_local_audio_track_ssrc1.ended = true;
1391 expected_local_audio_track_ssrc1.detached = false;
1392 expected_local_audio_track_ssrc1.audio_level = 1.0;
1393 expected_local_audio_track_ssrc1.total_audio_energy = 0.25;
1394 expected_local_audio_track_ssrc1.total_samples_duration = 0.5;
1395 expected_local_audio_track_ssrc1.echo_return_loss = 42.0;
1396 expected_local_audio_track_ssrc1.echo_return_loss_enhancement = 52.0;
1397 ASSERT_TRUE(report->Get(expected_local_audio_track_ssrc1.id()))
1398 << "Did not find " << expected_local_audio_track_ssrc1.id() << " in "
1399 << report->ToJson();
1400 EXPECT_EQ(expected_local_audio_track_ssrc1,
1401 report->Get(expected_local_audio_track_ssrc1.id())
1402 ->cast_to<RTCMediaStreamTrackStats>());
1403}
1404
1405TEST_F(RTCStatsCollectorTest,
1406 CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio) {
Harald Alvestranda3dab842018-01-14 08:18:581407 rtc::scoped_refptr<MediaStream> remote_stream =
Seth Hampson845e8782018-03-02 19:34:101408 MediaStream::Create("RemoteStreamId");
Steve Anton5b387312018-02-03 00:00:201409 pc_->mutable_remote_streams()->AddStream(remote_stream);
Harald Alvestranda3dab842018-01-14 08:18:581410
hbos09bc1282016-11-08 14:29:221411 // Remote audio track
hbos9e302742017-01-20 10:47:101412 rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track =
1413 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID",
1414 MediaStreamTrackInterface::kLive);
Yves Gerey665174f2018-06-19 13:03:051415 remote_stream->AddTrack(
1416 static_cast<AudioTrackInterface*>(remote_audio_track.get()));
hbos9e302742017-01-20 10:47:101417
1418 cricket::VoiceReceiverInfo voice_receiver_info;
1419 voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
1420 voice_receiver_info.local_stats[0].ssrc = 3;
1421 voice_receiver_info.audio_level = 16383;
zsteine76bd3a2017-07-14 19:17:491422 voice_receiver_info.total_output_energy = 0.125;
Steve Anton2dbc69f2017-08-25 00:15:131423 voice_receiver_info.total_samples_received = 4567;
zsteine76bd3a2017-07-14 19:17:491424 voice_receiver_info.total_output_duration = 0.25;
Steve Anton2dbc69f2017-08-25 00:15:131425 voice_receiver_info.concealed_samples = 123;
Gustaf Ullberg9a2e9062017-09-18 07:28:201426 voice_receiver_info.concealment_events = 12;
Gustaf Ullbergb0a02072017-10-02 10:00:341427 voice_receiver_info.jitter_buffer_delay_seconds = 3456;
Ruslan Burakov8af88962018-11-22 16:21:101428 voice_receiver_info.jitter_buffer_flushes = 7;
Jakob Ivarsson352ce5c2018-11-27 11:52:161429 voice_receiver_info.delayed_packet_outage_samples = 15;
hbos9e302742017-01-20 10:47:101430
Steve Anton5b387312018-02-03 00:00:201431 stats_->CreateMockRtpSendersReceiversAndChannels(
Harald Alvestranda3dab842018-01-14 08:18:581432 {}, {std::make_pair(remote_audio_track.get(), voice_receiver_info)}, {},
1433 {}, {}, {remote_stream});
hbos09bc1282016-11-08 14:29:221434
Steve Anton5b387312018-02-03 00:00:201435 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos09bc1282016-11-08 14:29:221436
hbos09bc1282016-11-08 14:29:221437 RTCMediaStreamStats expected_remote_stream(
Harald Alvestranda3dab842018-01-14 08:18:581438 IdForType<RTCMediaStreamStats>(report), report->timestamp_us());
Seth Hampson13b8bad2018-03-13 23:05:281439 expected_remote_stream.stream_identifier = remote_stream->id();
Harald Alvestranda3dab842018-01-14 08:18:581440 expected_remote_stream.track_ids =
1441 std::vector<std::string>({IdForType<RTCMediaStreamTrackStats>(report)});
1442 ASSERT_TRUE(report->Get(expected_remote_stream.id()))
1443 << "Did not find " << expected_remote_stream.id() << " in "
1444 << report->ToJson();
Yves Gerey665174f2018-06-19 13:03:051445 EXPECT_EQ(
1446 expected_remote_stream,
1447 report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>());
hbos09bc1282016-11-08 14:29:221448
hbos09bc1282016-11-08 14:29:221449 RTCMediaStreamTrackStats expected_remote_audio_track(
Harald Alvestranda3dab842018-01-14 08:18:581450 IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(),
1451 RTCMediaStreamTrackKind::kAudio);
hbos09bc1282016-11-08 14:29:221452 expected_remote_audio_track.track_identifier = remote_audio_track->id();
1453 expected_remote_audio_track.remote_source = true;
1454 expected_remote_audio_track.ended = false;
1455 expected_remote_audio_track.detached = false;
hbos9e302742017-01-20 10:47:101456 expected_remote_audio_track.audio_level = 16383.0 / 32767.0;
zsteine76bd3a2017-07-14 19:17:491457 expected_remote_audio_track.total_audio_energy = 0.125;
Steve Anton2dbc69f2017-08-25 00:15:131458 expected_remote_audio_track.total_samples_received = 4567;
zsteine76bd3a2017-07-14 19:17:491459 expected_remote_audio_track.total_samples_duration = 0.25;
Steve Anton2dbc69f2017-08-25 00:15:131460 expected_remote_audio_track.concealed_samples = 123;
Gustaf Ullberg9a2e9062017-09-18 07:28:201461 expected_remote_audio_track.concealment_events = 12;
Gustaf Ullbergb0a02072017-10-02 10:00:341462 expected_remote_audio_track.jitter_buffer_delay = 3456;
Ruslan Burakov8af88962018-11-22 16:21:101463 expected_remote_audio_track.jitter_buffer_flushes = 7;
Jakob Ivarsson352ce5c2018-11-27 11:52:161464 expected_remote_audio_track.delayed_packet_outage_samples = 15;
hbosdbb64d82016-12-21 09:57:461465 ASSERT_TRUE(report->Get(expected_remote_audio_track.id()));
hbos09bc1282016-11-08 14:29:221466 EXPECT_EQ(expected_remote_audio_track,
Yves Gerey665174f2018-06-19 13:03:051467 report->Get(expected_remote_audio_track.id())
1468 ->cast_to<RTCMediaStreamTrackStats>());
hbos09bc1282016-11-08 14:29:221469}
1470
1471TEST_F(RTCStatsCollectorTest,
Harald Alvestranda3dab842018-01-14 08:18:581472 CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video) {
hbos09bc1282016-11-08 14:29:221473 rtc::scoped_refptr<MediaStream> local_stream =
Seth Hampson845e8782018-03-02 19:34:101474 MediaStream::Create("LocalStreamId");
Steve Anton5b387312018-02-03 00:00:201475 pc_->mutable_local_streams()->AddStream(local_stream);
hbos09bc1282016-11-08 14:29:221476
1477 // Local video track
hbos9e302742017-01-20 10:47:101478 rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track =
1479 CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID",
1480 MediaStreamTrackInterface::kLive);
Yves Gerey665174f2018-06-19 13:03:051481 local_stream->AddTrack(
1482 static_cast<VideoTrackInterface*>(local_video_track.get()));
hbos09bc1282016-11-08 14:29:221483
hbos9e302742017-01-20 10:47:101484 cricket::VideoSenderInfo video_sender_info_ssrc1;
1485 video_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
1486 video_sender_info_ssrc1.local_stats[0].ssrc = 1;
1487 video_sender_info_ssrc1.send_frame_width = 1234;
1488 video_sender_info_ssrc1.send_frame_height = 4321;
hbosfefe0762017-01-20 14:14:251489 video_sender_info_ssrc1.frames_encoded = 11;
Ilya Nikolaevskiy70473fc2018-02-28 15:35:031490 video_sender_info_ssrc1.huge_frames_sent = 1;
hbos9e302742017-01-20 10:47:101491
Steve Anton5b387312018-02-03 00:00:201492 stats_->CreateMockRtpSendersReceiversAndChannels(
Harald Alvestranda3dab842018-01-14 08:18:581493 {}, {},
1494 {std::make_pair(local_video_track.get(), video_sender_info_ssrc1)}, {},
Seth Hampson13b8bad2018-03-13 23:05:281495 {local_stream->id()}, {});
Harald Alvestranda3dab842018-01-14 08:18:581496
Steve Anton5b387312018-02-03 00:00:201497 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
Harald Alvestranda3dab842018-01-14 08:18:581498
1499 auto stats_of_my_type = report->GetStatsOfType<RTCMediaStreamStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231500 ASSERT_EQ(1U, stats_of_my_type.size()) << "No stream in " << report->ToJson();
Harald Alvestranda3dab842018-01-14 08:18:581501 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231502 ASSERT_EQ(1U, stats_of_track_type.size())
Harald Alvestranda3dab842018-01-14 08:18:581503 << "Wrong number of tracks in " << report->ToJson();
1504
1505 RTCMediaStreamStats expected_local_stream(stats_of_my_type[0]->id(),
1506 report->timestamp_us());
Seth Hampson13b8bad2018-03-13 23:05:281507 expected_local_stream.stream_identifier = local_stream->id();
Harald Alvestranda3dab842018-01-14 08:18:581508 expected_local_stream.track_ids =
1509 std::vector<std::string>({stats_of_track_type[0]->id()});
1510 ASSERT_TRUE(report->Get(expected_local_stream.id()));
1511 EXPECT_EQ(
1512 expected_local_stream,
1513 report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>());
1514
1515 RTCMediaStreamTrackStats expected_local_video_track_ssrc1(
1516 stats_of_track_type[0]->id(), report->timestamp_us(),
1517 RTCMediaStreamTrackKind::kVideo);
1518 expected_local_video_track_ssrc1.track_identifier = local_video_track->id();
1519 expected_local_video_track_ssrc1.remote_source = false;
1520 expected_local_video_track_ssrc1.ended = false;
1521 expected_local_video_track_ssrc1.detached = false;
1522 expected_local_video_track_ssrc1.frame_width = 1234;
1523 expected_local_video_track_ssrc1.frame_height = 4321;
1524 expected_local_video_track_ssrc1.frames_sent = 11;
Ilya Nikolaevskiy70473fc2018-02-28 15:35:031525 expected_local_video_track_ssrc1.huge_frames_sent = 1;
Harald Alvestranda3dab842018-01-14 08:18:581526 ASSERT_TRUE(report->Get(expected_local_video_track_ssrc1.id()));
1527 EXPECT_EQ(expected_local_video_track_ssrc1,
1528 report->Get(expected_local_video_track_ssrc1.id())
1529 ->cast_to<RTCMediaStreamTrackStats>());
1530}
1531
1532TEST_F(RTCStatsCollectorTest,
1533 CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video) {
Harald Alvestranda3dab842018-01-14 08:18:581534 rtc::scoped_refptr<MediaStream> remote_stream =
Seth Hampson845e8782018-03-02 19:34:101535 MediaStream::Create("RemoteStreamId");
Steve Anton5b387312018-02-03 00:00:201536 pc_->mutable_remote_streams()->AddStream(remote_stream);
Harald Alvestranda3dab842018-01-14 08:18:581537
hbos9e302742017-01-20 10:47:101538 // Remote video track with values
1539 rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc3 =
1540 CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
1541 MediaStreamTrackInterface::kEnded);
Yves Gerey665174f2018-06-19 13:03:051542 remote_stream->AddTrack(
1543 static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get()));
hbos9e302742017-01-20 10:47:101544
1545 cricket::VideoReceiverInfo video_receiver_info_ssrc3;
1546 video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
1547 video_receiver_info_ssrc3.local_stats[0].ssrc = 3;
1548 video_receiver_info_ssrc3.frame_width = 6789;
1549 video_receiver_info_ssrc3.frame_height = 9876;
hbos50cfe1f2017-01-23 15:21:551550 video_receiver_info_ssrc3.frames_received = 1000;
1551 video_receiver_info_ssrc3.frames_decoded = 995;
1552 video_receiver_info_ssrc3.frames_rendered = 990;
hbos9e302742017-01-20 10:47:101553
Steve Anton5b387312018-02-03 00:00:201554 stats_->CreateMockRtpSendersReceiversAndChannels(
Harald Alvestranda3dab842018-01-14 08:18:581555 {}, {}, {},
Harald Alvestrandc72af932018-01-11 16:18:191556 {std::make_pair(remote_video_track_ssrc3.get(),
Harald Alvestranda3dab842018-01-14 08:18:581557 video_receiver_info_ssrc3)},
1558 {}, {remote_stream});
hbos09bc1282016-11-08 14:29:221559
Steve Anton5b387312018-02-03 00:00:201560 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos09bc1282016-11-08 14:29:221561
Harald Alvestranda3dab842018-01-14 08:18:581562 auto stats_of_my_type = report->GetStatsOfType<RTCMediaStreamStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231563 ASSERT_EQ(1U, stats_of_my_type.size()) << "No stream in " << report->ToJson();
Harald Alvestranda3dab842018-01-14 08:18:581564 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231565 ASSERT_EQ(1U, stats_of_track_type.size())
Harald Alvestranda3dab842018-01-14 08:18:581566 << "Wrong number of tracks in " << report->ToJson();
1567 ASSERT_TRUE(*(stats_of_track_type[0]->remote_source));
hbos09bc1282016-11-08 14:29:221568
Harald Alvestranda3dab842018-01-14 08:18:581569 RTCMediaStreamStats expected_remote_stream(stats_of_my_type[0]->id(),
1570 report->timestamp_us());
Seth Hampson13b8bad2018-03-13 23:05:281571 expected_remote_stream.stream_identifier = remote_stream->id();
Harald Alvestranda3dab842018-01-14 08:18:581572 expected_remote_stream.track_ids =
1573 std::vector<std::string>({stats_of_track_type[0]->id()});
hbosdbb64d82016-12-21 09:57:461574 ASSERT_TRUE(report->Get(expected_remote_stream.id()));
Yves Gerey665174f2018-06-19 13:03:051575 EXPECT_EQ(
1576 expected_remote_stream,
1577 report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>());
hbos09bc1282016-11-08 14:29:221578
hbos9e302742017-01-20 10:47:101579 RTCMediaStreamTrackStats expected_remote_video_track_ssrc3(
Harald Alvestranda3dab842018-01-14 08:18:581580 stats_of_track_type[0]->id(), report->timestamp_us(),
1581 RTCMediaStreamTrackKind::kVideo);
hbos9e302742017-01-20 10:47:101582 expected_remote_video_track_ssrc3.track_identifier =
1583 remote_video_track_ssrc3->id();
1584 expected_remote_video_track_ssrc3.remote_source = true;
1585 expected_remote_video_track_ssrc3.ended = true;
1586 expected_remote_video_track_ssrc3.detached = false;
1587 expected_remote_video_track_ssrc3.frame_width = 6789;
1588 expected_remote_video_track_ssrc3.frame_height = 9876;
hbos50cfe1f2017-01-23 15:21:551589 expected_remote_video_track_ssrc3.frames_received = 1000;
1590 expected_remote_video_track_ssrc3.frames_decoded = 995;
1591 expected_remote_video_track_ssrc3.frames_dropped = 1000 - 990;
hbos9e302742017-01-20 10:47:101592 ASSERT_TRUE(report->Get(expected_remote_video_track_ssrc3.id()));
1593 EXPECT_EQ(expected_remote_video_track_ssrc3,
Yves Gerey665174f2018-06-19 13:03:051594 report->Get(expected_remote_video_track_ssrc3.id())
1595 ->cast_to<RTCMediaStreamTrackStats>());
hbos09bc1282016-11-08 14:29:221596}
1597
hboseeafe942016-11-01 10:00:171598TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
hboseeafe942016-11-01 10:00:171599 cricket::VoiceMediaInfo voice_media_info;
hbos0adb8282016-11-23 10:32:061600
hboseeafe942016-11-01 10:00:171601 voice_media_info.receivers.push_back(cricket::VoiceReceiverInfo());
1602 voice_media_info.receivers[0].local_stats.push_back(
1603 cricket::SsrcReceiverInfo());
1604 voice_media_info.receivers[0].local_stats[0].ssrc = 1;
Harald Alvestrand719487e2017-12-13 11:26:041605 voice_media_info.receivers[0].packets_lost = -1; // Signed per RFC3550
hboseeafe942016-11-01 10:00:171606 voice_media_info.receivers[0].packets_rcvd = 2;
1607 voice_media_info.receivers[0].bytes_rcvd = 3;
Oskar Sundbomcbc71b22017-11-16 09:56:071608 voice_media_info.receivers[0].codec_payload_type = 42;
hboseeafe942016-11-01 10:00:171609 voice_media_info.receivers[0].jitter_ms = 4500;
1610 voice_media_info.receivers[0].fraction_lost = 5.5f;
hbos0adb8282016-11-23 10:32:061611
1612 RtpCodecParameters codec_parameters;
1613 codec_parameters.payload_type = 42;
deadbeefe702b302017-02-04 20:09:011614 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
1615 codec_parameters.name = "dummy";
Oskar Sundbomcbc71b22017-11-16 09:56:071616 codec_parameters.clock_rate = 0;
hbos0adb8282016-11-23 10:32:061617 voice_media_info.receive_codecs.insert(
1618 std::make_pair(codec_parameters.payload_type, codec_parameters));
1619
Steve Anton57858b32018-02-15 23:19:501620 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:201621 voice_media_channel->SetStats(voice_media_info);
Henrik Boström5b3541f2018-03-19 12:52:561622 stats_->SetupRemoteTrackAndReceiver(
1623 cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1);
hboseeafe942016-11-01 10:00:171624
Steve Anton5b387312018-02-03 00:00:201625 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hboseeafe942016-11-01 10:00:171626
Harald Alvestranda3dab842018-01-14 08:18:581627 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231628 ASSERT_EQ(1U, stats_of_track_type.size());
Harald Alvestranda3dab842018-01-14 08:18:581629
Yves Gerey665174f2018-06-19 13:03:051630 RTCInboundRTPStreamStats expected_audio("RTCInboundRTPAudioStream_1",
1631 report->timestamp_us());
hbos3443bb72017-02-07 14:28:111632 expected_audio.ssrc = 1;
hboseeafe942016-11-01 10:00:171633 expected_audio.is_remote = false;
1634 expected_audio.media_type = "audio";
Philipp Hancke3bc01662018-08-28 12:55:031635 expected_audio.kind = "audio";
Harald Alvestranda3dab842018-01-14 08:18:581636 expected_audio.track_id = stats_of_track_type[0]->id();
Steve Anton57858b32018-02-15 23:19:501637 expected_audio.transport_id = "RTCTransport_TransportName_1";
1638 expected_audio.codec_id = "RTCCodec_AudioMid_Inbound_42";
hboseeafe942016-11-01 10:00:171639 expected_audio.packets_received = 2;
1640 expected_audio.bytes_received = 3;
Harald Alvestrand719487e2017-12-13 11:26:041641 expected_audio.packets_lost = -1;
hboseeafe942016-11-01 10:00:171642 expected_audio.jitter = 4.5;
1643 expected_audio.fraction_lost = 5.5;
nissec8ee8822017-01-18 15:20:551644 ASSERT_TRUE(report->Get(expected_audio.id()));
hbosa51d4f32017-02-16 13:34:481645 EXPECT_EQ(
1646 report->Get(expected_audio.id())->cast_to<RTCInboundRTPStreamStats>(),
1647 expected_audio);
hbosb0ae9202017-01-27 14:35:161648 EXPECT_TRUE(report->Get(*expected_audio.track_id));
hbos84abeb12017-01-16 14:16:441649 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
1650 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
hboseeafe942016-11-01 10:00:171651}
1652
1653TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
hboseeafe942016-11-01 10:00:171654 cricket::VideoMediaInfo video_media_info;
hbos0adb8282016-11-23 10:32:061655
hboseeafe942016-11-01 10:00:171656 video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
1657 video_media_info.receivers[0].local_stats.push_back(
1658 cricket::SsrcReceiverInfo());
1659 video_media_info.receivers[0].local_stats[0].ssrc = 1;
1660 video_media_info.receivers[0].packets_rcvd = 2;
hbos02cd4d62016-12-09 12:19:441661 video_media_info.receivers[0].packets_lost = 42;
hboseeafe942016-11-01 10:00:171662 video_media_info.receivers[0].bytes_rcvd = 3;
1663 video_media_info.receivers[0].fraction_lost = 4.5f;
Oskar Sundbomcbc71b22017-11-16 09:56:071664 video_media_info.receivers[0].codec_payload_type = 42;
hbos820f5782016-11-22 11:16:501665 video_media_info.receivers[0].firs_sent = 5;
1666 video_media_info.receivers[0].plis_sent = 6;
1667 video_media_info.receivers[0].nacks_sent = 7;
hbos6769c492017-01-02 16:35:131668 video_media_info.receivers[0].frames_decoded = 8;
Danil Chapovalov66cadcc2018-06-19 14:47:431669 video_media_info.receivers[0].qp_sum = absl::nullopt;
hbos0adb8282016-11-23 10:32:061670
1671 RtpCodecParameters codec_parameters;
1672 codec_parameters.payload_type = 42;
deadbeefe702b302017-02-04 20:09:011673 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
1674 codec_parameters.name = "dummy";
Oskar Sundbomcbc71b22017-11-16 09:56:071675 codec_parameters.clock_rate = 0;
hbos0adb8282016-11-23 10:32:061676 video_media_info.receive_codecs.insert(
1677 std::make_pair(codec_parameters.payload_type, codec_parameters));
1678
Steve Anton57858b32018-02-15 23:19:501679 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:201680 video_media_channel->SetStats(video_media_info);
Henrik Boström5b3541f2018-03-19 12:52:561681 stats_->SetupRemoteTrackAndReceiver(
1682 cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1);
hboseeafe942016-11-01 10:00:171683
Steve Anton5b387312018-02-03 00:00:201684 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hboseeafe942016-11-01 10:00:171685
Yves Gerey665174f2018-06-19 13:03:051686 RTCInboundRTPStreamStats expected_video("RTCInboundRTPVideoStream_1",
1687 report->timestamp_us());
hbos3443bb72017-02-07 14:28:111688 expected_video.ssrc = 1;
hbos820f5782016-11-22 11:16:501689 expected_video.is_remote = false;
1690 expected_video.media_type = "video";
Philipp Hancke3bc01662018-08-28 12:55:031691 expected_video.kind = "video";
Harald Alvestranda3dab842018-01-14 08:18:581692 expected_video.track_id = IdForType<RTCMediaStreamTrackStats>(report);
Steve Anton57858b32018-02-15 23:19:501693 expected_video.transport_id = "RTCTransport_TransportName_1";
1694 expected_video.codec_id = "RTCCodec_VideoMid_Inbound_42";
hbos820f5782016-11-22 11:16:501695 expected_video.fir_count = 5;
1696 expected_video.pli_count = 6;
1697 expected_video.nack_count = 7;
1698 expected_video.packets_received = 2;
1699 expected_video.bytes_received = 3;
hbos02cd4d62016-12-09 12:19:441700 expected_video.packets_lost = 42;
hbos820f5782016-11-22 11:16:501701 expected_video.fraction_lost = 4.5;
hbos6769c492017-01-02 16:35:131702 expected_video.frames_decoded = 8;
hbosa51d4f32017-02-16 13:34:481703 // |expected_video.qp_sum| should be undefined.
hboseeafe942016-11-01 10:00:171704
nissec8ee8822017-01-18 15:20:551705 ASSERT_TRUE(report->Get(expected_video.id()));
hbosa51d4f32017-02-16 13:34:481706 EXPECT_EQ(
1707 report->Get(expected_video.id())->cast_to<RTCInboundRTPStreamStats>(),
1708 expected_video);
hboseeafe942016-11-01 10:00:171709
hbosa51d4f32017-02-16 13:34:481710 // Set previously undefined values and "GetStats" again.
Oskar Sundbomcbc71b22017-11-16 09:56:071711 video_media_info.receivers[0].qp_sum = 9;
hbosa51d4f32017-02-16 13:34:481712 expected_video.qp_sum = 9;
Steve Anton5b387312018-02-03 00:00:201713 video_media_channel->SetStats(video_media_info);
hbosa51d4f32017-02-16 13:34:481714
Steve Anton5b387312018-02-03 00:00:201715 report = stats_->GetFreshStatsReport();
hbosa51d4f32017-02-16 13:34:481716
1717 ASSERT_TRUE(report->Get(expected_video.id()));
1718 EXPECT_EQ(
1719 report->Get(expected_video.id())->cast_to<RTCInboundRTPStreamStats>(),
1720 expected_video);
hbosb0ae9202017-01-27 14:35:161721 EXPECT_TRUE(report->Get(*expected_video.track_id));
hbos84abeb12017-01-16 14:16:441722 EXPECT_TRUE(report->Get(*expected_video.transport_id));
hbosa51d4f32017-02-16 13:34:481723 EXPECT_TRUE(report->Get(*expected_video.codec_id));
hboseeafe942016-11-01 10:00:171724}
1725
hbos6ded1902016-11-01 08:50:461726TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
hbos6ded1902016-11-01 08:50:461727 cricket::VoiceMediaInfo voice_media_info;
hbos0adb8282016-11-23 10:32:061728
hbos6ded1902016-11-01 08:50:461729 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
1730 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
1731 voice_media_info.senders[0].local_stats[0].ssrc = 1;
1732 voice_media_info.senders[0].packets_sent = 2;
1733 voice_media_info.senders[0].bytes_sent = 3;
Oskar Sundbomcbc71b22017-11-16 09:56:071734 voice_media_info.senders[0].codec_payload_type = 42;
hbos0adb8282016-11-23 10:32:061735
1736 RtpCodecParameters codec_parameters;
1737 codec_parameters.payload_type = 42;
deadbeefe702b302017-02-04 20:09:011738 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
1739 codec_parameters.name = "dummy";
Oskar Sundbomcbc71b22017-11-16 09:56:071740 codec_parameters.clock_rate = 0;
hbos0adb8282016-11-23 10:32:061741 voice_media_info.send_codecs.insert(
1742 std::make_pair(codec_parameters.payload_type, codec_parameters));
1743
Steve Anton57858b32018-02-15 23:19:501744 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:201745 voice_media_channel->SetStats(voice_media_info);
1746 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_AUDIO,
1747 "LocalAudioTrackID", 1, true);
hbos6ded1902016-11-01 08:50:461748
Steve Anton5b387312018-02-03 00:00:201749 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos6ded1902016-11-01 08:50:461750
Yves Gerey665174f2018-06-19 13:03:051751 RTCOutboundRTPStreamStats expected_audio("RTCOutboundRTPAudioStream_1",
1752 report->timestamp_us());
hbos3443bb72017-02-07 14:28:111753 expected_audio.ssrc = 1;
hbos6ded1902016-11-01 08:50:461754 expected_audio.is_remote = false;
1755 expected_audio.media_type = "audio";
Philipp Hancke3bc01662018-08-28 12:55:031756 expected_audio.kind = "audio";
Harald Alvestranda3dab842018-01-14 08:18:581757 expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report);
Steve Anton57858b32018-02-15 23:19:501758 expected_audio.transport_id = "RTCTransport_TransportName_1";
1759 expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
hbos6ded1902016-11-01 08:50:461760 expected_audio.packets_sent = 2;
1761 expected_audio.bytes_sent = 3;
hboscd195be2017-02-07 16:31:271762
hboscd195be2017-02-07 16:31:271763 ASSERT_TRUE(report->Get(expected_audio.id()));
hbosa51d4f32017-02-16 13:34:481764 EXPECT_EQ(
1765 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
1766 expected_audio);
skvladed02c6d2017-02-07 18:45:311767
hbosa51d4f32017-02-16 13:34:481768 ASSERT_TRUE(report->Get(expected_audio.id()));
1769 EXPECT_EQ(
1770 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
1771 expected_audio);
hbosb0ae9202017-01-27 14:35:161772 EXPECT_TRUE(report->Get(*expected_audio.track_id));
hbos84abeb12017-01-16 14:16:441773 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
1774 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
hbos6ded1902016-11-01 08:50:461775}
1776
1777TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
hbos6ded1902016-11-01 08:50:461778 cricket::VideoMediaInfo video_media_info;
hbos0adb8282016-11-23 10:32:061779
hbos6ded1902016-11-01 08:50:461780 video_media_info.senders.push_back(cricket::VideoSenderInfo());
1781 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
1782 video_media_info.senders[0].local_stats[0].ssrc = 1;
1783 video_media_info.senders[0].firs_rcvd = 2;
1784 video_media_info.senders[0].plis_rcvd = 3;
1785 video_media_info.senders[0].nacks_rcvd = 4;
1786 video_media_info.senders[0].packets_sent = 5;
1787 video_media_info.senders[0].bytes_sent = 6;
Oskar Sundbomcbc71b22017-11-16 09:56:071788 video_media_info.senders[0].codec_payload_type = 42;
hbos6769c492017-01-02 16:35:131789 video_media_info.senders[0].frames_encoded = 8;
Danil Chapovalov66cadcc2018-06-19 14:47:431790 video_media_info.senders[0].qp_sum = absl::nullopt;
hbos0adb8282016-11-23 10:32:061791
1792 RtpCodecParameters codec_parameters;
1793 codec_parameters.payload_type = 42;
deadbeefe702b302017-02-04 20:09:011794 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
1795 codec_parameters.name = "dummy";
Oskar Sundbomcbc71b22017-11-16 09:56:071796 codec_parameters.clock_rate = 0;
hbos0adb8282016-11-23 10:32:061797 video_media_info.send_codecs.insert(
1798 std::make_pair(codec_parameters.payload_type, codec_parameters));
1799
Steve Anton57858b32018-02-15 23:19:501800 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:201801 video_media_channel->SetStats(video_media_info);
1802 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_VIDEO,
1803 "LocalVideoTrackID", 1, true);
hbos6ded1902016-11-01 08:50:461804
Steve Anton5b387312018-02-03 00:00:201805 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos6ded1902016-11-01 08:50:461806
Harald Alvestranda3dab842018-01-14 08:18:581807 auto stats_of_my_type = report->GetStatsOfType<RTCOutboundRTPStreamStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231808 ASSERT_EQ(1U, stats_of_my_type.size());
Harald Alvestranda3dab842018-01-14 08:18:581809 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:231810 ASSERT_EQ(1U, stats_of_track_type.size());
Harald Alvestranda3dab842018-01-14 08:18:581811
1812 RTCOutboundRTPStreamStats expected_video(stats_of_my_type[0]->id(),
1813 report->timestamp_us());
hbos3443bb72017-02-07 14:28:111814 expected_video.ssrc = 1;
hbos6ded1902016-11-01 08:50:461815 expected_video.is_remote = false;
1816 expected_video.media_type = "video";
Philipp Hancke3bc01662018-08-28 12:55:031817 expected_video.kind = "video";
Harald Alvestranda3dab842018-01-14 08:18:581818 expected_video.track_id = stats_of_track_type[0]->id();
Steve Anton57858b32018-02-15 23:19:501819 expected_video.transport_id = "RTCTransport_TransportName_1";
1820 expected_video.codec_id = "RTCCodec_VideoMid_Outbound_42";
hbos6ded1902016-11-01 08:50:461821 expected_video.fir_count = 2;
1822 expected_video.pli_count = 3;
1823 expected_video.nack_count = 4;
1824 expected_video.packets_sent = 5;
1825 expected_video.bytes_sent = 6;
skvladed02c6d2017-02-07 18:45:311826 expected_video.frames_encoded = 8;
hbosa7a9be12017-03-01 09:02:451827 // |expected_video.qp_sum| should be undefined.
hboscd195be2017-02-07 16:31:271828 ASSERT_TRUE(report->Get(expected_video.id()));
Harald Alvestranda3dab842018-01-14 08:18:581829
hbosa51d4f32017-02-16 13:34:481830 EXPECT_EQ(
1831 report->Get(expected_video.id())->cast_to<RTCOutboundRTPStreamStats>(),
1832 expected_video);
skvladed02c6d2017-02-07 18:45:311833
hbosa51d4f32017-02-16 13:34:481834 // Set previously undefined values and "GetStats" again.
Oskar Sundbomcbc71b22017-11-16 09:56:071835 video_media_info.senders[0].qp_sum = 9;
hbosa51d4f32017-02-16 13:34:481836 expected_video.qp_sum = 9;
Steve Anton5b387312018-02-03 00:00:201837 video_media_channel->SetStats(video_media_info);
hbosa51d4f32017-02-16 13:34:481838
Steve Anton5b387312018-02-03 00:00:201839 report = stats_->GetFreshStatsReport();
hbosa51d4f32017-02-16 13:34:481840
1841 ASSERT_TRUE(report->Get(expected_video.id()));
1842 EXPECT_EQ(
1843 report->Get(expected_video.id())->cast_to<RTCOutboundRTPStreamStats>(),
1844 expected_video);
hbosb0ae9202017-01-27 14:35:161845 EXPECT_TRUE(report->Get(*expected_video.track_id));
hbos84abeb12017-01-16 14:16:441846 EXPECT_TRUE(report->Get(*expected_video.transport_id));
1847 EXPECT_TRUE(report->Get(*expected_video.codec_id));
hbos6ded1902016-11-01 08:50:461848}
1849
hbos2fa7c672016-10-24 11:00:051850TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) {
Steve Anton5b387312018-02-03 00:00:201851 const char kTransportName[] = "transport";
1852
1853 pc_->AddVoiceChannel("audio", kTransportName);
1854
Gary Liu37e489c2017-11-21 18:49:361855 std::unique_ptr<cricket::Candidate> rtp_local_candidate =
1856 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
1857 cricket::LOCAL_PORT_TYPE, 42);
hbos2fa7c672016-10-24 11:00:051858 std::unique_ptr<cricket::Candidate> rtp_remote_candidate =
1859 CreateFakeCandidate("42.42.42.42", 42, "protocol",
Gary Liu37e489c2017-11-21 18:49:361860 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
1861 42);
hbos2fa7c672016-10-24 11:00:051862 std::unique_ptr<cricket::Candidate> rtcp_local_candidate =
Gary Liu37e489c2017-11-21 18:49:361863 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
hbos2fa7c672016-10-24 11:00:051864 cricket::LOCAL_PORT_TYPE, 42);
1865 std::unique_ptr<cricket::Candidate> rtcp_remote_candidate =
1866 CreateFakeCandidate("42.42.42.42", 42, "protocol",
Gary Liu37e489c2017-11-21 18:49:361867 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
1868 42);
hbos2fa7c672016-10-24 11:00:051869
hbos2fa7c672016-10-24 11:00:051870 cricket::ConnectionInfo rtp_connection_info;
1871 rtp_connection_info.best_connection = false;
1872 rtp_connection_info.local_candidate = *rtp_local_candidate.get();
1873 rtp_connection_info.remote_candidate = *rtp_remote_candidate.get();
1874 rtp_connection_info.sent_total_bytes = 42;
1875 rtp_connection_info.recv_total_bytes = 1337;
1876 cricket::TransportChannelStats rtp_transport_channel_stats;
1877 rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
1878 rtp_transport_channel_stats.connection_infos.push_back(rtp_connection_info);
hbos7064d592017-01-16 15:38:021879 rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
Steve Anton5b387312018-02-03 00:00:201880 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
hbos2fa7c672016-10-24 11:00:051881
1882 // Get stats without RTCP, an active connection or certificates.
Steve Anton5b387312018-02-03 00:00:201883 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
hbos0583b282016-11-30 09:50:141884
1885 RTCTransportStats expected_rtp_transport(
1886 "RTCTransport_transport_" +
Jonas Olsson6b1985d2018-07-05 09:59:481887 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP),
hbos0583b282016-11-30 09:50:141888 report->timestamp_us());
1889 expected_rtp_transport.bytes_sent = 42;
1890 expected_rtp_transport.bytes_received = 1337;
hbos7064d592017-01-16 15:38:021891 expected_rtp_transport.dtls_state = RTCDtlsTransportState::kNew;
hbos0583b282016-11-30 09:50:141892
hbosdbb64d82016-12-21 09:57:461893 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
hbos0583b282016-11-30 09:50:141894 EXPECT_EQ(
1895 expected_rtp_transport,
1896 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
hbos2fa7c672016-10-24 11:00:051897
1898 cricket::ConnectionInfo rtcp_connection_info;
1899 rtcp_connection_info.best_connection = false;
1900 rtcp_connection_info.local_candidate = *rtcp_local_candidate.get();
1901 rtcp_connection_info.remote_candidate = *rtcp_remote_candidate.get();
1902 rtcp_connection_info.sent_total_bytes = 1337;
1903 rtcp_connection_info.recv_total_bytes = 42;
1904 cricket::TransportChannelStats rtcp_transport_channel_stats;
1905 rtcp_transport_channel_stats.component =
1906 cricket::ICE_CANDIDATE_COMPONENT_RTCP;
1907 rtcp_transport_channel_stats.connection_infos.push_back(rtcp_connection_info);
hbos7064d592017-01-16 15:38:021908 rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTING;
Steve Anton5b387312018-02-03 00:00:201909 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
1910 rtcp_transport_channel_stats});
hbos2fa7c672016-10-24 11:00:051911
hbos2fa7c672016-10-24 11:00:051912 // Get stats with RTCP and without an active connection or certificates.
Steve Anton5b387312018-02-03 00:00:201913 report = stats_->GetFreshStatsReport();
hbos0583b282016-11-30 09:50:141914
1915 RTCTransportStats expected_rtcp_transport(
1916 "RTCTransport_transport_" +
Jonas Olsson6b1985d2018-07-05 09:59:481917 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTCP),
hbos0583b282016-11-30 09:50:141918 report->timestamp_us());
1919 expected_rtcp_transport.bytes_sent = 1337;
1920 expected_rtcp_transport.bytes_received = 42;
hbos7064d592017-01-16 15:38:021921 expected_rtcp_transport.dtls_state = RTCDtlsTransportState::kConnecting;
hbos0583b282016-11-30 09:50:141922
1923 expected_rtp_transport.rtcp_transport_stats_id = expected_rtcp_transport.id();
1924
hbosdbb64d82016-12-21 09:57:461925 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
hbos0583b282016-11-30 09:50:141926 EXPECT_EQ(
1927 expected_rtp_transport,
1928 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
hbosdbb64d82016-12-21 09:57:461929 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
hbos0583b282016-11-30 09:50:141930 EXPECT_EQ(
1931 expected_rtcp_transport,
1932 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
hbos2fa7c672016-10-24 11:00:051933
hbos7064d592017-01-16 15:38:021934 // Get stats with an active connection (selected candidate pair).
Steve Anton5b387312018-02-03 00:00:201935 rtcp_transport_channel_stats.connection_infos[0].best_connection = true;
1936 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
1937 rtcp_transport_channel_stats});
hbos2fa7c672016-10-24 11:00:051938
Steve Anton5b387312018-02-03 00:00:201939 report = stats_->GetFreshStatsReport();
hbos0583b282016-11-30 09:50:141940
hbos0583b282016-11-30 09:50:141941 expected_rtcp_transport.selected_candidate_pair_id =
1942 "RTCIceCandidatePair_" + rtcp_local_candidate->id() + "_" +
1943 rtcp_remote_candidate->id();
1944
hbosdbb64d82016-12-21 09:57:461945 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
hbos0583b282016-11-30 09:50:141946 EXPECT_EQ(
1947 expected_rtp_transport,
1948 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
hbosdbb64d82016-12-21 09:57:461949 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
hbos0583b282016-11-30 09:50:141950 EXPECT_EQ(
1951 expected_rtcp_transport,
1952 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
hbos2fa7c672016-10-24 11:00:051953
1954 // Get stats with certificates.
1955 std::unique_ptr<CertificateInfo> local_certinfo =
Steve Anton5b387312018-02-03 00:00:201956 CreateFakeCertificateAndInfoFromDers({"(local) local", "(local) chain"});
1957 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
hbos2fa7c672016-10-24 11:00:051958 std::unique_ptr<CertificateInfo> remote_certinfo =
1959 CreateFakeCertificateAndInfoFromDers(
Steve Anton5b387312018-02-03 00:00:201960 {"(remote) local", "(remote) chain"});
Taylor Brandstetterc3928662018-02-23 21:04:511961 pc_->SetRemoteCertChain(
Benjamin Wright6c6c9df2018-10-25 08:16:261962 kTransportName,
1963 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
hbos2fa7c672016-10-24 11:00:051964
Steve Anton5b387312018-02-03 00:00:201965 report = stats_->GetFreshStatsReport();
hbos0583b282016-11-30 09:50:141966
1967 expected_rtp_transport.local_certificate_id =
1968 "RTCCertificate_" + local_certinfo->fingerprints[0];
1969 expected_rtp_transport.remote_certificate_id =
1970 "RTCCertificate_" + remote_certinfo->fingerprints[0];
1971
1972 expected_rtcp_transport.local_certificate_id =
1973 *expected_rtp_transport.local_certificate_id;
1974 expected_rtcp_transport.remote_certificate_id =
1975 *expected_rtp_transport.remote_certificate_id;
1976
hbosdbb64d82016-12-21 09:57:461977 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
hbos0583b282016-11-30 09:50:141978 EXPECT_EQ(
1979 expected_rtp_transport,
1980 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
hbosdbb64d82016-12-21 09:57:461981 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
hbos0583b282016-11-30 09:50:141982 EXPECT_EQ(
1983 expected_rtcp_transport,
1984 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
hbos2fa7c672016-10-24 11:00:051985}
1986
Harald Alvestrand89061872018-01-02 13:08:341987TEST_F(RTCStatsCollectorTest, CollectNoStreamRTCOutboundRTPStreamStats_Audio) {
Harald Alvestrand89061872018-01-02 13:08:341988 cricket::VoiceMediaInfo voice_media_info;
1989
1990 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
1991 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
1992 voice_media_info.senders[0].local_stats[0].ssrc = 1;
1993 voice_media_info.senders[0].packets_sent = 2;
1994 voice_media_info.senders[0].bytes_sent = 3;
1995 voice_media_info.senders[0].codec_payload_type = 42;
1996
1997 RtpCodecParameters codec_parameters;
1998 codec_parameters.payload_type = 42;
1999 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
2000 codec_parameters.name = "dummy";
2001 codec_parameters.clock_rate = 0;
2002 voice_media_info.send_codecs.insert(
2003 std::make_pair(codec_parameters.payload_type, codec_parameters));
2004
Steve Anton5b387312018-02-03 00:00:202005 // Emulates the case where AddTrack is used without an associated MediaStream
Steve Anton57858b32018-02-15 23:19:502006 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
Steve Anton5b387312018-02-03 00:00:202007 voice_media_channel->SetStats(voice_media_info);
2008 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_AUDIO,
2009 "LocalAudioTrackID", 1, false);
Harald Alvestrand89061872018-01-02 13:08:342010
Steve Anton5b387312018-02-03 00:00:202011 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
Harald Alvestrand89061872018-01-02 13:08:342012
2013 RTCOutboundRTPStreamStats expected_audio("RTCOutboundRTPAudioStream_1",
2014 report->timestamp_us());
2015 expected_audio.ssrc = 1;
2016 expected_audio.is_remote = false;
2017 expected_audio.media_type = "audio";
Philipp Hancke3bc01662018-08-28 12:55:032018 expected_audio.kind = "audio";
Harald Alvestranda3dab842018-01-14 08:18:582019 expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report);
Steve Anton57858b32018-02-15 23:19:502020 expected_audio.transport_id = "RTCTransport_TransportName_1";
2021 expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
Harald Alvestrand89061872018-01-02 13:08:342022 expected_audio.packets_sent = 2;
2023 expected_audio.bytes_sent = 3;
2024
2025 ASSERT_TRUE(report->Get(expected_audio.id()));
2026 EXPECT_EQ(
2027 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
2028 expected_audio);
Harald Alvestrand89061872018-01-02 13:08:342029 EXPECT_TRUE(report->Get(*expected_audio.track_id));
2030 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
2031 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
2032}
2033
Henrik Boström5b3541f2018-03-19 12:52:562034TEST_F(RTCStatsCollectorTest, GetStatsWithSenderSelector) {
2035 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
2036 // Expected stats graph when filtered by sender:
2037 //
2038 // track (sender)
2039 // ^
2040 // |
2041 // outbound-rtp
2042 // | |
2043 // v v
2044 // codec (send) transport
2045 rtc::scoped_refptr<const RTCStatsReport> sender_report =
2046 stats_->GetStatsReportWithSenderSelector(graph.sender);
2047 EXPECT_TRUE(sender_report);
2048 EXPECT_EQ(sender_report->timestamp_us(), graph.full_report->timestamp_us());
2049 EXPECT_EQ(sender_report->size(), 4u);
2050 EXPECT_TRUE(sender_report->Get(graph.send_codec_id));
2051 EXPECT_FALSE(sender_report->Get(graph.recv_codec_id));
2052 EXPECT_TRUE(sender_report->Get(graph.outbound_rtp_id));
2053 EXPECT_FALSE(sender_report->Get(graph.inbound_rtp_id));
2054 EXPECT_TRUE(sender_report->Get(graph.transport_id));
2055 EXPECT_TRUE(sender_report->Get(graph.sender_track_id));
2056 EXPECT_FALSE(sender_report->Get(graph.receiver_track_id));
2057 EXPECT_FALSE(sender_report->Get(graph.remote_stream_id));
2058 EXPECT_FALSE(sender_report->Get(graph.peer_connection_id));
2059}
2060
2061TEST_F(RTCStatsCollectorTest, GetStatsWithReceiverSelector) {
2062 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
2063 // Expected stats graph when filtered by receiver:
2064 //
2065 // track (receiver)
2066 // ^
2067 // |
2068 // inbound-rtp ---------------+
2069 // | |
2070 // v v
2071 // transport codec (recv)
2072 rtc::scoped_refptr<const RTCStatsReport> receiver_report =
2073 stats_->GetStatsReportWithReceiverSelector(graph.receiver);
2074 EXPECT_TRUE(receiver_report);
2075 EXPECT_EQ(receiver_report->size(), 4u);
2076 EXPECT_EQ(receiver_report->timestamp_us(), graph.full_report->timestamp_us());
2077 EXPECT_FALSE(receiver_report->Get(graph.send_codec_id));
2078 EXPECT_TRUE(receiver_report->Get(graph.recv_codec_id));
2079 EXPECT_FALSE(receiver_report->Get(graph.outbound_rtp_id));
2080 EXPECT_TRUE(receiver_report->Get(graph.inbound_rtp_id));
2081 EXPECT_TRUE(receiver_report->Get(graph.transport_id));
2082 EXPECT_FALSE(receiver_report->Get(graph.sender_track_id));
2083 EXPECT_TRUE(receiver_report->Get(graph.receiver_track_id));
2084 EXPECT_FALSE(receiver_report->Get(graph.remote_stream_id));
2085 EXPECT_FALSE(receiver_report->Get(graph.peer_connection_id));
2086}
2087
2088TEST_F(RTCStatsCollectorTest, GetStatsWithNullSenderSelector) {
2089 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
2090 rtc::scoped_refptr<const RTCStatsReport> empty_report =
2091 stats_->GetStatsReportWithSenderSelector(nullptr);
2092 EXPECT_TRUE(empty_report);
2093 EXPECT_EQ(empty_report->timestamp_us(), graph.full_report->timestamp_us());
2094 EXPECT_EQ(empty_report->size(), 0u);
2095}
2096
2097TEST_F(RTCStatsCollectorTest, GetStatsWithNullReceiverSelector) {
2098 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
2099 rtc::scoped_refptr<const RTCStatsReport> empty_report =
2100 stats_->GetStatsReportWithReceiverSelector(nullptr);
2101 EXPECT_TRUE(empty_report);
2102 EXPECT_EQ(empty_report->timestamp_us(), graph.full_report->timestamp_us());
2103 EXPECT_EQ(empty_report->size(), 0u);
2104}
2105
Harald Alvestrand89061872018-01-02 13:08:342106// When the PC has not had SetLocalDescription done, tracks all have
2107// SSRC 0, meaning "unconnected".
Harald Alvestrandb8e12012018-01-23 14:28:162108// In this state, we report on track stats, but not RTP stats.
2109TEST_F(RTCStatsCollectorTest, StatsReportedOnZeroSsrc) {
Harald Alvestrand89061872018-01-02 13:08:342110 rtc::scoped_refptr<MediaStreamTrackInterface> track =
2111 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "audioTrack",
2112 MediaStreamTrackInterface::kLive);
Steve Anton57858b32018-02-15 23:19:502113 rtc::scoped_refptr<MockRtpSenderInternal> sender =
2114 CreateMockSender(track, 0, 49, {});
Steve Anton5b387312018-02-03 00:00:202115 pc_->AddSender(sender);
2116
2117 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2118
Harald Alvestrand89061872018-01-02 13:08:342119 std::vector<const RTCMediaStreamTrackStats*> track_stats =
2120 report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:232121 EXPECT_EQ(1U, track_stats.size());
Steve Anton5b387312018-02-03 00:00:202122
Harald Alvestrandb8e12012018-01-23 14:28:162123 std::vector<const RTCRTPStreamStats*> rtp_stream_stats =
2124 report->GetStatsOfType<RTCRTPStreamStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:232125 EXPECT_EQ(0U, rtp_stream_stats.size());
Harald Alvestrand89061872018-01-02 13:08:342126}
2127
Harald Alvestrand76d29522018-01-30 13:43:292128TEST_F(RTCStatsCollectorTest, DoNotCrashOnSsrcChange) {
2129 rtc::scoped_refptr<MediaStreamTrackInterface> track =
2130 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "audioTrack",
2131 MediaStreamTrackInterface::kLive);
Steve Anton57858b32018-02-15 23:19:502132 rtc::scoped_refptr<MockRtpSenderInternal> sender =
Harald Alvestrand76d29522018-01-30 13:43:292133 CreateMockSender(track, 4711, 49, {});
Steve Anton5b387312018-02-03 00:00:202134 pc_->AddSender(sender);
2135
Harald Alvestrand76d29522018-01-30 13:43:292136 // We do not generate any matching voice_sender_info stats.
Steve Anton5b387312018-02-03 00:00:202137 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2138
Harald Alvestrand76d29522018-01-30 13:43:292139 std::vector<const RTCMediaStreamTrackStats*> track_stats =
2140 report->GetStatsOfType<RTCMediaStreamTrackStats>();
Mirko Bonadeie12c1fe2018-07-03 10:53:232141 EXPECT_EQ(1U, track_stats.size());
Harald Alvestrand76d29522018-01-30 13:43:292142}
2143
Taylor Brandstetter87d5a742018-03-06 17:42:252144// Used for test below, to test calling GetStatsReport during a callback.
Taylor Brandstetter25e022f2018-03-08 17:53:472145class RecursiveCallback : public RTCStatsCollectorCallback {
Taylor Brandstetter87d5a742018-03-06 17:42:252146 public:
Taylor Brandstetter25e022f2018-03-08 17:53:472147 explicit RecursiveCallback(RTCStatsCollectorWrapper* stats) : stats_(stats) {}
Taylor Brandstetter87d5a742018-03-06 17:42:252148
2149 void OnStatsDelivered(
2150 const rtc::scoped_refptr<const RTCStatsReport>& report) override {
2151 stats_->GetStatsReport();
2152 called_ = true;
2153 }
2154
2155 bool called() const { return called_; }
2156
2157 private:
2158 RTCStatsCollectorWrapper* stats_;
2159 bool called_ = false;
2160};
2161
2162// Test that nothing bad happens if a callback causes GetStatsReport to be
2163// called again recursively. Regression test for crbug.com/webrtc/8973.
Taylor Brandstetter25e022f2018-03-08 17:53:472164TEST_F(RTCStatsCollectorTest, DoNotCrashWhenGetStatsCalledDuringCallback) {
2165 rtc::scoped_refptr<RecursiveCallback> callback1(
2166 new rtc::RefCountedObject<RecursiveCallback>(stats_.get()));
2167 rtc::scoped_refptr<RecursiveCallback> callback2(
2168 new rtc::RefCountedObject<RecursiveCallback>(stats_.get()));
Taylor Brandstetter87d5a742018-03-06 17:42:252169 stats_->stats_collector()->GetStatsReport(callback1);
2170 stats_->stats_collector()->GetStatsReport(callback2);
2171 EXPECT_TRUE_WAIT(callback1->called(), kGetStatsReportTimeoutMs);
2172 EXPECT_TRUE_WAIT(callback2->called(), kGetStatsReportTimeoutMs);
2173}
2174
Steve Anton5b387312018-02-03 00:00:202175class RTCTestStats : public RTCStats {
hbosc82f2e12016-09-05 08:36:502176 public:
Steve Anton5b387312018-02-03 00:00:202177 WEBRTC_RTCSTATS_DECL();
2178
2179 RTCTestStats(const std::string& id, int64_t timestamp_us)
2180 : RTCStats(id, timestamp_us), dummy_stat("dummyStat") {}
2181
2182 RTCStatsMember<int32_t> dummy_stat;
2183};
2184
2185WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats", &dummy_stat);
2186
2187// Overrides the stats collection to verify thread usage and that the resulting
2188// partial reports are merged.
2189class FakeRTCStatsCollector : public RTCStatsCollector,
2190 public RTCStatsCollectorCallback {
2191 public:
2192 static rtc::scoped_refptr<FakeRTCStatsCollector> Create(
2193 PeerConnectionInternal* pc,
2194 int64_t cache_lifetime_us) {
2195 return rtc::scoped_refptr<FakeRTCStatsCollector>(
2196 new rtc::RefCountedObject<FakeRTCStatsCollector>(pc,
2197 cache_lifetime_us));
2198 }
2199
2200 // RTCStatsCollectorCallback implementation.
2201 void OnStatsDelivered(
2202 const rtc::scoped_refptr<const RTCStatsReport>& report) override {
2203 EXPECT_TRUE(signaling_thread_->IsCurrent());
2204 rtc::CritScope cs(&lock_);
2205 delivered_report_ = report;
2206 }
2207
2208 void VerifyThreadUsageAndResultsMerging() {
2209 GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback>(this));
2210 EXPECT_TRUE_WAIT(HasVerifiedResults(), kGetStatsReportTimeoutMs);
2211 }
2212
2213 bool HasVerifiedResults() {
2214 EXPECT_TRUE(signaling_thread_->IsCurrent());
2215 rtc::CritScope cs(&lock_);
2216 if (!delivered_report_)
2217 return false;
2218 EXPECT_EQ(produced_on_signaling_thread_, 1);
2219 EXPECT_EQ(produced_on_network_thread_, 1);
2220
2221 EXPECT_TRUE(delivered_report_->Get("SignalingThreadStats"));
2222 EXPECT_TRUE(delivered_report_->Get("NetworkThreadStats"));
2223
2224 produced_on_signaling_thread_ = 0;
2225 produced_on_network_thread_ = 0;
2226 delivered_report_ = nullptr;
2227 return true;
hbosc82f2e12016-09-05 08:36:502228 }
2229
2230 protected:
Steve Anton5b387312018-02-03 00:00:202231 FakeRTCStatsCollector(PeerConnectionInternal* pc, int64_t cache_lifetime)
2232 : RTCStatsCollector(pc, cache_lifetime),
2233 signaling_thread_(pc->signaling_thread()),
2234 worker_thread_(pc->worker_thread()),
2235 network_thread_(pc->network_thread()) {}
2236
2237 void ProducePartialResultsOnSignalingThread(int64_t timestamp_us) override {
2238 EXPECT_TRUE(signaling_thread_->IsCurrent());
2239 {
2240 rtc::CritScope cs(&lock_);
2241 EXPECT_FALSE(delivered_report_);
2242 ++produced_on_signaling_thread_;
2243 }
2244
2245 rtc::scoped_refptr<RTCStatsReport> signaling_report =
2246 RTCStatsReport::Create(0);
2247 signaling_report->AddStats(std::unique_ptr<const RTCStats>(
2248 new RTCTestStats("SignalingThreadStats", timestamp_us)));
2249 AddPartialResults(signaling_report);
2250 }
2251 void ProducePartialResultsOnNetworkThread(int64_t timestamp_us) override {
2252 EXPECT_TRUE(network_thread_->IsCurrent());
2253 {
2254 rtc::CritScope cs(&lock_);
2255 EXPECT_FALSE(delivered_report_);
2256 ++produced_on_network_thread_;
2257 }
2258
2259 rtc::scoped_refptr<RTCStatsReport> network_report =
2260 RTCStatsReport::Create(0);
2261 network_report->AddStats(std::unique_ptr<const RTCStats>(
2262 new RTCTestStats("NetworkThreadStats", timestamp_us)));
2263 AddPartialResults(network_report);
2264 }
2265
2266 private:
2267 rtc::Thread* const signaling_thread_;
2268 rtc::Thread* const worker_thread_;
2269 rtc::Thread* const network_thread_;
2270
2271 rtc::CriticalSection lock_;
2272 rtc::scoped_refptr<const RTCStatsReport> delivered_report_;
2273 int produced_on_signaling_thread_ = 0;
2274 int produced_on_network_thread_ = 0;
hbosc82f2e12016-09-05 08:36:502275};
2276
Steve Anton5b387312018-02-03 00:00:202277TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
2278 rtc::scoped_refptr<FakePeerConnectionForStats> pc(
2279 new rtc::RefCountedObject<FakePeerConnectionForStats>());
2280 rtc::scoped_refptr<FakeRTCStatsCollector> stats_collector(
2281 FakeRTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec));
2282 stats_collector->VerifyThreadUsageAndResultsMerging();
hbosc82f2e12016-09-05 08:36:502283}
2284
2285} // namespace
2286
hbosd565b732016-08-30 21:04:352287} // namespace webrtc