webrtc/api/statscollector_unittest.cc - Issue 2514883002: Create //webrtc/api:libjingle_peerconnection_api + refactorings.

Side by Side Diff: webrtc/api/statscollector_unittest.cc

Issue 2514883002: Create //webrtc/api:libjingle_peerconnection_api + refactorings. (Closed)

Patch Set: Rebase Created 4 years ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 * Copyright 2014 The WebRTC project authors. All Rights Reserved.

3 *

4 * Use of this source code is governed by a BSD-style license

5 * that can be found in the LICENSE file in the root of the source

6 * tree. An additional intellectual property rights grant can be found

7 * in the file PATENTS. All contributing project authors may

8 * be found in the AUTHORS file in the root of the source tree.

9 */

10

11 #include <stdio.h>

12

13 #include <algorithm>

14 #include <memory>

15

16 #include "webrtc/api/statscollector.h"

17

18 #include "webrtc/api/mediastream.h"

19 #include "webrtc/api/mediastreaminterface.h"

20 #include "webrtc/api/mediastreamtrack.h"

21 #include "webrtc/api/peerconnection.h"

22 #include "webrtc/api/peerconnectionfactory.h"

23 #include "webrtc/api/test/fakedatachannelprovider.h"

24 #include "webrtc/api/test/fakevideotracksource.h"

25 #include "webrtc/api/test/mock_peerconnection.h"

26 #include "webrtc/api/test/mock_webrtcsession.h"

27 #include "webrtc/api/videotrack.h"

28 #include "webrtc/base/base64.h"

29 #include "webrtc/base/fakesslidentity.h"

30 #include "webrtc/base/gunit.h"

31 #include "webrtc/base/network.h"

32 #include "webrtc/base/stringencode.h"

33 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"

34 #include "webrtc/media/base/fakemediaengine.h"

35 #include "webrtc/media/base/test/mock_mediachannel.h"

36 #include "webrtc/p2p/base/faketransportcontroller.h"

37 #include "webrtc/pc/channelmanager.h"

38 #include "webrtc/test/gmock.h"

39 #include "webrtc/test/gtest.h"

40

41 using testing::_;

42 using testing::DoAll;

43 using testing::Field;

44 using testing::Return;

45 using testing::ReturnNull;

46 using testing::ReturnRef;

47 using testing::SetArgPointee;

48 using webrtc::PeerConnectionInterface;

49 using webrtc::StatsReport;

50 using webrtc::StatsReports;

51

52 namespace {

53 const bool kDefaultRtcpEnabled = false;

54 const bool kDefaultSrtpRequired = true;

55 }

56

57 namespace cricket {

58

59 class ChannelManager;

60

61 } // namespace cricket

62

63 namespace webrtc {

64

65 namespace internal {

66 // This value comes from openssl/tls1.h

67 static const int TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014;

68 } // namespace internal

69

70 // Error return values

71 const char kNotFound[] = "NOT FOUND";

72

73 // Constant names for track identification.

74 const char kLocalTrackId[] = "local_track_id";

75 const char kRemoteTrackId[] = "remote_track_id";

76 const uint32_t kSsrcOfTrack = 1234;

77

78 class FakeAudioProcessor : public webrtc::AudioProcessorInterface {

79 public:

80 FakeAudioProcessor() {}

81 ~FakeAudioProcessor() {}

82

83 private:

84 void GetStats(AudioProcessorInterface::AudioProcessorStats* stats) override {

85 stats->typing_noise_detected = true;

86 stats->echo_return_loss = 2;

87 stats->echo_return_loss_enhancement = 3;

88 stats->echo_delay_median_ms = 4;

89 stats->aec_quality_min = 5.1f;

90 stats->echo_delay_std_ms = 6;

91 }

92 };

93

94 class FakeAudioTrack

95 : public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface> {

96 public:

97 explicit FakeAudioTrack(const std::string& id)

98 : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),

99 processor_(new rtc::RefCountedObject<FakeAudioProcessor>()) {}

100 std::string kind() const override { return "audio"; }

101 webrtc::AudioSourceInterface* GetSource() const override { return NULL; }

102 void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}

103 void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}

104 bool GetSignalLevel(int* level) override {

105 *level = 1;

106 return true;

107 }

108 rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()

109 override {

110 return processor_;

111 }

112

113 private:

114 rtc::scoped_refptr<FakeAudioProcessor> processor_;

115 };

116

117 // This fake audio processor is used to verify that the undesired initial values

118 // (-1) will be filtered out.

119 class FakeAudioProcessorWithInitValue : public webrtc::AudioProcessorInterface {

120 public:

121 FakeAudioProcessorWithInitValue() {}

122 ~FakeAudioProcessorWithInitValue() {}

123

124 private:

125 void GetStats(AudioProcessorInterface::AudioProcessorStats* stats) override {

126 stats->typing_noise_detected = false;

127 stats->echo_return_loss = -100;

128 stats->echo_return_loss_enhancement = -100;

129 stats->echo_delay_median_ms = -1;

130 stats->aec_quality_min = -1.0f;

131 stats->echo_delay_std_ms = -1;

132 }

133 };

134

135 class FakeAudioTrackWithInitValue

136 : public webrtc::MediaStreamTrack<webrtc::AudioTrackInterface> {

137 public:

138 explicit FakeAudioTrackWithInitValue(const std::string& id)

139 : webrtc::MediaStreamTrack<webrtc::AudioTrackInterface>(id),

140 processor_(

141 new rtc::RefCountedObject<FakeAudioProcessorWithInitValue>()) {}

142 std::string kind() const override { return "audio"; }

143 webrtc::AudioSourceInterface* GetSource() const override { return NULL; }

144 void AddSink(webrtc::AudioTrackSinkInterface* sink) override {}

145 void RemoveSink(webrtc::AudioTrackSinkInterface* sink) override {}

146 bool GetSignalLevel(int* level) override {

147 *level = 1;

148 return true;

149 }

150 rtc::scoped_refptr<webrtc::AudioProcessorInterface> GetAudioProcessor()

151 override {

152 return processor_;

153 }

154

155 private:

156 rtc::scoped_refptr<FakeAudioProcessorWithInitValue> processor_;

157 };

158

159 bool GetValue(const StatsReport* report,

160 StatsReport::StatsValueName name,

161 std::string* value) {

162 const StatsReport::Value* v = report->FindValue(name);

163 if (!v)

164 return false;

165 *value = v->ToString();

166 return true;

167 }

168

169 std::string ExtractStatsValue(const StatsReport::StatsType& type,

170 const StatsReports& reports,

171 StatsReport::StatsValueName name) {

172 for (const auto* r : reports) {

173 std::string ret;

174 if (r->type() == type && GetValue(r, name, &ret))

175 return ret;

176 }

177

178 return kNotFound;

179 }

180

181 StatsReport::Id TypedIdFromIdString(StatsReport::StatsType type,

182 const std::string& value) {

183 EXPECT_FALSE(value.empty());

184 StatsReport::Id id;

185 if (value.empty())

186 return id;

187

188 // This has assumptions about how the ID is constructed. As is, this is

189 // OK since this is for testing purposes only, but if we ever need this

190 // in production, we should add a generic method that does this.

191 size_t index = value.find('_');

192 EXPECT_NE(index, std::string::npos);

193 if (index == std::string::npos \|\| index == (value.length() - 1))

194 return id;

195

196 id = StatsReport::NewTypedId(type, value.substr(index + 1));

197 EXPECT_EQ(id->ToString(), value);

198 return id;

199 }

200

201 StatsReport::Id IdFromCertIdString(const std::string& cert_id) {

202 return TypedIdFromIdString(StatsReport::kStatsReportTypeCertificate, cert_id);

203 }

204

205 // Finds the \|n\|-th report of type \|type\| in \|reports\|.

206 // \|n\| starts from 1 for finding the first report.

207 const StatsReport* FindNthReportByType(

208 const StatsReports& reports, const StatsReport::StatsType& type, int n) {

209 for (size_t i = 0; i < reports.size(); ++i) {

210 if (reports[i]->type() == type) {

211 n--;

212 if (n == 0)

213 return reports[i];

214 }

215 }

216 return nullptr;

217 }

218

219 const StatsReport* FindReportById(const StatsReports& reports,

220 const StatsReport::Id& id) {

221 for (const auto* r : reports) {

222 if (r->id()->Equals(id))

223 return r;

224 }

225 return nullptr;

226 }

227

228 std::string ExtractSsrcStatsValue(StatsReports reports,

229 StatsReport::StatsValueName name) {

230 return ExtractStatsValue(StatsReport::kStatsReportTypeSsrc, reports, name);

231 }

232

233 std::string ExtractBweStatsValue(StatsReports reports,

234 StatsReport::StatsValueName name) {

235 return ExtractStatsValue(

236 StatsReport::kStatsReportTypeBwe, reports, name);

237 }

238

239 std::string DerToPem(const std::string& der) {

240 return rtc::SSLIdentity::DerToPem(

241 rtc::kPemTypeCertificate,

242 reinterpret_cast<const unsigned char*>(der.c_str()),

243 der.length());

244 }

245

246 std::vector<std::string> DersToPems(

247 const std::vector<std::string>& ders) {

248 std::vector<std::string> pems(ders.size());

249 std::transform(ders.begin(), ders.end(), pems.begin(), DerToPem);

250 return pems;

251 }

252

253 void CheckCertChainReports(const StatsReports& reports,

254 const std::vector<std::string>& ders,

255 const StatsReport::Id& start_id) {

256 StatsReport::Id cert_id;

257 const StatsReport::Id* certificate_id = &start_id;

258 size_t i = 0;

259 while (true) {

260 const StatsReport* report = FindReportById(reports, *certificate_id);

261 ASSERT_TRUE(report != NULL);

262

263 std::string der_base64;

264 EXPECT_TRUE(GetValue(

265 report, StatsReport::kStatsValueNameDer, &der_base64));

266 std::string der = rtc::Base64::Decode(der_base64, rtc::Base64::DO_STRICT);

267 EXPECT_EQ(ders[i], der);

268

269 std::string fingerprint_algorithm;

270 EXPECT_TRUE(GetValue(

271 report,

272 StatsReport::kStatsValueNameFingerprintAlgorithm,

273 &fingerprint_algorithm));

274 // The digest algorithm for a FakeSSLCertificate is always SHA-1.

275 std::string sha_1_str = rtc::DIGEST_SHA_1;

276 EXPECT_EQ(sha_1_str, fingerprint_algorithm);

277

278 std::string fingerprint;

279 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameFingerprint,

280 &fingerprint));

281 EXPECT_FALSE(fingerprint.empty());

282

283 ++i;

284 std::string issuer_id;

