OLD | NEW |
1 /* | 1 /* |
2 * libjingle | 2 * libjingle |
3 * Copyright 2012 Google Inc. | 3 * Copyright 2012 Google Inc. |
4 * | 4 * |
5 * Redistribution and use in source and binary forms, with or without | 5 * Redistribution and use in source and binary forms, with or without |
6 * modification, are permitted provided that the following conditions are met: | 6 * modification, are permitted provided that the following conditions are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright notice, | 8 * 1. Redistributions of source code must retain the above copyright notice, |
9 * this list of conditions and the following disclaimer. | 9 * this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | 10 * 2. Redistributions in binary form must reproduce the above copyright notice, |
(...skipping 30 matching lines...) Expand all Loading... |
41 #include "testing/gtest/include/gtest/gtest.h" | 41 #include "testing/gtest/include/gtest/gtest.h" |
42 #include "webrtc/base/gunit.h" | 42 #include "webrtc/base/gunit.h" |
43 | 43 |
44 using ::testing::_; | 44 using ::testing::_; |
45 using ::testing::Exactly; | 45 using ::testing::Exactly; |
46 | 46 |
47 static const char kStreamLabel1[] = "local_stream_1"; | 47 static const char kStreamLabel1[] = "local_stream_1"; |
48 static const char kVideoTrackId[] = "video_1"; | 48 static const char kVideoTrackId[] = "video_1"; |
49 static const char kAudioTrackId[] = "audio_1"; | 49 static const char kAudioTrackId[] = "audio_1"; |
50 static const uint32_t kVideoSsrc = 98; | 50 static const uint32_t kVideoSsrc = 98; |
| 51 static const uint32_t kVideoSsrc2 = 100; |
51 static const uint32_t kAudioSsrc = 99; | 52 static const uint32_t kAudioSsrc = 99; |
| 53 static const uint32_t kAudioSsrc2 = 101; |
52 | 54 |
53 namespace webrtc { | 55 namespace webrtc { |
54 | 56 |
55 // Helper class to test RtpSender/RtpReceiver. | 57 // Helper class to test RtpSender/RtpReceiver. |
56 class MockAudioProvider : public AudioProviderInterface { | 58 class MockAudioProvider : public AudioProviderInterface { |
57 public: | 59 public: |
58 virtual ~MockAudioProvider() {} | 60 virtual ~MockAudioProvider() {} |
59 MOCK_METHOD2(SetAudioPlayout, | 61 MOCK_METHOD2(SetAudioPlayout, |
60 void(uint32_t ssrc, | 62 void(uint32_t ssrc, |
61 bool enable)); | 63 bool enable)); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
113 stream_ = MediaStream::Create(kStreamLabel1); | 115 stream_ = MediaStream::Create(kStreamLabel1); |
114 rtc::scoped_refptr<VideoSourceInterface> source(FakeVideoSource::Create()); | 116 rtc::scoped_refptr<VideoSourceInterface> source(FakeVideoSource::Create()); |
115 video_track_ = VideoTrack::Create(kVideoTrackId, source); | 117 video_track_ = VideoTrack::Create(kVideoTrackId, source); |
116 EXPECT_TRUE(stream_->AddTrack(video_track_)); | 118 EXPECT_TRUE(stream_->AddTrack(video_track_)); |
117 } | 119 } |
118 | 120 |
119 void CreateAudioRtpSender() { | 121 void CreateAudioRtpSender() { |
120 audio_track_ = AudioTrack::Create(kAudioTrackId, NULL); | 122 audio_track_ = AudioTrack::Create(kAudioTrackId, NULL); |
121 EXPECT_TRUE(stream_->AddTrack(audio_track_)); | 123 EXPECT_TRUE(stream_->AddTrack(audio_track_)); |
122 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); | 124 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
123 audio_rtp_sender_ = new AudioRtpSender(stream_->GetAudioTracks()[0], | 125 audio_rtp_sender_ = |
124 kAudioSsrc, &audio_provider_); | 126 new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(), |
| 127 &audio_provider_, nullptr); |
| 128 audio_rtp_sender_->SetSsrc(kAudioSsrc); |
125 } | 129 } |
126 | 130 |
127 void CreateVideoRtpSender() { | 131 void CreateVideoRtpSender() { |
128 EXPECT_CALL(video_provider_, | 132 EXPECT_CALL(video_provider_, |
129 SetCaptureDevice( | 133 SetCaptureDevice( |
130 kVideoSsrc, video_track_->GetSource()->GetVideoCapturer())); | 134 kVideoSsrc, video_track_->GetSource()->GetVideoCapturer())); |
131 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); | 135 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
132 video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0], | 136 video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0], |
133 kVideoSsrc, &video_provider_); | 137 stream_->label(), &video_provider_); |
| 138 video_rtp_sender_->SetSsrc(kVideoSsrc); |
134 } | 139 } |
135 | 140 |
136 void DestroyAudioRtpSender() { | 141 void DestroyAudioRtpSender() { |
137 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)) | 142 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)) |
138 .Times(1); | 143 .Times(1); |
139 audio_rtp_sender_ = nullptr; | 144 audio_rtp_sender_ = nullptr; |
140 } | 145 } |
141 | 146 |
142 void DestroyVideoRtpSender() { | 147 void DestroyVideoRtpSender() { |
143 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)).Times(1); | 148 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, NULL)).Times(1); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
273 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true)); | 278 EXPECT_CALL(audio_provider_, SetAudioPlayout(kAudioSsrc, true)); |
274 audio_track_->set_enabled(true); | 279 audio_track_->set_enabled(true); |
275 | 280 |
276 double new_volume = 0.8; | 281 double new_volume = 0.8; |
277 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, new_volume)); | 282 EXPECT_CALL(audio_provider_, SetAudioPlayoutVolume(kAudioSsrc, new_volume)); |
278 audio_track_->GetSource()->SetVolume(new_volume); | 283 audio_track_->GetSource()->SetVolume(new_volume); |
279 | 284 |
280 DestroyAudioRtpReceiver(); | 285 DestroyAudioRtpReceiver(); |
281 } | 286 } |
282 | 287 |
| 288 // Test that provider methods aren't called without both a track and an SSRC. |
| 289 TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) { |
| 290 rtc::scoped_refptr<AudioRtpSender> sender = |
| 291 new AudioRtpSender(&audio_provider_, nullptr); |
| 292 rtc::scoped_refptr<AudioTrackInterface> track = |
| 293 AudioTrack::Create(kAudioTrackId, nullptr); |
| 294 EXPECT_TRUE(sender->SetTrack(track)); |
| 295 EXPECT_TRUE(sender->SetTrack(nullptr)); |
| 296 sender->SetSsrc(kAudioSsrc); |
| 297 sender->SetSsrc(0); |
| 298 // Just let it get destroyed and make sure it doesn't call any methods on the |
| 299 // provider interface. |
| 300 } |
| 301 |
| 302 // Test that provider methods aren't called without both a track and an SSRC. |
| 303 TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) { |
| 304 rtc::scoped_refptr<VideoRtpSender> sender = |
| 305 new VideoRtpSender(&video_provider_); |
| 306 EXPECT_TRUE(sender->SetTrack(video_track_)); |
| 307 EXPECT_TRUE(sender->SetTrack(nullptr)); |
| 308 sender->SetSsrc(kVideoSsrc); |
| 309 sender->SetSsrc(0); |
| 310 // Just let it get destroyed and make sure it doesn't call any methods on the |
| 311 // provider interface. |
| 312 } |
| 313 |
| 314 // Test that an audio sender calls the expected methods on the provider once |
| 315 // it has a track and SSRC, when the SSRC is set first. |
| 316 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) { |
| 317 rtc::scoped_refptr<AudioRtpSender> sender = |
| 318 new AudioRtpSender(&audio_provider_, nullptr); |
| 319 rtc::scoped_refptr<AudioTrackInterface> track = |
| 320 AudioTrack::Create(kAudioTrackId, nullptr); |
| 321 sender->SetSsrc(kAudioSsrc); |
| 322 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
| 323 sender->SetTrack(track); |
| 324 |
| 325 // Calls expected from destructor. |
| 326 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); |
| 327 } |
| 328 |
| 329 // Test that an audio sender calls the expected methods on the provider once |
| 330 // it has a track and SSRC, when the SSRC is set last. |
| 331 TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) { |
| 332 rtc::scoped_refptr<AudioRtpSender> sender = |
| 333 new AudioRtpSender(&audio_provider_, nullptr); |
| 334 rtc::scoped_refptr<AudioTrackInterface> track = |
| 335 AudioTrack::Create(kAudioTrackId, nullptr); |
| 336 sender->SetTrack(track); |
| 337 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
| 338 sender->SetSsrc(kAudioSsrc); |
| 339 |
| 340 // Calls expected from destructor. |
| 341 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); |
| 342 } |
| 343 |
| 344 // Test that a video sender calls the expected methods on the provider once |
| 345 // it has a track and SSRC, when the SSRC is set first. |
| 346 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) { |
| 347 rtc::scoped_refptr<VideoRtpSender> sender = |
| 348 new VideoRtpSender(&video_provider_); |
| 349 sender->SetSsrc(kVideoSsrc); |
| 350 EXPECT_CALL(video_provider_, |
| 351 SetCaptureDevice(kVideoSsrc, |
| 352 video_track_->GetSource()->GetVideoCapturer())); |
| 353 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
| 354 sender->SetTrack(video_track_); |
| 355 |
| 356 // Calls expected from destructor. |
| 357 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1); |
| 358 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1); |
| 359 } |
| 360 |
| 361 // Test that a video sender calls the expected methods on the provider once |
| 362 // it has a track and SSRC, when the SSRC is set last. |
| 363 TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) { |
| 364 rtc::scoped_refptr<VideoRtpSender> sender = |
| 365 new VideoRtpSender(&video_provider_); |
| 366 sender->SetTrack(video_track_); |
| 367 EXPECT_CALL(video_provider_, |
| 368 SetCaptureDevice(kVideoSsrc, |
| 369 video_track_->GetSource()->GetVideoCapturer())); |
| 370 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
| 371 sender->SetSsrc(kVideoSsrc); |
| 372 |
| 373 // Calls expected from destructor. |
| 374 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1); |
| 375 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1); |
| 376 } |
| 377 |
| 378 // Test that the sender is disconnected from the provider when its SSRC is |
| 379 // set to 0. |
| 380 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) { |
| 381 rtc::scoped_refptr<AudioTrackInterface> track = |
| 382 AudioTrack::Create(kAudioTrackId, nullptr); |
| 383 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
| 384 rtc::scoped_refptr<AudioRtpSender> sender = |
| 385 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); |
| 386 sender->SetSsrc(kAudioSsrc); |
| 387 |
| 388 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); |
| 389 sender->SetSsrc(0); |
| 390 |
| 391 // Make sure it's SetSsrc that called methods on the provider, and not the |
| 392 // destructor. |
| 393 EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0); |
| 394 } |
| 395 |
| 396 // Test that the sender is disconnected from the provider when its SSRC is |
| 397 // set to 0. |
| 398 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) { |
| 399 EXPECT_CALL(video_provider_, |
| 400 SetCaptureDevice(kVideoSsrc, |
| 401 video_track_->GetSource()->GetVideoCapturer())); |
| 402 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
| 403 rtc::scoped_refptr<VideoRtpSender> sender = |
| 404 new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_); |
| 405 sender->SetSsrc(kVideoSsrc); |
| 406 |
| 407 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1); |
| 408 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1); |
| 409 sender->SetSsrc(0); |
| 410 |
| 411 // Make sure it's SetSsrc that called methods on the provider, and not the |
| 412 // destructor. |
| 413 EXPECT_CALL(video_provider_, SetCaptureDevice(_, _)).Times(0); |
| 414 EXPECT_CALL(video_provider_, SetVideoSend(_, _, _)).Times(0); |
| 415 } |
| 416 |
| 417 TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) { |
| 418 rtc::scoped_refptr<AudioTrackInterface> track = |
| 419 AudioTrack::Create(kAudioTrackId, nullptr); |
| 420 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
| 421 rtc::scoped_refptr<AudioRtpSender> sender = |
| 422 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); |
| 423 sender->SetSsrc(kAudioSsrc); |
| 424 |
| 425 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); |
| 426 EXPECT_TRUE(sender->SetTrack(nullptr)); |
| 427 |
| 428 // Make sure it's SetTrack that called methods on the provider, and not the |
| 429 // destructor. |
| 430 EXPECT_CALL(audio_provider_, SetAudioSend(_, _, _, _)).Times(0); |
| 431 } |
| 432 |
| 433 TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) { |
| 434 EXPECT_CALL(video_provider_, |
| 435 SetCaptureDevice(kVideoSsrc, |
| 436 video_track_->GetSource()->GetVideoCapturer())); |
| 437 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
| 438 rtc::scoped_refptr<VideoRtpSender> sender = |
| 439 new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_); |
| 440 sender->SetSsrc(kVideoSsrc); |
| 441 |
| 442 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1); |
| 443 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1); |
| 444 EXPECT_TRUE(sender->SetTrack(nullptr)); |
| 445 |
| 446 // Make sure it's SetTrack that called methods on the provider, and not the |
| 447 // destructor. |
| 448 EXPECT_CALL(video_provider_, SetCaptureDevice(_, _)).Times(0); |
| 449 EXPECT_CALL(video_provider_, SetVideoSend(_, _, _)).Times(0); |
| 450 } |
| 451 |
| 452 TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) { |
| 453 rtc::scoped_refptr<AudioTrackInterface> track = |
| 454 AudioTrack::Create(kAudioTrackId, nullptr); |
| 455 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _)); |
| 456 rtc::scoped_refptr<AudioRtpSender> sender = |
| 457 new AudioRtpSender(track, kStreamLabel1, &audio_provider_, nullptr); |
| 458 sender->SetSsrc(kAudioSsrc); |
| 459 |
| 460 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, false, _, _)).Times(1); |
| 461 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, true, _, _)).Times(1); |
| 462 sender->SetSsrc(kAudioSsrc2); |
| 463 |
| 464 // Calls expected from destructor. |
| 465 EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc2, false, _, _)).Times(1); |
| 466 } |
| 467 |
| 468 TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) { |
| 469 EXPECT_CALL(video_provider_, |
| 470 SetCaptureDevice(kVideoSsrc, |
| 471 video_track_->GetSource()->GetVideoCapturer())); |
| 472 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, true, _)); |
| 473 rtc::scoped_refptr<VideoRtpSender> sender = |
| 474 new VideoRtpSender(video_track_, kStreamLabel1, &video_provider_); |
| 475 sender->SetSsrc(kVideoSsrc); |
| 476 |
| 477 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc, nullptr)).Times(1); |
| 478 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc, false, _)).Times(1); |
| 479 EXPECT_CALL(video_provider_, |
| 480 SetCaptureDevice(kVideoSsrc2, |
| 481 video_track_->GetSource()->GetVideoCapturer())); |
| 482 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, true, _)); |
| 483 sender->SetSsrc(kVideoSsrc2); |
| 484 |
| 485 // Calls expected from destructor. |
| 486 EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc2, nullptr)).Times(1); |
| 487 EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, false, _)).Times(1); |
| 488 } |
| 489 |
283 } // namespace webrtc | 490 } // namespace webrtc |
OLD | NEW |