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