285 if (!GetValue(report, StatsReport::kStatsValueNameIssuerId,

286 &issuer_id)) {

287 break;

288 }

289

290 cert_id = IdFromCertIdString(issuer_id);

291 certificate_id = &cert_id;

292 }

293 EXPECT_EQ(ders.size(), i);

294 }

295

296 void VerifyVoiceReceiverInfoReport(

297 const StatsReport* report,

298 const cricket::VoiceReceiverInfo& info) {

299 std::string value_in_report;

300 EXPECT_TRUE(GetValue(

301 report, StatsReport::kStatsValueNameAudioOutputLevel, &value_in_report));

302 EXPECT_EQ(rtc::ToString<int>(info.audio_level), value_in_report);

303 EXPECT_TRUE(GetValue(

304 report, StatsReport::kStatsValueNameBytesReceived, &value_in_report));

305 EXPECT_EQ(rtc::ToString<int64_t>(info.bytes_rcvd), value_in_report);

306 EXPECT_TRUE(GetValue(

307 report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));

308 EXPECT_EQ(rtc::ToString<int>(info.jitter_ms), value_in_report);

309 EXPECT_TRUE(GetValue(

310 report, StatsReport::kStatsValueNameJitterBufferMs, &value_in_report));

311 EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_ms), value_in_report);

312 EXPECT_TRUE(GetValue(

313 report, StatsReport::kStatsValueNamePreferredJitterBufferMs,

314 &value_in_report));

315 EXPECT_EQ(rtc::ToString<int>(info.jitter_buffer_preferred_ms),

316 value_in_report);

317 EXPECT_TRUE(GetValue(

318 report, StatsReport::kStatsValueNameCurrentDelayMs, &value_in_report));

319 EXPECT_EQ(rtc::ToString<int>(info.delay_estimate_ms), value_in_report);

320 EXPECT_TRUE(GetValue(

321 report, StatsReport::kStatsValueNameExpandRate, &value_in_report));

322 EXPECT_EQ(rtc::ToString<float>(info.expand_rate), value_in_report);

323 EXPECT_TRUE(GetValue(

324 report, StatsReport::kStatsValueNameSpeechExpandRate, &value_in_report));

325 EXPECT_EQ(rtc::ToString<float>(info.speech_expand_rate), value_in_report);

326 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAccelerateRate,

327 &value_in_report));

328 EXPECT_EQ(rtc::ToString<float>(info.accelerate_rate), value_in_report);

329 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNamePreemptiveExpandRate,

330 &value_in_report));

331 EXPECT_EQ(rtc::ToString<float>(info.preemptive_expand_rate), value_in_report);

332 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameSecondaryDecodedRate,

333 &value_in_report));

334 EXPECT_EQ(rtc::ToString<float>(info.secondary_decoded_rate), value_in_report);

335 EXPECT_TRUE(GetValue(

336 report, StatsReport::kStatsValueNamePacketsReceived, &value_in_report));

337 EXPECT_EQ(rtc::ToString<int>(info.packets_rcvd), value_in_report);

338 EXPECT_TRUE(GetValue(

339 report, StatsReport::kStatsValueNameDecodingCTSG, &value_in_report));

340 EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_silence_generator),

341 value_in_report);

342 EXPECT_TRUE(GetValue(

343 report, StatsReport::kStatsValueNameDecodingCTN, &value_in_report));

344 EXPECT_EQ(rtc::ToString<int>(info.decoding_calls_to_neteq),

345 value_in_report);

346 EXPECT_TRUE(GetValue(

347 report, StatsReport::kStatsValueNameDecodingNormal, &value_in_report));

348 EXPECT_EQ(rtc::ToString<int>(info.decoding_normal), value_in_report);

349 EXPECT_TRUE(GetValue(

350 report, StatsReport::kStatsValueNameDecodingPLC, &value_in_report));

351 EXPECT_EQ(rtc::ToString<int>(info.decoding_plc), value_in_report);

352 EXPECT_TRUE(GetValue(

353 report, StatsReport::kStatsValueNameDecodingCNG, &value_in_report));

354 EXPECT_EQ(rtc::ToString<int>(info.decoding_cng), value_in_report);

355 EXPECT_TRUE(GetValue(

356 report, StatsReport::kStatsValueNameDecodingPLCCNG, &value_in_report));

357 EXPECT_EQ(rtc::ToString<int>(info.decoding_plc_cng), value_in_report);

358 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameDecodingMutedOutput,

359 &value_in_report));

360 EXPECT_EQ(rtc::ToString<int>(info.decoding_muted_output), value_in_report);

361 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameCodecName,

362 &value_in_report));

363 }

364

365

366 void VerifyVoiceSenderInfoReport(const StatsReport* report,

367 const cricket::VoiceSenderInfo& sinfo) {

368 std::string value_in_report;

369 EXPECT_TRUE(GetValue(

370 report, StatsReport::kStatsValueNameCodecName, &value_in_report));

371 EXPECT_EQ(sinfo.codec_name, value_in_report);

372 EXPECT_TRUE(GetValue(

373 report, StatsReport::kStatsValueNameBytesSent, &value_in_report));

374 EXPECT_EQ(rtc::ToString<int64_t>(sinfo.bytes_sent), value_in_report);

375 EXPECT_TRUE(GetValue(

376 report, StatsReport::kStatsValueNamePacketsSent, &value_in_report));

377 EXPECT_EQ(rtc::ToString<int>(sinfo.packets_sent), value_in_report);

378 EXPECT_TRUE(GetValue(

379 report, StatsReport::kStatsValueNamePacketsLost, &value_in_report));

380 EXPECT_EQ(rtc::ToString<int>(sinfo.packets_lost), value_in_report);

381 EXPECT_TRUE(GetValue(

382 report, StatsReport::kStatsValueNameRtt, &value_in_report));

383 EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);

384 EXPECT_TRUE(GetValue(

385 report, StatsReport::kStatsValueNameRtt, &value_in_report));

386 EXPECT_EQ(rtc::ToString<int>(sinfo.rtt_ms), value_in_report);

387 EXPECT_TRUE(GetValue(

388 report, StatsReport::kStatsValueNameJitterReceived, &value_in_report));

389 EXPECT_EQ(rtc::ToString<int>(sinfo.jitter_ms), value_in_report);

390 EXPECT_TRUE(GetValue(

391 report, StatsReport::kStatsValueNameEchoCancellationQualityMin,

392 &value_in_report));

393 EXPECT_EQ(rtc::ToString<float>(sinfo.aec_quality_min), value_in_report);

394 EXPECT_TRUE(GetValue(

395 report, StatsReport::kStatsValueNameEchoDelayMedian, &value_in_report));

396 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_median_ms),

397 value_in_report);

398 EXPECT_TRUE(GetValue(

399 report, StatsReport::kStatsValueNameEchoDelayStdDev, &value_in_report));

400 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_delay_std_ms),

401 value_in_report);

402 EXPECT_TRUE(GetValue(

403 report, StatsReport::kStatsValueNameEchoReturnLoss, &value_in_report));

404 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss),

405 value_in_report);

406 EXPECT_TRUE(GetValue(

407 report, StatsReport::kStatsValueNameEchoReturnLossEnhancement,

408 &value_in_report));

409 EXPECT_EQ(rtc::ToString<int>(sinfo.echo_return_loss_enhancement),

410 value_in_report);

411 EXPECT_TRUE(GetValue(report,

412 StatsReport::kStatsValueNameResidualEchoLikelihood,

413 &value_in_report));

414 EXPECT_EQ(rtc::ToString<float>(sinfo.residual_echo_likelihood),

415 value_in_report);

416 EXPECT_TRUE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,

417 &value_in_report));

418 EXPECT_EQ(rtc::ToString<int>(sinfo.audio_level), value_in_report);

419 EXPECT_TRUE(GetValue(

420 report, StatsReport::kStatsValueNameTypingNoiseState, &value_in_report));

421 std::string typing_detected = sinfo.typing_noise_detected ? "true" : "false";

422 EXPECT_EQ(typing_detected, value_in_report);

423 }

424

425 // Helper methods to avoid duplication of code.

426 void InitVoiceSenderInfo(cricket::VoiceSenderInfo* voice_sender_info) {

427 voice_sender_info->add_ssrc(kSsrcOfTrack);

428 voice_sender_info->codec_name = "fake_codec";

429 voice_sender_info->bytes_sent = 100;

430 voice_sender_info->packets_sent = 101;

431 voice_sender_info->rtt_ms = 102;

432 voice_sender_info->fraction_lost = 103;

433 voice_sender_info->jitter_ms = 104;

434 voice_sender_info->packets_lost = 105;

435 voice_sender_info->ext_seqnum = 106;

436 voice_sender_info->audio_level = 107;

437 voice_sender_info->echo_return_loss = 108;

438 voice_sender_info->echo_return_loss_enhancement = 109;

439 voice_sender_info->echo_delay_median_ms = 110;

440 voice_sender_info->echo_delay_std_ms = 111;

441 voice_sender_info->aec_quality_min = 112.0f;

442 voice_sender_info->typing_noise_detected = false;

443 }

444

445 void UpdateVoiceSenderInfoFromAudioTrack(

446 AudioTrackInterface* audio_track,

447 cricket::VoiceSenderInfo* voice_sender_info) {

448 audio_track->GetSignalLevel(&voice_sender_info->audio_level);

449 webrtc::AudioProcessorInterface::AudioProcessorStats audio_processor_stats;

450 audio_track->GetAudioProcessor()->GetStats(&audio_processor_stats);

451 voice_sender_info->typing_noise_detected =

452 audio_processor_stats.typing_noise_detected;

453 voice_sender_info->echo_return_loss = audio_processor_stats.echo_return_loss;

454 voice_sender_info->echo_return_loss_enhancement =

455 audio_processor_stats.echo_return_loss_enhancement;

456 voice_sender_info->echo_delay_median_ms =

457 audio_processor_stats.echo_delay_median_ms;

458 voice_sender_info->aec_quality_min = audio_processor_stats.aec_quality_min;

459 voice_sender_info->echo_delay_std_ms =

460 audio_processor_stats.echo_delay_std_ms;

461 }

462

