blob: 21f9df8e8f32e03cdbcab02d9ac3008b1742a4ba [file] [log] [blame]
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001/*
2 * libjingle
jlmiller@webrtc.org5f93d0a2015-01-20 21:36:13 +00003 * Copyright 2014 Google Inc.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00004 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright notice,
11 * this list of conditions and the following disclaimer in the documentation
12 * and/or other materials provided with the distribution.
13 * 3. The name of the author may not be used to endorse or promote products
14 * derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28#include <stdio.h>
29
deadbeefcbecd352015-09-23 11:50:27 -070030#include <algorithm>
31
henrike@webrtc.org28e20752013-07-10 00:45:36 +000032#include "talk/app/webrtc/statscollector.h"
33
34#include "talk/app/webrtc/mediastream.h"
henrike@webrtc.org40b3b682014-03-03 18:30:11 +000035#include "talk/app/webrtc/mediastreaminterface.h"
decurtis@webrtc.org487a4442015-01-15 22:55:07 +000036#include "talk/app/webrtc/mediastreamsignaling.h"
henrike@webrtc.org40b3b682014-03-03 18:30:11 +000037#include "talk/app/webrtc/mediastreamtrack.h"
decurtis@webrtc.org487a4442015-01-15 22:55:07 +000038#include "talk/app/webrtc/test/fakedatachannelprovider.h"
39#include "talk/app/webrtc/test/fakemediastreamsignaling.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000040#include "talk/app/webrtc/videotrack.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000041#include "talk/media/base/fakemediaengine.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000042#include "talk/session/media/channelmanager.h"
xians@webrtc.org4cb01282014-06-12 14:57:05 +000043#include "testing/gmock/include/gmock/gmock.h"
44#include "testing/gtest/include/gtest/gtest.h"
buildbot@webrtc.orga09a9992014-08-13 17:26:08 +000045#include "webrtc/base/base64.h"
46#include "webrtc/base/fakesslidentity.h"
47#include "webrtc/base/gunit.h"
guoweis@webrtc.org950c5182014-12-16 23:01:31 +000048#include "webrtc/base/network.h"
deadbeefcbecd352015-09-23 11:50:27 -070049#include "webrtc/p2p/base/faketransportcontroller.h"
henrike@webrtc.org28e20752013-07-10 00:45:36 +000050
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +000051using rtc::scoped_ptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000052using testing::_;
53using testing::DoAll;
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +000054using testing::Field;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000055using testing::Return;
56using testing::ReturnNull;
57using testing::SetArgPointee;
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +000058using webrtc::PeerConnectionInterface;
henrike@webrtc.org40b3b682014-03-03 18:30:11 +000059using webrtc::StatsReport;
60using webrtc::StatsReports;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000061
Guo-wei Shieh456696a2015-09-30 21:48:54 -070062namespace {
63// This value comes from openssl/tls1.h
Guo-wei Shieh6caafbe2015-10-05 12:43:27 -070064const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;
Guo-wei Shieh456696a2015-09-30 21:48:54 -070065} // namespace
66
henrike@webrtc.org28e20752013-07-10 00:45:36 +000067namespace cricket {
68
69class ChannelManager;
henrike@webrtc.org28e20752013-07-10 00:45:36 +000070
71} // namespace cricket
72
guoweis@webrtc.org950c5182014-12-16 23:01:31 +000073namespace webrtc {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000074
75// Error return values
76const char kNotFound[] = "NOT FOUND";
henrike@webrtc.org28e20752013-07-10 00:45:36 +000077
wu@webrtc.org97077a32013-10-25 21:18:33 +000078// Constant names for track identification.
xians@webrtc.org4cb01282014-06-12 14:57:05 +000079const char kLocalTrackId[] = "local_track_id";
80const char kRemoteTrackId[] = "remote_track_id";
Peter Boström0c4e06b2015-10-07 12:23:21 +020081const uint32_t kSsrcOfTrack = 1234;
wu@webrtc.org97077a32013-10-25 21:18:33 +000082
henrike@webrtc.org28e20752013-07-10 00:45:36 +000083class MockWebRtcSession : public webrtc::WebRtcSession {
84 public:
85 explicit MockWebRtcSession(cricket::ChannelManager* channel_manager)
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +000086 : WebRtcSession(channel_manager, rtc::Thread::Current(),
87 rtc::Thread::Current(), NULL, NULL) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +000088 }
henrike@webrtc.org40b3b682014-03-03 18:30:11 +000089 MOCK_METHOD0(voice_channel, cricket::VoiceChannel*());
henrike@webrtc.org28e20752013-07-10 00:45:36 +000090 MOCK_METHOD0(video_channel, cricket::VideoChannel*());
decurtis@webrtc.org487a4442015-01-15 22:55:07 +000091 MOCK_CONST_METHOD0(mediastream_signaling, const MediaStreamSignaling*());
xians@webrtc.org4cb01282014-06-12 14:57:05 +000092 // Libjingle uses "local" for a outgoing track, and "remote" for a incoming
93 // track.
Peter Boström0c4e06b2015-10-07 12:23:21 +020094 MOCK_METHOD2(GetLocalTrackIdBySsrc, bool(uint32_t, std::string*));
95 MOCK_METHOD2(GetRemoteTrackIdBySsrc, bool(uint32_t, std::string*));
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +000096 MOCK_METHOD1(GetTransportStats, bool(cricket::SessionStats*));
deadbeefcbecd352015-09-23 11:50:27 -070097 MOCK_METHOD2(GetLocalCertificate,
98 bool(const std::string& transport_name,
99 rtc::scoped_refptr<rtc::RTCCertificate>* certificate));
100 MOCK_METHOD2(GetRemoteSSLCertificate,
101 bool(const std::string& transport_name,
102 rtc::SSLCertificate** cert));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000103};
104
105class MockVideoMediaChannel : public cricket::FakeVideoMediaChannel {
106 public:
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200107 MockVideoMediaChannel() :
108 cricket::FakeVideoMediaChannel(NULL, cricket::VideoOptions()) {}
pbos@webrtc.org058b1f12015-03-04 08:54:32 +0000109 MOCK_METHOD1(GetStats, bool(cricket::VideoMediaInfo*));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000110};
111
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000112class MockVoiceMediaChannel : public cricket::FakeVoiceMediaChannel {
113 public:
Fredrik Solenbergb071a192015-09-17 16:42:56 +0200114 MockVoiceMediaChannel() :
115 cricket::FakeVoiceMediaChannel(NULL, cricket::AudioOptions()) {}
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000116 MOCK_METHOD1(GetStats, bool(cricket::VoiceMediaInfo*));
117};
118
119class FakeAudioProcessor : public webrtc::AudioProcessorInterface {
120 public:
121 FakeAudioProcessor() {}
122 ~FakeAudioProcessor() {}
123
124 private:
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000125 void GetStats(AudioProcessorInterface::AudioProcessorStats* stats) override {
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000126 stats->typing_noise_detected = true;
127 stats->echo_return_loss = 2;
128 stats->echo_return_loss_enhancement = 3;
129 stats->echo_delay_median_ms = 4;
130 stats->aec_quality_min = 5.1f;
131 stats->echo_delay_std_ms = 6;
132 }
133};
134
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000135class FakeAudioTrack
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000136 : public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface> {
137 public:
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000138 explicit FakeAudioTrack(const std::string& id)
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000139 : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000140 processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000141 std::string kind() const override { return "audio"; }
142 webrtc::AudioSourceInterface* GetSource() const override { return NULL; }
143 void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}
144 void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}
145 bool GetSignalLevel(int* level) override {
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000146 *level = 1;
147 return true;
148 }
kjellander@webrtc.org14665ff2015-03-04 12:58:35 +0000149 rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()
150 override {
henrike@webrtc.orgb90991d2014-03-04 19:54:57 +0000151 return processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000152 }
153
154 private:
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000155 rtc::scoped_refptr<FakeAudioProcessor> processor_;
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000156};
157
158bool GetValue(const StatsReport* report,
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000159 StatsReport::StatsValueName name,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000160 std::string* value) {
tommi@webrtc.org92f40182015-03-04 15:25:19 +0000161 const StatsReport::Value* v = report->FindValue(name);
162 if (!v)
163 return false;
164 *value = v->ToString();
165 return true;
wu@webrtc.org4551b792013-10-09 15:37:36 +0000166}
167
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000168std::string ExtractStatsValue(const StatsReport::StatsType& type,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000169 const StatsReports& reports,
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000170 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000171 for (const auto* r : reports) {
wu@webrtc.org4551b792013-10-09 15:37:36 +0000172 std::string ret;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000173 if (r->type() == type && GetValue(r, name, &ret))
wu@webrtc.org4551b792013-10-09 15:37:36 +0000174 return ret;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000175 }
176
177 return kNotFound;
178}
179
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000180StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type,
181 const std::string& value) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000182 EXPECT_FALSE(value.empty());
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000183 StatsReport::Id id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000184 if (value.empty())
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000185 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000186
187 // This has assumptions about how the ID is constructed. As is, this is
188 // OK since this is for testing purposes only, but if we ever need this
189 // in production, we should add a generic method that does this.
190 size_t index = value.find('_');
191 EXPECT_NE(index, std::string::npos);
192 if (index == std::string::npos || index == (value.length() - 1))
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000193 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000194
195 id = StatsReport::NewTypedId(type, value.substr(index + 1));
196 EXPECT_EQ(id->ToString(), value);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000197 return id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000198}
199
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000200StatsReport::Id IdFromCertIdString(const std::string& cert_id) {
201 return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id);
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000202}
203
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000204// Finds the |n|-th report of type |type| in |reports|.
205// |n| starts from 1 for finding the first report.
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000206const StatsReport* FindNthReportByType(
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000207 const StatsReports& reports, const StatsReport::StatsType& type, int n) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000208 for (size_t i = 0; i < reports.size(); ++i) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000209 if (reports[i]->type() == type) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000210 n--;
211 if (n == 0)
tommi@webrtc.org5b06b062014-08-15 08:38:30 +0000212 return reports[i];
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000213 }
214 }
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000215 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000216}
217
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000218const StatsReport* FindReportById(const StatsReports& reports,
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000219 const StatsReport::Id& id) {
tommi@webrtc.org8e327c42015-01-19 20:41:26 +0000220 for (const auto* r : reports) {
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000221 if (r->id()->Equals(id))
tommi@webrtc.org8e327c42015-01-19 20:41:26 +0000222 return r;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000223 }
tommi@webrtc.org8e327c42015-01-19 20:41:26 +0000224 return nullptr;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000225}
226
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000227std::string ExtractSsrcStatsValue(StatsReports reports,
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000228 StatsReport::StatsValueName name) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000229 return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000230}
231
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000232std::string ExtractBweStatsValue(StatsReports reports,
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000233 StatsReport::StatsValueName name) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000234 return ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000235 StatsReport::kStatsReportTypeBwe, reports, name);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000236}
237
wu@webrtc.org4551b792013-10-09 15:37:36 +0000238std::string DerToPem(const std::string& der) {
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000239 return rtc::SSLIdentity::DerToPem(
240 rtc::kPemTypeCertificate,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000241 reinterpret_cast<const unsigned char*>(der.c_str()),
242 der.length());
243}
244
245std::vector<std::string> DersToPems(
246 const std::vector<std::string>& ders) {
247 std::vector<std::string> pems(ders.size());
248 std::transform(ders.begin(), ders.end(), pems.begin(), DerToPem);
249 return pems;
250}
251
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000252void CheckCertChainReports(const StatsReports& reports,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000253 const std::vector<std::string>& ders,
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000254 const StatsReport::Id& start_id) {
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000255 StatsReport::Id cert_id;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000256 const StatsReport::Id* certificate_id = &start_id;
wu@webrtc.org4551b792013-10-09 15:37:36 +0000257 size_t i = 0;
258 while (true) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000259 const StatsReport* report = FindReportById(reports, *certificate_id);
wu@webrtc.org4551b792013-10-09 15:37:36 +0000260 ASSERT_TRUE(report != NULL);
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000261
wu@webrtc.org4551b792013-10-09 15:37:36 +0000262 std::string der_base64;
263 EXPECT_TRUE(GetValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000264 report, StatsReport::kStatsValueNameDer, &der_base64));
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000265 std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);
wu@webrtc.org4551b792013-10-09 15:37:36 +0000266 EXPECT_EQ(ders[i], der);
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000267
268 std::string fingerprint_algorithm;
269 EXPECT_TRUE(GetValue(
270 report,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000271 StatsReport::kStatsValueNameFingerprintAlgorithm,
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000272 &fingerprint_algorithm));
273 // The digest algorithm for a FakeSSLCertificate is always SHA-1.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000274 std::string sha_1_str = rtc::DIGEST_SHA_1;
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000275 EXPECT_EQ(sha_1_str, fingerprint_algorithm);
276
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000277 std::string fingerprint;
278 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint,
279 &fingerprint));
280 EXPECT_FALSE(fingerprint.empty());
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +0000281
wu@webrtc.org4551b792013-10-09 15:37:36 +0000282 ++i;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000283 std::string issuer_id;
284 if (!GetValue(report, StatsReport::kStatsValueNameIssuerId,
285 &issuer_id)) {
wu@webrtc.org4551b792013-10-09 15:37:36 +0000286 break;
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000287 }
288
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000289 cert_id = IdFromCertIdString(issuer_id);
290 certificate_id = &cert_id;
wu@webrtc.org4551b792013-10-09 15:37:36 +0000291 }
292 EXPECT_EQ(ders.size(), i);
293}
294
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000295void VerifyVoiceReceiverInfoReport(
296 const StatsReport* report,
297 const cricket::VoiceReceiverInfo& info) {
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000298 std::string value_in_report;
299 EXPECT_TRUE(GetValue(
300 report, StatsReport::kStatsValueNameAudioOutputLevel, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000301 EXPECT_EQ(rtc::ToString<int>(info.audio_level), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000302 EXPECT_TRUE(GetValue(
303 report, StatsReport::kStatsValueNameBytesReceived, &value_in_report));
Peter Boström0c4e06b2015-10-07 12:23:21 +0200304 EXPECT_EQ(rtc::ToString<int64_t>(info.bytes_rcvd), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000305 EXPECT_TRUE(GetValue(
306 report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000307 EXPECT_EQ(rtc::ToString<int>(info.jitter_ms), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000308 EXPECT_TRUE(GetValue(
309 report, StatsReport::kStatsValueNameJitterBufferMs, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000310 EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_ms), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000311 EXPECT_TRUE(GetValue(
312 report, StatsReport::kStatsValueNamePreferredJitterBufferMs,
313 &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000314 EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_preferred_ms),
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000315 value_in_report);
316 EXPECT_TRUE(GetValue(
317 report, StatsReport::kStatsValueNameCurrentDelayMs, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000318 EXPECT_EQ(rtc::ToString<int>(info.delay_estimate_ms), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000319 EXPECT_TRUE(GetValue(
320 report, StatsReport::kStatsValueNameExpandRate, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000321 EXPECT_EQ(rtc::ToString<float>(info.expand_rate), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000322 EXPECT_TRUE(GetValue(
minyue@webrtc.org652bc372015-02-18 23:50:46 +0000323 report, StatsReport::kStatsValueNameSpeechExpandRate, &value_in_report));
324 EXPECT_EQ(rtc::ToString<float>(info.speech_expand_rate), value_in_report);
Henrik Lundin8e6fd462015-06-02 09:24:52 +0200325 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,
326 &value_in_report));
327 EXPECT_EQ(rtc::ToString<float>(info.accelerate_rate), value_in_report);
328 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate,
329 &value_in_report));
330 EXPECT_EQ(rtc::ToString<float>(info.preemptive_expand_rate), value_in_report);
minyue@webrtc.org652bc372015-02-18 23:50:46 +0000331 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate,
332 &value_in_report));
333 EXPECT_EQ(rtc::ToString<float>(info.secondary_decoded_rate), value_in_report);
334 EXPECT_TRUE(GetValue(
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000335 report, StatsReport::kStatsValueNamePacketsReceived, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000336 EXPECT_EQ(rtc::ToString<int>(info.packets_rcvd), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000337 EXPECT_TRUE(GetValue(
338 report, StatsReport::kStatsValueNameDecodingCTSG, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000339 EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_silence_generator),
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000340 value_in_report);
341 EXPECT_TRUE(GetValue(
342 report, StatsReport::kStatsValueNameDecodingCTN, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000343 EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_neteq),
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000344 value_in_report);
345 EXPECT_TRUE(GetValue(
346 report, StatsReport::kStatsValueNameDecodingNormal, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000347 EXPECT_EQ(rtc::ToString<int>(info.decoding_normal), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000348 EXPECT_TRUE(GetValue(
349 report, StatsReport::kStatsValueNameDecodingPLC, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000350 EXPECT_EQ(rtc::ToString<int>(info.decoding_plc), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000351 EXPECT_TRUE(GetValue(
352 report, StatsReport::kStatsValueNameDecodingCNG, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000353 EXPECT_EQ(rtc::ToString<int>(info.decoding_cng), value_in_report);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000354 EXPECT_TRUE(GetValue(
355 report, StatsReport::kStatsValueNameDecodingPLCCNG, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000356 EXPECT_EQ(rtc::ToString<int>(info.decoding_plc_cng), value_in_report);
buildbot@webrtc.org7e71b772014-06-13 01:14:01 +0000357 EXPECT_TRUE(GetValue(
358 report, StatsReport::kStatsValueNameCodecName, &value_in_report));
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +0000359}
360
361
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000362void VerifyVoiceSenderInfoReport(const StatsReport* report,
363 const cricket::VoiceSenderInfo& sinfo) {
364 std::string value_in_report;
365 EXPECT_TRUE(GetValue(
366 report, StatsReport::kStatsValueNameCodecName, &value_in_report));
367 EXPECT_EQ(sinfo.codec_name, value_in_report);
368 EXPECT_TRUE(GetValue(
369 report, StatsReport::kStatsValueNameBytesSent, &value_in_report));
Peter Boström0c4e06b2015-10-07 12:23:21 +0200370 EXPECT_EQ(rtc::ToString<int64_t>(sinfo.bytes_sent), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000371 EXPECT_TRUE(GetValue(
372 report, StatsReport::kStatsValueNamePacketsSent, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000373 EXPECT_EQ(rtc::ToString<int>(sinfo.packets_sent), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000374 EXPECT_TRUE(GetValue(
henrike@webrtc.orgffe26202014-03-19 22:20:10 +0000375 report, StatsReport::kStatsValueNamePacketsLost, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000376 EXPECT_EQ(rtc::ToString<int>(sinfo.packets_lost), value_in_report);
henrike@webrtc.orgffe26202014-03-19 22:20:10 +0000377 EXPECT_TRUE(GetValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000378 report, StatsReport::kStatsValueNameRtt, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000379 EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000380 EXPECT_TRUE(GetValue(
381 report, StatsReport::kStatsValueNameRtt, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000382 EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000383 EXPECT_TRUE(GetValue(
384 report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000385 EXPECT_EQ(rtc::ToString<int>(sinfo.jitter_ms), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000386 EXPECT_TRUE(GetValue(
387 report, StatsReport::kStatsValueNameEchoCancellationQualityMin,
388 &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000389 EXPECT_EQ(rtc::ToString<float>(sinfo.aec_quality_min), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000390 EXPECT_TRUE(GetValue(
391 report, StatsReport::kStatsValueNameEchoDelayMedian, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000392 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_median_ms),
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000393 value_in_report);
394 EXPECT_TRUE(GetValue(
395 report, StatsReport::kStatsValueNameEchoDelayStdDev, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000396 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_std_ms),
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000397 value_in_report);
398 EXPECT_TRUE(GetValue(
399 report, StatsReport::kStatsValueNameEchoReturnLoss, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000400 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss),
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000401 value_in_report);
402 EXPECT_TRUE(GetValue(
403 report, StatsReport::kStatsValueNameEchoReturnLossEnhancement,
404 &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000405 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss_enhancement),
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000406 value_in_report);
407 EXPECT_TRUE(GetValue(
408 report, StatsReport::kStatsValueNameAudioInputLevel, &value_in_report));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000409 EXPECT_EQ(rtc::ToString<int>(sinfo.audio_level), value_in_report);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000410 EXPECT_TRUE(GetValue(
411 report, StatsReport::kStatsValueNameTypingNoiseState, &value_in_report));
412 std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";
413 EXPECT_EQ(typing_detected, value_in_report);
414}
415
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000416// Helper methods to avoid duplication of code.
417void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info) {
418 voice_sender_info->add_ssrc(kSsrcOfTrack);
419 voice_sender_info->codec_name = "fake_codec";
420 voice_sender_info->bytes_sent = 100;
421 voice_sender_info->packets_sent = 101;
422 voice_sender_info->rtt_ms = 102;
423 voice_sender_info->fraction_lost = 103;
424 voice_sender_info->jitter_ms = 104;
425 voice_sender_info->packets_lost = 105;
426 voice_sender_info->ext_seqnum = 106;
427 voice_sender_info->audio_level = 107;
428 voice_sender_info->echo_return_loss = 108;
429 voice_sender_info->echo_return_loss_enhancement = 109;
430 voice_sender_info->echo_delay_median_ms = 110;
431 voice_sender_info->echo_delay_std_ms = 111;
432 voice_sender_info->aec_quality_min = 112.0f;
433 voice_sender_info->typing_noise_detected = false;
434}
435
436void UpdateVoiceSenderInfoFromAudioTrack(
437 FakeAudioTrack* audio_track, cricket::VoiceSenderInfo* voice_sender_info) {
438 audio_track->GetSignalLevel(&voice_sender_info->audio_level);
439 webrtc::AudioProcessorInterface::AudioProcessorStats audio_processor_stats;
440 audio_track->GetAudioProcessor()->GetStats(&audio_processor_stats);
441 voice_sender_info->typing_noise_detected =
442 audio_processor_stats.typing_noise_detected;
443 voice_sender_info->echo_return_loss = audio_processor_stats.echo_return_loss;
444 voice_sender_info->echo_return_loss_enhancement =
445 audio_processor_stats.echo_return_loss_enhancement;
446 voice_sender_info->echo_delay_median_ms =
447 audio_processor_stats.echo_delay_median_ms;
448 voice_sender_info->aec_quality_min = audio_processor_stats.aec_quality_min;
449 voice_sender_info->echo_delay_std_ms =
450 audio_processor_stats.echo_delay_std_ms;
451}
452
453void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) {
454 voice_receiver_info->add_ssrc(kSsrcOfTrack);
455 voice_receiver_info->bytes_rcvd = 110;
456 voice_receiver_info->packets_rcvd = 111;
457 voice_receiver_info->packets_lost = 112;
458 voice_receiver_info->fraction_lost = 113;
459 voice_receiver_info->packets_lost = 114;
460 voice_receiver_info->ext_seqnum = 115;
461 voice_receiver_info->jitter_ms = 116;
462 voice_receiver_info->jitter_buffer_ms = 117;
463 voice_receiver_info->jitter_buffer_preferred_ms = 118;
464 voice_receiver_info->delay_estimate_ms = 119;
465 voice_receiver_info->audio_level = 120;
466 voice_receiver_info->expand_rate = 121;
minyue@webrtc.org652bc372015-02-18 23:50:46 +0000467 voice_receiver_info->speech_expand_rate = 122;
468 voice_receiver_info->secondary_decoded_rate = 123;
Henrik Lundin8e6fd462015-06-02 09:24:52 +0200469 voice_receiver_info->accelerate_rate = 124;
470 voice_receiver_info->preemptive_expand_rate = 125;
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000471}
472
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000473class StatsCollectorForTest : public webrtc::StatsCollector {
474 public:
475 explicit StatsCollectorForTest(WebRtcSession* session) :
476 StatsCollector(session), time_now_(19477) {
477 }
478
479 double GetTimeNow() override {
480 return time_now_;
481 }
482
483 private:
484 double time_now_;
485};
486
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000487class StatsCollectorTest : public testing::Test {
488 protected:
489 StatsCollectorTest()
tommi@webrtc.org5b06b062014-08-15 08:38:30 +0000490 : media_engine_(new cricket::FakeMediaEngine()),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000491 channel_manager_(
solenbergfacbbec2015-09-24 00:41:50 -0700492 new cricket::ChannelManager(media_engine_, rtc::Thread::Current())),
Henrik Kjellander7c027b62015-04-22 13:21:30 +0200493 session_(channel_manager_.get()),
494 signaling_(channel_manager_.get()) {
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000495 // By default, we ignore session GetStats calls.
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000496 EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000497 EXPECT_CALL(session_, mediastream_signaling()).WillRepeatedly(
498 Return(&signaling_));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000499 }
500
tommi@webrtc.org5b06b062014-08-15 08:38:30 +0000501 ~StatsCollectorTest() {}
502
wu@webrtc.org97077a32013-10-25 21:18:33 +0000503 // This creates a standard setup with a transport called "trspname"
504 // having one transport channel
505 // and the specified virtual connection name.
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000506 void InitSessionStats(const std::string& vc_name) {
wu@webrtc.org97077a32013-10-25 21:18:33 +0000507 const std::string kTransportName("trspname");
508 cricket::TransportStats transport_stats;
509 cricket::TransportChannelStats channel_stats;
510 channel_stats.component = 1;
deadbeefcbecd352015-09-23 11:50:27 -0700511 transport_stats.transport_name = kTransportName;
wu@webrtc.org97077a32013-10-25 21:18:33 +0000512 transport_stats.channel_stats.push_back(channel_stats);
513
514 session_stats_.transport_stats[kTransportName] = transport_stats;
515 session_stats_.proxy_to_transport[vc_name] = kTransportName;
516 }
517
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000518 // Adds a outgoing video track with a given SSRC into the stats.
519 void AddOutgoingVideoTrackStats() {
wu@webrtc.org97077a32013-10-25 21:18:33 +0000520 stream_ = webrtc::MediaStream::Create("streamlabel");
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000521 track_= webrtc::VideoTrack::Create(kLocalTrackId, NULL);
wu@webrtc.org97077a32013-10-25 21:18:33 +0000522 stream_->AddTrack(track_);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000523 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
524 .WillRepeatedly(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));
wu@webrtc.org97077a32013-10-25 21:18:33 +0000525 }
526
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000527 // Adds a incoming video track with a given SSRC into the stats.
528 void AddIncomingVideoTrackStats() {
529 stream_ = webrtc::MediaStream::Create("streamlabel");
530 track_= webrtc::VideoTrack::Create(kRemoteTrackId, NULL);
531 stream_->AddTrack(track_);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000532 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
xians@webrtc.org01bda202014-07-09 07:38:38 +0000533 .WillRepeatedly(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000534 }
535
536 // Adds a outgoing audio track with a given SSRC into the stats.
537 void AddOutgoingAudioTrackStats() {
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000538 if (stream_ == NULL)
539 stream_ = webrtc::MediaStream::Create("streamlabel");
540
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000541 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000542 kLocalTrackId);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000543 stream_->AddTrack(audio_track_);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000544 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
xians@webrtc.org01bda202014-07-09 07:38:38 +0000545 .WillOnce(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000546 }
547
548 // Adds a incoming audio track with a given SSRC into the stats.
549 void AddIncomingAudioTrackStats() {
550 if (stream_ == NULL)
551 stream_ = webrtc::MediaStream::Create("streamlabel");
552
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000553 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000554 kRemoteTrackId);
555 stream_->AddTrack(audio_track_);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000556 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
xians@webrtc.org01bda202014-07-09 07:38:38 +0000557 .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
558 }
559
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000560 StatsReport* AddCandidateReport(StatsCollector* collector,
561 const cricket::Candidate& candidate,
562 bool local) {
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000563 return collector->AddCandidateReport(candidate, local);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +0000564 }
565
xians@webrtc.org01bda202014-07-09 07:38:38 +0000566 void SetupAndVerifyAudioTrackStats(
567 FakeAudioTrack* audio_track,
568 webrtc::MediaStream* stream,
569 webrtc::StatsCollector* stats,
570 cricket::VoiceChannel* voice_channel,
571 const std::string& vc_name,
572 MockVoiceMediaChannel* media_channel,
573 cricket::VoiceSenderInfo* voice_sender_info,
574 cricket::VoiceReceiverInfo* voice_receiver_info,
575 cricket::VoiceMediaInfo* stats_read,
576 StatsReports* reports) {
577 // A track can't have both sender report and recv report at the same time
578 // for now, this might change in the future though.
579 ASSERT((voice_sender_info == NULL) ^ (voice_receiver_info == NULL));
xians@webrtc.org01bda202014-07-09 07:38:38 +0000580
581 // Instruct the session to return stats containing the transport channel.
582 InitSessionStats(vc_name);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000583 EXPECT_CALL(session_, GetTransportStats(_))
xians@webrtc.org01bda202014-07-09 07:38:38 +0000584 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
585 Return(true)));
586
587 // Constructs an ssrc stats update.
588 if (voice_sender_info)
589 stats_read->senders.push_back(*voice_sender_info);
590 if (voice_receiver_info)
591 stats_read->receivers.push_back(*voice_receiver_info);
592
593 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(
594 Return(voice_channel));
595 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
596 EXPECT_CALL(*media_channel, GetStats(_))
597 .WillOnce(DoAll(SetArgPointee<0>(*stats_read), Return(true)));
598
599 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org69bc5a32014-12-15 09:44:48 +0000600 stats->ClearUpdateStatsCacheForTest();
xians@webrtc.org01bda202014-07-09 07:38:38 +0000601 stats->GetStats(NULL, reports);
602
603 // Verify the existence of the track report.
604 const StatsReport* report = FindNthReportByType(
605 *reports, StatsReport::kStatsReportTypeSsrc, 1);
606 EXPECT_FALSE(report == NULL);
jbauchbe24c942015-06-22 15:06:43 -0700607 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());
xians@webrtc.org01bda202014-07-09 07:38:38 +0000608 std::string track_id = ExtractSsrcStatsValue(
609 *reports, StatsReport::kStatsValueNameTrackId);
610 EXPECT_EQ(audio_track->id(), track_id);
611 std::string ssrc_id = ExtractSsrcStatsValue(
612 *reports, StatsReport::kStatsValueNameSsrc);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200613 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
xians@webrtc.org01bda202014-07-09 07:38:38 +0000614
615 // Verifies the values in the track report.
616 if (voice_sender_info) {
617 UpdateVoiceSenderInfoFromAudioTrack(audio_track, voice_sender_info);
618 VerifyVoiceSenderInfoReport(report, *voice_sender_info);
619 }
620 if (voice_receiver_info) {
621 VerifyVoiceReceiverInfoReport(report, *voice_receiver_info);
622 }
623
624 // Verify we get the same result by passing a track to GetStats().
625 StatsReports track_reports; // returned values.
626 stats->GetStats(audio_track, &track_reports);
627 const StatsReport* track_report = FindNthReportByType(
628 track_reports, StatsReport::kStatsReportTypeSsrc, 1);
629 EXPECT_TRUE(track_report);
jbauchbe24c942015-06-22 15:06:43 -0700630 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());
xians@webrtc.org01bda202014-07-09 07:38:38 +0000631 track_id = ExtractSsrcStatsValue(track_reports,
632 StatsReport::kStatsValueNameTrackId);
633 EXPECT_EQ(audio_track->id(), track_id);
634 ssrc_id = ExtractSsrcStatsValue(track_reports,
635 StatsReport::kStatsValueNameSsrc);
Peter Boström0c4e06b2015-10-07 12:23:21 +0200636 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
xians@webrtc.org01bda202014-07-09 07:38:38 +0000637 if (voice_sender_info)
638 VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);
639 if (voice_receiver_info)
640 VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000641 }
642
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000643 void TestCertificateReports(const rtc::FakeSSLCertificate& local_cert,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000644 const std::vector<std::string>& local_ders,
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000645 const rtc::FakeSSLCertificate& remote_cert,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000646 const std::vector<std::string>& remote_ders) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000647 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000648
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000649 StatsReports reports; // returned values.
wu@webrtc.org4551b792013-10-09 15:37:36 +0000650
651 // Fake stats to process.
652 cricket::TransportChannelStats channel_stats;
653 channel_stats.component = 1;
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30 +0000654 channel_stats.srtp_cipher = "the-srtp-cipher";
Guo-wei Shieh456696a2015-09-30 21:48:54 -0700655 channel_stats.ssl_cipher = TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;
wu@webrtc.org4551b792013-10-09 15:37:36 +0000656
657 cricket::TransportStats transport_stats;
deadbeefcbecd352015-09-23 11:50:27 -0700658 transport_stats.transport_name = "audio";
wu@webrtc.org4551b792013-10-09 15:37:36 +0000659 transport_stats.channel_stats.push_back(channel_stats);
660
661 cricket::SessionStats session_stats;
deadbeefcbecd352015-09-23 11:50:27 -0700662 session_stats.transport_stats[transport_stats.transport_name] =
wu@webrtc.org4551b792013-10-09 15:37:36 +0000663 transport_stats;
664
deadbeefcbecd352015-09-23 11:50:27 -0700665 // Fake certificate to report
Henrik Boströmd8281982015-08-27 10:12:24 +0200666 rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(
667 rtc::RTCCertificate::Create(rtc::scoped_ptr<rtc::FakeSSLIdentity>(
deadbeefcbecd352015-09-23 11:50:27 -0700668 new rtc::FakeSSLIdentity(local_cert))
669 .Pass()));
wu@webrtc.org4551b792013-10-09 15:37:36 +0000670
671 // Configure MockWebRtcSession
deadbeefcbecd352015-09-23 11:50:27 -0700672 EXPECT_CALL(session_,
673 GetLocalCertificate(transport_stats.transport_name, _))
674 .WillOnce(DoAll(SetArgPointee<1>(local_certificate), Return(true)));
675 EXPECT_CALL(session_,
676 GetRemoteSSLCertificate(transport_stats.transport_name, _))
677 .WillOnce(
678 DoAll(SetArgPointee<1>(remote_cert.GetReference()), Return(true)));
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000679 EXPECT_CALL(session_, GetTransportStats(_))
wu@webrtc.org4551b792013-10-09 15:37:36 +0000680 .WillOnce(DoAll(SetArgPointee<0>(session_stats),
681 Return(true)));
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000682 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
683 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.org4551b792013-10-09 15:37:36 +0000684
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000685 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
wu@webrtc.org4551b792013-10-09 15:37:36 +0000686
687 stats.GetStats(NULL, &reports);
688
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000689 const StatsReport* channel_report = FindNthReportByType(
690 reports, StatsReport::kStatsReportTypeComponent, 1);
wu@webrtc.org4551b792013-10-09 15:37:36 +0000691 EXPECT_TRUE(channel_report != NULL);
692
693 // Check local certificate chain.
694 std::string local_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000695 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000696 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000697 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000698 if (local_ders.size() > 0) {
699 EXPECT_NE(kNotFound, local_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000700 StatsReport::Id id(IdFromCertIdString(local_certificate_id));
701 CheckCertChainReports(reports, local_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000702 } else {
703 EXPECT_EQ(kNotFound, local_certificate_id);
704 }
wu@webrtc.org4551b792013-10-09 15:37:36 +0000705
706 // Check remote certificate chain.
707 std::string remote_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000708 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +0000709 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000710 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000711 if (remote_ders.size() > 0) {
712 EXPECT_NE(kNotFound, remote_certificate_id);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000713 StatsReport::Id id(IdFromCertIdString(remote_certificate_id));
714 CheckCertChainReports(reports, remote_ders, id);
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000715 } else {
716 EXPECT_EQ(kNotFound, remote_certificate_id);
717 }
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30 +0000718
719 // Check negotiated ciphers.
720 std::string dtls_cipher = ExtractStatsValue(
721 StatsReport::kStatsReportTypeComponent,
722 reports,
723 StatsReport::kStatsValueNameDtlsCipher);
Guo-wei Shieh456696a2015-09-30 21:48:54 -0700724 EXPECT_EQ(rtc::SSLStreamAdapter::GetSslCipherSuiteName(
725 TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),
726 dtls_cipher);
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30 +0000727 std::string srtp_cipher = ExtractStatsValue(
728 StatsReport::kStatsReportTypeComponent,
729 reports,
730 StatsReport::kStatsValueNameSrtpCipher);
731 EXPECT_EQ("the-srtp-cipher", srtp_cipher);
wu@webrtc.org4551b792013-10-09 15:37:36 +0000732 }
wu@webrtc.org97077a32013-10-25 21:18:33 +0000733
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000734 cricket::FakeMediaEngine* media_engine_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000735 rtc::scoped_ptr<cricket::ChannelManager> channel_manager_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000736 MockWebRtcSession session_;
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000737 FakeMediaStreamSignaling signaling_;
738 FakeDataChannelProvider data_channel_provider_;
wu@webrtc.org97077a32013-10-25 21:18:33 +0000739 cricket::SessionStats session_stats_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000740 rtc::scoped_refptr<webrtc::MediaStream> stream_;
741 rtc::scoped_refptr<webrtc::VideoTrack> track_;
742 rtc::scoped_refptr<FakeAudioTrack> audio_track_;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000743};
744
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000745// Verify that ExtractDataInfo populates reports.
746TEST_F(StatsCollectorTest, ExtractDataInfo) {
747 const std::string label = "hacks";
748 const int id = 31337;
749 const std::string state = DataChannelInterface::DataStateString(
750 DataChannelInterface::DataState::kConnecting);
751
752 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
753 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
754
755 InternalDataChannelInit config;
756 config.id = id;
757 signaling_.AddDataChannel(DataChannel::Create(
758 &data_channel_provider_, cricket::DCT_SCTP, label, config));
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000759 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000760
761 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
762
763 StatsReports reports;
764 stats.GetStats(NULL, &reports);
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000765
766 const StatsReport* report =
767 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);
768
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000769 StatsReport::Id reportId = StatsReport::NewTypedIntId(
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000770 StatsReport::kStatsReportTypeDataChannel, id);
771
772 EXPECT_TRUE(reportId->Equals(report->id()));
773
774 EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000775 EXPECT_EQ(label, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
776 reports,
777 StatsReport::kStatsValueNameLabel));
Peter Boström0c4e06b2015-10-07 12:23:21 +0200778 EXPECT_EQ(rtc::ToString<int64_t>(id),
779 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000780 StatsReport::kStatsValueNameDataChannelId));
781 EXPECT_EQ(state, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
782 reports,
783 StatsReport::kStatsValueNameState));
784 EXPECT_EQ("", ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,
785 reports,
786 StatsReport::kStatsValueNameProtocol));
787}
788
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000789// This test verifies that 64-bit counters are passed successfully.
790TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000791 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000792
deadbeefcbecd352015-09-23 11:50:27 -0700793 EXPECT_CALL(session_, GetLocalCertificate(_, _))
794 .WillRepeatedly(Return(false));
795 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
796 .WillRepeatedly(Return(false));
797
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000798 const char kVideoChannelName[] = "video";
799
800 InitSessionStats(kVideoChannelName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000801 EXPECT_CALL(session_, GetTransportStats(_))
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000802 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
803 Return(true)));
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000804
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000805 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000806 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +0200807 media_channel, NULL, kVideoChannelName, false);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000808 StatsReports reports; // returned values.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000809 cricket::VideoSenderInfo video_sender_info;
810 cricket::VideoMediaInfo stats_read;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000811 // The number of bytes must be larger than 0xFFFFFFFF for this test.
Peter Boström0c4e06b2015-10-07 12:23:21 +0200812 const int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000813 const std::string kBytesSentString("12345678901234");
814
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000815 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +0000816 stats.AddStream(stream_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000817
818 // Construct a stats value to read.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +0000819 video_sender_info.add_ssrc(1234);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000820 video_sender_info.bytes_sent = kBytesSent;
821 stats_read.senders.push_back(video_sender_info);
822
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000823 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
824 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +0000825 EXPECT_CALL(*media_channel, GetStats(_))
826 .WillOnce(DoAll(SetArgPointee<0>(stats_read),
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000827 Return(true)));
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000828 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000829 stats.GetStats(NULL, &reports);
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000830 std::string result = ExtractSsrcStatsValue(reports,
831 StatsReport::kStatsValueNameBytesSent);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000832 EXPECT_EQ(kBytesSentString, result);
833}
834
835// Test that BWE information is reported via stats.
836TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000837 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000838
deadbeefcbecd352015-09-23 11:50:27 -0700839 EXPECT_CALL(session_, GetLocalCertificate(_, _))
840 .WillRepeatedly(Return(false));
841 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
842 .WillRepeatedly(Return(false));
843
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000844 const char kVideoChannelName[] = "video";
845
846 InitSessionStats(kVideoChannelName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000847 EXPECT_CALL(session_, GetTransportStats(_))
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000848 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
849 Return(true)));
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000850
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000851 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000852 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +0200853 media_channel, NULL, kVideoChannelName, false);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000854
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000855 StatsReports reports; // returned values.
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000856 cricket::VideoSenderInfo video_sender_info;
857 cricket::VideoMediaInfo stats_read;
858 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and
859 // BWE.
Peter Boström0c4e06b2015-10-07 12:23:21 +0200860 const int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000861 const std::string kBytesSentString("12345678901234");
862
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000863 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +0000864 stats.AddStream(stream_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000865
866 // Construct a stats value to read.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +0000867 video_sender_info.add_ssrc(1234);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000868 video_sender_info.bytes_sent = kBytesSent;
869 stats_read.senders.push_back(video_sender_info);
870 cricket::BandwidthEstimationInfo bwe;
871 const int kTargetEncBitrate = 123456;
872 const std::string kTargetEncBitrateString("123456");
873 bwe.target_enc_bitrate = kTargetEncBitrate;
874 stats_read.bw_estimations.push_back(bwe);
875
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000876 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
877 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +0000878 EXPECT_CALL(*media_channel, GetStats(_))
879 .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));
wu@webrtc.org97077a32013-10-25 21:18:33 +0000880
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000881 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000882 stats.GetStats(NULL, &reports);
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000883 std::string result = ExtractSsrcStatsValue(reports,
884 StatsReport::kStatsValueNameBytesSent);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000885 EXPECT_EQ(kBytesSentString, result);
tommi@webrtc.org242068d2014-07-14 20:19:56 +0000886 result = ExtractBweStatsValue(reports,
887 StatsReport::kStatsValueNameTargetEncBitrate);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000888 EXPECT_EQ(kTargetEncBitrateString, result);
889}
890
891// This test verifies that an object of type "googSession" always
892// exists in the returned stats.
893TEST_F(StatsCollectorTest, SessionObjectExists) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000894 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000895
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000896 StatsReports reports; // returned values.
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000897 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
898 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000899 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000900 stats.GetStats(NULL, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000901 const StatsReport* session_report = FindNthReportByType(
902 reports, StatsReport::kStatsReportTypeSession, 1);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000903 EXPECT_FALSE(session_report == NULL);
904}
905
906// This test verifies that only one object of type "googSession" exists
907// in the returned stats.
908TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000909 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000910
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000911 StatsReports reports; // returned values.
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000912 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
913 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000914 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
915 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000916 stats.GetStats(NULL, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000917 const StatsReport* session_report = FindNthReportByType(
918 reports, StatsReport::kStatsReportTypeSession, 1);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000919 EXPECT_FALSE(session_report == NULL);
920 session_report = FindNthReportByType(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000921 reports, StatsReport::kStatsReportTypeSession, 2);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000922 EXPECT_EQ(NULL, session_report);
923}
924
925// This test verifies that the empty track report exists in the returned stats
926// without calling StatsCollector::UpdateStats.
927TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000928 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000929
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000930 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000931 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +0200932 media_channel, NULL, "video", false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000933 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +0000934 stats.AddStream(stream_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000935
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000936 // Verfies the existence of the track report.
tommi@webrtc.org03505bc2014-07-14 20:15:26 +0000937 StatsReports reports;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000938 stats.GetStats(NULL, &reports);
939 EXPECT_EQ((size_t)1, reports.size());
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +0000940 EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());
jbauchbe24c942015-06-22 15:06:43 -0700941 EXPECT_EQ(0, reports[0]->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000942
943 std::string trackValue =
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000944 ExtractStatsValue(StatsReport::kStatsReportTypeTrack,
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000945 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000946 StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000947 EXPECT_EQ(kLocalTrackId, trackValue);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000948}
949
950// This test verifies that the empty track report exists in the returned stats
951// when StatsCollector::UpdateStats is called with ssrc stats.
952TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +0000953 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +0000954
deadbeefcbecd352015-09-23 11:50:27 -0700955 EXPECT_CALL(session_, GetLocalCertificate(_, _))
956 .WillRepeatedly(Return(false));
957 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
958 .WillRepeatedly(Return(false));
959
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000960 const char kVideoChannelName[] = "video";
961 InitSessionStats(kVideoChannelName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +0000962 EXPECT_CALL(session_, GetTransportStats(_))
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000963 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
964 Return(true)));
tommi@webrtc.orgd3900292015-03-12 16:35:55 +0000965
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000966 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +0000967 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +0200968 media_channel, NULL, kVideoChannelName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000969 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +0000970 stats.AddStream(stream_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000971
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000972 // Constructs an ssrc stats update.
973 cricket::VideoSenderInfo video_sender_info;
974 cricket::VideoMediaInfo stats_read;
Peter Boström0c4e06b2015-10-07 12:23:21 +0200975 const int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000976
977 // Construct a stats value to read.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +0000978 video_sender_info.add_ssrc(1234);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000979 video_sender_info.bytes_sent = kBytesSent;
980 stats_read.senders.push_back(video_sender_info);
981
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000982 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
983 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +0000984 EXPECT_CALL(*media_channel, GetStats(_))
985 .WillOnce(DoAll(SetArgPointee<0>(stats_read),
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000986 Return(true)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000987
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +0000988 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:26 +0000989 StatsReports reports;
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000990 stats.GetStats(NULL, &reports);
wu@webrtc.org97077a32013-10-25 21:18:33 +0000991 // |reports| should contain at least one session report, one track report,
992 // and one ssrc report.
993 EXPECT_LE((size_t)3, reports.size());
henrike@webrtc.org40b3b682014-03-03 18:30:11 +0000994 const StatsReport* track_report = FindNthReportByType(
995 reports, StatsReport::kStatsReportTypeTrack, 1);
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000996 EXPECT_TRUE(track_report);
henrike@webrtc.org28e20752013-07-10 00:45:36 +0000997
xians@webrtc.org4cb01282014-06-12 14:57:05 +0000998 // Get report for the specific |track|.
tommi@webrtc.org5b06b062014-08-15 08:38:30 +0000999 reports.clear();
wu@webrtc.org97077a32013-10-25 21:18:33 +00001000 stats.GetStats(track_, &reports);
1001 // |reports| should contain at least one session report, one track report,
1002 // and one ssrc report.
1003 EXPECT_LE((size_t)3, reports.size());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001004 track_report = FindNthReportByType(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001005 reports, StatsReport::kStatsReportTypeTrack, 1);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001006 EXPECT_TRUE(track_report);
jbauchbe24c942015-06-22 15:06:43 -07001007 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001008
1009 std::string ssrc_id = ExtractSsrcStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001010 reports, StatsReport::kStatsValueNameSsrc);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001011 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001012
1013 std::string track_id = ExtractSsrcStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001014 reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001015 EXPECT_EQ(kLocalTrackId, track_id);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001016}
1017
1018// This test verifies that an SSRC object has the identifier of a Transport
1019// stats object, and that this transport stats object exists in stats.
1020TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001021 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001022
deadbeefcbecd352015-09-23 11:50:27 -07001023 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1024 .WillRepeatedly(Return(false));
1025 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1026 .WillRepeatedly(Return(false));
1027
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001028 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001029 // The transport_name known by the video channel.
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001030 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001031 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001032 media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001033 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +00001034 stats.AddStream(stream_);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001035
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001036 // Constructs an ssrc stats update.
1037 cricket::VideoSenderInfo video_sender_info;
1038 cricket::VideoMediaInfo stats_read;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001039 const int64_t kBytesSent = 12345678901234LL;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001040
1041 // Construct a stats value to read.
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +00001042 video_sender_info.add_ssrc(1234);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001043 video_sender_info.bytes_sent = kBytesSent;
1044 stats_read.senders.push_back(video_sender_info);
1045
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001046 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
1047 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001048 EXPECT_CALL(*media_channel, GetStats(_))
1049 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001050 Return(true)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001051
wu@webrtc.org97077a32013-10-25 21:18:33 +00001052 InitSessionStats(kVcName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001053 EXPECT_CALL(session_, GetTransportStats(_))
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001054 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
1055 Return(true)));
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001056
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001057 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:26 +00001058 StatsReports reports;
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001059 stats.GetStats(NULL, &reports);
1060 std::string transport_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001061 StatsReport::kStatsReportTypeSsrc,
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001062 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001063 StatsReport::kStatsValueNameTransportId);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001064 ASSERT_NE(kNotFound, transport_id);
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +00001065 // Transport id component ID will always be 1.
1066 // This has assumptions about how the ID is constructed. As is, this is
1067 // OK since this is for testing purposes only, but if we ever need this
1068 // in production, we should add a generic method that does this.
1069 size_t index = transport_id.find('-');
1070 ASSERT_NE(std::string::npos, index);
1071 std::string content = transport_id.substr(index + 1);
1072 index = content.rfind('-');
1073 ASSERT_NE(std::string::npos, index);
1074 content = content.substr(0, index);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001075 StatsReport::Id id(StatsReport::NewComponentId(content, 1));
tommi@webrtc.org4fb7e252015-01-21 11:36:18 +00001076 ASSERT_EQ(transport_id, id->ToString());
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001077 const StatsReport* transport_report = FindReportById(reports, id);
henrike@webrtc.org28e20752013-07-10 00:45:36 +00001078 ASSERT_FALSE(transport_report == NULL);
1079}
1080
wu@webrtc.org97077a32013-10-25 21:18:33 +00001081// This test verifies that a remote stats object will not be created for
1082// an outgoing SSRC where remote stats are not returned.
1083TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001084 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001085
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001086 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001087 // The transport_name known by the video channel.
wu@webrtc.org97077a32013-10-25 21:18:33 +00001088 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001089 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001090 media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001091 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +00001092 stats.AddStream(stream_);
1093
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001094 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
1095 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.org97077a32013-10-25 21:18:33 +00001096
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001097 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001098 StatsReports reports;
wu@webrtc.org97077a32013-10-25 21:18:33 +00001099 stats.GetStats(NULL, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001100 const StatsReport* remote_report = FindNthReportByType(reports,
1101 StatsReport::kStatsReportTypeRemoteSsrc, 1);
wu@webrtc.org97077a32013-10-25 21:18:33 +00001102 EXPECT_TRUE(remote_report == NULL);
1103}
1104
1105// This test verifies that a remote stats object will be created for
1106// an outgoing SSRC where stats are returned.
1107TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001108 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001109
deadbeefcbecd352015-09-23 11:50:27 -07001110 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1111 .WillRepeatedly(Return(false));
1112 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1113 .WillRepeatedly(Return(false));
1114
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001115 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001116 // The transport_name known by the video channel.
wu@webrtc.org97077a32013-10-25 21:18:33 +00001117 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001118 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001119 media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001120 AddOutgoingVideoTrackStats();
wu@webrtc.org97077a32013-10-25 21:18:33 +00001121 stats.AddStream(stream_);
1122
wu@webrtc.org97077a32013-10-25 21:18:33 +00001123 // Instruct the session to return stats containing the transport channel.
1124 InitSessionStats(kVcName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001125 EXPECT_CALL(session_, GetTransportStats(_))
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001126 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
1127 Return(true)));
wu@webrtc.org97077a32013-10-25 21:18:33 +00001128
1129 // Constructs an ssrc stats update.
1130 cricket::VideoMediaInfo stats_read;
1131
1132 cricket::SsrcReceiverInfo remote_ssrc_stats;
1133 remote_ssrc_stats.timestamp = 12345.678;
1134 remote_ssrc_stats.ssrc = kSsrcOfTrack;
1135 cricket::VideoSenderInfo video_sender_info;
sergeyu@chromium.org5bc25c42013-12-05 00:24:06 +00001136 video_sender_info.add_ssrc(kSsrcOfTrack);
wu@webrtc.org97077a32013-10-25 21:18:33 +00001137 video_sender_info.remote_stats.push_back(remote_ssrc_stats);
1138 stats_read.senders.push_back(video_sender_info);
1139
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001140 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
1141 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001142 EXPECT_CALL(*media_channel, GetStats(_))
1143 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
wu@webrtc.org97077a32013-10-25 21:18:33 +00001144 Return(true)));
1145
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001146 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:26 +00001147 StatsReports reports;
wu@webrtc.org97077a32013-10-25 21:18:33 +00001148 stats.GetStats(NULL, &reports);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001149
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001150 const StatsReport* remote_report = FindNthReportByType(reports,
1151 StatsReport::kStatsReportTypeRemoteSsrc, 1);
wu@webrtc.org97077a32013-10-25 21:18:33 +00001152 EXPECT_FALSE(remote_report == NULL);
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001153 EXPECT_EQ(12345.678, remote_report->timestamp());
wu@webrtc.org97077a32013-10-25 21:18:33 +00001154}
1155
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001156// This test verifies that the empty track report exists in the returned stats
1157// when StatsCollector::UpdateStats is called with ssrc stats.
1158TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001159 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001160
deadbeefcbecd352015-09-23 11:50:27 -07001161 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1162 .WillRepeatedly(Return(false));
1163 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1164 .WillRepeatedly(Return(false));
1165
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001166 const char kVideoChannelName[] = "video";
1167 InitSessionStats(kVideoChannelName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001168 EXPECT_CALL(session_, GetTransportStats(_))
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001169 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
1170 Return(true)));
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001171
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001172 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001173 cricket::VideoChannel video_channel(rtc::Thread::Current(),
Fredrik Solenberg0c022642015-08-05 12:25:22 +02001174 media_channel, NULL, kVideoChannelName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001175 AddIncomingVideoTrackStats();
1176 stats.AddStream(stream_);
1177
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001178 // Constructs an ssrc stats update.
1179 cricket::VideoReceiverInfo video_receiver_info;
1180 cricket::VideoMediaInfo stats_read;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001181 const int64_t kNumOfPacketsConcealed = 54321;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001182
1183 // Construct a stats value to read.
1184 video_receiver_info.add_ssrc(1234);
pbos@webrtc.org1ed62242015-02-19 13:57:03 +00001185 video_receiver_info.packets_concealed = kNumOfPacketsConcealed;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001186 stats_read.receivers.push_back(video_receiver_info);
1187
1188 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));
1189 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
pbos@webrtc.org058b1f12015-03-04 08:54:32 +00001190 EXPECT_CALL(*media_channel, GetStats(_))
1191 .WillOnce(DoAll(SetArgPointee<0>(stats_read),
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001192 Return(true)));
1193
1194 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
tommi@webrtc.org03505bc2014-07-14 20:15:26 +00001195 StatsReports reports;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001196 stats.GetStats(NULL, &reports);
1197 // |reports| should contain at least one session report, one track report,
1198 // and one ssrc report.
1199 EXPECT_LE(static_cast<size_t>(3), reports.size());
1200 const StatsReport* track_report = FindNthReportByType(
1201 reports, StatsReport::kStatsReportTypeTrack, 1);
1202 EXPECT_TRUE(track_report);
jbauchbe24c942015-06-22 15:06:43 -07001203 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001204
1205 std::string ssrc_id = ExtractSsrcStatsValue(
1206 reports, StatsReport::kStatsValueNameSsrc);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001207 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001208
1209 std::string track_id = ExtractSsrcStatsValue(
1210 reports, StatsReport::kStatsValueNameTrackId);
1211 EXPECT_EQ(kRemoteTrackId, track_id);
1212}
1213
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001214// This test verifies the Ice Candidate report should contain the correct
1215// information from local/remote candidates.
1216TEST_F(StatsCollectorTest, IceCandidateReport) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001217 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001218
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001219 StatsReports reports; // returned values.
1220
1221 const int local_port = 2000;
1222 const char local_ip[] = "192.168.0.1";
1223 const int remote_port = 2001;
1224 const char remote_ip[] = "192.168.0.2";
1225
1226 rtc::SocketAddress local_address(local_ip, local_port);
1227 rtc::SocketAddress remote_address(remote_ip, remote_port);
1228 rtc::AdapterType network_type = rtc::ADAPTER_TYPE_ETHERNET;
Peter Boström0c4e06b2015-10-07 12:23:21 +02001229 uint32_t priority = 1000;
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001230
1231 cricket::Candidate c;
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001232 ASSERT(c.id().length() > 0);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001233 c.set_type(cricket::LOCAL_PORT_TYPE);
1234 c.set_protocol(cricket::UDP_PROTOCOL_NAME);
1235 c.set_address(local_address);
1236 c.set_priority(priority);
1237 c.set_network_type(network_type);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001238 std::string report_id = AddCandidateReport(&stats, c, true)->id()->ToString();
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001239 EXPECT_EQ("Cand-" + c.id(), report_id);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001240
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001241 c = cricket::Candidate();
1242 ASSERT(c.id().length() > 0);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001243 c.set_type(cricket::PRFLX_PORT_TYPE);
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001244 c.set_protocol(cricket::UDP_PROTOCOL_NAME);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001245 c.set_address(remote_address);
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001246 c.set_priority(priority);
1247 c.set_network_type(network_type);
tommi@webrtc.orgd3900292015-03-12 16:35:55 +00001248 report_id = AddCandidateReport(&stats, c, false)->id()->ToString();
guoweis@webrtc.org61c12472015-01-15 06:53:07 +00001249 EXPECT_EQ("Cand-" + c.id(), report_id);
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001250
1251 stats.GetStats(NULL, &reports);
1252
1253 // Verify the local candidate report is populated correctly.
1254 EXPECT_EQ(
1255 local_ip,
1256 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1257 StatsReport::kStatsValueNameCandidateIPAddress));
1258 EXPECT_EQ(
1259 rtc::ToString<int>(local_port),
1260 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1261 StatsReport::kStatsValueNameCandidatePortNumber));
1262 EXPECT_EQ(
1263 cricket::UDP_PROTOCOL_NAME,
1264 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1265 StatsReport::kStatsValueNameCandidateTransportType));
1266 EXPECT_EQ(
1267 rtc::ToString<int>(priority),
1268 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1269 StatsReport::kStatsValueNameCandidatePriority));
1270 EXPECT_EQ(
1271 IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),
1272 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1273 StatsReport::kStatsValueNameCandidateType));
1274 EXPECT_EQ(
1275 AdapterTypeToStatsType(network_type),
1276 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,
1277 StatsReport::kStatsValueNameCandidateNetworkType));
1278
1279 // Verify the remote candidate report is populated correctly.
1280 EXPECT_EQ(remote_ip,
1281 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1282 reports,
1283 StatsReport::kStatsValueNameCandidateIPAddress));
1284 EXPECT_EQ(rtc::ToString<int>(remote_port),
1285 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1286 reports,
1287 StatsReport::kStatsValueNameCandidatePortNumber));
1288 EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,
1289 ExtractStatsValue(
1290 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1291 StatsReport::kStatsValueNameCandidateTransportType));
1292 EXPECT_EQ(rtc::ToString<int>(priority),
1293 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1294 reports,
1295 StatsReport::kStatsValueNameCandidatePriority));
1296 EXPECT_EQ(
1297 IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),
1298 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,
1299 reports, StatsReport::kStatsValueNameCandidateType));
1300 EXPECT_EQ(kNotFound,
1301 ExtractStatsValue(
1302 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,
1303 StatsReport::kStatsValueNameCandidateNetworkType));
1304}
1305
wu@webrtc.org4551b792013-10-09 15:37:36 +00001306// This test verifies that all chained certificates are correctly
1307// reported
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001308TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:36 +00001309 // Build local certificate chain.
1310 std::vector<std::string> local_ders(5);
1311 local_ders[0] = "These";
1312 local_ders[1] = "are";
1313 local_ders[2] = "some";
1314 local_ders[3] = "der";
1315 local_ders[4] = "values";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001316 rtc::FakeSSLCertificate local_cert(DersToPems(local_ders));
wu@webrtc.org4551b792013-10-09 15:37:36 +00001317
1318 // Build remote certificate chain
1319 std::vector<std::string> remote_ders(4);
1320 remote_ders[0] = "A";
1321 remote_ders[1] = "non-";
1322 remote_ders[2] = "intersecting";
1323 remote_ders[3] = "set";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001324 rtc::FakeSSLCertificate remote_cert(DersToPems(remote_ders));
wu@webrtc.org4551b792013-10-09 15:37:36 +00001325
1326 TestCertificateReports(local_cert, local_ders, remote_cert, remote_ders);
1327}
1328
1329// This test verifies that all certificates without chains are correctly
1330// reported.
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001331TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {
wu@webrtc.org4551b792013-10-09 15:37:36 +00001332 // Build local certificate.
1333 std::string local_der = "This is the local der.";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001334 rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
wu@webrtc.org4551b792013-10-09 15:37:36 +00001335
1336 // Build remote certificate.
1337 std::string remote_der = "This is somebody else's der.";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001338 rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
wu@webrtc.org4551b792013-10-09 15:37:36 +00001339
1340 TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
1341 remote_cert, std::vector<std::string>(1, remote_der));
1342}
1343
1344// This test verifies that the stats are generated correctly when no
1345// transport is present.
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001346TEST_F(StatsCollectorTest, NoTransport) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001347 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001348
deadbeefcbecd352015-09-23 11:50:27 -07001349 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1350 .WillRepeatedly(Return(false));
1351 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1352 .WillRepeatedly(Return(false));
1353
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001354 StatsReports reports; // returned values.
wu@webrtc.org4551b792013-10-09 15:37:36 +00001355
1356 // Fake stats to process.
1357 cricket::TransportChannelStats channel_stats;
1358 channel_stats.component = 1;
1359
1360 cricket::TransportStats transport_stats;
deadbeefcbecd352015-09-23 11:50:27 -07001361 transport_stats.transport_name = "audio";
wu@webrtc.org4551b792013-10-09 15:37:36 +00001362 transport_stats.channel_stats.push_back(channel_stats);
1363
1364 cricket::SessionStats session_stats;
deadbeefcbecd352015-09-23 11:50:27 -07001365 session_stats.transport_stats[transport_stats.transport_name] =
wu@webrtc.org4551b792013-10-09 15:37:36 +00001366 transport_stats;
1367
1368 // Configure MockWebRtcSession
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001369 EXPECT_CALL(session_, GetTransportStats(_))
wu@webrtc.org4551b792013-10-09 15:37:36 +00001370 .WillOnce(DoAll(SetArgPointee<0>(session_stats),
1371 Return(true)));
wu@webrtc.org97077a32013-10-25 21:18:33 +00001372
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001373 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
1374 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.org4551b792013-10-09 15:37:36 +00001375
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001376 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001377 stats.GetStats(NULL, &reports);
1378
1379 // Check that the local certificate is absent.
1380 std::string local_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001381 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +00001382 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001383 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001384 ASSERT_EQ(kNotFound, local_certificate_id);
1385
1386 // Check that the remote certificate is absent.
1387 std::string remote_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001388 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +00001389 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001390 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001391 ASSERT_EQ(kNotFound, remote_certificate_id);
pthatcher@webrtc.org7bea1ff2015-03-04 01:38:30 +00001392
1393 // Check that the negotiated ciphers are absent.
1394 std::string dtls_cipher = ExtractStatsValue(
1395 StatsReport::kStatsReportTypeComponent,
1396 reports,
1397 StatsReport::kStatsValueNameDtlsCipher);
1398 ASSERT_EQ(kNotFound, dtls_cipher);
1399 std::string srtp_cipher = ExtractStatsValue(
1400 StatsReport::kStatsReportTypeComponent,
1401 reports,
1402 StatsReport::kStatsValueNameSrtpCipher);
1403 ASSERT_EQ(kNotFound, srtp_cipher);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001404}
1405
1406// This test verifies that the stats are generated correctly when the transport
1407// does not have any certificates.
mallinath@webrtc.org19f27e62013-10-13 17:18:27 +00001408TEST_F(StatsCollectorTest, NoCertificates) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001409 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001410
deadbeefcbecd352015-09-23 11:50:27 -07001411 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1412 .WillRepeatedly(Return(false));
1413 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1414 .WillRepeatedly(Return(false));
1415
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001416 StatsReports reports; // returned values.
wu@webrtc.org4551b792013-10-09 15:37:36 +00001417
1418 // Fake stats to process.
1419 cricket::TransportChannelStats channel_stats;
1420 channel_stats.component = 1;
1421
1422 cricket::TransportStats transport_stats;
deadbeefcbecd352015-09-23 11:50:27 -07001423 transport_stats.transport_name = "audio";
wu@webrtc.org4551b792013-10-09 15:37:36 +00001424 transport_stats.channel_stats.push_back(channel_stats);
1425
1426 cricket::SessionStats session_stats;
deadbeefcbecd352015-09-23 11:50:27 -07001427 session_stats.transport_stats[transport_stats.transport_name] =
wu@webrtc.org4551b792013-10-09 15:37:36 +00001428 transport_stats;
1429
1430 // Fake transport object.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001431 rtc::scoped_ptr<cricket::FakeTransport> transport(
deadbeefcbecd352015-09-23 11:50:27 -07001432 new cricket::FakeTransport(transport_stats.transport_name));
wu@webrtc.org4551b792013-10-09 15:37:36 +00001433
1434 // Configure MockWebRtcSession
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001435 EXPECT_CALL(session_, GetTransportStats(_))
wu@webrtc.org4551b792013-10-09 15:37:36 +00001436 .WillOnce(DoAll(SetArgPointee<0>(session_stats),
1437 Return(true)));
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001438 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
1439 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());
wu@webrtc.org4551b792013-10-09 15:37:36 +00001440
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001441 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001442 stats.GetStats(NULL, &reports);
1443
1444 // Check that the local certificate is absent.
1445 std::string local_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001446 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +00001447 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001448 StatsReport::kStatsValueNameLocalCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001449 ASSERT_EQ(kNotFound, local_certificate_id);
1450
1451 // Check that the remote certificate is absent.
1452 std::string remote_certificate_id = ExtractStatsValue(
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001453 StatsReport::kStatsReportTypeComponent,
wu@webrtc.org4551b792013-10-09 15:37:36 +00001454 reports,
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001455 StatsReport::kStatsValueNameRemoteCertificateId);
wu@webrtc.org4551b792013-10-09 15:37:36 +00001456 ASSERT_EQ(kNotFound, remote_certificate_id);
1457}
1458
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001459// This test verifies that a remote certificate with an unsupported digest
1460// algorithm is correctly ignored.
1461TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {
1462 // Build a local certificate.
1463 std::string local_der = "This is the local der.";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001464 rtc::FakeSSLCertificate local_cert(DerToPem(local_der));
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001465
1466 // Build a remote certificate with an unsupported digest algorithm.
1467 std::string remote_der = "This is somebody else's der.";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001468 rtc::FakeSSLCertificate remote_cert(DerToPem(remote_der));
wu@webrtc.orgb9a088b2014-02-13 23:18:49 +00001469 remote_cert.set_digest_algorithm("foobar");
1470
1471 TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),
1472 remote_cert, std::vector<std::string>());
1473}
1474
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001475// This test verifies that a local stats object can get statistics via
1476// AudioTrackInterface::GetStats() method.
1477TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001478 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001479
deadbeefcbecd352015-09-23 11:50:27 -07001480 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1481 .WillRepeatedly(Return(false));
1482 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1483 .WillRepeatedly(Return(false));
tommi@webrtc.org242068d2014-07-14 20:19:56 +00001484
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001485 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001486 // The transport_name known by the voice channel.
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001487 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001488 cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
pthatcher@webrtc.orgb01c7072015-03-13 20:05:17 +00001489 media_engine_, media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001490 AddOutgoingAudioTrackStats();
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001491 stats.AddStream(stream_);
xians@webrtc.org01bda202014-07-09 07:38:38 +00001492 stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001493
1494 cricket::VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001495 InitVoiceSenderInfo(&voice_sender_info);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001496
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001497 cricket::VoiceMediaInfo stats_read;
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001498 StatsReports reports; // returned values.
xians@webrtc.org01bda202014-07-09 07:38:38 +00001499 SetupAndVerifyAudioTrackStats(
1500 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
1501 media_channel, &voice_sender_info, NULL, &stats_read, &reports);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001502
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001503 // Verify that there is no remote report for the local audio track because
1504 // we did not set it up.
1505 const StatsReport* remote_report = FindNthReportByType(reports,
1506 StatsReport::kStatsReportTypeRemoteSsrc, 1);
1507 EXPECT_TRUE(remote_report == NULL);
1508}
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001509
1510// This test verifies that audio receive streams populate stats reports
1511// correctly.
1512TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001513 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001514
deadbeefcbecd352015-09-23 11:50:27 -07001515 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1516 .WillRepeatedly(Return(false));
1517 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1518 .WillRepeatedly(Return(false));
1519
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001520 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001521 // The transport_name known by the voice channel.
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001522 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001523 cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
pthatcher@webrtc.orgb01c7072015-03-13 20:05:17 +00001524 media_engine_, media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001525 AddIncomingAudioTrackStats();
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001526 stats.AddStream(stream_);
1527
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001528 cricket::VoiceReceiverInfo voice_receiver_info;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001529 InitVoiceReceiverInfo(&voice_receiver_info);
buildbot@webrtc.org7e71b772014-06-13 01:14:01 +00001530 voice_receiver_info.codec_name = "fake_codec";
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001531
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001532 cricket::VoiceMediaInfo stats_read;
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001533 StatsReports reports; // returned values.
xians@webrtc.org01bda202014-07-09 07:38:38 +00001534 SetupAndVerifyAudioTrackStats(
1535 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
1536 media_channel, NULL, &voice_receiver_info, &stats_read, &reports);
buildbot@webrtc.org3e01e0b2014-05-13 17:54:10 +00001537}
1538
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001539// This test verifies that a local stats object won't update its statistics
1540// after a RemoveLocalAudioTrack() call.
1541TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001542 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001543
deadbeefcbecd352015-09-23 11:50:27 -07001544 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1545 .WillRepeatedly(Return(false));
1546 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1547 .WillRepeatedly(Return(false));
1548
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001549 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001550 // The transport_name known by the voice channel.
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001551 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001552 cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
pthatcher@webrtc.orgb01c7072015-03-13 20:05:17 +00001553 media_engine_, media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001554 AddOutgoingAudioTrackStats();
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001555 stats.AddStream(stream_);
1556 stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1557
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001558 // Instruct the session to return stats containing the transport channel.
1559 InitSessionStats(kVcName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001560 EXPECT_CALL(session_, GetTransportStats(_))
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001561 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
1562 Return(true)));
1563
1564 stats.RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1565 cricket::VoiceSenderInfo voice_sender_info;
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001566 InitVoiceSenderInfo(&voice_sender_info);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001567
1568 // Constructs an ssrc stats update.
1569 cricket::VoiceMediaInfo stats_read;
1570 stats_read.senders.push_back(voice_sender_info);
1571
1572 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));
1573 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
1574 EXPECT_CALL(*media_channel, GetStats(_))
1575 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
1576 Return(true)));
1577
1578 StatsReports reports; // returned values.
1579 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1580 stats.GetStats(NULL, &reports);
1581
1582 // The report will exist since we don't remove them in RemoveStream().
1583 const StatsReport* report = FindNthReportByType(
1584 reports, StatsReport::kStatsReportTypeSsrc, 1);
1585 EXPECT_FALSE(report == NULL);
jbauchbe24c942015-06-22 15:06:43 -07001586 EXPECT_EQ(stats.GetTimeNow(), report->timestamp());
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001587 std::string track_id = ExtractSsrcStatsValue(
1588 reports, StatsReport::kStatsValueNameTrackId);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001589 EXPECT_EQ(kLocalTrackId, track_id);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001590 std::string ssrc_id = ExtractSsrcStatsValue(
1591 reports, StatsReport::kStatsValueNameSsrc);
Peter Boström0c4e06b2015-10-07 12:23:21 +02001592 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);
henrike@webrtc.org40b3b682014-03-03 18:30:11 +00001593
1594 // Verifies the values in the track report, no value will be changed by the
1595 // AudioTrackInterface::GetSignalValue() and
1596 // AudioProcessorInterface::AudioProcessorStats::GetStats();
1597 VerifyVoiceSenderInfoReport(report, voice_sender_info);
1598}
1599
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001600// This test verifies that when ongoing and incoming audio tracks are using
1601// the same ssrc, they populate stats reports correctly.
1602TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001603 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001604
deadbeefcbecd352015-09-23 11:50:27 -07001605 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1606 .WillRepeatedly(Return(false));
1607 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1608 .WillRepeatedly(Return(false));
1609
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001610 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001611 // The transport_name known by the voice channel.
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001612 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001613 cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
pthatcher@webrtc.orgb01c7072015-03-13 20:05:17 +00001614 media_engine_, media_channel, NULL, kVcName, false);
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001615
1616 // Create a local stream with a local audio track and adds it to the stats.
1617 AddOutgoingAudioTrackStats();
1618 stats.AddStream(stream_);
1619 stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1620
1621 // Create a remote stream with a remote audio track and adds it to the stats.
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001622 rtc::scoped_refptr<webrtc::MediaStream> remote_stream(
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001623 webrtc::MediaStream::Create("remotestreamlabel"));
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001624 rtc::scoped_refptr<FakeAudioTrack> remote_track(
1625 new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001626 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))
xians@webrtc.org01bda202014-07-09 07:38:38 +00001627 .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001628 remote_stream->AddTrack(remote_track);
1629 stats.AddStream(remote_stream);
1630
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001631 // Instruct the session to return stats containing the transport channel.
1632 InitSessionStats(kVcName);
pthatcher@webrtc.orgc04a97f2015-03-16 19:31:40 +00001633 EXPECT_CALL(session_, GetTransportStats(_))
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001634 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),
1635 Return(true)));
1636
1637 cricket::VoiceSenderInfo voice_sender_info;
1638 InitVoiceSenderInfo(&voice_sender_info);
1639
1640 // Some of the contents in |voice_sender_info| needs to be updated from the
1641 // |audio_track_|.
1642 UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info);
1643
1644 cricket::VoiceReceiverInfo voice_receiver_info;
1645 InitVoiceReceiverInfo(&voice_receiver_info);
1646
1647 // Constructs an ssrc stats update.
1648 cricket::VoiceMediaInfo stats_read;
1649 stats_read.senders.push_back(voice_sender_info);
1650 stats_read.receivers.push_back(voice_receiver_info);
1651
1652 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));
1653 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());
1654 EXPECT_CALL(*media_channel, GetStats(_))
1655 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),
1656 Return(true)));
1657
1658 StatsReports reports; // returned values.
1659 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);
1660
1661 // Get stats for the local track.
1662 stats.GetStats(audio_track_.get(), &reports);
1663 const StatsReport* track_report = FindNthReportByType(
1664 reports, StatsReport::kStatsReportTypeSsrc, 1);
1665 EXPECT_TRUE(track_report);
jbauchbe24c942015-06-22 15:06:43 -07001666 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001667 std::string track_id = ExtractSsrcStatsValue(
1668 reports, StatsReport::kStatsValueNameTrackId);
1669 EXPECT_EQ(kLocalTrackId, track_id);
1670 VerifyVoiceSenderInfoReport(track_report, voice_sender_info);
1671
1672 // Get stats for the remote track.
tommi@webrtc.org5b06b062014-08-15 08:38:30 +00001673 reports.clear();
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001674 stats.GetStats(remote_track.get(), &reports);
1675 track_report = FindNthReportByType(reports,
1676 StatsReport::kStatsReportTypeSsrc, 1);
1677 EXPECT_TRUE(track_report);
jbauchbe24c942015-06-22 15:06:43 -07001678 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());
xians@webrtc.org4cb01282014-06-12 14:57:05 +00001679 track_id = ExtractSsrcStatsValue(reports,
1680 StatsReport::kStatsValueNameTrackId);
1681 EXPECT_EQ(kRemoteTrackId, track_id);
1682 VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);
1683}
1684
xians@webrtc.org01bda202014-07-09 07:38:38 +00001685// This test verifies that when two outgoing audio tracks are using the same
1686// ssrc at different times, they populate stats reports correctly.
1687// TODO(xians): Figure out if it is possible to encapsulate the setup and
1688// avoid duplication of code in test cases.
1689TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {
decurtis@webrtc.org322a5642015-02-03 22:09:37 +00001690 StatsCollectorForTest stats(&session_);
decurtis@webrtc.org487a4442015-01-15 22:55:07 +00001691
deadbeefcbecd352015-09-23 11:50:27 -07001692 EXPECT_CALL(session_, GetLocalCertificate(_, _))
1693 .WillRepeatedly(Return(false));
1694 EXPECT_CALL(session_, GetRemoteSSLCertificate(_, _))
1695 .WillRepeatedly(Return(false));
1696
xians@webrtc.org01bda202014-07-09 07:38:38 +00001697 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();
deadbeefcbecd352015-09-23 11:50:27 -07001698 // The transport_name known by the voice channel.
xians@webrtc.org01bda202014-07-09 07:38:38 +00001699 const std::string kVcName("vcname");
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001700 cricket::VoiceChannel voice_channel(rtc::Thread::Current(),
pthatcher@webrtc.orgb01c7072015-03-13 20:05:17 +00001701 media_engine_, media_channel, NULL, kVcName, false);
xians@webrtc.org01bda202014-07-09 07:38:38 +00001702
1703 // Create a local stream with a local audio track and adds it to the stats.
1704 AddOutgoingAudioTrackStats();
1705 stats.AddStream(stream_);
1706 stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);
1707
1708 cricket::VoiceSenderInfo voice_sender_info;
1709 voice_sender_info.add_ssrc(kSsrcOfTrack);
1710
1711 cricket::VoiceMediaInfo stats_read;
1712 StatsReports reports; // returned values.
1713 SetupAndVerifyAudioTrackStats(
1714 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,
1715 media_channel, &voice_sender_info, NULL, &stats_read, &reports);
1716
1717 // Remove the previous audio track from the stream.
1718 stream_->RemoveTrack(audio_track_.get());
1719 stats.RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);
1720
1721 // Create a new audio track and adds it to the stream and stats.
1722 static const std::string kNewTrackId = "new_track_id";
buildbot@webrtc.orgd4e598d2014-07-29 17:36:52 +00001723 rtc::scoped_refptr<FakeAudioTrack> new_audio_track(
1724 new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));
xians@webrtc.org01bda202014-07-09 07:38:38 +00001725 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))
1726 .WillOnce(DoAll(SetArgPointee<1>(kNewTrackId), Return(true)));
1727 stream_->AddTrack(new_audio_track);
1728
1729 stats.AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);
tommi@webrtc.org69bc5a32014-12-15 09:44:48 +00001730 stats.ClearUpdateStatsCacheForTest();
xians@webrtc.org01bda202014-07-09 07:38:38 +00001731 cricket::VoiceSenderInfo new_voice_sender_info;
1732 InitVoiceSenderInfo(&new_voice_sender_info);
1733 cricket::VoiceMediaInfo new_stats_read;
tommi@webrtc.org5b06b062014-08-15 08:38:30 +00001734 reports.clear();
xians@webrtc.org01bda202014-07-09 07:38:38 +00001735 SetupAndVerifyAudioTrackStats(
1736 new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,
1737 media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);
1738}
1739
guoweis@webrtc.org950c5182014-12-16 23:01:31 +00001740} // namespace webrtc