1 /*
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
11 #include "pc/rtc_stats_collector.h"
12
13 #include <ctype.h>
14
15 #include <algorithm>
16 #include <initializer_list>
17 #include <memory>
18 #include <ostream>
19 #include <string>
20 #include <utility>
21 #include <vector>
22
23 #include "absl/memory/memory.h"
24 #include "absl/strings/str_replace.h"
25 #include "api/media_stream_track.h"
26 #include "api/rtp_parameters.h"
27 #include "api/stats/rtc_stats_report.h"
28 #include "api/stats/rtcstats_objects.h"
29 #include "api/units/time_delta.h"
30 #include "modules/rtp_rtcp/include/report_block_data.h"
31 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
32 #include "p2p/base/p2p_constants.h"
33 #include "p2p/base/port.h"
34 #include "pc/media_stream.h"
35 #include "pc/test/fake_data_channel_provider.h"
36 #include "pc/test/fake_peer_connection_for_stats.h"
37 #include "pc/test/mock_data_channel.h"
38 #include "pc/test/mock_rtp_receiver_internal.h"
39 #include "pc/test/mock_rtp_sender_internal.h"
40 #include "pc/test/rtc_stats_obtainer.h"
41 #include "rtc_base/checks.h"
42 #include "rtc_base/fake_clock.h"
43 #include "rtc_base/fake_ssl_identity.h"
44 #include "rtc_base/gunit.h"
45 #include "rtc_base/logging.h"
46 #include "rtc_base/strings/json.h"
47 #include "rtc_base/synchronization/mutex.h"
48 #include "rtc_base/time_utils.h"
49
50 using ::testing::_;
51 using ::testing::AtLeast;
52 using ::testing::Invoke;
53 using ::testing::Return;
54
55 namespace webrtc {
56
57 // These are used by gtest code, such as if |EXPECT_EQ| fails.
PrintTo(const RTCCertificateStats & stats,::std::ostream * os)58 void PrintTo(const RTCCertificateStats& stats, ::std::ostream* os) {
59 *os << stats.ToJson();
60 }
61
PrintTo(const RTCCodecStats & stats,::std::ostream * os)62 void PrintTo(const RTCCodecStats& stats, ::std::ostream* os) {
63 *os << stats.ToJson();
64 }
65
PrintTo(const RTCDataChannelStats & stats,::std::ostream * os)66 void PrintTo(const RTCDataChannelStats& stats, ::std::ostream* os) {
67 *os << stats.ToJson();
68 }
69
PrintTo(const RTCIceCandidatePairStats & stats,::std::ostream * os)70 void PrintTo(const RTCIceCandidatePairStats& stats, ::std::ostream* os) {
71 *os << stats.ToJson();
72 }
73
PrintTo(const RTCLocalIceCandidateStats & stats,::std::ostream * os)74 void PrintTo(const RTCLocalIceCandidateStats& stats, ::std::ostream* os) {
75 *os << stats.ToJson();
76 }
77
PrintTo(const RTCRemoteIceCandidateStats & stats,::std::ostream * os)78 void PrintTo(const RTCRemoteIceCandidateStats& stats, ::std::ostream* os) {
79 *os << stats.ToJson();
80 }
81
PrintTo(const RTCPeerConnectionStats & stats,::std::ostream * os)82 void PrintTo(const RTCPeerConnectionStats& stats, ::std::ostream* os) {
83 *os << stats.ToJson();
84 }
85
PrintTo(const RTCMediaStreamStats & stats,::std::ostream * os)86 void PrintTo(const RTCMediaStreamStats& stats, ::std::ostream* os) {
87 *os << stats.ToJson();
88 }
89
PrintTo(const RTCMediaStreamTrackStats & stats,::std::ostream * os)90 void PrintTo(const RTCMediaStreamTrackStats& stats, ::std::ostream* os) {
91 *os << stats.ToJson();
92 }
93
PrintTo(const RTCInboundRTPStreamStats & stats,::std::ostream * os)94 void PrintTo(const RTCInboundRTPStreamStats& stats, ::std::ostream* os) {
95 *os << stats.ToJson();
96 }
97
PrintTo(const RTCOutboundRTPStreamStats & stats,::std::ostream * os)98 void PrintTo(const RTCOutboundRTPStreamStats& stats, ::std::ostream* os) {
99 *os << stats.ToJson();
100 }
101
PrintTo(const RTCRemoteInboundRtpStreamStats & stats,::std::ostream * os)102 void PrintTo(const RTCRemoteInboundRtpStreamStats& stats, ::std::ostream* os) {
103 *os << stats.ToJson();
104 }
105
PrintTo(const RTCAudioSourceStats & stats,::std::ostream * os)106 void PrintTo(const RTCAudioSourceStats& stats, ::std::ostream* os) {
107 *os << stats.ToJson();
108 }
109
PrintTo(const RTCVideoSourceStats & stats,::std::ostream * os)110 void PrintTo(const RTCVideoSourceStats& stats, ::std::ostream* os) {
111 *os << stats.ToJson();
112 }
113
PrintTo(const RTCTransportStats & stats,::std::ostream * os)114 void PrintTo(const RTCTransportStats& stats, ::std::ostream* os) {
115 *os << stats.ToJson();
116 }
117
118 namespace {
119
120 const int64_t kGetStatsReportTimeoutMs = 1000;
121
122 // Fake data used by `SetupExampleStatsVoiceGraph()` to fill in remote outbound
123 // stats.
124 constexpr int64_t kRemoteOutboundStatsTimestampMs = 123;
125 constexpr int64_t kRemoteOutboundStatsRemoteTimestampMs = 456;
126 constexpr uint32_t kRemoteOutboundStatsPacketsSent = 7u;
127 constexpr uint64_t kRemoteOutboundStatsBytesSent = 8u;
128 constexpr uint64_t kRemoteOutboundStatsReportsCount = 9u;
129
130 struct CertificateInfo {
131 rtc::scoped_refptr<rtc::RTCCertificate> certificate;
132 std::vector<std::string> ders;
133 std::vector<std::string> pems;
134 std::vector<std::string> fingerprints;
135 };
136
137 // Return the ID for an object of the given type in a report.
138 // The object must be present and be unique.
139 template <typename T>
IdForType(const RTCStatsReport * report)140 std::string IdForType(const RTCStatsReport* report) {
141 auto stats_of_my_type = report->RTCStatsReport::GetStatsOfType<T>();
142 // We cannot use ASSERT here, since we're within a function.
143 EXPECT_EQ(1U, stats_of_my_type.size())
144 << "Unexpected number of stats of this type";
145 if (stats_of_my_type.size() == 1) {
146 return stats_of_my_type[0]->id();
147 } else {
148 // Return something that is not going to be a valid stas ID.
149 return "Type not found";
150 }
151 }
152
CreateFakeCertificateAndInfoFromDers(const std::vector<std::string> & ders)153 std::unique_ptr<CertificateInfo> CreateFakeCertificateAndInfoFromDers(
154 const std::vector<std::string>& ders) {
155 RTC_CHECK(!ders.empty());
156 std::unique_ptr<CertificateInfo> info(new CertificateInfo());
157 info->ders = ders;
158 for (const std::string& der : ders) {
159 info->pems.push_back(rtc::SSLIdentity::DerToPem(
160 "CERTIFICATE", reinterpret_cast<const unsigned char*>(der.c_str()),
161 der.length()));
162 }
163 info->certificate =
164 rtc::RTCCertificate::Create(std::unique_ptr<rtc::FakeSSLIdentity>(
165 new rtc::FakeSSLIdentity(info->pems)));
166 // Strip header/footer and newline characters of PEM strings.
167 for (size_t i = 0; i < info->pems.size(); ++i) {
168 absl::StrReplaceAll({{"-----BEGIN CERTIFICATE-----", ""},
169 {"-----END CERTIFICATE-----", ""},
170 {"\n", ""}},
171 &info->pems[i]);
172 }
173 // Fingerprints for the whole certificate chain, starting with leaf
174 // certificate.
175 const rtc::SSLCertChain& chain = info->certificate->GetSSLCertificateChain();
176 std::unique_ptr<rtc::SSLFingerprint> fp;
177 for (size_t i = 0; i < chain.GetSize(); i++) {
178 fp = rtc::SSLFingerprint::Create("sha-1", chain.Get(i));
179 EXPECT_TRUE(fp);
180 info->fingerprints.push_back(fp->GetRfc4572Fingerprint());
181 }
182 EXPECT_EQ(info->ders.size(), info->fingerprints.size());
183 return info;
184 }
185
CreateFakeCandidate(const std::string & hostname,int port,const std::string & protocol,const rtc::AdapterType adapter_type,const std::string & candidate_type,uint32_t priority)186 std::unique_ptr<cricket::Candidate> CreateFakeCandidate(
187 const std::string& hostname,
188 int port,
189 const std::string& protocol,
190 const rtc::AdapterType adapter_type,
191 const std::string& candidate_type,
192 uint32_t priority) {
193 std::unique_ptr<cricket::Candidate> candidate(new cricket::Candidate());
194 candidate->set_address(rtc::SocketAddress(hostname, port));
195 candidate->set_protocol(protocol);
196 candidate->set_network_type(adapter_type);
197 candidate->set_type(candidate_type);
198 candidate->set_priority(priority);
199 return candidate;
200 }
201
202 class FakeAudioTrackForStats : public MediaStreamTrack<AudioTrackInterface> {
203 public:
Create(const std::string & id,MediaStreamTrackInterface::TrackState state)204 static rtc::scoped_refptr<FakeAudioTrackForStats> Create(
205 const std::string& id,
206 MediaStreamTrackInterface::TrackState state) {
207 rtc::scoped_refptr<FakeAudioTrackForStats> audio_track_stats(
208 new rtc::RefCountedObject<FakeAudioTrackForStats>(id));
209 audio_track_stats->set_state(state);
210 return audio_track_stats;
211 }
212
FakeAudioTrackForStats(const std::string & id)213 explicit FakeAudioTrackForStats(const std::string& id)
214 : MediaStreamTrack<AudioTrackInterface>(id) {}
215
kind() const216 std::string kind() const override {
217 return MediaStreamTrackInterface::kAudioKind;
218 }
GetSource() const219 webrtc::AudioSourceInterface* GetSource() const override { return nullptr; }
AddSink(webrtc::AudioTrackSinkInterface * sink)220 void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
RemoveSink(webrtc::AudioTrackSinkInterface * sink)221 void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
GetSignalLevel(int * level)222 bool GetSignalLevel(int* level) override { return false; }
GetAudioProcessor()223 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
224 return nullptr;
225 }
226 };
227
228 class FakeVideoTrackSourceForStats : public VideoTrackSourceInterface {
229 public:
Create(int input_width,int input_height)230 static rtc::scoped_refptr<FakeVideoTrackSourceForStats> Create(
231 int input_width,
232 int input_height) {
233 return rtc::scoped_refptr<FakeVideoTrackSourceForStats>(
234 new rtc::RefCountedObject<FakeVideoTrackSourceForStats>(input_width,
235 input_height));
236 }
237
FakeVideoTrackSourceForStats(int input_width,int input_height)238 FakeVideoTrackSourceForStats(int input_width, int input_height)
239 : input_width_(input_width), input_height_(input_height) {}
~FakeVideoTrackSourceForStats()240 ~FakeVideoTrackSourceForStats() override {}
241
242 // VideoTrackSourceInterface
is_screencast() const243 bool is_screencast() const override { return false; }
needs_denoising() const244 absl::optional<bool> needs_denoising() const override { return false; }
GetStats(VideoTrackSourceInterface::Stats * stats)245 bool GetStats(VideoTrackSourceInterface::Stats* stats) override {
246 stats->input_width = input_width_;
247 stats->input_height = input_height_;
248 return true;
249 }
250 // MediaSourceInterface (part of VideoTrackSourceInterface)
state() const251 MediaSourceInterface::SourceState state() const override {
252 return MediaSourceInterface::SourceState::kLive;
253 }
remote() const254 bool remote() const override { return false; }
255 // NotifierInterface (part of MediaSourceInterface)
RegisterObserver(ObserverInterface * observer)256 void RegisterObserver(ObserverInterface* observer) override {}
UnregisterObserver(ObserverInterface * observer)257 void UnregisterObserver(ObserverInterface* observer) override {}
258 // rtc::VideoSourceInterface<VideoFrame> (part of VideoTrackSourceInterface)
AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame> * sink,const rtc::VideoSinkWants & wants)259 void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
260 const rtc::VideoSinkWants& wants) override {}
RemoveSink(rtc::VideoSinkInterface<VideoFrame> * sink)261 void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {}
SupportsEncodedOutput() const262 bool SupportsEncodedOutput() const override { return false; }
GenerateKeyFrame()263 void GenerateKeyFrame() override {}
AddEncodedSink(rtc::VideoSinkInterface<RecordableEncodedFrame> * sink)264 void AddEncodedSink(
265 rtc::VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
RemoveEncodedSink(rtc::VideoSinkInterface<RecordableEncodedFrame> * sink)266 void RemoveEncodedSink(
267 rtc::VideoSinkInterface<RecordableEncodedFrame>* sink) override {}
268
269 private:
270 int input_width_;
271 int input_height_;
272 };
273
274 class FakeVideoTrackForStats : public MediaStreamTrack<VideoTrackInterface> {
275 public:
Create(const std::string & id,MediaStreamTrackInterface::TrackState state,rtc::scoped_refptr<VideoTrackSourceInterface> source)276 static rtc::scoped_refptr<FakeVideoTrackForStats> Create(
277 const std::string& id,
278 MediaStreamTrackInterface::TrackState state,
279 rtc::scoped_refptr<VideoTrackSourceInterface> source) {
280 rtc::scoped_refptr<FakeVideoTrackForStats> video_track(
281 new rtc::RefCountedObject<FakeVideoTrackForStats>(id,
282 std::move(source)));
283 video_track->set_state(state);
284 return video_track;
285 }
286
FakeVideoTrackForStats(const std::string & id,rtc::scoped_refptr<VideoTrackSourceInterface> source)287 FakeVideoTrackForStats(const std::string& id,
288 rtc::scoped_refptr<VideoTrackSourceInterface> source)
289 : MediaStreamTrack<VideoTrackInterface>(id), source_(source) {}
290
kind() const291 std::string kind() const override {
292 return MediaStreamTrackInterface::kVideoKind;
293 }
294
AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame> * sink,const rtc::VideoSinkWants & wants)295 void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
296 const rtc::VideoSinkWants& wants) override {}
RemoveSink(rtc::VideoSinkInterface<VideoFrame> * sink)297 void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) override {}
298
GetSource() const299 VideoTrackSourceInterface* GetSource() const override {
300 return source_.get();
301 }
302
303 private:
304 rtc::scoped_refptr<VideoTrackSourceInterface> source_;
305 };
306
CreateFakeTrack(cricket::MediaType media_type,const std::string & track_id,MediaStreamTrackInterface::TrackState track_state)307 rtc::scoped_refptr<MediaStreamTrackInterface> CreateFakeTrack(
308 cricket::MediaType media_type,
309 const std::string& track_id,
310 MediaStreamTrackInterface::TrackState track_state) {
311 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
312 return FakeAudioTrackForStats::Create(track_id, track_state);
313 } else {
314 RTC_DCHECK_EQ(media_type, cricket::MEDIA_TYPE_VIDEO);
315 return FakeVideoTrackForStats::Create(track_id, track_state, nullptr);
316 }
317 }
318
CreateMockSender(cricket::MediaType media_type,rtc::scoped_refptr<MediaStreamTrackInterface> track,uint32_t ssrc,int attachment_id,std::vector<std::string> local_stream_ids)319 rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
320 cricket::MediaType media_type,
321 rtc::scoped_refptr<MediaStreamTrackInterface> track,
322 uint32_t ssrc,
323 int attachment_id,
324 std::vector<std::string> local_stream_ids) {
325 RTC_DCHECK(!track ||
326 (track->kind() == MediaStreamTrackInterface::kAudioKind &&
327 media_type == cricket::MEDIA_TYPE_AUDIO) ||
328 (track->kind() == MediaStreamTrackInterface::kVideoKind &&
329 media_type == cricket::MEDIA_TYPE_VIDEO));
330 rtc::scoped_refptr<MockRtpSenderInternal> sender(
331 new rtc::RefCountedObject<MockRtpSenderInternal>());
332 EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
333 EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
334 EXPECT_CALL(*sender, media_type()).WillRepeatedly(Return(media_type));
335 EXPECT_CALL(*sender, GetParameters()).WillRepeatedly(Invoke([ssrc]() {
336 RtpParameters params;
337 params.encodings.push_back(RtpEncodingParameters());
338 params.encodings[0].ssrc = ssrc;
339 return params;
340 }));
341 EXPECT_CALL(*sender, AttachmentId()).WillRepeatedly(Return(attachment_id));
342 EXPECT_CALL(*sender, stream_ids()).WillRepeatedly(Return(local_stream_ids));
343 EXPECT_CALL(*sender, SetTransceiverAsStopped());
344 EXPECT_CALL(*sender, Stop());
345 return sender;
346 }
347
CreateMockReceiver(const rtc::scoped_refptr<MediaStreamTrackInterface> & track,uint32_t ssrc,int attachment_id)348 rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
349 const rtc::scoped_refptr<MediaStreamTrackInterface>& track,
350 uint32_t ssrc,
351 int attachment_id) {
352 rtc::scoped_refptr<MockRtpReceiverInternal> receiver(
353 new rtc::RefCountedObject<MockRtpReceiverInternal>());
354 EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
355 EXPECT_CALL(*receiver, streams())
356 .WillRepeatedly(
357 Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>({})));
358
359 EXPECT_CALL(*receiver, media_type())
360 .WillRepeatedly(
361 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
362 ? cricket::MEDIA_TYPE_AUDIO
363 : cricket::MEDIA_TYPE_VIDEO));
364 EXPECT_CALL(*receiver, GetParameters()).WillRepeatedly(Invoke([ssrc]() {
365 RtpParameters params;
366 params.encodings.push_back(RtpEncodingParameters());
367 params.encodings[0].ssrc = ssrc;
368 return params;
369 }));
370 EXPECT_CALL(*receiver, AttachmentId()).WillRepeatedly(Return(attachment_id));
371 EXPECT_CALL(*receiver, StopAndEndTrack());
372 return receiver;
373 }
374
375 class RTCStatsCollectorWrapper {
376 public:
RTCStatsCollectorWrapper(rtc::scoped_refptr<FakePeerConnectionForStats> pc)377 explicit RTCStatsCollectorWrapper(
378 rtc::scoped_refptr<FakePeerConnectionForStats> pc)
379 : pc_(pc),
380 stats_collector_(
381 RTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec)) {
382 }
383
stats_collector()384 rtc::scoped_refptr<RTCStatsCollector> stats_collector() {
385 return stats_collector_;
386 }
387
GetStatsReport()388 rtc::scoped_refptr<const RTCStatsReport> GetStatsReport() {
389 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
390 stats_collector_->GetStatsReport(callback);
391 return WaitForReport(callback);
392 }
393
GetStatsReportWithSenderSelector(rtc::scoped_refptr<RtpSenderInternal> selector)394 rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithSenderSelector(
395 rtc::scoped_refptr<RtpSenderInternal> selector) {
396 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
397 stats_collector_->GetStatsReport(selector, callback);
398 return WaitForReport(callback);
399 }
400
GetStatsReportWithReceiverSelector(rtc::scoped_refptr<RtpReceiverInternal> selector)401 rtc::scoped_refptr<const RTCStatsReport> GetStatsReportWithReceiverSelector(
402 rtc::scoped_refptr<RtpReceiverInternal> selector) {
403 rtc::scoped_refptr<RTCStatsObtainer> callback = RTCStatsObtainer::Create();
404 stats_collector_->GetStatsReport(selector, callback);
405 return WaitForReport(callback);
406 }
407
GetFreshStatsReport()408 rtc::scoped_refptr<const RTCStatsReport> GetFreshStatsReport() {
409 stats_collector_->ClearCachedStatsReport();
410 return GetStatsReport();
411 }
412
SetupLocalTrackAndSender(cricket::MediaType media_type,const std::string & track_id,uint32_t ssrc,bool add_stream,int attachment_id)413 rtc::scoped_refptr<MockRtpSenderInternal> SetupLocalTrackAndSender(
414 cricket::MediaType media_type,
415 const std::string& track_id,
416 uint32_t ssrc,
417 bool add_stream,
418 int attachment_id) {
419 rtc::scoped_refptr<MediaStream> local_stream;
420 if (add_stream) {
421 local_stream = MediaStream::Create("LocalStreamId");
422 pc_->mutable_local_streams()->AddStream(local_stream);
423 }
424
425 rtc::scoped_refptr<MediaStreamTrackInterface> track;
426 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
427 track = CreateFakeTrack(media_type, track_id,
428 MediaStreamTrackInterface::kLive);
429 if (add_stream) {
430 local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
431 }
432 } else {
433 track = CreateFakeTrack(media_type, track_id,
434 MediaStreamTrackInterface::kLive);
435 if (add_stream) {
436 local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
437 }
438 }
439
440 rtc::scoped_refptr<MockRtpSenderInternal> sender =
441 CreateMockSender(media_type, track, ssrc, attachment_id, {});
442 pc_->AddSender(sender);
443 return sender;
444 }
445
SetupRemoteTrackAndReceiver(cricket::MediaType media_type,const std::string & track_id,const std::string & stream_id,uint32_t ssrc)446 rtc::scoped_refptr<MockRtpReceiverInternal> SetupRemoteTrackAndReceiver(
447 cricket::MediaType media_type,
448 const std::string& track_id,
449 const std::string& stream_id,
450 uint32_t ssrc) {
451 rtc::scoped_refptr<MediaStream> remote_stream =
452 MediaStream::Create(stream_id);
453 pc_->mutable_remote_streams()->AddStream(remote_stream);
454
455 rtc::scoped_refptr<MediaStreamTrackInterface> track;
456 if (media_type == cricket::MEDIA_TYPE_AUDIO) {
457 track = CreateFakeTrack(media_type, track_id,
458 MediaStreamTrackInterface::kLive);
459 remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get()));
460 } else {
461 track = CreateFakeTrack(media_type, track_id,
462 MediaStreamTrackInterface::kLive);
463 remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get()));
464 }
465
466 rtc::scoped_refptr<MockRtpReceiverInternal> receiver =
467 CreateMockReceiver(track, ssrc, 62);
468 EXPECT_CALL(*receiver, streams())
469 .WillRepeatedly(
470 Return(std::vector<rtc::scoped_refptr<MediaStreamInterface>>(
471 {remote_stream})));
472 pc_->AddReceiver(receiver);
473 return receiver;
474 }
475
476 // Attaches tracks to peer connections by configuring RTP senders and RTP
477 // receivers according to the tracks' pairings with
478 // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be
479 // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only
480 // be associated with one |[Voice/Video]ReceiverInfo|.
481 // Senders get assigned attachment ID "ssrc + 10".
CreateMockRtpSendersReceiversAndChannels(std::initializer_list<std::pair<MediaStreamTrackInterface *,cricket::VoiceSenderInfo>> local_audio_track_info_pairs,std::initializer_list<std::pair<MediaStreamTrackInterface *,cricket::VoiceReceiverInfo>> remote_audio_track_info_pairs,std::initializer_list<std::pair<MediaStreamTrackInterface *,cricket::VideoSenderInfo>> local_video_track_info_pairs,std::initializer_list<std::pair<MediaStreamTrackInterface *,cricket::VideoReceiverInfo>> remote_video_track_info_pairs,std::vector<std::string> local_stream_ids,std::vector<rtc::scoped_refptr<MediaStreamInterface>> remote_streams)482 void CreateMockRtpSendersReceiversAndChannels(
483 std::initializer_list<
484 std::pair<MediaStreamTrackInterface*, cricket::VoiceSenderInfo>>
485 local_audio_track_info_pairs,
486 std::initializer_list<
487 std::pair<MediaStreamTrackInterface*, cricket::VoiceReceiverInfo>>
488 remote_audio_track_info_pairs,
489 std::initializer_list<
490 std::pair<MediaStreamTrackInterface*, cricket::VideoSenderInfo>>
491 local_video_track_info_pairs,
492 std::initializer_list<
493 std::pair<MediaStreamTrackInterface*, cricket::VideoReceiverInfo>>
494 remote_video_track_info_pairs,
495 std::vector<std::string> local_stream_ids,
496 std::vector<rtc::scoped_refptr<MediaStreamInterface>> remote_streams) {
497 cricket::VoiceMediaInfo voice_media_info;
498 cricket::VideoMediaInfo video_media_info;
499
500 // Local audio tracks and voice sender infos
501 for (auto& pair : local_audio_track_info_pairs) {
502 MediaStreamTrackInterface* local_audio_track = pair.first;
503 const cricket::VoiceSenderInfo& voice_sender_info = pair.second;
504 RTC_DCHECK_EQ(local_audio_track->kind(),
505 MediaStreamTrackInterface::kAudioKind);
506
507 voice_media_info.senders.push_back(voice_sender_info);
508 rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
509 cricket::MEDIA_TYPE_AUDIO,
510 rtc::scoped_refptr<MediaStreamTrackInterface>(local_audio_track),
511 voice_sender_info.local_stats[0].ssrc,
512 voice_sender_info.local_stats[0].ssrc + 10, local_stream_ids);
513 EXPECT_CALL(*rtp_sender, SetMediaChannel(_));
514 pc_->AddSender(rtp_sender);
515 }
516
517 // Remote audio tracks and voice receiver infos
518 for (auto& pair : remote_audio_track_info_pairs) {
519 MediaStreamTrackInterface* remote_audio_track = pair.first;
520 const cricket::VoiceReceiverInfo& voice_receiver_info = pair.second;
521 RTC_DCHECK_EQ(remote_audio_track->kind(),
522 MediaStreamTrackInterface::kAudioKind);
523
524 voice_media_info.receivers.push_back(voice_receiver_info);
525 rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
526 CreateMockReceiver(
527 rtc::scoped_refptr<MediaStreamTrackInterface>(remote_audio_track),
528 voice_receiver_info.local_stats[0].ssrc,
529 voice_receiver_info.local_stats[0].ssrc + 10);
530 EXPECT_CALL(*rtp_receiver, streams())
531 .WillRepeatedly(Return(remote_streams));
532 EXPECT_CALL(*rtp_receiver, SetMediaChannel(_));
533 pc_->AddReceiver(rtp_receiver);
534 }
535
536 // Local video tracks and video sender infos
537 for (auto& pair : local_video_track_info_pairs) {
538 MediaStreamTrackInterface* local_video_track = pair.first;
539 const cricket::VideoSenderInfo& video_sender_info = pair.second;
540 RTC_DCHECK_EQ(local_video_track->kind(),
541 MediaStreamTrackInterface::kVideoKind);
542
543 video_media_info.senders.push_back(video_sender_info);
544 video_media_info.aggregated_senders.push_back(video_sender_info);
545 rtc::scoped_refptr<MockRtpSenderInternal> rtp_sender = CreateMockSender(
546 cricket::MEDIA_TYPE_VIDEO,
547 rtc::scoped_refptr<MediaStreamTrackInterface>(local_video_track),
548 video_sender_info.local_stats[0].ssrc,
549 video_sender_info.local_stats[0].ssrc + 10, local_stream_ids);
550 EXPECT_CALL(*rtp_sender, SetMediaChannel(_));
551 pc_->AddSender(rtp_sender);
552 }
553
554 // Remote video tracks and video receiver infos
555 for (auto& pair : remote_video_track_info_pairs) {
556 MediaStreamTrackInterface* remote_video_track = pair.first;
557 const cricket::VideoReceiverInfo& video_receiver_info = pair.second;
558 RTC_DCHECK_EQ(remote_video_track->kind(),
559 MediaStreamTrackInterface::kVideoKind);
560
561 video_media_info.receivers.push_back(video_receiver_info);
562 rtc::scoped_refptr<MockRtpReceiverInternal> rtp_receiver =
563 CreateMockReceiver(
564 rtc::scoped_refptr<MediaStreamTrackInterface>(remote_video_track),
565 video_receiver_info.local_stats[0].ssrc,
566 video_receiver_info.local_stats[0].ssrc + 10);
567 EXPECT_CALL(*rtp_receiver, streams())
568 .WillRepeatedly(Return(remote_streams));
569 EXPECT_CALL(*rtp_receiver, SetMediaChannel(_));
570 pc_->AddReceiver(rtp_receiver);
571 }
572
573 auto* voice_media_channel = pc_->AddVoiceChannel("audio", "transport");
574 voice_media_channel->SetStats(voice_media_info);
575
576 auto* video_media_channel = pc_->AddVideoChannel("video", "transport");
577 video_media_channel->SetStats(video_media_info);
578 }
579
580 private:
WaitForReport(rtc::scoped_refptr<RTCStatsObtainer> callback)581 rtc::scoped_refptr<const RTCStatsReport> WaitForReport(
582 rtc::scoped_refptr<RTCStatsObtainer> callback) {
583 EXPECT_TRUE_WAIT(callback->report(), kGetStatsReportTimeoutMs);
584 int64_t after = rtc::TimeUTCMicros();
585 for (const RTCStats& stats : *callback->report()) {
586 if (stats.type() == RTCRemoteInboundRtpStreamStats::kType ||
587 stats.type() == RTCRemoteOutboundRtpStreamStats::kType) {
588 // Ignore remote timestamps.
589 continue;
590 }
591 EXPECT_LE(stats.timestamp_us(), after);
592 }
593 return callback->report();
594 }
595
596 rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
597 rtc::scoped_refptr<RTCStatsCollector> stats_collector_;
598 };
599
600 class RTCStatsCollectorTest : public ::testing::Test {
601 public:
RTCStatsCollectorTest()602 RTCStatsCollectorTest()
603 : pc_(new rtc::RefCountedObject<FakePeerConnectionForStats>()),
604 stats_(new RTCStatsCollectorWrapper(pc_)) {}
605
ExpectReportContainsCertificateInfo(const rtc::scoped_refptr<const RTCStatsReport> & report,const CertificateInfo & certinfo)606 void ExpectReportContainsCertificateInfo(
607 const rtc::scoped_refptr<const RTCStatsReport>& report,
608 const CertificateInfo& certinfo) {
609 for (size_t i = 0; i < certinfo.fingerprints.size(); ++i) {
610 RTCCertificateStats expected_certificate_stats(
611 "RTCCertificate_" + certinfo.fingerprints[i], report->timestamp_us());
612 expected_certificate_stats.fingerprint = certinfo.fingerprints[i];
613 expected_certificate_stats.fingerprint_algorithm = "sha-1";
614 expected_certificate_stats.base64_certificate = certinfo.pems[i];
615 if (i + 1 < certinfo.fingerprints.size()) {
616 expected_certificate_stats.issuer_certificate_id =
617 "RTCCertificate_" + certinfo.fingerprints[i + 1];
618 }
619 ASSERT_TRUE(report->Get(expected_certificate_stats.id()));
620 EXPECT_EQ(expected_certificate_stats,
621 report->Get(expected_certificate_stats.id())
622 ->cast_to<RTCCertificateStats>());
623 }
624 }
625
626 struct ExampleStatsGraph {
627 rtc::scoped_refptr<RtpSenderInternal> sender;
628 rtc::scoped_refptr<RtpReceiverInternal> receiver;
629
630 rtc::scoped_refptr<const RTCStatsReport> full_report;
631 std::string send_codec_id;
632 std::string recv_codec_id;
633 std::string outbound_rtp_id;
634 std::string inbound_rtp_id;
635 std::string remote_outbound_rtp_id;
636 std::string transport_id;
637 std::string sender_track_id;
638 std::string receiver_track_id;
639 std::string remote_stream_id;
640 std::string peer_connection_id;
641 std::string media_source_id;
642 };
643
644 // Sets up the example stats graph (see ASCII art below) for a video only
645 // call. The graph is used for testing the stats selection algorithm (see
646 // https://w3c.github.io/webrtc-pc/#dfn-stats-selection-algorithm).
647 // These tests test the integration of the stats traversal algorithm inside of
648 // RTCStatsCollector. See rtcstatstraveral_unittest.cc for more stats
649 // traversal tests.
SetupExampleStatsGraphForSelectorTests()650 ExampleStatsGraph SetupExampleStatsGraphForSelectorTests() {
651 ExampleStatsGraph graph;
652
653 // codec (send)
654 graph.send_codec_id = "RTCCodec_VideoMid_Outbound_1";
655 cricket::VideoMediaInfo video_media_info;
656 RtpCodecParameters send_codec;
657 send_codec.payload_type = 1;
658 send_codec.clock_rate = 0;
659 video_media_info.send_codecs.insert(
660 std::make_pair(send_codec.payload_type, send_codec));
661 // codec (recv)
662 graph.recv_codec_id = "RTCCodec_VideoMid_Inbound_2";
663 RtpCodecParameters recv_codec;
664 recv_codec.payload_type = 2;
665 recv_codec.clock_rate = 0;
666 video_media_info.receive_codecs.insert(
667 std::make_pair(recv_codec.payload_type, recv_codec));
668 // outbound-rtp
669 graph.outbound_rtp_id = "RTCOutboundRTPVideoStream_3";
670 video_media_info.senders.push_back(cricket::VideoSenderInfo());
671 video_media_info.senders[0].local_stats.push_back(
672 cricket::SsrcSenderInfo());
673 video_media_info.senders[0].local_stats[0].ssrc = 3;
674 video_media_info.senders[0].codec_payload_type = send_codec.payload_type;
675 video_media_info.aggregated_senders.push_back(video_media_info.senders[0]);
676 // inbound-rtp
677 graph.inbound_rtp_id = "RTCInboundRTPVideoStream_4";
678 video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
679 video_media_info.receivers[0].local_stats.push_back(
680 cricket::SsrcReceiverInfo());
681 video_media_info.receivers[0].local_stats[0].ssrc = 4;
682 video_media_info.receivers[0].codec_payload_type = recv_codec.payload_type;
683 // transport
684 graph.transport_id = "RTCTransport_TransportName_1";
685 auto* video_media_channel =
686 pc_->AddVideoChannel("VideoMid", "TransportName");
687 video_media_channel->SetStats(video_media_info);
688 // track (sender)
689 graph.sender = stats_->SetupLocalTrackAndSender(
690 cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID", 3, false, 50);
691 graph.sender_track_id = "RTCMediaStreamTrack_sender_" +
692 rtc::ToString(graph.sender->AttachmentId());
693 // track (receiver) and stream (remote stream)
694 graph.receiver = stats_->SetupRemoteTrackAndReceiver(
695 cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 4);
696 graph.receiver_track_id = "RTCMediaStreamTrack_receiver_" +
697 rtc::ToString(graph.receiver->AttachmentId());
698 graph.remote_stream_id = "RTCMediaStream_RemoteStreamId";
699 // peer-connection
700 graph.peer_connection_id = "RTCPeerConnection";
701 // media-source (kind: video)
702 graph.media_source_id =
703 "RTCVideoSource_" + rtc::ToString(graph.sender->AttachmentId());
704
705 // Expected stats graph:
706 //
707 // +--- track (sender) stream (remote stream) ---> track (receiver)
708 // | ^ ^
709 // | | |
710 // | +--------- outbound-rtp inbound-rtp ---------------+
711 // | | | | | |
712 // | | v v v v
713 // | | codec (send) transport codec (recv) peer-connection
714 // v v
715 // media-source
716
717 // Verify the stats graph is set up correctly.
718 graph.full_report = stats_->GetStatsReport();
719 EXPECT_EQ(graph.full_report->size(), 10u);
720 EXPECT_TRUE(graph.full_report->Get(graph.send_codec_id));
721 EXPECT_TRUE(graph.full_report->Get(graph.recv_codec_id));
722 EXPECT_TRUE(graph.full_report->Get(graph.outbound_rtp_id));
723 EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id));
724 EXPECT_TRUE(graph.full_report->Get(graph.transport_id));
725 EXPECT_TRUE(graph.full_report->Get(graph.sender_track_id));
726 EXPECT_TRUE(graph.full_report->Get(graph.receiver_track_id));
727 EXPECT_TRUE(graph.full_report->Get(graph.remote_stream_id));
728 EXPECT_TRUE(graph.full_report->Get(graph.peer_connection_id));
729 EXPECT_TRUE(graph.full_report->Get(graph.media_source_id));
730 const auto& sender_track = graph.full_report->Get(graph.sender_track_id)
731 ->cast_to<RTCMediaStreamTrackStats>();
732 EXPECT_EQ(*sender_track.media_source_id, graph.media_source_id);
733 const auto& outbound_rtp = graph.full_report->Get(graph.outbound_rtp_id)
734 ->cast_to<RTCOutboundRTPStreamStats>();
735 EXPECT_EQ(*outbound_rtp.media_source_id, graph.media_source_id);
736 EXPECT_EQ(*outbound_rtp.codec_id, graph.send_codec_id);
737 EXPECT_EQ(*outbound_rtp.track_id, graph.sender_track_id);
738 EXPECT_EQ(*outbound_rtp.transport_id, graph.transport_id);
739 const auto& inbound_rtp = graph.full_report->Get(graph.inbound_rtp_id)
740 ->cast_to<RTCInboundRTPStreamStats>();
741 EXPECT_EQ(*inbound_rtp.codec_id, graph.recv_codec_id);
742 EXPECT_EQ(*inbound_rtp.track_id, graph.receiver_track_id);
743 EXPECT_EQ(*inbound_rtp.transport_id, graph.transport_id);
744
745 return graph;
746 }
747
748 // Sets up an example stats graph (see ASCII art below) for an audio only call
749 // and checks that the expected stats are generated.
SetupExampleStatsVoiceGraph(bool add_remote_outbound_stats)750 ExampleStatsGraph SetupExampleStatsVoiceGraph(
751 bool add_remote_outbound_stats) {
752 constexpr uint32_t kLocalSsrc = 3;
753 constexpr uint32_t kRemoteSsrc = 4;
754 ExampleStatsGraph graph;
755
756 // codec (send)
757 graph.send_codec_id = "RTCCodec_VoiceMid_Outbound_1";
758 cricket::VoiceMediaInfo media_info;
759 RtpCodecParameters send_codec;
760 send_codec.payload_type = 1;
761 send_codec.clock_rate = 0;
762 media_info.send_codecs.insert(
763 std::make_pair(send_codec.payload_type, send_codec));
764 // codec (recv)
765 graph.recv_codec_id = "RTCCodec_VoiceMid_Inbound_2";
766 RtpCodecParameters recv_codec;
767 recv_codec.payload_type = 2;
768 recv_codec.clock_rate = 0;
769 media_info.receive_codecs.insert(
770 std::make_pair(recv_codec.payload_type, recv_codec));
771 // outbound-rtp
772 graph.outbound_rtp_id = "RTCOutboundRTPAudioStream_3";
773 media_info.senders.push_back(cricket::VoiceSenderInfo());
774 media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
775 media_info.senders[0].local_stats[0].ssrc = kLocalSsrc;
776 media_info.senders[0].codec_payload_type = send_codec.payload_type;
777 // inbound-rtp
778 graph.inbound_rtp_id = "RTCInboundRTPAudioStream_4";
779 media_info.receivers.push_back(cricket::VoiceReceiverInfo());
780 media_info.receivers[0].local_stats.push_back(cricket::SsrcReceiverInfo());
781 media_info.receivers[0].local_stats[0].ssrc = kRemoteSsrc;
782 media_info.receivers[0].codec_payload_type = recv_codec.payload_type;
783 // remote-outbound-rtp
784 if (add_remote_outbound_stats) {
785 graph.remote_outbound_rtp_id = "RTCRemoteOutboundRTPAudioStream_4";
786 media_info.receivers[0].last_sender_report_timestamp_ms =
787 kRemoteOutboundStatsTimestampMs;
788 media_info.receivers[0].last_sender_report_remote_timestamp_ms =
789 kRemoteOutboundStatsRemoteTimestampMs;
790 media_info.receivers[0].sender_reports_packets_sent =
791 kRemoteOutboundStatsPacketsSent;
792 media_info.receivers[0].sender_reports_bytes_sent =
793 kRemoteOutboundStatsBytesSent;
794 media_info.receivers[0].sender_reports_reports_count =
795 kRemoteOutboundStatsReportsCount;
796 }
797
798 // transport
799 graph.transport_id = "RTCTransport_TransportName_1";
800 auto* video_media_channel =
801 pc_->AddVoiceChannel("VoiceMid", "TransportName");
802 video_media_channel->SetStats(media_info);
803 // track (sender)
804 graph.sender = stats_->SetupLocalTrackAndSender(
805 cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID", kLocalSsrc, false, 50);
806 graph.sender_track_id = "RTCMediaStreamTrack_sender_" +
807 rtc::ToString(graph.sender->AttachmentId());
808 // track (receiver) and stream (remote stream)
809 graph.receiver = stats_->SetupRemoteTrackAndReceiver(
810 cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID", "RemoteStreamId",
811 kRemoteSsrc);
812 graph.receiver_track_id = "RTCMediaStreamTrack_receiver_" +
813 rtc::ToString(graph.receiver->AttachmentId());
814 graph.remote_stream_id = "RTCMediaStream_RemoteStreamId";
815 // peer-connection
816 graph.peer_connection_id = "RTCPeerConnection";
817 // media-source (kind: video)
818 graph.media_source_id =
819 "RTCAudioSource_" + rtc::ToString(graph.sender->AttachmentId());
820
821 // Expected stats graph:
822 //
823 // +--- track (sender) stream (remote stream) ---> track (receiver)
824 // | ^ ^
825 // | | |
826 // | +--------- outbound-rtp inbound-rtp ---------------+
827 // | | | | | |
828 // | | v v v v
829 // | | codec (send) transport codec (recv) peer-connection
830 // v v
831 // media-source
832
833 // Verify the stats graph is set up correctly.
834 graph.full_report = stats_->GetStatsReport();
835 EXPECT_EQ(graph.full_report->size(), add_remote_outbound_stats ? 11u : 10u);
836 EXPECT_TRUE(graph.full_report->Get(graph.send_codec_id));
837 EXPECT_TRUE(graph.full_report->Get(graph.recv_codec_id));
838 EXPECT_TRUE(graph.full_report->Get(graph.outbound_rtp_id));
839 EXPECT_TRUE(graph.full_report->Get(graph.inbound_rtp_id));
840 EXPECT_TRUE(graph.full_report->Get(graph.transport_id));
841 EXPECT_TRUE(graph.full_report->Get(graph.sender_track_id));
842 EXPECT_TRUE(graph.full_report->Get(graph.receiver_track_id));
843 EXPECT_TRUE(graph.full_report->Get(graph.remote_stream_id));
844 EXPECT_TRUE(graph.full_report->Get(graph.peer_connection_id));
845 EXPECT_TRUE(graph.full_report->Get(graph.media_source_id));
846 // `graph.remote_outbound_rtp_id` is omitted on purpose so that expectations
847 // can be added by the caller depending on what value it sets for the
848 // `add_remote_outbound_stats` argument.
849 const auto& sender_track = graph.full_report->Get(graph.sender_track_id)
850 ->cast_to<RTCMediaStreamTrackStats>();
851 EXPECT_EQ(*sender_track.media_source_id, graph.media_source_id);
852 const auto& outbound_rtp = graph.full_report->Get(graph.outbound_rtp_id)
853 ->cast_to<RTCOutboundRTPStreamStats>();
854 EXPECT_EQ(*outbound_rtp.media_source_id, graph.media_source_id);
855 EXPECT_EQ(*outbound_rtp.codec_id, graph.send_codec_id);
856 EXPECT_EQ(*outbound_rtp.track_id, graph.sender_track_id);
857 EXPECT_EQ(*outbound_rtp.transport_id, graph.transport_id);
858 const auto& inbound_rtp = graph.full_report->Get(graph.inbound_rtp_id)
859 ->cast_to<RTCInboundRTPStreamStats>();
860 EXPECT_EQ(*inbound_rtp.codec_id, graph.recv_codec_id);
861 EXPECT_EQ(*inbound_rtp.track_id, graph.receiver_track_id);
862 EXPECT_EQ(*inbound_rtp.transport_id, graph.transport_id);
863
864 return graph;
865 }
866
867 protected:
868 rtc::ScopedFakeClock fake_clock_;
869 rtc::scoped_refptr<FakePeerConnectionForStats> pc_;
870 std::unique_ptr<RTCStatsCollectorWrapper> stats_;
871 };
872
TEST_F(RTCStatsCollectorTest,SingleCallback)873 TEST_F(RTCStatsCollectorTest, SingleCallback) {
874 rtc::scoped_refptr<const RTCStatsReport> result;
875 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&result));
876 EXPECT_TRUE_WAIT(result, kGetStatsReportTimeoutMs);
877 }
878
TEST_F(RTCStatsCollectorTest,MultipleCallbacks)879 TEST_F(RTCStatsCollectorTest, MultipleCallbacks) {
880 rtc::scoped_refptr<const RTCStatsReport> a, b, c;
881 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
882 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
883 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
884 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
885 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
886 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
887
888 EXPECT_EQ(a.get(), b.get());
889 EXPECT_EQ(b.get(), c.get());
890 }
891
TEST_F(RTCStatsCollectorTest,CachedStatsReports)892 TEST_F(RTCStatsCollectorTest, CachedStatsReports) {
893 // Caching should ensure |a| and |b| are the same report.
894 rtc::scoped_refptr<const RTCStatsReport> a = stats_->GetStatsReport();
895 rtc::scoped_refptr<const RTCStatsReport> b = stats_->GetStatsReport();
896 EXPECT_EQ(a.get(), b.get());
897 // Invalidate cache by clearing it.
898 stats_->stats_collector()->ClearCachedStatsReport();
899 rtc::scoped_refptr<const RTCStatsReport> c = stats_->GetStatsReport();
900 EXPECT_NE(b.get(), c.get());
901 // Invalidate cache by advancing time.
902 fake_clock_.AdvanceTime(TimeDelta::Millis(51));
903 rtc::scoped_refptr<const RTCStatsReport> d = stats_->GetStatsReport();
904 EXPECT_TRUE(d);
905 EXPECT_NE(c.get(), d.get());
906 }
907
TEST_F(RTCStatsCollectorTest,MultipleCallbacksWithInvalidatedCacheInBetween)908 TEST_F(RTCStatsCollectorTest, MultipleCallbacksWithInvalidatedCacheInBetween) {
909 rtc::scoped_refptr<const RTCStatsReport> a, b, c;
910 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&a));
911 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&b));
912 // Cache is invalidated after 50 ms.
913 fake_clock_.AdvanceTime(TimeDelta::Millis(51));
914 stats_->stats_collector()->GetStatsReport(RTCStatsObtainer::Create(&c));
915 EXPECT_TRUE_WAIT(a, kGetStatsReportTimeoutMs);
916 EXPECT_TRUE_WAIT(b, kGetStatsReportTimeoutMs);
917 EXPECT_TRUE_WAIT(c, kGetStatsReportTimeoutMs);
918 EXPECT_EQ(a.get(), b.get());
919 // The act of doing |AdvanceTime| processes all messages. If this was not the
920 // case we might not require |c| to be fresher than |b|.
921 EXPECT_NE(c.get(), b.get());
922 }
923
TEST_F(RTCStatsCollectorTest,ToJsonProducesParseableJson)924 TEST_F(RTCStatsCollectorTest, ToJsonProducesParseableJson) {
925 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
926 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
927 std::string json_format = report->ToJson();
928 Json::Reader reader;
929 Json::Value json_value;
930 ASSERT_TRUE(reader.parse(json_format, json_value));
931 // A very brief sanity check on the result.
932 EXPECT_EQ(report->size(), json_value.size());
933 }
934
TEST_F(RTCStatsCollectorTest,CollectRTCCertificateStatsSingle)935 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsSingle) {
936 const char kTransportName[] = "transport";
937
938 pc_->AddVoiceChannel("audio", kTransportName);
939
940 std::unique_ptr<CertificateInfo> local_certinfo =
941 CreateFakeCertificateAndInfoFromDers(
942 std::vector<std::string>({"(local) single certificate"}));
943 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
944
945 std::unique_ptr<CertificateInfo> remote_certinfo =
946 CreateFakeCertificateAndInfoFromDers(
947 std::vector<std::string>({"(remote) single certificate"}));
948 pc_->SetRemoteCertChain(
949 kTransportName,
950 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
951
952 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
953
954 ExpectReportContainsCertificateInfo(report, *local_certinfo);
955 ExpectReportContainsCertificateInfo(report, *remote_certinfo);
956 }
957
TEST_F(RTCStatsCollectorTest,CollectRTCCodecStats)958 TEST_F(RTCStatsCollectorTest, CollectRTCCodecStats) {
959 // Audio
960 cricket::VoiceMediaInfo voice_media_info;
961
962 RtpCodecParameters inbound_audio_codec;
963 inbound_audio_codec.payload_type = 1;
964 inbound_audio_codec.kind = cricket::MEDIA_TYPE_AUDIO;
965 inbound_audio_codec.name = "opus";
966 inbound_audio_codec.clock_rate = 1337;
967 inbound_audio_codec.num_channels = 1;
968 inbound_audio_codec.parameters = {{"minptime", "10"}, {"useinbandfec", "1"}};
969 voice_media_info.receive_codecs.insert(
970 std::make_pair(inbound_audio_codec.payload_type, inbound_audio_codec));
971
972 RtpCodecParameters outbound_audio_codec;
973 outbound_audio_codec.payload_type = 2;
974 outbound_audio_codec.kind = cricket::MEDIA_TYPE_AUDIO;
975 outbound_audio_codec.name = "isac";
976 outbound_audio_codec.clock_rate = 1338;
977 outbound_audio_codec.num_channels = 2;
978 voice_media_info.send_codecs.insert(
979 std::make_pair(outbound_audio_codec.payload_type, outbound_audio_codec));
980
981 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
982 voice_media_channel->SetStats(voice_media_info);
983
984 // Video
985 cricket::VideoMediaInfo video_media_info;
986
987 RtpCodecParameters inbound_video_codec;
988 inbound_video_codec.payload_type = 3;
989 inbound_video_codec.kind = cricket::MEDIA_TYPE_VIDEO;
990 inbound_video_codec.name = "H264";
991 inbound_video_codec.clock_rate = 1339;
992 inbound_video_codec.parameters = {{"level-asymmetry-allowed", "1"},
993 {"packetization-mode", "1"},
994 {"profile-level-id", "42001f"}};
995 video_media_info.receive_codecs.insert(
996 std::make_pair(inbound_video_codec.payload_type, inbound_video_codec));
997
998 RtpCodecParameters outbound_video_codec;
999 outbound_video_codec.payload_type = 4;
1000 outbound_video_codec.kind = cricket::MEDIA_TYPE_VIDEO;
1001 outbound_video_codec.name = "VP8";
1002 outbound_video_codec.clock_rate = 1340;
1003 video_media_info.send_codecs.insert(
1004 std::make_pair(outbound_video_codec.payload_type, outbound_video_codec));
1005
1006 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
1007 video_media_channel->SetStats(video_media_info);
1008
1009 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1010
1011 RTCCodecStats expected_inbound_audio_codec("RTCCodec_AudioMid_Inbound_1",
1012 report->timestamp_us());
1013 expected_inbound_audio_codec.payload_type = 1;
1014 expected_inbound_audio_codec.mime_type = "audio/opus";
1015 expected_inbound_audio_codec.clock_rate = 1337;
1016 expected_inbound_audio_codec.channels = 1;
1017 expected_inbound_audio_codec.sdp_fmtp_line = "minptime=10;useinbandfec=1";
1018 expected_inbound_audio_codec.transport_id = "RTCTransport_TransportName_1";
1019
1020 RTCCodecStats expected_outbound_audio_codec("RTCCodec_AudioMid_Outbound_2",
1021 report->timestamp_us());
1022 expected_outbound_audio_codec.payload_type = 2;
1023 expected_outbound_audio_codec.mime_type = "audio/isac";
1024 expected_outbound_audio_codec.clock_rate = 1338;
1025 expected_outbound_audio_codec.channels = 2;
1026 expected_outbound_audio_codec.transport_id = "RTCTransport_TransportName_1";
1027
1028 RTCCodecStats expected_inbound_video_codec("RTCCodec_VideoMid_Inbound_3",
1029 report->timestamp_us());
1030 expected_inbound_video_codec.payload_type = 3;
1031 expected_inbound_video_codec.mime_type = "video/H264";
1032 expected_inbound_video_codec.clock_rate = 1339;
1033 expected_inbound_video_codec.sdp_fmtp_line =
1034 "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42001f";
1035 expected_inbound_video_codec.transport_id = "RTCTransport_TransportName_1";
1036
1037 RTCCodecStats expected_outbound_video_codec("RTCCodec_VideoMid_Outbound_4",
1038 report->timestamp_us());
1039 expected_outbound_video_codec.payload_type = 4;
1040 expected_outbound_video_codec.mime_type = "video/VP8";
1041 expected_outbound_video_codec.clock_rate = 1340;
1042 expected_outbound_video_codec.transport_id = "RTCTransport_TransportName_1";
1043
1044 ASSERT_TRUE(report->Get(expected_inbound_audio_codec.id()));
1045 EXPECT_EQ(
1046 expected_inbound_audio_codec,
1047 report->Get(expected_inbound_audio_codec.id())->cast_to<RTCCodecStats>());
1048
1049 ASSERT_TRUE(report->Get(expected_outbound_audio_codec.id()));
1050 EXPECT_EQ(expected_outbound_audio_codec,
1051 report->Get(expected_outbound_audio_codec.id())
1052 ->cast_to<RTCCodecStats>());
1053
1054 ASSERT_TRUE(report->Get(expected_inbound_video_codec.id()));
1055 EXPECT_EQ(
1056 expected_inbound_video_codec,
1057 report->Get(expected_inbound_video_codec.id())->cast_to<RTCCodecStats>());
1058
1059 ASSERT_TRUE(report->Get(expected_outbound_video_codec.id()));
1060 EXPECT_EQ(expected_outbound_video_codec,
1061 report->Get(expected_outbound_video_codec.id())
1062 ->cast_to<RTCCodecStats>());
1063 }
1064
TEST_F(RTCStatsCollectorTest,CollectRTCCertificateStatsMultiple)1065 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsMultiple) {
1066 const char kAudioTransport[] = "audio";
1067 const char kVideoTransport[] = "video";
1068
1069 pc_->AddVoiceChannel("audio", kAudioTransport);
1070 std::unique_ptr<CertificateInfo> audio_local_certinfo =
1071 CreateFakeCertificateAndInfoFromDers(
1072 std::vector<std::string>({"(local) audio"}));
1073 pc_->SetLocalCertificate(kAudioTransport, audio_local_certinfo->certificate);
1074 std::unique_ptr<CertificateInfo> audio_remote_certinfo =
1075 CreateFakeCertificateAndInfoFromDers(
1076 std::vector<std::string>({"(remote) audio"}));
1077 pc_->SetRemoteCertChain(
1078 kAudioTransport,
1079 audio_remote_certinfo->certificate->GetSSLCertificateChain().Clone());
1080
1081 pc_->AddVideoChannel("video", kVideoTransport);
1082 std::unique_ptr<CertificateInfo> video_local_certinfo =
1083 CreateFakeCertificateAndInfoFromDers(
1084 std::vector<std::string>({"(local) video"}));
1085 pc_->SetLocalCertificate(kVideoTransport, video_local_certinfo->certificate);
1086 std::unique_ptr<CertificateInfo> video_remote_certinfo =
1087 CreateFakeCertificateAndInfoFromDers(
1088 std::vector<std::string>({"(remote) video"}));
1089 pc_->SetRemoteCertChain(
1090 kVideoTransport,
1091 video_remote_certinfo->certificate->GetSSLCertificateChain().Clone());
1092
1093 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1094 ExpectReportContainsCertificateInfo(report, *audio_local_certinfo);
1095 ExpectReportContainsCertificateInfo(report, *audio_remote_certinfo);
1096 ExpectReportContainsCertificateInfo(report, *video_local_certinfo);
1097 ExpectReportContainsCertificateInfo(report, *video_remote_certinfo);
1098 }
1099
TEST_F(RTCStatsCollectorTest,CollectRTCCertificateStatsChain)1100 TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) {
1101 const char kTransportName[] = "transport";
1102
1103 pc_->AddVoiceChannel("audio", kTransportName);
1104
1105 std::unique_ptr<CertificateInfo> local_certinfo =
1106 CreateFakeCertificateAndInfoFromDers(
1107 {"(local) this", "(local) is", "(local) a", "(local) chain"});
1108 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
1109
1110 std::unique_ptr<CertificateInfo> remote_certinfo =
1111 CreateFakeCertificateAndInfoFromDers({"(remote) this", "(remote) is",
1112 "(remote) another",
1113 "(remote) chain"});
1114 pc_->SetRemoteCertChain(
1115 kTransportName,
1116 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
1117
1118 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1119 ExpectReportContainsCertificateInfo(report, *local_certinfo);
1120 ExpectReportContainsCertificateInfo(report, *remote_certinfo);
1121 }
1122
TEST_F(RTCStatsCollectorTest,CollectTwoRTCDataChannelStatsWithPendingId)1123 TEST_F(RTCStatsCollectorTest, CollectTwoRTCDataChannelStatsWithPendingId) {
1124 pc_->AddSctpDataChannel(
1125 new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting));
1126 pc_->AddSctpDataChannel(
1127 new MockSctpDataChannel(/*id=*/-1, DataChannelInterface::kConnecting));
1128
1129 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1130 }
1131
TEST_F(RTCStatsCollectorTest,CollectRTCDataChannelStats)1132 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
1133 // Note: The test assumes data channel IDs are predictable.
1134 // This is not a safe assumption, but in order to make it work for
1135 // the test, we reset the ID allocator at test start.
1136 SctpDataChannel::ResetInternalIdAllocatorForTesting(-1);
1137 pc_->AddSctpDataChannel(new MockSctpDataChannel(
1138 0, "MockSctpDataChannel0", DataChannelInterface::kConnecting, "udp", 1, 2,
1139 3, 4));
1140 RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
1141 expected_data_channel0.label = "MockSctpDataChannel0";
1142 expected_data_channel0.protocol = "udp";
1143 expected_data_channel0.data_channel_identifier = 0;
1144 expected_data_channel0.state = "connecting";
1145 expected_data_channel0.messages_sent = 1;
1146 expected_data_channel0.bytes_sent = 2;
1147 expected_data_channel0.messages_received = 3;
1148 expected_data_channel0.bytes_received = 4;
1149
1150 pc_->AddSctpDataChannel(new MockSctpDataChannel(1, "MockSctpDataChannel1",
1151 DataChannelInterface::kOpen,
1152 "tcp", 5, 6, 7, 8));
1153 RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
1154 expected_data_channel1.label = "MockSctpDataChannel1";
1155 expected_data_channel1.protocol = "tcp";
1156 expected_data_channel1.data_channel_identifier = 1;
1157 expected_data_channel1.state = "open";
1158 expected_data_channel1.messages_sent = 5;
1159 expected_data_channel1.bytes_sent = 6;
1160 expected_data_channel1.messages_received = 7;
1161 expected_data_channel1.bytes_received = 8;
1162
1163 pc_->AddSctpDataChannel(new MockSctpDataChannel(
1164 2, "MockSctpDataChannel2", DataChannelInterface::kClosing, "udp", 9, 10,
1165 11, 12));
1166 RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
1167 expected_data_channel2.label = "MockSctpDataChannel2";
1168 expected_data_channel2.protocol = "udp";
1169 expected_data_channel2.data_channel_identifier = 2;
1170 expected_data_channel2.state = "closing";
1171 expected_data_channel2.messages_sent = 9;
1172 expected_data_channel2.bytes_sent = 10;
1173 expected_data_channel2.messages_received = 11;
1174 expected_data_channel2.bytes_received = 12;
1175
1176 pc_->AddSctpDataChannel(new MockSctpDataChannel(3, "MockSctpDataChannel3",
1177 DataChannelInterface::kClosed,
1178 "tcp", 13, 14, 15, 16));
1179 RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
1180 expected_data_channel3.label = "MockSctpDataChannel3";
1181 expected_data_channel3.protocol = "tcp";
1182 expected_data_channel3.data_channel_identifier = 3;
1183 expected_data_channel3.state = "closed";
1184 expected_data_channel3.messages_sent = 13;
1185 expected_data_channel3.bytes_sent = 14;
1186 expected_data_channel3.messages_received = 15;
1187 expected_data_channel3.bytes_received = 16;
1188
1189 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1190
1191 ASSERT_TRUE(report->Get(expected_data_channel0.id()));
1192 EXPECT_EQ(
1193 expected_data_channel0,
1194 report->Get(expected_data_channel0.id())->cast_to<RTCDataChannelStats>());
1195 ASSERT_TRUE(report->Get(expected_data_channel1.id()));
1196 EXPECT_EQ(
1197 expected_data_channel1,
1198 report->Get(expected_data_channel1.id())->cast_to<RTCDataChannelStats>());
1199 ASSERT_TRUE(report->Get(expected_data_channel2.id()));
1200 EXPECT_EQ(
1201 expected_data_channel2,
1202 report->Get(expected_data_channel2.id())->cast_to<RTCDataChannelStats>());
1203 ASSERT_TRUE(report->Get(expected_data_channel3.id()));
1204 EXPECT_EQ(
1205 expected_data_channel3,
1206 report->Get(expected_data_channel3.id())->cast_to<RTCDataChannelStats>());
1207 }
1208
TEST_F(RTCStatsCollectorTest,CollectRTCIceCandidateStats)1209 TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidateStats) {
1210 // Candidates in the first transport stats.
1211 std::unique_ptr<cricket::Candidate> a_local_host =
1212 CreateFakeCandidate("1.2.3.4", 5, "a_local_host's protocol",
1213 rtc::ADAPTER_TYPE_VPN, cricket::LOCAL_PORT_TYPE, 0);
1214 RTCLocalIceCandidateStats expected_a_local_host(
1215 "RTCIceCandidate_" + a_local_host->id(), 0);
1216 expected_a_local_host.transport_id = "RTCTransport_a_0";
1217 expected_a_local_host.network_type = "vpn";
1218 expected_a_local_host.ip = "1.2.3.4";
1219 expected_a_local_host.address = "1.2.3.4";
1220 expected_a_local_host.port = 5;
1221 expected_a_local_host.protocol = "a_local_host's protocol";
1222 expected_a_local_host.candidate_type = "host";
1223 expected_a_local_host.priority = 0;
1224 EXPECT_FALSE(*expected_a_local_host.is_remote);
1225
1226 std::unique_ptr<cricket::Candidate> a_remote_srflx = CreateFakeCandidate(
1227 "6.7.8.9", 10, "remote_srflx's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1228 cricket::STUN_PORT_TYPE, 1);
1229 RTCRemoteIceCandidateStats expected_a_remote_srflx(
1230 "RTCIceCandidate_" + a_remote_srflx->id(), 0);
1231 expected_a_remote_srflx.transport_id = "RTCTransport_a_0";
1232 expected_a_remote_srflx.ip = "6.7.8.9";
1233 expected_a_remote_srflx.address = "6.7.8.9";
1234 expected_a_remote_srflx.port = 10;
1235 expected_a_remote_srflx.protocol = "remote_srflx's protocol";
1236 expected_a_remote_srflx.candidate_type = "srflx";
1237 expected_a_remote_srflx.priority = 1;
1238 EXPECT_TRUE(*expected_a_remote_srflx.is_remote);
1239
1240 std::unique_ptr<cricket::Candidate> a_local_prflx = CreateFakeCandidate(
1241 "11.12.13.14", 15, "a_local_prflx's protocol", rtc::ADAPTER_TYPE_CELLULAR,
1242 cricket::PRFLX_PORT_TYPE, 2);
1243 RTCLocalIceCandidateStats expected_a_local_prflx(
1244 "RTCIceCandidate_" + a_local_prflx->id(), 0);
1245 expected_a_local_prflx.transport_id = "RTCTransport_a_0";
1246 expected_a_local_prflx.network_type = "cellular";
1247 expected_a_local_prflx.ip = "11.12.13.14";
1248 expected_a_local_prflx.address = "11.12.13.14";
1249 expected_a_local_prflx.port = 15;
1250 expected_a_local_prflx.protocol = "a_local_prflx's protocol";
1251 expected_a_local_prflx.candidate_type = "prflx";
1252 expected_a_local_prflx.priority = 2;
1253 EXPECT_FALSE(*expected_a_local_prflx.is_remote);
1254
1255 std::unique_ptr<cricket::Candidate> a_remote_relay = CreateFakeCandidate(
1256 "16.17.18.19", 20, "a_remote_relay's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1257 cricket::RELAY_PORT_TYPE, 3);
1258 RTCRemoteIceCandidateStats expected_a_remote_relay(
1259 "RTCIceCandidate_" + a_remote_relay->id(), 0);
1260 expected_a_remote_relay.transport_id = "RTCTransport_a_0";
1261 expected_a_remote_relay.ip = "16.17.18.19";
1262 expected_a_remote_relay.address = "16.17.18.19";
1263 expected_a_remote_relay.port = 20;
1264 expected_a_remote_relay.protocol = "a_remote_relay's protocol";
1265 expected_a_remote_relay.candidate_type = "relay";
1266 expected_a_remote_relay.priority = 3;
1267 EXPECT_TRUE(*expected_a_remote_relay.is_remote);
1268
1269 std::unique_ptr<cricket::Candidate> a_local_relay = CreateFakeCandidate(
1270 "16.17.18.19", 21, "a_local_relay's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1271 cricket::RELAY_PORT_TYPE, 1);
1272 a_local_relay->set_relay_protocol("tcp");
1273
1274 RTCRemoteIceCandidateStats expected_a_local_relay(
1275 "RTCIceCandidate_" + a_local_relay->id(), 0);
1276 expected_a_local_relay.transport_id = "RTCTransport_a_0";
1277 expected_a_local_relay.ip = "16.17.18.19";
1278 expected_a_local_relay.address = "16.17.18.19";
1279 expected_a_local_relay.port = 21;
1280 expected_a_local_relay.protocol = "a_local_relay's protocol";
1281 expected_a_local_relay.relay_protocol = "tcp";
1282 expected_a_local_relay.candidate_type = "relay";
1283 expected_a_local_relay.priority = 1;
1284 EXPECT_TRUE(*expected_a_local_relay.is_remote);
1285
1286 // Candidates in the second transport stats.
1287 std::unique_ptr<cricket::Candidate> b_local =
1288 CreateFakeCandidate("42.42.42.42", 42, "b_local's protocol",
1289 rtc::ADAPTER_TYPE_WIFI, cricket::LOCAL_PORT_TYPE, 42);
1290 RTCLocalIceCandidateStats expected_b_local("RTCIceCandidate_" + b_local->id(),
1291 0);
1292 expected_b_local.transport_id = "RTCTransport_b_0";
1293 expected_b_local.network_type = "wifi";
1294 expected_b_local.ip = "42.42.42.42";
1295 expected_b_local.address = "42.42.42.42";
1296 expected_b_local.port = 42;
1297 expected_b_local.protocol = "b_local's protocol";
1298 expected_b_local.candidate_type = "host";
1299 expected_b_local.priority = 42;
1300 EXPECT_FALSE(*expected_b_local.is_remote);
1301
1302 std::unique_ptr<cricket::Candidate> b_remote = CreateFakeCandidate(
1303 "42.42.42.42", 42, "b_remote's protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1304 cricket::LOCAL_PORT_TYPE, 42);
1305 RTCRemoteIceCandidateStats expected_b_remote(
1306 "RTCIceCandidate_" + b_remote->id(), 0);
1307 expected_b_remote.transport_id = "RTCTransport_b_0";
1308 expected_b_remote.ip = "42.42.42.42";
1309 expected_b_remote.address = "42.42.42.42";
1310 expected_b_remote.port = 42;
1311 expected_b_remote.protocol = "b_remote's protocol";
1312 expected_b_remote.candidate_type = "host";
1313 expected_b_remote.priority = 42;
1314 EXPECT_TRUE(*expected_b_remote.is_remote);
1315
1316 // Add candidate pairs to connection.
1317 cricket::TransportChannelStats a_transport_channel_stats;
1318 a_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
1319 cricket::ConnectionInfo());
1320 a_transport_channel_stats.ice_transport_stats.connection_infos[0]
1321 .local_candidate = *a_local_host.get();
1322 a_transport_channel_stats.ice_transport_stats.connection_infos[0]
1323 .remote_candidate = *a_remote_srflx.get();
1324 a_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
1325 cricket::ConnectionInfo());
1326 a_transport_channel_stats.ice_transport_stats.connection_infos[1]
1327 .local_candidate = *a_local_prflx.get();
1328 a_transport_channel_stats.ice_transport_stats.connection_infos[1]
1329 .remote_candidate = *a_remote_relay.get();
1330 a_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
1331 cricket::ConnectionInfo());
1332 a_transport_channel_stats.ice_transport_stats.connection_infos[2]
1333 .local_candidate = *a_local_relay.get();
1334 a_transport_channel_stats.ice_transport_stats.connection_infos[2]
1335 .remote_candidate = *a_remote_relay.get();
1336
1337 pc_->AddVoiceChannel("audio", "a");
1338 pc_->SetTransportStats("a", a_transport_channel_stats);
1339
1340 cricket::TransportChannelStats b_transport_channel_stats;
1341 b_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
1342 cricket::ConnectionInfo());
1343 b_transport_channel_stats.ice_transport_stats.connection_infos[0]
1344 .local_candidate = *b_local.get();
1345 b_transport_channel_stats.ice_transport_stats.connection_infos[0]
1346 .remote_candidate = *b_remote.get();
1347
1348 pc_->AddVideoChannel("video", "b");
1349 pc_->SetTransportStats("b", b_transport_channel_stats);
1350
1351 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1352
1353 ASSERT_TRUE(report->Get(expected_a_local_host.id()));
1354 EXPECT_EQ(expected_a_local_host, report->Get(expected_a_local_host.id())
1355 ->cast_to<RTCLocalIceCandidateStats>());
1356 ASSERT_TRUE(report->Get(expected_a_remote_srflx.id()));
1357 EXPECT_EQ(expected_a_remote_srflx,
1358 report->Get(expected_a_remote_srflx.id())
1359 ->cast_to<RTCRemoteIceCandidateStats>());
1360 ASSERT_TRUE(report->Get(expected_a_local_prflx.id()));
1361 EXPECT_EQ(expected_a_local_prflx, report->Get(expected_a_local_prflx.id())
1362 ->cast_to<RTCLocalIceCandidateStats>());
1363 ASSERT_TRUE(report->Get(expected_a_remote_relay.id()));
1364 EXPECT_EQ(expected_a_remote_relay,
1365 report->Get(expected_a_remote_relay.id())
1366 ->cast_to<RTCRemoteIceCandidateStats>());
1367 ASSERT_TRUE(report->Get(expected_b_local.id()));
1368 EXPECT_EQ(
1369 expected_b_local,
1370 report->Get(expected_b_local.id())->cast_to<RTCLocalIceCandidateStats>());
1371 ASSERT_TRUE(report->Get(expected_b_remote.id()));
1372 EXPECT_EQ(expected_b_remote, report->Get(expected_b_remote.id())
1373 ->cast_to<RTCRemoteIceCandidateStats>());
1374 EXPECT_TRUE(report->Get("RTCTransport_a_0"));
1375 EXPECT_TRUE(report->Get("RTCTransport_b_0"));
1376 }
1377
TEST_F(RTCStatsCollectorTest,CollectRTCIceCandidatePairStats)1378 TEST_F(RTCStatsCollectorTest, CollectRTCIceCandidatePairStats) {
1379 const char kTransportName[] = "transport";
1380
1381 std::unique_ptr<cricket::Candidate> local_candidate =
1382 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
1383 cricket::LOCAL_PORT_TYPE, 42);
1384 std::unique_ptr<cricket::Candidate> remote_candidate = CreateFakeCandidate(
1385 "42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_UNKNOWN,
1386 cricket::LOCAL_PORT_TYPE, 42);
1387
1388 cricket::ConnectionInfo connection_info;
1389 connection_info.best_connection = false;
1390 connection_info.local_candidate = *local_candidate.get();
1391 connection_info.remote_candidate = *remote_candidate.get();
1392 connection_info.writable = true;
1393 connection_info.sent_total_bytes = 42;
1394 connection_info.recv_total_bytes = 1234;
1395 connection_info.total_round_trip_time_ms = 0;
1396 connection_info.current_round_trip_time_ms = absl::nullopt;
1397 connection_info.recv_ping_requests = 2020;
1398 connection_info.sent_ping_requests_total = 2020;
1399 connection_info.sent_ping_requests_before_first_response = 2000;
1400 connection_info.recv_ping_responses = 4321;
1401 connection_info.sent_ping_responses = 1000;
1402 connection_info.state = cricket::IceCandidatePairState::IN_PROGRESS;
1403 connection_info.priority = 5555;
1404 connection_info.nominated = false;
1405
1406 cricket::TransportChannelStats transport_channel_stats;
1407 transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
1408 transport_channel_stats.ice_transport_stats.connection_infos.push_back(
1409 connection_info);
1410
1411 pc_->AddVideoChannel("video", kTransportName);
1412 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1413
1414 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1415
1416 RTCIceCandidatePairStats expected_pair("RTCIceCandidatePair_" +
1417 local_candidate->id() + "_" +
1418 remote_candidate->id(),
1419 report->timestamp_us());
1420 expected_pair.transport_id =
1421 "RTCTransport_transport_" +
1422 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP);
1423 expected_pair.local_candidate_id = "RTCIceCandidate_" + local_candidate->id();
1424 expected_pair.remote_candidate_id =
1425 "RTCIceCandidate_" + remote_candidate->id();
1426 expected_pair.state = RTCStatsIceCandidatePairState::kInProgress;
1427 expected_pair.priority = 5555;
1428 expected_pair.nominated = false;
1429 expected_pair.writable = true;
1430 expected_pair.bytes_sent = 42;
1431 expected_pair.bytes_received = 1234;
1432 expected_pair.total_round_trip_time = 0.0;
1433 expected_pair.requests_received = 2020;
1434 expected_pair.requests_sent = 2000;
1435 expected_pair.responses_received = 4321;
1436 expected_pair.responses_sent = 1000;
1437 expected_pair.consent_requests_sent = (2020 - 2000);
1438 // |expected_pair.current_round_trip_time| should be undefined because the
1439 // current RTT is not set.
1440 // |expected_pair.available_[outgoing/incoming]_bitrate| should be undefined
1441 // because is is not the current pair.
1442
1443 ASSERT_TRUE(report->Get(expected_pair.id()));
1444 EXPECT_EQ(
1445 expected_pair,
1446 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1447 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1448
1449 // Set nominated and "GetStats" again.
1450 transport_channel_stats.ice_transport_stats.connection_infos[0].nominated =
1451 true;
1452 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1453 report = stats_->GetFreshStatsReport();
1454 expected_pair.nominated = true;
1455 ASSERT_TRUE(report->Get(expected_pair.id()));
1456 EXPECT_EQ(
1457 expected_pair,
1458 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1459 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1460
1461 // Set round trip times and "GetStats" again.
1462 transport_channel_stats.ice_transport_stats.connection_infos[0]
1463 .total_round_trip_time_ms = 7331;
1464 transport_channel_stats.ice_transport_stats.connection_infos[0]
1465 .current_round_trip_time_ms = 1337;
1466 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1467 report = stats_->GetFreshStatsReport();
1468 expected_pair.total_round_trip_time = 7.331;
1469 expected_pair.current_round_trip_time = 1.337;
1470 ASSERT_TRUE(report->Get(expected_pair.id()));
1471 EXPECT_EQ(
1472 expected_pair,
1473 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1474 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1475
1476 // Make pair the current pair, clear bandwidth and "GetStats" again.
1477 transport_channel_stats.ice_transport_stats.connection_infos[0]
1478 .best_connection = true;
1479 pc_->SetTransportStats(kTransportName, transport_channel_stats);
1480 report = stats_->GetFreshStatsReport();
1481 // |expected_pair.available_[outgoing/incoming]_bitrate| should still be
1482 // undefined because bandwidth is not set.
1483 ASSERT_TRUE(report->Get(expected_pair.id()));
1484 EXPECT_EQ(
1485 expected_pair,
1486 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1487 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1488
1489 // Set bandwidth and "GetStats" again.
1490 webrtc::Call::Stats call_stats;
1491 const int kSendBandwidth = 888;
1492 call_stats.send_bandwidth_bps = kSendBandwidth;
1493 const int kRecvBandwidth = 999;
1494 call_stats.recv_bandwidth_bps = kRecvBandwidth;
1495 pc_->SetCallStats(call_stats);
1496 report = stats_->GetFreshStatsReport();
1497 expected_pair.available_outgoing_bitrate = kSendBandwidth;
1498 expected_pair.available_incoming_bitrate = kRecvBandwidth;
1499 ASSERT_TRUE(report->Get(expected_pair.id()));
1500 EXPECT_EQ(
1501 expected_pair,
1502 report->Get(expected_pair.id())->cast_to<RTCIceCandidatePairStats>());
1503 EXPECT_TRUE(report->Get(*expected_pair.transport_id));
1504
1505 RTCLocalIceCandidateStats expected_local_candidate(
1506 *expected_pair.local_candidate_id, report->timestamp_us());
1507 expected_local_candidate.transport_id = *expected_pair.transport_id;
1508 expected_local_candidate.network_type = "wifi";
1509 expected_local_candidate.ip = "42.42.42.42";
1510 expected_local_candidate.address = "42.42.42.42";
1511 expected_local_candidate.port = 42;
1512 expected_local_candidate.protocol = "protocol";
1513 expected_local_candidate.candidate_type = "host";
1514 expected_local_candidate.priority = 42;
1515 EXPECT_FALSE(*expected_local_candidate.is_remote);
1516 ASSERT_TRUE(report->Get(expected_local_candidate.id()));
1517 EXPECT_EQ(expected_local_candidate,
1518 report->Get(expected_local_candidate.id())
1519 ->cast_to<RTCLocalIceCandidateStats>());
1520
1521 RTCRemoteIceCandidateStats expected_remote_candidate(
1522 *expected_pair.remote_candidate_id, report->timestamp_us());
1523 expected_remote_candidate.transport_id = *expected_pair.transport_id;
1524 expected_remote_candidate.ip = "42.42.42.42";
1525 expected_remote_candidate.address = "42.42.42.42";
1526 expected_remote_candidate.port = 42;
1527 expected_remote_candidate.protocol = "protocol";
1528 expected_remote_candidate.candidate_type = "host";
1529 expected_remote_candidate.priority = 42;
1530 EXPECT_TRUE(*expected_remote_candidate.is_remote);
1531 ASSERT_TRUE(report->Get(expected_remote_candidate.id()));
1532 EXPECT_EQ(expected_remote_candidate,
1533 report->Get(expected_remote_candidate.id())
1534 ->cast_to<RTCRemoteIceCandidateStats>());
1535 }
1536
TEST_F(RTCStatsCollectorTest,CollectRTCPeerConnectionStats)1537 TEST_F(RTCStatsCollectorTest, CollectRTCPeerConnectionStats) {
1538 {
1539 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1540 RTCPeerConnectionStats expected("RTCPeerConnection",
1541 report->timestamp_us());
1542 expected.data_channels_opened = 0;
1543 expected.data_channels_closed = 0;
1544 ASSERT_TRUE(report->Get("RTCPeerConnection"));
1545 EXPECT_EQ(
1546 expected,
1547 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
1548 }
1549
1550 // TODO(bugs.webrtc.org/11547): Supply a separate network thread.
1551 FakeDataChannelProvider provider;
1552 rtc::scoped_refptr<SctpDataChannel> dummy_channel_a = SctpDataChannel::Create(
1553 &provider, "DummyChannelA", InternalDataChannelInit(),
1554 rtc::Thread::Current(), rtc::Thread::Current());
1555 pc_->SignalSctpDataChannelCreated()(dummy_channel_a.get());
1556 rtc::scoped_refptr<SctpDataChannel> dummy_channel_b = SctpDataChannel::Create(
1557 &provider, "DummyChannelB", InternalDataChannelInit(),
1558 rtc::Thread::Current(), rtc::Thread::Current());
1559 pc_->SignalSctpDataChannelCreated()(dummy_channel_b.get());
1560
1561 dummy_channel_a->SignalOpened(dummy_channel_a.get());
1562 // Closing a channel that is not opened should not affect the counts.
1563 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1564
1565 {
1566 rtc::scoped_refptr<const RTCStatsReport> report =
1567 stats_->GetFreshStatsReport();
1568 RTCPeerConnectionStats expected("RTCPeerConnection",
1569 report->timestamp_us());
1570 expected.data_channels_opened = 1;
1571 expected.data_channels_closed = 0;
1572 ASSERT_TRUE(report->Get("RTCPeerConnection"));
1573 EXPECT_EQ(
1574 expected,
1575 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
1576 }
1577
1578 dummy_channel_b->SignalOpened(dummy_channel_b.get());
1579 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1580
1581 {
1582 rtc::scoped_refptr<const RTCStatsReport> report =
1583 stats_->GetFreshStatsReport();
1584 RTCPeerConnectionStats expected("RTCPeerConnection",
1585 report->timestamp_us());
1586 expected.data_channels_opened = 2;
1587 expected.data_channels_closed = 1;
1588 ASSERT_TRUE(report->Get("RTCPeerConnection"));
1589 EXPECT_EQ(
1590 expected,
1591 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
1592 }
1593
1594 // Re-opening a data channel (or opening a new data channel that is re-using
1595 // the same address in memory) should increase the opened count.
1596 dummy_channel_b->SignalOpened(dummy_channel_b.get());
1597
1598 {
1599 rtc::scoped_refptr<const RTCStatsReport> report =
1600 stats_->GetFreshStatsReport();
1601 RTCPeerConnectionStats expected("RTCPeerConnection",
1602 report->timestamp_us());
1603 expected.data_channels_opened = 3;
1604 expected.data_channels_closed = 1;
1605 ASSERT_TRUE(report->Get("RTCPeerConnection"));
1606 EXPECT_EQ(
1607 expected,
1608 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
1609 }
1610
1611 dummy_channel_a->SignalClosed(dummy_channel_a.get());
1612 dummy_channel_b->SignalClosed(dummy_channel_b.get());
1613
1614 {
1615 rtc::scoped_refptr<const RTCStatsReport> report =
1616 stats_->GetFreshStatsReport();
1617 RTCPeerConnectionStats expected("RTCPeerConnection",
1618 report->timestamp_us());
1619 expected.data_channels_opened = 3;
1620 expected.data_channels_closed = 3;
1621 ASSERT_TRUE(report->Get("RTCPeerConnection"));
1622 EXPECT_EQ(
1623 expected,
1624 report->Get("RTCPeerConnection")->cast_to<RTCPeerConnectionStats>());
1625 }
1626 }
1627
TEST_F(RTCStatsCollectorTest,CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio)1628 TEST_F(RTCStatsCollectorTest,
1629 CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio) {
1630 rtc::scoped_refptr<MediaStream> local_stream =
1631 MediaStream::Create("LocalStreamId");
1632 pc_->mutable_local_streams()->AddStream(local_stream);
1633
1634 // Local audio track
1635 rtc::scoped_refptr<MediaStreamTrackInterface> local_audio_track =
1636 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "LocalAudioTrackID",
1637 MediaStreamTrackInterface::kEnded);
1638 local_stream->AddTrack(
1639 static_cast<AudioTrackInterface*>(local_audio_track.get()));
1640
1641 cricket::VoiceSenderInfo voice_sender_info_ssrc1;
1642 voice_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
1643 voice_sender_info_ssrc1.local_stats[0].ssrc = 1;
1644 voice_sender_info_ssrc1.apm_statistics.echo_return_loss = 42.0;
1645 voice_sender_info_ssrc1.apm_statistics.echo_return_loss_enhancement = 52.0;
1646
1647 stats_->CreateMockRtpSendersReceiversAndChannels(
1648 {std::make_pair(local_audio_track.get(), voice_sender_info_ssrc1)}, {},
1649 {}, {}, {local_stream->id()}, {});
1650
1651 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1652
1653 RTCMediaStreamStats expected_local_stream(
1654 IdForType<RTCMediaStreamStats>(report), report->timestamp_us());
1655 expected_local_stream.stream_identifier = local_stream->id();
1656 expected_local_stream.track_ids = {
1657 IdForType<RTCMediaStreamTrackStats>(report)};
1658 ASSERT_TRUE(report->Get(expected_local_stream.id()))
1659 << "Did not find " << expected_local_stream.id() << " in "
1660 << report->ToJson();
1661 EXPECT_EQ(
1662 expected_local_stream,
1663 report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>());
1664
1665 RTCMediaStreamTrackStats expected_local_audio_track_ssrc1(
1666 IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(),
1667 RTCMediaStreamTrackKind::kAudio);
1668 expected_local_audio_track_ssrc1.track_identifier = local_audio_track->id();
1669 expected_local_audio_track_ssrc1.media_source_id =
1670 "RTCAudioSource_11"; // Attachment ID = SSRC + 10
1671 expected_local_audio_track_ssrc1.remote_source = false;
1672 expected_local_audio_track_ssrc1.ended = true;
1673 expected_local_audio_track_ssrc1.detached = false;
1674 expected_local_audio_track_ssrc1.echo_return_loss = 42.0;
1675 expected_local_audio_track_ssrc1.echo_return_loss_enhancement = 52.0;
1676 ASSERT_TRUE(report->Get(expected_local_audio_track_ssrc1.id()))
1677 << "Did not find " << expected_local_audio_track_ssrc1.id() << " in "
1678 << report->ToJson();
1679 EXPECT_EQ(expected_local_audio_track_ssrc1,
1680 report->Get(expected_local_audio_track_ssrc1.id())
1681 ->cast_to<RTCMediaStreamTrackStats>());
1682 }
1683
TEST_F(RTCStatsCollectorTest,CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio)1684 TEST_F(RTCStatsCollectorTest,
1685 CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Audio) {
1686 rtc::scoped_refptr<MediaStream> remote_stream =
1687 MediaStream::Create("RemoteStreamId");
1688 pc_->mutable_remote_streams()->AddStream(remote_stream);
1689
1690 // Remote audio track
1691 rtc::scoped_refptr<MediaStreamTrackInterface> remote_audio_track =
1692 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID",
1693 MediaStreamTrackInterface::kLive);
1694 remote_stream->AddTrack(
1695 static_cast<AudioTrackInterface*>(remote_audio_track.get()));
1696
1697 cricket::VoiceReceiverInfo voice_receiver_info;
1698 voice_receiver_info.local_stats.push_back(cricket::SsrcReceiverInfo());
1699 voice_receiver_info.local_stats[0].ssrc = 3;
1700 voice_receiver_info.audio_level = 16383; // [0,32767]
1701 voice_receiver_info.total_output_energy = 0.125;
1702 voice_receiver_info.total_samples_received = 4567;
1703 voice_receiver_info.total_output_duration = 0.25;
1704 voice_receiver_info.concealed_samples = 123;
1705 voice_receiver_info.concealment_events = 12;
1706 voice_receiver_info.inserted_samples_for_deceleration = 987;
1707 voice_receiver_info.removed_samples_for_acceleration = 876;
1708 voice_receiver_info.silent_concealed_samples = 765;
1709 voice_receiver_info.jitter_buffer_delay_seconds = 3456;
1710 voice_receiver_info.jitter_buffer_emitted_count = 13;
1711 voice_receiver_info.jitter_buffer_target_delay_seconds = 7.894;
1712 voice_receiver_info.jitter_buffer_flushes = 7;
1713 voice_receiver_info.delayed_packet_outage_samples = 15;
1714 voice_receiver_info.relative_packet_arrival_delay_seconds = 16;
1715 voice_receiver_info.interruption_count = 7788;
1716 voice_receiver_info.total_interruption_duration_ms = 778899;
1717
1718 stats_->CreateMockRtpSendersReceiversAndChannels(
1719 {}, {std::make_pair(remote_audio_track.get(), voice_receiver_info)}, {},
1720 {}, {}, {remote_stream});
1721
1722 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1723
1724 RTCMediaStreamStats expected_remote_stream(
1725 IdForType<RTCMediaStreamStats>(report), report->timestamp_us());
1726 expected_remote_stream.stream_identifier = remote_stream->id();
1727 expected_remote_stream.track_ids =
1728 std::vector<std::string>({IdForType<RTCMediaStreamTrackStats>(report)});
1729 ASSERT_TRUE(report->Get(expected_remote_stream.id()))
1730 << "Did not find " << expected_remote_stream.id() << " in "
1731 << report->ToJson();
1732 EXPECT_EQ(
1733 expected_remote_stream,
1734 report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>());
1735
1736 RTCMediaStreamTrackStats expected_remote_audio_track(
1737 IdForType<RTCMediaStreamTrackStats>(report), report->timestamp_us(),
1738 RTCMediaStreamTrackKind::kAudio);
1739 expected_remote_audio_track.track_identifier = remote_audio_track->id();
1740 // |expected_remote_audio_track.media_source_id| should be undefined
1741 // because the track is remote.
1742 expected_remote_audio_track.remote_source = true;
1743 expected_remote_audio_track.ended = false;
1744 expected_remote_audio_track.detached = false;
1745 expected_remote_audio_track.audio_level = 16383.0 / 32767.0; // [0,1]
1746 expected_remote_audio_track.total_audio_energy = 0.125;
1747 expected_remote_audio_track.total_samples_received = 4567;
1748 expected_remote_audio_track.total_samples_duration = 0.25;
1749 expected_remote_audio_track.concealed_samples = 123;
1750 expected_remote_audio_track.concealment_events = 12;
1751 expected_remote_audio_track.inserted_samples_for_deceleration = 987;
1752 expected_remote_audio_track.removed_samples_for_acceleration = 876;
1753 expected_remote_audio_track.silent_concealed_samples = 765;
1754 expected_remote_audio_track.jitter_buffer_delay = 3456;
1755 expected_remote_audio_track.jitter_buffer_emitted_count = 13;
1756 expected_remote_audio_track.jitter_buffer_target_delay = 7.894;
1757 expected_remote_audio_track.jitter_buffer_flushes = 7;
1758 expected_remote_audio_track.delayed_packet_outage_samples = 15;
1759 expected_remote_audio_track.relative_packet_arrival_delay = 16;
1760 expected_remote_audio_track.interruption_count = 7788;
1761 expected_remote_audio_track.total_interruption_duration = 778.899;
1762 ASSERT_TRUE(report->Get(expected_remote_audio_track.id()));
1763 EXPECT_EQ(expected_remote_audio_track,
1764 report->Get(expected_remote_audio_track.id())
1765 ->cast_to<RTCMediaStreamTrackStats>());
1766 }
1767
TEST_F(RTCStatsCollectorTest,CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video)1768 TEST_F(RTCStatsCollectorTest,
1769 CollectLocalRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video) {
1770 rtc::scoped_refptr<MediaStream> local_stream =
1771 MediaStream::Create("LocalStreamId");
1772 pc_->mutable_local_streams()->AddStream(local_stream);
1773
1774 // Local video track
1775 rtc::scoped_refptr<MediaStreamTrackInterface> local_video_track =
1776 CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "LocalVideoTrackID",
1777 MediaStreamTrackInterface::kLive);
1778 local_stream->AddTrack(
1779 static_cast<VideoTrackInterface*>(local_video_track.get()));
1780
1781 cricket::VideoSenderInfo video_sender_info_ssrc1;
1782 video_sender_info_ssrc1.local_stats.push_back(cricket::SsrcSenderInfo());
1783 video_sender_info_ssrc1.local_stats[0].ssrc = 1;
1784 video_sender_info_ssrc1.send_frame_width = 1234;
1785 video_sender_info_ssrc1.send_frame_height = 4321;
1786 video_sender_info_ssrc1.frames_encoded = 11;
1787 video_sender_info_ssrc1.huge_frames_sent = 1;
1788
1789 stats_->CreateMockRtpSendersReceiversAndChannels(
1790 {}, {},
1791 {std::make_pair(local_video_track.get(), video_sender_info_ssrc1)}, {},
1792 {local_stream->id()}, {});
1793
1794 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1795
1796 auto stats_of_my_type = report->GetStatsOfType<RTCMediaStreamStats>();
1797 ASSERT_EQ(1U, stats_of_my_type.size()) << "No stream in " << report->ToJson();
1798 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
1799 ASSERT_EQ(1U, stats_of_track_type.size())
1800 << "Wrong number of tracks in " << report->ToJson();
1801
1802 RTCMediaStreamStats expected_local_stream(stats_of_my_type[0]->id(),
1803 report->timestamp_us());
1804 expected_local_stream.stream_identifier = local_stream->id();
1805 expected_local_stream.track_ids =
1806 std::vector<std::string>({stats_of_track_type[0]->id()});
1807 ASSERT_TRUE(report->Get(expected_local_stream.id()));
1808 EXPECT_EQ(
1809 expected_local_stream,
1810 report->Get(expected_local_stream.id())->cast_to<RTCMediaStreamStats>());
1811
1812 RTCMediaStreamTrackStats expected_local_video_track_ssrc1(
1813 stats_of_track_type[0]->id(), report->timestamp_us(),
1814 RTCMediaStreamTrackKind::kVideo);
1815 expected_local_video_track_ssrc1.track_identifier = local_video_track->id();
1816 expected_local_video_track_ssrc1.media_source_id =
1817 "RTCVideoSource_11"; // Attachment ID = SSRC + 10
1818 expected_local_video_track_ssrc1.remote_source = false;
1819 expected_local_video_track_ssrc1.ended = false;
1820 expected_local_video_track_ssrc1.detached = false;
1821 expected_local_video_track_ssrc1.frame_width = 1234;
1822 expected_local_video_track_ssrc1.frame_height = 4321;
1823 expected_local_video_track_ssrc1.frames_sent = 11;
1824 expected_local_video_track_ssrc1.huge_frames_sent = 1;
1825 ASSERT_TRUE(report->Get(expected_local_video_track_ssrc1.id()));
1826 EXPECT_EQ(expected_local_video_track_ssrc1,
1827 report->Get(expected_local_video_track_ssrc1.id())
1828 ->cast_to<RTCMediaStreamTrackStats>());
1829 }
1830
TEST_F(RTCStatsCollectorTest,CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video)1831 TEST_F(RTCStatsCollectorTest,
1832 CollectRemoteRTCMediaStreamStatsAndRTCMediaStreamTrackStats_Video) {
1833 rtc::scoped_refptr<MediaStream> remote_stream =
1834 MediaStream::Create("RemoteStreamId");
1835 pc_->mutable_remote_streams()->AddStream(remote_stream);
1836
1837 // Remote video track with values
1838 rtc::scoped_refptr<MediaStreamTrackInterface> remote_video_track_ssrc3 =
1839 CreateFakeTrack(cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID3",
1840 MediaStreamTrackInterface::kEnded);
1841 remote_stream->AddTrack(
1842 static_cast<VideoTrackInterface*>(remote_video_track_ssrc3.get()));
1843
1844 cricket::VideoReceiverInfo video_receiver_info_ssrc3;
1845 video_receiver_info_ssrc3.local_stats.push_back(cricket::SsrcReceiverInfo());
1846 video_receiver_info_ssrc3.local_stats[0].ssrc = 3;
1847 video_receiver_info_ssrc3.frame_width = 6789;
1848 video_receiver_info_ssrc3.frame_height = 9876;
1849 video_receiver_info_ssrc3.jitter_buffer_delay_seconds = 2.5;
1850 video_receiver_info_ssrc3.jitter_buffer_emitted_count = 25;
1851 video_receiver_info_ssrc3.frames_received = 1000;
1852 video_receiver_info_ssrc3.frames_decoded = 995;
1853 video_receiver_info_ssrc3.frames_dropped = 10;
1854 video_receiver_info_ssrc3.frames_rendered = 990;
1855 video_receiver_info_ssrc3.freeze_count = 3;
1856 video_receiver_info_ssrc3.pause_count = 2;
1857 video_receiver_info_ssrc3.total_freezes_duration_ms = 1000;
1858 video_receiver_info_ssrc3.total_pauses_duration_ms = 10000;
1859 video_receiver_info_ssrc3.total_frames_duration_ms = 15000;
1860 video_receiver_info_ssrc3.sum_squared_frame_durations = 1.5;
1861
1862 stats_->CreateMockRtpSendersReceiversAndChannels(
1863 {}, {}, {},
1864 {std::make_pair(remote_video_track_ssrc3.get(),
1865 video_receiver_info_ssrc3)},
1866 {}, {remote_stream});
1867
1868 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1869
1870 auto stats_of_my_type = report->GetStatsOfType<RTCMediaStreamStats>();
1871 ASSERT_EQ(1U, stats_of_my_type.size()) << "No stream in " << report->ToJson();
1872 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
1873 ASSERT_EQ(1U, stats_of_track_type.size())
1874 << "Wrong number of tracks in " << report->ToJson();
1875 ASSERT_TRUE(*(stats_of_track_type[0]->remote_source));
1876
1877 RTCMediaStreamStats expected_remote_stream(stats_of_my_type[0]->id(),
1878 report->timestamp_us());
1879 expected_remote_stream.stream_identifier = remote_stream->id();
1880 expected_remote_stream.track_ids =
1881 std::vector<std::string>({stats_of_track_type[0]->id()});
1882 ASSERT_TRUE(report->Get(expected_remote_stream.id()));
1883 EXPECT_EQ(
1884 expected_remote_stream,
1885 report->Get(expected_remote_stream.id())->cast_to<RTCMediaStreamStats>());
1886
1887 RTCMediaStreamTrackStats expected_remote_video_track_ssrc3(
1888 stats_of_track_type[0]->id(), report->timestamp_us(),
1889 RTCMediaStreamTrackKind::kVideo);
1890 expected_remote_video_track_ssrc3.track_identifier =
1891 remote_video_track_ssrc3->id();
1892 // |expected_remote_video_track_ssrc3.media_source_id| should be undefined
1893 // because the track is remote.
1894 expected_remote_video_track_ssrc3.remote_source = true;
1895 expected_remote_video_track_ssrc3.ended = true;
1896 expected_remote_video_track_ssrc3.detached = false;
1897 expected_remote_video_track_ssrc3.frame_width = 6789;
1898 expected_remote_video_track_ssrc3.frame_height = 9876;
1899 expected_remote_video_track_ssrc3.jitter_buffer_delay = 2.5;
1900 expected_remote_video_track_ssrc3.jitter_buffer_emitted_count = 25;
1901 expected_remote_video_track_ssrc3.frames_received = 1000;
1902 expected_remote_video_track_ssrc3.frames_decoded = 995;
1903 expected_remote_video_track_ssrc3.frames_dropped = 10;
1904 expected_remote_video_track_ssrc3.freeze_count = 3;
1905 expected_remote_video_track_ssrc3.pause_count = 2;
1906 expected_remote_video_track_ssrc3.total_freezes_duration = 1;
1907 expected_remote_video_track_ssrc3.total_pauses_duration = 10;
1908 expected_remote_video_track_ssrc3.total_frames_duration = 15;
1909 expected_remote_video_track_ssrc3.sum_squared_frame_durations = 1.5;
1910
1911 ASSERT_TRUE(report->Get(expected_remote_video_track_ssrc3.id()));
1912 EXPECT_EQ(expected_remote_video_track_ssrc3,
1913 report->Get(expected_remote_video_track_ssrc3.id())
1914 ->cast_to<RTCMediaStreamTrackStats>());
1915 }
1916
TEST_F(RTCStatsCollectorTest,CollectRTCInboundRTPStreamStats_Audio)1917 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Audio) {
1918 cricket::VoiceMediaInfo voice_media_info;
1919
1920 voice_media_info.receivers.push_back(cricket::VoiceReceiverInfo());
1921 voice_media_info.receivers[0].local_stats.push_back(
1922 cricket::SsrcReceiverInfo());
1923 voice_media_info.receivers[0].local_stats[0].ssrc = 1;
1924 voice_media_info.receivers[0].packets_lost = -1; // Signed per RFC3550
1925 voice_media_info.receivers[0].packets_rcvd = 2;
1926 voice_media_info.receivers[0].fec_packets_discarded = 5566;
1927 voice_media_info.receivers[0].fec_packets_received = 6677;
1928 voice_media_info.receivers[0].payload_bytes_rcvd = 3;
1929 voice_media_info.receivers[0].header_and_padding_bytes_rcvd = 4;
1930 voice_media_info.receivers[0].codec_payload_type = 42;
1931 voice_media_info.receivers[0].jitter_ms = 4500;
1932 voice_media_info.receivers[0].jitter_buffer_delay_seconds = 1.0;
1933 voice_media_info.receivers[0].jitter_buffer_emitted_count = 2;
1934 voice_media_info.receivers[0].total_samples_received = 3;
1935 voice_media_info.receivers[0].concealed_samples = 4;
1936 voice_media_info.receivers[0].silent_concealed_samples = 5;
1937 voice_media_info.receivers[0].concealment_events = 6;
1938 voice_media_info.receivers[0].inserted_samples_for_deceleration = 7;
1939 voice_media_info.receivers[0].removed_samples_for_acceleration = 8;
1940 voice_media_info.receivers[0].audio_level = 14442; // [0,32767]
1941 voice_media_info.receivers[0].total_output_energy = 10.0;
1942 voice_media_info.receivers[0].total_output_duration = 11.0;
1943
1944 voice_media_info.receivers[0].last_packet_received_timestamp_ms =
1945 absl::nullopt;
1946
1947 RtpCodecParameters codec_parameters;
1948 codec_parameters.payload_type = 42;
1949 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
1950 codec_parameters.name = "dummy";
1951 codec_parameters.clock_rate = 0;
1952 voice_media_info.receive_codecs.insert(
1953 std::make_pair(codec_parameters.payload_type, codec_parameters));
1954
1955 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
1956 voice_media_channel->SetStats(voice_media_info);
1957 stats_->SetupRemoteTrackAndReceiver(
1958 cricket::MEDIA_TYPE_AUDIO, "RemoteAudioTrackID", "RemoteStreamId", 1);
1959
1960 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
1961
1962 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
1963 ASSERT_EQ(1U, stats_of_track_type.size());
1964
1965 RTCInboundRTPStreamStats expected_audio("RTCInboundRTPAudioStream_1",
1966 report->timestamp_us());
1967 expected_audio.ssrc = 1;
1968 expected_audio.media_type = "audio";
1969 expected_audio.kind = "audio";
1970 expected_audio.track_id = stats_of_track_type[0]->id();
1971 expected_audio.transport_id = "RTCTransport_TransportName_1";
1972 expected_audio.codec_id = "RTCCodec_AudioMid_Inbound_42";
1973 expected_audio.packets_received = 2;
1974 expected_audio.fec_packets_discarded = 5566;
1975 expected_audio.fec_packets_received = 6677;
1976 expected_audio.bytes_received = 3;
1977 expected_audio.header_bytes_received = 4;
1978 expected_audio.packets_lost = -1;
1979 // |expected_audio.last_packet_received_timestamp| should be undefined.
1980 expected_audio.jitter = 4.5;
1981 expected_audio.jitter_buffer_delay = 1.0;
1982 expected_audio.jitter_buffer_emitted_count = 2;
1983 expected_audio.total_samples_received = 3;
1984 expected_audio.concealed_samples = 4;
1985 expected_audio.silent_concealed_samples = 5;
1986 expected_audio.concealment_events = 6;
1987 expected_audio.inserted_samples_for_deceleration = 7;
1988 expected_audio.removed_samples_for_acceleration = 8;
1989 expected_audio.audio_level = 14442.0 / 32767.0; // [0,1]
1990 expected_audio.total_audio_energy = 10.0;
1991 expected_audio.total_samples_duration = 11.0;
1992
1993 ASSERT_TRUE(report->Get(expected_audio.id()));
1994 EXPECT_EQ(
1995 report->Get(expected_audio.id())->cast_to<RTCInboundRTPStreamStats>(),
1996 expected_audio);
1997
1998 // Set previously undefined values and "GetStats" again.
1999 voice_media_info.receivers[0].last_packet_received_timestamp_ms = 3000;
2000 expected_audio.last_packet_received_timestamp = 3000.0;
2001 voice_media_info.receivers[0].estimated_playout_ntp_timestamp_ms = 4567;
2002 expected_audio.estimated_playout_timestamp = 4567;
2003 voice_media_channel->SetStats(voice_media_info);
2004
2005 report = stats_->GetFreshStatsReport();
2006
2007 ASSERT_TRUE(report->Get(expected_audio.id()));
2008 EXPECT_EQ(
2009 report->Get(expected_audio.id())->cast_to<RTCInboundRTPStreamStats>(),
2010 expected_audio);
2011 EXPECT_TRUE(report->Get(*expected_audio.track_id));
2012 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
2013 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
2014 }
2015
TEST_F(RTCStatsCollectorTest,CollectRTCInboundRTPStreamStats_Video)2016 TEST_F(RTCStatsCollectorTest, CollectRTCInboundRTPStreamStats_Video) {
2017 cricket::VideoMediaInfo video_media_info;
2018
2019 video_media_info.receivers.push_back(cricket::VideoReceiverInfo());
2020 video_media_info.receivers[0].local_stats.push_back(
2021 cricket::SsrcReceiverInfo());
2022 video_media_info.receivers[0].local_stats[0].ssrc = 1;
2023 video_media_info.receivers[0].packets_rcvd = 2;
2024 video_media_info.receivers[0].packets_lost = 42;
2025 video_media_info.receivers[0].payload_bytes_rcvd = 3;
2026 video_media_info.receivers[0].header_and_padding_bytes_rcvd = 12;
2027 video_media_info.receivers[0].codec_payload_type = 42;
2028 video_media_info.receivers[0].firs_sent = 5;
2029 video_media_info.receivers[0].plis_sent = 6;
2030 video_media_info.receivers[0].nacks_sent = 7;
2031 video_media_info.receivers[0].frames_received = 8;
2032 video_media_info.receivers[0].frames_decoded = 9;
2033 video_media_info.receivers[0].key_frames_decoded = 3;
2034 video_media_info.receivers[0].frames_dropped = 13;
2035 video_media_info.receivers[0].qp_sum = absl::nullopt;
2036 video_media_info.receivers[0].total_decode_time_ms = 9000;
2037 video_media_info.receivers[0].total_inter_frame_delay = 0.123;
2038 video_media_info.receivers[0].total_squared_inter_frame_delay = 0.00456;
2039 video_media_info.receivers[0].jitter_ms = 1199;
2040
2041 video_media_info.receivers[0].last_packet_received_timestamp_ms =
2042 absl::nullopt;
2043 video_media_info.receivers[0].content_type = VideoContentType::UNSPECIFIED;
2044 video_media_info.receivers[0].estimated_playout_ntp_timestamp_ms =
2045 absl::nullopt;
2046 video_media_info.receivers[0].decoder_implementation_name = "";
2047
2048 RtpCodecParameters codec_parameters;
2049 codec_parameters.payload_type = 42;
2050 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
2051 codec_parameters.name = "dummy";
2052 codec_parameters.clock_rate = 0;
2053 video_media_info.receive_codecs.insert(
2054 std::make_pair(codec_parameters.payload_type, codec_parameters));
2055
2056 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
2057 video_media_channel->SetStats(video_media_info);
2058 stats_->SetupRemoteTrackAndReceiver(
2059 cricket::MEDIA_TYPE_VIDEO, "RemoteVideoTrackID", "RemoteStreamId", 1);
2060
2061 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2062
2063 RTCInboundRTPStreamStats expected_video("RTCInboundRTPVideoStream_1",
2064 report->timestamp_us());
2065 expected_video.ssrc = 1;
2066 expected_video.media_type = "video";
2067 expected_video.kind = "video";
2068 expected_video.track_id = IdForType<RTCMediaStreamTrackStats>(report);
2069 expected_video.transport_id = "RTCTransport_TransportName_1";
2070 expected_video.codec_id = "RTCCodec_VideoMid_Inbound_42";
2071 expected_video.fir_count = 5;
2072 expected_video.pli_count = 6;
2073 expected_video.nack_count = 7;
2074 expected_video.packets_received = 2;
2075 expected_video.bytes_received = 3;
2076 expected_video.header_bytes_received = 12;
2077 expected_video.packets_lost = 42;
2078 expected_video.frames_received = 8;
2079 expected_video.frames_decoded = 9;
2080 expected_video.key_frames_decoded = 3;
2081 expected_video.frames_dropped = 13;
2082 // |expected_video.qp_sum| should be undefined.
2083 expected_video.total_decode_time = 9.0;
2084 expected_video.total_inter_frame_delay = 0.123;
2085 expected_video.total_squared_inter_frame_delay = 0.00456;
2086 expected_video.jitter = 1.199;
2087 // |expected_video.last_packet_received_timestamp| should be undefined.
2088 // |expected_video.content_type| should be undefined.
2089 // |expected_video.decoder_implementation| should be undefined.
2090
2091 ASSERT_TRUE(report->Get(expected_video.id()));
2092 EXPECT_EQ(
2093 report->Get(expected_video.id())->cast_to<RTCInboundRTPStreamStats>(),
2094 expected_video);
2095
2096 // Set previously undefined values and "GetStats" again.
2097 video_media_info.receivers[0].qp_sum = 9;
2098 expected_video.qp_sum = 9;
2099 video_media_info.receivers[0].last_packet_received_timestamp_ms = 1000;
2100 expected_video.last_packet_received_timestamp = 1000.0;
2101 video_media_info.receivers[0].content_type = VideoContentType::SCREENSHARE;
2102 expected_video.content_type = "screenshare";
2103 video_media_info.receivers[0].estimated_playout_ntp_timestamp_ms = 1234;
2104 expected_video.estimated_playout_timestamp = 1234;
2105 video_media_info.receivers[0].decoder_implementation_name = "libfoodecoder";
2106 expected_video.decoder_implementation = "libfoodecoder";
2107 video_media_channel->SetStats(video_media_info);
2108
2109 report = stats_->GetFreshStatsReport();
2110
2111 ASSERT_TRUE(report->Get(expected_video.id()));
2112 EXPECT_EQ(
2113 report->Get(expected_video.id())->cast_to<RTCInboundRTPStreamStats>(),
2114 expected_video);
2115 EXPECT_TRUE(report->Get(*expected_video.track_id));
2116 EXPECT_TRUE(report->Get(*expected_video.transport_id));
2117 EXPECT_TRUE(report->Get(*expected_video.codec_id));
2118 }
2119
TEST_F(RTCStatsCollectorTest,CollectRTCOutboundRTPStreamStats_Audio)2120 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Audio) {
2121 cricket::VoiceMediaInfo voice_media_info;
2122
2123 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
2124 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2125 voice_media_info.senders[0].local_stats[0].ssrc = 1;
2126 voice_media_info.senders[0].packets_sent = 2;
2127 voice_media_info.senders[0].retransmitted_packets_sent = 20;
2128 voice_media_info.senders[0].payload_bytes_sent = 3;
2129 voice_media_info.senders[0].header_and_padding_bytes_sent = 12;
2130 voice_media_info.senders[0].retransmitted_bytes_sent = 30;
2131 voice_media_info.senders[0].codec_payload_type = 42;
2132
2133 RtpCodecParameters codec_parameters;
2134 codec_parameters.payload_type = 42;
2135 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
2136 codec_parameters.name = "dummy";
2137 codec_parameters.clock_rate = 0;
2138 voice_media_info.send_codecs.insert(
2139 std::make_pair(codec_parameters.payload_type, codec_parameters));
2140
2141 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
2142 voice_media_channel->SetStats(voice_media_info);
2143 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_AUDIO,
2144 "LocalAudioTrackID", 1, true,
2145 /*attachment_id=*/50);
2146
2147 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2148
2149 RTCOutboundRTPStreamStats expected_audio("RTCOutboundRTPAudioStream_1",
2150 report->timestamp_us());
2151 expected_audio.media_source_id = "RTCAudioSource_50";
2152 // |expected_audio.remote_id| should be undefined.
2153 expected_audio.ssrc = 1;
2154 expected_audio.media_type = "audio";
2155 expected_audio.kind = "audio";
2156 expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report);
2157 expected_audio.transport_id = "RTCTransport_TransportName_1";
2158 expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
2159 expected_audio.packets_sent = 2;
2160 expected_audio.retransmitted_packets_sent = 20;
2161 expected_audio.bytes_sent = 3;
2162 expected_audio.header_bytes_sent = 12;
2163 expected_audio.retransmitted_bytes_sent = 30;
2164
2165 ASSERT_TRUE(report->Get(expected_audio.id()));
2166 EXPECT_EQ(
2167 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
2168 expected_audio);
2169
2170 ASSERT_TRUE(report->Get(expected_audio.id()));
2171 EXPECT_EQ(
2172 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
2173 expected_audio);
2174 EXPECT_TRUE(report->Get(*expected_audio.track_id));
2175 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
2176 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
2177 }
2178
TEST_F(RTCStatsCollectorTest,CollectRTCOutboundRTPStreamStats_Video)2179 TEST_F(RTCStatsCollectorTest, CollectRTCOutboundRTPStreamStats_Video) {
2180 cricket::VideoMediaInfo video_media_info;
2181
2182 video_media_info.senders.push_back(cricket::VideoSenderInfo());
2183 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2184 video_media_info.senders[0].local_stats[0].ssrc = 1;
2185 video_media_info.senders[0].firs_rcvd = 2;
2186 video_media_info.senders[0].plis_rcvd = 3;
2187 video_media_info.senders[0].nacks_rcvd = 4;
2188 video_media_info.senders[0].packets_sent = 5;
2189 video_media_info.senders[0].retransmitted_packets_sent = 50;
2190 video_media_info.senders[0].payload_bytes_sent = 6;
2191 video_media_info.senders[0].header_and_padding_bytes_sent = 12;
2192 video_media_info.senders[0].retransmitted_bytes_sent = 60;
2193 video_media_info.senders[0].codec_payload_type = 42;
2194 video_media_info.senders[0].frames_encoded = 8;
2195 video_media_info.senders[0].key_frames_encoded = 3;
2196 video_media_info.senders[0].total_encode_time_ms = 9000;
2197 video_media_info.senders[0].total_encoded_bytes_target = 1234;
2198 video_media_info.senders[0].total_packet_send_delay_ms = 10000;
2199 video_media_info.senders[0].quality_limitation_reason =
2200 QualityLimitationReason::kBandwidth;
2201 video_media_info.senders[0].quality_limitation_resolution_changes = 56u;
2202 video_media_info.senders[0].qp_sum = absl::nullopt;
2203 video_media_info.senders[0].content_type = VideoContentType::UNSPECIFIED;
2204 video_media_info.senders[0].encoder_implementation_name = "";
2205 video_media_info.senders[0].send_frame_width = 200;
2206 video_media_info.senders[0].send_frame_height = 100;
2207 video_media_info.senders[0].framerate_sent = 10;
2208 video_media_info.senders[0].frames_sent = 5;
2209 video_media_info.senders[0].huge_frames_sent = 2;
2210 video_media_info.aggregated_senders.push_back(video_media_info.senders[0]);
2211 RtpCodecParameters codec_parameters;
2212 codec_parameters.payload_type = 42;
2213 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
2214 codec_parameters.name = "dummy";
2215 codec_parameters.clock_rate = 0;
2216 video_media_info.send_codecs.insert(
2217 std::make_pair(codec_parameters.payload_type, codec_parameters));
2218
2219 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
2220 video_media_channel->SetStats(video_media_info);
2221 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_VIDEO,
2222 "LocalVideoTrackID", 1, true,
2223 /*attachment_id=*/50);
2224
2225 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2226
2227 auto stats_of_my_type = report->GetStatsOfType<RTCOutboundRTPStreamStats>();
2228 ASSERT_EQ(1U, stats_of_my_type.size());
2229 auto stats_of_track_type = report->GetStatsOfType<RTCMediaStreamTrackStats>();
2230 ASSERT_EQ(1U, stats_of_track_type.size());
2231
2232 RTCOutboundRTPStreamStats expected_video(stats_of_my_type[0]->id(),
2233 report->timestamp_us());
2234 expected_video.media_source_id = "RTCVideoSource_50";
2235 // |expected_video.remote_id| should be undefined.
2236 expected_video.ssrc = 1;
2237 expected_video.media_type = "video";
2238 expected_video.kind = "video";
2239 expected_video.track_id = stats_of_track_type[0]->id();
2240 expected_video.transport_id = "RTCTransport_TransportName_1";
2241 expected_video.codec_id = "RTCCodec_VideoMid_Outbound_42";
2242 expected_video.fir_count = 2;
2243 expected_video.pli_count = 3;
2244 expected_video.nack_count = 4;
2245 expected_video.packets_sent = 5;
2246 expected_video.retransmitted_packets_sent = 50;
2247 expected_video.bytes_sent = 6;
2248 expected_video.header_bytes_sent = 12;
2249 expected_video.retransmitted_bytes_sent = 60;
2250 expected_video.frames_encoded = 8;
2251 expected_video.key_frames_encoded = 3;
2252 expected_video.total_encode_time = 9.0;
2253 expected_video.total_encoded_bytes_target = 1234;
2254 expected_video.total_packet_send_delay = 10.0;
2255 expected_video.quality_limitation_reason = "bandwidth";
2256 expected_video.quality_limitation_resolution_changes = 56u;
2257 expected_video.frame_width = 200u;
2258 expected_video.frame_height = 100u;
2259 expected_video.frames_per_second = 10.0;
2260 expected_video.frames_sent = 5;
2261 expected_video.huge_frames_sent = 2;
2262 // |expected_video.content_type| should be undefined.
2263 // |expected_video.qp_sum| should be undefined.
2264 // |expected_video.encoder_implementation| should be undefined.
2265 ASSERT_TRUE(report->Get(expected_video.id()));
2266
2267 EXPECT_EQ(
2268 report->Get(expected_video.id())->cast_to<RTCOutboundRTPStreamStats>(),
2269 expected_video);
2270
2271 // Set previously undefined values and "GetStats" again.
2272 video_media_info.senders[0].qp_sum = 9;
2273 expected_video.qp_sum = 9;
2274 video_media_info.senders[0].content_type = VideoContentType::SCREENSHARE;
2275 expected_video.content_type = "screenshare";
2276 video_media_info.senders[0].encoder_implementation_name = "libfooencoder";
2277 video_media_info.aggregated_senders[0] = video_media_info.senders[0];
2278 expected_video.encoder_implementation = "libfooencoder";
2279 video_media_channel->SetStats(video_media_info);
2280
2281 report = stats_->GetFreshStatsReport();
2282
2283 ASSERT_TRUE(report->Get(expected_video.id()));
2284 EXPECT_EQ(
2285 report->Get(expected_video.id())->cast_to<RTCOutboundRTPStreamStats>(),
2286 expected_video);
2287 EXPECT_TRUE(report->Get(*expected_video.track_id));
2288 EXPECT_TRUE(report->Get(*expected_video.transport_id));
2289 EXPECT_TRUE(report->Get(*expected_video.codec_id));
2290 }
2291
TEST_F(RTCStatsCollectorTest,CollectRTCTransportStats)2292 TEST_F(RTCStatsCollectorTest, CollectRTCTransportStats) {
2293 const char kTransportName[] = "transport";
2294
2295 pc_->AddVoiceChannel("audio", kTransportName);
2296
2297 std::unique_ptr<cricket::Candidate> rtp_local_candidate =
2298 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
2299 cricket::LOCAL_PORT_TYPE, 42);
2300 std::unique_ptr<cricket::Candidate> rtp_remote_candidate =
2301 CreateFakeCandidate("42.42.42.42", 42, "protocol",
2302 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
2303 42);
2304 std::unique_ptr<cricket::Candidate> rtcp_local_candidate =
2305 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
2306 cricket::LOCAL_PORT_TYPE, 42);
2307 std::unique_ptr<cricket::Candidate> rtcp_remote_candidate =
2308 CreateFakeCandidate("42.42.42.42", 42, "protocol",
2309 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
2310 42);
2311
2312 cricket::ConnectionInfo rtp_connection_info;
2313 rtp_connection_info.best_connection = false;
2314 rtp_connection_info.local_candidate = *rtp_local_candidate.get();
2315 rtp_connection_info.remote_candidate = *rtp_remote_candidate.get();
2316 rtp_connection_info.sent_total_bytes = 42;
2317 rtp_connection_info.recv_total_bytes = 1337;
2318 rtp_connection_info.sent_total_packets = 3;
2319 rtp_connection_info.sent_discarded_packets = 2;
2320 rtp_connection_info.packets_received = 4;
2321 cricket::TransportChannelStats rtp_transport_channel_stats;
2322 rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
2323 rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
2324 rtp_connection_info);
2325 rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
2326 rtp_transport_channel_stats.ice_transport_stats
2327 .selected_candidate_pair_changes = 1;
2328 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
2329
2330 // Get stats without RTCP, an active connection or certificates.
2331 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2332
2333 RTCTransportStats expected_rtp_transport(
2334 "RTCTransport_transport_" +
2335 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP),
2336 report->timestamp_us());
2337 expected_rtp_transport.bytes_sent = 42;
2338 expected_rtp_transport.packets_sent = 1;
2339 expected_rtp_transport.bytes_received = 1337;
2340 expected_rtp_transport.packets_received = 4;
2341 expected_rtp_transport.dtls_state = RTCDtlsTransportState::kNew;
2342 expected_rtp_transport.selected_candidate_pair_changes = 1;
2343
2344 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
2345 EXPECT_EQ(
2346 expected_rtp_transport,
2347 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
2348
2349 cricket::ConnectionInfo rtcp_connection_info;
2350 rtcp_connection_info.best_connection = false;
2351 rtcp_connection_info.local_candidate = *rtcp_local_candidate.get();
2352 rtcp_connection_info.remote_candidate = *rtcp_remote_candidate.get();
2353 rtcp_connection_info.sent_total_bytes = 1337;
2354 rtcp_connection_info.recv_total_bytes = 42;
2355 rtcp_connection_info.sent_total_packets = 3;
2356 rtcp_connection_info.sent_discarded_packets = 2;
2357 rtcp_connection_info.packets_received = 4;
2358 cricket::TransportChannelStats rtcp_transport_channel_stats;
2359 rtcp_transport_channel_stats.component =
2360 cricket::ICE_CANDIDATE_COMPONENT_RTCP;
2361 rtcp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
2362 rtcp_connection_info);
2363 rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTING;
2364 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
2365 rtcp_transport_channel_stats});
2366
2367 // Get stats with RTCP and without an active connection or certificates.
2368 report = stats_->GetFreshStatsReport();
2369
2370 RTCTransportStats expected_rtcp_transport(
2371 "RTCTransport_transport_" +
2372 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTCP),
2373 report->timestamp_us());
2374 expected_rtcp_transport.bytes_sent = 1337;
2375 expected_rtcp_transport.packets_sent = 1;
2376 expected_rtcp_transport.bytes_received = 42;
2377 expected_rtcp_transport.packets_received = 4;
2378 expected_rtcp_transport.dtls_state = RTCDtlsTransportState::kConnecting;
2379 expected_rtcp_transport.selected_candidate_pair_changes = 0;
2380
2381 expected_rtp_transport.rtcp_transport_stats_id = expected_rtcp_transport.id();
2382 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
2383 EXPECT_EQ(
2384 expected_rtp_transport,
2385 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
2386 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
2387 EXPECT_EQ(
2388 expected_rtcp_transport,
2389 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
2390
2391 // Get stats with an active connection (selected candidate pair).
2392 rtcp_transport_channel_stats.ice_transport_stats.connection_infos[0]
2393 .best_connection = true;
2394 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats,
2395 rtcp_transport_channel_stats});
2396
2397 report = stats_->GetFreshStatsReport();
2398
2399 expected_rtcp_transport.selected_candidate_pair_id =
2400 "RTCIceCandidatePair_" + rtcp_local_candidate->id() + "_" +
2401 rtcp_remote_candidate->id();
2402
2403 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
2404 EXPECT_EQ(
2405 expected_rtp_transport,
2406 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
2407 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
2408 EXPECT_EQ(
2409 expected_rtcp_transport,
2410 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
2411
2412 // Get stats with certificates.
2413 std::unique_ptr<CertificateInfo> local_certinfo =
2414 CreateFakeCertificateAndInfoFromDers({"(local) local", "(local) chain"});
2415 pc_->SetLocalCertificate(kTransportName, local_certinfo->certificate);
2416 std::unique_ptr<CertificateInfo> remote_certinfo =
2417 CreateFakeCertificateAndInfoFromDers(
2418 {"(remote) local", "(remote) chain"});
2419 pc_->SetRemoteCertChain(
2420 kTransportName,
2421 remote_certinfo->certificate->GetSSLCertificateChain().Clone());
2422
2423 report = stats_->GetFreshStatsReport();
2424
2425 expected_rtp_transport.local_certificate_id =
2426 "RTCCertificate_" + local_certinfo->fingerprints[0];
2427 expected_rtp_transport.remote_certificate_id =
2428 "RTCCertificate_" + remote_certinfo->fingerprints[0];
2429
2430 expected_rtcp_transport.local_certificate_id =
2431 *expected_rtp_transport.local_certificate_id;
2432 expected_rtcp_transport.remote_certificate_id =
2433 *expected_rtp_transport.remote_certificate_id;
2434
2435 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
2436 EXPECT_EQ(
2437 expected_rtp_transport,
2438 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
2439 ASSERT_TRUE(report->Get(expected_rtcp_transport.id()));
2440 EXPECT_EQ(
2441 expected_rtcp_transport,
2442 report->Get(expected_rtcp_transport.id())->cast_to<RTCTransportStats>());
2443 }
2444
TEST_F(RTCStatsCollectorTest,CollectRTCTransportStatsWithCrypto)2445 TEST_F(RTCStatsCollectorTest, CollectRTCTransportStatsWithCrypto) {
2446 const char kTransportName[] = "transport";
2447
2448 pc_->AddVoiceChannel("audio", kTransportName);
2449
2450 std::unique_ptr<cricket::Candidate> rtp_local_candidate =
2451 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
2452 cricket::LOCAL_PORT_TYPE, 42);
2453 std::unique_ptr<cricket::Candidate> rtp_remote_candidate =
2454 CreateFakeCandidate("42.42.42.42", 42, "protocol",
2455 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
2456 42);
2457 std::unique_ptr<cricket::Candidate> rtcp_local_candidate =
2458 CreateFakeCandidate("42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_WIFI,
2459 cricket::LOCAL_PORT_TYPE, 42);
2460 std::unique_ptr<cricket::Candidate> rtcp_remote_candidate =
2461 CreateFakeCandidate("42.42.42.42", 42, "protocol",
2462 rtc::ADAPTER_TYPE_UNKNOWN, cricket::LOCAL_PORT_TYPE,
2463 42);
2464
2465 cricket::ConnectionInfo rtp_connection_info;
2466 rtp_connection_info.best_connection = false;
2467 rtp_connection_info.local_candidate = *rtp_local_candidate.get();
2468 rtp_connection_info.remote_candidate = *rtp_remote_candidate.get();
2469 rtp_connection_info.sent_total_bytes = 42;
2470 rtp_connection_info.recv_total_bytes = 1337;
2471 rtp_connection_info.sent_total_packets = 3;
2472 rtp_connection_info.sent_discarded_packets = 2;
2473 rtp_connection_info.packets_received = 4;
2474 cricket::TransportChannelStats rtp_transport_channel_stats;
2475 rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
2476 rtp_transport_channel_stats.ice_transport_stats.connection_infos.push_back(
2477 rtp_connection_info);
2478 // The state must be connected in order for crypto parameters to show up.
2479 rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_CONNECTED;
2480 rtp_transport_channel_stats.ice_transport_stats
2481 .selected_candidate_pair_changes = 1;
2482 rtp_transport_channel_stats.ssl_version_bytes = 0x0203;
2483 // 0x2F is TLS_RSA_WITH_AES_128_CBC_SHA according to IANA
2484 rtp_transport_channel_stats.ssl_cipher_suite = 0x2F;
2485 rtp_transport_channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
2486 pc_->SetTransportStats(kTransportName, {rtp_transport_channel_stats});
2487
2488 // Get stats
2489 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2490
2491 RTCTransportStats expected_rtp_transport(
2492 "RTCTransport_transport_" +
2493 rtc::ToString(cricket::ICE_CANDIDATE_COMPONENT_RTP),
2494 report->timestamp_us());
2495 expected_rtp_transport.bytes_sent = 42;
2496 expected_rtp_transport.packets_sent = 1;
2497 expected_rtp_transport.bytes_received = 1337;
2498 expected_rtp_transport.packets_received = 4;
2499 expected_rtp_transport.dtls_state = RTCDtlsTransportState::kConnected;
2500 expected_rtp_transport.selected_candidate_pair_changes = 1;
2501 // Crypto parameters
2502 expected_rtp_transport.tls_version = "0203";
2503 expected_rtp_transport.dtls_cipher = "TLS_RSA_WITH_AES_128_CBC_SHA";
2504 expected_rtp_transport.srtp_cipher = "AES_CM_128_HMAC_SHA1_80";
2505
2506 ASSERT_TRUE(report->Get(expected_rtp_transport.id()));
2507 EXPECT_EQ(
2508 expected_rtp_transport,
2509 report->Get(expected_rtp_transport.id())->cast_to<RTCTransportStats>());
2510 }
2511
TEST_F(RTCStatsCollectorTest,CollectNoStreamRTCOutboundRTPStreamStats_Audio)2512 TEST_F(RTCStatsCollectorTest, CollectNoStreamRTCOutboundRTPStreamStats_Audio) {
2513 cricket::VoiceMediaInfo voice_media_info;
2514
2515 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
2516 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2517 voice_media_info.senders[0].local_stats[0].ssrc = 1;
2518 voice_media_info.senders[0].packets_sent = 2;
2519 voice_media_info.senders[0].retransmitted_packets_sent = 20;
2520 voice_media_info.senders[0].payload_bytes_sent = 3;
2521 voice_media_info.senders[0].header_and_padding_bytes_sent = 4;
2522 voice_media_info.senders[0].retransmitted_bytes_sent = 30;
2523 voice_media_info.senders[0].codec_payload_type = 42;
2524
2525 RtpCodecParameters codec_parameters;
2526 codec_parameters.payload_type = 42;
2527 codec_parameters.kind = cricket::MEDIA_TYPE_AUDIO;
2528 codec_parameters.name = "dummy";
2529 codec_parameters.clock_rate = 0;
2530 voice_media_info.send_codecs.insert(
2531 std::make_pair(codec_parameters.payload_type, codec_parameters));
2532
2533 // Emulates the case where AddTrack is used without an associated MediaStream
2534 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
2535 voice_media_channel->SetStats(voice_media_info);
2536 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_AUDIO,
2537 "LocalAudioTrackID", 1, false,
2538 /*attachment_id=*/50);
2539
2540 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2541
2542 RTCOutboundRTPStreamStats expected_audio("RTCOutboundRTPAudioStream_1",
2543 report->timestamp_us());
2544 expected_audio.media_source_id = "RTCAudioSource_50";
2545 expected_audio.ssrc = 1;
2546 expected_audio.media_type = "audio";
2547 expected_audio.kind = "audio";
2548 expected_audio.track_id = IdForType<RTCMediaStreamTrackStats>(report);
2549 expected_audio.transport_id = "RTCTransport_TransportName_1";
2550 expected_audio.codec_id = "RTCCodec_AudioMid_Outbound_42";
2551 expected_audio.packets_sent = 2;
2552 expected_audio.retransmitted_packets_sent = 20;
2553 expected_audio.bytes_sent = 3;
2554 expected_audio.header_bytes_sent = 4;
2555 expected_audio.retransmitted_bytes_sent = 30;
2556
2557 ASSERT_TRUE(report->Get(expected_audio.id()));
2558 EXPECT_EQ(
2559 report->Get(expected_audio.id())->cast_to<RTCOutboundRTPStreamStats>(),
2560 expected_audio);
2561 EXPECT_TRUE(report->Get(*expected_audio.track_id));
2562 EXPECT_TRUE(report->Get(*expected_audio.transport_id));
2563 EXPECT_TRUE(report->Get(*expected_audio.codec_id));
2564 }
2565
TEST_F(RTCStatsCollectorTest,RTCAudioSourceStatsCollectedForSenderWithTrack)2566 TEST_F(RTCStatsCollectorTest, RTCAudioSourceStatsCollectedForSenderWithTrack) {
2567 const uint32_t kSsrc = 4;
2568 const int kAttachmentId = 42;
2569
2570 cricket::VoiceMediaInfo voice_media_info;
2571 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
2572 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2573 voice_media_info.senders[0].local_stats[0].ssrc = kSsrc;
2574 voice_media_info.senders[0].audio_level = 32767; // [0,32767]
2575 voice_media_info.senders[0].total_input_energy = 2.0;
2576 voice_media_info.senders[0].total_input_duration = 3.0;
2577 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
2578 voice_media_channel->SetStats(voice_media_info);
2579 stats_->SetupLocalTrackAndSender(cricket::MEDIA_TYPE_AUDIO,
2580 "LocalAudioTrackID", kSsrc, false,
2581 kAttachmentId);
2582
2583 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2584
2585 RTCAudioSourceStats expected_audio("RTCAudioSource_42",
2586 report->timestamp_us());
2587 expected_audio.track_identifier = "LocalAudioTrackID";
2588 expected_audio.kind = "audio";
2589 expected_audio.audio_level = 1.0; // [0,1]
2590 expected_audio.total_audio_energy = 2.0;
2591 expected_audio.total_samples_duration = 3.0;
2592
2593 ASSERT_TRUE(report->Get(expected_audio.id()));
2594 EXPECT_EQ(report->Get(expected_audio.id())->cast_to<RTCAudioSourceStats>(),
2595 expected_audio);
2596 }
2597
TEST_F(RTCStatsCollectorTest,RTCVideoSourceStatsCollectedForSenderWithTrack)2598 TEST_F(RTCStatsCollectorTest, RTCVideoSourceStatsCollectedForSenderWithTrack) {
2599 const uint32_t kSsrc = 4;
2600 const int kAttachmentId = 42;
2601 const int kVideoSourceWidth = 12;
2602 const int kVideoSourceHeight = 34;
2603
2604 cricket::VideoMediaInfo video_media_info;
2605 video_media_info.aggregated_senders.push_back(cricket::VideoSenderInfo());
2606 video_media_info.senders.push_back(cricket::VideoSenderInfo());
2607 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2608 video_media_info.senders[0].local_stats[0].ssrc = kSsrc;
2609 video_media_info.senders[0].framerate_input = 29;
2610 video_media_info.aggregated_senders[0].local_stats.push_back(
2611 cricket::SsrcSenderInfo());
2612 video_media_info.aggregated_senders[0].local_stats[0].ssrc = kSsrc;
2613 video_media_info.aggregated_senders[0].framerate_input = 29;
2614 video_media_info.aggregated_senders[0].frames = 10001;
2615 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
2616 video_media_channel->SetStats(video_media_info);
2617
2618 auto video_source = FakeVideoTrackSourceForStats::Create(kVideoSourceWidth,
2619 kVideoSourceHeight);
2620 auto video_track = FakeVideoTrackForStats::Create(
2621 "LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source);
2622 rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
2623 cricket::MEDIA_TYPE_VIDEO, video_track, kSsrc, kAttachmentId, {});
2624 pc_->AddSender(sender);
2625
2626 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2627
2628 RTCVideoSourceStats expected_video("RTCVideoSource_42",
2629 report->timestamp_us());
2630 expected_video.track_identifier = "LocalVideoTrackID";
2631 expected_video.kind = "video";
2632 expected_video.width = kVideoSourceWidth;
2633 expected_video.height = kVideoSourceHeight;
2634 expected_video.frames_per_second = 29;
2635 expected_video.frames = 10001;
2636
2637 ASSERT_TRUE(report->Get(expected_video.id()));
2638 EXPECT_EQ(report->Get(expected_video.id())->cast_to<RTCVideoSourceStats>(),
2639 expected_video);
2640 }
2641
2642 // This test exercises the current behavior and code path, but the correct
2643 // behavior is to report frame rate even if we have no SSRC.
2644 // TODO(hbos): When we know the frame rate even if we have no SSRC, update the
2645 // expectations of this test.
TEST_F(RTCStatsCollectorTest,RTCVideoSourceStatsMissingFrameRateWhenSenderHasNoSsrc)2646 TEST_F(RTCStatsCollectorTest,
2647 RTCVideoSourceStatsMissingFrameRateWhenSenderHasNoSsrc) {
2648 // TODO(https://crbug.com/webrtc/8694): When 0 is no longer a magic value for
2649 // "none", update this test.
2650 const uint32_t kNoSsrc = 0;
2651 const int kAttachmentId = 42;
2652 const int kVideoSourceWidth = 12;
2653 const int kVideoSourceHeight = 34;
2654
2655 cricket::VideoMediaInfo video_media_info;
2656 video_media_info.senders.push_back(cricket::VideoSenderInfo());
2657 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2658 video_media_info.senders[0].framerate_input = 29;
2659 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
2660 video_media_channel->SetStats(video_media_info);
2661
2662 auto video_source = FakeVideoTrackSourceForStats::Create(kVideoSourceWidth,
2663 kVideoSourceHeight);
2664 auto video_track = FakeVideoTrackForStats::Create(
2665 "LocalVideoTrackID", MediaStreamTrackInterface::kLive, video_source);
2666 rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
2667 cricket::MEDIA_TYPE_VIDEO, video_track, kNoSsrc, kAttachmentId, {});
2668 pc_->AddSender(sender);
2669
2670 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2671 ASSERT_TRUE(report->Get("RTCVideoSource_42"));
2672 auto video_stats =
2673 report->Get("RTCVideoSource_42")->cast_to<RTCVideoSourceStats>();
2674 EXPECT_FALSE(video_stats.frames_per_second.is_defined());
2675 EXPECT_FALSE(video_stats.frames.is_defined());
2676 }
2677
2678 // The track not having a source is not expected to be true in practise, but
2679 // this is true in some tests relying on fakes. This test covers that code path.
TEST_F(RTCStatsCollectorTest,RTCVideoSourceStatsMissingResolutionWhenTrackHasNoSource)2680 TEST_F(RTCStatsCollectorTest,
2681 RTCVideoSourceStatsMissingResolutionWhenTrackHasNoSource) {
2682 const uint32_t kSsrc = 4;
2683 const int kAttachmentId = 42;
2684
2685 cricket::VideoMediaInfo video_media_info;
2686 video_media_info.senders.push_back(cricket::VideoSenderInfo());
2687 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2688 video_media_info.senders[0].local_stats[0].ssrc = kSsrc;
2689 video_media_info.senders[0].framerate_input = 29;
2690 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
2691 video_media_channel->SetStats(video_media_info);
2692
2693 auto video_track = FakeVideoTrackForStats::Create(
2694 "LocalVideoTrackID", MediaStreamTrackInterface::kLive,
2695 /*source=*/nullptr);
2696 rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
2697 cricket::MEDIA_TYPE_VIDEO, video_track, kSsrc, kAttachmentId, {});
2698 pc_->AddSender(sender);
2699
2700 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2701 ASSERT_TRUE(report->Get("RTCVideoSource_42"));
2702 auto video_stats =
2703 report->Get("RTCVideoSource_42")->cast_to<RTCVideoSourceStats>();
2704 EXPECT_FALSE(video_stats.width.is_defined());
2705 EXPECT_FALSE(video_stats.height.is_defined());
2706 }
2707
TEST_F(RTCStatsCollectorTest,RTCAudioSourceStatsNotCollectedForSenderWithoutTrack)2708 TEST_F(RTCStatsCollectorTest,
2709 RTCAudioSourceStatsNotCollectedForSenderWithoutTrack) {
2710 const uint32_t kSsrc = 4;
2711 const int kAttachmentId = 42;
2712
2713 cricket::VoiceMediaInfo voice_media_info;
2714 voice_media_info.senders.push_back(cricket::VoiceSenderInfo());
2715 voice_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
2716 voice_media_info.senders[0].local_stats[0].ssrc = kSsrc;
2717 auto* voice_media_channel = pc_->AddVoiceChannel("AudioMid", "TransportName");
2718 voice_media_channel->SetStats(voice_media_info);
2719 rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
2720 cricket::MEDIA_TYPE_AUDIO, /*track=*/nullptr, kSsrc, kAttachmentId, {});
2721 pc_->AddSender(sender);
2722
2723 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2724 EXPECT_FALSE(report->Get("RTCAudioSource_42"));
2725 }
2726
2727 // Parameterized tests on cricket::MediaType (audio or video).
2728 class RTCStatsCollectorTestWithParamKind
2729 : public RTCStatsCollectorTest,
2730 public ::testing::WithParamInterface<cricket::MediaType> {
2731 public:
RTCStatsCollectorTestWithParamKind()2732 RTCStatsCollectorTestWithParamKind() : media_type_(GetParam()) {
2733 RTC_DCHECK(media_type_ == cricket::MEDIA_TYPE_AUDIO ||
2734 media_type_ == cricket::MEDIA_TYPE_VIDEO);
2735 }
2736
MediaTypeUpperCase() const2737 std::string MediaTypeUpperCase() const {
2738 switch (media_type_) {
2739 case cricket::MEDIA_TYPE_AUDIO:
2740 return "Audio";
2741 case cricket::MEDIA_TYPE_VIDEO:
2742 return "Video";
2743 case cricket::MEDIA_TYPE_DATA:
2744 case cricket::MEDIA_TYPE_UNSUPPORTED:
2745 RTC_NOTREACHED();
2746 return "";
2747 }
2748 }
2749
MediaTypeLowerCase() const2750 std::string MediaTypeLowerCase() const {
2751 std::string str = MediaTypeUpperCase();
2752 std::transform(str.begin(), str.end(), str.begin(), ::tolower);
2753 return str;
2754 }
2755
2756 // Adds a sender and channel of the appropriate kind, creating a sender info
2757 // with the report block's |source_ssrc| and report block data.
AddSenderInfoAndMediaChannel(std::string transport_name,const std::vector<ReportBlockData> & report_block_datas,absl::optional<RtpCodecParameters> codec)2758 void AddSenderInfoAndMediaChannel(
2759 std::string transport_name,
2760 const std::vector<ReportBlockData>& report_block_datas,
2761 absl::optional<RtpCodecParameters> codec) {
2762 switch (media_type_) {
2763 case cricket::MEDIA_TYPE_AUDIO: {
2764 cricket::VoiceMediaInfo voice_media_info;
2765 for (const auto& report_block_data : report_block_datas) {
2766 cricket::VoiceSenderInfo sender;
2767 sender.local_stats.push_back(cricket::SsrcSenderInfo());
2768 sender.local_stats[0].ssrc =
2769 report_block_data.report_block().source_ssrc;
2770 if (codec.has_value()) {
2771 sender.codec_payload_type = codec->payload_type;
2772 voice_media_info.send_codecs.insert(
2773 std::make_pair(codec->payload_type, *codec));
2774 }
2775 sender.report_block_datas.push_back(report_block_data);
2776 voice_media_info.senders.push_back(sender);
2777 }
2778 auto* voice_media_channel = pc_->AddVoiceChannel("mid", transport_name);
2779 voice_media_channel->SetStats(voice_media_info);
2780 return;
2781 }
2782 case cricket::MEDIA_TYPE_VIDEO: {
2783 cricket::VideoMediaInfo video_media_info;
2784 for (const auto& report_block_data : report_block_datas) {
2785 cricket::VideoSenderInfo sender;
2786 sender.local_stats.push_back(cricket::SsrcSenderInfo());
2787 sender.local_stats[0].ssrc =
2788 report_block_data.report_block().source_ssrc;
2789 if (codec.has_value()) {
2790 sender.codec_payload_type = codec->payload_type;
2791 video_media_info.send_codecs.insert(
2792 std::make_pair(codec->payload_type, *codec));
2793 }
2794 sender.report_block_datas.push_back(report_block_data);
2795 video_media_info.aggregated_senders.push_back(sender);
2796 video_media_info.senders.push_back(sender);
2797 }
2798 auto* video_media_channel = pc_->AddVideoChannel("mid", transport_name);
2799 video_media_channel->SetStats(video_media_info);
2800 return;
2801 }
2802 case cricket::MEDIA_TYPE_DATA:
2803 case cricket::MEDIA_TYPE_UNSUPPORTED:
2804 RTC_NOTREACHED();
2805 }
2806 }
2807
2808 protected:
2809 cricket::MediaType media_type_;
2810 };
2811
2812 // Verifies RTCRemoteInboundRtpStreamStats members that don't require
2813 // RTCCodecStats (codecId, jitter) and without setting up an RTCP transport.
TEST_P(RTCStatsCollectorTestWithParamKind,RTCRemoteInboundRtpStreamStatsCollectedFromReportBlock)2814 TEST_P(RTCStatsCollectorTestWithParamKind,
2815 RTCRemoteInboundRtpStreamStatsCollectedFromReportBlock) {
2816 const int64_t kReportBlockTimestampUtcUs = 123456789;
2817 const uint8_t kFractionLost = 12;
2818 const int64_t kRoundTripTimeSample1Ms = 1234;
2819 const double kRoundTripTimeSample1Seconds = 1.234;
2820 const int64_t kRoundTripTimeSample2Ms = 13000;
2821 const double kRoundTripTimeSample2Seconds = 13;
2822
2823 // The report block's timestamp cannot be from the future, set the fake clock
2824 // to match.
2825 fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
2826 auto ssrcs = {12, 13};
2827 std::vector<ReportBlockData> report_block_datas;
2828 for (auto ssrc : ssrcs) {
2829 RTCPReportBlock report_block;
2830 // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
2831 // |source_ssrc|, "SSRC of the RTP packet sender".
2832 report_block.source_ssrc = ssrc;
2833 report_block.packets_lost = 7;
2834 report_block.fraction_lost = kFractionLost;
2835 ReportBlockData report_block_data;
2836 report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
2837 report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample1Ms);
2838 // Only the last sample should be exposed as the
2839 // |RTCRemoteInboundRtpStreamStats::round_trip_time|.
2840 report_block_data.AddRoundTripTimeSample(kRoundTripTimeSample2Ms);
2841 report_block_datas.push_back(report_block_data);
2842 }
2843 AddSenderInfoAndMediaChannel("TransportName", report_block_datas,
2844 absl::nullopt);
2845
2846 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2847 for (auto ssrc : ssrcs) {
2848 std::string stream_id = "Stream_" + std::to_string(ssrc);
2849 RTCRemoteInboundRtpStreamStats expected_remote_inbound_rtp(
2850 "RTCRemoteInboundRtp" + MediaTypeUpperCase() + stream_id,
2851 kReportBlockTimestampUtcUs);
2852 expected_remote_inbound_rtp.ssrc = ssrc;
2853 expected_remote_inbound_rtp.fraction_lost =
2854 static_cast<double>(kFractionLost) / (1 << 8);
2855 expected_remote_inbound_rtp.kind = MediaTypeLowerCase();
2856 expected_remote_inbound_rtp.transport_id =
2857 "RTCTransport_TransportName_1"; // 1 for RTP (we have no RTCP
2858 // transport)
2859 expected_remote_inbound_rtp.packets_lost = 7;
2860 expected_remote_inbound_rtp.local_id =
2861 "RTCOutboundRTP" + MediaTypeUpperCase() + stream_id;
2862 expected_remote_inbound_rtp.round_trip_time = kRoundTripTimeSample2Seconds;
2863 expected_remote_inbound_rtp.total_round_trip_time =
2864 kRoundTripTimeSample1Seconds + kRoundTripTimeSample2Seconds;
2865 expected_remote_inbound_rtp.round_trip_time_measurements = 2;
2866 // This test does not set up RTCCodecStats, so |codec_id| and |jitter| are
2867 // expected to be missing. These are tested separately.
2868
2869 ASSERT_TRUE(report->Get(expected_remote_inbound_rtp.id()));
2870 EXPECT_EQ(report->Get(expected_remote_inbound_rtp.id())
2871 ->cast_to<RTCRemoteInboundRtpStreamStats>(),
2872 expected_remote_inbound_rtp);
2873 EXPECT_TRUE(report->Get(*expected_remote_inbound_rtp.transport_id));
2874 ASSERT_TRUE(report->Get(*expected_remote_inbound_rtp.local_id));
2875 // Lookup works in both directions.
2876 EXPECT_EQ(*report->Get(*expected_remote_inbound_rtp.local_id)
2877 ->cast_to<RTCOutboundRTPStreamStats>()
2878 .remote_id,
2879 expected_remote_inbound_rtp.id());
2880 }
2881 }
2882
TEST_P(RTCStatsCollectorTestWithParamKind,RTCRemoteInboundRtpStreamStatsWithTimestampFromReportBlock)2883 TEST_P(RTCStatsCollectorTestWithParamKind,
2884 RTCRemoteInboundRtpStreamStatsWithTimestampFromReportBlock) {
2885 const int64_t kReportBlockTimestampUtcUs = 123456789;
2886 fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
2887
2888 RTCPReportBlock report_block;
2889 // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
2890 // |source_ssrc|, "SSRC of the RTP packet sender".
2891 report_block.source_ssrc = 12;
2892 ReportBlockData report_block_data;
2893 report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
2894
2895 AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
2896 absl::nullopt);
2897
2898 // Advance time, it should be OK to have fresher reports than report blocks.
2899 fake_clock_.AdvanceTime(TimeDelta::Micros(1234));
2900
2901 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2902
2903 std::string remote_inbound_rtp_id =
2904 "RTCRemoteInboundRtp" + MediaTypeUpperCase() + "Stream_12";
2905 ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
2906 auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id)
2907 ->cast_to<RTCRemoteInboundRtpStreamStats>();
2908
2909 // Even though the report time is different, the remote-inbound-rtp timestamp
2910 // is of the time that the report block was received.
2911 EXPECT_EQ(kReportBlockTimestampUtcUs + 1234, report->timestamp_us());
2912 EXPECT_EQ(kReportBlockTimestampUtcUs, remote_inbound_rtp.timestamp_us());
2913 }
2914
TEST_P(RTCStatsCollectorTestWithParamKind,RTCRemoteInboundRtpStreamStatsWithCodecBasedMembers)2915 TEST_P(RTCStatsCollectorTestWithParamKind,
2916 RTCRemoteInboundRtpStreamStatsWithCodecBasedMembers) {
2917 const int64_t kReportBlockTimestampUtcUs = 123456789;
2918 fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
2919
2920 RTCPReportBlock report_block;
2921 // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
2922 // |source_ssrc|, "SSRC of the RTP packet sender".
2923 report_block.source_ssrc = 12;
2924 report_block.jitter = 5000;
2925 ReportBlockData report_block_data;
2926 report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
2927
2928 RtpCodecParameters codec;
2929 codec.payload_type = 3;
2930 codec.kind = media_type_;
2931 codec.clock_rate = 1000;
2932
2933 AddSenderInfoAndMediaChannel("TransportName", {report_block_data}, codec);
2934
2935 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2936
2937 std::string remote_inbound_rtp_id =
2938 "RTCRemoteInboundRtp" + MediaTypeUpperCase() + "Stream_12";
2939 ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
2940 auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id)
2941 ->cast_to<RTCRemoteInboundRtpStreamStats>();
2942
2943 EXPECT_TRUE(remote_inbound_rtp.codec_id.is_defined());
2944 EXPECT_TRUE(report->Get(*remote_inbound_rtp.codec_id));
2945
2946 EXPECT_TRUE(remote_inbound_rtp.jitter.is_defined());
2947 // The jitter (in seconds) is the report block's jitter divided by the codec's
2948 // clock rate.
2949 EXPECT_EQ(5.0, *remote_inbound_rtp.jitter);
2950 }
2951
TEST_P(RTCStatsCollectorTestWithParamKind,RTCRemoteInboundRtpStreamStatsWithRtcpTransport)2952 TEST_P(RTCStatsCollectorTestWithParamKind,
2953 RTCRemoteInboundRtpStreamStatsWithRtcpTransport) {
2954 const int64_t kReportBlockTimestampUtcUs = 123456789;
2955 fake_clock_.SetTime(Timestamp::Micros(kReportBlockTimestampUtcUs));
2956
2957 RTCPReportBlock report_block;
2958 // The remote-inbound-rtp SSRC and the outbound-rtp SSRC is the same as the
2959 // |source_ssrc|, "SSRC of the RTP packet sender".
2960 report_block.source_ssrc = 12;
2961 ReportBlockData report_block_data;
2962 report_block_data.SetReportBlock(report_block, kReportBlockTimestampUtcUs);
2963
2964 cricket::TransportChannelStats rtp_transport_channel_stats;
2965 rtp_transport_channel_stats.component = cricket::ICE_CANDIDATE_COMPONENT_RTP;
2966 rtp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
2967 cricket::TransportChannelStats rtcp_transport_channel_stats;
2968 rtcp_transport_channel_stats.component =
2969 cricket::ICE_CANDIDATE_COMPONENT_RTCP;
2970 rtcp_transport_channel_stats.dtls_state = cricket::DTLS_TRANSPORT_NEW;
2971 pc_->SetTransportStats("TransportName", {rtp_transport_channel_stats,
2972 rtcp_transport_channel_stats});
2973 AddSenderInfoAndMediaChannel("TransportName", {report_block_data},
2974 absl::nullopt);
2975
2976 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
2977
2978 std::string remote_inbound_rtp_id =
2979 "RTCRemoteInboundRtp" + MediaTypeUpperCase() + "Stream_12";
2980 ASSERT_TRUE(report->Get(remote_inbound_rtp_id));
2981 auto& remote_inbound_rtp = report->Get(remote_inbound_rtp_id)
2982 ->cast_to<RTCRemoteInboundRtpStreamStats>();
2983
2984 EXPECT_TRUE(remote_inbound_rtp.transport_id.is_defined());
2985 EXPECT_EQ("RTCTransport_TransportName_2", // 2 for RTCP
2986 *remote_inbound_rtp.transport_id);
2987 EXPECT_TRUE(report->Get(*remote_inbound_rtp.transport_id));
2988 }
2989
2990 INSTANTIATE_TEST_SUITE_P(All,
2991 RTCStatsCollectorTestWithParamKind,
2992 ::testing::Values(cricket::MEDIA_TYPE_AUDIO, // "/0"
2993 cricket::MEDIA_TYPE_VIDEO)); // "/1"
2994
2995 // Checks that no remote outbound stats are collected if not available in
2996 // `VoiceMediaInfo`.
TEST_F(RTCStatsCollectorTest,RTCRemoteOutboundRtpAudioStreamStatsNotCollected)2997 TEST_F(RTCStatsCollectorTest,
2998 RTCRemoteOutboundRtpAudioStreamStatsNotCollected) {
2999 ExampleStatsGraph graph =
3000 SetupExampleStatsVoiceGraph(/*add_remote_outbound_stats=*/false);
3001 EXPECT_FALSE(graph.full_report->Get(graph.remote_outbound_rtp_id));
3002 // Also check that no other remote outbound report is created (in case the
3003 // expected ID is incorrect).
3004 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
3005 ASSERT_NE(report->begin(), report->end())
3006 << "No reports have been generated.";
3007 for (const auto& stats : *report) {
3008 SCOPED_TRACE(stats.id());
3009 EXPECT_NE(stats.type(), RTCRemoteOutboundRtpStreamStats::kType);
3010 }
3011 }
3012
3013 // Checks that the remote outbound stats are collected when available in
3014 // `VoiceMediaInfo`.
TEST_F(RTCStatsCollectorTest,RTCRemoteOutboundRtpAudioStreamStatsCollected)3015 TEST_F(RTCStatsCollectorTest, RTCRemoteOutboundRtpAudioStreamStatsCollected) {
3016 ExampleStatsGraph graph =
3017 SetupExampleStatsVoiceGraph(/*add_remote_outbound_stats=*/true);
3018 ASSERT_TRUE(graph.full_report->Get(graph.remote_outbound_rtp_id));
3019 const auto& remote_outbound_rtp =
3020 graph.full_report->Get(graph.remote_outbound_rtp_id)
3021 ->cast_to<RTCRemoteOutboundRtpStreamStats>();
3022 EXPECT_EQ(remote_outbound_rtp.timestamp_us(),
3023 kRemoteOutboundStatsTimestampMs * rtc::kNumMicrosecsPerMillisec);
3024 EXPECT_FLOAT_EQ(*remote_outbound_rtp.remote_timestamp,
3025 static_cast<double>(kRemoteOutboundStatsRemoteTimestampMs));
3026 EXPECT_EQ(*remote_outbound_rtp.packets_sent, kRemoteOutboundStatsPacketsSent);
3027 EXPECT_EQ(*remote_outbound_rtp.bytes_sent, kRemoteOutboundStatsBytesSent);
3028 EXPECT_EQ(*remote_outbound_rtp.reports_sent,
3029 kRemoteOutboundStatsReportsCount);
3030 }
3031
TEST_F(RTCStatsCollectorTest,RTCVideoSourceStatsNotCollectedForSenderWithoutTrack)3032 TEST_F(RTCStatsCollectorTest,
3033 RTCVideoSourceStatsNotCollectedForSenderWithoutTrack) {
3034 const uint32_t kSsrc = 4;
3035 const int kAttachmentId = 42;
3036
3037 cricket::VideoMediaInfo video_media_info;
3038 video_media_info.senders.push_back(cricket::VideoSenderInfo());
3039 video_media_info.senders[0].local_stats.push_back(cricket::SsrcSenderInfo());
3040 video_media_info.senders[0].local_stats[0].ssrc = kSsrc;
3041 video_media_info.senders[0].framerate_input = 29;
3042 auto* video_media_channel = pc_->AddVideoChannel("VideoMid", "TransportName");
3043 video_media_channel->SetStats(video_media_info);
3044
3045 rtc::scoped_refptr<MockRtpSenderInternal> sender = CreateMockSender(
3046 cricket::MEDIA_TYPE_VIDEO, /*track=*/nullptr, kSsrc, kAttachmentId, {});
3047 pc_->AddSender(sender);
3048
3049 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
3050 EXPECT_FALSE(report->Get("RTCVideoSource_42"));
3051 }
3052
TEST_F(RTCStatsCollectorTest,GetStatsWithSenderSelector)3053 TEST_F(RTCStatsCollectorTest, GetStatsWithSenderSelector) {
3054 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
3055 // Expected stats graph when filtered by sender:
3056 //
3057 // +--- track (sender)
3058 // | ^
3059 // | |
3060 // | +--------- outbound-rtp
3061 // | | | |
3062 // | | v v
3063 // | | codec (send) transport
3064 // v v
3065 // media-source
3066 rtc::scoped_refptr<const RTCStatsReport> sender_report =
3067 stats_->GetStatsReportWithSenderSelector(graph.sender);
3068 EXPECT_TRUE(sender_report);
3069 EXPECT_EQ(sender_report->timestamp_us(), graph.full_report->timestamp_us());
3070 EXPECT_EQ(sender_report->size(), 5u);
3071 EXPECT_TRUE(sender_report->Get(graph.send_codec_id));
3072 EXPECT_FALSE(sender_report->Get(graph.recv_codec_id));
3073 EXPECT_TRUE(sender_report->Get(graph.outbound_rtp_id));
3074 EXPECT_FALSE(sender_report->Get(graph.inbound_rtp_id));
3075 EXPECT_TRUE(sender_report->Get(graph.transport_id));
3076 EXPECT_TRUE(sender_report->Get(graph.sender_track_id));
3077 EXPECT_FALSE(sender_report->Get(graph.receiver_track_id));
3078 EXPECT_FALSE(sender_report->Get(graph.remote_stream_id));
3079 EXPECT_FALSE(sender_report->Get(graph.peer_connection_id));
3080 EXPECT_TRUE(sender_report->Get(graph.media_source_id));
3081 }
3082
TEST_F(RTCStatsCollectorTest,GetStatsWithReceiverSelector)3083 TEST_F(RTCStatsCollectorTest, GetStatsWithReceiverSelector) {
3084 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
3085 // Expected stats graph when filtered by receiver:
3086 //
3087 // track (receiver)
3088 // ^
3089 // |
3090 // inbound-rtp ---------------+
3091 // | |
3092 // v v
3093 // transport codec (recv)
3094 rtc::scoped_refptr<const RTCStatsReport> receiver_report =
3095 stats_->GetStatsReportWithReceiverSelector(graph.receiver);
3096 EXPECT_TRUE(receiver_report);
3097 EXPECT_EQ(receiver_report->size(), 4u);
3098 EXPECT_EQ(receiver_report->timestamp_us(), graph.full_report->timestamp_us());
3099 EXPECT_FALSE(receiver_report->Get(graph.send_codec_id));
3100 EXPECT_TRUE(receiver_report->Get(graph.recv_codec_id));
3101 EXPECT_FALSE(receiver_report->Get(graph.outbound_rtp_id));
3102 EXPECT_TRUE(receiver_report->Get(graph.inbound_rtp_id));
3103 EXPECT_TRUE(receiver_report->Get(graph.transport_id));
3104 EXPECT_FALSE(receiver_report->Get(graph.sender_track_id));
3105 EXPECT_TRUE(receiver_report->Get(graph.receiver_track_id));
3106 EXPECT_FALSE(receiver_report->Get(graph.remote_stream_id));
3107 EXPECT_FALSE(receiver_report->Get(graph.peer_connection_id));
3108 EXPECT_FALSE(receiver_report->Get(graph.media_source_id));
3109 }
3110
TEST_F(RTCStatsCollectorTest,GetStatsWithNullSenderSelector)3111 TEST_F(RTCStatsCollectorTest, GetStatsWithNullSenderSelector) {
3112 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
3113 rtc::scoped_refptr<const RTCStatsReport> empty_report =
3114 stats_->GetStatsReportWithSenderSelector(nullptr);
3115 EXPECT_TRUE(empty_report);
3116 EXPECT_EQ(empty_report->timestamp_us(), graph.full_report->timestamp_us());
3117 EXPECT_EQ(empty_report->size(), 0u);
3118 }
3119
TEST_F(RTCStatsCollectorTest,GetStatsWithNullReceiverSelector)3120 TEST_F(RTCStatsCollectorTest, GetStatsWithNullReceiverSelector) {
3121 ExampleStatsGraph graph = SetupExampleStatsGraphForSelectorTests();
3122 rtc::scoped_refptr<const RTCStatsReport> empty_report =
3123 stats_->GetStatsReportWithReceiverSelector(nullptr);
3124 EXPECT_TRUE(empty_report);
3125 EXPECT_EQ(empty_report->timestamp_us(), graph.full_report->timestamp_us());
3126 EXPECT_EQ(empty_report->size(), 0u);
3127 }
3128
3129 // When the PC has not had SetLocalDescription done, tracks all have
3130 // SSRC 0, meaning "unconnected".
3131 // In this state, we report on track stats, but not RTP stats.
TEST_F(RTCStatsCollectorTest,StatsReportedOnZeroSsrc)3132 TEST_F(RTCStatsCollectorTest, StatsReportedOnZeroSsrc) {
3133 rtc::scoped_refptr<MediaStreamTrackInterface> track =
3134 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "audioTrack",
3135 MediaStreamTrackInterface::kLive);
3136 rtc::scoped_refptr<MockRtpSenderInternal> sender =
3137 CreateMockSender(cricket::MEDIA_TYPE_AUDIO, track, 0, 49, {});
3138 pc_->AddSender(sender);
3139
3140 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
3141
3142 std::vector<const RTCMediaStreamTrackStats*> track_stats =
3143 report->GetStatsOfType<RTCMediaStreamTrackStats>();
3144 EXPECT_EQ(1U, track_stats.size());
3145
3146 std::vector<const RTCRTPStreamStats*> rtp_stream_stats =
3147 report->GetStatsOfType<RTCRTPStreamStats>();
3148 EXPECT_EQ(0U, rtp_stream_stats.size());
3149 }
3150
TEST_F(RTCStatsCollectorTest,DoNotCrashOnSsrcChange)3151 TEST_F(RTCStatsCollectorTest, DoNotCrashOnSsrcChange) {
3152 rtc::scoped_refptr<MediaStreamTrackInterface> track =
3153 CreateFakeTrack(cricket::MEDIA_TYPE_AUDIO, "audioTrack",
3154 MediaStreamTrackInterface::kLive);
3155 rtc::scoped_refptr<MockRtpSenderInternal> sender =
3156 CreateMockSender(cricket::MEDIA_TYPE_AUDIO, track, 4711, 49, {});
3157 pc_->AddSender(sender);
3158
3159 // We do not generate any matching voice_sender_info stats.
3160 rtc::scoped_refptr<const RTCStatsReport> report = stats_->GetStatsReport();
3161
3162 std::vector<const RTCMediaStreamTrackStats*> track_stats =
3163 report->GetStatsOfType<RTCMediaStreamTrackStats>();
3164 EXPECT_EQ(1U, track_stats.size());
3165 }
3166
3167 // Used for test below, to test calling GetStatsReport during a callback.
3168 class RecursiveCallback : public RTCStatsCollectorCallback {
3169 public:
RecursiveCallback(RTCStatsCollectorWrapper * stats)3170 explicit RecursiveCallback(RTCStatsCollectorWrapper* stats) : stats_(stats) {}
3171
OnStatsDelivered(const rtc::scoped_refptr<const RTCStatsReport> & report)3172 void OnStatsDelivered(
3173 const rtc::scoped_refptr<const RTCStatsReport>& report) override {
3174 stats_->GetStatsReport();
3175 called_ = true;
3176 }
3177
called() const3178 bool called() const { return called_; }
3179
3180 private:
3181 RTCStatsCollectorWrapper* stats_;
3182 bool called_ = false;
3183 };
3184
3185 // Test that nothing bad happens if a callback causes GetStatsReport to be
3186 // called again recursively. Regression test for crbug.com/webrtc/8973.
TEST_F(RTCStatsCollectorTest,DoNotCrashWhenGetStatsCalledDuringCallback)3187 TEST_F(RTCStatsCollectorTest, DoNotCrashWhenGetStatsCalledDuringCallback) {
3188 rtc::scoped_refptr<RecursiveCallback> callback1(
3189 new rtc::RefCountedObject<RecursiveCallback>(stats_.get()));
3190 rtc::scoped_refptr<RecursiveCallback> callback2(
3191 new rtc::RefCountedObject<RecursiveCallback>(stats_.get()));
3192 stats_->stats_collector()->GetStatsReport(callback1);
3193 stats_->stats_collector()->GetStatsReport(callback2);
3194 EXPECT_TRUE_WAIT(callback1->called(), kGetStatsReportTimeoutMs);
3195 EXPECT_TRUE_WAIT(callback2->called(), kGetStatsReportTimeoutMs);
3196 }
3197
3198 class RTCTestStats : public RTCStats {
3199 public:
3200 WEBRTC_RTCSTATS_DECL();
3201
RTCTestStats(const std::string & id,int64_t timestamp_us)3202 RTCTestStats(const std::string& id, int64_t timestamp_us)
3203 : RTCStats(id, timestamp_us), dummy_stat("dummyStat") {}
3204
3205 RTCStatsMember<int32_t> dummy_stat;
3206 };
3207
3208 WEBRTC_RTCSTATS_IMPL(RTCTestStats, RTCStats, "test-stats", &dummy_stat)
3209
3210 // Overrides the stats collection to verify thread usage and that the resulting
3211 // partial reports are merged.
3212 class FakeRTCStatsCollector : public RTCStatsCollector,
3213 public RTCStatsCollectorCallback {
3214 public:
Create(PeerConnectionInternal * pc,int64_t cache_lifetime_us)3215 static rtc::scoped_refptr<FakeRTCStatsCollector> Create(
3216 PeerConnectionInternal* pc,
3217 int64_t cache_lifetime_us) {
3218 return rtc::scoped_refptr<FakeRTCStatsCollector>(
3219 new rtc::RefCountedObject<FakeRTCStatsCollector>(pc,
3220 cache_lifetime_us));
3221 }
3222
3223 // RTCStatsCollectorCallback implementation.
OnStatsDelivered(const rtc::scoped_refptr<const RTCStatsReport> & report)3224 void OnStatsDelivered(
3225 const rtc::scoped_refptr<const RTCStatsReport>& report) override {
3226 EXPECT_TRUE(signaling_thread_->IsCurrent());
3227 MutexLock lock(&lock_);
3228 delivered_report_ = report;
3229 }
3230
VerifyThreadUsageAndResultsMerging()3231 void VerifyThreadUsageAndResultsMerging() {
3232 GetStatsReport(rtc::scoped_refptr<RTCStatsCollectorCallback>(this));
3233 EXPECT_TRUE_WAIT(HasVerifiedResults(), kGetStatsReportTimeoutMs);
3234 }
3235
HasVerifiedResults()3236 bool HasVerifiedResults() {
3237 EXPECT_TRUE(signaling_thread_->IsCurrent());
3238 MutexLock lock(&lock_);
3239 if (!delivered_report_)
3240 return false;
3241 EXPECT_EQ(produced_on_signaling_thread_, 1);
3242 EXPECT_EQ(produced_on_network_thread_, 1);
3243
3244 EXPECT_TRUE(delivered_report_->Get("SignalingThreadStats"));
3245 EXPECT_TRUE(delivered_report_->Get("NetworkThreadStats"));
3246
3247 produced_on_signaling_thread_ = 0;
3248 produced_on_network_thread_ = 0;
3249 delivered_report_ = nullptr;
3250 return true;
3251 }
3252
3253 protected:
FakeRTCStatsCollector(PeerConnectionInternal * pc,int64_t cache_lifetime)3254 FakeRTCStatsCollector(PeerConnectionInternal* pc, int64_t cache_lifetime)
3255 : RTCStatsCollector(pc, cache_lifetime),
3256 signaling_thread_(pc->signaling_thread()),
3257 worker_thread_(pc->worker_thread()),
3258 network_thread_(pc->network_thread()) {}
3259
ProducePartialResultsOnSignalingThreadImpl(int64_t timestamp_us,RTCStatsReport * partial_report)3260 void ProducePartialResultsOnSignalingThreadImpl(
3261 int64_t timestamp_us,
3262 RTCStatsReport* partial_report) override {
3263 EXPECT_TRUE(signaling_thread_->IsCurrent());
3264 {
3265 MutexLock lock(&lock_);
3266 EXPECT_FALSE(delivered_report_);
3267 ++produced_on_signaling_thread_;
3268 }
3269
3270 partial_report->AddStats(std::unique_ptr<const RTCStats>(
3271 new RTCTestStats("SignalingThreadStats", timestamp_us)));
3272 }
ProducePartialResultsOnNetworkThreadImpl(int64_t timestamp_us,const std::map<std::string,cricket::TransportStats> & transport_stats_by_name,const std::map<std::string,CertificateStatsPair> & transport_cert_stats,RTCStatsReport * partial_report)3273 void ProducePartialResultsOnNetworkThreadImpl(
3274 int64_t timestamp_us,
3275 const std::map<std::string, cricket::TransportStats>&
3276 transport_stats_by_name,
3277 const std::map<std::string, CertificateStatsPair>& transport_cert_stats,
3278 RTCStatsReport* partial_report) override {
3279 EXPECT_TRUE(network_thread_->IsCurrent());
3280 {
3281 MutexLock lock(&lock_);
3282 EXPECT_FALSE(delivered_report_);
3283 ++produced_on_network_thread_;
3284 }
3285
3286 partial_report->AddStats(std::unique_ptr<const RTCStats>(
3287 new RTCTestStats("NetworkThreadStats", timestamp_us)));
3288 }
3289
3290 private:
3291 rtc::Thread* const signaling_thread_;
3292 rtc::Thread* const worker_thread_;
3293 rtc::Thread* const network_thread_;
3294
3295 Mutex lock_;
3296 rtc::scoped_refptr<const RTCStatsReport> delivered_report_;
3297 int produced_on_signaling_thread_ = 0;
3298 int produced_on_network_thread_ = 0;
3299 };
3300
TEST(RTCStatsCollectorTestWithFakeCollector,ThreadUsageAndResultsMerging)3301 TEST(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) {
3302 rtc::scoped_refptr<FakePeerConnectionForStats> pc(
3303 new rtc::RefCountedObject<FakePeerConnectionForStats>());
3304 rtc::scoped_refptr<FakeRTCStatsCollector> stats_collector(
3305 FakeRTCStatsCollector::Create(pc, 50 * rtc::kNumMicrosecsPerMillisec));
3306 stats_collector->VerifyThreadUsageAndResultsMerging();
3307 }
3308
3309 } // namespace
3310
3311 } // namespace webrtc
3312