463 void InitVoiceReceiverInfo(cricket::VoiceReceiverInfo* voice_receiver_info) {

464 voice_receiver_info->add_ssrc(kSsrcOfTrack);

465 voice_receiver_info->bytes_rcvd = 110;

466 voice_receiver_info->packets_rcvd = 111;

467 voice_receiver_info->packets_lost = 112;

468 voice_receiver_info->fraction_lost = 113;

469 voice_receiver_info->packets_lost = 114;

470 voice_receiver_info->ext_seqnum = 115;

471 voice_receiver_info->jitter_ms = 116;

472 voice_receiver_info->jitter_buffer_ms = 117;

473 voice_receiver_info->jitter_buffer_preferred_ms = 118;

474 voice_receiver_info->delay_estimate_ms = 119;

475 voice_receiver_info->audio_level = 120;

476 voice_receiver_info->expand_rate = 121;

477 voice_receiver_info->speech_expand_rate = 122;

478 voice_receiver_info->secondary_decoded_rate = 123;

479 voice_receiver_info->accelerate_rate = 124;

480 voice_receiver_info->preemptive_expand_rate = 125;

481 }

482

483 class StatsCollectorForTest : public webrtc::StatsCollector {

484 public:

485 explicit StatsCollectorForTest(PeerConnection* pc)

486 : StatsCollector(pc), time_now_(19477) {}

487

488 double GetTimeNow() override {

489 return time_now_;

490 }

491

492 private:

493 double time_now_;

494 };

495

496 class StatsCollectorTest : public testing::Test {

497 protected:

498 StatsCollectorTest()

499 : worker_thread_(rtc::Thread::Current()),

500 network_thread_(rtc::Thread::Current()),

501 media_engine_(new cricket::FakeMediaEngine()),

502 channel_manager_(new cricket::ChannelManager(media_engine_,

503 worker_thread_,

504 network_thread_)),

505 media_controller_(

506 webrtc::MediaControllerInterface::Create(cricket::MediaConfig(),

507 worker_thread_,

508 channel_manager_.get(),

509 &event_log_)),

510 session_(media_controller_.get()) {

511 // By default, we ignore session GetStats calls.

512 EXPECT_CALL(session_, GetTransportStats(_)).WillRepeatedly(Return(false));

513 // Add default returns for mock classes.

514 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());

515 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

516 EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_));

517 EXPECT_CALL(pc_, sctp_data_channels())

518 .WillRepeatedly(ReturnRef(data_channels_));

519 }

520

521 ~StatsCollectorTest() {}

522

523 // This creates a standard setup with a transport called "trspname"

524 // having one transport channel

525 // and the specified virtual connection name.

526 void InitSessionStats(const std::string& vc_name) {

527 const std::string kTransportName("trspname");

528 cricket::TransportStats transport_stats;

529 cricket::TransportChannelStats channel_stats;

530 channel_stats.component = 1;

531 transport_stats.transport_name = kTransportName;

532 transport_stats.channel_stats.push_back(channel_stats);

533

534 session_stats_.transport_stats[kTransportName] = transport_stats;

535 session_stats_.proxy_to_transport[vc_name] = kTransportName;

536 }

537

538 // Adds a outgoing video track with a given SSRC into the stats.

539 void AddOutgoingVideoTrackStats() {

540 stream_ = webrtc::MediaStream::Create("streamlabel");

541 track_ = webrtc::VideoTrack::Create(kLocalTrackId,

542 webrtc::FakeVideoTrackSource::Create());

543 stream_->AddTrack(track_);

544 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))

545 .WillRepeatedly(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));

546 }

547

548 // Adds a incoming video track with a given SSRC into the stats.

549 void AddIncomingVideoTrackStats() {

550 stream_ = webrtc::MediaStream::Create("streamlabel");

551 track_ = webrtc::VideoTrack::Create(kRemoteTrackId,

552 webrtc::FakeVideoTrackSource::Create());

553 stream_->AddTrack(track_);

554 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))

555 .WillRepeatedly(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));

556 }

557

558 // Adds a outgoing audio track with a given SSRC into the stats.

559 void AddOutgoingAudioTrackStats() {

560 if (stream_ == NULL)

561 stream_ = webrtc::MediaStream::Create("streamlabel");

562

563 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(

564 kLocalTrackId);

565 stream_->AddTrack(audio_track_);

566 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))

567 .WillOnce(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));

568 }

569

570 // Adds a incoming audio track with a given SSRC into the stats.

571 void AddIncomingAudioTrackStats() {

572 if (stream_ == NULL)

573 stream_ = webrtc::MediaStream::Create("streamlabel");

574

575 audio_track_ = new rtc::RefCountedObject<FakeAudioTrack>(

576 kRemoteTrackId);

577 stream_->AddTrack(audio_track_);

578 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))

579 .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));

580 }

581

582 void AddDataChannel(cricket::DataChannelType type,

583 const std::string& label,

584 int id) {

585 InternalDataChannelInit config;

586 config.id = id;

587

588 data_channels_.push_back(DataChannel::Create(

589 &data_channel_provider_, cricket::DCT_SCTP, label, config));

590 }

591

592 StatsReport* AddCandidateReport(StatsCollector* collector,

593 const cricket::Candidate& candidate,

594 bool local) {

595 return collector->AddCandidateReport(candidate, local);

596 }

597

598 void SetupAndVerifyAudioTrackStats(

599 FakeAudioTrack* audio_track,

600 webrtc::MediaStream* stream,

601 webrtc::StatsCollector* stats,

602 cricket::VoiceChannel* voice_channel,

603 const std::string& vc_name,

604 MockVoiceMediaChannel* media_channel,

605 cricket::VoiceSenderInfo* voice_sender_info,

606 cricket::VoiceReceiverInfo* voice_receiver_info,

607 cricket::VoiceMediaInfo* stats_read,

608 StatsReports* reports) {

609 // A track can't have both sender report and recv report at the same time

610 // for now, this might change in the future though.

611 ASSERT((voice_sender_info == NULL) ^ (voice_receiver_info == NULL));

612

613 // Instruct the session to return stats containing the transport channel.

614 InitSessionStats(vc_name);

615 EXPECT_CALL(session_, GetTransportStats(_))

616 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

617 Return(true)));

618

619 // Constructs an ssrc stats update.

620 if (voice_sender_info)

621 stats_read->senders.push_back(*voice_sender_info);

622 if (voice_receiver_info)

623 stats_read->receivers.push_back(*voice_receiver_info);

624

625 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(

626 Return(voice_channel));

627 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());

628 EXPECT_CALL(*media_channel, GetStats(_))

629 .WillOnce(DoAll(SetArgPointee<0>(*stats_read), Return(true)));

630

631 stats->UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

632 stats->ClearUpdateStatsCacheForTest();

633 stats->GetStats(NULL, reports);

634

635 // Verify the existence of the track report.

636 const StatsReport* report = FindNthReportByType(

637 *reports, StatsReport::kStatsReportTypeSsrc, 1);

638 EXPECT_FALSE(report == NULL);

639 EXPECT_EQ(stats->GetTimeNow(), report->timestamp());

640 std::string track_id = ExtractSsrcStatsValue(

641 *reports, StatsReport::kStatsValueNameTrackId);

642 EXPECT_EQ(audio_track->id(), track_id);

643 std::string ssrc_id = ExtractSsrcStatsValue(

644 *reports, StatsReport::kStatsValueNameSsrc);

645 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);

646

647 std::string media_type = ExtractSsrcStatsValue(*reports,

648 StatsReport::kStatsValueNameMediaType);

649 EXPECT_EQ("audio", media_type);

650

651 // Verifies the values in the track report.

652 if (voice_sender_info) {

653 UpdateVoiceSenderInfoFromAudioTrack(audio_track, voice_sender_info);

654 VerifyVoiceSenderInfoReport(report, *voice_sender_info);

655 }

656 if (voice_receiver_info) {

657 VerifyVoiceReceiverInfoReport(report, *voice_receiver_info);

658 }

659

660 // Verify we get the same result by passing a track to GetStats().

661 StatsReports track_reports; // returned values.

662 stats->GetStats(audio_track, &track_reports);

663 const StatsReport* track_report = FindNthReportByType(

664 track_reports, StatsReport::kStatsReportTypeSsrc, 1);

665 EXPECT_TRUE(track_report);

666 EXPECT_EQ(stats->GetTimeNow(), track_report->timestamp());

667 track_id = ExtractSsrcStatsValue(track_reports,

668 StatsReport::kStatsValueNameTrackId);

669 EXPECT_EQ(audio_track->id(), track_id);

670 ssrc_id = ExtractSsrcStatsValue(track_reports,

671 StatsReport::kStatsValueNameSsrc);

672 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);

673 if (voice_sender_info)

674 VerifyVoiceSenderInfoReport(track_report, *voice_sender_info);

675 if (voice_receiver_info)

676 VerifyVoiceReceiverInfoReport(track_report, *voice_receiver_info);

677 }

678

679 void TestCertificateReports(

680 const rtc::FakeSSLCertificate& local_cert,

681 const std::vector<std::string>& local_ders,

682 std::unique_ptr<rtc::FakeSSLCertificate> remote_cert,

683 const std::vector<std::string>& remote_ders) {

684 StatsCollectorForTest stats(&pc_);

685

686 StatsReports reports; // returned values.

687

688 // Fake stats to process.

689 cricket::TransportChannelStats channel_stats;

690 channel_stats.component = 1;

691 channel_stats.srtp_crypto_suite = rtc::SRTP_AES128_CM_SHA1_80;

692 channel_stats.ssl_cipher_suite =

693 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA;

694

695 cricket::TransportStats transport_stats;

696 transport_stats.transport_name = "audio";

697 transport_stats.channel_stats.push_back(channel_stats);

698

699 SessionStats session_stats;

700 session_stats.transport_stats[transport_stats.transport_name] =

701 transport_stats;

702

703 // Fake certificate to report

704 rtc::scoped_refptr<rtc::RTCCertificate> local_certificate(

705 rtc::RTCCertificate::Create(std::unique_ptr<rtc::FakeSSLIdentity>(

706 new rtc::FakeSSLIdentity(local_cert))));

707

708 // Configure MockWebRtcSession

709 EXPECT_CALL(session_,

710 GetLocalCertificate(transport_stats.transport_name, _))

711 .WillOnce(DoAll(SetArgPointee<1>(local_certificate), Return(true)));

712 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(

713 transport_stats.transport_name))

714 .WillOnce(Return(remote_cert.release()));

715 EXPECT_CALL(session_, GetTransportStats(_))

716 .WillOnce(DoAll(SetArgPointee<0>(session_stats),

717 Return(true)));

718

719 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

720

721 stats.GetStats(NULL, &reports);

722

723 const StatsReport* channel_report = FindNthReportByType(

724 reports, StatsReport::kStatsReportTypeComponent, 1);

725 EXPECT_TRUE(channel_report != NULL);

726

727 // Check local certificate chain.

728 std::string local_certificate_id = ExtractStatsValue(

729 StatsReport::kStatsReportTypeComponent,

730 reports,

731 StatsReport::kStatsValueNameLocalCertificateId);

