1 /*
2 * Copyright 2014 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/stats_collector.h"
12
13 #include <stdio.h>
14
15 #include <memory>
16
17 #include "absl/algorithm/container.h"
18 #include "absl/types/optional.h"
19 #include "api/audio_codecs/audio_encoder.h"
20 #include "api/candidate.h"
21 #include "api/data_channel_interface.h"
22 #include "api/media_stream_track.h"
23 #include "api/scoped_refptr.h"
24 #include "call/call.h"
25 #include "media/base/media_channel.h"
26 #include "modules/audio_processing/include/audio_processing_statistics.h"
27 #include "pc/media_stream.h"
28 #include "pc/sctp_data_channel.h"
29 #include "pc/test/fake_peer_connection_for_stats.h"
30 #include "pc/test/fake_video_track_source.h"
31 #include "pc/test/mock_rtp_receiver_internal.h"
32 #include "pc/test/mock_rtp_sender_internal.h"
33 #include "pc/transport_stats.h"
34 #include "pc/video_track.h"
35 #include "rtc_base/fake_ssl_identity.h"
36 #include "rtc_base/message_digest.h"
37 #include "rtc_base/net_helper.h"
38 #include "rtc_base/ref_counted_object.h"
39 #include "rtc_base/rtc_certificate.h"
40 #include "rtc_base/socket_address.h"
41 #include "rtc_base/ssl_identity.h"
42 #include "rtc_base/ssl_stream_adapter.h"
43 #include "rtc_base/string_encode.h"
44 #include "rtc_base/third_party/base64/base64.h"
45 #include "rtc_base/thread.h"
46 #include "test/gtest.h"
47
48 using cricket::ConnectionInfo;
49 using cricket::SsrcReceiverInfo;
50 using cricket::TransportChannelStats;
51 using cricket::VideoMediaInfo;
52 using cricket::VideoReceiverInfo;
53 using cricket::VideoSenderInfo;
54 using cricket::VoiceMediaInfo;
55 using cricket::VoiceReceiverInfo;
56 using cricket::VoiceSenderInfo;
57 using ::testing::Return;
58 using ::testing::UnorderedElementsAre;
59
60 namespace webrtc {
61
62 namespace internal {
63 // This value comes from openssl/tls1.h
64 static const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;
65 } // namespace internal
66
67 // Error return values
68 const char kNotFound[] = "NOT FOUND";
69
70 // Constant names for track identification.
71 const char kLocalTrackId[] = "local_track_id";
72 const char kRemoteTrackId[] = "remote_track_id";
73 const uint32_t kSsrcOfTrack = 1234;
74
75 class FakeAudioProcessor : public AudioProcessorInterface {
76 public:
FakeAudioProcessor()77 FakeAudioProcessor() {}
~FakeAudioProcessor()78 ~FakeAudioProcessor() {}
79
80 private:
GetStats(bool has_recv_streams)81 AudioProcessorInterface::AudioProcessorStatistics GetStats(
82 bool has_recv_streams) override {
83 AudioProcessorStatistics stats;
84 stats.typing_noise_detected = true;
85 if (has_recv_streams) {
86 stats.apm_statistics.echo_return_loss = 2.0;
87 stats.apm_statistics.echo_return_loss_enhancement = 3.0;
88 stats.apm_statistics.delay_median_ms = 4;
89 stats.apm_statistics.delay_standard_deviation_ms = 5;
90 }
91 return stats;
92 }
93 };
94
95 class FakeAudioTrack : public MediaStreamTrack<AudioTrackInterface> {
96 public:
FakeAudioTrack(const std::string & id)97 explicit FakeAudioTrack(const std::string& id)
98 : MediaStreamTrack<AudioTrackInterface>(id),
99 processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
kind() const100 std::string kind() const override { return "audio"; }
GetSource() const101 AudioSourceInterface* GetSource() const override { return NULL; }
AddSink(AudioTrackSinkInterface * sink)102 void AddSink(AudioTrackSinkInterface* sink) override {}
RemoveSink(AudioTrackSinkInterface * sink)103 void RemoveSink(AudioTrackSinkInterface* sink) override {}
GetSignalLevel(int * level)104 bool GetSignalLevel(int* level) override {
105 *level = 1;
106 return true;
107 }
GetAudioProcessor()108 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
109 return processor_;
110 }
111
112 private:
113 rtc::scoped_refptr<FakeAudioProcessor> processor_;
114 };
115
116 // This fake audio processor is used to verify that the undesired initial values
117 // (-1) will be filtered out.
118 class FakeAudioProcessorWithInitValue : public AudioProcessorInterface {
119 public:
FakeAudioProcessorWithInitValue()120 FakeAudioProcessorWithInitValue() {}
~FakeAudioProcessorWithInitValue()121 ~FakeAudioProcessorWithInitValue() {}
122
123 private:
GetStats(bool)124 AudioProcessorInterface::AudioProcessorStatistics GetStats(
125 bool /*has_recv_streams*/) override {
126 AudioProcessorStatistics stats;
127 stats.typing_noise_detected = false;
128 return stats;
129 }
130 };
131
132 class FakeAudioTrackWithInitValue
133 : public MediaStreamTrack<AudioTrackInterface> {
134 public:
FakeAudioTrackWithInitValue(const std::string & id)135 explicit FakeAudioTrackWithInitValue(const std::string& id)
136 : MediaStreamTrack<AudioTrackInterface>(id),
137 processor_(
138 new rtc::RefCountedObject<FakeAudioProcessorWithInitValue>()) {}
kind() const139 std::string kind() const override { return "audio"; }
GetSource() const140 AudioSourceInterface* GetSource() const override { return NULL; }
AddSink(AudioTrackSinkInterface * sink)141 void AddSink(AudioTrackSinkInterface* sink) override {}
RemoveSink(AudioTrackSinkInterface * sink)142 void RemoveSink(AudioTrackSinkInterface* sink) override {}
GetSignalLevel(int * level)143 bool GetSignalLevel(int* level) override {
144 *level = 1;
145 return true;
146 }
GetAudioProcessor()147 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
148 return processor_;
149 }
150
151 private:
152 rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_;
153 };
154
GetValue(const StatsReport * report,StatsReport::StatsValueName name,std::string * value)155 bool GetValue(const StatsReport* report,
156 StatsReport::StatsValueName name,
157 std::string* value) {
158 const StatsReport::Value* v = report->FindValue(name);
159 if (!v)
160 return false;
161 *value = v->ToString();
162 return true;
163 }
164
ExtractStatsValue(const StatsReport::StatsType & type,const StatsReports & reports,StatsReport::StatsValueName name)165 std::string ExtractStatsValue(const StatsReport::StatsType& type,
166 const StatsReports& reports,
167 StatsReport::StatsValueName name) {
168 for (const auto* r : reports) {
169 std::string ret;
170 if (r->type() == type && GetValue(r, name, &ret))
171 return ret;
172 }
173
174 return kNotFound;
175 }
176
TypedIdFromIdString(StatsReport::StatsType type,const std::string & value)177 StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type,
178 const std::string& value) {
179 EXPECT_FALSE(value.empty());
180 StatsReport::Id id;
181 if (value.empty())
182 return id;
183
184 // This has assumptions about how the ID is constructed. As is, this is
185 // OK since this is for testing purposes only, but if we ever need this
186 // in production, we should add a generic method that does this.
187 size_t index = value.find('_');
188 EXPECT_NE(index, std::string::npos);
189 if (index == std::string::npos || index == (value.length() - 1))
190 return id;
191
192 id = StatsReport::NewTypedId(type, value.substr(index + 1));
193 EXPECT_EQ(id->ToString(), value);
194 return id;
195 }
196
IdFromCertIdString(const std::string & cert_id)197 StatsReport::Id IdFromCertIdString(const std::string& cert_id) {
198 return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id);
199 }
200
201 // Finds the |n|-th report of type |type| in |reports|.
202 // |n| starts from 1 for finding the first report.
FindNthReportByType(const StatsReports & reports,const StatsReport::StatsType & type,int n)203 const StatsReport* FindNthReportByType(const StatsReports& reports,
204 const StatsReport::StatsType& type,
205 int n) {
206 for (size_t i = 0; i < reports.size(); ++i) {
207 if (reports[i]->type() == type) {
208 n--;
209 if (n == 0)
210 return reports[i];
211 }
212 }
213 return nullptr;
214 }
215
216 // Returns the value of the stat identified by |name| in the |n|-th report of
217 // type |type| in |reports|.
218 // |n| starts from 1 for finding the first report.
219 // If either the |n|-th report is not found, or the stat is not present in that
220 // report, then nullopt is returned.
GetValueInNthReportByType(const StatsReports & reports,StatsReport::StatsType type,StatsReport::StatsValueName name,int n)221 absl::optional<std::string> GetValueInNthReportByType(
222 const StatsReports& reports,
223 StatsReport::StatsType type,
224 StatsReport::StatsValueName name,
225 int n) {
226 const StatsReport* report = FindNthReportByType(reports, type, n);
227 if (!report) {
228 return absl::nullopt;
229 }
230 std::string value;
231 if (!GetValue(report, name, &value)) {
232 return absl::nullopt;
233 }
234 return value;
235 }
236
GetReportsByType(const StatsReports & reports,StatsReport::StatsType type)237 std::vector<const StatsReport*> GetReportsByType(const StatsReports& reports,
238 StatsReport::StatsType type) {
239 std::vector<const StatsReport*> filtered_reports;
240 for (const StatsReport* report : reports) {
241 if (report->type() == type) {
242 filtered_reports.push_back(report);
243 }
244 }
245 return filtered_reports;
246 }
247
FindReportById(const StatsReports & reports,const StatsReport::Id & id)248 const StatsReport* FindReportById(const StatsReports& reports,
249 const StatsReport::Id& id) {
250 for (const auto* r : reports) {
251 if (r->id()->Equals(id))
252 return r;
253 }
254 return nullptr;
255 }
256
ExtractSsrcStatsValue(const StatsReports & reports,StatsReport::StatsValueName name)257 std::string ExtractSsrcStatsValue(const StatsReports& reports,
258 StatsReport::StatsValueName name) {
259 return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name);
260 }
261
ExtractBweStatsValue(const StatsReports & reports,StatsReport::StatsValueName name)262 std::string ExtractBweStatsValue(const StatsReports& reports,
263 StatsReport::StatsValueName name) {
264 return ExtractStatsValue(StatsReport::kStatsReportTypeBwe, reports, name);
265 }
266
DerToPem(const std::string & der)267 std::string DerToPem(const std::string& der) {
268 return rtc::SSLIdentity::DerToPem(
269 rtc::kPemTypeCertificate,
270 reinterpret_cast<const unsigned char*>(der.c_str()), der.length());
271 }
272
DersToPems(const std::vector<std::string> & ders)273 std::vector<std::string> DersToPems(const std::vector<std::string>& ders) {
274 std::vector<std::string> pems(ders.size());
275 absl::c_transform(ders, pems.begin(), DerToPem);
276 return pems;
277 }
278
CheckCertChainReports(const StatsReports & reports,const std::vector<std::string> & ders,const StatsReport::Id & start_id)279 void CheckCertChainReports(const StatsReports& reports,
280 const std::vector<std::string>& ders,
281 const StatsReport::Id& start_id) {
282 StatsReport::Id cert_id;
283 const StatsReport::Id* certificate_id = &start_id;
284 size_t i = 0;
285 while (true) {
286 const StatsReport* report = FindReportById(reports, *certificate_id);
287 ASSERT_TRUE(report != NULL);
288
289 std::string der_base64;
290 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDer, &der_base64));
291 std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
292 EXPECT_EQ(ders[i], der);
293
294 std::string fingerprint_algorithm;
295 EXPECT_TRUE(GetValue(report,
296 StatsReport::kStatsValueNameFingerprintAlgorithm,
297 &fingerprint_algorithm));
298 // The digest algorithm for a FakeSSLCertificate is always SHA-1.
299 std::string sha_1_str = rtc::DIGEST_SHA_1;
300 EXPECT_EQ(sha_1_str, fingerprint_algorithm);
301
302 std::string fingerprint;
303 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint,
304 &fingerprint));
305 EXPECT_FALSE(fingerprint.empty());
306
307 ++i;
308 std::string issuer_id;
309 if (!GetValue(report, StatsReport::kStatsValueNameIssuerId, &issuer_id)) {
310 break;
311 }
312
313 cert_id = IdFromCertIdString(issuer_id);
314 certificate_id = &cert_id;
315 }
316 EXPECT_EQ(ders.size(), i);
317 }
318
VerifyVoiceReceiverInfoReport(const StatsReport * report,const cricket::VoiceReceiverInfo & info)319 void VerifyVoiceReceiverInfoReport(const StatsReport* report,
320 const cricket::VoiceReceiverInfo& info) {
321 std::string value_in_report;
322 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioOutputLevel,
323 &value_in_report));
324 EXPECT_EQ(rtc::ToString(info.audio_level), value_in_report);
325 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesReceived,
326 &value_in_report));
327 EXPECT_EQ(rtc::ToString(info.payload_bytes_rcvd +
328 info.header_and_padding_bytes_rcvd),
329 value_in_report);
330 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
331 &value_in_report));
332 EXPECT_EQ(rtc::ToString(info.jitter_ms), value_in_report);
333 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterBufferMs,
334 &value_in_report));
335 EXPECT_EQ(rtc::ToString(info.jitter_buffer_ms), value_in_report);
336 EXPECT_TRUE(GetValue(report,
337 StatsReport::kStatsValueNamePreferredJitterBufferMs,
338 &value_in_report));
339 EXPECT_EQ(rtc::ToString(info.jitter_buffer_preferred_ms), value_in_report);
340 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCurrentDelayMs,
341 &value_in_report));
342 EXPECT_EQ(rtc::ToString(info.delay_estimate_ms), value_in_report);
343 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameExpandRate,
344 &value_in_report));
345 EXPECT_EQ(rtc::ToString(info.expand_rate), value_in_report);
346 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSpeechExpandRate,
347 &value_in_report));
348 EXPECT_EQ(rtc::ToString(info.speech_expand_rate), value_in_report);
349 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,
350 &value_in_report));
351 EXPECT_EQ(rtc::ToString(info.accelerate_rate), value_in_report);
352 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate,
353 &value_in_report));
354 EXPECT_EQ(rtc::ToString(info.preemptive_expand_rate), value_in_report);
355 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate,
356 &value_in_report));
357 EXPECT_EQ(rtc::ToString(info.secondary_decoded_rate), value_in_report);
358 EXPECT_TRUE(GetValue(report,
359 StatsReport::kStatsValueNameSecondaryDiscardedRate,
360 &value_in_report));
361 EXPECT_EQ(rtc::ToString(info.secondary_discarded_rate), value_in_report);
362 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsReceived,
363 &value_in_report));
364 EXPECT_EQ(rtc::ToString(info.packets_rcvd), value_in_report);
365 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTSG,
366 &value_in_report));
367 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_silence_generator),
368 value_in_report);
369 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTN,
370 &value_in_report));
371 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_neteq), value_in_report);
372 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingNormal,
373 &value_in_report));
374 EXPECT_EQ(rtc::ToString(info.decoding_normal), value_in_report);
375 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLC,
376 &value_in_report));
377 EXPECT_EQ(rtc::ToString(info.decoding_plc), value_in_report);
378 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCodecPLC,
379 &value_in_report));
380 EXPECT_EQ(rtc::ToString(info.decoding_codec_plc), value_in_report);
381 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCNG,
382 &value_in_report));
383 EXPECT_EQ(rtc::ToString(info.decoding_cng), value_in_report);
384 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLCCNG,
385 &value_in_report));
386 EXPECT_EQ(rtc::ToString(info.decoding_plc_cng), value_in_report);
387 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput,
388 &value_in_report));
389 EXPECT_EQ(rtc::ToString(info.decoding_muted_output), value_in_report);
390 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
391 &value_in_report));
392 }
393
VerifyVoiceSenderInfoReport(const StatsReport * report,const cricket::VoiceSenderInfo & sinfo)394 void VerifyVoiceSenderInfoReport(const StatsReport* report,
395 const cricket::VoiceSenderInfo& sinfo) {
396 std::string value_in_report;
397 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
398 &value_in_report));
399 EXPECT_EQ(sinfo.codec_name, value_in_report);
400 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesSent,
401 &value_in_report));
402 EXPECT_EQ(rtc::ToString(sinfo.payload_bytes_sent +
403 sinfo.header_and_padding_bytes_sent),
404 value_in_report);
405 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsSent,
406 &value_in_report));
407 EXPECT_EQ(rtc::ToString(sinfo.packets_sent), value_in_report);
408 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
409 &value_in_report));
410 EXPECT_EQ(rtc::ToString(sinfo.packets_lost), value_in_report);
411 EXPECT_TRUE(
412 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
413 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
414 EXPECT_TRUE(
415 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
416 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
417 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
418 &value_in_report));
419 EXPECT_EQ(rtc::ToString(sinfo.jitter_ms), value_in_report);
420 if (sinfo.apm_statistics.delay_median_ms) {
421 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
422 &value_in_report));
423 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_median_ms),
424 value_in_report);
425 } else {
426 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
427 &value_in_report));
428 }
429 if (sinfo.apm_statistics.delay_standard_deviation_ms) {
430 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
431 &value_in_report));
432 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_standard_deviation_ms),
433 value_in_report);
434 } else {
435 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
436 &value_in_report));
437 }
438 if (sinfo.apm_statistics.echo_return_loss) {
439 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
440 &value_in_report));
441 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss),
442 value_in_report);
443 } else {
444 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
445 &value_in_report));
446 }
447 if (sinfo.apm_statistics.echo_return_loss_enhancement) {
448 EXPECT_TRUE(GetValue(report,
449 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
450 &value_in_report));
451 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss_enhancement),
452 value_in_report);
453 } else {
454 EXPECT_FALSE(GetValue(report,
455 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
456 &value_in_report));
457 }
458 if (sinfo.apm_statistics.residual_echo_likelihood) {
459 EXPECT_TRUE(GetValue(report,
460 StatsReport::kStatsValueNameResidualEchoLikelihood,
461 &value_in_report));
462 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.residual_echo_likelihood),
463 value_in_report);
464 } else {
465 EXPECT_FALSE(GetValue(report,
466 StatsReport::kStatsValueNameResidualEchoLikelihood,
467 &value_in_report));
468 }
469 if (sinfo.apm_statistics.residual_echo_likelihood_recent_max) {
470 EXPECT_TRUE(GetValue(
471 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
472 &value_in_report));
473 EXPECT_EQ(rtc::ToString(
474 *sinfo.apm_statistics.residual_echo_likelihood_recent_max),
475 value_in_report);
476 } else {
477 EXPECT_FALSE(GetValue(
478 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
479 &value_in_report));
480 }
481 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
482 &value_in_report));
483 EXPECT_EQ(rtc::ToString(sinfo.audio_level), value_in_report);
484 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameTypingNoiseState,
485 &value_in_report));
486 std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
487 EXPECT_EQ(typing_detected, value_in_report);
488 EXPECT_TRUE(GetValue(report,
489 StatsReport::kStatsValueNameAnaBitrateActionCounter,
490 &value_in_report));
491 ASSERT_TRUE(sinfo.ana_statistics.bitrate_action_counter);
492 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.bitrate_action_counter),
493 value_in_report);
494 EXPECT_TRUE(GetValue(report,
495 StatsReport::kStatsValueNameAnaChannelActionCounter,
496 &value_in_report));
497 ASSERT_TRUE(sinfo.ana_statistics.channel_action_counter);
498 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.channel_action_counter),
499 value_in_report);
500 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaDtxActionCounter,
501 &value_in_report));
502 ASSERT_TRUE(sinfo.ana_statistics.dtx_action_counter);
503 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.dtx_action_counter),
504 value_in_report);
505 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaFecActionCounter,
506 &value_in_report));
507 ASSERT_TRUE(sinfo.ana_statistics.fec_action_counter);
508 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.fec_action_counter),
509 value_in_report);
510 EXPECT_TRUE(GetValue(
511 report, StatsReport::kStatsValueNameAnaFrameLengthIncreaseCounter,
512 &value_in_report));
513 ASSERT_TRUE(sinfo.ana_statistics.frame_length_increase_counter);
514 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_increase_counter),
515 value_in_report);
516 EXPECT_TRUE(GetValue(
517 report, StatsReport::kStatsValueNameAnaFrameLengthDecreaseCounter,
518 &value_in_report));
519 ASSERT_TRUE(sinfo.ana_statistics.frame_length_decrease_counter);
520 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_decrease_counter),
521 value_in_report);
522 EXPECT_TRUE(GetValue(report,
523 StatsReport::kStatsValueNameAnaUplinkPacketLossFraction,
524 &value_in_report));
525 ASSERT_TRUE(sinfo.ana_statistics.uplink_packet_loss_fraction);
526 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.uplink_packet_loss_fraction),
527 value_in_report);
528 }
529
530 // Helper methods to avoid duplication of code.
InitVoiceSenderInfo(cricket::VoiceSenderInfo * voice_sender_info,uint32_t ssrc=kSsrcOfTrack)531 void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info,
532 uint32_t ssrc = kSsrcOfTrack) {
533 voice_sender_info->add_ssrc(ssrc);
534 voice_sender_info->codec_name = "fake_codec";
535 voice_sender_info->payload_bytes_sent = 88;
536 voice_sender_info->header_and_padding_bytes_sent = 12;
537 voice_sender_info->packets_sent = 101;
538 voice_sender_info->rtt_ms = 102;
539 voice_sender_info->fraction_lost = 103;
540 voice_sender_info->jitter_ms = 104;
541 voice_sender_info->packets_lost = 105;
542 voice_sender_info->audio_level = 107;
543 voice_sender_info->apm_statistics.echo_return_loss = 108;
544 voice_sender_info->apm_statistics.echo_return_loss_enhancement = 109;
545 voice_sender_info->apm_statistics.delay_median_ms = 110;
546 voice_sender_info->apm_statistics.delay_standard_deviation_ms = 111;
547 voice_sender_info->typing_noise_detected = false;
548 voice_sender_info->ana_statistics.bitrate_action_counter = 112;
549 voice_sender_info->ana_statistics.channel_action_counter = 113;
550 voice_sender_info->ana_statistics.dtx_action_counter = 114;
551 voice_sender_info->ana_statistics.fec_action_counter = 115;
552 voice_sender_info->ana_statistics.frame_length_increase_counter = 116;
553 voice_sender_info->ana_statistics.frame_length_decrease_counter = 117;
554 voice_sender_info->ana_statistics.uplink_packet_loss_fraction = 118.0;
555 }
556
UpdateVoiceSenderInfoFromAudioTrack(AudioTrackInterface * audio_track,cricket::VoiceSenderInfo * voice_sender_info,bool has_remote_tracks)557 void UpdateVoiceSenderInfoFromAudioTrack(
558 AudioTrackInterface* audio_track,
559 cricket::VoiceSenderInfo* voice_sender_info,
560 bool has_remote_tracks) {
561 audio_track->GetSignalLevel(&voice_sender_info->audio_level);
562 AudioProcessorInterface::AudioProcessorStatistics audio_processor_stats =
563 audio_track->GetAudioProcessor()->GetStats(has_remote_tracks);
564 voice_sender_info->typing_noise_detected =
565 audio_processor_stats.typing_noise_detected;
566 voice_sender_info->apm_statistics = audio_processor_stats.apm_statistics;
567 }
568
InitVoiceReceiverInfo(cricket::VoiceReceiverInfo * voice_receiver_info)569 void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) {
570 voice_receiver_info->add_ssrc(kSsrcOfTrack);
571 voice_receiver_info->payload_bytes_rcvd = 98;
572 voice_receiver_info->header_and_padding_bytes_rcvd = 12;
573 voice_receiver_info->packets_rcvd = 111;
574 voice_receiver_info->packets_lost = 114;
575 voice_receiver_info->jitter_ms = 116;
576 voice_receiver_info->jitter_buffer_ms = 117;
577 voice_receiver_info->jitter_buffer_preferred_ms = 118;
578 voice_receiver_info->delay_estimate_ms = 119;
579 voice_receiver_info->audio_level = 120;
580 voice_receiver_info->expand_rate = 121;
581 voice_receiver_info->speech_expand_rate = 122;
582 voice_receiver_info->secondary_decoded_rate = 123;
583 voice_receiver_info->accelerate_rate = 124;
584 voice_receiver_info->preemptive_expand_rate = 125;
585 voice_receiver_info->secondary_discarded_rate = 126;
586 voice_receiver_info->decoding_codec_plc = 127;
587 }
588
589 class StatsCollectorForTest : public StatsCollector {
590 public:
StatsCollectorForTest(PeerConnectionInternal * pc)591 explicit StatsCollectorForTest(PeerConnectionInternal* pc)
592 : StatsCollector(pc), time_now_(19477) {}
593
GetTimeNow()594 double GetTimeNow() override { return time_now_; }
595
596 private:
597 double time_now_;
598 };
599
600 class StatsCollectorTest : public ::testing::Test {
601 protected:
CreatePeerConnection()602 rtc::scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() {
603 return new rtc::RefCountedObject<FakePeerConnectionForStats>();
604 }
605
CreateStatsCollector(PeerConnectionInternal * pc)606 std::unique_ptr<StatsCollectorForTest> CreateStatsCollector(
607 PeerConnectionInternal* pc) {
608 return std::make_unique<StatsCollectorForTest>(pc);
609 }
610
VerifyAudioTrackStats(FakeAudioTrack * audio_track,StatsCollectorForTest * stats,const VoiceMediaInfo & voice_info,StatsReports * reports)611 void VerifyAudioTrackStats(FakeAudioTrack* audio_track,
612 StatsCollectorForTest* stats,
613 const VoiceMediaInfo& voice_info,
614 StatsReports* reports) {
615 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
616 stats->ClearUpdateStatsCacheForTest();
617 stats->GetStats(nullptr, reports);
618
619 // Verify the existence of the track report.
620 const StatsReport* report =
621 FindNthReportByType(*reports, StatsReport::kStatsReportTypeSsrc, 1);
622 ASSERT_TRUE(report);
623 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
624 std::string track_id =
625 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameTrackId);
626 EXPECT_EQ(audio_track->id(), track_id);
627 std::string ssrc_id =
628 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameSsrc);
629 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
630
631 std::string media_type =
632 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameMediaType);
633 EXPECT_EQ("audio", media_type);
634
635 // Verifies the values in the track report.
636 if (!voice_info.senders.empty()) {
637 VerifyVoiceSenderInfoReport(report, voice_info.senders[0]);
638 }
639 if (!voice_info.receivers.empty()) {
640 VerifyVoiceReceiverInfoReport(report, voice_info.receivers[0]);
641 }
642
643 // Verify we get the same result by passing a track to GetStats().
644 StatsReports track_reports; // returned values.
645 stats->GetStats(audio_track, &track_reports);
646 const StatsReport* track_report = FindNthReportByType(
647 track_reports, StatsReport::kStatsReportTypeSsrc, 1);
648 ASSERT_TRUE(track_report);
649 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
650 track_id = ExtractSsrcStatsValue(track_reports,
651 StatsReport::kStatsValueNameTrackId);
652 EXPECT_EQ(audio_track->id(), track_id);
653 ssrc_id =
654 ExtractSsrcStatsValue(track_reports, StatsReport::kStatsValueNameSsrc);
655 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
656 if (!voice_info.senders.empty()) {
657 VerifyVoiceSenderInfoReport(track_report, voice_info.senders[0]);
658 }
659 if (!voice_info.receivers.empty()) {
660 VerifyVoiceReceiverInfoReport(track_report, voice_info.receivers[0]);
661 }
662 }
663
TestCertificateReports(const rtc::FakeSSLIdentity & local_identity,const std::vector<std::string> & local_ders,const rtc::FakeSSLIdentity & remote_identity,const std::vector<std::string> & remote_ders)664 void TestCertificateReports(const rtc::FakeSSLIdentity& local_identity,
665 const std::vector<std::string>& local_ders,
666 const rtc::FakeSSLIdentity& remote_identity,
667 const std::vector<std::string>& remote_ders) {
668 const std::string kTransportName = "transport";
669
670 auto pc = CreatePeerConnection();
671 auto stats = CreateStatsCollector(pc);
672
673 pc->AddVoiceChannel("audio", kTransportName);
674
675 // Fake stats to process.
676 TransportChannelStats channel_stats;
677 channel_stats.component = 1;
678 channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
679 channel_stats.ssl_cipher_suite =
680 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
681 pc->SetTransportStats(kTransportName, channel_stats);
682
683 // Fake certificate to report.
684 rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
685 rtc::RTCCertificate::Create(local_identity.Clone()));
686 pc->SetLocalCertificate(kTransportName, local_certificate);
687 pc->SetRemoteCertChain(kTransportName,
688 remote_identity.cert_chain().Clone());
689
690 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
691
692 StatsReports reports;
693 stats->GetStats(nullptr, &reports);
694
695 const StatsReport* channel_report =
696 FindNthReportByType(reports, StatsReport::kStatsReportTypeComponent, 1);
697 EXPECT_TRUE(channel_report);
698
699 // Check local certificate chain.
700 std::string local_certificate_id =
701 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
702 StatsReport::kStatsValueNameLocalCertificateId);
703 if (local_ders.size() > 0) {
704 EXPECT_NE(kNotFound, local_certificate_id);
705 StatsReport::Id id(IdFromCertIdString(local_certificate_id));
706 CheckCertChainReports(reports, local_ders, id);
707 } else {
708 EXPECT_EQ(kNotFound, local_certificate_id);
709 }
710
711 // Check remote certificate chain.
712 std::string remote_certificate_id =
713 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
714 StatsReport::kStatsValueNameRemoteCertificateId);
715 if (remote_ders.size() > 0) {
716 EXPECT_NE(kNotFound, remote_certificate_id);
717 StatsReport::Id id(IdFromCertIdString(remote_certificate_id));
718 CheckCertChainReports(reports, remote_ders, id);
719 } else {
720 EXPECT_EQ(kNotFound, remote_certificate_id);
721 }
722
723 // Check negotiated ciphers.
724 std::string dtls_cipher_suite =
725 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
726 StatsReport::kStatsValueNameDtlsCipher);
727 EXPECT_EQ(rtc::SSLStreamAdapter::SslCipherSuiteToName(
728 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
729 dtls_cipher_suite);
730 std::string srtp_crypto_suite =
731 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
732 StatsReport::kStatsValueNameSrtpCipher);
733 EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::SRTP_AES128_CM_SHA1_80),
734 srtp_crypto_suite);
735 }
736 };
737
CreateMockSender(rtc::scoped_refptr<MediaStreamTrackInterface> track,uint32_t ssrc)738 static rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
739 rtc::scoped_refptr<MediaStreamTrackInterface> track,
740 uint32_t ssrc) {
741 rtc::scoped_refptr<MockRtpSenderInternal> sender(
742 new rtc::RefCountedObject<MockRtpSenderInternal>());
743 EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
744 EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
745 EXPECT_CALL(*sender, media_type())
746 .WillRepeatedly(
747 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
748 ? cricket::MEDIA_TYPE_AUDIO
749 : cricket::MEDIA_TYPE_VIDEO));
750 return sender;
751 }
752
CreateMockReceiver(rtc::scoped_refptr<MediaStreamTrackInterface> track,uint32_t ssrc)753 static rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
754 rtc::scoped_refptr<MediaStreamTrackInterface> track,
755 uint32_t ssrc) {
756 rtc::scoped_refptr<MockRtpReceiverInternal> receiver(
757 new rtc::RefCountedObject<MockRtpReceiverInternal>());
758 EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
759 EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Return(ssrc));
760 EXPECT_CALL(*receiver, media_type())
761 .WillRepeatedly(
762 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
763 ? cricket::MEDIA_TYPE_AUDIO
764 : cricket::MEDIA_TYPE_VIDEO));
765 return receiver;
766 }
767
768 class StatsCollectorTrackTest : public StatsCollectorTest,
769 public ::testing::WithParamInterface<bool> {
770 public:
771 // Adds a outgoing video track with a given SSRC into the stats.
772 // If GetParam() returns true, the track is also inserted into the local
773 // stream, which is created if necessary.
AddOutgoingVideoTrack(FakePeerConnectionForStats * pc,StatsCollectorForTest * stats)774 void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
775 StatsCollectorForTest* stats) {
776 track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(),
777 rtc::Thread::Current());
778 if (GetParam()) {
779 if (!stream_)
780 stream_ = MediaStream::Create("streamid");
781 stream_->AddTrack(track_);
782 stats->AddStream(stream_);
783 } else {
784 stats->AddTrack(track_);
785 }
786 pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
787 }
788
789 // Adds a incoming video track with a given SSRC into the stats.
AddIncomingVideoTrack(FakePeerConnectionForStats * pc,StatsCollectorForTest * stats)790 void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
791 StatsCollectorForTest* stats) {
792 track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(),
793 rtc::Thread::Current());
794 if (GetParam()) {
795 stream_ = MediaStream::Create("streamid");
796 stream_->AddTrack(track_);
797 stats->AddStream(stream_);
798 } else {
799 stats->AddTrack(track_);
800 }
801 pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
802 }
803
804 // Adds a outgoing audio track with a given SSRC into the stats,
805 // and register it into the stats object.
806 // If GetParam() returns true, the track is also inserted into the local
807 // stream, which is created if necessary.
AddOutgoingAudioTrack(FakePeerConnectionForStats * pc,StatsCollectorForTest * stats)808 rtc::scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack(
809 FakePeerConnectionForStats* pc,
810 StatsCollectorForTest* stats) {
811 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(kLocalTrackId);
812 if (GetParam()) {
813 if (!stream_)
814 stream_ = MediaStream::Create("streamid");
815 stream_->AddTrack(audio_track_);
816 stats->AddStream(stream_);
817 } else {
818 stats->AddTrack(audio_track_);
819 }
820 return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack));
821 }
822
823 // Adds a incoming audio track with a given SSRC into the stats.
AddIncomingAudioTrack(FakePeerConnectionForStats * pc,StatsCollectorForTest * stats)824 void AddIncomingAudioTrack(FakePeerConnectionForStats* pc,
825 StatsCollectorForTest* stats) {
826 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId);
827 if (GetParam()) {
828 if (stream_ == NULL)
829 stream_ = MediaStream::Create("streamid");
830 stream_->AddTrack(audio_track_);
831 stats->AddStream(stream_);
832 } else {
833 stats->AddTrack(audio_track_);
834 }
835 pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
836 }
837
838 rtc::scoped_refptr<MediaStream> stream_;
839 rtc::scoped_refptr<VideoTrack> track_;
840 rtc::scoped_refptr<FakeAudioTrack> audio_track_;
841 };
842
TEST_F(StatsCollectorTest,FilterOutNegativeDataChannelId)843 TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {
844 auto pc = CreatePeerConnection();
845 auto stats = CreateStatsCollector(pc);
846
847 pc->AddSctpDataChannel("hacks");
848
849 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
850 StatsReports reports;
851 stats->GetStats(nullptr, &reports);
852
853 const StatsReport* report =
854 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
855
856 std::string value_in_report;
857 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,
858 &value_in_report));
859 }
860
861 // Verify that ExtractDataInfo populates reports.
TEST_F(StatsCollectorTest,ExtractDataInfo)862 TEST_F(StatsCollectorTest, ExtractDataInfo) {
863 const std::string kDataChannelLabel = "hacks";
864 constexpr int kDataChannelId = 31337;
865 const std::string kConnectingString = DataChannelInterface::DataStateString(
866 DataChannelInterface::DataState::kConnecting);
867
868 auto pc = CreatePeerConnection();
869 auto stats = CreateStatsCollector(pc);
870
871 InternalDataChannelInit init;
872 init.id = kDataChannelId;
873 pc->AddSctpDataChannel(kDataChannelLabel, init);
874
875 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
876 StatsReports reports;
877 stats->GetStats(nullptr, &reports);
878
879 const StatsReport* report =
880 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
881
882 StatsReport::Id report_id = StatsReport::NewTypedIntId(
883 StatsReport::kStatsReportTypeDataChannel, kDataChannelId);
884
885 EXPECT_TRUE(report_id->Equals(report->id()));
886
887 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
888 EXPECT_EQ(kDataChannelLabel,
889 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
890 StatsReport::kStatsValueNameLabel));
891 EXPECT_EQ(rtc::ToString(kDataChannelId),
892 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
893 StatsReport::kStatsValueNameDataChannelId));
894 EXPECT_EQ(kConnectingString,
895 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
896 StatsReport::kStatsValueNameState));
897 EXPECT_EQ("",
898 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
899 StatsReport::kStatsValueNameProtocol));
900 }
901
902 // This test verifies that 64-bit counters are passed successfully.
TEST_P(StatsCollectorTrackTest,BytesCounterHandles64Bits)903 TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
904 // The number of bytes must be larger than 0xFFFFFFFF for this test.
905 constexpr int64_t kBytesSent = 12345678901234LL;
906
907 auto pc = CreatePeerConnection();
908 auto stats = CreateStatsCollector(pc);
909
910 VideoSenderInfo video_sender_info;
911 video_sender_info.add_ssrc(1234);
912 video_sender_info.payload_bytes_sent = kBytesSent;
913 video_sender_info.header_and_padding_bytes_sent = 0;
914 VideoMediaInfo video_info;
915 video_info.aggregated_senders.push_back(video_sender_info);
916
917 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
918 video_media_channel->SetStats(video_info);
919
920 AddOutgoingVideoTrack(pc, stats.get());
921
922 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
923 StatsReports reports;
924 stats->GetStats(nullptr, &reports);
925
926 EXPECT_EQ(
927 rtc::ToString(kBytesSent),
928 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
929 }
930
931 // Test that audio BWE information is reported via stats.
TEST_P(StatsCollectorTrackTest,AudioBandwidthEstimationInfoIsReported)932 TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) {
933 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
934 // BWE.
935 constexpr int64_t kBytesSent = 12345678901234LL;
936 constexpr int kSendBandwidth = 1234567;
937 constexpr int kRecvBandwidth = 12345678;
938 constexpr int kPacerDelay = 123;
939
940 auto pc = CreatePeerConnection();
941 auto stats = CreateStatsCollector(pc);
942
943 VoiceSenderInfo voice_sender_info;
944 voice_sender_info.add_ssrc(1234);
945 voice_sender_info.payload_bytes_sent = kBytesSent - 12;
946 voice_sender_info.header_and_padding_bytes_sent = 12;
947 VoiceMediaInfo voice_info;
948 voice_info.senders.push_back(voice_sender_info);
949
950 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
951 voice_media_channel->SetStats(voice_info);
952
953 AddOutgoingAudioTrack(pc, stats.get());
954
955 Call::Stats call_stats;
956 call_stats.send_bandwidth_bps = kSendBandwidth;
957 call_stats.recv_bandwidth_bps = kRecvBandwidth;
958 call_stats.pacer_delay_ms = kPacerDelay;
959 pc->SetCallStats(call_stats);
960
961 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
962 StatsReports reports;
963 stats->GetStats(nullptr, &reports);
964
965 EXPECT_EQ(
966 rtc::ToString(kBytesSent),
967 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
968 EXPECT_EQ(rtc::ToString(kSendBandwidth),
969 ExtractBweStatsValue(
970 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
971 EXPECT_EQ(
972 rtc::ToString(kRecvBandwidth),
973 ExtractBweStatsValue(
974 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
975 EXPECT_EQ(
976 rtc::ToString(kPacerDelay),
977 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
978 }
979
980 // Test that video BWE information is reported via stats.
TEST_P(StatsCollectorTrackTest,VideoBandwidthEstimationInfoIsReported)981 TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
982 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
983 // BWE.
984 constexpr int64_t kBytesSent = 12345678901234LL;
985 constexpr int kSendBandwidth = 1234567;
986 constexpr int kRecvBandwidth = 12345678;
987 constexpr int kPacerDelay = 123;
988
989 auto pc = CreatePeerConnection();
990 auto stats = CreateStatsCollector(pc);
991
992 VideoSenderInfo video_sender_info;
993 video_sender_info.add_ssrc(1234);
994 video_sender_info.payload_bytes_sent = kBytesSent - 12;
995 video_sender_info.header_and_padding_bytes_sent = 12;
996
997 VideoMediaInfo video_info;
998 video_info.aggregated_senders.push_back(video_sender_info);
999
1000 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1001 video_media_channel->SetStats(video_info);
1002
1003 AddOutgoingVideoTrack(pc, stats.get());
1004
1005 Call::Stats call_stats;
1006 call_stats.send_bandwidth_bps = kSendBandwidth;
1007 call_stats.recv_bandwidth_bps = kRecvBandwidth;
1008 call_stats.pacer_delay_ms = kPacerDelay;
1009 pc->SetCallStats(call_stats);
1010
1011 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1012 StatsReports reports;
1013 stats->GetStats(nullptr, &reports);
1014
1015 EXPECT_EQ(
1016 rtc::ToString(kBytesSent),
1017 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
1018 EXPECT_EQ(rtc::ToString(kSendBandwidth),
1019 ExtractBweStatsValue(
1020 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
1021 EXPECT_EQ(
1022 rtc::ToString(kRecvBandwidth),
1023 ExtractBweStatsValue(
1024 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
1025 EXPECT_EQ(
1026 rtc::ToString(kPacerDelay),
1027 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
1028 }
1029
1030 // This test verifies that an object of type "googSession" always
1031 // exists in the returned stats.
TEST_F(StatsCollectorTest,SessionObjectExists)1032 TEST_F(StatsCollectorTest, SessionObjectExists) {
1033 auto pc = CreatePeerConnection();
1034 auto stats = CreateStatsCollector(pc);
1035
1036 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1037 StatsReports reports;
1038 stats->GetStats(nullptr, &reports);
1039
1040 EXPECT_TRUE(
1041 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
1042 }
1043
1044 // This test verifies that only one object of type "googSession" exists
1045 // in the returned stats.
TEST_F(StatsCollectorTest,OnlyOneSessionObjectExists)1046 TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
1047 auto pc = CreatePeerConnection();
1048 auto stats = CreateStatsCollector(pc);
1049
1050 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1051 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1052 StatsReports reports;
1053 stats->GetStats(nullptr, &reports);
1054
1055 EXPECT_TRUE(
1056 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
1057 EXPECT_FALSE(
1058 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 2));
1059 }
1060
1061 // This test verifies that the empty track report exists in the returned stats
1062 // without calling StatsCollector::UpdateStats.
TEST_P(StatsCollectorTrackTest,TrackObjectExistsWithoutUpdateStats)1063 TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) {
1064 auto pc = CreatePeerConnection();
1065 auto stats = CreateStatsCollector(pc);
1066
1067 pc->AddVideoChannel("video", "transport");
1068 AddOutgoingVideoTrack(pc, stats.get());
1069
1070 // Verfies the existence of the track report.
1071 StatsReports reports;
1072 stats->GetStats(nullptr, &reports);
1073 ASSERT_EQ(1u, reports.size());
1074 EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
1075 EXPECT_EQ(0, reports[0]->timestamp());
1076
1077 std::string trackValue =
1078 ExtractStatsValue(StatsReport::kStatsReportTypeTrack, reports,
1079 StatsReport::kStatsValueNameTrackId);
1080 EXPECT_EQ(kLocalTrackId, trackValue);
1081 }
1082
1083 // This test verifies that the empty track report exists in the returned stats
1084 // when StatsCollector::UpdateStats is called with ssrc stats.
TEST_P(StatsCollectorTrackTest,TrackAndSsrcObjectExistAfterUpdateSsrcStats)1085 TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
1086 constexpr int64_t kBytesSent = 12345678901234LL;
1087
1088 auto pc = CreatePeerConnection();
1089 auto stats = CreateStatsCollector(pc);
1090
1091 VideoSenderInfo video_sender_info;
1092 video_sender_info.add_ssrc(1234);
1093 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1094 video_sender_info.header_and_padding_bytes_sent = 12;
1095 VideoMediaInfo video_info;
1096 video_info.aggregated_senders.push_back(video_sender_info);
1097
1098 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1099 video_media_channel->SetStats(video_info);
1100
1101 AddOutgoingVideoTrack(pc, stats.get());
1102
1103 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1104 StatsReports reports;
1105 stats->GetStats(nullptr, &reports);
1106
1107 // |reports| should contain at least one session report, one track report,
1108 // and one ssrc report.
1109 EXPECT_LE(3u, reports.size());
1110 const StatsReport* track_report =
1111 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
1112 EXPECT_TRUE(track_report);
1113
1114 // Get report for the specific |track|.
1115 reports.clear();
1116 stats->GetStats(track_, &reports);
1117 // |reports| should contain at least one session report, one track report,
1118 // and one ssrc report.
1119 EXPECT_LE(3u, reports.size());
1120 track_report =
1121 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
1122 ASSERT_TRUE(track_report);
1123 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
1124
1125 std::string ssrc_id =
1126 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
1127 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
1128
1129 std::string track_id =
1130 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
1131 EXPECT_EQ(kLocalTrackId, track_id);
1132
1133 std::string media_type =
1134 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameMediaType);
1135 EXPECT_EQ("video", media_type);
1136 }
1137
1138 // This test verifies that an SSRC object has the identifier of a Transport
1139 // stats object, and that this transport stats object exists in stats.
TEST_P(StatsCollectorTrackTest,TransportObjectLinkedFromSsrcObject)1140 TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
1141 constexpr int64_t kBytesSent = 12345678901234LL;
1142
1143 auto pc = CreatePeerConnection();
1144 auto stats = CreateStatsCollector(pc);
1145
1146 VideoSenderInfo video_sender_info;
1147 video_sender_info.add_ssrc(1234);
1148 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1149 video_sender_info.header_and_padding_bytes_sent = 12;
1150 VideoMediaInfo video_info;
1151 video_info.aggregated_senders.push_back(video_sender_info);
1152
1153 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1154 video_media_channel->SetStats(video_info);
1155
1156 AddOutgoingVideoTrack(pc, stats.get());
1157
1158 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1159 StatsReports reports;
1160 stats->GetStats(nullptr, &reports);
1161
1162 std::string transport_id =
1163 ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports,
1164 StatsReport::kStatsValueNameTransportId);
1165 ASSERT_NE(kNotFound, transport_id);
1166
1167 // Transport id component ID will always be 1.
1168 // This has assumptions about how the ID is constructed. As is, this is
1169 // OK since this is for testing purposes only, but if we ever need this
1170 // in production, we should add a generic method that does this.
1171 size_t index = transport_id.find('-');
1172 ASSERT_NE(std::string::npos, index);
1173 std::string content = transport_id.substr(index + 1);
1174 index = content.rfind('-');
1175 ASSERT_NE(std::string::npos, index);
1176 content = content.substr(0, index);
1177 StatsReport::Id id(StatsReport::NewComponentId(content, 1));
1178 ASSERT_EQ(transport_id, id->ToString());
1179 const StatsReport* transport_report = FindReportById(reports, id);
1180 ASSERT_TRUE(transport_report);
1181 }
1182
1183 // This test verifies that a remote stats object will not be created for
1184 // an outgoing SSRC where remote stats are not returned.
TEST_P(StatsCollectorTrackTest,RemoteSsrcInfoIsAbsent)1185 TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) {
1186 auto pc = CreatePeerConnection();
1187 auto stats = CreateStatsCollector(pc);
1188
1189 pc->AddVideoChannel("video", "transport");
1190 AddOutgoingVideoTrack(pc, stats.get());
1191
1192 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1193 StatsReports reports;
1194 stats->GetStats(nullptr, &reports);
1195
1196 const StatsReport* remote_report =
1197 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
1198 EXPECT_FALSE(remote_report);
1199 }
1200
1201 // This test verifies that a remote stats object will be created for
1202 // an outgoing SSRC where stats are returned.
TEST_P(StatsCollectorTrackTest,RemoteSsrcInfoIsPresent)1203 TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
1204 auto pc = CreatePeerConnection();
1205 auto stats = CreateStatsCollector(pc);
1206
1207 SsrcReceiverInfo remote_ssrc_stats;
1208 remote_ssrc_stats.timestamp = 12345.678;
1209 remote_ssrc_stats.ssrc = kSsrcOfTrack;
1210 VideoSenderInfo video_sender_info;
1211 video_sender_info.add_ssrc(kSsrcOfTrack);
1212 video_sender_info.remote_stats.push_back(remote_ssrc_stats);
1213 VideoMediaInfo video_info;
1214 video_info.aggregated_senders.push_back(video_sender_info);
1215
1216 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1217 video_media_channel->SetStats(video_info);
1218
1219 AddOutgoingVideoTrack(pc, stats.get());
1220
1221 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1222 StatsReports reports;
1223 stats->GetStats(nullptr, &reports);
1224
1225 const StatsReport* remote_report =
1226 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
1227 ASSERT_TRUE(remote_report);
1228 EXPECT_EQ(12345.678, remote_report->timestamp());
1229 }
1230
1231 // This test verifies that the empty track report exists in the returned stats
1232 // when StatsCollector::UpdateStats is called with ssrc stats.
TEST_P(StatsCollectorTrackTest,ReportsFromRemoteTrack)1233 TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) {
1234 constexpr int64_t kNumOfPacketsConcealed = 54321;
1235
1236 auto pc = CreatePeerConnection();
1237 auto stats = CreateStatsCollector(pc);
1238
1239 VideoReceiverInfo video_receiver_info;
1240 video_receiver_info.add_ssrc(1234);
1241 video_receiver_info.packets_concealed = kNumOfPacketsConcealed;
1242 VideoMediaInfo video_info;
1243 video_info.receivers.push_back(video_receiver_info);
1244
1245 auto* video_media_info = pc->AddVideoChannel("video", "transport");
1246 video_media_info->SetStats(video_info);
1247
1248 AddIncomingVideoTrack(pc, stats.get());
1249
1250 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1251 StatsReports reports;
1252 stats->GetStats(nullptr, &reports);
1253
1254 // |reports| should contain at least one session report, one track report,
1255 // and one ssrc report.
1256 EXPECT_LE(3u, reports.size());
1257 const StatsReport* track_report =
1258 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
1259 ASSERT_TRUE(track_report);
1260 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
1261
1262 std::string ssrc_id =
1263 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
1264 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
1265
1266 std::string track_id =
1267 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
1268 EXPECT_EQ(kRemoteTrackId, track_id);
1269 }
1270
1271 // This test verifies the Ice Candidate report should contain the correct
1272 // information from local/remote candidates.
TEST_F(StatsCollectorTest,IceCandidateReport)1273 TEST_F(StatsCollectorTest, IceCandidateReport) {
1274 const std::string kTransportName = "transport";
1275 const rtc::AdapterType kNetworkType = rtc::ADAPTER_TYPE_ETHERNET;
1276 constexpr uint32_t kPriority = 1000;
1277
1278 constexpr int kLocalPort = 2000;
1279 const std::string kLocalIp = "192.168.0.1";
1280 const rtc::SocketAddress kLocalAddress(kLocalIp, kLocalPort);
1281
1282 constexpr int kRemotePort = 2001;
1283 const std::string kRemoteIp = "192.168.0.2";
1284 const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
1285
1286 auto pc = CreatePeerConnection();
1287 auto stats = CreateStatsCollector(pc);
1288
1289 cricket::Candidate local;
1290 EXPECT_GT(local.id().length(), 0u);
1291 local.set_type(cricket::LOCAL_PORT_TYPE);
1292 local.set_protocol(cricket::UDP_PROTOCOL_NAME);
1293 local.set_address(kLocalAddress);
1294 local.set_priority(kPriority);
1295 local.set_network_type(kNetworkType);
1296
1297 cricket::Candidate remote;
1298 EXPECT_GT(remote.id().length(), 0u);
1299 remote.set_type(cricket::PRFLX_PORT_TYPE);
1300 remote.set_protocol(cricket::UDP_PROTOCOL_NAME);
1301 remote.set_address(kRemoteAddress);
1302 remote.set_priority(kPriority);
1303 remote.set_network_type(kNetworkType);
1304
1305 ConnectionInfo connection_info;
1306 connection_info.local_candidate = local;
1307 connection_info.remote_candidate = remote;
1308 TransportChannelStats channel_stats;
1309 channel_stats.ice_transport_stats.connection_infos.push_back(connection_info);
1310
1311 pc->AddVoiceChannel("audio", kTransportName);
1312 pc->SetTransportStats(kTransportName, channel_stats);
1313
1314 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1315 StatsReports reports;
1316 stats->GetStats(nullptr, &reports);
1317
1318 // Verify the local candidate report is populated correctly.
1319 EXPECT_EQ(
1320 "Cand-" + local.id(),
1321 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1322 StatsReport::kStatsValueNameLocalCandidateId));
1323 EXPECT_EQ(
1324 kLocalIp,
1325 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1326 StatsReport::kStatsValueNameCandidateIPAddress));
1327 EXPECT_EQ(
1328 rtc::ToString(kLocalPort),
1329 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1330 StatsReport::kStatsValueNameCandidatePortNumber));
1331 EXPECT_EQ(
1332 cricket::UDP_PROTOCOL_NAME,
1333 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1334 StatsReport::kStatsValueNameCandidateTransportType));
1335 EXPECT_EQ(
1336 rtc::ToString(kPriority),
1337 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1338 StatsReport::kStatsValueNameCandidatePriority));
1339 EXPECT_EQ(
1340 IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),
1341 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1342 StatsReport::kStatsValueNameCandidateType));
1343 EXPECT_EQ(
1344 AdapterTypeToStatsType(kNetworkType),
1345 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1346 StatsReport::kStatsValueNameCandidateNetworkType));
1347
1348 // Verify the remote candidate report is populated correctly.
1349 EXPECT_EQ(
1350 "Cand-" + remote.id(),
1351 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1352 StatsReport::kStatsValueNameRemoteCandidateId));
1353 EXPECT_EQ(kRemoteIp,
1354 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1355 reports,
1356 StatsReport::kStatsValueNameCandidateIPAddress));
1357 EXPECT_EQ(rtc::ToString(kRemotePort),
1358 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1359 reports,
1360 StatsReport::kStatsValueNameCandidatePortNumber));
1361 EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
1362 ExtractStatsValue(
1363 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1364 StatsReport::kStatsValueNameCandidateTransportType));
1365 EXPECT_EQ(rtc::ToString(kPriority),
1366 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1367 reports,
1368 StatsReport::kStatsValueNameCandidatePriority));
1369 EXPECT_EQ(
1370 IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),
1371 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1372 reports, StatsReport::kStatsValueNameCandidateType));
1373 EXPECT_EQ(kNotFound,
1374 ExtractStatsValue(
1375 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1376 StatsReport::kStatsValueNameCandidateNetworkType));
1377 }
1378
1379 // This test verifies that all chained certificates are correctly
1380 // reported
TEST_F(StatsCollectorTest,ChainedCertificateReportsCreated)1381 TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
1382 // Build local certificate chain.
1383 std::vector<std::string> local_ders(5);
1384 local_ders[0] = "These";
1385 local_ders[1] = "are";
1386 local_ders[2] = "some";
1387 local_ders[3] = "der";
1388 local_ders[4] = "values";
1389 rtc::FakeSSLIdentity local_identity(DersToPems(local_ders));
1390
1391 // Build remote certificate chain
1392 std::vector<std::string> remote_ders(4);
1393 remote_ders[0] = "A";
1394 remote_ders[1] = "non-";
1395 remote_ders[2] = "intersecting";
1396 remote_ders[3] = "set";
1397 rtc::FakeSSLIdentity remote_identity(DersToPems(remote_ders));
1398
1399 TestCertificateReports(local_identity, local_ders, remote_identity,
1400 remote_ders);
1401 }
1402
1403 // This test verifies that all certificates without chains are correctly
1404 // reported.
TEST_F(StatsCollectorTest,ChainlessCertificateReportsCreated)1405 TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
1406 // Build local certificate.
1407 std::string local_der = "This is the local der.";
1408 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
1409
1410 // Build remote certificate.
1411 std::string remote_der = "This is somebody else's der.";
1412 rtc::FakeSSLIdentity remote_identity(DerToPem(remote_der));
1413
1414 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1415 remote_identity,
1416 std::vector<std::string>(1, remote_der));
1417 }
1418
1419 // This test verifies that the stats are generated correctly when no
1420 // transport is present.
TEST_F(StatsCollectorTest,NoTransport)1421 TEST_F(StatsCollectorTest, NoTransport) {
1422 auto pc = CreatePeerConnection();
1423 auto stats = CreateStatsCollector(pc);
1424
1425 // This will cause the fake PeerConnection to generate a TransportStats entry
1426 // but with only a single dummy TransportChannelStats.
1427 pc->AddVoiceChannel("audio", "transport");
1428
1429 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1430 StatsReports reports;
1431 stats->GetStats(nullptr, &reports);
1432
1433 // Check that the local certificate is absent.
1434 std::string local_certificate_id =
1435 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1436 StatsReport::kStatsValueNameLocalCertificateId);
1437 ASSERT_EQ(kNotFound, local_certificate_id);
1438
1439 // Check that the remote certificate is absent.
1440 std::string remote_certificate_id =
1441 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1442 StatsReport::kStatsValueNameRemoteCertificateId);
1443 ASSERT_EQ(kNotFound, remote_certificate_id);
1444
1445 // Check that the negotiated ciphers are absent.
1446 std::string dtls_cipher_suite =
1447 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1448 StatsReport::kStatsValueNameDtlsCipher);
1449 ASSERT_EQ(kNotFound, dtls_cipher_suite);
1450 std::string srtp_crypto_suite =
1451 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1452 StatsReport::kStatsValueNameSrtpCipher);
1453 ASSERT_EQ(kNotFound, srtp_crypto_suite);
1454 }
1455
1456 // This test verifies that a remote certificate with an unsupported digest
1457 // algorithm is correctly ignored.
TEST_F(StatsCollectorTest,UnsupportedDigestIgnored)1458 TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
1459 // Build a local certificate.
1460 std::string local_der = "This is the local der.";
1461 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
1462
1463 // Build a remote certificate with an unsupported digest algorithm.
1464 std::string remote_der = "This is somebody else's der.";
1465 rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
1466 remote_cert.set_digest_algorithm("foobar");
1467 rtc::FakeSSLIdentity remote_identity(remote_cert);
1468
1469 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1470 remote_identity, std::vector<std::string>());
1471 }
1472
1473 // This test verifies that the audio/video related stats which are -1 initially
1474 // will be filtered out.
TEST_P(StatsCollectorTrackTest,FilterOutNegativeInitialValues)1475 TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
1476 // This test uses streams, but only works for the stream case.
1477 if (!GetParam()) {
1478 return;
1479 }
1480
1481 auto pc = CreatePeerConnection();
1482 auto stats = CreateStatsCollector(pc);
1483
1484 // Create a local stream with a local audio track and adds it to the stats.
1485 stream_ = MediaStream::Create("streamid");
1486 rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(
1487 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));
1488 stream_->AddTrack(local_track);
1489 pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
1490 if (GetParam()) {
1491 stats->AddStream(stream_);
1492 }
1493 stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
1494
1495 // Create a remote stream with a remote audio track and adds it to the stats.
1496 rtc::scoped_refptr<MediaStream> remote_stream(
1497 MediaStream::Create("remotestreamid"));
1498 rtc::scoped_refptr<FakeAudioTrackWithInitValue> remote_track(
1499 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kRemoteTrackId));
1500 remote_stream->AddTrack(remote_track);
1501 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
1502 if (GetParam()) {
1503 stats->AddStream(remote_stream);
1504 }
1505
1506 VoiceSenderInfo voice_sender_info;
1507 voice_sender_info.add_ssrc(kSsrcOfTrack);
1508 // These values are set to -1 initially in audio_send_stream.
1509 // The voice_sender_info will read the values from audio_send_stream.
1510 voice_sender_info.rtt_ms = -1;
1511 voice_sender_info.packets_lost = -1;
1512 voice_sender_info.jitter_ms = -1;
1513
1514 // Some of the contents in |voice_sender_info| needs to be updated from the
1515 // |audio_track_|.
1516 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &voice_sender_info,
1517 true);
1518
1519 VoiceReceiverInfo voice_receiver_info;
1520 voice_receiver_info.add_ssrc(kSsrcOfTrack);
1521 voice_receiver_info.capture_start_ntp_time_ms = -1;
1522 voice_receiver_info.audio_level = -1;
1523
1524 // Constructs an ssrc stats update.
1525 VoiceMediaInfo voice_info;
1526 voice_info.senders.push_back(voice_sender_info);
1527 voice_info.receivers.push_back(voice_receiver_info);
1528
1529 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1530 voice_media_channel->SetStats(voice_info);
1531
1532 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1533
1534 // Get stats for the local track.
1535 StatsReports reports;
1536 stats->GetStats(local_track.get(), &reports);
1537 const StatsReport* report =
1538 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
1539 ASSERT_TRUE(report);
1540 // The -1 will not be added to the stats report.
1541 std::string value_in_report;
1542 EXPECT_FALSE(
1543 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
1544 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
1545 &value_in_report));
1546 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
1547 &value_in_report));
1548 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
1549 &value_in_report));
1550 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
1551 &value_in_report));
1552
1553 // Get stats for the remote track.
1554 reports.clear();
1555 stats->GetStats(remote_track.get(), &reports);
1556 report = FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
1557 ASSERT_TRUE(report);
1558 EXPECT_FALSE(GetValue(report,
1559 StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
1560 &value_in_report));
1561 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
1562 &value_in_report));
1563 }
1564
1565 // This test verifies that a local stats object can get statistics via
1566 // AudioTrackInterface::GetStats() method.
TEST_P(StatsCollectorTrackTest,GetStatsFromLocalAudioTrack)1567 TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
1568 auto pc = CreatePeerConnection();
1569 auto stats = CreateStatsCollector(pc);
1570
1571 AddOutgoingAudioTrack(pc, stats.get());
1572 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
1573
1574 VoiceSenderInfo voice_sender_info;
1575 InitVoiceSenderInfo(&voice_sender_info);
1576 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
1577 VoiceMediaInfo voice_info;
1578 voice_info.senders.push_back(voice_sender_info);
1579
1580 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1581 voice_media_channel->SetStats(voice_info);
1582
1583 StatsReports reports; // returned values.
1584 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
1585
1586 // Verify that there is no remote report for the local audio track because
1587 // we did not set it up.
1588 const StatsReport* remote_report =
1589 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
1590 EXPECT_TRUE(remote_report == NULL);
1591 }
1592
1593 // This test verifies that audio receive streams populate stats reports
1594 // correctly.
TEST_P(StatsCollectorTrackTest,GetStatsFromRemoteStream)1595 TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) {
1596 auto pc = CreatePeerConnection();
1597 auto stats = CreateStatsCollector(pc);
1598
1599 AddIncomingAudioTrack(pc, stats.get());
1600
1601 VoiceReceiverInfo voice_receiver_info;
1602 InitVoiceReceiverInfo(&voice_receiver_info);
1603 voice_receiver_info.codec_name = "fake_codec";
1604 VoiceMediaInfo voice_info;
1605 voice_info.receivers.push_back(voice_receiver_info);
1606
1607 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1608 voice_media_channel->SetStats(voice_info);
1609
1610 StatsReports reports; // returned values.
1611 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
1612 }
1613
1614 // This test verifies that a local stats object won't update its statistics
1615 // after a RemoveLocalAudioTrack() call.
TEST_P(StatsCollectorTrackTest,GetStatsAfterRemoveAudioStream)1616 TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) {
1617 auto pc = CreatePeerConnection();
1618 auto stats = CreateStatsCollector(pc);
1619
1620 AddOutgoingAudioTrack(pc, stats.get());
1621 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1622
1623 VoiceSenderInfo voice_sender_info;
1624 InitVoiceSenderInfo(&voice_sender_info);
1625 VoiceMediaInfo voice_info;
1626 voice_info.senders.push_back(voice_sender_info);
1627
1628 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1629 voice_media_channel->SetStats(voice_info);
1630
1631 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1632
1633 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1634 StatsReports reports;
1635 stats->GetStats(nullptr, &reports);
1636
1637 // The report will exist since we don't remove them in RemoveStream().
1638 const StatsReport* report =
1639 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
1640 ASSERT_TRUE(report);
1641 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
1642 std::string track_id =
1643 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
1644 EXPECT_EQ(kLocalTrackId, track_id);
1645 std::string ssrc_id =
1646 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
1647 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
1648
1649 // Verifies the values in the track report, no value will be changed by the
1650 // AudioTrackInterface::GetSignalValue() and
1651 // AudioProcessorInterface::GetStats();
1652 VerifyVoiceSenderInfoReport(report, voice_sender_info);
1653 }
1654
1655 // This test verifies that when ongoing and incoming audio tracks are using
1656 // the same ssrc, they populate stats reports correctly.
TEST_P(StatsCollectorTrackTest,LocalAndRemoteTracksWithSameSsrc)1657 TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
1658 auto pc = CreatePeerConnection();
1659 auto stats = CreateStatsCollector(pc);
1660
1661 // Create a local stream with a local audio track and adds it to the stats.
1662 AddOutgoingAudioTrack(pc, stats.get());
1663 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1664
1665 // Create a remote stream with a remote audio track and adds it to the stats.
1666 rtc::scoped_refptr<MediaStream> remote_stream(
1667 MediaStream::Create("remotestreamid"));
1668 rtc::scoped_refptr<FakeAudioTrack> remote_track(
1669 new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));
1670 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
1671 remote_stream->AddTrack(remote_track);
1672 stats->AddStream(remote_stream);
1673
1674 VoiceSenderInfo voice_sender_info;
1675 InitVoiceSenderInfo(&voice_sender_info);
1676 // Some of the contents in |voice_sender_info| needs to be updated from the
1677 // |audio_track_|.
1678 UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info,
1679 true);
1680
1681 VoiceReceiverInfo voice_receiver_info;
1682 InitVoiceReceiverInfo(&voice_receiver_info);
1683
1684 // Constructs an ssrc stats update.
1685 VoiceMediaInfo voice_info;
1686 voice_info.senders.push_back(voice_sender_info);
1687 voice_info.receivers.push_back(voice_receiver_info);
1688
1689 // Instruct the session to return stats containing the transport channel.
1690 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1691 voice_media_channel->SetStats(voice_info);
1692
1693 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1694
1695 // Get stats for the local track.
1696 StatsReports reports; // returned values.
1697 stats->GetStats(audio_track_.get(), &reports);
1698
1699 const StatsReport* track_report =
1700 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
1701 ASSERT_TRUE(track_report);
1702 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
1703 std::string track_id =
1704 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
1705 EXPECT_EQ(kLocalTrackId, track_id);
1706 VerifyVoiceSenderInfoReport(track_report, voice_sender_info);
1707
1708 // Get stats for the remote track.
1709 reports.clear();
1710 stats->GetStats(remote_track.get(), &reports);
1711 track_report =
1712 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
1713 ASSERT_TRUE(track_report);
1714 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
1715 track_id =
1716 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
1717 EXPECT_EQ(kRemoteTrackId, track_id);
1718 VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
1719 }
1720
1721 // This test verifies that when two outgoing audio tracks are using the same
1722 // ssrc at different times, they populate stats reports correctly.
1723 // TODO(xians): Figure out if it is possible to encapsulate the setup and
1724 // avoid duplication of code in test cases.
TEST_P(StatsCollectorTrackTest,TwoLocalTracksWithSameSsrc)1725 TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
1726 // This test only makes sense when we're using streams.
1727 if (!GetParam()) {
1728 return;
1729 }
1730
1731 auto pc = CreatePeerConnection();
1732 auto stats = CreateStatsCollector(pc);
1733
1734 // Create a local stream with a local audio track and adds it to the stats.
1735 auto sender = AddOutgoingAudioTrack(pc, stats.get());
1736 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
1737
1738 VoiceSenderInfo voice_sender_info;
1739 InitVoiceSenderInfo(&voice_sender_info);
1740 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
1741 voice_sender_info.add_ssrc(kSsrcOfTrack);
1742 VoiceMediaInfo voice_info;
1743 voice_info.senders.push_back(voice_sender_info);
1744
1745 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1746 voice_media_channel->SetStats(voice_info);
1747
1748 StatsReports reports; // returned values.
1749 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
1750
1751 // Remove the previous audio track from the stream.
1752 stream_->RemoveTrack(audio_track_.get());
1753 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1754 pc->RemoveSender(sender);
1755
1756 // Create a new audio track and adds it to the stream and stats.
1757 static const std::string kNewTrackId = "new_track_id";
1758 rtc::scoped_refptr<FakeAudioTrack> new_audio_track(
1759 new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));
1760 pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
1761 stream_->AddTrack(new_audio_track);
1762
1763 stats->AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);
1764 stats->ClearUpdateStatsCacheForTest();
1765
1766 VoiceSenderInfo new_voice_sender_info;
1767 InitVoiceSenderInfo(&new_voice_sender_info);
1768 UpdateVoiceSenderInfoFromAudioTrack(new_audio_track, &new_voice_sender_info,
1769 false);
1770 VoiceMediaInfo new_voice_info;
1771 new_voice_info.senders.push_back(new_voice_sender_info);
1772 voice_media_channel->SetStats(new_voice_info);
1773
1774 reports.clear();
1775 VerifyAudioTrackStats(new_audio_track, stats.get(), new_voice_info, &reports);
1776 }
1777
1778 // Test that if there are two local senders with the same track then two SSRC
1779 // reports will be created, one for each sender, with the same track ID and one
1780 // track report will be created for the shared track.
TEST_P(StatsCollectorTrackTest,TwoLocalSendersWithSameTrack)1781 TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) {
1782 constexpr uint32_t kFirstSsrc = 22;
1783 constexpr uint32_t kSecondSsrc = 33;
1784
1785 auto pc = CreatePeerConnection();
1786 auto stats = CreateStatsCollector(pc);
1787
1788 rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(
1789 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));
1790 pc->AddSender(CreateMockSender(local_track, kFirstSsrc));
1791 stats->AddLocalAudioTrack(local_track.get(), kFirstSsrc);
1792 pc->AddSender(CreateMockSender(local_track, kSecondSsrc));
1793 stats->AddLocalAudioTrack(local_track.get(), kSecondSsrc);
1794
1795 VoiceSenderInfo first_sender_info;
1796 InitVoiceSenderInfo(&first_sender_info, kFirstSsrc);
1797 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &first_sender_info,
1798 false);
1799
1800 VoiceSenderInfo second_sender_info;
1801 InitVoiceSenderInfo(&second_sender_info, kSecondSsrc);
1802 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &second_sender_info,
1803 false);
1804
1805 VoiceMediaInfo voice_info;
1806 voice_info.senders.push_back(first_sender_info);
1807 voice_info.senders.push_back(second_sender_info);
1808
1809 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1810 voice_media_channel->SetStats(voice_info);
1811
1812 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1813
1814 StatsReports reports;
1815 stats->GetStats(local_track.get(), &reports);
1816 RTC_LOG(LS_INFO) << reports.size();
1817
1818 // Both SSRC reports have the same track ID.
1819 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1820 reports, StatsReport::kStatsReportTypeSsrc,
1821 StatsReport::kStatsValueNameTrackId, 1));
1822 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1823 reports, StatsReport::kStatsReportTypeSsrc,
1824 StatsReport::kStatsValueNameTrackId, 2));
1825
1826 // The SSRC in each SSRC report is different and correspond to the sender
1827 // SSRC.
1828 std::vector<absl::optional<std::string>> ssrcs = {
1829 GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc,
1830 StatsReport::kStatsValueNameSsrc, 1),
1831 GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc,
1832 StatsReport::kStatsValueNameSsrc, 2)};
1833 EXPECT_THAT(ssrcs, UnorderedElementsAre(rtc::ToString(kFirstSsrc),
1834 rtc::ToString(kSecondSsrc)));
1835
1836 // There is one track report with the same track ID as the SSRC reports.
1837 EXPECT_EQ(
1838 1u, GetReportsByType(reports, StatsReport::kStatsReportTypeTrack).size());
1839 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1840 reports, StatsReport::kStatsReportTypeTrack,
1841 StatsReport::kStatsValueNameTrackId, 1));
1842 }
1843
1844 // This test verifies that stats are correctly set in video send ssrc stats.
TEST_P(StatsCollectorTrackTest,VerifyVideoSendSsrcStats)1845 TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) {
1846 auto pc = CreatePeerConnection();
1847 auto stats = CreateStatsCollector(pc);
1848
1849 AddOutgoingVideoTrack(pc, stats.get());
1850
1851 VideoSenderInfo video_sender_info;
1852 video_sender_info.add_ssrc(1234);
1853 video_sender_info.frames_encoded = 10;
1854 video_sender_info.qp_sum = 11;
1855 VideoMediaInfo video_info;
1856 video_info.aggregated_senders.push_back(video_sender_info);
1857
1858 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1859 video_media_channel->SetStats(video_info);
1860
1861 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1862 StatsReports reports;
1863 stats->GetStats(nullptr, &reports);
1864
1865 EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),
1866 ExtractSsrcStatsValue(reports,
1867 StatsReport::kStatsValueNameFramesEncoded));
1868 EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),
1869 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
1870 }
1871
1872 // This test verifies that stats are correctly set in video receive ssrc stats.
TEST_P(StatsCollectorTrackTest,VerifyVideoReceiveSsrcStatsNew)1873 TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) {
1874 auto pc = CreatePeerConnection();
1875 auto stats = CreateStatsCollector(pc);
1876
1877 AddIncomingVideoTrack(pc, stats.get());
1878
1879 VideoReceiverInfo video_receiver_info;
1880 video_receiver_info.add_ssrc(1234);
1881 video_receiver_info.frames_decoded = 10;
1882 video_receiver_info.qp_sum = 11;
1883 VideoMediaInfo video_info;
1884 video_info.receivers.push_back(video_receiver_info);
1885
1886 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1887 video_media_channel->SetStats(video_info);
1888
1889 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1890 StatsReports reports;
1891 stats->GetStats(nullptr, &reports);
1892
1893 EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),
1894 ExtractSsrcStatsValue(reports,
1895 StatsReport::kStatsValueNameFramesDecoded));
1896 EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum),
1897 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
1898 }
1899
1900 INSTANTIATE_TEST_SUITE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool());
1901
1902 } // namespace webrtc
1903