blob: c6b57c278ed19967f32eb11a9a4e1ba0f40420e9 [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
jbauch555604a2016-04-26 10:13:2215#include <memory>
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"
Mirko Bonadeid9708072019-01-25 19:26:4822#include "api/scoped_refptr.h"
Yves Gerey3e707812018-11-28 15:47:4923#include "call/call.h"
Steve Anton10542f22019-01-11 17:11:0024#include "media/base/media_channel.h"
Yves Gerey3e707812018-11-28 15:47:4925#include "modules/audio_processing/include/audio_processing_statistics.h"
Steve Anton10542f22019-01-11 17:11:0026#include "pc/data_channel.h"
27#include "pc/media_stream.h"
28#include "pc/media_stream_track.h"
Steve Anton10542f22019-01-11 17:11:0029#include "pc/test/fake_peer_connection_for_stats.h"
30#include "pc/test/fake_video_track_source.h"
Steve Antonefe4c922019-03-27 17:26:0631#include "pc/test/mock_rtp_receiver_internal.h"
32#include "pc/test/mock_rtp_sender_internal.h"
Steve Anton10542f22019-01-11 17:11:0033#include "pc/transport_stats.h"
34#include "pc/video_track.h"
35#include "rtc_base/fake_ssl_identity.h"
36#include "rtc_base/message_digest.h"
37#include "rtc_base/net_helper.h"
38#include "rtc_base/ref_counted_object.h"
39#include "rtc_base/rtc_certificate.h"
Steve Anton10542f22019-01-11 17:11:0040#include "rtc_base/socket_address.h"
41#include "rtc_base/ssl_identity.h"
42#include "rtc_base/ssl_stream_adapter.h"
43#include "rtc_base/string_encode.h"
Artem Titova76af0c2018-07-23 15:38:1244#include "rtc_base/third_party/base64/base64.h"
Yves Gerey3e707812018-11-28 15:47:4945#include "rtc_base/thread.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3146#include "test/gtest.h"
henrike@webrtc.org28e20752013-07-10 00:45:3647
Steve Anton3871f6f2018-01-26 18:25:5348using cricket::ConnectionInfo;
49using cricket::SsrcReceiverInfo;
50using cricket::TransportChannelStats;
51using cricket::VideoMediaInfo;
52using cricket::VideoReceiverInfo;
53using cricket::VideoSenderInfo;
54using cricket::VoiceMediaInfo;
55using cricket::VoiceReceiverInfo;
56using cricket::VoiceSenderInfo;
Steve Antonefe4c922019-03-27 17:26:0657using ::testing::Return;
58using ::testing::UnorderedElementsAre;
henrike@webrtc.org28e20752013-07-10 00:45:3659
guoweis@webrtc.org950c5182014-12-16 23:01:3160namespace webrtc {
henrike@webrtc.org28e20752013-07-10 00:45:3661
tkchin7d06a8c2016-04-04 21:10:4362namespace internal {
63// This value comes from openssl/tls1.h
64static const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;
65} // namespace internal
66
henrike@webrtc.org28e20752013-07-10 00:45:3667// Error return values
68const char kNotFound[] = "NOT FOUND";
henrike@webrtc.org28e20752013-07-10 00:45:3669
wu@webrtc.org97077a32013-10-25 21:18:3370// Constant names for track identification.
xians@webrtc.org4cb01282014-06-12 14:57:0571const char kLocalTrackId[] = "local_track_id";
72const char kRemoteTrackId[] = "remote_track_id";
Peter Boström0c4e06b2015-10-07 10:23:2173const uint32_t kSsrcOfTrack = 1234;
wu@webrtc.org97077a32013-10-25 21:18:3374
Steve Anton3871f6f2018-01-26 18:25:5375class FakeAudioProcessor : public AudioProcessorInterface {
henrike@webrtc.org40b3b682014-03-03 18:30:1176 public:
77 FakeAudioProcessor() {}
78 ~FakeAudioProcessor() {}
79
80 private:
Ivo Creusenae0260962017-11-20 12:07:1681 AudioProcessorInterface::AudioProcessorStatistics GetStats(
Ivo Creusen56d460902017-11-24 16:29:5982 bool has_recv_streams) override {
Ivo Creusenae0260962017-11-20 12:07:1683 AudioProcessorStatistics stats;
84 stats.typing_noise_detected = true;
Ivo Creusen56d460902017-11-24 16:29:5985 if (has_recv_streams) {
86 stats.apm_statistics.echo_return_loss = 2.0;
87 stats.apm_statistics.echo_return_loss_enhancement = 3.0;
88 stats.apm_statistics.delay_median_ms = 4;
89 stats.apm_statistics.delay_standard_deviation_ms = 5;
90 }
Ivo Creusenae0260962017-11-20 12:07:1691 return stats;
92 }
henrike@webrtc.org40b3b682014-03-03 18:30:1193};
94
Steve Anton3871f6f2018-01-26 18:25:5395class FakeAudioTrack : public MediaStreamTrack<AudioTrackInterface> {
henrike@webrtc.org40b3b682014-03-03 18:30:1196 public:
xians@webrtc.org4cb01282014-06-12 14:57:0597 explicit FakeAudioTrack(const std::string& id)
Steve Anton3871f6f2018-01-26 18:25:5398 : MediaStreamTrack<AudioTrackInterface>(id),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:5299 processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35100 std::string kind() const override { return "audio"; }
Steve Anton3871f6f2018-01-26 18:25:53101 AudioSourceInterface* GetSource() const override { return NULL; }
102 void AddSink(AudioTrackSinkInterface* sink) override {}
103 void RemoveSink(AudioTrackSinkInterface* sink) override {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35104 bool GetSignalLevel(int* level) override {
henrike@webrtc.org40b3b682014-03-03 18:30:11105 *level = 1;
106 return true;
107 }
Steve Anton3871f6f2018-01-26 18:25:53108 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
henrike@webrtc.orgb90991d2014-03-04 19:54:57109 return processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11110 }
111
112 private:
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52113 rtc::scoped_refptr<FakeAudioProcessor> processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11114};
115
zhihuang6ba3b192016-05-13 18:46:35116// This fake audio processor is used to verify that the undesired initial values
117// (-1) will be filtered out.
Steve Anton3871f6f2018-01-26 18:25:53118class FakeAudioProcessorWithInitValue : public AudioProcessorInterface {
zhihuang6ba3b192016-05-13 18:46:35119 public:
120 FakeAudioProcessorWithInitValue() {}
121 ~FakeAudioProcessorWithInitValue() {}
122
123 private:
Ivo Creusenae0260962017-11-20 12:07:16124 AudioProcessorInterface::AudioProcessorStatistics GetStats(
125 bool /*has_recv_streams*/) override {
126 AudioProcessorStatistics stats;
127 stats.typing_noise_detected = false;
128 return stats;
129 }
zhihuang6ba3b192016-05-13 18:46:35130};
131
132class FakeAudioTrackWithInitValue
Steve Anton3871f6f2018-01-26 18:25:53133 : public MediaStreamTrack<AudioTrackInterface> {
zhihuang6ba3b192016-05-13 18:46:35134 public:
135 explicit FakeAudioTrackWithInitValue(const std::string& id)
Steve Anton3871f6f2018-01-26 18:25:53136 : MediaStreamTrack<AudioTrackInterface>(id),
zhihuang6ba3b192016-05-13 18:46:35137 processor_(
138 new rtc::RefCountedObject<FakeAudioProcessorWithInitValue>()) {}
139 std::string kind() const override { return "audio"; }
Steve Anton3871f6f2018-01-26 18:25:53140 AudioSourceInterface* GetSource() const override { return NULL; }
141 void AddSink(AudioTrackSinkInterface* sink) override {}
142 void RemoveSink(AudioTrackSinkInterface* sink) override {}
zhihuang6ba3b192016-05-13 18:46:35143 bool GetSignalLevel(int* level) override {
144 *level = 1;
145 return true;
146 }
Steve Anton3871f6f2018-01-26 18:25:53147 rtc::scoped_refptr<AudioProcessorInterface> GetAudioProcessor() override {
zhihuang6ba3b192016-05-13 18:46:35148 return processor_;
149 }
150
151 private:
152 rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_;
153};
154
henrike@webrtc.org40b3b682014-03-03 18:30:11155bool GetValue(const StatsReport* report,
tommi@webrtc.org242068d2014-07-14 20:19:56156 StatsReport::StatsValueName name,
wu@webrtc.org4551b792013-10-09 15:37:36157 std::string* value) {
tommi@webrtc.org92f40182015-03-04 15:25:19158 const StatsReport::Value* v = report->FindValue(name);
159 if (!v)
160 return false;
161 *value = v->ToString();
162 return true;
wu@webrtc.org4551b792013-10-09 15:37:36163}
164
tommi@webrtc.org4fb7e252015-01-21 11:36:18165std::string ExtractStatsValue(const StatsReport::StatsType& type,
henrike@webrtc.org40b3b682014-03-03 18:30:11166 const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56167 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18168 for (const auto* r : reports) {
wu@webrtc.org4551b792013-10-09 15:37:36169 std::string ret;
tommi@webrtc.org4fb7e252015-01-21 11:36:18170 if (r->type() == type && GetValue(r, name, &ret))
wu@webrtc.org4551b792013-10-09 15:37:36171 return ret;
henrike@webrtc.org28e20752013-07-10 00:45:36172 }
173
174 return kNotFound;
175}
176
tommi@webrtc.orgd3900292015-03-12 16:35:55177StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type,
178 const std::string& value) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18179 EXPECT_FALSE(value.empty());
tommi@webrtc.orgd3900292015-03-12 16:35:55180 StatsReport::Id id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18181 if (value.empty())
tommi@webrtc.orgd3900292015-03-12 16:35:55182 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18183
184 // This has assumptions about how the ID is constructed. As is, this is
185 // OK since this is for testing purposes only, but if we ever need this
186 // in production, we should add a generic method that does this.
187 size_t index = value.find('_');
188 EXPECT_NE(index, std::string::npos);
189 if (index == std::string::npos || index == (value.length() - 1))
tommi@webrtc.orgd3900292015-03-12 16:35:55190 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18191
192 id = StatsReport::NewTypedId(type, value.substr(index + 1));
193 EXPECT_EQ(id->ToString(), value);
tommi@webrtc.orgd3900292015-03-12 16:35:55194 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18195}
196
tommi@webrtc.orgd3900292015-03-12 16:35:55197StatsReport::Id IdFromCertIdString(const std::string& cert_id) {
198 return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id);
tommi@webrtc.org4fb7e252015-01-21 11:36:18199}
200
henrike@webrtc.org28e20752013-07-10 00:45:36201// Finds the |n|-th report of type |type| in |reports|.
202// |n| starts from 1 for finding the first report.
Yves Gerey665174f2018-06-19 13:03:05203const StatsReport* FindNthReportByType(const StatsReports& reports,
204 const StatsReport::StatsType& type,
205 int n) {
henrike@webrtc.org28e20752013-07-10 00:45:36206 for (size_t i = 0; i < reports.size(); ++i) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18207 if (reports[i]->type() == type) {
henrike@webrtc.org28e20752013-07-10 00:45:36208 n--;
209 if (n == 0)
tommi@webrtc.org5b06b062014-08-15 08:38:30210 return reports[i];
henrike@webrtc.org28e20752013-07-10 00:45:36211 }
212 }
tommi@webrtc.org4fb7e252015-01-21 11:36:18213 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36214}
215
Steve Antonefe4c922019-03-27 17:26:06216// Returns the value of the stat identified by |name| in the |n|-th report of
217// type |type| in |reports|.
218// |n| starts from 1 for finding the first report.
219// If either the |n|-th report is not found, or the stat is not present in that
220// report, then nullopt is returned.
221absl::optional<std::string> GetValueInNthReportByType(
222 const StatsReports& reports,
223 StatsReport::StatsType type,
224 StatsReport::StatsValueName name,
225 int n) {
226 const StatsReport* report = FindNthReportByType(reports, type, n);
227 if (!report) {
228 return absl::nullopt;
229 }
230 std::string value;
231 if (!GetValue(report, name, &value)) {
232 return absl::nullopt;
233 }
234 return value;
235}
236
237std::vector<const StatsReport*> GetReportsByType(const StatsReports& reports,
238 StatsReport::StatsType type) {
239 std::vector<const StatsReport*> filtered_reports;
240 for (const StatsReport* report : reports) {
241 if (report->type() == type) {
242 filtered_reports.push_back(report);
243 }
244 }
245 return filtered_reports;
246}
247
henrike@webrtc.org40b3b682014-03-03 18:30:11248const StatsReport* FindReportById(const StatsReports& reports,
tommi@webrtc.org4fb7e252015-01-21 11:36:18249 const StatsReport::Id& id) {
tommi@webrtc.org8e327c42015-01-19 20:41:26250 for (const auto* r : reports) {
tommi@webrtc.orgd3900292015-03-12 16:35:55251 if (r->id()->Equals(id))
tommi@webrtc.org8e327c42015-01-19 20:41:26252 return r;
henrike@webrtc.org28e20752013-07-10 00:45:36253 }
tommi@webrtc.org8e327c42015-01-19 20:41:26254 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36255}
256
Mirko Bonadeic61ce0d2017-11-21 16:04:20257std::string ExtractSsrcStatsValue(const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56258 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18259 return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36260}
261
Mirko Bonadeic61ce0d2017-11-21 16:04:20262std::string ExtractBweStatsValue(const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56263 StatsReport::StatsValueName name) {
Yves Gerey665174f2018-06-19 13:03:05264 return ExtractStatsValue(StatsReport::kStatsReportTypeBwe, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36265}
266
wu@webrtc.org4551b792013-10-09 15:37:36267std::string DerToPem(const std::string& der) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52268 return rtc::SSLIdentity::DerToPem(
Yves Gerey665174f2018-06-19 13:03:05269 rtc::kPemTypeCertificate,
270 reinterpret_cast<const unsigned char*>(der.c_str()), der.length());
wu@webrtc.org4551b792013-10-09 15:37:36271}
272
Yves Gerey665174f2018-06-19 13:03:05273std::vector<std::string> DersToPems(const std::vector<std::string>& ders) {
wu@webrtc.org4551b792013-10-09 15:37:36274 std::vector<std::string> pems(ders.size());
Steve Anton64b626b2019-01-29 01:25:26275 absl::c_transform(ders, pems.begin(), DerToPem);
wu@webrtc.org4551b792013-10-09 15:37:36276 return pems;
277}
278
henrike@webrtc.org40b3b682014-03-03 18:30:11279void CheckCertChainReports(const StatsReports& reports,
wu@webrtc.org4551b792013-10-09 15:37:36280 const std::vector<std::string>& ders,
tommi@webrtc.org4fb7e252015-01-21 11:36:18281 const StatsReport::Id& start_id) {
tommi@webrtc.orgd3900292015-03-12 16:35:55282 StatsReport::Id cert_id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18283 const StatsReport::Id* certificate_id = &start_id;
wu@webrtc.org4551b792013-10-09 15:37:36284 size_t i = 0;
285 while (true) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18286 const StatsReport* report = FindReportById(reports, *certificate_id);
wu@webrtc.org4551b792013-10-09 15:37:36287 ASSERT_TRUE(report != NULL);
mallinath@webrtc.org19f27e62013-10-13 17:18:27288
wu@webrtc.org4551b792013-10-09 15:37:36289 std::string der_base64;
Yves Gerey665174f2018-06-19 13:03:05290 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDer, &der_base64));
tommi@webrtc.org4fb7e252015-01-21 11:36:18291 std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
wu@webrtc.org4551b792013-10-09 15:37:36292 EXPECT_EQ(ders[i], der);
mallinath@webrtc.org19f27e62013-10-13 17:18:27293
294 std::string fingerprint_algorithm;
Yves Gerey665174f2018-06-19 13:03:05295 EXPECT_TRUE(GetValue(report,
296 StatsReport::kStatsValueNameFingerprintAlgorithm,
297 &fingerprint_algorithm));
mallinath@webrtc.org19f27e62013-10-13 17:18:27298 // The digest algorithm for a FakeSSLCertificate is always SHA-1.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52299 std::string sha_1_str = rtc::DIGEST_SHA_1;
mallinath@webrtc.org19f27e62013-10-13 17:18:27300 EXPECT_EQ(sha_1_str, fingerprint_algorithm);
301
tommi@webrtc.org4fb7e252015-01-21 11:36:18302 std::string fingerprint;
303 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint,
304 &fingerprint));
305 EXPECT_FALSE(fingerprint.empty());
mallinath@webrtc.org19f27e62013-10-13 17:18:27306
wu@webrtc.org4551b792013-10-09 15:37:36307 ++i;
tommi@webrtc.org4fb7e252015-01-21 11:36:18308 std::string issuer_id;
Yves Gerey665174f2018-06-19 13:03:05309 if (!GetValue(report, StatsReport::kStatsValueNameIssuerId, &issuer_id)) {
wu@webrtc.org4551b792013-10-09 15:37:36310 break;
tommi@webrtc.org4fb7e252015-01-21 11:36:18311 }
312
tommi@webrtc.orgd3900292015-03-12 16:35:55313 cert_id = IdFromCertIdString(issuer_id);
314 certificate_id = &cert_id;
wu@webrtc.org4551b792013-10-09 15:37:36315 }
316 EXPECT_EQ(ders.size(), i);
317}
318
Yves Gerey665174f2018-06-19 13:03:05319void VerifyVoiceReceiverInfoReport(const StatsReport* report,
320 const cricket::VoiceReceiverInfo& info) {
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10321 std::string value_in_report;
Yves Gerey665174f2018-06-19 13:03:05322 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioOutputLevel,
323 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48324 EXPECT_EQ(rtc::ToString(info.audio_level), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05325 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesReceived,
326 &value_in_report));
Niels Möllerac0a4cb2019-10-09 13:01:33327 EXPECT_EQ(rtc::ToString(info.payload_bytes_rcvd +
328 info.header_and_padding_bytes_rcvd),
329 value_in_report);
Yves Gerey665174f2018-06-19 13:03:05330 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
331 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48332 EXPECT_EQ(rtc::ToString(info.jitter_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05333 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterBufferMs,
334 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48335 EXPECT_EQ(rtc::ToString(info.jitter_buffer_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05336 EXPECT_TRUE(GetValue(report,
337 StatsReport::kStatsValueNamePreferredJitterBufferMs,
338 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48339 EXPECT_EQ(rtc::ToString(info.jitter_buffer_preferred_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05340 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCurrentDelayMs,
341 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48342 EXPECT_EQ(rtc::ToString(info.delay_estimate_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05343 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameExpandRate,
344 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48345 EXPECT_EQ(rtc::ToString(info.expand_rate), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05346 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSpeechExpandRate,
347 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48348 EXPECT_EQ(rtc::ToString(info.speech_expand_rate), value_in_report);
Henrik Lundin8e6fd462015-06-02 07:24:52349 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,
350 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48351 EXPECT_EQ(rtc::ToString(info.accelerate_rate), value_in_report);
Henrik Lundin8e6fd462015-06-02 07:24:52352 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate,
353 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48354 EXPECT_EQ(rtc::ToString(info.preemptive_expand_rate), value_in_report);
minyue@webrtc.org652bc372015-02-18 23:50:46355 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate,
356 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48357 EXPECT_EQ(rtc::ToString(info.secondary_decoded_rate), value_in_report);
minyue-webrtc0e320ec2017-08-28 11:51:27358 EXPECT_TRUE(GetValue(report,
359 StatsReport::kStatsValueNameSecondaryDiscardedRate,
360 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48361 EXPECT_EQ(rtc::ToString(info.secondary_discarded_rate), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05362 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsReceived,
363 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48364 EXPECT_EQ(rtc::ToString(info.packets_rcvd), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05365 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTSG,
366 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48367 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_silence_generator),
Yves Gerey665174f2018-06-19 13:03:05368 value_in_report);
369 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCTN,
370 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48371 EXPECT_EQ(rtc::ToString(info.decoding_calls_to_neteq), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05372 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingNormal,
373 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48374 EXPECT_EQ(rtc::ToString(info.decoding_normal), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05375 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLC,
376 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48377 EXPECT_EQ(rtc::ToString(info.decoding_plc), value_in_report);
Alex Narest5b5d97c2019-08-07 16:15:08378 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCodecPLC,
379 &value_in_report));
380 EXPECT_EQ(rtc::ToString(info.decoding_codec_plc), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05381 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingCNG,
382 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48383 EXPECT_EQ(rtc::ToString(info.decoding_cng), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05384 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingPLCCNG,
385 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48386 EXPECT_EQ(rtc::ToString(info.decoding_plc_cng), value_in_report);
henrik.lundin63489782016-09-20 08:47:12387 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput,
388 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48389 EXPECT_EQ(rtc::ToString(info.decoding_muted_output), value_in_report);
henrik.lundin63489782016-09-20 08:47:12390 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
391 &value_in_report));
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10392}
393
henrike@webrtc.org40b3b682014-03-03 18:30:11394void VerifyVoiceSenderInfoReport(const StatsReport* report,
395 const cricket::VoiceSenderInfo& sinfo) {
396 std::string value_in_report;
Yves Gerey665174f2018-06-19 13:03:05397 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,
398 &value_in_report));
henrike@webrtc.org40b3b682014-03-03 18:30:11399 EXPECT_EQ(sinfo.codec_name, value_in_report);
Yves Gerey665174f2018-06-19 13:03:05400 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameBytesSent,
401 &value_in_report));
Niels Möllerac0a4cb2019-10-09 13:01:33402 EXPECT_EQ(rtc::ToString(sinfo.payload_bytes_sent +
403 sinfo.header_and_padding_bytes_sent),
404 value_in_report);
Yves Gerey665174f2018-06-19 13:03:05405 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsSent,
406 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48407 EXPECT_EQ(rtc::ToString(sinfo.packets_sent), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05408 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
409 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48410 EXPECT_EQ(rtc::ToString(sinfo.packets_lost), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05411 EXPECT_TRUE(
412 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48413 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05414 EXPECT_TRUE(
415 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48416 EXPECT_EQ(rtc::ToString(sinfo.rtt_ms), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05417 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
418 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48419 EXPECT_EQ(rtc::ToString(sinfo.jitter_ms), value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59420 if (sinfo.apm_statistics.delay_median_ms) {
421 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
422 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48423 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_median_ms),
Ivo Creusen56d460902017-11-24 16:29:59424 value_in_report);
425 } else {
426 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
427 &value_in_report));
428 }
429 if (sinfo.apm_statistics.delay_standard_deviation_ms) {
430 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
431 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48432 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.delay_standard_deviation_ms),
433 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59434 } else {
435 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
436 &value_in_report));
437 }
438 if (sinfo.apm_statistics.echo_return_loss) {
439 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
440 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48441 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss),
Ivo Creusen56d460902017-11-24 16:29:59442 value_in_report);
443 } else {
444 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoReturnLoss,
445 &value_in_report));
446 }
447 if (sinfo.apm_statistics.echo_return_loss_enhancement) {
448 EXPECT_TRUE(GetValue(report,
449 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
450 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48451 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.echo_return_loss_enhancement),
452 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59453 } else {
454 EXPECT_FALSE(GetValue(report,
455 StatsReport::kStatsValueNameEchoReturnLossEnhancement,
456 &value_in_report));
457 }
458 if (sinfo.apm_statistics.residual_echo_likelihood) {
459 EXPECT_TRUE(GetValue(report,
460 StatsReport::kStatsValueNameResidualEchoLikelihood,
461 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48462 EXPECT_EQ(rtc::ToString(*sinfo.apm_statistics.residual_echo_likelihood),
463 value_in_report);
Ivo Creusen56d460902017-11-24 16:29:59464 } else {
465 EXPECT_FALSE(GetValue(report,
466 StatsReport::kStatsValueNameResidualEchoLikelihood,
467 &value_in_report));
468 }
469 if (sinfo.apm_statistics.residual_echo_likelihood_recent_max) {
470 EXPECT_TRUE(GetValue(
471 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
472 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48473 EXPECT_EQ(rtc::ToString(
Ivo Creusen56d460902017-11-24 16:29:59474 *sinfo.apm_statistics.residual_echo_likelihood_recent_max),
475 value_in_report);
476 } else {
477 EXPECT_FALSE(GetValue(
478 report, StatsReport::kStatsValueNameResidualEchoLikelihoodRecentMax,
479 &value_in_report));
480 }
ivoc8c63a822016-10-21 11:10:03481 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
482 &value_in_report));
Jonas Olsson6b1985d2018-07-05 09:59:48483 EXPECT_EQ(rtc::ToString(sinfo.audio_level), value_in_report);
Yves Gerey665174f2018-06-19 13:03:05484 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameTypingNoiseState,
485 &value_in_report));
henrike@webrtc.org40b3b682014-03-03 18:30:11486 std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
487 EXPECT_EQ(typing_detected, value_in_report);
ivoce1198e02017-09-08 15:13:19488 EXPECT_TRUE(GetValue(report,
489 StatsReport::kStatsValueNameAnaBitrateActionCounter,
490 &value_in_report));
491 ASSERT_TRUE(sinfo.ana_statistics.bitrate_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48492 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.bitrate_action_counter),
493 value_in_report);
ivoce1198e02017-09-08 15:13:19494 EXPECT_TRUE(GetValue(report,
495 StatsReport::kStatsValueNameAnaChannelActionCounter,
496 &value_in_report));
497 ASSERT_TRUE(sinfo.ana_statistics.channel_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48498 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.channel_action_counter),
499 value_in_report);
ivoce1198e02017-09-08 15:13:19500 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaDtxActionCounter,
501 &value_in_report));
502 ASSERT_TRUE(sinfo.ana_statistics.dtx_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48503 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.dtx_action_counter),
ivoce1198e02017-09-08 15:13:19504 value_in_report);
505 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAnaFecActionCounter,
506 &value_in_report));
507 ASSERT_TRUE(sinfo.ana_statistics.fec_action_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48508 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.fec_action_counter),
ivoce1198e02017-09-08 15:13:19509 value_in_report);
ivoc0d0b9122017-09-08 20:24:21510 EXPECT_TRUE(GetValue(
511 report, StatsReport::kStatsValueNameAnaFrameLengthIncreaseCounter,
512 &value_in_report));
513 ASSERT_TRUE(sinfo.ana_statistics.frame_length_increase_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48514 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_increase_counter),
ivoce1198e02017-09-08 15:13:19515 value_in_report);
ivoc0d0b9122017-09-08 20:24:21516 EXPECT_TRUE(GetValue(
517 report, StatsReport::kStatsValueNameAnaFrameLengthDecreaseCounter,
518 &value_in_report));
519 ASSERT_TRUE(sinfo.ana_statistics.frame_length_decrease_counter);
Jonas Olsson6b1985d2018-07-05 09:59:48520 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.frame_length_decrease_counter),
ivoc0d0b9122017-09-08 20:24:21521 value_in_report);
522 EXPECT_TRUE(GetValue(report,
523 StatsReport::kStatsValueNameAnaUplinkPacketLossFraction,
524 &value_in_report));
525 ASSERT_TRUE(sinfo.ana_statistics.uplink_packet_loss_fraction);
Jonas Olsson6b1985d2018-07-05 09:59:48526 EXPECT_EQ(rtc::ToString(*sinfo.ana_statistics.uplink_packet_loss_fraction),
527 value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11528}
529
xians@webrtc.org4cb01282014-06-12 14:57:05530// Helper methods to avoid duplication of code.
Steve Antonefe4c922019-03-27 17:26:06531void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info,
532 uint32_t ssrc = kSsrcOfTrack) {
533 voice_sender_info->add_ssrc(ssrc);
xians@webrtc.org4cb01282014-06-12 14:57:05534 voice_sender_info->codec_name = "fake_codec";
Niels Möllerac0a4cb2019-10-09 13:01:33535 voice_sender_info->payload_bytes_sent = 88;
536 voice_sender_info->header_and_padding_bytes_sent = 12;
xians@webrtc.org4cb01282014-06-12 14:57:05537 voice_sender_info->packets_sent = 101;
538 voice_sender_info->rtt_ms = 102;
539 voice_sender_info->fraction_lost = 103;
540 voice_sender_info->jitter_ms = 104;
541 voice_sender_info->packets_lost = 105;
xians@webrtc.org4cb01282014-06-12 14:57:05542 voice_sender_info->audio_level = 107;
Sam Zackrisson5f2ffee2018-11-01 12:51:24543 voice_sender_info->apm_statistics.echo_return_loss = 108;
544 voice_sender_info->apm_statistics.echo_return_loss_enhancement = 109;
545 voice_sender_info->apm_statistics.delay_median_ms = 110;
546 voice_sender_info->apm_statistics.delay_standard_deviation_ms = 111;
xians@webrtc.org4cb01282014-06-12 14:57:05547 voice_sender_info->typing_noise_detected = false;
Ivo Creusen56d460902017-11-24 16:29:59548 voice_sender_info->ana_statistics.bitrate_action_counter = 112;
549 voice_sender_info->ana_statistics.channel_action_counter = 113;
550 voice_sender_info->ana_statistics.dtx_action_counter = 114;
551 voice_sender_info->ana_statistics.fec_action_counter = 115;
552 voice_sender_info->ana_statistics.frame_length_increase_counter = 116;
553 voice_sender_info->ana_statistics.frame_length_decrease_counter = 117;
554 voice_sender_info->ana_statistics.uplink_packet_loss_fraction = 118.0;
xians@webrtc.org4cb01282014-06-12 14:57:05555}
556
557void UpdateVoiceSenderInfoFromAudioTrack(
zhihuang6ba3b192016-05-13 18:46:35558 AudioTrackInterface* audio_track,
Ivo Creusen56d460902017-11-24 16:29:59559 cricket::VoiceSenderInfo* voice_sender_info,
560 bool has_remote_tracks) {
xians@webrtc.org4cb01282014-06-12 14:57:05561 audio_track->GetSignalLevel(&voice_sender_info->audio_level);
Steve Anton3871f6f2018-01-26 18:25:53562 AudioProcessorInterface::AudioProcessorStatistics audio_processor_stats =
563 audio_track->GetAudioProcessor()->GetStats(has_remote_tracks);
xians@webrtc.org4cb01282014-06-12 14:57:05564 voice_sender_info->typing_noise_detected =
565 audio_processor_stats.typing_noise_detected;
Ivo Creusen56d460902017-11-24 16:29:59566 voice_sender_info->apm_statistics = audio_processor_stats.apm_statistics;
xians@webrtc.org4cb01282014-06-12 14:57:05567}
568
569void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) {
570 voice_receiver_info->add_ssrc(kSsrcOfTrack);
Niels Möllerac0a4cb2019-10-09 13:01:33571 voice_receiver_info->payload_bytes_rcvd = 98;
572 voice_receiver_info->header_and_padding_bytes_rcvd = 12;
xians@webrtc.org4cb01282014-06-12 14:57:05573 voice_receiver_info->packets_rcvd = 111;
xians@webrtc.org4cb01282014-06-12 14:57:05574 voice_receiver_info->packets_lost = 114;
xians@webrtc.org4cb01282014-06-12 14:57:05575 voice_receiver_info->jitter_ms = 116;
576 voice_receiver_info->jitter_buffer_ms = 117;
577 voice_receiver_info->jitter_buffer_preferred_ms = 118;
578 voice_receiver_info->delay_estimate_ms = 119;
579 voice_receiver_info->audio_level = 120;
580 voice_receiver_info->expand_rate = 121;
minyue@webrtc.org652bc372015-02-18 23:50:46581 voice_receiver_info->speech_expand_rate = 122;
582 voice_receiver_info->secondary_decoded_rate = 123;
Henrik Lundin8e6fd462015-06-02 07:24:52583 voice_receiver_info->accelerate_rate = 124;
584 voice_receiver_info->preemptive_expand_rate = 125;
minyue-webrtc0e320ec2017-08-28 11:51:27585 voice_receiver_info->secondary_discarded_rate = 126;
Alex Narest5b5d97c2019-08-07 16:15:08586 voice_receiver_info->decoding_codec_plc = 127;
xians@webrtc.org4cb01282014-06-12 14:57:05587}
588
Steve Anton3871f6f2018-01-26 18:25:53589class StatsCollectorForTest : public StatsCollector {
decurtis@webrtc.org322a5642015-02-03 22:09:37590 public:
Steve Anton3871f6f2018-01-26 18:25:53591 explicit StatsCollectorForTest(PeerConnectionInternal* pc)
deadbeefab9b2d12015-10-14 18:33:11592 : StatsCollector(pc), time_now_(19477) {}
decurtis@webrtc.org322a5642015-02-03 22:09:37593
Yves Gerey665174f2018-06-19 13:03:05594 double GetTimeNow() override { return time_now_; }
decurtis@webrtc.org322a5642015-02-03 22:09:37595
596 private:
597 double time_now_;
598};
599
Mirko Bonadei6a489f22019-04-09 13:11:12600class StatsCollectorTest : public ::testing::Test {
henrike@webrtc.org28e20752013-07-10 00:45:36601 protected:
Steve Anton3871f6f2018-01-26 18:25:53602 rtc::scoped_refptr<FakePeerConnectionForStats> CreatePeerConnection() {
603 return new rtc::RefCountedObject<FakePeerConnectionForStats>();
henrike@webrtc.org28e20752013-07-10 00:45:36604 }
605
Steve Anton3871f6f2018-01-26 18:25:53606 std::unique_ptr<StatsCollectorForTest> CreateStatsCollector(
607 PeerConnectionInternal* pc) {
Mirko Bonadei317a1f02019-09-17 15:06:18608 return std::make_unique<StatsCollectorForTest>(pc);
wu@webrtc.org97077a32013-10-25 21:18:33609 }
610
Steve Anton3871f6f2018-01-26 18:25:53611 void VerifyAudioTrackStats(FakeAudioTrack* audio_track,
612 StatsCollectorForTest* stats,
613 const VoiceMediaInfo& voice_info,
614 StatsReports* reports) {
xians@webrtc.org01bda202014-07-09 07:38:38615 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org69bc5a32014-12-15 09:44:48616 stats->ClearUpdateStatsCacheForTest();
Steve Anton3871f6f2018-01-26 18:25:53617 stats->GetStats(nullptr, reports);
xians@webrtc.org01bda202014-07-09 07:38:38618
619 // Verify the existence of the track report.
Yves Gerey665174f2018-06-19 13:03:05620 const StatsReport* report =
621 FindNthReportByType(*reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:53622 ASSERT_TRUE(report);
jbauchbe24c942015-06-22 22:06:43623 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
Yves Gerey665174f2018-06-19 13:03:05624 std::string track_id =
625 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org01bda202014-07-09 07:38:38626 EXPECT_EQ(audio_track->id(), track_id);
Yves Gerey665174f2018-06-19 13:03:05627 std::string ssrc_id =
628 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:48629 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
xians@webrtc.org01bda202014-07-09 07:38:38630
Yves Gerey665174f2018-06-19 13:03:05631 std::string media_type =
632 ExtractSsrcStatsValue(*reports, StatsReport::kStatsValueNameMediaType);
fippobec70ab2016-01-28 09:27:15633 EXPECT_EQ("audio", media_type);
634
xians@webrtc.org01bda202014-07-09 07:38:38635 // Verifies the values in the track report.
Steve Anton3871f6f2018-01-26 18:25:53636 if (!voice_info.senders.empty()) {
637 VerifyVoiceSenderInfoReport(report, voice_info.senders[0]);
xians@webrtc.org01bda202014-07-09 07:38:38638 }
Steve Anton3871f6f2018-01-26 18:25:53639 if (!voice_info.receivers.empty()) {
640 VerifyVoiceReceiverInfoReport(report, voice_info.receivers[0]);
xians@webrtc.org01bda202014-07-09 07:38:38641 }
642
643 // Verify we get the same result by passing a track to GetStats().
644 StatsReports track_reports; // returned values.
645 stats->GetStats(audio_track, &track_reports);
646 const StatsReport* track_report = FindNthReportByType(
647 track_reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:53648 ASSERT_TRUE(track_report);
jbauchbe24c942015-06-22 22:06:43649 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
xians@webrtc.org01bda202014-07-09 07:38:38650 track_id = ExtractSsrcStatsValue(track_reports,
651 StatsReport::kStatsValueNameTrackId);
652 EXPECT_EQ(audio_track->id(), track_id);
Yves Gerey665174f2018-06-19 13:03:05653 ssrc_id =
654 ExtractSsrcStatsValue(track_reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:48655 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
Steve Anton3871f6f2018-01-26 18:25:53656 if (!voice_info.senders.empty()) {
657 VerifyVoiceSenderInfoReport(track_report, voice_info.senders[0]);
658 }
659 if (!voice_info.receivers.empty()) {
660 VerifyVoiceReceiverInfoReport(track_report, voice_info.receivers[0]);
661 }
henrike@webrtc.org40b3b682014-03-03 18:30:11662 }
663
Taylor Brandstetterc3928662018-02-23 21:04:51664 void TestCertificateReports(const rtc::FakeSSLIdentity& local_identity,
665 const std::vector<std::string>& local_ders,
666 const rtc::FakeSSLIdentity& remote_identity,
667 const std::vector<std::string>& remote_ders) {
Steve Anton3871f6f2018-01-26 18:25:53668 const std::string kTransportName = "transport";
decurtis@webrtc.org487a4442015-01-15 22:55:07669
Steve Anton3871f6f2018-01-26 18:25:53670 auto pc = CreatePeerConnection();
671 auto stats = CreateStatsCollector(pc);
672
Steve Anton5b387312018-02-03 00:00:20673 pc->AddVoiceChannel("audio", kTransportName);
wu@webrtc.org4551b792013-10-09 15:37:36674
675 // Fake stats to process.
Steve Anton3871f6f2018-01-26 18:25:53676 TransportChannelStats channel_stats;
wu@webrtc.org4551b792013-10-09 15:37:36677 channel_stats.component = 1;
Guo-wei Shieh521ed7b2015-11-19 03:41:53678 channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;
tkchin7d06a8c2016-04-04 21:10:43679 channel_stats.ssl_cipher_suite =
680 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
Steve Anton3871f6f2018-01-26 18:25:53681 pc->SetTransportStats(kTransportName, channel_stats);
wu@webrtc.org4551b792013-10-09 15:37:36682
Taylor Brandstetterc3928662018-02-23 21:04:51683 // Fake certificate to report.
Henrik Boströmd8281982015-08-27 08:12:24684 rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
Steve Anton3871f6f2018-01-26 18:25:53685 rtc::RTCCertificate::Create(
Taylor Brandstetterc3928662018-02-23 21:04:51686 std::unique_ptr<rtc::SSLIdentity>(local_identity.GetReference())));
Steve Anton3871f6f2018-01-26 18:25:53687 pc->SetLocalCertificate(kTransportName, local_certificate);
Taylor Brandstetterc3928662018-02-23 21:04:51688 pc->SetRemoteCertChain(kTransportName,
Steve Antonf25303e2018-10-16 22:23:31689 remote_identity.cert_chain().Clone());
wu@webrtc.org4551b792013-10-09 15:37:36690
Steve Anton3871f6f2018-01-26 18:25:53691 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
wu@webrtc.org4551b792013-10-09 15:37:36692
Steve Anton3871f6f2018-01-26 18:25:53693 StatsReports reports;
694 stats->GetStats(nullptr, &reports);
wu@webrtc.org4551b792013-10-09 15:37:36695
Yves Gerey665174f2018-06-19 13:03:05696 const StatsReport* channel_report =
697 FindNthReportByType(reports, StatsReport::kStatsReportTypeComponent, 1);
Steve Anton3871f6f2018-01-26 18:25:53698 EXPECT_TRUE(channel_report);
wu@webrtc.org4551b792013-10-09 15:37:36699
700 // Check local certificate chain.
Yves Gerey665174f2018-06-19 13:03:05701 std::string local_certificate_id =
702 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
703 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49704 if (local_ders.size() > 0) {
705 EXPECT_NE(kNotFound, local_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55706 StatsReport::Id id(IdFromCertIdString(local_certificate_id));
707 CheckCertChainReports(reports, local_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49708 } else {
709 EXPECT_EQ(kNotFound, local_certificate_id);
710 }
wu@webrtc.org4551b792013-10-09 15:37:36711
712 // Check remote certificate chain.
Yves Gerey665174f2018-06-19 13:03:05713 std::string remote_certificate_id =
714 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
715 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49716 if (remote_ders.size() > 0) {
717 EXPECT_NE(kNotFound, remote_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55718 StatsReport::Id id(IdFromCertIdString(remote_certificate_id));
719 CheckCertChainReports(reports, remote_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49720 } else {
721 EXPECT_EQ(kNotFound, remote_certificate_id);
722 }
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30723
724 // Check negotiated ciphers.
Guo-wei Shieh521ed7b2015-11-19 03:41:53725 std::string dtls_cipher_suite =
726 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
727 StatsReport::kStatsValueNameDtlsCipher);
728 EXPECT_EQ(rtc::SSLStreamAdapter::SslCipherSuiteToName(
tkchin7d06a8c2016-04-04 21:10:43729 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
Guo-wei Shieh521ed7b2015-11-19 03:41:53730 dtls_cipher_suite);
731 std::string srtp_crypto_suite =
732 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
733 StatsReport::kStatsValueNameSrtpCipher);
734 EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::SRTP_AES128_CM_SHA1_80),
735 srtp_crypto_suite);
wu@webrtc.org4551b792013-10-09 15:37:36736 }
Harald Alvestrand75ceef22018-01-04 14:26:13737};
738
Steve Antonefe4c922019-03-27 17:26:06739static rtc::scoped_refptr<MockRtpSenderInternal> CreateMockSender(
740 rtc::scoped_refptr<MediaStreamTrackInterface> track,
741 uint32_t ssrc) {
742 rtc::scoped_refptr<MockRtpSenderInternal> sender(
743 new rtc::RefCountedObject<MockRtpSenderInternal>());
744 EXPECT_CALL(*sender, track()).WillRepeatedly(Return(track));
745 EXPECT_CALL(*sender, ssrc()).WillRepeatedly(Return(ssrc));
746 EXPECT_CALL(*sender, media_type())
747 .WillRepeatedly(
748 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
749 ? cricket::MEDIA_TYPE_AUDIO
750 : cricket::MEDIA_TYPE_VIDEO));
751 return sender;
752}
753
754static rtc::scoped_refptr<MockRtpReceiverInternal> CreateMockReceiver(
755 rtc::scoped_refptr<MediaStreamTrackInterface> track,
756 uint32_t ssrc) {
757 rtc::scoped_refptr<MockRtpReceiverInternal> receiver(
758 new rtc::RefCountedObject<MockRtpReceiverInternal>());
759 EXPECT_CALL(*receiver, track()).WillRepeatedly(Return(track));
760 EXPECT_CALL(*receiver, ssrc()).WillRepeatedly(Return(ssrc));
761 EXPECT_CALL(*receiver, media_type())
762 .WillRepeatedly(
763 Return(track->kind() == MediaStreamTrackInterface::kAudioKind
764 ? cricket::MEDIA_TYPE_AUDIO
765 : cricket::MEDIA_TYPE_VIDEO));
766 return receiver;
767}
768
Harald Alvestrand75ceef22018-01-04 14:26:13769class StatsCollectorTrackTest : public StatsCollectorTest,
770 public ::testing::WithParamInterface<bool> {
771 public:
772 // Adds a outgoing video track with a given SSRC into the stats.
773 // If GetParam() returns true, the track is also inserted into the local
774 // stream, which is created if necessary.
Steve Anton3871f6f2018-01-26 18:25:53775 void AddOutgoingVideoTrack(FakePeerConnectionForStats* pc,
776 StatsCollectorForTest* stats) {
777 track_ = VideoTrack::Create(kLocalTrackId, FakeVideoTrackSource::Create(),
778 rtc::Thread::Current());
Harald Alvestrand75ceef22018-01-04 14:26:13779 if (GetParam()) {
780 if (!stream_)
Seth Hampson845e8782018-03-02 19:34:10781 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13782 stream_->AddTrack(track_);
783 stats->AddStream(stream_);
784 } else {
785 stats->AddTrack(track_);
786 }
Steve Antonefe4c922019-03-27 17:26:06787 pc->AddSender(CreateMockSender(track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13788 }
789
790 // Adds a incoming video track with a given SSRC into the stats.
Steve Anton3871f6f2018-01-26 18:25:53791 void AddIncomingVideoTrack(FakePeerConnectionForStats* pc,
792 StatsCollectorForTest* stats) {
793 track_ = VideoTrack::Create(kRemoteTrackId, FakeVideoTrackSource::Create(),
794 rtc::Thread::Current());
Harald Alvestrand75ceef22018-01-04 14:26:13795 if (GetParam()) {
Seth Hampson845e8782018-03-02 19:34:10796 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13797 stream_->AddTrack(track_);
798 stats->AddStream(stream_);
799 } else {
800 stats->AddTrack(track_);
801 }
Steve Antonefe4c922019-03-27 17:26:06802 pc->AddReceiver(CreateMockReceiver(track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13803 }
804
805 // Adds a outgoing audio track with a given SSRC into the stats,
806 // and register it into the stats object.
807 // If GetParam() returns true, the track is also inserted into the local
808 // stream, which is created if necessary.
Steve Antonefe4c922019-03-27 17:26:06809 rtc::scoped_refptr<RtpSenderInterface> AddOutgoingAudioTrack(
810 FakePeerConnectionForStats* pc,
811 StatsCollectorForTest* stats) {
Harald Alvestrand75ceef22018-01-04 14:26:13812 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(kLocalTrackId);
813 if (GetParam()) {
814 if (!stream_)
Seth Hampson845e8782018-03-02 19:34:10815 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13816 stream_->AddTrack(audio_track_);
817 stats->AddStream(stream_);
818 } else {
819 stats->AddTrack(audio_track_);
820 }
Steve Antonefe4c922019-03-27 17:26:06821 return pc->AddSender(CreateMockSender(audio_track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13822 }
823
824 // Adds a incoming audio track with a given SSRC into the stats.
Steve Anton3871f6f2018-01-26 18:25:53825 void AddIncomingAudioTrack(FakePeerConnectionForStats* pc,
826 StatsCollectorForTest* stats) {
Harald Alvestrand75ceef22018-01-04 14:26:13827 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId);
828 if (GetParam()) {
829 if (stream_ == NULL)
Seth Hampson845e8782018-03-02 19:34:10830 stream_ = MediaStream::Create("streamid");
Harald Alvestrand75ceef22018-01-04 14:26:13831 stream_->AddTrack(audio_track_);
832 stats->AddStream(stream_);
833 } else {
834 stats->AddTrack(audio_track_);
835 }
Steve Antonefe4c922019-03-27 17:26:06836 pc->AddReceiver(CreateMockReceiver(audio_track_, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:13837 }
838
Steve Anton3871f6f2018-01-26 18:25:53839 rtc::scoped_refptr<MediaStream> stream_;
840 rtc::scoped_refptr<VideoTrack> track_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52841 rtc::scoped_refptr<FakeAudioTrack> audio_track_;
henrike@webrtc.org28e20752013-07-10 00:45:36842};
843
zhihuang6ba3b192016-05-13 18:46:35844TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {
Steve Anton3871f6f2018-01-26 18:25:53845 auto pc = CreatePeerConnection();
846 auto stats = CreateStatsCollector(pc);
zhihuang6ba3b192016-05-13 18:46:35847
Steve Anton3871f6f2018-01-26 18:25:53848 pc->AddSctpDataChannel("hacks");
zhihuang6ba3b192016-05-13 18:46:35849
Steve Anton3871f6f2018-01-26 18:25:53850 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
zhihuang6ba3b192016-05-13 18:46:35851 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:53852 stats->GetStats(nullptr, &reports);
zhihuang6ba3b192016-05-13 18:46:35853
854 const StatsReport* report =
855 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
856
857 std::string value_in_report;
858 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,
859 &value_in_report));
860}
861
decurtis@webrtc.org487a4442015-01-15 22:55:07862// Verify that ExtractDataInfo populates reports.
863TEST_F(StatsCollectorTest, ExtractDataInfo) {
Steve Anton3871f6f2018-01-26 18:25:53864 const std::string kDataChannelLabel = "hacks";
865 constexpr int kDataChannelId = 31337;
866 const std::string kConnectingString = DataChannelInterface::DataStateString(
decurtis@webrtc.org487a4442015-01-15 22:55:07867 DataChannelInterface::DataState::kConnecting);
868
Steve Anton3871f6f2018-01-26 18:25:53869 auto pc = CreatePeerConnection();
870 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:07871
Steve Anton3871f6f2018-01-26 18:25:53872 InternalDataChannelInit init;
873 init.id = kDataChannelId;
874 pc->AddSctpDataChannel(kDataChannelLabel, init);
decurtis@webrtc.org487a4442015-01-15 22:55:07875
Steve Anton3871f6f2018-01-26 18:25:53876 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
decurtis@webrtc.org487a4442015-01-15 22:55:07877 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:53878 stats->GetStats(nullptr, &reports);
decurtis@webrtc.org322a5642015-02-03 22:09:37879
880 const StatsReport* report =
881 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
882
Steve Anton3871f6f2018-01-26 18:25:53883 StatsReport::Id report_id = StatsReport::NewTypedIntId(
884 StatsReport::kStatsReportTypeDataChannel, kDataChannelId);
decurtis@webrtc.org322a5642015-02-03 22:09:37885
Steve Anton3871f6f2018-01-26 18:25:53886 EXPECT_TRUE(report_id->Equals(report->id()));
decurtis@webrtc.org322a5642015-02-03 22:09:37887
Steve Anton3871f6f2018-01-26 18:25:53888 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
889 EXPECT_EQ(kDataChannelLabel,
890 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
891 StatsReport::kStatsValueNameLabel));
Jonas Olsson6b1985d2018-07-05 09:59:48892 EXPECT_EQ(rtc::ToString(kDataChannelId),
Peter Boström0c4e06b2015-10-07 10:23:21893 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
decurtis@webrtc.org487a4442015-01-15 22:55:07894 StatsReport::kStatsValueNameDataChannelId));
Steve Anton3871f6f2018-01-26 18:25:53895 EXPECT_EQ(kConnectingString,
896 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
897 StatsReport::kStatsValueNameState));
Yves Gerey665174f2018-06-19 13:03:05898 EXPECT_EQ("",
899 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
900 StatsReport::kStatsValueNameProtocol));
decurtis@webrtc.org487a4442015-01-15 22:55:07901}
902
henrike@webrtc.org28e20752013-07-10 00:45:36903// This test verifies that 64-bit counters are passed successfully.
Harald Alvestrand75ceef22018-01-04 14:26:13904TEST_P(StatsCollectorTrackTest, BytesCounterHandles64Bits) {
henrike@webrtc.org28e20752013-07-10 00:45:36905 // The number of bytes must be larger than 0xFFFFFFFF for this test.
Steve Anton3871f6f2018-01-26 18:25:53906 constexpr int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36907
Steve Anton3871f6f2018-01-26 18:25:53908 auto pc = CreatePeerConnection();
909 auto stats = CreateStatsCollector(pc);
henrike@webrtc.org28e20752013-07-10 00:45:36910
Steve Anton3871f6f2018-01-26 18:25:53911 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:06912 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:33913 video_sender_info.payload_bytes_sent = kBytesSent;
914 video_sender_info.header_and_padding_bytes_sent = 0;
Steve Anton3871f6f2018-01-26 18:25:53915 VideoMediaInfo video_info;
916 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:20917
918 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
919 video_media_channel->SetStats(video_info);
henrike@webrtc.org28e20752013-07-10 00:45:36920
Steve Anton3871f6f2018-01-26 18:25:53921 AddOutgoingVideoTrack(pc, stats.get());
922
923 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
924 StatsReports reports;
925 stats->GetStats(nullptr, &reports);
926
927 EXPECT_EQ(
928 rtc::ToString(kBytesSent),
929 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
henrike@webrtc.org28e20752013-07-10 00:45:36930}
931
Alex Narest42308f62017-06-19 15:58:12932// Test that audio BWE information is reported via stats.
Harald Alvestrand75ceef22018-01-04 14:26:13933TEST_P(StatsCollectorTrackTest, AudioBandwidthEstimationInfoIsReported) {
Alex Narest42308f62017-06-19 15:58:12934 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
935 // BWE.
Steve Anton3871f6f2018-01-26 18:25:53936 constexpr int64_t kBytesSent = 12345678901234LL;
937 constexpr int kSendBandwidth = 1234567;
938 constexpr int kRecvBandwidth = 12345678;
939 constexpr int kPacerDelay = 123;
Alex Narest42308f62017-06-19 15:58:12940
Steve Anton3871f6f2018-01-26 18:25:53941 auto pc = CreatePeerConnection();
942 auto stats = CreateStatsCollector(pc);
Alex Narest42308f62017-06-19 15:58:12943
Steve Anton3871f6f2018-01-26 18:25:53944 VoiceSenderInfo voice_sender_info;
Alex Narest42308f62017-06-19 15:58:12945 voice_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:33946 voice_sender_info.payload_bytes_sent = kBytesSent - 12;
947 voice_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:53948 VoiceMediaInfo voice_info;
949 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:20950
951 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
952 voice_media_channel->SetStats(voice_info);
Alex Narest42308f62017-06-19 15:58:12953
Steve Anton3871f6f2018-01-26 18:25:53954 AddOutgoingAudioTrack(pc, stats.get());
955
956 Call::Stats call_stats;
Alex Narest42308f62017-06-19 15:58:12957 call_stats.send_bandwidth_bps = kSendBandwidth;
958 call_stats.recv_bandwidth_bps = kRecvBandwidth;
959 call_stats.pacer_delay_ms = kPacerDelay;
Steve Anton3871f6f2018-01-26 18:25:53960 pc->SetCallStats(call_stats);
Alex Narest42308f62017-06-19 15:58:12961
Steve Anton3871f6f2018-01-26 18:25:53962 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
963 StatsReports reports;
964 stats->GetStats(nullptr, &reports);
965
966 EXPECT_EQ(
967 rtc::ToString(kBytesSent),
968 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
969 EXPECT_EQ(rtc::ToString(kSendBandwidth),
970 ExtractBweStatsValue(
971 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
972 EXPECT_EQ(
973 rtc::ToString(kRecvBandwidth),
974 ExtractBweStatsValue(
975 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
976 EXPECT_EQ(
977 rtc::ToString(kPacerDelay),
978 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
Alex Narest42308f62017-06-19 15:58:12979}
980
981// Test that video BWE information is reported via stats.
Harald Alvestrand75ceef22018-01-04 14:26:13982TEST_P(StatsCollectorTrackTest, VideoBandwidthEstimationInfoIsReported) {
henrike@webrtc.org28e20752013-07-10 00:45:36983 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
984 // BWE.
Steve Anton3871f6f2018-01-26 18:25:53985 constexpr int64_t kBytesSent = 12345678901234LL;
986 constexpr int kSendBandwidth = 1234567;
987 constexpr int kRecvBandwidth = 12345678;
988 constexpr int kPacerDelay = 123;
henrike@webrtc.org28e20752013-07-10 00:45:36989
Steve Anton3871f6f2018-01-26 18:25:53990 auto pc = CreatePeerConnection();
991 auto stats = CreateStatsCollector(pc);
henrike@webrtc.org28e20752013-07-10 00:45:36992
Steve Anton3871f6f2018-01-26 18:25:53993 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:06994 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:33995 video_sender_info.payload_bytes_sent = kBytesSent - 12;
996 video_sender_info.header_and_padding_bytes_sent = 12;
997
Steve Anton3871f6f2018-01-26 18:25:53998 VideoMediaInfo video_info;
999 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201000
1001 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1002 video_media_channel->SetStats(video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361003
Steve Anton3871f6f2018-01-26 18:25:531004 AddOutgoingVideoTrack(pc, stats.get());
1005
1006 Call::Stats call_stats;
stefanf79ade12017-06-02 13:44:031007 call_stats.send_bandwidth_bps = kSendBandwidth;
1008 call_stats.recv_bandwidth_bps = kRecvBandwidth;
1009 call_stats.pacer_delay_ms = kPacerDelay;
Steve Anton3871f6f2018-01-26 18:25:531010 pc->SetCallStats(call_stats);
wu@webrtc.org97077a32013-10-25 21:18:331011
Steve Anton3871f6f2018-01-26 18:25:531012 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1013 StatsReports reports;
1014 stats->GetStats(nullptr, &reports);
1015
1016 EXPECT_EQ(
1017 rtc::ToString(kBytesSent),
1018 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameBytesSent));
1019 EXPECT_EQ(rtc::ToString(kSendBandwidth),
1020 ExtractBweStatsValue(
1021 reports, StatsReport::kStatsValueNameAvailableSendBandwidth));
1022 EXPECT_EQ(
1023 rtc::ToString(kRecvBandwidth),
1024 ExtractBweStatsValue(
1025 reports, StatsReport::kStatsValueNameAvailableReceiveBandwidth));
1026 EXPECT_EQ(
1027 rtc::ToString(kPacerDelay),
1028 ExtractBweStatsValue(reports, StatsReport::kStatsValueNameBucketDelay));
henrike@webrtc.org28e20752013-07-10 00:45:361029}
1030
1031// This test verifies that an object of type "googSession" always
1032// exists in the returned stats.
1033TEST_F(StatsCollectorTest, SessionObjectExists) {
Steve Anton3871f6f2018-01-26 18:25:531034 auto pc = CreatePeerConnection();
1035 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071036
Steve Anton3871f6f2018-01-26 18:25:531037 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1038 StatsReports reports;
1039 stats->GetStats(nullptr, &reports);
1040
1041 EXPECT_TRUE(
1042 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
henrike@webrtc.org28e20752013-07-10 00:45:361043}
1044
1045// This test verifies that only one object of type "googSession" exists
1046// in the returned stats.
1047TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
Steve Anton3871f6f2018-01-26 18:25:531048 auto pc = CreatePeerConnection();
1049 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071050
Steve Anton3871f6f2018-01-26 18:25:531051 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1052 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1053 StatsReports reports;
1054 stats->GetStats(nullptr, &reports);
1055
1056 EXPECT_TRUE(
1057 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 1));
1058 EXPECT_FALSE(
1059 FindNthReportByType(reports, StatsReport::kStatsReportTypeSession, 2));
henrike@webrtc.org28e20752013-07-10 00:45:361060}
1061
1062// This test verifies that the empty track report exists in the returned stats
1063// without calling StatsCollector::UpdateStats.
Harald Alvestrand75ceef22018-01-04 14:26:131064TEST_P(StatsCollectorTrackTest, TrackObjectExistsWithoutUpdateStats) {
Steve Anton3871f6f2018-01-26 18:25:531065 auto pc = CreatePeerConnection();
1066 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071067
Steve Anton5b387312018-02-03 00:00:201068 pc->AddVideoChannel("video", "transport");
Steve Anton3871f6f2018-01-26 18:25:531069 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361070
henrike@webrtc.org28e20752013-07-10 00:45:361071 // Verfies the existence of the track report.
tommi@webrtc.org03505bc2014-07-14 20:15:261072 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531073 stats->GetStats(nullptr, &reports);
1074 ASSERT_EQ(1u, reports.size());
tommi@webrtc.org4fb7e252015-01-21 11:36:181075 EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
jbauchbe24c942015-06-22 22:06:431076 EXPECT_EQ(0, reports[0]->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:361077
1078 std::string trackValue =
Yves Gerey665174f2018-06-19 13:03:051079 ExtractStatsValue(StatsReport::kStatsReportTypeTrack, reports,
henrike@webrtc.org40b3b682014-03-03 18:30:111080 StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051081 EXPECT_EQ(kLocalTrackId, trackValue);
henrike@webrtc.org28e20752013-07-10 00:45:361082}
1083
1084// This test verifies that the empty track report exists in the returned stats
1085// when StatsCollector::UpdateStats is called with ssrc stats.
Harald Alvestrand75ceef22018-01-04 14:26:131086TEST_P(StatsCollectorTrackTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
Steve Anton3871f6f2018-01-26 18:25:531087 constexpr int64_t kBytesSent = 12345678901234LL;
decurtis@webrtc.org487a4442015-01-15 22:55:071088
Steve Anton3871f6f2018-01-26 18:25:531089 auto pc = CreatePeerConnection();
1090 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271091
Steve Anton3871f6f2018-01-26 18:25:531092 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061093 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:331094 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1095 video_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:531096 VideoMediaInfo video_info;
1097 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201098
1099 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1100 video_media_channel->SetStats(video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361101
Steve Anton3871f6f2018-01-26 18:25:531102 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361103
Steve Anton3871f6f2018-01-26 18:25:531104 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261105 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531106 stats->GetStats(nullptr, &reports);
1107
wu@webrtc.org97077a32013-10-25 21:18:331108 // |reports| should contain at least one session report, one track report,
1109 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531110 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051111 const StatsReport* track_report =
1112 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
xians@webrtc.org4cb01282014-06-12 14:57:051113 EXPECT_TRUE(track_report);
henrike@webrtc.org28e20752013-07-10 00:45:361114
xians@webrtc.org4cb01282014-06-12 14:57:051115 // Get report for the specific |track|.
tommi@webrtc.org5b06b062014-08-15 08:38:301116 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531117 stats->GetStats(track_, &reports);
wu@webrtc.org97077a32013-10-25 21:18:331118 // |reports| should contain at least one session report, one track report,
1119 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531120 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051121 track_report =
1122 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131123 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531124 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:361125
Yves Gerey665174f2018-06-19 13:03:051126 std::string ssrc_id =
1127 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481128 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org28e20752013-07-10 00:45:361129
Yves Gerey665174f2018-06-19 13:03:051130 std::string track_id =
1131 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051132 EXPECT_EQ(kLocalTrackId, track_id);
fippobec70ab2016-01-28 09:27:151133
Yves Gerey665174f2018-06-19 13:03:051134 std::string media_type =
1135 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameMediaType);
fippobec70ab2016-01-28 09:27:151136 EXPECT_EQ("video", media_type);
henrike@webrtc.org28e20752013-07-10 00:45:361137}
1138
1139// This test verifies that an SSRC object has the identifier of a Transport
1140// stats object, and that this transport stats object exists in stats.
Harald Alvestrand75ceef22018-01-04 14:26:131141TEST_P(StatsCollectorTrackTest, TransportObjectLinkedFromSsrcObject) {
Steve Anton3871f6f2018-01-26 18:25:531142 constexpr int64_t kBytesSent = 12345678901234LL;
decurtis@webrtc.org487a4442015-01-15 22:55:071143
Steve Anton3871f6f2018-01-26 18:25:531144 auto pc = CreatePeerConnection();
1145 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271146
Steve Anton3871f6f2018-01-26 18:25:531147 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061148 video_sender_info.add_ssrc(1234);
Niels Möllerac0a4cb2019-10-09 13:01:331149 video_sender_info.payload_bytes_sent = kBytesSent - 12;
1150 video_sender_info.header_and_padding_bytes_sent = 12;
Steve Anton3871f6f2018-01-26 18:25:531151 VideoMediaInfo video_info;
1152 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201153
1154 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1155 video_media_channel->SetStats(video_info);
henrike@webrtc.org28e20752013-07-10 00:45:361156
Steve Anton3871f6f2018-01-26 18:25:531157 AddOutgoingVideoTrack(pc, stats.get());
henrike@webrtc.org28e20752013-07-10 00:45:361158
Steve Anton3871f6f2018-01-26 18:25:531159 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261160 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531161 stats->GetStats(nullptr, &reports);
1162
Yves Gerey665174f2018-06-19 13:03:051163 std::string transport_id =
1164 ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports,
1165 StatsReport::kStatsValueNameTransportId);
henrike@webrtc.org28e20752013-07-10 00:45:361166 ASSERT_NE(kNotFound, transport_id);
Steve Anton3871f6f2018-01-26 18:25:531167
tommi@webrtc.org4fb7e252015-01-21 11:36:181168 // Transport id component ID will always be 1.
1169 // This has assumptions about how the ID is constructed. As is, this is
1170 // OK since this is for testing purposes only, but if we ever need this
1171 // in production, we should add a generic method that does this.
1172 size_t index = transport_id.find('-');
1173 ASSERT_NE(std::string::npos, index);
1174 std::string content = transport_id.substr(index + 1);
1175 index = content.rfind('-');
1176 ASSERT_NE(std::string::npos, index);
1177 content = content.substr(0, index);
tommi@webrtc.orgd3900292015-03-12 16:35:551178 StatsReport::Id id(StatsReport::NewComponentId(content, 1));
tommi@webrtc.org4fb7e252015-01-21 11:36:181179 ASSERT_EQ(transport_id, id->ToString());
tommi@webrtc.orgd3900292015-03-12 16:35:551180 const StatsReport* transport_report = FindReportById(reports, id);
Steve Anton3871f6f2018-01-26 18:25:531181 ASSERT_TRUE(transport_report);
henrike@webrtc.org28e20752013-07-10 00:45:361182}
1183
wu@webrtc.org97077a32013-10-25 21:18:331184// This test verifies that a remote stats object will not be created for
1185// an outgoing SSRC where remote stats are not returned.
Harald Alvestrand75ceef22018-01-04 14:26:131186TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsAbsent) {
Steve Anton3871f6f2018-01-26 18:25:531187 auto pc = CreatePeerConnection();
1188 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071189
Steve Anton5b387312018-02-03 00:00:201190 pc->AddVideoChannel("video", "transport");
Steve Anton3871f6f2018-01-26 18:25:531191 AddOutgoingVideoTrack(pc, stats.get());
wu@webrtc.org97077a32013-10-25 21:18:331192
Steve Anton3871f6f2018-01-26 18:25:531193 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org40b3b682014-03-03 18:30:111194 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531195 stats->GetStats(nullptr, &reports);
1196
Yves Gerey665174f2018-06-19 13:03:051197 const StatsReport* remote_report =
1198 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531199 EXPECT_FALSE(remote_report);
wu@webrtc.org97077a32013-10-25 21:18:331200}
1201
1202// This test verifies that a remote stats object will be created for
1203// an outgoing SSRC where stats are returned.
Harald Alvestrand75ceef22018-01-04 14:26:131204TEST_P(StatsCollectorTrackTest, RemoteSsrcInfoIsPresent) {
Steve Anton3871f6f2018-01-26 18:25:531205 auto pc = CreatePeerConnection();
1206 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071207
Steve Anton3871f6f2018-01-26 18:25:531208 SsrcReceiverInfo remote_ssrc_stats;
wu@webrtc.org97077a32013-10-25 21:18:331209 remote_ssrc_stats.timestamp = 12345.678;
1210 remote_ssrc_stats.ssrc = kSsrcOfTrack;
Steve Anton3871f6f2018-01-26 18:25:531211 VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:061212 video_sender_info.add_ssrc(kSsrcOfTrack);
wu@webrtc.org97077a32013-10-25 21:18:331213 video_sender_info.remote_stats.push_back(remote_ssrc_stats);
Steve Anton3871f6f2018-01-26 18:25:531214 VideoMediaInfo video_info;
1215 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201216
1217 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1218 video_media_channel->SetStats(video_info);
wu@webrtc.org97077a32013-10-25 21:18:331219
Steve Anton3871f6f2018-01-26 18:25:531220 AddOutgoingVideoTrack(pc, stats.get());
wu@webrtc.org97077a32013-10-25 21:18:331221
Steve Anton3871f6f2018-01-26 18:25:531222 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261223 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531224 stats->GetStats(nullptr, &reports);
xians@webrtc.org4cb01282014-06-12 14:57:051225
Yves Gerey665174f2018-06-19 13:03:051226 const StatsReport* remote_report =
1227 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531228 ASSERT_TRUE(remote_report);
decurtis@webrtc.org322a5642015-02-03 22:09:371229 EXPECT_EQ(12345.678, remote_report->timestamp());
wu@webrtc.org97077a32013-10-25 21:18:331230}
1231
xians@webrtc.org4cb01282014-06-12 14:57:051232// This test verifies that the empty track report exists in the returned stats
1233// when StatsCollector::UpdateStats is called with ssrc stats.
Harald Alvestrand75ceef22018-01-04 14:26:131234TEST_P(StatsCollectorTrackTest, ReportsFromRemoteTrack) {
Steve Anton3871f6f2018-01-26 18:25:531235 constexpr int64_t kNumOfPacketsConcealed = 54321;
decurtis@webrtc.org487a4442015-01-15 22:55:071236
Steve Anton3871f6f2018-01-26 18:25:531237 auto pc = CreatePeerConnection();
1238 auto stats = CreateStatsCollector(pc);
deadbeefcbecd352015-09-23 18:50:271239
Steve Anton3871f6f2018-01-26 18:25:531240 VideoReceiverInfo video_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051241 video_receiver_info.add_ssrc(1234);
pbos@webrtc.org1ed62242015-02-19 13:57:031242 video_receiver_info.packets_concealed = kNumOfPacketsConcealed;
Steve Anton3871f6f2018-01-26 18:25:531243 VideoMediaInfo video_info;
1244 video_info.receivers.push_back(video_receiver_info);
Steve Anton5b387312018-02-03 00:00:201245
1246 auto* video_media_info = pc->AddVideoChannel("video", "transport");
1247 video_media_info->SetStats(video_info);
xians@webrtc.org4cb01282014-06-12 14:57:051248
Steve Anton3871f6f2018-01-26 18:25:531249 AddIncomingVideoTrack(pc, stats.get());
xians@webrtc.org4cb01282014-06-12 14:57:051250
Steve Anton3871f6f2018-01-26 18:25:531251 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:261252 StatsReports reports;
Steve Anton3871f6f2018-01-26 18:25:531253 stats->GetStats(nullptr, &reports);
1254
xians@webrtc.org4cb01282014-06-12 14:57:051255 // |reports| should contain at least one session report, one track report,
1256 // and one ssrc report.
Steve Anton3871f6f2018-01-26 18:25:531257 EXPECT_LE(3u, reports.size());
Yves Gerey665174f2018-06-19 13:03:051258 const StatsReport* track_report =
1259 FindNthReportByType(reports, StatsReport::kStatsReportTypeTrack, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131260 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531261 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
xians@webrtc.org4cb01282014-06-12 14:57:051262
Yves Gerey665174f2018-06-19 13:03:051263 std::string ssrc_id =
1264 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481265 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
xians@webrtc.org4cb01282014-06-12 14:57:051266
Yves Gerey665174f2018-06-19 13:03:051267 std::string track_id =
1268 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051269 EXPECT_EQ(kRemoteTrackId, track_id);
1270}
1271
guoweis@webrtc.org950c5182014-12-16 23:01:311272// This test verifies the Ice Candidate report should contain the correct
1273// information from local/remote candidates.
1274TEST_F(StatsCollectorTest, IceCandidateReport) {
Steve Anton3871f6f2018-01-26 18:25:531275 const std::string kTransportName = "transport";
1276 const rtc::AdapterType kNetworkType = rtc::ADAPTER_TYPE_ETHERNET;
1277 constexpr uint32_t kPriority = 1000;
decurtis@webrtc.org487a4442015-01-15 22:55:071278
Steve Anton3871f6f2018-01-26 18:25:531279 constexpr int kLocalPort = 2000;
1280 const std::string kLocalIp = "192.168.0.1";
1281 const rtc::SocketAddress kLocalAddress(kLocalIp, kLocalPort);
guoweis@webrtc.org950c5182014-12-16 23:01:311282
Steve Anton3871f6f2018-01-26 18:25:531283 constexpr int kRemotePort = 2001;
1284 const std::string kRemoteIp = "192.168.0.2";
1285 const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
guoweis@webrtc.org950c5182014-12-16 23:01:311286
Steve Anton3871f6f2018-01-26 18:25:531287 auto pc = CreatePeerConnection();
1288 auto stats = CreateStatsCollector(pc);
guoweis@webrtc.org950c5182014-12-16 23:01:311289
Steve Anton3871f6f2018-01-26 18:25:531290 cricket::Candidate local;
1291 EXPECT_GT(local.id().length(), 0u);
1292 local.set_type(cricket::LOCAL_PORT_TYPE);
1293 local.set_protocol(cricket::UDP_PROTOCOL_NAME);
1294 local.set_address(kLocalAddress);
1295 local.set_priority(kPriority);
1296 local.set_network_type(kNetworkType);
guoweis@webrtc.org950c5182014-12-16 23:01:311297
Steve Anton3871f6f2018-01-26 18:25:531298 cricket::Candidate remote;
1299 EXPECT_GT(remote.id().length(), 0u);
1300 remote.set_type(cricket::PRFLX_PORT_TYPE);
1301 remote.set_protocol(cricket::UDP_PROTOCOL_NAME);
1302 remote.set_address(kRemoteAddress);
1303 remote.set_priority(kPriority);
1304 remote.set_network_type(kNetworkType);
guoweis@webrtc.org950c5182014-12-16 23:01:311305
Steve Anton3871f6f2018-01-26 18:25:531306 ConnectionInfo connection_info;
1307 connection_info.local_candidate = local;
1308 connection_info.remote_candidate = remote;
1309 TransportChannelStats channel_stats;
Jonas Oreland149dc722019-08-28 06:10:271310 channel_stats.ice_transport_stats.connection_infos.push_back(connection_info);
Steve Anton3871f6f2018-01-26 18:25:531311
Steve Anton5b387312018-02-03 00:00:201312 pc->AddVoiceChannel("audio", kTransportName);
Steve Anton3871f6f2018-01-26 18:25:531313 pc->SetTransportStats(kTransportName, channel_stats);
1314
1315 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1316 StatsReports reports;
1317 stats->GetStats(nullptr, &reports);
guoweis@webrtc.org950c5182014-12-16 23:01:311318
1319 // Verify the local candidate report is populated correctly.
1320 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531321 "Cand-" + local.id(),
1322 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1323 StatsReport::kStatsValueNameLocalCandidateId));
1324 EXPECT_EQ(
1325 kLocalIp,
guoweis@webrtc.org950c5182014-12-16 23:01:311326 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1327 StatsReport::kStatsValueNameCandidateIPAddress));
1328 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531329 rtc::ToString(kLocalPort),
guoweis@webrtc.org950c5182014-12-16 23:01:311330 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1331 StatsReport::kStatsValueNameCandidatePortNumber));
1332 EXPECT_EQ(
1333 cricket::UDP_PROTOCOL_NAME,
1334 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1335 StatsReport::kStatsValueNameCandidateTransportType));
1336 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531337 rtc::ToString(kPriority),
guoweis@webrtc.org950c5182014-12-16 23:01:311338 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1339 StatsReport::kStatsValueNameCandidatePriority));
1340 EXPECT_EQ(
1341 IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),
1342 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1343 StatsReport::kStatsValueNameCandidateType));
1344 EXPECT_EQ(
Steve Anton3871f6f2018-01-26 18:25:531345 AdapterTypeToStatsType(kNetworkType),
guoweis@webrtc.org950c5182014-12-16 23:01:311346 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1347 StatsReport::kStatsValueNameCandidateNetworkType));
1348
1349 // Verify the remote candidate report is populated correctly.
Steve Anton3871f6f2018-01-26 18:25:531350 EXPECT_EQ(
1351 "Cand-" + remote.id(),
1352 ExtractStatsValue(StatsReport::kStatsReportTypeCandidatePair, reports,
1353 StatsReport::kStatsValueNameRemoteCandidateId));
1354 EXPECT_EQ(kRemoteIp,
guoweis@webrtc.org950c5182014-12-16 23:01:311355 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1356 reports,
1357 StatsReport::kStatsValueNameCandidateIPAddress));
Steve Anton3871f6f2018-01-26 18:25:531358 EXPECT_EQ(rtc::ToString(kRemotePort),
guoweis@webrtc.org950c5182014-12-16 23:01:311359 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1360 reports,
1361 StatsReport::kStatsValueNameCandidatePortNumber));
1362 EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
1363 ExtractStatsValue(
1364 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1365 StatsReport::kStatsValueNameCandidateTransportType));
Steve Anton3871f6f2018-01-26 18:25:531366 EXPECT_EQ(rtc::ToString(kPriority),
guoweis@webrtc.org950c5182014-12-16 23:01:311367 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1368 reports,
1369 StatsReport::kStatsValueNameCandidatePriority));
1370 EXPECT_EQ(
1371 IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),
1372 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1373 reports, StatsReport::kStatsValueNameCandidateType));
1374 EXPECT_EQ(kNotFound,
1375 ExtractStatsValue(
1376 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1377 StatsReport::kStatsValueNameCandidateNetworkType));
1378}
1379
wu@webrtc.org4551b792013-10-09 15:37:361380// This test verifies that all chained certificates are correctly
1381// reported
mallinath@webrtc.org19f27e62013-10-13 17:18:271382TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:361383 // Build local certificate chain.
1384 std::vector<std::string> local_ders(5);
1385 local_ders[0] = "These";
1386 local_ders[1] = "are";
1387 local_ders[2] = "some";
1388 local_ders[3] = "der";
1389 local_ders[4] = "values";
Taylor Brandstetterc3928662018-02-23 21:04:511390 rtc::FakeSSLIdentity local_identity(DersToPems(local_ders));
wu@webrtc.org4551b792013-10-09 15:37:361391
1392 // Build remote certificate chain
1393 std::vector<std::string> remote_ders(4);
1394 remote_ders[0] = "A";
1395 remote_ders[1] = "non-";
1396 remote_ders[2] = "intersecting";
1397 remote_ders[3] = "set";
Taylor Brandstetterc3928662018-02-23 21:04:511398 rtc::FakeSSLIdentity remote_identity(DersToPems(remote_ders));
wu@webrtc.org4551b792013-10-09 15:37:361399
Taylor Brandstetterc3928662018-02-23 21:04:511400 TestCertificateReports(local_identity, local_ders, remote_identity,
kwibergb4d01c42016-04-06 12:15:061401 remote_ders);
wu@webrtc.org4551b792013-10-09 15:37:361402}
1403
1404// This test verifies that all certificates without chains are correctly
1405// reported.
mallinath@webrtc.org19f27e62013-10-13 17:18:271406TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:361407 // Build local certificate.
1408 std::string local_der = "This is the local der.";
Taylor Brandstetterc3928662018-02-23 21:04:511409 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
wu@webrtc.org4551b792013-10-09 15:37:361410
1411 // Build remote certificate.
1412 std::string remote_der = "This is somebody else's der.";
Taylor Brandstetterc3928662018-02-23 21:04:511413 rtc::FakeSSLIdentity remote_identity(DerToPem(remote_der));
wu@webrtc.org4551b792013-10-09 15:37:361414
Taylor Brandstetterc3928662018-02-23 21:04:511415 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1416 remote_identity,
kwibergb4d01c42016-04-06 12:15:061417 std::vector<std::string>(1, remote_der));
wu@webrtc.org4551b792013-10-09 15:37:361418}
1419
1420// This test verifies that the stats are generated correctly when no
1421// transport is present.
mallinath@webrtc.org19f27e62013-10-13 17:18:271422TEST_F(StatsCollectorTest, NoTransport) {
Steve Anton3871f6f2018-01-26 18:25:531423 auto pc = CreatePeerConnection();
1424 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071425
Steve Anton3871f6f2018-01-26 18:25:531426 // This will cause the fake PeerConnection to generate a TransportStats entry
1427 // but with only a single dummy TransportChannelStats.
Steve Anton5b387312018-02-03 00:00:201428 pc->AddVoiceChannel("audio", "transport");
deadbeefcbecd352015-09-23 18:50:271429
Steve Anton3871f6f2018-01-26 18:25:531430 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1431 StatsReports reports;
1432 stats->GetStats(nullptr, &reports);
wu@webrtc.org4551b792013-10-09 15:37:361433
1434 // Check that the local certificate is absent.
Yves Gerey665174f2018-06-19 13:03:051435 std::string local_certificate_id =
1436 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1437 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:361438 ASSERT_EQ(kNotFound, local_certificate_id);
1439
1440 // Check that the remote certificate is absent.
Yves Gerey665174f2018-06-19 13:03:051441 std::string remote_certificate_id =
1442 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1443 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:361444 ASSERT_EQ(kNotFound, remote_certificate_id);
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:301445
1446 // Check that the negotiated ciphers are absent.
Guo-wei Shieh521ed7b2015-11-19 03:41:531447 std::string dtls_cipher_suite =
1448 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1449 StatsReport::kStatsValueNameDtlsCipher);
1450 ASSERT_EQ(kNotFound, dtls_cipher_suite);
1451 std::string srtp_crypto_suite =
1452 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,
1453 StatsReport::kStatsValueNameSrtpCipher);
1454 ASSERT_EQ(kNotFound, srtp_crypto_suite);
wu@webrtc.org4551b792013-10-09 15:37:361455}
1456
wu@webrtc.orgb9a088b2014-02-13 23:18:491457// This test verifies that a remote certificate with an unsupported digest
1458// algorithm is correctly ignored.
1459TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
1460 // Build a local certificate.
1461 std::string local_der = "This is the local der.";
Taylor Brandstetterc3928662018-02-23 21:04:511462 rtc::FakeSSLIdentity local_identity(DerToPem(local_der));
wu@webrtc.orgb9a088b2014-02-13 23:18:491463
1464 // Build a remote certificate with an unsupported digest algorithm.
1465 std::string remote_der = "This is somebody else's der.";
Taylor Brandstetterc3928662018-02-23 21:04:511466 rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
1467 remote_cert.set_digest_algorithm("foobar");
1468 rtc::FakeSSLIdentity remote_identity(remote_cert);
wu@webrtc.orgb9a088b2014-02-13 23:18:491469
Taylor Brandstetterc3928662018-02-23 21:04:511470 TestCertificateReports(local_identity, std::vector<std::string>(1, local_der),
1471 remote_identity, std::vector<std::string>());
wu@webrtc.orgb9a088b2014-02-13 23:18:491472}
1473
zhihuang6ba3b192016-05-13 18:46:351474// This test verifies that the audio/video related stats which are -1 initially
1475// will be filtered out.
Harald Alvestrand75ceef22018-01-04 14:26:131476TEST_P(StatsCollectorTrackTest, FilterOutNegativeInitialValues) {
Harald Alvestrand75ceef22018-01-04 14:26:131477 // This test uses streams, but only works for the stream case.
Steve Anton3871f6f2018-01-26 18:25:531478 if (!GetParam()) {
Harald Alvestrand75ceef22018-01-04 14:26:131479 return;
Steve Anton3871f6f2018-01-26 18:25:531480 }
zhihuang6ba3b192016-05-13 18:46:351481
Steve Anton3871f6f2018-01-26 18:25:531482 auto pc = CreatePeerConnection();
1483 auto stats = CreateStatsCollector(pc);
zhihuang6ba3b192016-05-13 18:46:351484
1485 // Create a local stream with a local audio track and adds it to the stats.
Seth Hampson845e8782018-03-02 19:34:101486 stream_ = MediaStream::Create("streamid");
zhihuang6ba3b192016-05-13 18:46:351487 rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(
1488 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));
1489 stream_->AddTrack(local_track);
Steve Antonefe4c922019-03-27 17:26:061490 pc->AddSender(CreateMockSender(local_track, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:131491 if (GetParam()) {
Steve Anton3871f6f2018-01-26 18:25:531492 stats->AddStream(stream_);
Harald Alvestrand75ceef22018-01-04 14:26:131493 }
Steve Anton3871f6f2018-01-26 18:25:531494 stats->AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);
zhihuang6ba3b192016-05-13 18:46:351495
1496 // Create a remote stream with a remote audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531497 rtc::scoped_refptr<MediaStream> remote_stream(
Seth Hampson845e8782018-03-02 19:34:101498 MediaStream::Create("remotestreamid"));
zhihuang6ba3b192016-05-13 18:46:351499 rtc::scoped_refptr<FakeAudioTrackWithInitValue> remote_track(
1500 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kRemoteTrackId));
zhihuang6ba3b192016-05-13 18:46:351501 remote_stream->AddTrack(remote_track);
Steve Antonefe4c922019-03-27 17:26:061502 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
Harald Alvestrand75ceef22018-01-04 14:26:131503 if (GetParam()) {
Steve Anton3871f6f2018-01-26 18:25:531504 stats->AddStream(remote_stream);
Harald Alvestrand75ceef22018-01-04 14:26:131505 }
zhihuang6ba3b192016-05-13 18:46:351506
Steve Anton3871f6f2018-01-26 18:25:531507 VoiceSenderInfo voice_sender_info;
zhihuang6ba3b192016-05-13 18:46:351508 voice_sender_info.add_ssrc(kSsrcOfTrack);
1509 // These values are set to -1 initially in audio_send_stream.
1510 // The voice_sender_info will read the values from audio_send_stream.
1511 voice_sender_info.rtt_ms = -1;
1512 voice_sender_info.packets_lost = -1;
1513 voice_sender_info.jitter_ms = -1;
1514
1515 // Some of the contents in |voice_sender_info| needs to be updated from the
1516 // |audio_track_|.
Ivo Creusen56d460902017-11-24 16:29:591517 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &voice_sender_info,
1518 true);
zhihuang6ba3b192016-05-13 18:46:351519
Steve Anton3871f6f2018-01-26 18:25:531520 VoiceReceiverInfo voice_receiver_info;
zhihuang6ba3b192016-05-13 18:46:351521 voice_receiver_info.add_ssrc(kSsrcOfTrack);
1522 voice_receiver_info.capture_start_ntp_time_ms = -1;
1523 voice_receiver_info.audio_level = -1;
1524
1525 // Constructs an ssrc stats update.
Steve Anton3871f6f2018-01-26 18:25:531526 VoiceMediaInfo voice_info;
1527 voice_info.senders.push_back(voice_sender_info);
1528 voice_info.receivers.push_back(voice_receiver_info);
zhihuang6ba3b192016-05-13 18:46:351529
Steve Anton5b387312018-02-03 00:00:201530 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1531 voice_media_channel->SetStats(voice_info);
zhihuang6ba3b192016-05-13 18:46:351532
Steve Anton3871f6f2018-01-26 18:25:531533 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
zhihuang6ba3b192016-05-13 18:46:351534
1535 // Get stats for the local track.
Steve Anton3871f6f2018-01-26 18:25:531536 StatsReports reports;
1537 stats->GetStats(local_track.get(), &reports);
zhihuang6ba3b192016-05-13 18:46:351538 const StatsReport* report =
1539 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131540 ASSERT_TRUE(report);
zhihuang6ba3b192016-05-13 18:46:351541 // The -1 will not be added to the stats report.
1542 std::string value_in_report;
1543 EXPECT_FALSE(
1544 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));
1545 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,
1546 &value_in_report));
1547 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,
1548 &value_in_report));
zhihuang6ba3b192016-05-13 18:46:351549 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,
1550 &value_in_report));
1551 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,
1552 &value_in_report));
1553
1554 // Get stats for the remote track.
1555 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531556 stats->GetStats(remote_track.get(), &reports);
zhihuang6ba3b192016-05-13 18:46:351557 report = FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131558 ASSERT_TRUE(report);
zhihuang6ba3b192016-05-13 18:46:351559 EXPECT_FALSE(GetValue(report,
1560 StatsReport::kStatsValueNameCaptureStartNtpTimeMs,
1561 &value_in_report));
1562 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,
1563 &value_in_report));
1564}
1565
henrike@webrtc.org40b3b682014-03-03 18:30:111566// This test verifies that a local stats object can get statistics via
1567// AudioTrackInterface::GetStats() method.
Harald Alvestrand75ceef22018-01-04 14:26:131568TEST_P(StatsCollectorTrackTest, GetStatsFromLocalAudioTrack) {
Steve Anton3871f6f2018-01-26 18:25:531569 auto pc = CreatePeerConnection();
1570 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071571
Steve Anton3871f6f2018-01-26 18:25:531572 AddOutgoingAudioTrack(pc, stats.get());
1573 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
tommi@webrtc.org242068d2014-07-14 20:19:561574
Steve Anton3871f6f2018-01-26 18:25:531575 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051576 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531577 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
1578 VoiceMediaInfo voice_info;
1579 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201580
1581 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1582 voice_media_channel->SetStats(voice_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111583
henrike@webrtc.org40b3b682014-03-03 18:30:111584 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531585 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:111586
xians@webrtc.org4cb01282014-06-12 14:57:051587 // Verify that there is no remote report for the local audio track because
1588 // we did not set it up.
Yves Gerey665174f2018-06-19 13:03:051589 const StatsReport* remote_report =
1590 FindNthReportByType(reports, StatsReport::kStatsReportTypeRemoteSsrc, 1);
xians@webrtc.org4cb01282014-06-12 14:57:051591 EXPECT_TRUE(remote_report == NULL);
1592}
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101593
1594// This test verifies that audio receive streams populate stats reports
1595// correctly.
Harald Alvestrand75ceef22018-01-04 14:26:131596TEST_P(StatsCollectorTrackTest, GetStatsFromRemoteStream) {
Steve Anton3871f6f2018-01-26 18:25:531597 auto pc = CreatePeerConnection();
1598 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071599
Steve Anton3871f6f2018-01-26 18:25:531600 AddIncomingAudioTrack(pc, stats.get());
deadbeefcbecd352015-09-23 18:50:271601
Steve Anton3871f6f2018-01-26 18:25:531602 VoiceReceiverInfo voice_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051603 InitVoiceReceiverInfo(&voice_receiver_info);
buildbot@webrtc.org7e71b772014-06-13 01:14:011604 voice_receiver_info.codec_name = "fake_codec";
Steve Anton3871f6f2018-01-26 18:25:531605 VoiceMediaInfo voice_info;
1606 voice_info.receivers.push_back(voice_receiver_info);
Steve Anton5b387312018-02-03 00:00:201607
1608 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1609 voice_media_channel->SetStats(voice_info);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101610
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101611 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531612 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:101613}
1614
henrike@webrtc.org40b3b682014-03-03 18:30:111615// This test verifies that a local stats object won't update its statistics
1616// after a RemoveLocalAudioTrack() call.
Harald Alvestrand75ceef22018-01-04 14:26:131617TEST_P(StatsCollectorTrackTest, GetStatsAfterRemoveAudioStream) {
Steve Anton3871f6f2018-01-26 18:25:531618 auto pc = CreatePeerConnection();
1619 auto stats = CreateStatsCollector(pc);
decurtis@webrtc.org487a4442015-01-15 22:55:071620
Steve Anton3871f6f2018-01-26 18:25:531621 AddOutgoingAudioTrack(pc, stats.get());
1622 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
deadbeefcbecd352015-09-23 18:50:271623
Steve Anton3871f6f2018-01-26 18:25:531624 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051625 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531626 VoiceMediaInfo voice_info;
1627 voice_info.senders.push_back(voice_sender_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111628
Steve Anton5b387312018-02-03 00:00:201629 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1630 voice_media_channel->SetStats(voice_info);
henrike@webrtc.org40b3b682014-03-03 18:30:111631
Steve Anton3871f6f2018-01-26 18:25:531632 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
henrike@webrtc.org40b3b682014-03-03 18:30:111633
Steve Anton3871f6f2018-01-26 18:25:531634 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1635 StatsReports reports;
1636 stats->GetStats(nullptr, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:111637
1638 // The report will exist since we don't remove them in RemoveStream().
Yves Gerey665174f2018-06-19 13:03:051639 const StatsReport* report =
1640 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Steve Anton3871f6f2018-01-26 18:25:531641 ASSERT_TRUE(report);
1642 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051643 std::string track_id =
1644 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051645 EXPECT_EQ(kLocalTrackId, track_id);
Yves Gerey665174f2018-06-19 13:03:051646 std::string ssrc_id =
1647 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameSsrc);
Jonas Olsson6b1985d2018-07-05 09:59:481648 EXPECT_EQ(rtc::ToString(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org40b3b682014-03-03 18:30:111649
1650 // Verifies the values in the track report, no value will be changed by the
1651 // AudioTrackInterface::GetSignalValue() and
Sam Zackrisson28127632018-11-01 10:37:151652 // AudioProcessorInterface::GetStats();
henrike@webrtc.org40b3b682014-03-03 18:30:111653 VerifyVoiceSenderInfoReport(report, voice_sender_info);
1654}
1655
xians@webrtc.org4cb01282014-06-12 14:57:051656// This test verifies that when ongoing and incoming audio tracks are using
1657// the same ssrc, they populate stats reports correctly.
Harald Alvestrand75ceef22018-01-04 14:26:131658TEST_P(StatsCollectorTrackTest, LocalAndRemoteTracksWithSameSsrc) {
Steve Anton3871f6f2018-01-26 18:25:531659 auto pc = CreatePeerConnection();
1660 auto stats = CreateStatsCollector(pc);
xians@webrtc.org4cb01282014-06-12 14:57:051661
1662 // Create a local stream with a local audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531663 AddOutgoingAudioTrack(pc, stats.get());
1664 stats->AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
xians@webrtc.org4cb01282014-06-12 14:57:051665
1666 // Create a remote stream with a remote audio track and adds it to the stats.
Steve Anton3871f6f2018-01-26 18:25:531667 rtc::scoped_refptr<MediaStream> remote_stream(
Seth Hampson845e8782018-03-02 19:34:101668 MediaStream::Create("remotestreamid"));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:521669 rtc::scoped_refptr<FakeAudioTrack> remote_track(
1670 new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));
Steve Antonefe4c922019-03-27 17:26:061671 pc->AddReceiver(CreateMockReceiver(remote_track, kSsrcOfTrack));
xians@webrtc.org4cb01282014-06-12 14:57:051672 remote_stream->AddTrack(remote_track);
Steve Anton3871f6f2018-01-26 18:25:531673 stats->AddStream(remote_stream);
xians@webrtc.org4cb01282014-06-12 14:57:051674
Steve Anton3871f6f2018-01-26 18:25:531675 VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:051676 InitVoiceSenderInfo(&voice_sender_info);
xians@webrtc.org4cb01282014-06-12 14:57:051677 // Some of the contents in |voice_sender_info| needs to be updated from the
1678 // |audio_track_|.
Ivo Creusen56d460902017-11-24 16:29:591679 UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info,
1680 true);
xians@webrtc.org4cb01282014-06-12 14:57:051681
Steve Anton3871f6f2018-01-26 18:25:531682 VoiceReceiverInfo voice_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:051683 InitVoiceReceiverInfo(&voice_receiver_info);
1684
1685 // Constructs an ssrc stats update.
Steve Anton3871f6f2018-01-26 18:25:531686 VoiceMediaInfo voice_info;
1687 voice_info.senders.push_back(voice_sender_info);
1688 voice_info.receivers.push_back(voice_receiver_info);
xians@webrtc.org4cb01282014-06-12 14:57:051689
Steve Anton3871f6f2018-01-26 18:25:531690 // Instruct the session to return stats containing the transport channel.
Steve Anton5b387312018-02-03 00:00:201691 auto* voice_media_channel = pc->AddVoiceChannel("audio", "transport");
1692 voice_media_channel->SetStats(voice_info);
xians@webrtc.org4cb01282014-06-12 14:57:051693
Steve Anton3871f6f2018-01-26 18:25:531694 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
xians@webrtc.org4cb01282014-06-12 14:57:051695
1696 // Get stats for the local track.
Steve Anton3871f6f2018-01-26 18:25:531697 StatsReports reports; // returned values.
1698 stats->GetStats(audio_track_.get(), &reports);
1699
Yves Gerey665174f2018-06-19 13:03:051700 const StatsReport* track_report =
1701 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131702 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531703 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051704 std::string track_id =
1705 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051706 EXPECT_EQ(kLocalTrackId, track_id);
1707 VerifyVoiceSenderInfoReport(track_report, voice_sender_info);
1708
1709 // Get stats for the remote track.
tommi@webrtc.org5b06b062014-08-15 08:38:301710 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531711 stats->GetStats(remote_track.get(), &reports);
Yves Gerey665174f2018-06-19 13:03:051712 track_report =
1713 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);
Harald Alvestrand75ceef22018-01-04 14:26:131714 ASSERT_TRUE(track_report);
Steve Anton3871f6f2018-01-26 18:25:531715 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
Yves Gerey665174f2018-06-19 13:03:051716 track_id =
1717 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:051718 EXPECT_EQ(kRemoteTrackId, track_id);
1719 VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
1720}
1721
xians@webrtc.org01bda202014-07-09 07:38:381722// This test verifies that when two outgoing audio tracks are using the same
1723// ssrc at different times, they populate stats reports correctly.
1724// TODO(xians): Figure out if it is possible to encapsulate the setup and
1725// avoid duplication of code in test cases.
Harald Alvestrand75ceef22018-01-04 14:26:131726TEST_P(StatsCollectorTrackTest, TwoLocalTracksWithSameSsrc) {
Harald Alvestrand75ceef22018-01-04 14:26:131727 // This test only makes sense when we're using streams.
Steve Anton3871f6f2018-01-26 18:25:531728 if (!GetParam()) {
Harald Alvestrand75ceef22018-01-04 14:26:131729 return;
Steve Anton3871f6f2018-01-26 18:25:531730 }
Harald Alvestrand75ceef22018-01-04 14:26:131731
Steve Anton3871f6f2018-01-26 18:25:531732 auto pc = CreatePeerConnection();
1733 auto stats = CreateStatsCollector(pc);
xians@webrtc.org01bda202014-07-09 07:38:381734
1735 // Create a local stream with a local audio track and adds it to the stats.
Steve Antonefe4c922019-03-27 17:26:061736 auto sender = AddOutgoingAudioTrack(pc, stats.get());
Steve Anton3871f6f2018-01-26 18:25:531737 stats->AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
xians@webrtc.org01bda202014-07-09 07:38:381738
Steve Anton3871f6f2018-01-26 18:25:531739 VoiceSenderInfo voice_sender_info;
ivoce1198e02017-09-08 15:13:191740 InitVoiceSenderInfo(&voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531741 UpdateVoiceSenderInfoFromAudioTrack(audio_track_, &voice_sender_info, false);
xians@webrtc.org01bda202014-07-09 07:38:381742 voice_sender_info.add_ssrc(kSsrcOfTrack);
Steve Anton3871f6f2018-01-26 18:25:531743 VoiceMediaInfo voice_info;
1744 voice_info.senders.push_back(voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201745
1746 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1747 voice_media_channel->SetStats(voice_info);
xians@webrtc.org01bda202014-07-09 07:38:381748
xians@webrtc.org01bda202014-07-09 07:38:381749 StatsReports reports; // returned values.
Steve Anton3871f6f2018-01-26 18:25:531750 VerifyAudioTrackStats(audio_track_, stats.get(), voice_info, &reports);
xians@webrtc.org01bda202014-07-09 07:38:381751
1752 // Remove the previous audio track from the stream.
1753 stream_->RemoveTrack(audio_track_.get());
Steve Anton3871f6f2018-01-26 18:25:531754 stats->RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
Steve Antonefe4c922019-03-27 17:26:061755 pc->RemoveSender(sender);
xians@webrtc.org01bda202014-07-09 07:38:381756
1757 // Create a new audio track and adds it to the stream and stats.
1758 static const std::string kNewTrackId = "new_track_id";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:521759 rtc::scoped_refptr<FakeAudioTrack> new_audio_track(
1760 new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));
Steve Antonefe4c922019-03-27 17:26:061761 pc->AddSender(CreateMockSender(new_audio_track, kSsrcOfTrack));
xians@webrtc.org01bda202014-07-09 07:38:381762 stream_->AddTrack(new_audio_track);
1763
Steve Anton3871f6f2018-01-26 18:25:531764 stats->AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);
1765 stats->ClearUpdateStatsCacheForTest();
1766
1767 VoiceSenderInfo new_voice_sender_info;
xians@webrtc.org01bda202014-07-09 07:38:381768 InitVoiceSenderInfo(&new_voice_sender_info);
Steve Anton3871f6f2018-01-26 18:25:531769 UpdateVoiceSenderInfoFromAudioTrack(new_audio_track, &new_voice_sender_info,
1770 false);
1771 VoiceMediaInfo new_voice_info;
1772 new_voice_info.senders.push_back(new_voice_sender_info);
Steve Anton5b387312018-02-03 00:00:201773 voice_media_channel->SetStats(new_voice_info);
Steve Anton3871f6f2018-01-26 18:25:531774
tommi@webrtc.org5b06b062014-08-15 08:38:301775 reports.clear();
Steve Anton3871f6f2018-01-26 18:25:531776 VerifyAudioTrackStats(new_audio_track, stats.get(), new_voice_info, &reports);
xians@webrtc.org01bda202014-07-09 07:38:381777}
1778
Steve Antonefe4c922019-03-27 17:26:061779// Test that if there are two local senders with the same track then two SSRC
1780// reports will be created, one for each sender, with the same track ID and one
1781// track report will be created for the shared track.
1782TEST_P(StatsCollectorTrackTest, TwoLocalSendersWithSameTrack) {
1783 constexpr uint32_t kFirstSsrc = 22;
1784 constexpr uint32_t kSecondSsrc = 33;
1785
1786 auto pc = CreatePeerConnection();
1787 auto stats = CreateStatsCollector(pc);
1788
1789 rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(
1790 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));
1791 pc->AddSender(CreateMockSender(local_track, kFirstSsrc));
1792 stats->AddLocalAudioTrack(local_track.get(), kFirstSsrc);
1793 pc->AddSender(CreateMockSender(local_track, kSecondSsrc));
1794 stats->AddLocalAudioTrack(local_track.get(), kSecondSsrc);
1795
1796 VoiceSenderInfo first_sender_info;
1797 InitVoiceSenderInfo(&first_sender_info, kFirstSsrc);
1798 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &first_sender_info,
1799 false);
1800
1801 VoiceSenderInfo second_sender_info;
1802 InitVoiceSenderInfo(&second_sender_info, kSecondSsrc);
1803 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &second_sender_info,
1804 false);
1805
1806 VoiceMediaInfo voice_info;
1807 voice_info.senders.push_back(first_sender_info);
1808 voice_info.senders.push_back(second_sender_info);
1809
1810 auto* voice_media_channel = pc->AddVoiceChannel("voice", "transport");
1811 voice_media_channel->SetStats(voice_info);
1812
1813 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1814
1815 StatsReports reports;
1816 stats->GetStats(local_track.get(), &reports);
1817 RTC_LOG(LS_INFO) << reports.size();
1818
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;
1857 video_info.senders.push_back(video_sender_info);
Steve Anton5b387312018-02-03 00:00:201858
1859 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1860 video_media_channel->SetStats(video_info);
sakal43536c32016-10-24 08:46:431861
Steve Anton3871f6f2018-01-26 18:25:531862 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1863 StatsReports reports;
1864 stats->GetStats(nullptr, &reports);
1865
sakal43536c32016-10-24 08:46:431866 EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),
1867 ExtractSsrcStatsValue(reports,
1868 StatsReport::kStatsValueNameFramesEncoded));
sakal87da4042016-10-31 13:53:471869 EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),
1870 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
sakal43536c32016-10-24 08:46:431871}
1872
sakale5ba44e2016-10-26 14:09:241873// This test verifies that stats are correctly set in video receive ssrc stats.
Steve Anton3871f6f2018-01-26 18:25:531874TEST_P(StatsCollectorTrackTest, VerifyVideoReceiveSsrcStatsNew) {
1875 auto pc = CreatePeerConnection();
1876 auto stats = CreateStatsCollector(pc);
sakale5ba44e2016-10-26 14:09:241877
Steve Anton3871f6f2018-01-26 18:25:531878 AddIncomingVideoTrack(pc, stats.get());
sakale5ba44e2016-10-26 14:09:241879
Steve Anton3871f6f2018-01-26 18:25:531880 VideoReceiverInfo video_receiver_info;
sakale5ba44e2016-10-26 14:09:241881 video_receiver_info.add_ssrc(1234);
1882 video_receiver_info.frames_decoded = 10;
Artem Titov8a3ab0e2018-07-27 14:52:571883 video_receiver_info.qp_sum = 11;
Steve Anton3871f6f2018-01-26 18:25:531884 VideoMediaInfo video_info;
1885 video_info.receivers.push_back(video_receiver_info);
Steve Anton5b387312018-02-03 00:00:201886
1887 auto* video_media_channel = pc->AddVideoChannel("video", "transport");
1888 video_media_channel->SetStats(video_info);
sakale5ba44e2016-10-26 14:09:241889
Steve Anton3871f6f2018-01-26 18:25:531890 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1891 StatsReports reports;
1892 stats->GetStats(nullptr, &reports);
1893
sakale5ba44e2016-10-26 14:09:241894 EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),
1895 ExtractSsrcStatsValue(reports,
1896 StatsReport::kStatsValueNameFramesDecoded));
sakalcc452e12017-02-09 12:53:451897 EXPECT_EQ(rtc::ToString(*video_receiver_info.qp_sum),
1898 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));
sakale5ba44e2016-10-26 14:09:241899}
1900
Mirko Bonadeic84f6612019-01-31 11:20:571901INSTANTIATE_TEST_SUITE_P(HasStream, StatsCollectorTrackTest, ::testing::Bool());
Harald Alvestrand75ceef22018-01-04 14:26:131902
guoweis@webrtc.org950c5182014-12-16 23:01:311903} // namespace webrtc