732 if (local_ders.size() > 0) {

733 EXPECT_NE(kNotFound, local_certificate_id);

734 StatsReport::Id id(IdFromCertIdString(local_certificate_id));

735 CheckCertChainReports(reports, local_ders, id);

736 } else {

737 EXPECT_EQ(kNotFound, local_certificate_id);

738 }

739

740 // Check remote certificate chain.

741 std::string remote_certificate_id = ExtractStatsValue(

742 StatsReport::kStatsReportTypeComponent,

743 reports,

744 StatsReport::kStatsValueNameRemoteCertificateId);

745 if (remote_ders.size() > 0) {

746 EXPECT_NE(kNotFound, remote_certificate_id);

747 StatsReport::Id id(IdFromCertIdString(remote_certificate_id));

748 CheckCertChainReports(reports, remote_ders, id);

749 } else {

750 EXPECT_EQ(kNotFound, remote_certificate_id);

751 }

752

753 // Check negotiated ciphers.

754 std::string dtls_cipher_suite =

755 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,

756 StatsReport::kStatsValueNameDtlsCipher);

757 EXPECT_EQ(rtc::SSLStreamAdapter::SslCipherSuiteToName(

758 internal::TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA),

759 dtls_cipher_suite);

760 std::string srtp_crypto_suite =

761 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,

762 StatsReport::kStatsValueNameSrtpCipher);

763 EXPECT_EQ(rtc::SrtpCryptoSuiteToName(rtc::SRTP_AES128_CM_SHA1_80),

764 srtp_crypto_suite);

765 }

766

767 webrtc::RtcEventLogNullImpl event_log_;

768 rtc::Thread* const worker_thread_;

769 rtc::Thread* const network_thread_;

770 cricket::FakeMediaEngine* media_engine_;

771 std::unique_ptr<cricket::ChannelManager> channel_manager_;

772 std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;

773 MockWebRtcSession session_;

774 MockPeerConnection pc_;

775 FakeDataChannelProvider data_channel_provider_;

776 SessionStats session_stats_;

777 rtc::scoped_refptr<webrtc::MediaStream> stream_;

778 rtc::scoped_refptr<webrtc::VideoTrack> track_;

779 rtc::scoped_refptr<FakeAudioTrack> audio_track_;

780 std::vector<rtc::scoped_refptr<DataChannel>> data_channels_;

781 };

782

783 TEST_F(StatsCollectorTest, FilterOutNegativeDataChannelId) {

784 const std::string label = "hacks";

785 // The data channel id is from the Config which is -1 initially.

786 const int id = -1;

787 const std::string state = DataChannelInterface::DataStateString(

788 DataChannelInterface::DataState::kConnecting);

789

790 AddDataChannel(cricket::DCT_SCTP, label, id);

791 StatsCollectorForTest stats(&pc_);

792

793 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

794

795 StatsReports reports;

796 stats.GetStats(NULL, &reports);

797

798 const StatsReport* report =

799 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);

800

801 std::string value_in_report;

802 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameDataChannelId,

803 &value_in_report));

804 }

805

806 // Verify that ExtractDataInfo populates reports.

807 TEST_F(StatsCollectorTest, ExtractDataInfo) {

808 const std::string label = "hacks";

809 const int id = 31337;

810 const std::string state = DataChannelInterface::DataStateString(

811 DataChannelInterface::DataState::kConnecting);

812

813 AddDataChannel(cricket::DCT_SCTP, label, id);

814 StatsCollectorForTest stats(&pc_);

815

816 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

817

818 StatsReports reports;

819 stats.GetStats(NULL, &reports);

820

821 const StatsReport* report =

822 FindNthReportByType(reports, StatsReport::kStatsReportTypeDataChannel, 1);

823

824 StatsReport::Id reportId = StatsReport::NewTypedIntId(

825 StatsReport::kStatsReportTypeDataChannel, id);

826

827 EXPECT_TRUE(reportId->Equals(report->id()));

828

829 EXPECT_EQ(stats.GetTimeNow(), report->timestamp());

830 EXPECT_EQ(label, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,

831 reports,

832 StatsReport::kStatsValueNameLabel));

833 EXPECT_EQ(rtc::ToString<int64_t>(id),

834 ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel, reports,

835 StatsReport::kStatsValueNameDataChannelId));

836 EXPECT_EQ(state, ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,

837 reports,

838 StatsReport::kStatsValueNameState));

839 EXPECT_EQ("", ExtractStatsValue(StatsReport::kStatsReportTypeDataChannel,

840 reports,

841 StatsReport::kStatsValueNameProtocol));

842 }

843

844 // This test verifies that 64-bit counters are passed successfully.

845 TEST_F(StatsCollectorTest, BytesCounterHandles64Bits) {

846 StatsCollectorForTest stats(&pc_);

847

848 EXPECT_CALL(session_, GetLocalCertificate(_, _))

849 .WillRepeatedly(Return(false));

850 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

851 .WillRepeatedly(Return(nullptr));

852

853 const char kVideoChannelName[] = "video";

854

855 InitSessionStats(kVideoChannelName);

856 EXPECT_CALL(session_, GetTransportStats(_))

857 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

858 Return(true)));

859

860 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

861 cricket::VideoChannel video_channel(

862 worker_thread_, network_thread_, media_channel, nullptr,

863 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

864 StatsReports reports; // returned values.

865 cricket::VideoSenderInfo video_sender_info;

866 cricket::VideoMediaInfo stats_read;

867 // The number of bytes must be larger than 0xFFFFFFFF for this test.

868 const int64_t kBytesSent = 12345678901234LL;

869 const std::string kBytesSentString("12345678901234");

870

871 AddOutgoingVideoTrackStats();

872 stats.AddStream(stream_);

873

874 // Construct a stats value to read.

875 video_sender_info.add_ssrc(1234);

876 video_sender_info.bytes_sent = kBytesSent;

877 stats_read.senders.push_back(video_sender_info);

878

879 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

880 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

881 EXPECT_CALL(*media_channel, GetStats(_))

882 .WillOnce(DoAll(SetArgPointee<0>(stats_read),

883 Return(true)));

884 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

885 stats.GetStats(NULL, &reports);

886 std::string result = ExtractSsrcStatsValue(reports,

887 StatsReport::kStatsValueNameBytesSent);

888 EXPECT_EQ(kBytesSentString, result);

889 }

890

891 // Test that BWE information is reported via stats.

892 TEST_F(StatsCollectorTest, BandwidthEstimationInfoIsReported) {

893 StatsCollectorForTest stats(&pc_);

894

895 EXPECT_CALL(session_, GetLocalCertificate(_, _))

896 .WillRepeatedly(Return(false));

897 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

898 .WillRepeatedly(Return(nullptr));

899

900 const char kVideoChannelName[] = "video";

901

902 InitSessionStats(kVideoChannelName);

903 EXPECT_CALL(session_, GetTransportStats(_))

904 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

905 Return(true)));

906

907 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

908 cricket::VideoChannel video_channel(

909 worker_thread_, network_thread_, media_channel, nullptr,

910 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

911

912 StatsReports reports; // returned values.

913 cricket::VideoSenderInfo video_sender_info;

914 cricket::VideoMediaInfo stats_read;

915 // Set up an SSRC just to test that we get both kinds of stats back: SSRC and

916 // BWE.

917 const int64_t kBytesSent = 12345678901234LL;

918 const std::string kBytesSentString("12345678901234");

919

920 AddOutgoingVideoTrackStats();

921 stats.AddStream(stream_);

922

923 // Construct a stats value to read.

924 video_sender_info.add_ssrc(1234);

925 video_sender_info.bytes_sent = kBytesSent;

926 stats_read.senders.push_back(video_sender_info);

927 cricket::BandwidthEstimationInfo bwe;

928 const int kTargetEncBitrate = 123456;

929 const std::string kTargetEncBitrateString("123456");

930 bwe.target_enc_bitrate = kTargetEncBitrate;

931 stats_read.bw_estimations.push_back(bwe);

932

933 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

934 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

935 EXPECT_CALL(*media_channel, GetStats(_))

936 .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));

937

938 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

939 stats.GetStats(NULL, &reports);

940 std::string result = ExtractSsrcStatsValue(reports,

941 StatsReport::kStatsValueNameBytesSent);

942 EXPECT_EQ(kBytesSentString, result);

943 result = ExtractBweStatsValue(reports,

944 StatsReport::kStatsValueNameTargetEncBitrate);

945 EXPECT_EQ(kTargetEncBitrateString, result);

946 }

947

948 // This test verifies that an object of type "googSession" always

949 // exists in the returned stats.

950 TEST_F(StatsCollectorTest, SessionObjectExists) {

951 StatsCollectorForTest stats(&pc_);

952

953 StatsReports reports; // returned values.

954 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

955 stats.GetStats(NULL, &reports);

956 const StatsReport* session_report = FindNthReportByType(

957 reports, StatsReport::kStatsReportTypeSession, 1);

958 EXPECT_FALSE(session_report == NULL);

959 }

960

961 // This test verifies that only one object of type "googSession" exists

962 // in the returned stats.

963 TEST_F(StatsCollectorTest, OnlyOneSessionObjectExists) {

964 StatsCollectorForTest stats(&pc_);

965

966 StatsReports reports; // returned values.

967 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

968 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

969 stats.GetStats(NULL, &reports);

970 const StatsReport* session_report = FindNthReportByType(

971 reports, StatsReport::kStatsReportTypeSession, 1);

972 EXPECT_FALSE(session_report == NULL);

973 session_report = FindNthReportByType(

974 reports, StatsReport::kStatsReportTypeSession, 2);

975 EXPECT_EQ(NULL, session_report);

976 }

977

978 // This test verifies that the empty track report exists in the returned stats

979 // without calling StatsCollector::UpdateStats.

980 TEST_F(StatsCollectorTest, TrackObjectExistsWithoutUpdateStats) {

981 StatsCollectorForTest stats(&pc_);

982

983 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

984 cricket::VideoChannel video_channel(

985 worker_thread_, network_thread_, media_channel, nullptr, "video",

986 kDefaultRtcpEnabled, kDefaultSrtpRequired);

987 AddOutgoingVideoTrackStats();

988 stats.AddStream(stream_);

989

990 // Verfies the existence of the track report.

991 StatsReports reports;

992 stats.GetStats(NULL, &reports);

993 EXPECT_EQ((size_t)1, reports.size());

994 EXPECT_EQ(StatsReport::kStatsReportTypeTrack, reports[0]->type());

995 EXPECT_EQ(0, reports[0]->timestamp());

996

997 std::string trackValue =

998 ExtractStatsValue(StatsReport::kStatsReportTypeTrack,

999 reports,

1000 StatsReport::kStatsValueNameTrackId);

1001 EXPECT_EQ(kLocalTrackId, trackValue);

1002 }

