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