blob: 144ca34b550c7ce5f14b8a250df77b5437e4057d [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:361/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2014 The WebRTC project authors. All Rights Reserved.
henrike@webrtc.org28e20752013-07-10 00:45:363 *
kjellanderb24317b2016-02-10 15:54:434 * 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.
henrike@webrtc.org28e20752013-07-10 00:45:369 */
10
Jonas Olssona4d87372019-07-05 17:08:3311#include "pc/stats_collector.h"
12
henrike@webrtc.org28e20752013-07-10 00:45:3613#include <stdio.h>
Jonas Olssona4d87372019-07-05 17:08:3314
Harald Alvestrandc24a2182022-02-23 13:44:5915#include <cstdint>
deadbeefcbecd352015-09-23 18:50:2716
Steve Anton64b626b2019-01-29 01:25:2617#include "absl/algorithm/container.h"
Yves Gerey3e707812018-11-28 15:47:4918#include "absl/types/optional.h"
19#include "api/audio_codecs/audio_encoder.h"
20#include "api/candidate.h"
Steve Anton10542f22019-01-11 17:11:0021#include "api/data_channel_interface.h"
Harald Alvestrand9cb42c82020-10-11 13:03:4722#include "api/media_stream_track.h"
Harald Alvestrandc24a2182022-02-23 13:44:5923#include "api/media_types.h"
24#include "api/rtp_sender_interface.h"
Mirko Bonadeid9708072019-01-25 19:26:4825#include "api/scoped_refptr.h"
Yves Gerey3e707812018-11-28 15:47:4926#include "call/call.h"
Steve Anton10542f22019-01-11 17:11:0027#include "media/base/media_channel.h"
Yves Gerey3e707812018-11-28 15:47:4928#include "modules/audio_processing/include/audio_processing_statistics.h"
Harald Alvestrandc24a2182022-02-23 13:44:5929#include "p2p/base/ice_transport_internal.h"
Steve Anton10542f22019-01-11 17:11:0030#include "pc/media_stream.h"
Harald Alvestrandc24a2182022-02-23 13:44:5931#include "pc/rtp_receiver.h"
32#include "pc/rtp_sender.h"
Taylor Brandstetter3a034e12020-07-09 22:32:3433#include "pc/sctp_data_channel.h"
Steve Anton10542f22019-01-11 17:11:0034#include "pc/test/fake_peer_connection_for_stats.h"
35#include "pc/test/fake_video_track_source.h"
Steve Antonefe4c922019-03-27 17:26:0636#include "pc/test/mock_rtp_receiver_internal.h"
37#include "pc/test/mock_rtp_sender_internal.h"
Steve Anton10542f22019-01-11 17:11:0038#include "pc/transport_stats.h"
39#include "pc/video_track.h"
40#include "rtc_base/fake_ssl_identity.h"
41#include "rtc_base/message_digest.h"
42#include "rtc_base/net_helper.h"
43#include "rtc_base/ref_counted_object.h"
44#include "rtc_base/rtc_certificate.h"
Steve Anton10542f22019-01-11 17:11:0045#include "rtc_base/socket_address.h"
46#include "rtc_base/ssl_identity.h"
47#include "rtc_base/ssl_stream_adapter.h"
48#include "rtc_base/string_encode.h"
Artem Titova76af0c2018-07-23 15:38:1249#include "rtc_base/third_party/base64/base64.h"
Yves Gerey3e707812018-11-28 15:47:4950#include "rtc_base/thread.h"
Harald Alvestrandc24a2182022-02-23 13:44:5951#include "test/gmock.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3152#include "test/gtest.h"
henrike@webrtc.org28e20752013-07-10 00:45:3653
Steve Anton3871f6f2018-01-26 18:25:5354using cricket::ConnectionInfo;
55using cricket::SsrcReceiverInfo;
56using cricket::TransportChannelStats;
57using cricket::VideoMediaInfo;
58using cricket::VideoReceiverInfo;
59using cricket::VideoSenderInfo;
60using cricket::VoiceMediaInfo;
61using cricket::VoiceReceiverInfo;
62using cricket::VoiceSenderInfo;
Tomas Gunnarsson16de2162022-01-26 09:21:5763using ::testing::_;
64using ::testing::AtMost;
Steve Antonefe4c922019-03-27 17:26:0665using ::testing::Return;
66using ::testing::UnorderedElementsAre;
henrike@webrtc.org28e20752013-07-10 00:45:3667
guoweis@webrtc.org950c5182014-12-16 23:01:3168namespace webrtc {
henrike@webrtc.org28e20752013-07-10 00:45:3669
tkchin7d06a8c2016-04-04 21:10:4370namespace internal {
71// This value comes from openssl/tls1.h
72static const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;
73} // namespace internal
74
henrike@webrtc.org28e20752013-07-10 00:45:3675// Error return values
76const char kNotFound[] = "NOT FOUND";
henrike@webrtc.org28e20752013-07-10 00:45:3677
wu@webrtc.org97077a32013-10-25 21:18:3378// Constant names for track identification.
xians@webrtc.org4cb01282014-06-12 14:57:0579const char kLocalTrackId[] = "local_track_id";
80const char kRemoteTrackId[] = "remote_track_id";
Peter Boström0c4e06b2015-10-07 10:23:2181const uint32_t kSsrcOfTrack = 1234;
wu@webrtc.org97077a32013-10-25 21:18:3382
Steve Anton3871f6f2018-01-26 18:25:5383class FakeAudioProcessor : public AudioProcessorInterface {
henrike@webrtc.org40b3b682014-03-03 18:30:1184 public:
85 FakeAudioProcessor() {}
86 ~FakeAudioProcessor() {}
87
88 private:
Ivo Creusenae0260962017-11-20 12:07:1689 AudioProcessorInterface::AudioProcessorStatistics GetStats(
Ivo Creusen56d460902017-11-24 16:29:5990 bool has_recv_streams) override {
Ivo Creusenae0260962017-11-20 12:07:1691 AudioProcessorStatistics stats;
92 stats.typing_noise_detected = true;
Ivo Creusen56d460902017-11-24 16:29:5993 if (has_recv_streams) {
94 stats.apm_statistics.echo_return_loss = 2.0;
95 stats.apm_statistics.echo_return_loss_enhancement = 3.0;
96 stats.apm_statistics.delay_median_ms = 4;
97 stats.apm_statistics.delay_standard_deviation_ms = 5;
98 }
Ivo Creusenae0260962017-11-20 12:07:1699 return stats;
100 }
henrike@webrtc.org40b3b682014-03-03 18:30:11101};
102
Steve Anton3871f6f2018-01-26 18:25:53103class FakeAudioTrack : public MediaStreamTrack<AudioTrackInterface> {
henrike@webrtc.org40b3b682014-03-03 18:30:11104 public:
xians@webrtc.org4cb01282014-06-12 14:57:05105 explicit FakeAudioTrack(const std::string& id)
Steve Anton3871f6f2018-01-26 18:25:53106 : MediaStreamTrack<AudioTrackInterface>(id),
Tommi87f70902021-04-27 12:43:08107 processor_(rtc::make_ref_counted<FakeAudioProcessor>()) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35108 std::string kind() const override { return "audio"; }
Steve Anton3871f6f2018-01-26 18:25:53109 AudioSourceInterface* GetSource() const override { return NULL; }
110 void AddSink(AudioTrackSinkInterface* sink) override {}
111 void RemoveSink(AudioTrackSinkInterface* sink) override {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35112 bool GetSignalLevel(int* level) override {
henrike@webrtc.org40b3b682014-03-03 18:30:11113 *level = 1;
114 return true;
115 }
Steve Anton3871f6f2018-01-26 18:25:53116 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
henrike@webrtc.orgb90991d2014-03-04 19:54:57117 return processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11118 }
119
120 private:
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52121 rtc::scoped_refptr<FakeAudioProcessor> processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11122};
123
zhihuang6ba3b192016-05-13 18:46:35124// This fake audio processor is used to verify that the undesired initial values
125// (-1) will be filtered out.
Steve Anton3871f6f2018-01-26 18:25:53126class FakeAudioProcessorWithInitValue : public AudioProcessorInterface {
zhihuang6ba3b192016-05-13 18:46:35127 public:
128 FakeAudioProcessorWithInitValue() {}
129 ~FakeAudioProcessorWithInitValue() {}
130
131 private:
Ivo Creusenae0260962017-11-20 12:07:16132 AudioProcessorInterface::AudioProcessorStatistics GetStats(
133 bool /*has_recv_streams*/) override {
134 AudioProcessorStatistics stats;
135 stats.typing_noise_detected = false;
136 return stats;
137 }
zhihuang6ba3b192016-05-13 18:46:35138};
139
140class FakeAudioTrackWithInitValue
Steve Anton3871f6f2018-01-26 18:25:53141 : public MediaStreamTrack<AudioTrackInterface> {
zhihuang6ba3b192016-05-13 18:46:35142 public:
143 explicit FakeAudioTrackWithInitValue(const std::string& id)
Steve Anton3871f6f2018-01-26 18:25:53144 : MediaStreamTrack<AudioTrackInterface>(id),
Tommi87f70902021-04-27 12:43:08145 processor_(rtc::make_ref_counted<FakeAudioProcessorWithInitValue>()) {}
zhihuang6ba3b192016-05-13 18:46:35146 std::string kind() const override { return "audio"; }
Steve Anton3871f6f2018-01-26 18:25:53147 AudioSourceInterface* GetSource() const override { return NULL; }
148 void AddSink(AudioTrackSinkInterface* sink) override {}
149 void RemoveSink(AudioTrackSinkInterface* sink) override {}
zhihuang6ba3b192016-05-13 18:46:35150 bool GetSignalLevel(int* level) override {
151 *level = 1;
152 return true;
153 }
Steve Anton3871f6f2018-01-26 18:25:53154 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
zhihuang6ba3b192016-05-13 18:46:35155 return processor_;
156 }
157
158 private:
159 rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_;
160};
161
henrike@webrtc.org40b3b682014-03-03 18:30:11162bool GetValue(const StatsReport* report,
tommi@webrtc.org242068d2014-07-14 20:19:56163 StatsReport::StatsValueName name,
wu@webrtc.org4551b792013-10-09 15:37:36164 std::string* value) {
tommi@webrtc.org92f40182015-03-04 15:25:19165 const StatsReport::Value* v = report->FindValue(name);
166 if (!v)
167 return false;
168 *value = v->ToString();
169 return true;
wu@webrtc.org4551b792013-10-09 15:37:36170}
171
tommi@webrtc.org4fb7e252015-01-21 11:36:18172std::string ExtractStatsValue(const StatsReport::StatsType& type,
henrike@webrtc.org40b3b682014-03-03 18:30:11173 const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56174 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18175 for (const auto* r : reports) {
wu@webrtc.org4551b792013-10-09 15:37:36176 std::string ret;
tommi@webrtc.org4fb7e252015-01-21 11:36:18177 if (r->type() == type && GetValue(r, name, &ret))
wu@webrtc.org4551b792013-10-09 15:37:36178 return ret;
henrike@webrtc.org28e20752013-07-10 00:45:36179 }
180
181 return kNotFound;
182}
183
tommi@webrtc.orgd3900292015-03-12 16:35:55184StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type,
185 const std::string& value) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18186 EXPECT_FALSE(value.empty());
tommi@webrtc.orgd3900292015-03-12 16:35:55187 StatsReport::Id id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18188 if (value.empty())
tommi@webrtc.orgd3900292015-03-12 16:35:55189 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18190
191 // This has assumptions about how the ID is constructed. As is, this is
192 // OK since this is for testing purposes only, but if we ever need this
193 // in production, we should add a generic method that does this.
194 size_t index = value.find('_');
195 EXPECT_NE(index, std::string::npos);
196 if (index == std::string::npos || index == (value.length() - 1))
tommi@webrtc.orgd3900292015-03-12 16:35:55197 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18198
199 id = StatsReport::NewTypedId(type, value.substr(index + 1));
200 EXPECT_EQ(id->ToString(), value);
tommi@webrtc.orgd3900292015-03-12 16:35:55201 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18202}
203
tommi@webrtc.orgd3900292015-03-12 16:35:55204StatsReport::Id IdFromCertIdString(const std::string& cert_id) {
205 return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id);
tommi@webrtc.org4fb7e252015-01-21 11:36:18206}
207
Artem Titov880fa812021-07-30 20:30:23208// Finds the `n`-th report of type `type` in `reports`.
209// `n` starts from 1 for finding the first report.
Yves Gerey665174f2018-06-19 13:03:05210const StatsReport* FindNthReportByType(const StatsReports& reports,
211 const StatsReport::StatsType& type,
212 int n) {
henrike@webrtc.org28e20752013-07-10 00:45:36213 for (size_t i = 0; i < reports.size(); ++i) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18214 if (reports[i]->type() == type) {
henrike@webrtc.org28e20752013-07-10 00:45:36215 n--;
216 if (n == 0)
tommi@webrtc.org5b06b062014-08-15 08:38:30217 return reports[i];
henrike@webrtc.org28e20752013-07-10 00:45:36218 }
219 }
tommi@webrtc.org4fb7e252015-01-21 11:36:18220 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36221}
222
Artem Titov880fa812021-07-30 20:30:23223// Returns the value of the stat identified by `name` in the `n`-th report of
224// type `type` in `reports`.
225// `n` starts from 1 for finding the first report.
226// If either the `n`-th report is not found, or the stat is not present in that
Steve Antonefe4c922019-03-27 17:26:06227// report, then nullopt is returned.
228absl::optional<std::string> GetValueInNthReportByType(
229 const StatsReports& reports,
230 StatsReport::StatsType type,
231 StatsReport::StatsValueName name,
232 int n) {
233 const StatsReport* report = FindNthReportByType(reports, type, n);
234 if (!report) {
235 return absl::nullopt;
236 }
237 std::string value;
238 if (!GetValue(report, name, &value)) {
239 return absl::nullopt;
240 }
241 return value;
242}
243
244std::vector<const StatsReport*> GetReportsByType(const StatsReports& reports,
245 StatsReport::StatsType type) {
246 std::vector<const StatsReport*> filtered_reports;
247 for (const StatsReport* report : reports) {
248 if (report->type() == type) {
249 filtered_reports.push_back(report);
250 }
251 }
252 return filtered_reports;
253}
254
henrike@webrtc.org40b3b682014-03-03 18:30:11255const StatsReport* FindReportById(const StatsReports& reports,
tommi@webrtc.org4fb7e252015-01-21 11:36:18256 const StatsReport::Id& id) {
tommi@webrtc.org8e327c42015-01-19 20:41:26257 for (const auto* r : reports) {
tommi@webrtc.orgd3900292015-03-12 16:35:55258 if (r->id()->Equals(id))
tommi@webrtc.org8e327c42015-01-19 20:41:26259 return r;
henrike@webrtc.org28e20752013-07-10 00:45:36260 }
tommi@webrtc.org8e327c42015-01-19 20:41:26261 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36262}
263
Mirko Bonadeic61ce0d2017-11-21 16:04:20264std::string ExtractSsrcStatsValue(const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56265 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18266 return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36267}
268
Mirko Bonadeic61ce0d2017-11-21 16:04:20269std::string ExtractBweStatsValue(const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56270 StatsReport::StatsValueName name) {
Yves Gerey665174f2018-06-19 13:03:05271 return ExtractStatsValue(StatsReport::kStatsReportTypeBwe, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36272}
273
wu@webrtc.org4551b792013-10-09 15:37:36274std::string DerToPem(const std::string& der) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52275 return rtc::SSLIdentity::DerToPem(
Yves Gerey665174f2018-06-19 13:03:05276 rtc::kPemTypeCertificate,
277 reinterpret_cast<const unsigned char*>(der.c_str()), der.length());
wu@webrtc.org4551b792013-10-09 15:37:36278}
279
Yves Gerey665174f2018-06-19 13:03:05280std::vector<std::string> DersToPems(const std::vector<std::string>& ders) {
wu@webrtc.org4551b792013-10-09 15:37:36281 std::vector<std::string> pems(ders.size());
Steve Anton64b626b2019-01-29 01:25:26282 absl::c_transform(ders, pems.begin(), DerToPem);
wu@webrtc.org4551b792013-10-09 15:37:36283 return pems;
284}
285
henrike@webrtc.org40b3b682014-03-03 18:30:11286void CheckCertChainReports(const StatsReports& reports,
wu@webrtc.org4551b792013-10-09 15:37:36287 const std::vector<std::string>& ders,
tommi@webrtc.org4fb7e252015-01-21 11:36:18288 const StatsReport::Id& start_id) {
tommi@webrtc.orgd3900292015-03-12 16:35:55289 StatsReport::Id cert_id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18290 const StatsReport::Id* certificate_id = &start_id;
wu@webrtc.org4551b792013-10-09 15:37:36291 size_t i = 0;
292 while (true) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18293 const StatsReport* report = FindReportById(reports, *certificate_id);
wu@webrtc.org4551b792013-10-09 15:37:36294 ASSERT_TRUE(report != NULL);
mallinath@webrtc.org19f27e62013-10-13 17:18:27295
wu@webrtc.org4551b792013-10-09 15:37:36296 std::string der_base64;
Yves Gerey665174f2018-06-19 13:03:05297 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDer, &der_base64));
tommi@webrtc.org4fb7e252015-01-21 11:36:18298 std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
wu@webrtc.org4551b792013-10-09 15:37:36299 EXPECT_EQ(ders[i], der);
mallinath@webrtc.org19f27e62013-10-13 17:18:27300
301 std::string fingerprint_algorithm;
Yves Gerey665174f2018-06-19 13:03:05302 EXPECT_TRUE(GetValue(report,
303 StatsReport::kStatsValueNameFingerprintAlgorithm,
304 &fingerprint_algorithm));
mallinath@webrtc.org19f27e62013-10-13 17:18:27305 // The digest algorithm for a FakeSSLCertificate is always SHA-1.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52306 std::string sha_1_str = rtc::DIGEST_SHA_1;
mallinath@webrtc.org19f27e62013-10-13 17:18:27307 EXPECT_EQ(sha_1_str, fingerprint_algorithm);
308
tommi@webrtc.org4fb7e252015-01-21 11:36:18309 std::string fingerprint;
310 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint,
311 &fingerprint));
312 EXPECT_FALSE(fingerprint.empty());
mallinath@webrtc.org19f27e62013-10-13 17:18:27313
wu@webrtc.org4551b792013-10-09 15:37:36314 ++i;
tommi@webrtc.org4fb7e252015-01-21 11:36:18315 std::string issuer_id;
Yves Gerey665174f2018-06-19 13:03:05316 if (!GetValue(report, StatsReport::kStatsValueNameIssuerId, &issuer_id)) {
wu@webrtc.org4551b792013-10-09 15:37:36317 break;
tommi@webrtc.org4fb7e252015-01-21 11:36:18318 }
319
tommi@webrtc.orgd3900292015-03-12 16:35:55320 cert_id = IdFromCertIdString(issuer_id);
321 certificate_id = &cert_id;
wu@webrtc.org4551b792013-10-09 15:37:36322 }
323 EXPECT_EQ(ders.size(), i);
324}
325
Yves Gerey665174f2018-06-19 13:03:05326void VerifyVoiceReceiverInfoReport(const StatsReport* report,
327 const cricket::VoiceReceiverInfo& info) {
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10328 std::string value_in_report;
Yves Gerey665174f2018-06-19 13:03:05329 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioOutputLevel,
330 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48331 EXPECT_EQ(rtc::ToString(info.audio_level), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05332 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesReceived,
333 &value_in_report));
Niels Möllerac0a4cb2019-10-09 13:01:33334 EXPECT_EQ(rtc::ToString(info.payload_bytes_rcvd +
335 info.header_and_padding_bytes_rcvd),
336 value_in_report);
Yves Gerey665174f2018-06-19 13:03:05337 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
338 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48339 EXPECT_EQ(rtc::ToString(info.jitter_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05340 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterBufferMs,
341 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48342 EXPECT_EQ(rtc::ToString(info.jitter_buffer_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05343 EXPECT_TRUE(GetValue(report,
344 StatsReport::kStatsValueNamePreferredJitterBufferMs,
345 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48346 EXPECT_EQ(rtc::ToString(info.jitter_buffer_preferred_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05347 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCurrentDelayMs,
348 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48349 EXPECT_EQ(rtc::ToString(info.delay_estimate_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05350 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameExpandRate,
351 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48352 EXPECT_EQ(rtc::ToString(info.expand_rate), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05353 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSpeechExpandRate,
354 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48355 EXPECT_EQ(rtc::ToString(info.speech_expand_rate), value_in_report);
Henrik Lundin8e6fd462015-06-02 07:24:52356 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,
357 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48358 EXPECT_EQ(rtc::ToString(info.accelerate_rate), value_in_report);
Henrik Lundin8e6fd462015-06-02 07:24:52359 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate,
360 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48361 EXPECT_EQ(rtc::ToString(info.preemptive_expand_rate), value_in_report);
minyue@webrtc.org652bc372015-02-18 23:50:46362 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate,
363 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48364 EXPECT_EQ(rtc::ToString(info.secondary_decoded_rate), value_in_report);
minyue-webrtc0e320ec2017-08-28 11:51:27365 EXPECT_TRUE(GetValue(report,
366 StatsReport::kStatsValueNameSecondaryDiscardedRate,
367 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48368 EXPECT_EQ(rtc::ToString(info.secondary_discarded_rate), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05369 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsReceived,
370 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48371 EXPECT_EQ(rtc::ToString(info.packets_rcvd), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05372 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTSG,
373 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48374 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_silence_generator),
Yves Gerey665174f2018-06-19 13:03:05375 value_in_report);
376 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTN,
377 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48378 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_neteq), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05379 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingNormal,
380 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48381 EXPECT_EQ(rtc::ToString(info.decoding_normal), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05382 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLC,
383 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48384 EXPECT_EQ(rtc::ToString(info.decoding_plc), value_in_report);
Alex Narest5b5d97c2019-08-07 16:15:08385 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCodecPLC,
386 &value_in_report));
387 EXPECT_EQ(rtc::ToString(info.decoding_codec_plc), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05388 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCNG,
389 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48390 EXPECT_EQ(rtc::ToString(info.decoding_cng), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05391 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLCCNG,
392 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48393 EXPECT_EQ(rtc::ToString(info.decoding_plc_cng), value_in_report);
henrik.lundin63489782016-09-20 08:47:12394 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput,
395 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48396 EXPECT_EQ(rtc::ToString(info.decoding_muted_output), value_in_report);
henrik.lundin63489782016-09-20 08:47:12397 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
398 &value_in_report));
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10399}
400
henrike@webrtc.org40b3b682014-03-03 18:30:11401void VerifyVoiceSenderInfoReport(const StatsReport* report,
402 const cricket::VoiceSenderInfo& sinfo) {
403 std::string value_in_report;
Yves Gerey665174f2018-06-19 13:03:05404 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
405 &value_in_report));
henrike@webrtc.org40b3b682014-03-03 18:30:11406 EXPECT_EQ(sinfo.codec_name, value_in_report);
Yves Gerey665174f2018-06-19 13:03:05407 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesSent,
408 &value_in_report));
Niels Möllerac0a4cb2019-10-09 13:01:33409 EXPECT_EQ(rtc::ToString(sinfo.payload_bytes_sent +
410 sinfo.header_and_padding_bytes_sent),
411 value_in_report);
Yves Gerey665174f2018-06-19 13:03:05412 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsSent,
413 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48414 EXPECT_EQ(rtc::ToString(sinfo.packets_sent), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05415 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
416 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48417 EXPECT_EQ(rtc::ToString(sinfo.packets_lost), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05418 EXPECT_TRUE(
419 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48420 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05421 EXPECT_TRUE(
422 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48423 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05424 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
425 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48426 EXPECT_EQ(rtc::ToString(sinfo.jitter_ms), value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59427 if (sinfo.apm_statistics.delay_median_ms) {
428 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
429 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48430 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_median_ms),
Ivo Creusen56d460902017-11-24 16:29:59431 value_in_report);
432 } else {
433 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
434 &value_in_report));
435 }
436 if (sinfo.apm_statistics.delay_standard_deviation_ms) {
437 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
438 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48439 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_standard_deviation_ms),
440 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59441 } else {
442 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
443 &value_in_report));
444 }
445 if (sinfo.apm_statistics.echo_return_loss) {
446 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
447 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48448 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss),
Ivo Creusen56d460902017-11-24 16:29:59449 value_in_report);
450 } else {
451 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
452 &value_in_report));
453 }
454 if (sinfo.apm_statistics.echo_return_loss_enhancement) {
455 EXPECT_TRUE(GetValue(report,
456 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
457 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48458 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss_enhancement),
459 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59460 } else {
461 EXPECT_FALSE(GetValue(report,
462 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
463 &value_in_report));
464 }
465 if (sinfo.apm_statistics.residual_echo_likelihood) {
466 EXPECT_TRUE(GetValue(report,
467 StatsReport::kStatsValueNameResidualEchoLikelihood,
468 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48469 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.residual_echo_likelihood),
470 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59471 } else {
472 EXPECT_FALSE(GetValue(report,
473 StatsReport::kStatsValueNameResidualEchoLikelihood,
474 &value_in_report));
475 }
476 if (sinfo.apm_statistics.residual_echo_likelihood_recent_max) {
477 EXPECT_TRUE(GetValue(
478 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
479 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48480 EXPECT_EQ(rtc::ToString(
Ivo Creusen56d460902017-11-24 16:29:59481 *sinfo.apm_statistics.residual_echo_likelihood_recent_max),
482 value_in_report);
483 } else {
484 EXPECT_FALSE(GetValue(
485 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
486 &value_in_report));
487 }
ivoc8c63a822016-10-21 11:10:03488 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
489 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48490 EXPECT_EQ(rtc::ToString(sinfo.audio_level), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05491 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameTypingNoiseState,
492 &value_in_report));
henrike@webrtc.org40b3b682014-03-03 18:30:11493 std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
494 EXPECT_EQ(typing_detected, value_in_report);
ivoce1198e02017-09-08 15:13:19495 EXPECT_TRUE(GetValue(report,
496 StatsReport::kStatsValueNameAnaBitrateActionCounter,
497 &value_in_report));
498 ASSERT_TRUE(sinfo.ana_statistics.bitrate_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48499 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.bitrate_action_counter),
500 value_in_report);
ivoce1198e02017-09-08 15:13:19501 EXPECT_TRUE(GetValue(report,
502 StatsReport::kStatsValueNameAnaChannelActionCounter,
503 &value_in_report));
504 ASSERT_TRUE(sinfo.ana_statistics.channel_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48505 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.channel_action_counter),
506 value_in_report);
ivoce1198e02017-09-08 15:13:19507 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaDtxActionCounter,
508 &value_in_report));
509 ASSERT_TRUE(sinfo.ana_statistics.dtx_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48510 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.dtx_action_counter),
ivoce1198e02017-09-08 15:13:19511 value_in_report);
512 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaFecActionCounter,
513 &value_in_report));
514 ASSERT_TRUE(sinfo.ana_statistics.fec_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48515 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.fec_action_counter),
ivoce1198e02017-09-08 15:13:19516 value_in_report);
ivoc0d0b9122017-09-08 20:24:21517 EXPECT_TRUE(GetValue(
518 report, StatsReport::kStatsValueNameAnaFrameLengthIncreaseCounter,
519 &value_in_report));
520 ASSERT_TRUE(sinfo.ana_statistics.frame_length_increase_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48521 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_increase_counter),
ivoce1198e02017-09-08 15:13:19522 value_in_report);
ivoc0d0b9122017-09-08 20:24:21523 EXPECT_TRUE(GetValue(
524 report, StatsReport::kStatsValueNameAnaFrameLengthDecreaseCounter,
525 &value_in_report));
526 ASSERT_TRUE(sinfo.ana_statistics.frame_length_decrease_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48527 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_decrease_counter),
ivoc0d0b9122017-09-08 20:24:21528 value_in_report);
529 EXPECT_TRUE(GetValue(report,
530 StatsReport::kStatsValueNameAnaUplinkPacketLossFraction,
531 &value_in_report));
532 ASSERT_TRUE(sinfo.ana_statistics.uplink_packet_loss_fraction);
Jonas Olsson6b1985d2018-07-05 09:59:48533 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.uplink_packet_loss_fraction),
534 value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11535}
536
xians@webrtc.org4cb01282014-06-12 14:57:05537// Helper methods to avoid duplication of code.
Steve Antonefe4c922019-03-27 17:26:06538void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info,
539 uint32_t ssrc = kSsrcOfTrack) {
540 voice_sender_info->add_ssrc(ssrc);
xians@webrtc.org4cb01282014-06-12 14:57:05541 voice_sender_info->codec_name = "fake_codec";
Niels Möllerac0a4cb2019-10-09 13:01:33542 voice_sender_info->payload_bytes_sent = 88;
543 voice_sender_info->header_and_padding_bytes_sent = 12;
xians@webrtc.org4cb01282014-06-12 14:57:05544 voice_sender_info->packets_sent = 101;
545 voice_sender_info->rtt_ms = 102;
546 voice_sender_info->fraction_lost = 103;
547 voice_sender_info->jitter_ms = 104;
548 voice_sender_info->packets_lost = 105;
xians@webrtc.org4cb01282014-06-12 14:57:05549 voice_sender_info->audio_level = 107;
Sam Zackrisson5f2ffee2018-11-01 12:51:24550 voice_sender_info->apm_statistics.echo_return_loss = 108;
551 voice_sender_info->apm_statistics.echo_return_loss_enhancement = 109;
552 voice_sender_info->apm_statistics.delay_median_ms = 110;
553 voice_sender_info->apm_statistics.delay_standard_deviation_ms = 111;
xians@webrtc.org4cb01282014-06-12 14:57:05554 voice_sender_info->typing_noise_detected = false;
Ivo Creusen56d460902017-11-24 16:29:59555 voice_sender_info->ana_statistics.bitrate_action_counter = 112;
556 voice_sender_info->ana_statistics.channel_action_counter = 113;
557 voice_sender_info->ana_statistics.dtx_action_counter = 114;
558 voice_sender_info->ana_statistics.fec_action_counter = 115;
559 voice_sender_info->ana_statistics.frame_length_increase_counter = 116;
560 voice_sender_info->ana_statistics.frame_length_decrease_counter = 117;
561 voice_sender_info->ana_statistics.uplink_packet_loss_fraction = 118.0;
xians@webrtc.org4cb01282014-06-12 14:57:05562}
563
564void UpdateVoiceSenderInfoFromAudioTrack(
zhihuang6ba3b192016-05-13 18:46:35565 AudioTrackInterface* audio_track,
Ivo Creusen56d460902017-11-24 16:29:59566 cricket::VoiceSenderInfo* voice_sender_info,
567 bool has_remote_tracks) {
xians@webrtc.org4cb01282014-06-12 14:57:05568 audio_track->GetSignalLevel(&voice_sender_info->audio_level);
Steve Anton3871f6f2018-01-26 18:25:53569 AudioProcessorInterface::AudioProcessorStatistics audio_processor_stats =
570 audio_track->GetAudioProcessor()->GetStats(has_remote_tracks);
xians@webrtc.org4cb01282014-06-12 14:57:05571 voice_sender_info->typing_noise_detected =
572 audio_processor_stats.typing_noise_detected;
Ivo Creusen56d460902017-11-24 16:29:59573 voice_sender_info->apm_statistics = audio_processor_stats.apm_statistics;
xians@webrtc.org4cb01282014-06-12 14:57:05574}
575
576void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) {
577 voice_receiver_info->add_ssrc(kSsrcOfTrack);
Niels Möllerac0a4cb2019-10-09 13:01:33578 voice_receiver_info->payload_bytes_rcvd = 98;
579 voice_receiver_info->header_and_padding_bytes_rcvd = 12;
xians@webrtc.org4cb01282014-06-12 14:57:05580 voice_receiver_info->packets_rcvd = 111;
xians@webrtc.org4cb01282014-06-12 14:57:05581 voice_receiver_info->packets_lost = 114;
xians@webrtc.org4cb01282014-06-12 14:57:05582 voice_receiver_info->jitter_ms = 116;
583 voice_receiver_info->jitter_buffer_ms = 117;
584 voice_receiver_info->jitter_buffer_preferred_ms = 118;
585 voice_receiver_info->delay_estimate_ms = 119;
586 voice_receiver_info->audio_level = 120;
587 voice_receiver_info->expand_rate = 121;
minyue@webrtc.org652bc372015-02-18 23:50:46588 voice_receiver_info->speech_expand_rate = 122;
589 voice_receiver_info->secondary_decoded_rate = 123;
Henrik Lundin8e6fd462015-06-02 07:24:52590 voice_receiver_info->accelerate_rate = 124;
591 voice_receiver_info->preemptive_expand_rate = 125;
minyue-webrtc0e320ec2017-08-28 11:51:27592 voice_receiver_info->secondary_discarded_rate = 126;
Alex Narest5b5d97c2019-08-07 16:15:08593 voice_receiver_info->decoding_codec_plc = 127;
xians@webrtc.org4cb01282014-06-12 14:57:05594}
595
Steve Anton3871f6f2018-01-26 18:25:53596class StatsCollectorForTest : public StatsCollector {
decurtis@webrtc.org322a5642015-02-03 22:09:37597 public:
Steve Anton3871f6f2018-01-26 18:25:53598 explicit StatsCollectorForTest(PeerConnectionInternal* pc)
deadbeefab9b2d12015-10-14 18:33:11599 : StatsCollector(pc), time_now_(19477) {}
decurtis@webrtc.org322a5642015-02-03 22:09:37600
Yves Gerey665174f2018-06-19 13:03:05601 double GetTimeNow() override { return time_now_; }
decurtis@webrtc.org322a5642015-02-03 22:09:37602
603 private:
604 double time_now_;
605};
606
Mirko Bonadei6a489f22019-04-09 13:11:12607class StatsCollectorTest : public ::testing::Test {
henrike@webrtc.org28e20752013-07-10 00:45:36608 protected:
Steve Anton3871f6f2018-01-26 18:25:53609 rtc::scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() {
Tommi87f70902021-04-27 12:43:08610 return rtc::make_ref_counted<FakePeerConnectionForStats>();
henrike@webrtc.org28e20752013-07-10 00:45:36611 }
612
Steve Anton3871f6f2018-01-26 18:25:53613 std::unique_ptr<StatsCollectorForTest> CreateStatsCollector(
614 PeerConnectionInternal* pc) {
Mirko Bonadei317a1f02019-09-17 15:06:18615 return std::make_unique<StatsCollectorForTest>(pc);
wu@webrtc.org97077a32013-10-25 21:18:33616 }
617
Steve Anton3871f6f2018-01-26 18:25:53618 void VerifyAudioTrackStats(FakeAudioTrack* audio_track,
619 StatsCollectorForTest* stats,
620 const VoiceMediaInfo& voice_info,
621 StatsReports* reports) {
xians@webrtc.org01bda202014-07-09 07:38:38622 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
Tommic811ab52022-01-11 15:33:23623 stats->InvalidateCache();
Steve Anton3871f6f2018-01-26 18:25:53624 stats->GetStats(nullptr, reports);
xians@webrtc.org01bda202014-07-09 07:38:38625
626 // Verify the existence of the track report.
Yves Gerey665174f2018-06-19 13:03:05627 const StatsReport* report =
628 FindNthReportByType(*reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:53629 ASSERT_TRUE(report);
jbauchbe24c942015-06-22 22:06:43630 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
Yves Gerey665174f2018-06-19 13:03:05631 std::string track_id =
632 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org01bda202014-07-09 07:38:38633 EXPECT_EQ(audio_track->id(), track_id);
Yves Gerey665174f2018-06-19 13:03:05634 std::string ssrc_id =
635 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:48636 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
xians@webrtc.org01bda202014-07-09 07:38:38637
Yves Gerey665174f2018-06-19 13:03:05638 std::string media_type =
639 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameMediaType);
fippobec70ab2016-01-28 09:27:15640 EXPECT_EQ("audio", media_type);
641
xians@webrtc.org01bda202014-07-09 07:38:38642 // Verifies the values in the track report.
Steve Anton3871f6f2018-01-26 18:25:53643 if (!voice_info.senders.empty()) {
644 VerifyVoiceSenderInfoReport(report, voice_info.senders[0]);
xians@webrtc.org01bda202014-07-09 07:38:38645 }
Steve Anton3871f6f2018-01-26 18:25:53646 if (!voice_info.receivers.empty()) {
647 VerifyVoiceReceiverInfoReport(report, voice_info.receivers[0]);
xians@webrtc.org01bda202014-07-09 07:38:38648 }
649
650 // Verify we get the same result by passing a track to GetStats().
651 StatsReports track_reports; // returned values.
652 stats->GetStats(audio_track, &track_reports);
653 const StatsReport* track_report = FindNthReportByType(
654 track_reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:53655 ASSERT_TRUE(track_report);
jbauchbe24c942015-06-22 22:06:43656 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
xians@webrtc.org01bda202014-07-09 07:38:38657 track_id = ExtractSsrcStatsValue(track_reports,
658 StatsReport::kStatsValueNameTrackId);
659 EXPECT_EQ(audio_track->id(), track_id);
Yves Gerey665174f2018-06-19 13:03:05660 ssrc_id =
661 ExtractSsrcStatsValue(track_reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:48662 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
Steve Anton3871f6f2018-01-26 18:25:53663 if (!voice_info.senders.empty()) {
664 VerifyVoiceSenderInfoReport(track_report, voice_info.senders[0]);
665 }
666 if (!voice_info.receivers.empty()) {
667 VerifyVoiceReceiverInfoReport(track_report, voice_info.receivers[0]);
668 }
henrike@webrtc.org40b3b682014-03-03 18:30:11669 }
670
Taylor Brandstetterc3928662018-02-23 21:04:51671 void TestCertificateReports(const rtc::FakeSSLIdentity& local_identity,
672 const std::vector<std::string>& local_ders,
673 const rtc::FakeSSLIdentity& remote_identity,
674 const std::vector<std::string>& remote_ders) {
Steve Anton3871f6f2018-01-26 18:25:53675 const std::string kTransportName = "transport";
decurtis@webrtc.org487a4442015-01-15 22:55:07676
Steve Anton3871f6f2018-01-26 18:25:53677 auto pc = CreatePeerConnection();
678 auto stats = CreateStatsCollector(pc);
679
Steve Anton5b387312018-02-03 00:00:20680 pc->AddVoiceChannel("audio", kTransportName);
wu@webrtc.org4551b792013-10-09 15:37:36681
682 // Fake stats to process.
Steve Anton3871f6f2018-01-26 18:25:53683 TransportChannelStats channel_stats;
wu@webrtc.org4551b792013-10-09 15:37:36684 channel_stats.component = 1;
Mirko Bonadei7750d802021-07-26 15:27:42685 channel_stats.srtp_crypto_suite = rtc::kSrtpAes128CmSha1_80;
tkchin7d06a8c2016-04-04 21:10:43686 channel_stats.ssl_cipher_suite =
687 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
Steve Anton3871f6f2018-01-26 18:25:53688 pc->SetTransportStats(kTransportName, channel_stats);
wu@webrtc.org4551b792013-10-09 15:37:36689
Taylor Brandstetterc3928662018-02-23 21:04:51690 // Fake certificate to report.
Henrik Boströmd8281982015-08-27 08:12:24691 rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
Harald Alvestrandb33a0ca2020-04-16 12:59:40692 rtc::RTCCertificate::Create(local_identity.Clone()));
Steve Anton3871f6f2018-01-26 18:25:53693 pc->SetLocalCertificate(kTransportName, local_certificate);
Taylor Brandstetterc3928662018-02-23 21:04:51694 pc->SetRemoteCertChain(kTransportName,
Steve Antonf25303e2018-10-16 22:23:31695 remote_identity.cert_chain().Clone());
wu@webrtc.org4551b792013-10-09 15:37:36696
Steve Anton3871f6f2018-01-26 18:25:53697 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
wu@webrtc.org4551b792013-10-09 15:37:36698
Steve Anton3871f6f2018-01-26 18:25:53699 StatsReports reports;
700 stats->GetStats(nullptr, &reports);
wu@webrtc.org4551b792013-10-09 15:37:36701
Yves Gerey665174f2018-06-19 13:03:05702 const StatsReport* channel_report =
703 FindNthReportByType(reports, StatsReport::kStatsReportTypeComponent, 1);
Steve Anton3871f6f2018-01-26 18:25:53704 EXPECT_TRUE(channel_report);
wu@webrtc.org4551b792013-10-09 15:37:36705
706 // Check local certificate chain.
Yves Gerey665174f2018-06-19 13:03:05707 std::string local_certificate_id =
708 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
709 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49710 if (local_ders.size() > 0) {
711 EXPECT_NE(kNotFound, local_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55712 StatsReport::Id id(IdFromCertIdString(local_certificate_id));
713 CheckCertChainReports(reports, local_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49714 } else {
715 EXPECT_EQ(kNotFound, local_certificate_id);
716 }
wu@webrtc.org4551b792013-10-09 15:37:36717
718 // Check remote certificate chain.
Yves Gerey665174f2018-06-19 13:03:05719 std::string remote_certificate_id =
720 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
721 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49722 if (remote_ders.size() > 0) {
723 EXPECT_NE(kNotFound, remote_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55724 StatsReport::Id id(IdFromCertIdString(remote_certificate_id));
725 CheckCertChainReports(reports, remote_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49726 } else {
727 EXPECT_EQ(kNotFound, remote_certificate_id);
728 }
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30729
730 // Check negotiated ciphers.
Guo-wei Shieh521ed7b2015-11-19 03:41:53731 std::string dtls_cipher_suite =
732 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
733 StatsReport::kStatsValueNameDtlsCipher);
734 EXPECT_EQ(rtc::SSLStreamAdapter::SslCipherSuiteToName(
tkchin7d06a8c2016-04-04 21:10:43735 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
Guo-wei Shieh521ed7b2015-11-19 03:41:53736 dtls_cipher_suite);
737 std::string srtp_crypto_suite =
738 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
739 StatsReport::kStatsValueNameSrtpCipher);
Mirko Bonadei7750d802021-07-26 15:27:42740 EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::kSrtpAes128CmSha1_80),
Guo-wei Shieh521ed7b2015-11-19 03:41:53741 srtp_crypto_suite);
wu@webrtc.org4551b792013-10-09 15:37:36742 }
Harald Alvestrand75ceef22018-01-04 14:26:13743};
744
Steve Antonefe4c922019-03-27 17:26:06745static rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
746 rtc::scoped_refptr<MediaStreamTrackInterface> track,
747 uint32_t ssrc) {
Tommi87f70902021-04-27 12:43:08748 auto sender = rtc::make_ref_counted<MockRtpSenderInternal>();
Steve Antonefe4c922019-03-27 17:26:06749 EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
750 EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
751 EXPECT_CALL(*sender, media_type())
752 .WillRepeatedly(
753 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
754 ? cricket::MEDIA_TYPE_AUDIO
755 : cricket::MEDIA_TYPE_VIDEO));
Tomas Gunnarsson16de2162022-01-26 09:21:57756 EXPECT_CALL(*sender, SetMediaChannel(_)).Times(AtMost(2));
757 EXPECT_CALL(*sender, SetTransceiverAsStopped()).Times(AtMost(1));
758 EXPECT_CALL(*sender, Stop());
Steve Antonefe4c922019-03-27 17:26:06759 return sender;
760}
761
762static rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
763 rtc::scoped_refptr<MediaStreamTrackInterface> track,
764 uint32_t ssrc) {
Tommi87f70902021-04-27 12:43:08765 auto receiver = rtc::make_ref_counted<MockRtpReceiverInternal>();
Steve Antonefe4c922019-03-27 17:26:06766 EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
767 EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Return(ssrc));
768 EXPECT_CALL(*receiver, media_type())
769 .WillRepeatedly(
770 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
771 ? cricket::MEDIA_TYPE_AUDIO
772 : cricket::MEDIA_TYPE_VIDEO));
Tommi6589def2022-02-17 22:36:47773 EXPECT_CALL(*receiver, SetMediaChannel(_)).WillRepeatedly(Return());
774 EXPECT_CALL(*receiver, Stop()).WillRepeatedly(Return());
Steve Antonefe4c922019-03-27 17:26:06775 return receiver;
776}
777
Harald Alvestrand75ceef22018-01-04 14:26:13778class StatsCollectorTrackTest : public StatsCollectorTest,
779 public ::testing::WithParamInterface<bool> {
780 public:
781 // Adds a outgoing video track with a given SSRC into the stats.
782 // If GetParam() returns true, the track is also inserted into the local
783 // stream, which is created if necessary.
Steve Anton3871f6f2018-01-26 18:25:53784 void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
785 StatsCollectorForTest* stats) {
786 track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(),
787 rtc::Thread::Current());
Harald Alvestrand75ceef22018-01-04 14:26:13788 if (GetParam()) {
789 if (!stream_)
Seth Hampson845e8782018-03-02 19:34:10790 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13791 stream_->AddTrack(track_);
792 stats->AddStream(stream_);
793 } else {
794 stats->AddTrack(track_);
795 }
Steve Antonefe4c922019-03-27 17:26:06796 pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13797 }
798
799 // Adds a incoming video track with a given SSRC into the stats.
Steve Anton3871f6f2018-01-26 18:25:53800 void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
801 StatsCollectorForTest* stats) {
802 track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(),
803 rtc::Thread::Current());
Harald Alvestrand75ceef22018-01-04 14:26:13804 if (GetParam()) {
Seth Hampson845e8782018-03-02 19:34:10805 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13806 stream_->AddTrack(track_);
807 stats->AddStream(stream_);
808 } else {
809 stats->AddTrack(track_);
810 }
Steve Antonefe4c922019-03-27 17:26:06811 pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13812 }
813
814 // Adds a outgoing audio track with a given SSRC into the stats,
815 // and register it into the stats object.
816 // If GetParam() returns true, the track is also inserted into the local
817 // stream, which is created if necessary.
Steve Antonefe4c922019-03-27 17:26:06818 rtc::scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack(
819 FakePeerConnectionForStats* pc,
820 StatsCollectorForTest* stats) {
Tommi87f70902021-04-27 12:43:08821 audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kLocalTrackId);
Harald Alvestrand75ceef22018-01-04 14:26:13822 if (GetParam()) {
823 if (!stream_)
Seth Hampson845e8782018-03-02 19:34:10824 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13825 stream_->AddTrack(audio_track_);
826 stats->AddStream(stream_);
827 } else {
828 stats->AddTrack(audio_track_);
829 }
Steve Antonefe4c922019-03-27 17:26:06830 return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13831 }
832
833 // Adds a incoming audio track with a given SSRC into the stats.
Steve Anton3871f6f2018-01-26 18:25:53834 void AddIncomingAudioTrack(FakePeerConnectionForStats* pc,
835 StatsCollectorForTest* stats) {
Tommi87f70902021-04-27 12:43:08836 audio_track_ = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
Harald Alvestrand75ceef22018-01-04 14:26:13837 if (GetParam()) {
838 if (stream_ == NULL)
Seth Hampson845e8782018-03-02 19:34:10839 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13840 stream_->AddTrack(audio_track_);
841 stats->AddStream(stream_);
842 } else {
843 stats->AddTrack(audio_track_);
844 }
Steve Antonefe4c922019-03-27 17:26:06845 pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13846 }
847
Steve Anton3871f6f2018-01-26 18:25:53848 rtc::scoped_refptr<MediaStream> stream_;
849 rtc::scoped_refptr<VideoTrack> track_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52850 rtc::scoped_refptr<FakeAudioTrack> audio_track_;
henrike@webrtc.org28e20752013-07-10 00:45:36851};
852
zhihuang6ba3b192016-05-13 18:46:35853TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {
Steve Anton3871f6f2018-01-26 18:25:53854 auto pc = CreatePeerConnection();
855 auto stats = CreateStatsCollector(pc);
zhihuang6ba3b192016-05-13 18:46:35856
Steve Anton3871f6f2018-01-26 18:25:53857 pc->AddSctpDataChannel("hacks");
zhihuang6ba3b192016-05-13 18:46:35858
Steve Anton3871f6f2018-01-26 18:25:53859 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
zhihuang6ba3b192016-05-13 18:46:35860 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:53861 stats->GetStats(nullptr, &reports);
zhihuang6ba3b192016-05-13 18:46:35862
863 const StatsReport* report =
864 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
865
866 std::string value_in_report;
867 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,
868 &value_in_report));
869}
870
decurtis@webrtc.org487a4442015-01-15 22:55:07871// Verify that ExtractDataInfo populates reports.
872TEST_F(StatsCollectorTest, ExtractDataInfo) {
Steve Anton3871f6f2018-01-26 18:25:53873 const std::string kDataChannelLabel = "hacks";
874 constexpr int kDataChannelId = 31337;
875 const std::string kConnectingString = DataChannelInterface::DataStateString(
decurtis@webrtc.org487a4442015-01-15 22:55:07876 DataChannelInterface::DataState::kConnecting);
877
Steve Anton3871f6f2018-01-26 18:25:53878 auto pc = CreatePeerConnection();
879 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:07880
Steve Anton3871f6f2018-01-26 18:25:53881 InternalDataChannelInit init;
882 init.id = kDataChannelId;
883 pc->AddSctpDataChannel(kDataChannelLabel, init);
decurtis@webrtc.org487a4442015-01-15 22:55:07884
Steve Anton3871f6f2018-01-26 18:25:53885 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
decurtis@webrtc.org487a4442015-01-15 22:55:07886 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:53887 stats->GetStats(nullptr, &reports);
decurtis@webrtc.org322a5642015-02-03 22:09:37888
889 const StatsReport* report =
890 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
891
Steve Anton3871f6f2018-01-26 18:25:53892 StatsReport::Id report_id = StatsReport::NewTypedIntId(
893 StatsReport::kStatsReportTypeDataChannel, kDataChannelId);
decurtis@webrtc.org322a5642015-02-03 22:09:37894
Steve Anton3871f6f2018-01-26 18:25:53895 EXPECT_TRUE(report_id->Equals(report->id()));
decurtis@webrtc.org322a5642015-02-03 22:09:37896
Steve Anton3871f6f2018-01-26 18:25:53897 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
898 EXPECT_EQ(kDataChannelLabel,
899 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
900 StatsReport::kStatsValueNameLabel));
Jonas Olsson6b1985d2018-07-05 09:59:48901 EXPECT_EQ(rtc::ToString(kDataChannelId),
Peter Boström0c4e06b2015-10-07 10:23:21902 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
decurtis@webrtc.org487a4442015-01-15 22:55:07903 StatsReport::kStatsValueNameDataChannelId));
Steve Anton3871f6f2018-01-26 18:25:53904 EXPECT_EQ(kConnectingString,
905 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
906 StatsReport::kStatsValueNameState));
Yves Gerey665174f2018-06-19 13:03:05907 EXPECT_EQ("",
908 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
909 StatsReport::kStatsValueNameProtocol));
decurtis@webrtc.org487a4442015-01-15 22:55:07910}
911
henrike@webrtc.org28e20752013-07-10 00:45:36912// This test verifies that 64-bit counters are passed successfully.
Harald Alvestrand75ceef22018-01-04 14:26:13913TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
henrike@webrtc.org28e20752013-07-10 00:45:36914 // The number of bytes must be larger than 0xFFFFFFFF for this test.
Steve Anton3871f6f2018-01-26 18:25:53915 constexpr int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36916
Steve Anton3871f6f2018-01-26 18:25:53917 auto pc = CreatePeerConnection();
918 auto stats = CreateStatsCollector(pc);
henrike@webrtc.org28e20752013-07-10 00:45:36919
Steve Anton3871f6f2018-01-26 18:25:53920 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:06921 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:33922 video_sender_info.payload_bytes_sent = kBytesSent;
923 video_sender_info.header_and_padding_bytes_sent = 0;
Steve Anton3871f6f2018-01-26 18:25:53924 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:46925 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:20926
Tommi19015512022-02-02 10:49:35927 pc->AddVideoChannel("video", "transport", video_info);
henrike@webrtc.org28e20752013-07-10 00:45:36928
Steve Anton3871f6f2018-01-26 18:25:53929 AddOutgoingVideoTrack(pc, stats.get());
930
931 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
932 StatsReports reports;
933 stats->GetStats(nullptr, &reports);
934
935 EXPECT_EQ(
936 rtc::ToString(kBytesSent),
937 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
henrike@webrtc.org28e20752013-07-10 00:45:36938}
939
Alex Narest42308f62017-06-19 15:58:12940// Test that audio BWE information is reported via stats.
Harald Alvestrand75ceef22018-01-04 14:26:13941TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) {
Alex Narest42308f62017-06-19 15:58:12942 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
943 // BWE.
Steve Anton3871f6f2018-01-26 18:25:53944 constexpr int64_t kBytesSent = 12345678901234LL;
945 constexpr int kSendBandwidth = 1234567;
946 constexpr int kRecvBandwidth = 12345678;
947 constexpr int kPacerDelay = 123;
Alex Narest42308f62017-06-19 15:58:12948
Steve Anton3871f6f2018-01-26 18:25:53949 auto pc = CreatePeerConnection();
950 auto stats = CreateStatsCollector(pc);
Alex Narest42308f62017-06-19 15:58:12951
Steve Anton3871f6f2018-01-26 18:25:53952 VoiceSenderInfo voice_sender_info;
Alex Narest42308f62017-06-19 15:58:12953 voice_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:33954 voice_sender_info.payload_bytes_sent = kBytesSent - 12;
955 voice_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:53956 VoiceMediaInfo voice_info;
957 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:20958
959 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
960 voice_media_channel->SetStats(voice_info);
Alex Narest42308f62017-06-19 15:58:12961
Steve Anton3871f6f2018-01-26 18:25:53962 AddOutgoingAudioTrack(pc, stats.get());
963
964 Call::Stats call_stats;
Alex Narest42308f62017-06-19 15:58:12965 call_stats.send_bandwidth_bps = kSendBandwidth;
966 call_stats.recv_bandwidth_bps = kRecvBandwidth;
967 call_stats.pacer_delay_ms = kPacerDelay;
Steve Anton3871f6f2018-01-26 18:25:53968 pc->SetCallStats(call_stats);
Alex Narest42308f62017-06-19 15:58:12969
Steve Anton3871f6f2018-01-26 18:25:53970 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
971 StatsReports reports;
972 stats->GetStats(nullptr, &reports);
973
974 EXPECT_EQ(
975 rtc::ToString(kBytesSent),
976 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
977 EXPECT_EQ(rtc::ToString(kSendBandwidth),
978 ExtractBweStatsValue(
979 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
980 EXPECT_EQ(
981 rtc::ToString(kRecvBandwidth),
982 ExtractBweStatsValue(
983 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
984 EXPECT_EQ(
985 rtc::ToString(kPacerDelay),
986 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
Alex Narest42308f62017-06-19 15:58:12987}
988
989// Test that video BWE information is reported via stats.
Harald Alvestrand75ceef22018-01-04 14:26:13990TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
henrike@webrtc.org28e20752013-07-10 00:45:36991 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
992 // BWE.
Steve Anton3871f6f2018-01-26 18:25:53993 constexpr int64_t kBytesSent = 12345678901234LL;
994 constexpr int kSendBandwidth = 1234567;
995 constexpr int kRecvBandwidth = 12345678;
996 constexpr int kPacerDelay = 123;
henrike@webrtc.org28e20752013-07-10 00:45:36997
Steve Anton3871f6f2018-01-26 18:25:53998 auto pc = CreatePeerConnection();
999 auto stats = CreateStatsCollector(pc);
henrike@webrtc.org28e20752013-07-10 00:45:361000
Steve Anton3871f6f2018-01-26 18:25:531001 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061002 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:331003 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1004 video_sender_info.header_and_padding_bytes_sent = 12;
1005
Steve Anton3871f6f2018-01-26 18:25:531006 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:461007 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201008
Tommi19015512022-02-02 10:49:351009 pc->AddVideoChannel("video", "transport", video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361010
Steve Anton3871f6f2018-01-26 18:25:531011 AddOutgoingVideoTrack(pc, stats.get());
1012
1013 Call::Stats call_stats;
stefanf79ade12017-06-02 13:44:031014 call_stats.send_bandwidth_bps = kSendBandwidth;
1015 call_stats.recv_bandwidth_bps = kRecvBandwidth;
1016 call_stats.pacer_delay_ms = kPacerDelay;
Steve Anton3871f6f2018-01-26 18:25:531017 pc->SetCallStats(call_stats);
wu@webrtc.org97077a32013-10-25 21:18:331018
Steve Anton3871f6f2018-01-26 18:25:531019 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1020 StatsReports reports;
1021 stats->GetStats(nullptr, &reports);
1022
1023 EXPECT_EQ(
1024 rtc::ToString(kBytesSent),
1025 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
1026 EXPECT_EQ(rtc::ToString(kSendBandwidth),
1027 ExtractBweStatsValue(
1028 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
1029 EXPECT_EQ(
1030 rtc::ToString(kRecvBandwidth),
1031 ExtractBweStatsValue(
1032 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
1033 EXPECT_EQ(
1034 rtc::ToString(kPacerDelay),
1035 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
henrike@webrtc.org28e20752013-07-10 00:45:361036}
1037
1038// This test verifies that an object of type "googSession" always
1039// exists in the returned stats.
1040TEST_F(StatsCollectorTest, SessionObjectExists) {
Steve Anton3871f6f2018-01-26 18:25:531041 auto pc = CreatePeerConnection();
1042 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071043
Steve Anton3871f6f2018-01-26 18:25:531044 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1045 StatsReports reports;
1046 stats->GetStats(nullptr, &reports);
1047
1048 EXPECT_TRUE(
1049 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
henrike@webrtc.org28e20752013-07-10 00:45:361050}
1051
1052// This test verifies that only one object of type "googSession" exists
1053// in the returned stats.
1054TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
Steve Anton3871f6f2018-01-26 18:25:531055 auto pc = CreatePeerConnection();
1056 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071057
Steve Anton3871f6f2018-01-26 18:25:531058 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1059 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1060 StatsReports reports;
1061 stats->GetStats(nullptr, &reports);
1062
1063 EXPECT_TRUE(
1064 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
1065 EXPECT_FALSE(
1066 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 2));
henrike@webrtc.org28e20752013-07-10 00:45:361067}
1068
1069// This test verifies that the empty track report exists in the returned stats
1070// without calling StatsCollector::UpdateStats.
Harald Alvestrand75ceef22018-01-04 14:26:131071TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) {
Steve Anton3871f6f2018-01-26 18:25:531072 auto pc = CreatePeerConnection();
1073 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071074
Steve Anton5b387312018-02-03 00:00:201075 pc->AddVideoChannel("video", "transport");
Steve Anton3871f6f2018-01-26 18:25:531076 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361077
henrike@webrtc.org28e20752013-07-10 00:45:361078 // Verfies the existence of the track report.
tommi@webrtc.org03505bc2014-07-14 20:15:261079 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531080 stats->GetStats(nullptr, &reports);
1081 ASSERT_EQ(1u, reports.size());
tommi@webrtc.org4fb7e252015-01-21 11:36:181082 EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
jbauchbe24c942015-06-22 22:06:431083 EXPECT_EQ(0, reports[0]->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:361084
1085 std::string trackValue =
Yves Gerey665174f2018-06-19 13:03:051086 ExtractStatsValue(StatsReport::kStatsReportTypeTrack, reports,
henrike@webrtc.org40b3b682014-03-03 18:30:111087 StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051088 EXPECT_EQ(kLocalTrackId, trackValue);
henrike@webrtc.org28e20752013-07-10 00:45:361089}
1090
1091// This test verifies that the empty track report exists in the returned stats
1092// when StatsCollector::UpdateStats is called with ssrc stats.
Harald Alvestrand75ceef22018-01-04 14:26:131093TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
Steve Anton3871f6f2018-01-26 18:25:531094 constexpr int64_t kBytesSent = 12345678901234LL;
decurtis@webrtc.org487a4442015-01-15 22:55:071095
Steve Anton3871f6f2018-01-26 18:25:531096 auto pc = CreatePeerConnection();
1097 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271098
Steve Anton3871f6f2018-01-26 18:25:531099 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061100 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:331101 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1102 video_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:531103 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:461104 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201105
Tommi19015512022-02-02 10:49:351106 pc->AddVideoChannel("video", "transport", video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361107
Steve Anton3871f6f2018-01-26 18:25:531108 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361109
Steve Anton3871f6f2018-01-26 18:25:531110 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261111 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531112 stats->GetStats(nullptr, &reports);
1113
Artem Titov880fa812021-07-30 20:30:231114 // `reports` should contain at least one session report, one track report,
wu@webrtc.org97077a32013-10-25 21:18:331115 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531116 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051117 const StatsReport* track_report =
1118 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
xians@webrtc.org4cb01282014-06-12 14:57:051119 EXPECT_TRUE(track_report);
henrike@webrtc.org28e20752013-07-10 00:45:361120
Artem Titov880fa812021-07-30 20:30:231121 // Get report for the specific `track`.
tommi@webrtc.org5b06b062014-08-15 08:38:301122 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531123 stats->GetStats(track_, &reports);
Artem Titov880fa812021-07-30 20:30:231124 // `reports` should contain at least one session report, one track report,
wu@webrtc.org97077a32013-10-25 21:18:331125 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531126 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051127 track_report =
1128 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131129 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531130 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:361131
Yves Gerey665174f2018-06-19 13:03:051132 std::string ssrc_id =
1133 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481134 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org28e20752013-07-10 00:45:361135
Yves Gerey665174f2018-06-19 13:03:051136 std::string track_id =
1137 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051138 EXPECT_EQ(kLocalTrackId, track_id);
fippobec70ab2016-01-28 09:27:151139
Yves Gerey665174f2018-06-19 13:03:051140 std::string media_type =
1141 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameMediaType);
fippobec70ab2016-01-28 09:27:151142 EXPECT_EQ("video", media_type);
henrike@webrtc.org28e20752013-07-10 00:45:361143}
1144
1145// This test verifies that an SSRC object has the identifier of a Transport
1146// stats object, and that this transport stats object exists in stats.
Harald Alvestrand75ceef22018-01-04 14:26:131147TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
Steve Anton3871f6f2018-01-26 18:25:531148 constexpr int64_t kBytesSent = 12345678901234LL;
decurtis@webrtc.org487a4442015-01-15 22:55:071149
Steve Anton3871f6f2018-01-26 18:25:531150 auto pc = CreatePeerConnection();
1151 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271152
Steve Anton3871f6f2018-01-26 18:25:531153 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061154 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:331155 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1156 video_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:531157 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:461158 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201159
Tommi19015512022-02-02 10:49:351160 pc->AddVideoChannel("video", "transport", video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361161
Steve Anton3871f6f2018-01-26 18:25:531162 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361163
Steve Anton3871f6f2018-01-26 18:25:531164 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261165 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531166 stats->GetStats(nullptr, &reports);
1167
Yves Gerey665174f2018-06-19 13:03:051168 std::string transport_id =
1169 ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports,
1170 StatsReport::kStatsValueNameTransportId);
henrike@webrtc.org28e20752013-07-10 00:45:361171 ASSERT_NE(kNotFound, transport_id);
Steve Anton3871f6f2018-01-26 18:25:531172
tommi@webrtc.org4fb7e252015-01-21 11:36:181173 // Transport id component ID will always be 1.
1174 // This has assumptions about how the ID is constructed. As is, this is
1175 // OK since this is for testing purposes only, but if we ever need this
1176 // in production, we should add a generic method that does this.
1177 size_t index = transport_id.find('-');
1178 ASSERT_NE(std::string::npos, index);
1179 std::string content = transport_id.substr(index + 1);
1180 index = content.rfind('-');
1181 ASSERT_NE(std::string::npos, index);
1182 content = content.substr(0, index);
tommi@webrtc.orgd3900292015-03-12 16:35:551183 StatsReport::Id id(StatsReport::NewComponentId(content, 1));
tommi@webrtc.org4fb7e252015-01-21 11:36:181184 ASSERT_EQ(transport_id, id->ToString());
tommi@webrtc.orgd3900292015-03-12 16:35:551185 const StatsReport* transport_report = FindReportById(reports, id);
Steve Anton3871f6f2018-01-26 18:25:531186 ASSERT_TRUE(transport_report);
henrike@webrtc.org28e20752013-07-10 00:45:361187}
1188
wu@webrtc.org97077a32013-10-25 21:18:331189// This test verifies that a remote stats object will not be created for
1190// an outgoing SSRC where remote stats are not returned.
Harald Alvestrand75ceef22018-01-04 14:26:131191TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) {
Steve Anton3871f6f2018-01-26 18:25:531192 auto pc = CreatePeerConnection();
1193 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071194
Steve Anton5b387312018-02-03 00:00:201195 pc->AddVideoChannel("video", "transport");
Steve Anton3871f6f2018-01-26 18:25:531196 AddOutgoingVideoTrack(pc, stats.get());
wu@webrtc.org97077a32013-10-25 21:18:331197
Steve Anton3871f6f2018-01-26 18:25:531198 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org40b3b682014-03-03 18:30:111199 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531200 stats->GetStats(nullptr, &reports);
1201
Yves Gerey665174f2018-06-19 13:03:051202 const StatsReport* remote_report =
1203 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531204 EXPECT_FALSE(remote_report);
wu@webrtc.org97077a32013-10-25 21:18:331205}
1206
1207// This test verifies that a remote stats object will be created for
1208// an outgoing SSRC where stats are returned.
Harald Alvestrand75ceef22018-01-04 14:26:131209TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
Steve Anton3871f6f2018-01-26 18:25:531210 auto pc = CreatePeerConnection();
1211 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071212
Steve Anton3871f6f2018-01-26 18:25:531213 SsrcReceiverInfo remote_ssrc_stats;
wu@webrtc.org97077a32013-10-25 21:18:331214 remote_ssrc_stats.timestamp = 12345.678;
1215 remote_ssrc_stats.ssrc = kSsrcOfTrack;
Steve Anton3871f6f2018-01-26 18:25:531216 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061217 video_sender_info.add_ssrc(kSsrcOfTrack);
wu@webrtc.org97077a32013-10-25 21:18:331218 video_sender_info.remote_stats.push_back(remote_ssrc_stats);
Steve Anton3871f6f2018-01-26 18:25:531219 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:461220 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201221
Tommi19015512022-02-02 10:49:351222 pc->AddVideoChannel("video", "transport", video_info);
wu@webrtc.org97077a32013-10-25 21:18:331223
Steve Anton3871f6f2018-01-26 18:25:531224 AddOutgoingVideoTrack(pc, stats.get());
wu@webrtc.org97077a32013-10-25 21:18:331225
Steve Anton3871f6f2018-01-26 18:25:531226 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261227 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531228 stats->GetStats(nullptr, &reports);
xians@webrtc.org4cb01282014-06-12 14:57:051229
Yves Gerey665174f2018-06-19 13:03:051230 const StatsReport* remote_report =
1231 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531232 ASSERT_TRUE(remote_report);
decurtis@webrtc.org322a5642015-02-03 22:09:371233 EXPECT_EQ(12345.678, remote_report->timestamp());
wu@webrtc.org97077a32013-10-25 21:18:331234}
1235
xians@webrtc.org4cb01282014-06-12 14:57:051236// This test verifies that the empty track report exists in the returned stats
1237// when StatsCollector::UpdateStats is called with ssrc stats.
Harald Alvestrand75ceef22018-01-04 14:26:131238TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) {
Steve Anton3871f6f2018-01-26 18:25:531239 constexpr int64_t kNumOfPacketsConcealed = 54321;
decurtis@webrtc.org487a4442015-01-15 22:55:071240
Steve Anton3871f6f2018-01-26 18:25:531241 auto pc = CreatePeerConnection();
1242 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271243
Steve Anton3871f6f2018-01-26 18:25:531244 VideoReceiverInfo video_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051245 video_receiver_info.add_ssrc(1234);
pbos@webrtc.org1ed62242015-02-19 13:57:031246 video_receiver_info.packets_concealed = kNumOfPacketsConcealed;
Steve Anton3871f6f2018-01-26 18:25:531247 VideoMediaInfo video_info;
1248 video_info.receivers.push_back(video_receiver_info);
Steve Anton5b387312018-02-03 00:00:201249
Tommi19015512022-02-02 10:49:351250 pc->AddVideoChannel("video", "transport", video_info);
xians@webrtc.org4cb01282014-06-12 14:57:051251
Steve Anton3871f6f2018-01-26 18:25:531252 AddIncomingVideoTrack(pc, stats.get());
xians@webrtc.org4cb01282014-06-12 14:57:051253
Steve Anton3871f6f2018-01-26 18:25:531254 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261255 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531256 stats->GetStats(nullptr, &reports);
1257
Artem Titov880fa812021-07-30 20:30:231258 // `reports` should contain at least one session report, one track report,
xians@webrtc.org4cb01282014-06-12 14:57:051259 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531260 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051261 const StatsReport* track_report =
1262 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131263 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531264 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
xians@webrtc.org4cb01282014-06-12 14:57:051265
Yves Gerey665174f2018-06-19 13:03:051266 std::string ssrc_id =
1267 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481268 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
xians@webrtc.org4cb01282014-06-12 14:57:051269
Yves Gerey665174f2018-06-19 13:03:051270 std::string track_id =
1271 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051272 EXPECT_EQ(kRemoteTrackId, track_id);
1273}
1274
guoweis@webrtc.org950c5182014-12-16 23:01:311275// This test verifies the Ice Candidate report should contain the correct
1276// information from local/remote candidates.
1277TEST_F(StatsCollectorTest, IceCandidateReport) {
Steve Anton3871f6f2018-01-26 18:25:531278 const std::string kTransportName = "transport";
1279 const rtc::AdapterType kNetworkType = rtc::ADAPTER_TYPE_ETHERNET;
1280 constexpr uint32_t kPriority = 1000;
decurtis@webrtc.org487a4442015-01-15 22:55:071281
Steve Anton3871f6f2018-01-26 18:25:531282 constexpr int kLocalPort = 2000;
1283 const std::string kLocalIp = "192.168.0.1";
1284 const rtc::SocketAddress kLocalAddress(kLocalIp, kLocalPort);
guoweis@webrtc.org950c5182014-12-16 23:01:311285
Steve Anton3871f6f2018-01-26 18:25:531286 constexpr int kRemotePort = 2001;
1287 const std::string kRemoteIp = "192.168.0.2";
1288 const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
guoweis@webrtc.org950c5182014-12-16 23:01:311289
Steve Anton3871f6f2018-01-26 18:25:531290 auto pc = CreatePeerConnection();
1291 auto stats = CreateStatsCollector(pc);
guoweis@webrtc.org950c5182014-12-16 23:01:311292
Steve Anton3871f6f2018-01-26 18:25:531293 cricket::Candidate local;
1294 EXPECT_GT(local.id().length(), 0u);
1295 local.set_type(cricket::LOCAL_PORT_TYPE);
1296 local.set_protocol(cricket::UDP_PROTOCOL_NAME);
1297 local.set_address(kLocalAddress);
1298 local.set_priority(kPriority);
1299 local.set_network_type(kNetworkType);
guoweis@webrtc.org950c5182014-12-16 23:01:311300
Steve Anton3871f6f2018-01-26 18:25:531301 cricket::Candidate remote;
1302 EXPECT_GT(remote.id().length(), 0u);
1303 remote.set_type(cricket::PRFLX_PORT_TYPE);
1304 remote.set_protocol(cricket::UDP_PROTOCOL_NAME);
1305 remote.set_address(kRemoteAddress);
1306 remote.set_priority(kPriority);
1307 remote.set_network_type(kNetworkType);
guoweis@webrtc.org950c5182014-12-16 23:01:311308
Steve Anton3871f6f2018-01-26 18:25:531309 ConnectionInfo connection_info;
1310 connection_info.local_candidate = local;
1311 connection_info.remote_candidate = remote;
1312 TransportChannelStats channel_stats;
Jonas Oreland149dc722019-08-28 06:10:271313 channel_stats.ice_transport_stats.connection_infos.push_back(connection_info);
Steve Anton3871f6f2018-01-26 18:25:531314
Steve Anton5b387312018-02-03 00:00:201315 pc->AddVoiceChannel("audio", kTransportName);
Steve Anton3871f6f2018-01-26 18:25:531316 pc->SetTransportStats(kTransportName, channel_stats);
1317
1318 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1319 StatsReports reports;
1320 stats->GetStats(nullptr, &reports);
guoweis@webrtc.org950c5182014-12-16 23:01:311321
1322 // Verify the local candidate report is populated correctly.
1323 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531324 "Cand-" + local.id(),
1325 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1326 StatsReport::kStatsValueNameLocalCandidateId));
1327 EXPECT_EQ(
1328 kLocalIp,
guoweis@webrtc.org950c5182014-12-16 23:01:311329 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1330 StatsReport::kStatsValueNameCandidateIPAddress));
1331 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531332 rtc::ToString(kLocalPort),
guoweis@webrtc.org950c5182014-12-16 23:01:311333 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1334 StatsReport::kStatsValueNameCandidatePortNumber));
1335 EXPECT_EQ(
1336 cricket::UDP_PROTOCOL_NAME,
1337 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1338 StatsReport::kStatsValueNameCandidateTransportType));
1339 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531340 rtc::ToString(kPriority),
guoweis@webrtc.org950c5182014-12-16 23:01:311341 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1342 StatsReport::kStatsValueNameCandidatePriority));
1343 EXPECT_EQ(
1344 IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),
1345 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1346 StatsReport::kStatsValueNameCandidateType));
1347 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531348 AdapterTypeToStatsType(kNetworkType),
guoweis@webrtc.org950c5182014-12-16 23:01:311349 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1350 StatsReport::kStatsValueNameCandidateNetworkType));
1351
1352 // Verify the remote candidate report is populated correctly.
Steve Anton3871f6f2018-01-26 18:25:531353 EXPECT_EQ(
1354 "Cand-" + remote.id(),
1355 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1356 StatsReport::kStatsValueNameRemoteCandidateId));
1357 EXPECT_EQ(kRemoteIp,
guoweis@webrtc.org950c5182014-12-16 23:01:311358 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1359 reports,
1360 StatsReport::kStatsValueNameCandidateIPAddress));
Steve Anton3871f6f2018-01-26 18:25:531361 EXPECT_EQ(rtc::ToString(kRemotePort),
guoweis@webrtc.org950c5182014-12-16 23:01:311362 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1363 reports,
1364 StatsReport::kStatsValueNameCandidatePortNumber));
1365 EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
1366 ExtractStatsValue(
1367 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1368 StatsReport::kStatsValueNameCandidateTransportType));
Steve Anton3871f6f2018-01-26 18:25:531369 EXPECT_EQ(rtc::ToString(kPriority),
guoweis@webrtc.org950c5182014-12-16 23:01:311370 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1371 reports,
1372 StatsReport::kStatsValueNameCandidatePriority));
1373 EXPECT_EQ(
1374 IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),
1375 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1376 reports, StatsReport::kStatsValueNameCandidateType));
1377 EXPECT_EQ(kNotFound,
1378 ExtractStatsValue(
1379 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1380 StatsReport::kStatsValueNameCandidateNetworkType));
1381}
1382
wu@webrtc.org4551b792013-10-09 15:37:361383// This test verifies that all chained certificates are correctly
1384// reported
mallinath@webrtc.org19f27e62013-10-13 17:18:271385TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:361386 // Build local certificate chain.
1387 std::vector<std::string> local_ders(5);
1388 local_ders[0] = "These";
1389 local_ders[1] = "are";
1390 local_ders[2] = "some";
1391 local_ders[3] = "der";
1392 local_ders[4] = "values";
Taylor Brandstetterc3928662018-02-23 21:04:511393 rtc::FakeSSLIdentity local_identity(DersToPems(local_ders));
wu@webrtc.org4551b792013-10-09 15:37:361394
1395 // Build remote certificate chain
1396 std::vector<std::string> remote_ders(4);
1397 remote_ders[0] = "A";
1398 remote_ders[1] = "non-";
1399 remote_ders[2] = "intersecting";
1400 remote_ders[3] = "set";
Taylor Brandstetterc3928662018-02-23 21:04:511401 rtc::FakeSSLIdentity remote_identity(DersToPems(remote_ders));
wu@webrtc.org4551b792013-10-09 15:37:361402
Taylor Brandstetterc3928662018-02-23 21:04:511403 TestCertificateReports(local_identity, local_ders, remote_identity,
kwibergb4d01c42016-04-06 12:15:061404 remote_ders);
wu@webrtc.org4551b792013-10-09 15:37:361405}
1406
1407// This test verifies that all certificates without chains are correctly
1408// reported.
mallinath@webrtc.org19f27e62013-10-13 17:18:271409TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:361410 // Build local certificate.
1411 std::string local_der = "This is the local der.";
Taylor Brandstetterc3928662018-02-23 21:04:511412 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
wu@webrtc.org4551b792013-10-09 15:37:361413
1414 // Build remote certificate.
1415 std::string remote_der = "This is somebody else's der.";
Taylor Brandstetterc3928662018-02-23 21:04:511416 rtc::FakeSSLIdentity remote_identity(DerToPem(remote_der));
wu@webrtc.org4551b792013-10-09 15:37:361417
Taylor Brandstetterc3928662018-02-23 21:04:511418 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1419 remote_identity,
kwibergb4d01c42016-04-06 12:15:061420 std::vector<std::string>(1, remote_der));
wu@webrtc.org4551b792013-10-09 15:37:361421}
1422
1423// This test verifies that the stats are generated correctly when no
1424// transport is present.
mallinath@webrtc.org19f27e62013-10-13 17:18:271425TEST_F(StatsCollectorTest, NoTransport) {
Steve Anton3871f6f2018-01-26 18:25:531426 auto pc = CreatePeerConnection();
1427 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071428
Steve Anton3871f6f2018-01-26 18:25:531429 // This will cause the fake PeerConnection to generate a TransportStats entry
1430 // but with only a single dummy TransportChannelStats.
Steve Anton5b387312018-02-03 00:00:201431 pc->AddVoiceChannel("audio", "transport");
deadbeefcbecd352015-09-23 18:50:271432
Steve Anton3871f6f2018-01-26 18:25:531433 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1434 StatsReports reports;
1435 stats->GetStats(nullptr, &reports);
wu@webrtc.org4551b792013-10-09 15:37:361436
1437 // Check that the local certificate is absent.
Yves Gerey665174f2018-06-19 13:03:051438 std::string local_certificate_id =
1439 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1440 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:361441 ASSERT_EQ(kNotFound, local_certificate_id);
1442
1443 // Check that the remote certificate is absent.
Yves Gerey665174f2018-06-19 13:03:051444 std::string remote_certificate_id =
1445 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1446 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:361447 ASSERT_EQ(kNotFound, remote_certificate_id);
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:301448
1449 // Check that the negotiated ciphers are absent.
Guo-wei Shieh521ed7b2015-11-19 03:41:531450 std::string dtls_cipher_suite =
1451 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1452 StatsReport::kStatsValueNameDtlsCipher);
1453 ASSERT_EQ(kNotFound, dtls_cipher_suite);
1454 std::string srtp_crypto_suite =
1455 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1456 StatsReport::kStatsValueNameSrtpCipher);
1457 ASSERT_EQ(kNotFound, srtp_crypto_suite);
wu@webrtc.org4551b792013-10-09 15:37:361458}
1459
wu@webrtc.orgb9a088b2014-02-13 23:18:491460// This test verifies that a remote certificate with an unsupported digest
1461// algorithm is correctly ignored.
1462TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
1463 // Build a local certificate.
1464 std::string local_der = "This is the local der.";
Taylor Brandstetterc3928662018-02-23 21:04:511465 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
wu@webrtc.orgb9a088b2014-02-13 23:18:491466
1467 // Build a remote certificate with an unsupported digest algorithm.
1468 std::string remote_der = "This is somebody else's der.";
Taylor Brandstetterc3928662018-02-23 21:04:511469 rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
1470 remote_cert.set_digest_algorithm("foobar");
1471 rtc::FakeSSLIdentity remote_identity(remote_cert);
wu@webrtc.orgb9a088b2014-02-13 23:18:491472
Taylor Brandstetterc3928662018-02-23 21:04:511473 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1474 remote_identity, std::vector<std::string>());
wu@webrtc.orgb9a088b2014-02-13 23:18:491475}
1476
zhihuang6ba3b192016-05-13 18:46:351477// This test verifies that the audio/video related stats which are -1 initially
1478// will be filtered out.
Harald Alvestrand75ceef22018-01-04 14:26:131479TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
Harald Alvestrand75ceef22018-01-04 14:26:131480 // This test uses streams, but only works for the stream case.
Steve Anton3871f6f2018-01-26 18:25:531481 if (!GetParam()) {
Harald Alvestrand75ceef22018-01-04 14:26:131482 return;
Steve Anton3871f6f2018-01-26 18:25:531483 }
zhihuang6ba3b192016-05-13 18:46:351484
Steve Anton3871f6f2018-01-26 18:25:531485 auto pc = CreatePeerConnection();
1486 auto stats = CreateStatsCollector(pc);
zhihuang6ba3b192016-05-13 18:46:351487
1488 // Create a local stream with a local audio track and adds it to the stats.
Seth Hampson845e8782018-03-02 19:34:101489 stream_ = MediaStream::Create("streamid");
Tommi87f70902021-04-27 12:43:081490 auto local_track =
1491 rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
zhihuang6ba3b192016-05-13 18:46:351492 stream_->AddTrack(local_track);
Steve Antonefe4c922019-03-27 17:26:061493 pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:131494 if (GetParam()) {
Steve Anton3871f6f2018-01-26 18:25:531495 stats->AddStream(stream_);
Harald Alvestrand75ceef22018-01-04 14:26:131496 }
Steve Anton3871f6f2018-01-26 18:25:531497 stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
zhihuang6ba3b192016-05-13 18:46:351498
1499 // Create a remote stream with a remote audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531500 rtc::scoped_refptr<MediaStream> remote_stream(
Seth Hampson845e8782018-03-02 19:34:101501 MediaStream::Create("remotestreamid"));
Tommi87f70902021-04-27 12:43:081502 auto remote_track =
1503 rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kRemoteTrackId);
zhihuang6ba3b192016-05-13 18:46:351504 remote_stream->AddTrack(remote_track);
Steve Antonefe4c922019-03-27 17:26:061505 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:131506 if (GetParam()) {
Steve Anton3871f6f2018-01-26 18:25:531507 stats->AddStream(remote_stream);
Harald Alvestrand75ceef22018-01-04 14:26:131508 }
zhihuang6ba3b192016-05-13 18:46:351509
Steve Anton3871f6f2018-01-26 18:25:531510 VoiceSenderInfo voice_sender_info;
zhihuang6ba3b192016-05-13 18:46:351511 voice_sender_info.add_ssrc(kSsrcOfTrack);
1512 // These values are set to -1 initially in audio_send_stream.
1513 // The voice_sender_info will read the values from audio_send_stream.
1514 voice_sender_info.rtt_ms = -1;
1515 voice_sender_info.packets_lost = -1;
1516 voice_sender_info.jitter_ms = -1;
1517
Artem Titov880fa812021-07-30 20:30:231518 // Some of the contents in `voice_sender_info` needs to be updated from the
1519 // `audio_track_`.
Ivo Creusen56d460902017-11-24 16:29:591520 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &voice_sender_info,
1521 true);
zhihuang6ba3b192016-05-13 18:46:351522
Steve Anton3871f6f2018-01-26 18:25:531523 VoiceReceiverInfo voice_receiver_info;
zhihuang6ba3b192016-05-13 18:46:351524 voice_receiver_info.add_ssrc(kSsrcOfTrack);
1525 voice_receiver_info.capture_start_ntp_time_ms = -1;
1526 voice_receiver_info.audio_level = -1;
1527
1528 // Constructs an ssrc stats update.
Steve Anton3871f6f2018-01-26 18:25:531529 VoiceMediaInfo voice_info;
1530 voice_info.senders.push_back(voice_sender_info);
1531 voice_info.receivers.push_back(voice_receiver_info);
zhihuang6ba3b192016-05-13 18:46:351532
Steve Anton5b387312018-02-03 00:00:201533 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1534 voice_media_channel->SetStats(voice_info);
zhihuang6ba3b192016-05-13 18:46:351535
Steve Anton3871f6f2018-01-26 18:25:531536 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
zhihuang6ba3b192016-05-13 18:46:351537
1538 // Get stats for the local track.
Steve Anton3871f6f2018-01-26 18:25:531539 StatsReports reports;
1540 stats->GetStats(local_track.get(), &reports);
zhihuang6ba3b192016-05-13 18:46:351541 const StatsReport* report =
1542 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131543 ASSERT_TRUE(report);
zhihuang6ba3b192016-05-13 18:46:351544 // The -1 will not be added to the stats report.
1545 std::string value_in_report;
1546 EXPECT_FALSE(
1547 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
1548 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
1549 &value_in_report));
1550 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
1551 &value_in_report));
zhihuang6ba3b192016-05-13 18:46:351552 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
1553 &value_in_report));
1554 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
1555 &value_in_report));
1556
1557 // Get stats for the remote track.
1558 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531559 stats->GetStats(remote_track.get(), &reports);
zhihuang6ba3b192016-05-13 18:46:351560 report = FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131561 ASSERT_TRUE(report);
zhihuang6ba3b192016-05-13 18:46:351562 EXPECT_FALSE(GetValue(report,
1563 StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
1564 &value_in_report));
1565 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
1566 &value_in_report));
1567}
1568
henrike@webrtc.org40b3b682014-03-03 18:30:111569// This test verifies that a local stats object can get statistics via
1570// AudioTrackInterface::GetStats() method.
Harald Alvestrand75ceef22018-01-04 14:26:131571TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
Steve Anton3871f6f2018-01-26 18:25:531572 auto pc = CreatePeerConnection();
1573 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071574
Steve Anton3871f6f2018-01-26 18:25:531575 AddOutgoingAudioTrack(pc, stats.get());
1576 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
tommi@webrtc.org242068d2014-07-14 20:19:561577
Steve Anton3871f6f2018-01-26 18:25:531578 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051579 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531580 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
1581 VoiceMediaInfo voice_info;
1582 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201583
1584 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1585 voice_media_channel->SetStats(voice_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111586
henrike@webrtc.org40b3b682014-03-03 18:30:111587 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531588 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:111589
xians@webrtc.org4cb01282014-06-12 14:57:051590 // Verify that there is no remote report for the local audio track because
1591 // we did not set it up.
Yves Gerey665174f2018-06-19 13:03:051592 const StatsReport* remote_report =
1593 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
xians@webrtc.org4cb01282014-06-12 14:57:051594 EXPECT_TRUE(remote_report == NULL);
1595}
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101596
1597// This test verifies that audio receive streams populate stats reports
1598// correctly.
Harald Alvestrand75ceef22018-01-04 14:26:131599TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) {
Steve Anton3871f6f2018-01-26 18:25:531600 auto pc = CreatePeerConnection();
1601 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071602
Steve Anton3871f6f2018-01-26 18:25:531603 AddIncomingAudioTrack(pc, stats.get());
deadbeefcbecd352015-09-23 18:50:271604
Steve Anton3871f6f2018-01-26 18:25:531605 VoiceReceiverInfo voice_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051606 InitVoiceReceiverInfo(&voice_receiver_info);
buildbot@webrtc.org7e71b772014-06-13 01:14:011607 voice_receiver_info.codec_name = "fake_codec";
Steve Anton3871f6f2018-01-26 18:25:531608 VoiceMediaInfo voice_info;
1609 voice_info.receivers.push_back(voice_receiver_info);
Steve Anton5b387312018-02-03 00:00:201610
1611 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1612 voice_media_channel->SetStats(voice_info);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101613
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101614 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531615 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101616}
1617
henrike@webrtc.org40b3b682014-03-03 18:30:111618// This test verifies that a local stats object won't update its statistics
1619// after a RemoveLocalAudioTrack() call.
Harald Alvestrand75ceef22018-01-04 14:26:131620TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) {
Steve Anton3871f6f2018-01-26 18:25:531621 auto pc = CreatePeerConnection();
1622 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071623
Steve Anton3871f6f2018-01-26 18:25:531624 AddOutgoingAudioTrack(pc, stats.get());
1625 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
deadbeefcbecd352015-09-23 18:50:271626
Steve Anton3871f6f2018-01-26 18:25:531627 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051628 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531629 VoiceMediaInfo voice_info;
1630 voice_info.senders.push_back(voice_sender_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111631
Steve Anton5b387312018-02-03 00:00:201632 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1633 voice_media_channel->SetStats(voice_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111634
Steve Anton3871f6f2018-01-26 18:25:531635 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
henrike@webrtc.org40b3b682014-03-03 18:30:111636
Steve Anton3871f6f2018-01-26 18:25:531637 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1638 StatsReports reports;
1639 stats->GetStats(nullptr, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:111640
1641 // The report will exist since we don't remove them in RemoveStream().
Yves Gerey665174f2018-06-19 13:03:051642 const StatsReport* report =
1643 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531644 ASSERT_TRUE(report);
1645 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051646 std::string track_id =
1647 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051648 EXPECT_EQ(kLocalTrackId, track_id);
Yves Gerey665174f2018-06-19 13:03:051649 std::string ssrc_id =
1650 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481651 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org40b3b682014-03-03 18:30:111652
1653 // Verifies the values in the track report, no value will be changed by the
1654 // AudioTrackInterface::GetSignalValue() and
Sam Zackrisson28127632018-11-01 10:37:151655 // AudioProcessorInterface::GetStats();
henrike@webrtc.org40b3b682014-03-03 18:30:111656 VerifyVoiceSenderInfoReport(report, voice_sender_info);
1657}
1658
xians@webrtc.org4cb01282014-06-12 14:57:051659// This test verifies that when ongoing and incoming audio tracks are using
1660// the same ssrc, they populate stats reports correctly.
Harald Alvestrand75ceef22018-01-04 14:26:131661TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
Steve Anton3871f6f2018-01-26 18:25:531662 auto pc = CreatePeerConnection();
1663 auto stats = CreateStatsCollector(pc);
xians@webrtc.org4cb01282014-06-12 14:57:051664
1665 // Create a local stream with a local audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531666 AddOutgoingAudioTrack(pc, stats.get());
1667 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
xians@webrtc.org4cb01282014-06-12 14:57:051668
1669 // Create a remote stream with a remote audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531670 rtc::scoped_refptr<MediaStream> remote_stream(
Seth Hampson845e8782018-03-02 19:34:101671 MediaStream::Create("remotestreamid"));
Tommi87f70902021-04-27 12:43:081672 auto remote_track = rtc::make_ref_counted<FakeAudioTrack>(kRemoteTrackId);
Steve Antonefe4c922019-03-27 17:26:061673 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
xians@webrtc.org4cb01282014-06-12 14:57:051674 remote_stream->AddTrack(remote_track);
Steve Anton3871f6f2018-01-26 18:25:531675 stats->AddStream(remote_stream);
xians@webrtc.org4cb01282014-06-12 14:57:051676
Steve Anton3871f6f2018-01-26 18:25:531677 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051678 InitVoiceSenderInfo(&voice_sender_info);
Artem Titov880fa812021-07-30 20:30:231679 // Some of the contents in `voice_sender_info` needs to be updated from the
1680 // `audio_track_`.
Ivo Creusen56d460902017-11-24 16:29:591681 UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info,
1682 true);
xians@webrtc.org4cb01282014-06-12 14:57:051683
Steve Anton3871f6f2018-01-26 18:25:531684 VoiceReceiverInfo voice_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051685 InitVoiceReceiverInfo(&voice_receiver_info);
1686
1687 // Constructs an ssrc stats update.
Steve Anton3871f6f2018-01-26 18:25:531688 VoiceMediaInfo voice_info;
1689 voice_info.senders.push_back(voice_sender_info);
1690 voice_info.receivers.push_back(voice_receiver_info);
xians@webrtc.org4cb01282014-06-12 14:57:051691
Steve Anton3871f6f2018-01-26 18:25:531692 // Instruct the session to return stats containing the transport channel.
Steve Anton5b387312018-02-03 00:00:201693 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1694 voice_media_channel->SetStats(voice_info);
xians@webrtc.org4cb01282014-06-12 14:57:051695
Steve Anton3871f6f2018-01-26 18:25:531696 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
xians@webrtc.org4cb01282014-06-12 14:57:051697
1698 // Get stats for the local track.
Steve Anton3871f6f2018-01-26 18:25:531699 StatsReports reports; // returned values.
1700 stats->GetStats(audio_track_.get(), &reports);
1701
Yves Gerey665174f2018-06-19 13:03:051702 const StatsReport* track_report =
1703 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131704 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531705 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051706 std::string track_id =
1707 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051708 EXPECT_EQ(kLocalTrackId, track_id);
1709 VerifyVoiceSenderInfoReport(track_report, voice_sender_info);
1710
1711 // Get stats for the remote track.
tommi@webrtc.org5b06b062014-08-15 08:38:301712 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531713 stats->GetStats(remote_track.get(), &reports);
Yves Gerey665174f2018-06-19 13:03:051714 track_report =
1715 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131716 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531717 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051718 track_id =
1719 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051720 EXPECT_EQ(kRemoteTrackId, track_id);
1721 VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
1722}
1723
xians@webrtc.org01bda202014-07-09 07:38:381724// This test verifies that when two outgoing audio tracks are using the same
1725// ssrc at different times, they populate stats reports correctly.
1726// TODO(xians): Figure out if it is possible to encapsulate the setup and
1727// avoid duplication of code in test cases.
Harald Alvestrand75ceef22018-01-04 14:26:131728TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
Harald Alvestrand75ceef22018-01-04 14:26:131729 // This test only makes sense when we're using streams.
Steve Anton3871f6f2018-01-26 18:25:531730 if (!GetParam()) {
Harald Alvestrand75ceef22018-01-04 14:26:131731 return;
Steve Anton3871f6f2018-01-26 18:25:531732 }
Harald Alvestrand75ceef22018-01-04 14:26:131733
Steve Anton3871f6f2018-01-26 18:25:531734 auto pc = CreatePeerConnection();
1735 auto stats = CreateStatsCollector(pc);
xians@webrtc.org01bda202014-07-09 07:38:381736
1737 // Create a local stream with a local audio track and adds it to the stats.
Steve Antonefe4c922019-03-27 17:26:061738 auto sender = AddOutgoingAudioTrack(pc, stats.get());
Steve Anton3871f6f2018-01-26 18:25:531739 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
xians@webrtc.org01bda202014-07-09 07:38:381740
Steve Anton3871f6f2018-01-26 18:25:531741 VoiceSenderInfo voice_sender_info;
ivoce1198e02017-09-08 15:13:191742 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531743 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
xians@webrtc.org01bda202014-07-09 07:38:381744 voice_sender_info.add_ssrc(kSsrcOfTrack);
Steve Anton3871f6f2018-01-26 18:25:531745 VoiceMediaInfo voice_info;
1746 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201747
1748 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1749 voice_media_channel->SetStats(voice_info);
xians@webrtc.org01bda202014-07-09 07:38:381750
xians@webrtc.org01bda202014-07-09 07:38:381751 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531752 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
xians@webrtc.org01bda202014-07-09 07:38:381753
1754 // Remove the previous audio track from the stream.
1755 stream_->RemoveTrack(audio_track_.get());
Steve Anton3871f6f2018-01-26 18:25:531756 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
Steve Antonefe4c922019-03-27 17:26:061757 pc->RemoveSender(sender);
xians@webrtc.org01bda202014-07-09 07:38:381758
1759 // Create a new audio track and adds it to the stream and stats.
1760 static const std::string kNewTrackId = "new_track_id";
Tommi87f70902021-04-27 12:43:081761 auto new_audio_track = rtc::make_ref_counted<FakeAudioTrack>(kNewTrackId);
Steve Antonefe4c922019-03-27 17:26:061762 pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
xians@webrtc.org01bda202014-07-09 07:38:381763 stream_->AddTrack(new_audio_track);
1764
Steve Anton3871f6f2018-01-26 18:25:531765 stats->AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);
Tommic811ab52022-01-11 15:33:231766 stats->InvalidateCache();
Steve Anton3871f6f2018-01-26 18:25:531767
1768 VoiceSenderInfo new_voice_sender_info;
xians@webrtc.org01bda202014-07-09 07:38:381769 InitVoiceSenderInfo(&new_voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531770 UpdateVoiceSenderInfoFromAudioTrack(new_audio_track, &new_voice_sender_info,
1771 false);
1772 VoiceMediaInfo new_voice_info;
1773 new_voice_info.senders.push_back(new_voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201774 voice_media_channel->SetStats(new_voice_info);
Steve Anton3871f6f2018-01-26 18:25:531775
tommi@webrtc.org5b06b062014-08-15 08:38:301776 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531777 VerifyAudioTrackStats(new_audio_track, stats.get(), new_voice_info, &reports);
xians@webrtc.org01bda202014-07-09 07:38:381778}
1779
Steve Antonefe4c922019-03-27 17:26:061780// Test that if there are two local senders with the same track then two SSRC
1781// reports will be created, one for each sender, with the same track ID and one
1782// track report will be created for the shared track.
1783TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) {
1784 constexpr uint32_t kFirstSsrc = 22;
1785 constexpr uint32_t kSecondSsrc = 33;
1786
1787 auto pc = CreatePeerConnection();
1788 auto stats = CreateStatsCollector(pc);
1789
Tommi87f70902021-04-27 12:43:081790 auto local_track =
1791 rtc::make_ref_counted<FakeAudioTrackWithInitValue>(kLocalTrackId);
Steve Antonefe4c922019-03-27 17:26:061792 pc->AddSender(CreateMockSender(local_track, kFirstSsrc));
1793 stats->AddLocalAudioTrack(local_track.get(), kFirstSsrc);
1794 pc->AddSender(CreateMockSender(local_track, kSecondSsrc));
1795 stats->AddLocalAudioTrack(local_track.get(), kSecondSsrc);
1796
1797 VoiceSenderInfo first_sender_info;
1798 InitVoiceSenderInfo(&first_sender_info, kFirstSsrc);
1799 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &first_sender_info,
1800 false);
1801
1802 VoiceSenderInfo second_sender_info;
1803 InitVoiceSenderInfo(&second_sender_info, kSecondSsrc);
1804 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &second_sender_info,
1805 false);
1806
1807 VoiceMediaInfo voice_info;
1808 voice_info.senders.push_back(first_sender_info);
1809 voice_info.senders.push_back(second_sender_info);
1810
1811 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1812 voice_media_channel->SetStats(voice_info);
1813
1814 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1815
1816 StatsReports reports;
1817 stats->GetStats(local_track.get(), &reports);
Steve Antonefe4c922019-03-27 17:26:061818
1819 // Both SSRC reports have the same track ID.
1820 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1821 reports, StatsReport::kStatsReportTypeSsrc,
1822 StatsReport::kStatsValueNameTrackId, 1));
1823 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1824 reports, StatsReport::kStatsReportTypeSsrc,
1825 StatsReport::kStatsValueNameTrackId, 2));
1826
1827 // The SSRC in each SSRC report is different and correspond to the sender
1828 // SSRC.
1829 std::vector<absl::optional<std::string>> ssrcs = {
1830 GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc,
1831 StatsReport::kStatsValueNameSsrc, 1),
1832 GetValueInNthReportByType(reports, StatsReport::kStatsReportTypeSsrc,
1833 StatsReport::kStatsValueNameSsrc, 2)};
1834 EXPECT_THAT(ssrcs, UnorderedElementsAre(rtc::ToString(kFirstSsrc),
1835 rtc::ToString(kSecondSsrc)));
1836
1837 // There is one track report with the same track ID as the SSRC reports.
1838 EXPECT_EQ(
1839 1u, GetReportsByType(reports, StatsReport::kStatsReportTypeTrack).size());
1840 EXPECT_EQ(kLocalTrackId, GetValueInNthReportByType(
1841 reports, StatsReport::kStatsReportTypeTrack,
1842 StatsReport::kStatsValueNameTrackId, 1));
1843}
1844
sakal43536c32016-10-24 08:46:431845// This test verifies that stats are correctly set in video send ssrc stats.
Harald Alvestrand75ceef22018-01-04 14:26:131846TEST_P(StatsCollectorTrackTest, VerifyVideoSendSsrcStats) {
Steve Anton3871f6f2018-01-26 18:25:531847 auto pc = CreatePeerConnection();
1848 auto stats = CreateStatsCollector(pc);
sakal43536c32016-10-24 08:46:431849
Steve Anton3871f6f2018-01-26 18:25:531850 AddOutgoingVideoTrack(pc, stats.get());
sakal43536c32016-10-24 08:46:431851
Steve Anton3871f6f2018-01-26 18:25:531852 VideoSenderInfo video_sender_info;
sakal43536c32016-10-24 08:46:431853 video_sender_info.add_ssrc(1234);
1854 video_sender_info.frames_encoded = 10;
Oskar Sundbom36f8f3e2017-11-16 09:54:271855 video_sender_info.qp_sum = 11;
Steve Anton3871f6f2018-01-26 18:25:531856 VideoMediaInfo video_info;
Henrik Boströma0ff50c2020-05-05 13:54:461857 video_info.aggregated_senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201858
Tommi19015512022-02-02 10:49:351859 pc->AddVideoChannel("video", "transport", video_info);
sakal43536c32016-10-24 08:46:431860
Steve Anton3871f6f2018-01-26 18:25:531861 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1862 StatsReports reports;
1863 stats->GetStats(nullptr, &reports);
1864
sakal43536c32016-10-24 08:46:431865 EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),
1866 ExtractSsrcStatsValue(reports,
1867 StatsReport::kStatsValueNameFramesEncoded));
sakal87da4042016-10-31 13:53:471868 EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),
1869 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
sakal43536c32016-10-24 08:46:431870}
1871
sakale5ba44e2016-10-26 14:09:241872// This test verifies that stats are correctly set in video receive ssrc stats.
Steve Anton3871f6f2018-01-26 18:25:531873TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) {
1874 auto pc = CreatePeerConnection();
1875 auto stats = CreateStatsCollector(pc);
sakale5ba44e2016-10-26 14:09:241876
Steve Anton3871f6f2018-01-26 18:25:531877 AddIncomingVideoTrack(pc, stats.get());
sakale5ba44e2016-10-26 14:09:241878
Steve Anton3871f6f2018-01-26 18:25:531879 VideoReceiverInfo video_receiver_info;
sakale5ba44e2016-10-26 14:09:241880 video_receiver_info.add_ssrc(1234);
1881 video_receiver_info.frames_decoded = 10;
Artem Titov8a3ab0e2018-07-27 14:52:571882 video_receiver_info.qp_sum = 11;
Steve Anton3871f6f2018-01-26 18:25:531883 VideoMediaInfo video_info;
1884 video_info.receivers.push_back(video_receiver_info);
Steve Anton5b387312018-02-03 00:00:201885
Tommi19015512022-02-02 10:49:351886 pc->AddVideoChannel("video", "transport", video_info);
sakale5ba44e2016-10-26 14:09:241887
Steve Anton3871f6f2018-01-26 18:25:531888 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1889 StatsReports reports;
1890 stats->GetStats(nullptr, &reports);
1891
sakale5ba44e2016-10-26 14:09:241892 EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),
1893 ExtractSsrcStatsValue(reports,
1894 StatsReport::kStatsValueNameFramesDecoded));
sakalcc452e12017-02-09 12:53:451895 EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum),
1896 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
sakale5ba44e2016-10-26 14:09:241897}
1898
Mirko Bonadeic84f6612019-01-31 11:20:571899INSTANTIATE_TEST_SUITE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool());
Harald Alvestrand75ceef22018-01-04 14:26:131900
guoweis@webrtc.org950c5182014-12-16 23:01:311901} // namespace webrtc