1003

1004 // This test verifies that the empty track report exists in the returned stats

1005 // when StatsCollector::UpdateStats is called with ssrc stats.

1006 TEST_F(StatsCollectorTest, TrackAndSsrcObjectExistAfterUpdateSsrcStats) {

1007 StatsCollectorForTest stats(&pc_);

1008

1009 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1010 .WillRepeatedly(Return(false));

1011 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1012 .WillRepeatedly(Return(nullptr));

1013

1014 const char kVideoChannelName[] = "video";

1015 InitSessionStats(kVideoChannelName);

1016 EXPECT_CALL(session_, GetTransportStats(_))

1017 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1018 Return(true)));

1019

1020 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1021 cricket::VideoChannel video_channel(

1022 worker_thread_, network_thread_, media_channel, nullptr,

1023 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1024 AddOutgoingVideoTrackStats();

1025 stats.AddStream(stream_);

1026

1027 // Constructs an ssrc stats update.

1028 cricket::VideoSenderInfo video_sender_info;

1029 cricket::VideoMediaInfo stats_read;

1030 const int64_t kBytesSent = 12345678901234LL;

1031

1032 // Construct a stats value to read.

1033 video_sender_info.add_ssrc(1234);

1034 video_sender_info.bytes_sent = kBytesSent;

1035 stats_read.senders.push_back(video_sender_info);

1036

1037 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1038 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1039 EXPECT_CALL(*media_channel, GetStats(_))

1040 .WillOnce(DoAll(SetArgPointee<0>(stats_read),

1041 Return(true)));

1042

1043 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1044 StatsReports reports;

1045 stats.GetStats(NULL, &reports);

1046 // \|reports\| should contain at least one session report, one track report,

1047 // and one ssrc report.

1048 EXPECT_LE((size_t)3, reports.size());

1049 const StatsReport* track_report = FindNthReportByType(

1050 reports, StatsReport::kStatsReportTypeTrack, 1);

1051 EXPECT_TRUE(track_report);

1052

1053 // Get report for the specific \|track\|.

1054 reports.clear();

1055 stats.GetStats(track_, &reports);

1056 // \|reports\| should contain at least one session report, one track report,

1057 // and one ssrc report.

1058 EXPECT_LE((size_t)3, reports.size());

1059 track_report = FindNthReportByType(

1060 reports, StatsReport::kStatsReportTypeTrack, 1);

1061 EXPECT_TRUE(track_report);

1062 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());

1063

1064 std::string ssrc_id = ExtractSsrcStatsValue(

1065 reports, StatsReport::kStatsValueNameSsrc);

1066 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);

1067

1068 std::string track_id = ExtractSsrcStatsValue(

1069 reports, StatsReport::kStatsValueNameTrackId);

1070 EXPECT_EQ(kLocalTrackId, track_id);

1071

1072 std::string media_type = ExtractSsrcStatsValue(reports,

1073 StatsReport::kStatsValueNameMediaType);

1074 EXPECT_EQ("video", media_type);

1075 }

1076

1077 // This test verifies that an SSRC object has the identifier of a Transport

1078 // stats object, and that this transport stats object exists in stats.

1079 TEST_F(StatsCollectorTest, TransportObjectLinkedFromSsrcObject) {

1080 StatsCollectorForTest stats(&pc_);

1081

1082 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1083 .WillRepeatedly(Return(false));

1084 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1085 .WillRepeatedly(Return(nullptr));

1086

1087 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1088 // The transport_name known by the video channel.

1089 const std::string kVcName("vcname");

1090 cricket::VideoChannel video_channel(

1091 worker_thread_, network_thread_, media_channel, nullptr, kVcName,

1092 kDefaultRtcpEnabled, kDefaultSrtpRequired);

1093 AddOutgoingVideoTrackStats();

1094 stats.AddStream(stream_);

1095

1096 // Constructs an ssrc stats update.

1097 cricket::VideoSenderInfo video_sender_info;

1098 cricket::VideoMediaInfo stats_read;

1099 const int64_t kBytesSent = 12345678901234LL;

1100

1101 // Construct a stats value to read.

1102 video_sender_info.add_ssrc(1234);

1103 video_sender_info.bytes_sent = kBytesSent;

1104 stats_read.senders.push_back(video_sender_info);

1105

1106 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1107 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1108 EXPECT_CALL(*media_channel, GetStats(_))

1109 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),

1110 Return(true)));

1111

1112 InitSessionStats(kVcName);

1113 EXPECT_CALL(session_, GetTransportStats(_))

1114 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1115 Return(true)));

1116

1117 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1118 StatsReports reports;

1119 stats.GetStats(NULL, &reports);

1120 std::string transport_id = ExtractStatsValue(

1121 StatsReport::kStatsReportTypeSsrc,

1122 reports,

1123 StatsReport::kStatsValueNameTransportId);

1124 ASSERT_NE(kNotFound, transport_id);

1125 // Transport id component ID will always be 1.

1126 // This has assumptions about how the ID is constructed. As is, this is

1127 // OK since this is for testing purposes only, but if we ever need this

1128 // in production, we should add a generic method that does this.

1129 size_t index = transport_id.find('-');

1130 ASSERT_NE(std::string::npos, index);

1131 std::string content = transport_id.substr(index + 1);

1132 index = content.rfind('-');

1133 ASSERT_NE(std::string::npos, index);

1134 content = content.substr(0, index);

1135 StatsReport::Id id(StatsReport::NewComponentId(content, 1));

1136 ASSERT_EQ(transport_id, id->ToString());

1137 const StatsReport* transport_report = FindReportById(reports, id);

1138 ASSERT_FALSE(transport_report == NULL);

1139 }

1140

1141 // This test verifies that a remote stats object will not be created for

1142 // an outgoing SSRC where remote stats are not returned.

1143 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsAbsent) {

1144 StatsCollectorForTest stats(&pc_);

1145

1146 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1147 // The transport_name known by the video channel.

1148 const std::string kVcName("vcname");

1149 cricket::VideoChannel video_channel(

1150 worker_thread_, network_thread_, media_channel, nullptr, kVcName,

1151 kDefaultRtcpEnabled, kDefaultSrtpRequired);

1152 AddOutgoingVideoTrackStats();

1153 stats.AddStream(stream_);

1154

1155 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1156 StatsReports reports;

1157 stats.GetStats(NULL, &reports);

1158 const StatsReport* remote_report = FindNthReportByType(reports,

1159 StatsReport::kStatsReportTypeRemoteSsrc, 1);

1160 EXPECT_TRUE(remote_report == NULL);

1161 }

1162

1163 // This test verifies that a remote stats object will be created for

1164 // an outgoing SSRC where stats are returned.

1165 TEST_F(StatsCollectorTest, RemoteSsrcInfoIsPresent) {

1166 StatsCollectorForTest stats(&pc_);

1167

1168 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1169 .WillRepeatedly(Return(false));

1170 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1171 .WillRepeatedly(Return(nullptr));

1172

1173 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1174 // The transport_name known by the video channel.

1175 const std::string kVcName("vcname");

1176 cricket::VideoChannel video_channel(

1177 worker_thread_, network_thread_, media_channel, nullptr, kVcName,

1178 kDefaultRtcpEnabled, kDefaultSrtpRequired);

1179 AddOutgoingVideoTrackStats();

1180 stats.AddStream(stream_);

1181

1182 // Instruct the session to return stats containing the transport channel.

1183 InitSessionStats(kVcName);

1184 EXPECT_CALL(session_, GetTransportStats(_))

1185 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1186 Return(true)));

1187

1188 // Constructs an ssrc stats update.

1189 cricket::VideoMediaInfo stats_read;

1190

1191 cricket::SsrcReceiverInfo remote_ssrc_stats;

1192 remote_ssrc_stats.timestamp = 12345.678;

1193 remote_ssrc_stats.ssrc = kSsrcOfTrack;

1194 cricket::VideoSenderInfo video_sender_info;

1195 video_sender_info.add_ssrc(kSsrcOfTrack);

1196 video_sender_info.remote_stats.push_back(remote_ssrc_stats);

1197 stats_read.senders.push_back(video_sender_info);

1198

1199 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1200 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1201 EXPECT_CALL(*media_channel, GetStats(_))

1202 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),

1203 Return(true)));

1204

1205 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1206 StatsReports reports;

1207 stats.GetStats(NULL, &reports);

1208

1209 const StatsReport* remote_report = FindNthReportByType(reports,

1210 StatsReport::kStatsReportTypeRemoteSsrc, 1);

1211 EXPECT_FALSE(remote_report == NULL);

1212 EXPECT_EQ(12345.678, remote_report->timestamp());

1213 }

1214

1215 // This test verifies that the empty track report exists in the returned stats

1216 // when StatsCollector::UpdateStats is called with ssrc stats.

1217 TEST_F(StatsCollectorTest, ReportsFromRemoteTrack) {

1218 StatsCollectorForTest stats(&pc_);

1219

1220 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1221 .WillRepeatedly(Return(false));

1222 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1223 .WillRepeatedly(Return(nullptr));

1224

1225 const char kVideoChannelName[] = "video";

1226 InitSessionStats(kVideoChannelName);

1227 EXPECT_CALL(session_, GetTransportStats(_))

1228 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1229 Return(true)));

1230

1231 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1232 cricket::VideoChannel video_channel(

1233 worker_thread_, network_thread_, media_channel, nullptr,

1234 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1235 AddIncomingVideoTrackStats();

1236 stats.AddStream(stream_);

1237

1238 // Constructs an ssrc stats update.

1239 cricket::VideoReceiverInfo video_receiver_info;

1240 cricket::VideoMediaInfo stats_read;

1241 const int64_t kNumOfPacketsConcealed = 54321;

1242

1243 // Construct a stats value to read.

1244 video_receiver_info.add_ssrc(1234);

1245 video_receiver_info.packets_concealed = kNumOfPacketsConcealed;

1246 stats_read.receivers.push_back(video_receiver_info);

1247

1248 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1249 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1250 EXPECT_CALL(*media_channel, GetStats(_))

1251 .WillOnce(DoAll(SetArgPointee<0>(stats_read),

1252 Return(true)));

1253

1254 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1255 StatsReports reports;

1256 stats.GetStats(NULL, &reports);

1257 // \|reports\| should contain at least one session report, one track report,

1258 // and one ssrc report.

1259 EXPECT_LE(static_cast<size_t>(3), reports.size());

1260 const StatsReport* track_report = FindNthReportByType(

1261 reports, StatsReport::kStatsReportTypeTrack, 1);

1262 EXPECT_TRUE(track_report);

1263 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());

1264

