OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2016 The WebRTC project authors. All Rights Reserved. | 2 * Copyright 2016 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
(...skipping 267 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
278 RTCStatsCollectorTestHelper() | 278 RTCStatsCollectorTestHelper() |
279 : worker_thread_(rtc::Thread::Current()), | 279 : worker_thread_(rtc::Thread::Current()), |
280 network_thread_(rtc::Thread::Current()), | 280 network_thread_(rtc::Thread::Current()), |
281 signaling_thread_(rtc::Thread::Current()), | 281 signaling_thread_(rtc::Thread::Current()), |
282 media_engine_(new cricket::FakeMediaEngine()), | 282 media_engine_(new cricket::FakeMediaEngine()), |
283 channel_manager_(new cricket::ChannelManager( | 283 channel_manager_(new cricket::ChannelManager( |
284 std::unique_ptr<cricket::MediaEngineInterface>(media_engine_), | 284 std::unique_ptr<cricket::MediaEngineInterface>(media_engine_), |
285 worker_thread_, | 285 worker_thread_, |
286 network_thread_)), | 286 network_thread_)), |
287 session_(channel_manager_.get(), cricket::MediaConfig()), | 287 session_(channel_manager_.get(), cricket::MediaConfig()), |
288 pc_() { | 288 pc_(new rtc::RefCountedObject<MockPeerConnection>()) { |
289 // Default return values for mocks. | 289 // Default return values for mocks. |
290 EXPECT_CALL(pc_, local_streams()).WillRepeatedly(Return(nullptr)); | 290 EXPECT_CALL(*pc_, local_streams()).WillRepeatedly(Return(nullptr)); |
291 EXPECT_CALL(pc_, remote_streams()).WillRepeatedly(Return(nullptr)); | 291 EXPECT_CALL(*pc_, remote_streams()).WillRepeatedly(Return(nullptr)); |
292 EXPECT_CALL(pc_, session()).WillRepeatedly(Return(&session_)); | 292 EXPECT_CALL(*pc_, session()).WillRepeatedly(Return(&session_)); |
293 EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return( | 293 EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return( |
294 std::vector<rtc::scoped_refptr<RtpSenderInterface>>())); | 294 std::vector<rtc::scoped_refptr<RtpSenderInterface>>())); |
295 EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return( | 295 EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return( |
296 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>())); | 296 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>())); |
297 EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly( | 297 EXPECT_CALL(*pc_, sctp_data_channels()).WillRepeatedly( |
298 ReturnRef(data_channels_)); | 298 ReturnRef(data_channels_)); |
299 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull()); | 299 EXPECT_CALL(session_, video_channel()).WillRepeatedly(ReturnNull()); |
300 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull()); | 300 EXPECT_CALL(session_, voice_channel()).WillRepeatedly(ReturnNull()); |
301 EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull()); | 301 EXPECT_CALL(session_, GetStats(_)).WillRepeatedly(ReturnNull()); |
302 EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly( | 302 EXPECT_CALL(session_, GetLocalCertificate(_, _)).WillRepeatedly( |
303 Return(false)); | 303 Return(false)); |
304 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_)) | 304 EXPECT_CALL(session_, GetRemoteSSLCertificate_ReturnsRawPointer(_)) |
305 .WillRepeatedly(Return(nullptr)); | 305 .WillRepeatedly(Return(nullptr)); |
306 } | 306 } |
307 | 307 |
308 rtc::ScopedFakeClock& fake_clock() { return fake_clock_; } | 308 rtc::ScopedFakeClock& fake_clock() { return fake_clock_; } |
309 rtc::Thread* worker_thread() { return worker_thread_; } | 309 rtc::Thread* worker_thread() { return worker_thread_; } |
310 rtc::Thread* network_thread() { return network_thread_; } | 310 rtc::Thread* network_thread() { return network_thread_; } |
311 rtc::Thread* signaling_thread() { return signaling_thread_; } | 311 rtc::Thread* signaling_thread() { return signaling_thread_; } |
312 cricket::FakeMediaEngine* media_engine() { return media_engine_; } | 312 cricket::FakeMediaEngine* media_engine() { return media_engine_; } |
313 MockWebRtcSession& session() { return session_; } | 313 MockWebRtcSession& session() { return session_; } |
314 MockPeerConnection& pc() { return pc_; } | 314 MockPeerConnection& pc() { return *pc_; } |
315 std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() { | 315 std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() { |
316 return data_channels_; | 316 return data_channels_; |
317 } | 317 } |
318 | 318 |
319 // SetSessionDescriptionObserver overrides. | 319 // SetSessionDescriptionObserver overrides. |
320 void OnSuccess() override {} | 320 void OnSuccess() override {} |
321 void OnFailure(const std::string& error) override { | 321 void OnFailure(const std::string& error) override { |
322 RTC_NOTREACHED() << error; | 322 RTC_NOTREACHED() << error; |
323 } | 323 } |
324 | 324 |
325 void SetupLocalTrackAndSender(cricket::MediaType media_type, | 325 void SetupLocalTrackAndSender(cricket::MediaType media_type, |
326 const std::string& track_id, | 326 const std::string& track_id, |
327 uint32_t ssrc) { | 327 uint32_t ssrc) { |
328 rtc::scoped_refptr<StreamCollection> local_streams = | 328 rtc::scoped_refptr<StreamCollection> local_streams = |
329 StreamCollection::Create(); | 329 StreamCollection::Create(); |
330 EXPECT_CALL(pc_, local_streams()) | 330 EXPECT_CALL(*pc_, local_streams()) |
331 .WillRepeatedly(Return(local_streams)); | 331 .WillRepeatedly(Return(local_streams)); |
332 | 332 |
333 rtc::scoped_refptr<MediaStream> local_stream = | 333 rtc::scoped_refptr<MediaStream> local_stream = |
334 MediaStream::Create("LocalStreamLabel"); | 334 MediaStream::Create("LocalStreamLabel"); |
335 local_streams->AddStream(local_stream); | 335 local_streams->AddStream(local_stream); |
336 | 336 |
337 rtc::scoped_refptr<MediaStreamTrackInterface> track; | 337 rtc::scoped_refptr<MediaStreamTrackInterface> track; |
338 if (media_type == cricket::MEDIA_TYPE_AUDIO) { | 338 if (media_type == cricket::MEDIA_TYPE_AUDIO) { |
339 track = CreateFakeTrack(media_type, track_id, | 339 track = CreateFakeTrack(media_type, track_id, |
340 MediaStreamTrackInterface::kLive); | 340 MediaStreamTrackInterface::kLive); |
341 local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); | 341 local_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); |
342 } else { | 342 } else { |
343 track = CreateFakeTrack(media_type, track_id, | 343 track = CreateFakeTrack(media_type, track_id, |
344 MediaStreamTrackInterface::kLive); | 344 MediaStreamTrackInterface::kLive); |
345 local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get())); | 345 local_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get())); |
346 } | 346 } |
347 | 347 |
348 rtc::scoped_refptr<MockRtpSender> sender = CreateMockSender(track, ssrc); | 348 rtc::scoped_refptr<MockRtpSender> sender = CreateMockSender(track, ssrc); |
349 EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return( | 349 EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return( |
350 std::vector<rtc::scoped_refptr<RtpSenderInterface>>({ | 350 std::vector<rtc::scoped_refptr<RtpSenderInterface>>({ |
351 rtc::scoped_refptr<RtpSenderInterface>(sender.get()) }))); | 351 rtc::scoped_refptr<RtpSenderInterface>(sender.get()) }))); |
352 } | 352 } |
353 | 353 |
354 void SetupRemoteTrackAndReceiver(cricket::MediaType media_type, | 354 void SetupRemoteTrackAndReceiver(cricket::MediaType media_type, |
355 const std::string& track_id, | 355 const std::string& track_id, |
356 uint32_t ssrc) { | 356 uint32_t ssrc) { |
357 rtc::scoped_refptr<StreamCollection> remote_streams = | 357 rtc::scoped_refptr<StreamCollection> remote_streams = |
358 StreamCollection::Create(); | 358 StreamCollection::Create(); |
359 EXPECT_CALL(pc_, remote_streams()) | 359 EXPECT_CALL(*pc_, remote_streams()) |
360 .WillRepeatedly(Return(remote_streams)); | 360 .WillRepeatedly(Return(remote_streams)); |
361 | 361 |
362 rtc::scoped_refptr<MediaStream> remote_stream = | 362 rtc::scoped_refptr<MediaStream> remote_stream = |
363 MediaStream::Create("RemoteStreamLabel"); | 363 MediaStream::Create("RemoteStreamLabel"); |
364 remote_streams->AddStream(remote_stream); | 364 remote_streams->AddStream(remote_stream); |
365 | 365 |
366 rtc::scoped_refptr<MediaStreamTrackInterface> track; | 366 rtc::scoped_refptr<MediaStreamTrackInterface> track; |
367 if (media_type == cricket::MEDIA_TYPE_AUDIO) { | 367 if (media_type == cricket::MEDIA_TYPE_AUDIO) { |
368 track = CreateFakeTrack(media_type, track_id, | 368 track = CreateFakeTrack(media_type, track_id, |
369 MediaStreamTrackInterface::kLive); | 369 MediaStreamTrackInterface::kLive); |
370 remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); | 370 remote_stream->AddTrack(static_cast<AudioTrackInterface*>(track.get())); |
371 } else { | 371 } else { |
372 track = CreateFakeTrack(media_type, track_id, | 372 track = CreateFakeTrack(media_type, track_id, |
373 MediaStreamTrackInterface::kLive); | 373 MediaStreamTrackInterface::kLive); |
374 remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get())); | 374 remote_stream->AddTrack(static_cast<VideoTrackInterface*>(track.get())); |
375 } | 375 } |
376 | 376 |
377 rtc::scoped_refptr<MockRtpReceiver> receiver = | 377 rtc::scoped_refptr<MockRtpReceiver> receiver = |
378 CreateMockReceiver(track, ssrc); | 378 CreateMockReceiver(track, ssrc); |
379 EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return( | 379 EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return( |
380 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>({ | 380 std::vector<rtc::scoped_refptr<RtpReceiverInterface>>({ |
381 rtc::scoped_refptr<RtpReceiverInterface>(receiver.get()) }))); | 381 rtc::scoped_refptr<RtpReceiverInterface>(receiver.get()) }))); |
382 } | 382 } |
383 | 383 |
384 // Attaches tracks to peer connections by configuring RTP senders and RTP | 384 // Attaches tracks to peer connections by configuring RTP senders and RTP |
385 // receivers according to the tracks' pairings with | 385 // receivers according to the tracks' pairings with |
386 // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be | 386 // |[Voice/Video][Sender/Receiver]Info| and their SSRCs. Local tracks can be |
387 // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only | 387 // associated with multiple |[Voice/Video]SenderInfo|s, remote tracks can only |
388 // be associated with one |[Voice/Video]ReceiverInfo|. | 388 // be associated with one |[Voice/Video]ReceiverInfo|. |
389 void CreateMockRtpSendersReceiversAndChannels( | 389 void CreateMockRtpSendersReceiversAndChannels( |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
452 MediaStreamTrackInterface::kVideoKind); | 452 MediaStreamTrackInterface::kVideoKind); |
453 | 453 |
454 video_media_info_->receivers.push_back(video_receiver_info); | 454 video_media_info_->receivers.push_back(video_receiver_info); |
455 rtc::scoped_refptr<MockRtpReceiver> rtp_receiver = | 455 rtc::scoped_refptr<MockRtpReceiver> rtp_receiver = |
456 CreateMockReceiver(rtc::scoped_refptr<MediaStreamTrackInterface>( | 456 CreateMockReceiver(rtc::scoped_refptr<MediaStreamTrackInterface>( |
457 remote_video_track), | 457 remote_video_track), |
458 video_receiver_info.local_stats[0].ssrc); | 458 video_receiver_info.local_stats[0].ssrc); |
459 rtp_receivers_.push_back(rtc::scoped_refptr<RtpReceiverInterface>( | 459 rtp_receivers_.push_back(rtc::scoped_refptr<RtpReceiverInterface>( |
460 rtp_receiver.get())); | 460 rtp_receiver.get())); |
461 } | 461 } |
462 EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(rtp_senders_)); | 462 EXPECT_CALL(*pc_, GetSenders()).WillRepeatedly(Return(rtp_senders_)); |
463 EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(rtp_receivers_)); | 463 EXPECT_CALL(*pc_, GetReceivers()).WillRepeatedly(Return(rtp_receivers_)); |
464 | 464 |
465 MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel(); | 465 MockVoiceMediaChannel* voice_media_channel = new MockVoiceMediaChannel(); |
466 voice_channel_.reset(new cricket::VoiceChannel( | 466 voice_channel_.reset(new cricket::VoiceChannel( |
467 worker_thread_, network_thread_, nullptr, media_engine_, | 467 worker_thread_, network_thread_, nullptr, media_engine_, |
468 voice_media_channel, "VoiceContentName", kDefaultRtcpMuxRequired, | 468 voice_media_channel, "VoiceContentName", kDefaultRtcpMuxRequired, |
469 kDefaultSrtpRequired)); | 469 kDefaultSrtpRequired)); |
470 EXPECT_CALL(session_, voice_channel()) | 470 EXPECT_CALL(session_, voice_channel()) |
471 .WillRepeatedly(Return(voice_channel_.get())); | 471 .WillRepeatedly(Return(voice_channel_.get())); |
472 EXPECT_CALL(*voice_media_channel, GetStats(_)) | 472 EXPECT_CALL(*voice_media_channel, GetStats(_)) |
473 .WillOnce(DoAll(SetArgPointee<0>(*voice_media_info_), Return(true))); | 473 .WillOnce(DoAll(SetArgPointee<0>(*voice_media_info_), Return(true))); |
(...skipping 11 matching lines...) Expand all Loading... |
485 private: | 485 private: |
486 rtc::ScopedFakeClock fake_clock_; | 486 rtc::ScopedFakeClock fake_clock_; |
487 RtcEventLogNullImpl event_log_; | 487 RtcEventLogNullImpl event_log_; |
488 rtc::Thread* const worker_thread_; | 488 rtc::Thread* const worker_thread_; |
489 rtc::Thread* const network_thread_; | 489 rtc::Thread* const network_thread_; |
490 rtc::Thread* const signaling_thread_; | 490 rtc::Thread* const signaling_thread_; |
491 // |media_engine_| is actually owned by |channel_manager_|. | 491 // |media_engine_| is actually owned by |channel_manager_|. |
492 cricket::FakeMediaEngine* media_engine_; | 492 cricket::FakeMediaEngine* media_engine_; |
493 std::unique_ptr<cricket::ChannelManager> channel_manager_; | 493 std::unique_ptr<cricket::ChannelManager> channel_manager_; |
494 MockWebRtcSession session_; | 494 MockWebRtcSession session_; |
495 MockPeerConnection pc_; | 495 rtc::scoped_refptr<MockPeerConnection> pc_; |
496 | 496 |
497 std::vector<rtc::scoped_refptr<DataChannel>> data_channels_; | 497 std::vector<rtc::scoped_refptr<DataChannel>> data_channels_; |
498 std::unique_ptr<cricket::VoiceChannel> voice_channel_; | 498 std::unique_ptr<cricket::VoiceChannel> voice_channel_; |
499 std::unique_ptr<cricket::VideoChannel> video_channel_; | 499 std::unique_ptr<cricket::VideoChannel> video_channel_; |
500 std::unique_ptr<cricket::VoiceMediaInfo> voice_media_info_; | 500 std::unique_ptr<cricket::VoiceMediaInfo> voice_media_info_; |
501 std::unique_ptr<cricket::VideoMediaInfo> video_media_info_; | 501 std::unique_ptr<cricket::VideoMediaInfo> video_media_info_; |
502 std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders_; | 502 std::vector<rtc::scoped_refptr<RtpSenderInterface>> rtp_senders_; |
503 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers_; | 503 std::vector<rtc::scoped_refptr<RtpReceiverInterface>> rtp_receivers_; |
504 }; | 504 }; |
505 | 505 |
(...skipping 466 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
972 return static_cast<rtc::SSLCertificate*>(nullptr); | 972 return static_cast<rtc::SSLCertificate*>(nullptr); |
973 })); | 973 })); |
974 | 974 |
975 rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport(); | 975 rtc::scoped_refptr<const RTCStatsReport> report = GetStatsReport(); |
976 ExpectReportContainsCertificateInfo(report, *local_certinfo); | 976 ExpectReportContainsCertificateInfo(report, *local_certinfo); |
977 ExpectReportContainsCertificateInfo(report, *remote_certinfo); | 977 ExpectReportContainsCertificateInfo(report, *remote_certinfo); |
978 } | 978 } |
979 | 979 |
980 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) { | 980 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) { |
981 test_->data_channels().push_back( | 981 test_->data_channels().push_back( |
982 new MockDataChannel( | 982 new rtc::RefCountedObject<MockDataChannel>( |
983 0, "MockDataChannel0", DataChannelInterface::kConnecting, "udp", | 983 0, "MockDataChannel0", DataChannelInterface::kConnecting, "udp", |
984 1, 2, 3, 4)); | 984 1, 2, 3, 4)); |
985 RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0); | 985 RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0); |
986 expected_data_channel0.label = "MockDataChannel0"; | 986 expected_data_channel0.label = "MockDataChannel0"; |
987 expected_data_channel0.protocol = "udp"; | 987 expected_data_channel0.protocol = "udp"; |
988 expected_data_channel0.datachannelid = 0; | 988 expected_data_channel0.datachannelid = 0; |
989 expected_data_channel0.state = "connecting"; | 989 expected_data_channel0.state = "connecting"; |
990 expected_data_channel0.messages_sent = 1; | 990 expected_data_channel0.messages_sent = 1; |
991 expected_data_channel0.bytes_sent = 2; | 991 expected_data_channel0.bytes_sent = 2; |
992 expected_data_channel0.messages_received = 3; | 992 expected_data_channel0.messages_received = 3; |
993 expected_data_channel0.bytes_received = 4; | 993 expected_data_channel0.bytes_received = 4; |
994 | 994 |
995 test_->data_channels().push_back( | 995 test_->data_channels().push_back( |
996 new MockDataChannel( | 996 new rtc::RefCountedObject<MockDataChannel>( |
997 1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp", | 997 1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp", |
998 5, 6, 7, 8)); | 998 5, 6, 7, 8)); |
999 RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0); | 999 RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0); |
1000 expected_data_channel1.label = "MockDataChannel1"; | 1000 expected_data_channel1.label = "MockDataChannel1"; |
1001 expected_data_channel1.protocol = "tcp"; | 1001 expected_data_channel1.protocol = "tcp"; |
1002 expected_data_channel1.datachannelid = 1; | 1002 expected_data_channel1.datachannelid = 1; |
1003 expected_data_channel1.state = "open"; | 1003 expected_data_channel1.state = "open"; |
1004 expected_data_channel1.messages_sent = 5; | 1004 expected_data_channel1.messages_sent = 5; |
1005 expected_data_channel1.bytes_sent = 6; | 1005 expected_data_channel1.bytes_sent = 6; |
1006 expected_data_channel1.messages_received = 7; | 1006 expected_data_channel1.messages_received = 7; |
1007 expected_data_channel1.bytes_received = 8; | 1007 expected_data_channel1.bytes_received = 8; |
1008 | 1008 |
1009 test_->data_channels().push_back( | 1009 test_->data_channels().push_back( |
1010 new MockDataChannel( | 1010 new rtc::RefCountedObject<MockDataChannel>( |
1011 2, "MockDataChannel2", DataChannelInterface::kClosing, "udp", | 1011 2, "MockDataChannel2", DataChannelInterface::kClosing, "udp", |
1012 9, 10, 11, 12)); | 1012 9, 10, 11, 12)); |
1013 RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0); | 1013 RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0); |
1014 expected_data_channel2.label = "MockDataChannel2"; | 1014 expected_data_channel2.label = "MockDataChannel2"; |
1015 expected_data_channel2.protocol = "udp"; | 1015 expected_data_channel2.protocol = "udp"; |
1016 expected_data_channel2.datachannelid = 2; | 1016 expected_data_channel2.datachannelid = 2; |
1017 expected_data_channel2.state = "closing"; | 1017 expected_data_channel2.state = "closing"; |
1018 expected_data_channel2.messages_sent = 9; | 1018 expected_data_channel2.messages_sent = 9; |
1019 expected_data_channel2.bytes_sent = 10; | 1019 expected_data_channel2.bytes_sent = 10; |
1020 expected_data_channel2.messages_received = 11; | 1020 expected_data_channel2.messages_received = 11; |
1021 expected_data_channel2.bytes_received = 12; | 1021 expected_data_channel2.bytes_received = 12; |
1022 | 1022 |
1023 test_->data_channels().push_back( | 1023 test_->data_channels().push_back( |
1024 new MockDataChannel( | 1024 new rtc::RefCountedObject<MockDataChannel>( |
1025 3, "MockDataChannel3", DataChannelInterface::kClosed, "tcp", | 1025 3, "MockDataChannel3", DataChannelInterface::kClosed, "tcp", |
1026 13, 14, 15, 16)); | 1026 13, 14, 15, 16)); |
1027 RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0); | 1027 RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0); |
1028 expected_data_channel3.label = "MockDataChannel3"; | 1028 expected_data_channel3.label = "MockDataChannel3"; |
1029 expected_data_channel3.protocol = "tcp"; | 1029 expected_data_channel3.protocol = "tcp"; |
1030 expected_data_channel3.datachannelid = 3; | 1030 expected_data_channel3.datachannelid = 3; |
1031 expected_data_channel3.state = "closed"; | 1031 expected_data_channel3.state = "closed"; |
1032 expected_data_channel3.messages_sent = 13; | 1032 expected_data_channel3.messages_sent = 13; |
1033 expected_data_channel3.bytes_sent = 14; | 1033 expected_data_channel3.bytes_sent = 14; |
1034 expected_data_channel3.messages_received = 15; | 1034 expected_data_channel3.messages_received = 15; |
(...skipping 1297 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2332 rtc::scoped_refptr<FakeRTCStatsCollector> collector_; | 2332 rtc::scoped_refptr<FakeRTCStatsCollector> collector_; |
2333 }; | 2333 }; |
2334 | 2334 |
2335 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) { | 2335 TEST_F(RTCStatsCollectorTestWithFakeCollector, ThreadUsageAndResultsMerging) { |
2336 collector_->VerifyThreadUsageAndResultsMerging(); | 2336 collector_->VerifyThreadUsageAndResultsMerging(); |
2337 } | 2337 } |
2338 | 2338 |
2339 } // namespace | 2339 } // namespace |
2340 | 2340 |
2341 } // namespace webrtc | 2341 } // namespace webrtc |
OLD | NEW |