1265 std::string ssrc_id = ExtractSsrcStatsValue(

1266 reports, StatsReport::kStatsValueNameSsrc);

1267 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);

1268

1269 std::string track_id = ExtractSsrcStatsValue(

1270 reports, StatsReport::kStatsValueNameTrackId);

1271 EXPECT_EQ(kRemoteTrackId, track_id);

1272 }

1273

1274 // This test verifies the Ice Candidate report should contain the correct

1275 // information from local/remote candidates.

1276 TEST_F(StatsCollectorTest, IceCandidateReport) {

1277 StatsCollectorForTest stats(&pc_);

1278

1279 StatsReports reports; // returned values.

1280

1281 const int local_port = 2000;

1282 const char local_ip[] = "192.168.0.1";

1283 const int remote_port = 2001;

1284 const char remote_ip[] = "192.168.0.2";

1285

1286 rtc::SocketAddress local_address(local_ip, local_port);

1287 rtc::SocketAddress remote_address(remote_ip, remote_port);

1288 rtc::AdapterType network_type = rtc::ADAPTER_TYPE_ETHERNET;

1289 uint32_t priority = 1000;

1290

1291 cricket::Candidate c;

1292 ASSERT(c.id().length() > 0);

1293 c.set_type(cricket::LOCAL_PORT_TYPE);

1294 c.set_protocol(cricket::UDP_PROTOCOL_NAME);

1295 c.set_address(local_address);

1296 c.set_priority(priority);

1297 c.set_network_type(network_type);

1298 std::string report_id = AddCandidateReport(&stats, c, true)->id()->ToString();

1299 EXPECT_EQ("Cand-" + c.id(), report_id);

1300

1301 c = cricket::Candidate();

1302 ASSERT(c.id().length() > 0);

1303 c.set_type(cricket::PRFLX_PORT_TYPE);

1304 c.set_protocol(cricket::UDP_PROTOCOL_NAME);

1305 c.set_address(remote_address);

1306 c.set_priority(priority);

1307 c.set_network_type(network_type);

1308 report_id = AddCandidateReport(&stats, c, false)->id()->ToString();

1309 EXPECT_EQ("Cand-" + c.id(), report_id);

1310

1311 stats.GetStats(NULL, &reports);

1312

1313 // Verify the local candidate report is populated correctly.

1314 EXPECT_EQ(

1315 local_ip,

1316 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1317 StatsReport::kStatsValueNameCandidateIPAddress));

1318 EXPECT_EQ(

1319 rtc::ToString<int>(local_port),

1320 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1321 StatsReport::kStatsValueNameCandidatePortNumber));

1322 EXPECT_EQ(

1323 cricket::UDP_PROTOCOL_NAME,

1324 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1325 StatsReport::kStatsValueNameCandidateTransportType));

1326 EXPECT_EQ(

1327 rtc::ToString<int>(priority),

1328 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1329 StatsReport::kStatsValueNameCandidatePriority));

1330 EXPECT_EQ(

1331 IceCandidateTypeToStatsType(cricket::LOCAL_PORT_TYPE),

1332 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1333 StatsReport::kStatsValueNameCandidateType));

1334 EXPECT_EQ(

1335 AdapterTypeToStatsType(network_type),

1336 ExtractStatsValue(StatsReport::kStatsReportTypeIceLocalCandidate, reports,

1337 StatsReport::kStatsValueNameCandidateNetworkType));

1338

1339 // Verify the remote candidate report is populated correctly.

1340 EXPECT_EQ(remote_ip,

1341 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,

1342 reports,

1343 StatsReport::kStatsValueNameCandidateIPAddress));

1344 EXPECT_EQ(rtc::ToString<int>(remote_port),

1345 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,

1346 reports,

1347 StatsReport::kStatsValueNameCandidatePortNumber));

1348 EXPECT_EQ(cricket::UDP_PROTOCOL_NAME,

1349 ExtractStatsValue(

1350 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,

1351 StatsReport::kStatsValueNameCandidateTransportType));

1352 EXPECT_EQ(rtc::ToString<int>(priority),

1353 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,

1354 reports,

1355 StatsReport::kStatsValueNameCandidatePriority));

1356 EXPECT_EQ(

1357 IceCandidateTypeToStatsType(cricket::PRFLX_PORT_TYPE),

1358 ExtractStatsValue(StatsReport::kStatsReportTypeIceRemoteCandidate,

1359 reports, StatsReport::kStatsValueNameCandidateType));

1360 EXPECT_EQ(kNotFound,

1361 ExtractStatsValue(

1362 StatsReport::kStatsReportTypeIceRemoteCandidate, reports,

1363 StatsReport::kStatsValueNameCandidateNetworkType));

1364 }

1365

1366 // This test verifies that all chained certificates are correctly

1367 // reported

1368 TEST_F(StatsCollectorTest, ChainedCertificateReportsCreated) {

1369 // Build local certificate chain.

1370 std::vector<std::string> local_ders(5);

1371 local_ders[0] = "These";

1372 local_ders[1] = "are";

1373 local_ders[2] = "some";

1374 local_ders[3] = "der";

1375 local_ders[4] = "values";

1376 rtc::FakeSSLCertificate local_cert(DersToPems(local_ders));

1377

1378 // Build remote certificate chain

1379 std::vector<std::string> remote_ders(4);

1380 remote_ders[0] = "A";

1381 remote_ders[1] = "non-";

1382 remote_ders[2] = "intersecting";

1383 remote_ders[3] = "set";

1384 std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(

1385 new rtc::FakeSSLCertificate(DersToPems(remote_ders)));

1386

1387 TestCertificateReports(local_cert, local_ders, std::move(remote_cert),

1388 remote_ders);

1389 }

1390

1391 // This test verifies that all certificates without chains are correctly

1392 // reported.

1393 TEST_F(StatsCollectorTest, ChainlessCertificateReportsCreated) {

1394 // Build local certificate.

1395 std::string local_der = "This is the local der.";

1396 rtc::FakeSSLCertificate local_cert(DerToPem(local_der));

1397

1398 // Build remote certificate.

1399 std::string remote_der = "This is somebody else's der.";

1400 std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(

1401 new rtc::FakeSSLCertificate(DerToPem(remote_der)));

1402

1403 TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),

1404 std::move(remote_cert),

1405 std::vector<std::string>(1, remote_der));

1406 }

1407

1408 // This test verifies that the stats are generated correctly when no

1409 // transport is present.

1410 TEST_F(StatsCollectorTest, NoTransport) {

1411 StatsCollectorForTest stats(&pc_);

1412

1413 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1414 .WillRepeatedly(Return(false));

1415 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1416 .WillRepeatedly(Return(nullptr));

1417

1418 StatsReports reports; // returned values.

1419

1420 // Fake stats to process.

1421 cricket::TransportChannelStats channel_stats;

1422 channel_stats.component = 1;

1423

1424 cricket::TransportStats transport_stats;

1425 transport_stats.transport_name = "audio";

1426 transport_stats.channel_stats.push_back(channel_stats);

1427

1428 SessionStats session_stats;

1429 session_stats.transport_stats[transport_stats.transport_name] =

1430 transport_stats;

1431

1432 // Configure MockWebRtcSession

1433 EXPECT_CALL(session_, GetTransportStats(_))

1434 .WillOnce(DoAll(SetArgPointee<0>(session_stats),

1435 Return(true)));

1436

1437 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1438 stats.GetStats(NULL, &reports);

1439

1440 // Check that the local certificate is absent.

1441 std::string local_certificate_id = ExtractStatsValue(

1442 StatsReport::kStatsReportTypeComponent,

1443 reports,

1444 StatsReport::kStatsValueNameLocalCertificateId);

1445 ASSERT_EQ(kNotFound, local_certificate_id);

1446

1447 // Check that the remote certificate is absent.

1448 std::string remote_certificate_id = ExtractStatsValue(

1449 StatsReport::kStatsReportTypeComponent,

1450 reports,

1451 StatsReport::kStatsValueNameRemoteCertificateId);

1452 ASSERT_EQ(kNotFound, remote_certificate_id);

1453

1454 // Check that the negotiated ciphers are absent.

1455 std::string dtls_cipher_suite =

1456 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,

1457 StatsReport::kStatsValueNameDtlsCipher);

1458 ASSERT_EQ(kNotFound, dtls_cipher_suite);

1459 std::string srtp_crypto_suite =

1460 ExtractStatsValue(StatsReport::kStatsReportTypeComponent, reports,

1461 StatsReport::kStatsValueNameSrtpCipher);

1462 ASSERT_EQ(kNotFound, srtp_crypto_suite);

1463 }

1464

1465 // This test verifies that the stats are generated correctly when the transport

1466 // does not have any certificates.

1467 TEST_F(StatsCollectorTest, NoCertificates) {

1468 StatsCollectorForTest stats(&pc_);

1469

1470 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1471 .WillRepeatedly(Return(false));

1472 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1473 .WillRepeatedly(Return(nullptr));

1474

1475 StatsReports reports; // returned values.

1476

1477 // Fake stats to process.

1478 cricket::TransportChannelStats channel_stats;

1479 channel_stats.component = 1;

1480

1481 cricket::TransportStats transport_stats;

1482 transport_stats.transport_name = "audio";

1483 transport_stats.channel_stats.push_back(channel_stats);

1484

1485 SessionStats session_stats;

1486 session_stats.transport_stats[transport_stats.transport_name] =

1487 transport_stats;

1488

1489 // Configure MockWebRtcSession

1490 EXPECT_CALL(session_, GetTransportStats(_))

1491 .WillOnce(DoAll(SetArgPointee<0>(session_stats),

1492 Return(true)));

1493 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1494 stats.GetStats(NULL, &reports);

1495

1496 // Check that the local certificate is absent.

1497 std::string local_certificate_id = ExtractStatsValue(

1498 StatsReport::kStatsReportTypeComponent,

1499 reports,

1500 StatsReport::kStatsValueNameLocalCertificateId);

1501 ASSERT_EQ(kNotFound, local_certificate_id);

1502

1503 // Check that the remote certificate is absent.

1504 std::string remote_certificate_id = ExtractStatsValue(

1505 StatsReport::kStatsReportTypeComponent,

1506 reports,

1507 StatsReport::kStatsValueNameRemoteCertificateId);

1508 ASSERT_EQ(kNotFound, remote_certificate_id);

1509 }

1510

1511 // This test verifies that a remote certificate with an unsupported digest

1512 // algorithm is correctly ignored.

1513 TEST_F(StatsCollectorTest, UnsupportedDigestIgnored) {

1514 // Build a local certificate.

1515 std::string local_der = "This is the local der.";

1516 rtc::FakeSSLCertificate local_cert(DerToPem(local_der));

1517

1518 // Build a remote certificate with an unsupported digest algorithm.

1519 std::string remote_der = "This is somebody else's der.";

1520 std::unique_ptr<rtc::FakeSSLCertificate> remote_cert(

1521 new rtc::FakeSSLCertificate(DerToPem(remote_der)));

1522 remote_cert->set_digest_algorithm("foobar");

1523

1524 TestCertificateReports(local_cert, std::vector<std::string>(1, local_der),

1525 std::move(remote_cert), std::vector<std::string>());

1526 }

1527

1528 // This test verifies that the audio/video related stats which are -1 initially

1529 // will be filtered out.

1530 TEST_F(StatsCollectorTest, FilterOutNegativeInitialValues) {

1531 StatsCollectorForTest stats(&pc_);

1532

1533 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1534 .WillRepeatedly(Return(false));

1535 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1536 .WillRepeatedly(Return(nullptr));

1537

1538 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1539 // The transport_name known by the voice channel.

1540 const std::string kVcName("vcname");

1541 cricket::VoiceChannel voice_channel(

1542 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1543 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1544

1545 // Create a local stream with a local audio track and adds it to the stats.

1546 if (stream_ == NULL)

1547 stream_ = webrtc::MediaStream::Create("streamlabel");

1548

1549 rtc::scoped_refptr<FakeAudioTrackWithInitValue> local_track(

1550 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kLocalTrackId));

1551 stream_->AddTrack(local_track);

1552 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))

1553 .WillOnce(DoAll(SetArgPointee<1>(kLocalTrackId), Return(true)));

1554 stats.AddStream(stream_);

1555 stats.AddLocalAudioTrack(local_track.get(), kSsrcOfTrack);

1556

1557 // Create a remote stream with a remote audio track and adds it to the stats.

1558 rtc::scoped_refptr<webrtc::MediaStream> remote_stream(

1559 webrtc::MediaStream::Create("remotestreamlabel"));

1560 rtc::scoped_refptr<FakeAudioTrackWithInitValue> remote_track(

1561 new rtc::RefCountedObject<FakeAudioTrackWithInitValue>(kRemoteTrackId));

1562 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))

1563 .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));

1564 remote_stream->AddTrack(remote_track);

1565 stats.AddStream(remote_stream);

1566

1567 // Instruct the session to return stats containing the transport channel.

1568 InitSessionStats(kVcName);

1569 EXPECT_CALL(session_, GetTransportStats(_))

1570 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_), Return(true)));

1571

1572 cricket::VoiceSenderInfo voice_sender_info;

1573 voice_sender_info.add_ssrc(kSsrcOfTrack);

1574 // These values are set to -1 initially in audio_send_stream.

1575 // The voice_sender_info will read the values from audio_send_stream.

1576 voice_sender_info.rtt_ms = -1;

1577 voice_sender_info.packets_lost = -1;

1578 voice_sender_info.jitter_ms = -1;

1579

1580 // Some of the contents in \|voice_sender_info\| needs to be updated from the

1581 // \|audio_track_\|.

1582 UpdateVoiceSenderInfoFromAudioTrack(local_track.get(), &voice_sender_info);

1583

1584 cricket::VoiceReceiverInfo voice_receiver_info;

1585 voice_receiver_info.add_ssrc(kSsrcOfTrack);

1586 voice_receiver_info.capture_start_ntp_time_ms = -1;

1587 voice_receiver_info.audio_level = -1;

1588

1589 // Constructs an ssrc stats update.

1590 cricket::VoiceMediaInfo stats_read;

1591 stats_read.senders.push_back(voice_sender_info);

1592 stats_read.receivers.push_back(voice_receiver_info);

1593

1594 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));

1595 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());

1596 EXPECT_CALL(*media_channel, GetStats(_))

1597 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read), Return(true)));

1598

1599 StatsReports reports;

1600 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1601

1602 // Get stats for the local track.

1603 stats.GetStats(local_track.get(), &reports);

1604 const StatsReport* report =

1605 FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);

1606 EXPECT_TRUE(report);

1607 // The -1 will not be added to the stats report.

1608 std::string value_in_report;

1609 EXPECT_FALSE(

1610 GetValue(report, StatsReport::kStatsValueNameRtt, &value_in_report));

1611 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNamePacketsLost,

1612 &value_in_report));

1613 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameJitterReceived,

1614 &value_in_report));

1615 EXPECT_FALSE(GetValue(report,

1616 StatsReport::kStatsValueNameEchoCancellationQualityMin,

1617 &value_in_report));

1618 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayMedian,

1619 &value_in_report));

1620 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameEchoDelayStdDev,

1621 &value_in_report));

1622

1623 // Get stats for the remote track.

1624 reports.clear();

1625 stats.GetStats(remote_track.get(), &reports);

1626 report = FindNthReportByType(reports, StatsReport::kStatsReportTypeSsrc, 1);

1627 EXPECT_TRUE(report);

1628 EXPECT_FALSE(GetValue(report,

1629 StatsReport::kStatsValueNameCaptureStartNtpTimeMs,

1630 &value_in_report));

1631 EXPECT_FALSE(GetValue(report, StatsReport::kStatsValueNameAudioInputLevel,

1632 &value_in_report));

1633 }

1634

1635 // This test verifies that a local stats object can get statistics via

1636 // AudioTrackInterface::GetStats() method.

1637 TEST_F(StatsCollectorTest, GetStatsFromLocalAudioTrack) {

1638 StatsCollectorForTest stats(&pc_);

1639

1640 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1641 .WillRepeatedly(Return(false));

1642 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1643 .WillRepeatedly(Return(nullptr));

1644

1645 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1646 // The transport_name known by the voice channel.

1647 const std::string kVcName("vcname");

1648 cricket::VoiceChannel voice_channel(

1649 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1650 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1651 AddOutgoingAudioTrackStats();

1652 stats.AddStream(stream_);

1653 stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);

1654

1655 cricket::VoiceSenderInfo voice_sender_info;

1656 InitVoiceSenderInfo(&voice_sender_info);

1657

1658 cricket::VoiceMediaInfo stats_read;

1659 StatsReports reports; // returned values.

1660 SetupAndVerifyAudioTrackStats(

1661 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,

1662 media_channel, &voice_sender_info, NULL, &stats_read, &reports);

1663

1664 // Verify that there is no remote report for the local audio track because

1665 // we did not set it up.

1666 const StatsReport* remote_report = FindNthReportByType(reports,

1667 StatsReport::kStatsReportTypeRemoteSsrc, 1);

1668 EXPECT_TRUE(remote_report == NULL);

1669 }

1670

1671 // This test verifies that audio receive streams populate stats reports

1672 // correctly.

1673 TEST_F(StatsCollectorTest, GetStatsFromRemoteStream) {

1674 StatsCollectorForTest stats(&pc_);

1675

1676 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1677 .WillRepeatedly(Return(false));

1678 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1679 .WillRepeatedly(Return(nullptr));

1680

1681 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1682 // The transport_name known by the voice channel.

1683 const std::string kVcName("vcname");

1684 cricket::VoiceChannel voice_channel(

1685 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1686 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1687 AddIncomingAudioTrackStats();

1688 stats.AddStream(stream_);

1689

1690 cricket::VoiceReceiverInfo voice_receiver_info;

1691 InitVoiceReceiverInfo(&voice_receiver_info);

1692 voice_receiver_info.codec_name = "fake_codec";

1693

1694 cricket::VoiceMediaInfo stats_read;

1695 StatsReports reports; // returned values.

1696 SetupAndVerifyAudioTrackStats(

1697 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,

1698 media_channel, NULL, &voice_receiver_info, &stats_read, &reports);

1699 }

1700

1701 // This test verifies that a local stats object won't update its statistics

1702 // after a RemoveLocalAudioTrack() call.

1703 TEST_F(StatsCollectorTest, GetStatsAfterRemoveAudioStream) {

1704 StatsCollectorForTest stats(&pc_);

1705

1706 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1707 .WillRepeatedly(Return(false));

1708 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1709 .WillRepeatedly(Return(nullptr));

1710

1711 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1712 // The transport_name known by the voice channel.

1713 const std::string kVcName("vcname");

1714 cricket::VoiceChannel voice_channel(

1715 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1716 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1717 AddOutgoingAudioTrackStats();

1718 stats.AddStream(stream_);

1719 stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);

1720

1721 // Instruct the session to return stats containing the transport channel.

1722 InitSessionStats(kVcName);

1723 EXPECT_CALL(session_, GetTransportStats(_))

1724 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1725 Return(true)));

1726

1727 stats.RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);

1728 cricket::VoiceSenderInfo voice_sender_info;

1729 InitVoiceSenderInfo(&voice_sender_info);

1730

1731 // Constructs an ssrc stats update.

1732 cricket::VoiceMediaInfo stats_read;

1733 stats_read.senders.push_back(voice_sender_info);

1734

1735 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));

1736 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());

1737 EXPECT_CALL(*media_channel, GetStats(_))

1738 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),

1739 Return(true)));

1740

1741 StatsReports reports; // returned values.

1742 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1743 stats.GetStats(NULL, &reports);

1744

1745 // The report will exist since we don't remove them in RemoveStream().

1746 const StatsReport* report = FindNthReportByType(

1747 reports, StatsReport::kStatsReportTypeSsrc, 1);

1748 EXPECT_FALSE(report == NULL);

1749 EXPECT_EQ(stats.GetTimeNow(), report->timestamp());

1750 std::string track_id = ExtractSsrcStatsValue(

1751 reports, StatsReport::kStatsValueNameTrackId);

1752 EXPECT_EQ(kLocalTrackId, track_id);

1753 std::string ssrc_id = ExtractSsrcStatsValue(

1754 reports, StatsReport::kStatsValueNameSsrc);

1755 EXPECT_EQ(rtc::ToString<uint32_t>(kSsrcOfTrack), ssrc_id);

1756

1757 // Verifies the values in the track report, no value will be changed by the

1758 // AudioTrackInterface::GetSignalValue() and

1759 // AudioProcessorInterface::AudioProcessorStats::GetStats();

1760 VerifyVoiceSenderInfoReport(report, voice_sender_info);

1761 }

1762

1763 // This test verifies that when ongoing and incoming audio tracks are using

1764 // the same ssrc, they populate stats reports correctly.

1765 TEST_F(StatsCollectorTest, LocalAndRemoteTracksWithSameSsrc) {

1766 StatsCollectorForTest stats(&pc_);

1767

1768 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1769 .WillRepeatedly(Return(false));

1770 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1771 .WillRepeatedly(Return(nullptr));

1772

1773 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1774 // The transport_name known by the voice channel.

1775 const std::string kVcName("vcname");

1776 cricket::VoiceChannel voice_channel(

1777 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1778 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1779

1780 // Create a local stream with a local audio track and adds it to the stats.

1781 AddOutgoingAudioTrackStats();

1782 stats.AddStream(stream_);

1783 stats.AddLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);

1784

1785 // Create a remote stream with a remote audio track and adds it to the stats.

1786 rtc::scoped_refptr<webrtc::MediaStream> remote_stream(

1787 webrtc::MediaStream::Create("remotestreamlabel"));

1788 rtc::scoped_refptr<FakeAudioTrack> remote_track(

1789 new rtc::RefCountedObject<FakeAudioTrack>(kRemoteTrackId));

1790 EXPECT_CALL(session_, GetRemoteTrackIdBySsrc(kSsrcOfTrack, _))

1791 .WillOnce(DoAll(SetArgPointee<1>(kRemoteTrackId), Return(true)));

1792 remote_stream->AddTrack(remote_track);

1793 stats.AddStream(remote_stream);

1794

1795 // Instruct the session to return stats containing the transport channel.

1796 InitSessionStats(kVcName);

1797 EXPECT_CALL(session_, GetTransportStats(_))

1798 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_),

1799 Return(true)));

1800

1801 cricket::VoiceSenderInfo voice_sender_info;

1802 InitVoiceSenderInfo(&voice_sender_info);

1803

1804 // Some of the contents in \|voice_sender_info\| needs to be updated from the

1805 // \|audio_track_\|.

1806 UpdateVoiceSenderInfoFromAudioTrack(audio_track_.get(), &voice_sender_info);

1807

1808 cricket::VoiceReceiverInfo voice_receiver_info;

1809 InitVoiceReceiverInfo(&voice_receiver_info);

1810

1811 // Constructs an ssrc stats update.

1812 cricket::VoiceMediaInfo stats_read;

1813 stats_read.senders.push_back(voice_sender_info);

1814 stats_read.receivers.push_back(voice_receiver_info);

1815

1816 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(Return(&voice_channel));

1817 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull());

1818 EXPECT_CALL(*media_channel, GetStats(_))

1819 .WillRepeatedly(DoAll(SetArgPointee<0>(stats_read),

1820 Return(true)));

1821

1822 StatsReports reports; // returned values.

1823 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1824

1825 // Get stats for the local track.

1826 stats.GetStats(audio_track_.get(), &reports);

1827 const StatsReport* track_report = FindNthReportByType(

1828 reports, StatsReport::kStatsReportTypeSsrc, 1);

1829 EXPECT_TRUE(track_report);

1830 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());

1831 std::string track_id = ExtractSsrcStatsValue(

1832 reports, StatsReport::kStatsValueNameTrackId);

1833 EXPECT_EQ(kLocalTrackId, track_id);

1834 VerifyVoiceSenderInfoReport(track_report, voice_sender_info);

1835

1836 // Get stats for the remote track.

1837 reports.clear();

1838 stats.GetStats(remote_track.get(), &reports);

1839 track_report = FindNthReportByType(reports,

1840 StatsReport::kStatsReportTypeSsrc, 1);

1841 EXPECT_TRUE(track_report);

1842 EXPECT_EQ(stats.GetTimeNow(), track_report->timestamp());

1843 track_id = ExtractSsrcStatsValue(reports,

1844 StatsReport::kStatsValueNameTrackId);

1845 EXPECT_EQ(kRemoteTrackId, track_id);

1846 VerifyVoiceReceiverInfoReport(track_report, voice_receiver_info);

1847 }

1848

1849 // This test verifies that when two outgoing audio tracks are using the same

1850 // ssrc at different times, they populate stats reports correctly.

1851 // TODO(xians): Figure out if it is possible to encapsulate the setup and

1852 // avoid duplication of code in test cases.

1853 TEST_F(StatsCollectorTest, TwoLocalTracksWithSameSsrc) {

1854 StatsCollectorForTest stats(&pc_);

1855

1856 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1857 .WillRepeatedly(Return(false));

1858 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1859 .WillRepeatedly(Return(nullptr));

1860

1861 MockVoiceMediaChannel* media_channel = new MockVoiceMediaChannel();

1862 // The transport_name known by the voice channel.

1863 const std::string kVcName("vcname");

1864 cricket::VoiceChannel voice_channel(

1865 worker_thread_, network_thread_, media_engine_, media_channel, nullptr,

1866 kVcName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1867

1868 // Create a local stream with a local audio track and adds it to the stats.

1869 AddOutgoingAudioTrackStats();

1870 stats.AddStream(stream_);

1871 stats.AddLocalAudioTrack(audio_track_, kSsrcOfTrack);

1872

1873 cricket::VoiceSenderInfo voice_sender_info;

1874 voice_sender_info.add_ssrc(kSsrcOfTrack);

1875

1876 cricket::VoiceMediaInfo stats_read;

1877 StatsReports reports; // returned values.

1878 SetupAndVerifyAudioTrackStats(

1879 audio_track_.get(), stream_.get(), &stats, &voice_channel, kVcName,

1880 media_channel, &voice_sender_info, NULL, &stats_read, &reports);

1881

1882 // Remove the previous audio track from the stream.

1883 stream_->RemoveTrack(audio_track_.get());

1884 stats.RemoveLocalAudioTrack(audio_track_.get(), kSsrcOfTrack);

1885

1886 // Create a new audio track and adds it to the stream and stats.

1887 static const std::string kNewTrackId = "new_track_id";

1888 rtc::scoped_refptr<FakeAudioTrack> new_audio_track(

1889 new rtc::RefCountedObject<FakeAudioTrack>(kNewTrackId));

1890 EXPECT_CALL(session_, GetLocalTrackIdBySsrc(kSsrcOfTrack, _))

1891 .WillOnce(DoAll(SetArgPointee<1>(kNewTrackId), Return(true)));

1892 stream_->AddTrack(new_audio_track);

1893

1894 stats.AddLocalAudioTrack(new_audio_track, kSsrcOfTrack);

1895 stats.ClearUpdateStatsCacheForTest();

1896 cricket::VoiceSenderInfo new_voice_sender_info;

1897 InitVoiceSenderInfo(&new_voice_sender_info);

1898 cricket::VoiceMediaInfo new_stats_read;

1899 reports.clear();

1900 SetupAndVerifyAudioTrackStats(

1901 new_audio_track.get(), stream_.get(), &stats, &voice_channel, kVcName,

1902 media_channel, &new_voice_sender_info, NULL, &new_stats_read, &reports);

1903 }

1904

1905 // This test verifies that stats are correctly set in video send ssrc stats.

1906 TEST_F(StatsCollectorTest, VerifyVideoSendSsrcStats) {

1907 StatsCollectorForTest stats(&pc_);

1908

1909 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1910 .WillRepeatedly(Return(false));

1911 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1912 .WillRepeatedly(Return(nullptr));

1913

1914 const char kVideoChannelName[] = "video";

1915

1916 InitSessionStats(kVideoChannelName);

1917 EXPECT_CALL(session_, GetTransportStats(_))

1918 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_), Return(true)));

1919

1920 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1921 cricket::VideoChannel video_channel(

1922 worker_thread_, network_thread_, media_channel, nullptr,

1923 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1924 StatsReports reports; // returned values.

1925 cricket::VideoSenderInfo video_sender_info;

1926 cricket::VideoMediaInfo stats_read;

1927

1928 AddOutgoingVideoTrackStats();

1929 stats.AddStream(stream_);

1930

1931 // Construct a stats value to read.

1932 video_sender_info.add_ssrc(1234);

1933 video_sender_info.frames_encoded = 10;

1934 video_sender_info.qp_sum = rtc::Optional<uint64_t>(11);

1935 stats_read.senders.push_back(video_sender_info);

1936

1937 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1938 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1939 EXPECT_CALL(*media_channel, GetStats(_))

1940 .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));

1941 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1942 stats.GetStats(NULL, &reports);

1943 EXPECT_EQ(rtc::ToString(video_sender_info.frames_encoded),

1944 ExtractSsrcStatsValue(reports,

1945 StatsReport::kStatsValueNameFramesEncoded));

1946 EXPECT_EQ(rtc::ToString(*video_sender_info.qp_sum),

1947 ExtractSsrcStatsValue(reports, StatsReport::kStatsValueNameQpSum));

1948 }

1949

1950 // This test verifies that stats are correctly set in video receive ssrc stats.

1951 TEST_F(StatsCollectorTest, VerifyVideoReceiveSsrcStats) {

1952 StatsCollectorForTest stats(&pc_);

1953

1954 EXPECT_CALL(session_, GetLocalCertificate(_, _))

1955 .WillRepeatedly(Return(false));

1956 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_))

1957 .WillRepeatedly(Return(nullptr));

1958

1959 const char kVideoChannelName[] = "video";

1960

1961 InitSessionStats(kVideoChannelName);

1962 EXPECT_CALL(session_, GetTransportStats(_))

1963 .WillRepeatedly(DoAll(SetArgPointee<0>(session_stats_), Return(true)));

1964

1965 MockVideoMediaChannel* media_channel = new MockVideoMediaChannel();

1966 cricket::VideoChannel video_channel(

1967 worker_thread_, network_thread_, media_channel, nullptr,

1968 kVideoChannelName, kDefaultRtcpEnabled, kDefaultSrtpRequired);

1969 StatsReports reports; // returned values.

1970 cricket::VideoReceiverInfo video_receiver_info;

1971 cricket::VideoMediaInfo stats_read;

1972

1973 AddIncomingVideoTrackStats();

1974 stats.AddStream(stream_);

1975

1976 // Construct a stats value to read.

1977 video_receiver_info.add_ssrc(1234);

1978 video_receiver_info.frames_decoded = 10;

1979 stats_read.receivers.push_back(video_receiver_info);

1980

1981 EXPECT_CALL(session_, video_channel()).WillRepeatedly(Return(&video_channel));

1982 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull());

1983 EXPECT_CALL(*media_channel, GetStats(_))

1984 .WillOnce(DoAll(SetArgPointee<0>(stats_read), Return(true)));

1985 stats.UpdateStats(PeerConnectionInterface::kStatsOutputLevelStandard);

1986 stats.GetStats(NULL, &reports);

1987 EXPECT_EQ(rtc::ToString(video_receiver_info.frames_decoded),

1988 ExtractSsrcStatsValue(reports,

1989 StatsReport::kStatsValueNameFramesDecoded));

1990 }

1991

1992 } // namespace webrtc

OLD	NEW

« webrtc/api/jsepsessiondescription.h ('K') | « webrtc/api/statscollector.cc ('k') | webrtc/api/statstypes.h » ('j') | webrtc/pc/DEPS » ('J')