blob: f40b494e7e4d981d401b35fffd95e1eb6931ed1d [file] [log] [blame]
deadbeef70ab1a12015-09-28 23:53:551/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2012 The WebRTC project authors. All Rights Reserved.
deadbeef70ab1a12015-09-28 23:53:553 *
kjellanderb24317b2016-02-10 15:54:434 * 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.
deadbeef70ab1a12015-09-28 23:53:559 */
10
kwibergd1fe2812016-04-27 13:47:2911#include <memory>
deadbeef70ab1a12015-09-28 23:53:5512#include <string>
Tommif888bb52015-12-12 00:37:0113#include <utility>
deadbeef70ab1a12015-09-28 23:53:5514
Mirko Bonadei92ea95e2017-09-15 04:47:3115#include "media/base/fakemediaengine.h"
Steve Antonc9e15602017-11-06 23:40:0916#include "media/base/rtpdataengine.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3117#include "media/engine/fakewebrtccall.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3118#include "pc/audiotrack.h"
19#include "pc/channelmanager.h"
20#include "pc/localaudiosource.h"
21#include "pc/mediastream.h"
22#include "pc/remoteaudiosource.h"
23#include "pc/rtpreceiver.h"
24#include "pc/rtpsender.h"
25#include "pc/streamcollection.h"
Zhi Huangb5261582017-09-29 17:51:4326#include "pc/test/faketransportcontroller.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3127#include "pc/test/fakevideotracksource.h"
28#include "pc/videotrack.h"
29#include "pc/videotracksource.h"
30#include "rtc_base/gunit.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3131#include "test/gmock.h"
32#include "test/gtest.h"
deadbeef70ab1a12015-09-28 23:53:5533
34using ::testing::_;
35using ::testing::Exactly;
deadbeef5dd42fd2016-05-02 23:20:0136using ::testing::InvokeWithoutArgs;
skvladdc1c62c2016-03-17 02:07:4337using ::testing::Return;
deadbeef70ab1a12015-09-28 23:53:5538
deadbeef20cb0c12017-02-02 04:27:0039namespace {
40
deadbeef70ab1a12015-09-28 23:53:5541static const char kStreamLabel1[] = "local_stream_1";
42static const char kVideoTrackId[] = "video_1";
43static const char kAudioTrackId[] = "audio_1";
Peter Boström0c4e06b2015-10-07 10:23:2144static const uint32_t kVideoSsrc = 98;
deadbeeffac06552015-11-25 19:26:0145static const uint32_t kVideoSsrc2 = 100;
Peter Boström0c4e06b2015-10-07 10:23:2146static const uint32_t kAudioSsrc = 99;
deadbeeffac06552015-11-25 19:26:0147static const uint32_t kAudioSsrc2 = 101;
deadbeef20cb0c12017-02-02 04:27:0048static const int kDefaultTimeout = 10000; // 10 seconds.
deadbeef20cb0c12017-02-02 04:27:0049} // namespace
deadbeef70ab1a12015-09-28 23:53:5550
51namespace webrtc {
52
deadbeef20cb0c12017-02-02 04:27:0053class RtpSenderReceiverTest : public testing::Test,
54 public sigslot::has_slots<> {
tkchin3784b4a2016-06-25 02:31:4755 public:
Taylor Brandstetterba29c6a2016-06-27 23:30:3556 RtpSenderReceiverTest()
57 : // Create fake media engine/etc. so we can create channels to use to
deadbeefe814a0d2017-02-26 02:15:0958 // test RtpSenders/RtpReceivers.
Taylor Brandstetterba29c6a2016-06-27 23:30:3559 media_engine_(new cricket::FakeMediaEngine()),
Steve Antonc9e15602017-11-06 23:40:0960 channel_manager_(rtc::WrapUnique(media_engine_),
61 rtc::MakeUnique<cricket::RtpDataEngine>(),
62 rtc::Thread::Current(),
63 rtc::Thread::Current()),
skvlad11a9cbf2016-10-07 18:53:0564 fake_call_(Call::Config(&event_log_)),
deadbeefe814a0d2017-02-26 02:15:0965 local_stream_(MediaStream::Create(kStreamLabel1)) {
Taylor Brandstetterba29c6a2016-06-27 23:30:3566 // Create channels to be used by the RtpSenders and RtpReceivers.
67 channel_manager_.Init();
deadbeef7af91dd2016-12-13 19:29:1168 bool srtp_required = true;
zhihuangb2cdd932017-01-20 00:54:2569 cricket::DtlsTransportInternal* rtp_transport =
70 fake_transport_controller_.CreateDtlsTransport(
zhihuangf5b251b2017-01-13 03:37:4871 cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
Taylor Brandstetterba29c6a2016-06-27 23:30:3572 voice_channel_ = channel_manager_.CreateVoiceChannel(
nisseeaabdf62017-05-05 09:23:0273 &fake_call_, cricket::MediaConfig(),
74 rtp_transport, nullptr, rtc::Thread::Current(),
deadbeef1a2183d2017-02-11 07:44:4975 cricket::CN_AUDIO, srtp_required, cricket::AudioOptions());
Taylor Brandstetterba29c6a2016-06-27 23:30:3576 video_channel_ = channel_manager_.CreateVideoChannel(
nisseeaabdf62017-05-05 09:23:0277 &fake_call_, cricket::MediaConfig(),
78 rtp_transport, nullptr, rtc::Thread::Current(),
deadbeef1a2183d2017-02-11 07:44:4979 cricket::CN_VIDEO, srtp_required, cricket::VideoOptions());
deadbeef20cb0c12017-02-02 04:27:0080 voice_channel_->Enable(true);
81 video_channel_->Enable(true);
Taylor Brandstetterba29c6a2016-06-27 23:30:3582 voice_media_channel_ = media_engine_->GetVoiceChannel(0);
83 video_media_channel_ = media_engine_->GetVideoChannel(0);
84 RTC_CHECK(voice_channel_);
85 RTC_CHECK(video_channel_);
86 RTC_CHECK(voice_media_channel_);
87 RTC_CHECK(video_media_channel_);
88
89 // Create streams for predefined SSRCs. Streams need to exist in order
90 // for the senders and receievers to apply parameters to them.
91 // Normally these would be created by SetLocalDescription and
92 // SetRemoteDescription.
93 voice_media_channel_->AddSendStream(
94 cricket::StreamParams::CreateLegacy(kAudioSsrc));
95 voice_media_channel_->AddRecvStream(
96 cricket::StreamParams::CreateLegacy(kAudioSsrc));
97 voice_media_channel_->AddSendStream(
98 cricket::StreamParams::CreateLegacy(kAudioSsrc2));
99 voice_media_channel_->AddRecvStream(
100 cricket::StreamParams::CreateLegacy(kAudioSsrc2));
101 video_media_channel_->AddSendStream(
102 cricket::StreamParams::CreateLegacy(kVideoSsrc));
103 video_media_channel_->AddRecvStream(
104 cricket::StreamParams::CreateLegacy(kVideoSsrc));
105 video_media_channel_->AddSendStream(
106 cricket::StreamParams::CreateLegacy(kVideoSsrc2));
107 video_media_channel_->AddRecvStream(
108 cricket::StreamParams::CreateLegacy(kVideoSsrc2));
tkchin3784b4a2016-06-25 02:31:47109 }
Taylor Brandstetter2d549172016-06-24 21:18:22110
deadbeef20cb0c12017-02-02 04:27:00111 // Needed to use DTMF sender.
112 void AddDtmfCodec() {
113 cricket::AudioSendParameters params;
114 const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
115 0, 1);
116 params.codecs.push_back(kTelephoneEventCodec);
117 voice_media_channel_->SetSendParameters(params);
118 }
Taylor Brandstetterba29c6a2016-06-27 23:30:35119
pbos5214a0a2016-12-16 23:39:11120 void AddVideoTrack() { AddVideoTrack(false); }
121
122 void AddVideoTrack(bool is_screencast) {
perkja3ede6c2016-03-08 00:27:48123 rtc::scoped_refptr<VideoTrackSourceInterface> source(
pbos5214a0a2016-12-16 23:39:11124 FakeVideoTrackSource::Create(is_screencast));
perkj773be362017-08-01 06:22:01125 video_track_ =
126 VideoTrack::Create(kVideoTrackId, source, rtc::Thread::Current());
deadbeefe814a0d2017-02-26 02:15:09127 EXPECT_TRUE(local_stream_->AddTrack(video_track_));
deadbeef70ab1a12015-09-28 23:53:55128 }
129
Taylor Brandstetterba29c6a2016-06-27 23:30:35130 void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
131
132 void CreateAudioRtpSender(rtc::scoped_refptr<LocalAudioSource> source) {
133 audio_track_ = AudioTrack::Create(kAudioTrackId, source);
deadbeefe814a0d2017-02-26 02:15:09134 EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
deadbeeffac06552015-11-25 19:26:01135 audio_rtp_sender_ =
deadbeefe814a0d2017-02-26 02:15:09136 new AudioRtpSender(local_stream_->GetAudioTracks()[0],
Steve Anton8ffb9c32017-08-31 22:45:38137 {local_stream_->label()}, voice_channel_, nullptr);
deadbeeffac06552015-11-25 19:26:01138 audio_rtp_sender_->SetSsrc(kAudioSsrc);
deadbeef20cb0c12017-02-02 04:27:00139 audio_rtp_sender_->GetOnDestroyedSignal()->connect(
140 this, &RtpSenderReceiverTest::OnAudioSenderDestroyed);
Taylor Brandstetterba29c6a2016-06-27 23:30:35141 VerifyVoiceChannelInput();
deadbeef70ab1a12015-09-28 23:53:55142 }
143
deadbeef20cb0c12017-02-02 04:27:00144 void OnAudioSenderDestroyed() { audio_sender_destroyed_signal_fired_ = true; }
145
pbos5214a0a2016-12-16 23:39:11146 void CreateVideoRtpSender() { CreateVideoRtpSender(false); }
147
148 void CreateVideoRtpSender(bool is_screencast) {
149 AddVideoTrack(is_screencast);
deadbeefe814a0d2017-02-26 02:15:09150 video_rtp_sender_ =
151 new VideoRtpSender(local_stream_->GetVideoTracks()[0],
Steve Anton8ffb9c32017-08-31 22:45:38152 {local_stream_->label()}, video_channel_);
deadbeeffac06552015-11-25 19:26:01153 video_rtp_sender_->SetSsrc(kVideoSsrc);
Taylor Brandstetterba29c6a2016-06-27 23:30:35154 VerifyVideoChannelInput();
deadbeef70ab1a12015-09-28 23:53:55155 }
156
157 void DestroyAudioRtpSender() {
deadbeef70ab1a12015-09-28 23:53:55158 audio_rtp_sender_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 23:30:35159 VerifyVoiceChannelNoInput();
deadbeef70ab1a12015-09-28 23:53:55160 }
161
162 void DestroyVideoRtpSender() {
deadbeef70ab1a12015-09-28 23:53:55163 video_rtp_sender_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 23:30:35164 VerifyVideoChannelNoInput();
deadbeef70ab1a12015-09-28 23:53:55165 }
166
167 void CreateAudioRtpReceiver() {
deadbeefe814a0d2017-02-26 02:15:09168 audio_rtp_receiver_ =
169 new AudioRtpReceiver(kAudioTrackId, kAudioSsrc, voice_channel_);
perkjd61bf802016-03-24 10:16:19170 audio_track_ = audio_rtp_receiver_->audio_track();
Taylor Brandstetterba29c6a2016-06-27 23:30:35171 VerifyVoiceChannelOutput();
deadbeef70ab1a12015-09-28 23:53:55172 }
173
174 void CreateVideoRtpReceiver() {
deadbeefe814a0d2017-02-26 02:15:09175 video_rtp_receiver_ = new VideoRtpReceiver(
176 kVideoTrackId, rtc::Thread::Current(), kVideoSsrc, video_channel_);
perkjf0dcfe22016-03-10 17:32:00177 video_track_ = video_rtp_receiver_->video_track();
Taylor Brandstetterba29c6a2016-06-27 23:30:35178 VerifyVideoChannelOutput();
deadbeef70ab1a12015-09-28 23:53:55179 }
180
181 void DestroyAudioRtpReceiver() {
deadbeef70ab1a12015-09-28 23:53:55182 audio_rtp_receiver_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 23:30:35183 VerifyVoiceChannelNoOutput();
deadbeef70ab1a12015-09-28 23:53:55184 }
185
186 void DestroyVideoRtpReceiver() {
deadbeef70ab1a12015-09-28 23:53:55187 video_rtp_receiver_ = nullptr;
Taylor Brandstetterba29c6a2016-06-27 23:30:35188 VerifyVideoChannelNoOutput();
189 }
190
191 void VerifyVoiceChannelInput() { VerifyVoiceChannelInput(kAudioSsrc); }
192
193 void VerifyVoiceChannelInput(uint32_t ssrc) {
194 // Verify that the media channel has an audio source, and the stream isn't
195 // muted.
196 EXPECT_TRUE(voice_media_channel_->HasSource(ssrc));
197 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(ssrc));
198 }
199
200 void VerifyVideoChannelInput() { VerifyVideoChannelInput(kVideoSsrc); }
201
202 void VerifyVideoChannelInput(uint32_t ssrc) {
203 // Verify that the media channel has a video source,
204 EXPECT_TRUE(video_media_channel_->HasSource(ssrc));
205 }
206
207 void VerifyVoiceChannelNoInput() { VerifyVoiceChannelNoInput(kAudioSsrc); }
208
209 void VerifyVoiceChannelNoInput(uint32_t ssrc) {
210 // Verify that the media channel's source is reset.
211 EXPECT_FALSE(voice_media_channel_->HasSource(ssrc));
212 }
213
214 void VerifyVideoChannelNoInput() { VerifyVideoChannelNoInput(kVideoSsrc); }
215
216 void VerifyVideoChannelNoInput(uint32_t ssrc) {
217 // Verify that the media channel's source is reset.
218 EXPECT_FALSE(video_media_channel_->HasSource(ssrc));
219 }
220
221 void VerifyVoiceChannelOutput() {
222 // Verify that the volume is initialized to 1.
223 double volume;
224 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
225 EXPECT_EQ(1, volume);
226 }
227
228 void VerifyVideoChannelOutput() {
229 // Verify that the media channel has a sink.
230 EXPECT_TRUE(video_media_channel_->HasSink(kVideoSsrc));
231 }
232
233 void VerifyVoiceChannelNoOutput() {
234 // Verify that the volume is reset to 0.
235 double volume;
236 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
237 EXPECT_EQ(0, volume);
238 }
239
240 void VerifyVideoChannelNoOutput() {
241 // Verify that the media channel's sink is reset.
242 EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc));
deadbeef70ab1a12015-09-28 23:53:55243 }
244
245 protected:
skvlad11a9cbf2016-10-07 18:53:05246 webrtc::RtcEventLogNullImpl event_log_;
deadbeef112b2e92017-02-11 04:13:37247 // |media_engine_| is actually owned by |channel_manager_|.
Taylor Brandstetterba29c6a2016-06-27 23:30:35248 cricket::FakeMediaEngine* media_engine_;
249 cricket::FakeTransportController fake_transport_controller_;
250 cricket::ChannelManager channel_manager_;
251 cricket::FakeCall fake_call_;
Taylor Brandstetterba29c6a2016-06-27 23:30:35252 cricket::VoiceChannel* voice_channel_;
253 cricket::VideoChannel* video_channel_;
254 cricket::FakeVoiceMediaChannel* voice_media_channel_;
255 cricket::FakeVideoMediaChannel* video_media_channel_;
deadbeef70ab1a12015-09-28 23:53:55256 rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
257 rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
258 rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
259 rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
deadbeefe814a0d2017-02-26 02:15:09260 rtc::scoped_refptr<MediaStreamInterface> local_stream_;
deadbeef70ab1a12015-09-28 23:53:55261 rtc::scoped_refptr<VideoTrackInterface> video_track_;
262 rtc::scoped_refptr<AudioTrackInterface> audio_track_;
deadbeef20cb0c12017-02-02 04:27:00263 bool audio_sender_destroyed_signal_fired_ = false;
deadbeef70ab1a12015-09-28 23:53:55264};
265
Taylor Brandstetterba29c6a2016-06-27 23:30:35266// Test that |voice_channel_| is updated when an audio track is associated
deadbeef70ab1a12015-09-28 23:53:55267// and disassociated with an AudioRtpSender.
268TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) {
269 CreateAudioRtpSender();
270 DestroyAudioRtpSender();
271}
272
Taylor Brandstetterba29c6a2016-06-27 23:30:35273// Test that |video_channel_| is updated when a video track is associated and
deadbeef70ab1a12015-09-28 23:53:55274// disassociated with a VideoRtpSender.
275TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpSender) {
276 CreateVideoRtpSender();
277 DestroyVideoRtpSender();
278}
279
Taylor Brandstetterba29c6a2016-06-27 23:30:35280// Test that |voice_channel_| is updated when a remote audio track is
deadbeef70ab1a12015-09-28 23:53:55281// associated and disassociated with an AudioRtpReceiver.
282TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpReceiver) {
283 CreateAudioRtpReceiver();
284 DestroyAudioRtpReceiver();
285}
286
Taylor Brandstetterba29c6a2016-06-27 23:30:35287// Test that |video_channel_| is updated when a remote video track is
288// associated and disassociated with a VideoRtpReceiver.
deadbeef70ab1a12015-09-28 23:53:55289TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) {
290 CreateVideoRtpReceiver();
291 DestroyVideoRtpReceiver();
292}
293
Taylor Brandstetterba29c6a2016-06-27 23:30:35294// Test that the AudioRtpSender applies options from the local audio source.
295TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) {
296 cricket::AudioOptions options;
297 options.echo_cancellation = rtc::Optional<bool>(true);
deadbeef757146b2017-02-11 05:26:48298 auto source = LocalAudioSource::Create(&options);
Taylor Brandstetterba29c6a2016-06-27 23:30:35299 CreateAudioRtpSender(source.get());
Taylor Brandstetter2d549172016-06-24 21:18:22300
Taylor Brandstetterba29c6a2016-06-27 23:30:35301 EXPECT_EQ(rtc::Optional<bool>(true),
302 voice_media_channel_->options().echo_cancellation);
Taylor Brandstetter2d549172016-06-24 21:18:22303
304 DestroyAudioRtpSender();
305}
306
Taylor Brandstetterba29c6a2016-06-27 23:30:35307// Test that the stream is muted when the track is disabled, and unmuted when
308// the track is enabled.
309TEST_F(RtpSenderReceiverTest, LocalAudioTrackDisable) {
310 CreateAudioRtpSender();
311
312 audio_track_->set_enabled(false);
313 EXPECT_TRUE(voice_media_channel_->IsStreamMuted(kAudioSsrc));
314
315 audio_track_->set_enabled(true);
316 EXPECT_FALSE(voice_media_channel_->IsStreamMuted(kAudioSsrc));
317
318 DestroyAudioRtpSender();
319}
320
321// Test that the volume is set to 0 when the track is disabled, and back to
322// 1 when the track is enabled.
deadbeef70ab1a12015-09-28 23:53:55323TEST_F(RtpSenderReceiverTest, RemoteAudioTrackDisable) {
324 CreateAudioRtpReceiver();
325
Taylor Brandstetterba29c6a2016-06-27 23:30:35326 double volume;
327 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
328 EXPECT_EQ(1, volume);
Taylor Brandstetter2d549172016-06-24 21:18:22329
Taylor Brandstetterba29c6a2016-06-27 23:30:35330 audio_track_->set_enabled(false);
331 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
332 EXPECT_EQ(0, volume);
333
deadbeef70ab1a12015-09-28 23:53:55334 audio_track_->set_enabled(true);
Taylor Brandstetterba29c6a2016-06-27 23:30:35335 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
336 EXPECT_EQ(1, volume);
deadbeef70ab1a12015-09-28 23:53:55337
338 DestroyAudioRtpReceiver();
339}
340
Taylor Brandstetterba29c6a2016-06-27 23:30:35341// Currently no action is taken when a remote video track is disabled or
342// enabled, so there's nothing to test here, other than what is normally
343// verified in DestroyVideoRtpSender.
deadbeef70ab1a12015-09-28 23:53:55344TEST_F(RtpSenderReceiverTest, LocalVideoTrackDisable) {
345 CreateVideoRtpSender();
346
deadbeef70ab1a12015-09-28 23:53:55347 video_track_->set_enabled(false);
deadbeef70ab1a12015-09-28 23:53:55348 video_track_->set_enabled(true);
349
350 DestroyVideoRtpSender();
351}
352
Taylor Brandstetterba29c6a2016-06-27 23:30:35353// Test that the state of the video track created by the VideoRtpReceiver is
354// updated when the receiver is destroyed.
perkjf0dcfe22016-03-10 17:32:00355TEST_F(RtpSenderReceiverTest, RemoteVideoTrackState) {
356 CreateVideoRtpReceiver();
357
358 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kLive, video_track_->state());
359 EXPECT_EQ(webrtc::MediaSourceInterface::kLive,
360 video_track_->GetSource()->state());
361
362 DestroyVideoRtpReceiver();
363
364 EXPECT_EQ(webrtc::MediaStreamTrackInterface::kEnded, video_track_->state());
365 EXPECT_EQ(webrtc::MediaSourceInterface::kEnded,
366 video_track_->GetSource()->state());
367}
368
Taylor Brandstetterba29c6a2016-06-27 23:30:35369// Currently no action is taken when a remote video track is disabled or
370// enabled, so there's nothing to test here, other than what is normally
371// verified in DestroyVideoRtpReceiver.
deadbeef70ab1a12015-09-28 23:53:55372TEST_F(RtpSenderReceiverTest, RemoteVideoTrackDisable) {
373 CreateVideoRtpReceiver();
374
375 video_track_->set_enabled(false);
deadbeef70ab1a12015-09-28 23:53:55376 video_track_->set_enabled(true);
377
378 DestroyVideoRtpReceiver();
379}
380
Taylor Brandstetterba29c6a2016-06-27 23:30:35381// Test that the AudioRtpReceiver applies volume changes from the track source
382// to the media channel.
deadbeef70ab1a12015-09-28 23:53:55383TEST_F(RtpSenderReceiverTest, RemoteAudioTrackSetVolume) {
384 CreateAudioRtpReceiver();
385
Taylor Brandstetterba29c6a2016-06-27 23:30:35386 double volume;
387 audio_track_->GetSource()->SetVolume(0.5);
388 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
389 EXPECT_EQ(0.5, volume);
deadbeef70ab1a12015-09-28 23:53:55390
391 // Disable the audio track, this should prevent setting the volume.
deadbeef70ab1a12015-09-28 23:53:55392 audio_track_->set_enabled(false);
Taylor Brandstetterba29c6a2016-06-27 23:30:35393 audio_track_->GetSource()->SetVolume(0.8);
394 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
395 EXPECT_EQ(0, volume);
deadbeef70ab1a12015-09-28 23:53:55396
Taylor Brandstetterba29c6a2016-06-27 23:30:35397 // When the track is enabled, the previously set volume should take effect.
deadbeef70ab1a12015-09-28 23:53:55398 audio_track_->set_enabled(true);
Taylor Brandstetterba29c6a2016-06-27 23:30:35399 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
400 EXPECT_EQ(0.8, volume);
deadbeef70ab1a12015-09-28 23:53:55401
Taylor Brandstetterba29c6a2016-06-27 23:30:35402 // Try changing volume one more time.
403 audio_track_->GetSource()->SetVolume(0.9);
404 EXPECT_TRUE(voice_media_channel_->GetOutputVolume(kAudioSsrc, &volume));
405 EXPECT_EQ(0.9, volume);
deadbeef70ab1a12015-09-28 23:53:55406
407 DestroyAudioRtpReceiver();
408}
409
Taylor Brandstetterba29c6a2016-06-27 23:30:35410// Test that the media channel isn't enabled for sending if the audio sender
411// doesn't have both a track and SSRC.
deadbeeffac06552015-11-25 19:26:01412TEST_F(RtpSenderReceiverTest, AudioSenderWithoutTrackAndSsrc) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35413 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 19:26:01414 rtc::scoped_refptr<AudioTrackInterface> track =
415 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 23:30:35416
417 // Track but no SSRC.
418 EXPECT_TRUE(audio_rtp_sender_->SetTrack(track));
419 VerifyVoiceChannelNoInput();
420
421 // SSRC but no track.
422 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr));
423 audio_rtp_sender_->SetSsrc(kAudioSsrc);
424 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 19:26:01425}
426
Taylor Brandstetterba29c6a2016-06-27 23:30:35427// Test that the media channel isn't enabled for sending if the video sender
428// doesn't have both a track and SSRC.
deadbeeffac06552015-11-25 19:26:01429TEST_F(RtpSenderReceiverTest, VideoSenderWithoutTrackAndSsrc) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35430 video_rtp_sender_ = new VideoRtpSender(video_channel_);
431
432 // Track but no SSRC.
433 EXPECT_TRUE(video_rtp_sender_->SetTrack(video_track_));
434 VerifyVideoChannelNoInput();
435
436 // SSRC but no track.
437 EXPECT_TRUE(video_rtp_sender_->SetTrack(nullptr));
438 video_rtp_sender_->SetSsrc(kVideoSsrc);
439 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 19:26:01440}
441
Taylor Brandstetterba29c6a2016-06-27 23:30:35442// Test that the media channel is enabled for sending when the audio sender
443// has a track and SSRC, when the SSRC is set first.
deadbeeffac06552015-11-25 19:26:01444TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupSsrcThenTrack) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35445 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 19:26:01446 rtc::scoped_refptr<AudioTrackInterface> track =
447 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 23:30:35448 audio_rtp_sender_->SetSsrc(kAudioSsrc);
449 audio_rtp_sender_->SetTrack(track);
450 VerifyVoiceChannelInput();
deadbeeffac06552015-11-25 19:26:01451
Taylor Brandstetterba29c6a2016-06-27 23:30:35452 DestroyAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01453}
454
Taylor Brandstetterba29c6a2016-06-27 23:30:35455// Test that the media channel is enabled for sending when the audio sender
456// has a track and SSRC, when the SSRC is set last.
deadbeeffac06552015-11-25 19:26:01457TEST_F(RtpSenderReceiverTest, AudioSenderEarlyWarmupTrackThenSsrc) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35458 audio_rtp_sender_ = new AudioRtpSender(voice_channel_, nullptr);
deadbeeffac06552015-11-25 19:26:01459 rtc::scoped_refptr<AudioTrackInterface> track =
460 AudioTrack::Create(kAudioTrackId, nullptr);
Taylor Brandstetterba29c6a2016-06-27 23:30:35461 audio_rtp_sender_->SetTrack(track);
462 audio_rtp_sender_->SetSsrc(kAudioSsrc);
463 VerifyVoiceChannelInput();
deadbeeffac06552015-11-25 19:26:01464
Taylor Brandstetterba29c6a2016-06-27 23:30:35465 DestroyAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01466}
467
Taylor Brandstetterba29c6a2016-06-27 23:30:35468// Test that the media channel is enabled for sending when the video sender
469// has a track and SSRC, when the SSRC is set first.
deadbeeffac06552015-11-25 19:26:01470TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupSsrcThenTrack) {
nisseaf510af2016-03-21 15:20:42471 AddVideoTrack();
Taylor Brandstetterba29c6a2016-06-27 23:30:35472 video_rtp_sender_ = new VideoRtpSender(video_channel_);
473 video_rtp_sender_->SetSsrc(kVideoSsrc);
474 video_rtp_sender_->SetTrack(video_track_);
475 VerifyVideoChannelInput();
deadbeeffac06552015-11-25 19:26:01476
Taylor Brandstetterba29c6a2016-06-27 23:30:35477 DestroyVideoRtpSender();
deadbeeffac06552015-11-25 19:26:01478}
479
Taylor Brandstetterba29c6a2016-06-27 23:30:35480// Test that the media channel is enabled for sending when the video sender
481// has a track and SSRC, when the SSRC is set last.
deadbeeffac06552015-11-25 19:26:01482TEST_F(RtpSenderReceiverTest, VideoSenderEarlyWarmupTrackThenSsrc) {
nisseaf510af2016-03-21 15:20:42483 AddVideoTrack();
Taylor Brandstetterba29c6a2016-06-27 23:30:35484 video_rtp_sender_ = new VideoRtpSender(video_channel_);
485 video_rtp_sender_->SetTrack(video_track_);
486 video_rtp_sender_->SetSsrc(kVideoSsrc);
487 VerifyVideoChannelInput();
deadbeeffac06552015-11-25 19:26:01488
Taylor Brandstetterba29c6a2016-06-27 23:30:35489 DestroyVideoRtpSender();
deadbeeffac06552015-11-25 19:26:01490}
491
Taylor Brandstetterba29c6a2016-06-27 23:30:35492// Test that the media channel stops sending when the audio sender's SSRC is set
493// to 0.
deadbeeffac06552015-11-25 19:26:01494TEST_F(RtpSenderReceiverTest, AudioSenderSsrcSetToZero) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35495 CreateAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01496
Taylor Brandstetterba29c6a2016-06-27 23:30:35497 audio_rtp_sender_->SetSsrc(0);
498 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 19:26:01499}
500
Taylor Brandstetterba29c6a2016-06-27 23:30:35501// Test that the media channel stops sending when the video sender's SSRC is set
502// to 0.
deadbeeffac06552015-11-25 19:26:01503TEST_F(RtpSenderReceiverTest, VideoSenderSsrcSetToZero) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35504 CreateAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01505
Taylor Brandstetterba29c6a2016-06-27 23:30:35506 audio_rtp_sender_->SetSsrc(0);
507 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 19:26:01508}
509
Taylor Brandstetterba29c6a2016-06-27 23:30:35510// Test that the media channel stops sending when the audio sender's track is
511// set to null.
deadbeeffac06552015-11-25 19:26:01512TEST_F(RtpSenderReceiverTest, AudioSenderTrackSetToNull) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35513 CreateAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01514
Taylor Brandstetterba29c6a2016-06-27 23:30:35515 EXPECT_TRUE(audio_rtp_sender_->SetTrack(nullptr));
516 VerifyVoiceChannelNoInput();
deadbeeffac06552015-11-25 19:26:01517}
518
Taylor Brandstetterba29c6a2016-06-27 23:30:35519// Test that the media channel stops sending when the video sender's track is
520// set to null.
deadbeeffac06552015-11-25 19:26:01521TEST_F(RtpSenderReceiverTest, VideoSenderTrackSetToNull) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35522 CreateVideoRtpSender();
deadbeeffac06552015-11-25 19:26:01523
Taylor Brandstetterba29c6a2016-06-27 23:30:35524 video_rtp_sender_->SetSsrc(0);
525 VerifyVideoChannelNoInput();
deadbeeffac06552015-11-25 19:26:01526}
527
Taylor Brandstetterba29c6a2016-06-27 23:30:35528// Test that when the audio sender's SSRC is changed, the media channel stops
529// sending with the old SSRC and starts sending with the new one.
deadbeeffac06552015-11-25 19:26:01530TEST_F(RtpSenderReceiverTest, AudioSenderSsrcChanged) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35531 CreateAudioRtpSender();
deadbeeffac06552015-11-25 19:26:01532
Taylor Brandstetterba29c6a2016-06-27 23:30:35533 audio_rtp_sender_->SetSsrc(kAudioSsrc2);
534 VerifyVoiceChannelNoInput(kAudioSsrc);
535 VerifyVoiceChannelInput(kAudioSsrc2);
deadbeeffac06552015-11-25 19:26:01536
Taylor Brandstetterba29c6a2016-06-27 23:30:35537 audio_rtp_sender_ = nullptr;
538 VerifyVoiceChannelNoInput(kAudioSsrc2);
deadbeeffac06552015-11-25 19:26:01539}
540
Taylor Brandstetterba29c6a2016-06-27 23:30:35541// Test that when the audio sender's SSRC is changed, the media channel stops
542// sending with the old SSRC and starts sending with the new one.
deadbeeffac06552015-11-25 19:26:01543TEST_F(RtpSenderReceiverTest, VideoSenderSsrcChanged) {
Taylor Brandstetterba29c6a2016-06-27 23:30:35544 CreateVideoRtpSender();
deadbeeffac06552015-11-25 19:26:01545
Taylor Brandstetterba29c6a2016-06-27 23:30:35546 video_rtp_sender_->SetSsrc(kVideoSsrc2);
547 VerifyVideoChannelNoInput(kVideoSsrc);
548 VerifyVideoChannelInput(kVideoSsrc2);
deadbeeffac06552015-11-25 19:26:01549
Taylor Brandstetterba29c6a2016-06-27 23:30:35550 video_rtp_sender_ = nullptr;
551 VerifyVideoChannelNoInput(kVideoSsrc2);
deadbeeffac06552015-11-25 19:26:01552}
553
skvladdc1c62c2016-03-17 02:07:43554TEST_F(RtpSenderReceiverTest, AudioSenderCanSetParameters) {
555 CreateAudioRtpSender();
556
skvladdc1c62c2016-03-17 02:07:43557 RtpParameters params = audio_rtp_sender_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 23:30:35558 EXPECT_EQ(1u, params.encodings.size());
skvladdc1c62c2016-03-17 02:07:43559 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
560
561 DestroyAudioRtpSender();
562}
563
Taylor Brandstetterba29c6a2016-06-27 23:30:35564TEST_F(RtpSenderReceiverTest, SetAudioMaxSendBitrate) {
565 CreateAudioRtpSender();
566
567 EXPECT_EQ(-1, voice_media_channel_->max_bps());
568 webrtc::RtpParameters params = audio_rtp_sender_->GetParameters();
569 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01570 EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
571 params.encodings[0].max_bitrate_bps = rtc::Optional<int>(1000);
Taylor Brandstetterba29c6a2016-06-27 23:30:35572 EXPECT_TRUE(audio_rtp_sender_->SetParameters(params));
573
574 // Read back the parameters and verify they have been changed.
575 params = audio_rtp_sender_->GetParameters();
576 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01577 EXPECT_EQ(rtc::Optional<int>(1000), params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 23:30:35578
579 // Verify that the audio channel received the new parameters.
580 params = voice_media_channel_->GetRtpSendParameters(kAudioSsrc);
581 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01582 EXPECT_EQ(rtc::Optional<int>(1000), params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 23:30:35583
584 // Verify that the global bitrate limit has not been changed.
585 EXPECT_EQ(-1, voice_media_channel_->max_bps());
586
587 DestroyAudioRtpSender();
588}
589
skvladdc1c62c2016-03-17 02:07:43590TEST_F(RtpSenderReceiverTest, VideoSenderCanSetParameters) {
591 CreateVideoRtpSender();
592
skvladdc1c62c2016-03-17 02:07:43593 RtpParameters params = video_rtp_sender_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 23:30:35594 EXPECT_EQ(1u, params.encodings.size());
skvladdc1c62c2016-03-17 02:07:43595 EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
596
597 DestroyVideoRtpSender();
598}
599
Taylor Brandstetterba29c6a2016-06-27 23:30:35600TEST_F(RtpSenderReceiverTest, SetVideoMaxSendBitrate) {
601 CreateVideoRtpSender();
602
603 EXPECT_EQ(-1, video_media_channel_->max_bps());
604 webrtc::RtpParameters params = video_rtp_sender_->GetParameters();
605 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01606 EXPECT_FALSE(params.encodings[0].max_bitrate_bps);
607 params.encodings[0].max_bitrate_bps = rtc::Optional<int>(1000);
Taylor Brandstetterba29c6a2016-06-27 23:30:35608 EXPECT_TRUE(video_rtp_sender_->SetParameters(params));
609
610 // Read back the parameters and verify they have been changed.
611 params = video_rtp_sender_->GetParameters();
612 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01613 EXPECT_EQ(rtc::Optional<int>(1000), params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 23:30:35614
615 // Verify that the video channel received the new parameters.
616 params = video_media_channel_->GetRtpSendParameters(kVideoSsrc);
617 EXPECT_EQ(1, params.encodings.size());
deadbeefe702b302017-02-04 20:09:01618 EXPECT_EQ(rtc::Optional<int>(1000), params.encodings[0].max_bitrate_bps);
Taylor Brandstetterba29c6a2016-06-27 23:30:35619
620 // Verify that the global bitrate limit has not been changed.
621 EXPECT_EQ(-1, video_media_channel_->max_bps());
622
623 DestroyVideoRtpSender();
624}
625
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30626TEST_F(RtpSenderReceiverTest, AudioReceiverCanSetParameters) {
627 CreateAudioRtpReceiver();
628
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30629 RtpParameters params = audio_rtp_receiver_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 23:30:35630 EXPECT_EQ(1u, params.encodings.size());
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30631 EXPECT_TRUE(audio_rtp_receiver_->SetParameters(params));
632
633 DestroyAudioRtpReceiver();
634}
635
636TEST_F(RtpSenderReceiverTest, VideoReceiverCanSetParameters) {
637 CreateVideoRtpReceiver();
638
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30639 RtpParameters params = video_rtp_receiver_->GetParameters();
Taylor Brandstetterba29c6a2016-06-27 23:30:35640 EXPECT_EQ(1u, params.encodings.size());
Taylor Brandstetterdb0cd9e2016-05-16 18:40:30641 EXPECT_TRUE(video_rtp_receiver_->SetParameters(params));
642
643 DestroyVideoRtpReceiver();
644}
645
pbos5214a0a2016-12-16 23:39:11646// Test that makes sure that a video track content hint translates to the proper
647// value for sources that are not screencast.
648TEST_F(RtpSenderReceiverTest, PropagatesVideoTrackContentHint) {
649 CreateVideoRtpSender();
650
651 video_track_->set_enabled(true);
652
653 // |video_track_| is not screencast by default.
654 EXPECT_EQ(rtc::Optional<bool>(false),
655 video_media_channel_->options().is_screencast);
656 // No content hint should be set by default.
657 EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
658 video_track_->content_hint());
659 // Setting detailed should turn a non-screencast source into screencast mode.
660 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
661 EXPECT_EQ(rtc::Optional<bool>(true),
662 video_media_channel_->options().is_screencast);
663 // Removing the content hint should turn the track back into non-screencast
664 // mode.
665 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
666 EXPECT_EQ(rtc::Optional<bool>(false),
667 video_media_channel_->options().is_screencast);
668 // Setting fluid should remain in non-screencast mode (its default).
669 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
670 EXPECT_EQ(rtc::Optional<bool>(false),
671 video_media_channel_->options().is_screencast);
672
673 DestroyVideoRtpSender();
674}
675
676// Test that makes sure that a video track content hint translates to the proper
677// value for screencast sources.
678TEST_F(RtpSenderReceiverTest,
679 PropagatesVideoTrackContentHintForScreencastSource) {
680 CreateVideoRtpSender(true);
681
682 video_track_->set_enabled(true);
683
684 // |video_track_| with a screencast source should be screencast by default.
685 EXPECT_EQ(rtc::Optional<bool>(true),
686 video_media_channel_->options().is_screencast);
687 // No content hint should be set by default.
688 EXPECT_EQ(VideoTrackInterface::ContentHint::kNone,
689 video_track_->content_hint());
690 // Setting fluid should turn a screencast source into non-screencast mode.
691 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kFluid);
692 EXPECT_EQ(rtc::Optional<bool>(false),
693 video_media_channel_->options().is_screencast);
694 // Removing the content hint should turn the track back into screencast mode.
695 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
696 EXPECT_EQ(rtc::Optional<bool>(true),
697 video_media_channel_->options().is_screencast);
698 // Setting detailed should still remain in screencast mode (its default).
699 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
700 EXPECT_EQ(rtc::Optional<bool>(true),
701 video_media_channel_->options().is_screencast);
702
703 DestroyVideoRtpSender();
704}
705
706// Test that makes sure any content hints that are set on a track before
707// VideoRtpSender is ready to send are still applied when it gets ready to send.
708TEST_F(RtpSenderReceiverTest,
709 PropagatesVideoTrackContentHintSetBeforeEnabling) {
710 AddVideoTrack();
711 // Setting detailed overrides the default non-screencast mode. This should be
712 // applied even if the track is set on construction.
713 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
deadbeefe814a0d2017-02-26 02:15:09714 video_rtp_sender_ =
715 new VideoRtpSender(local_stream_->GetVideoTracks()[0],
Steve Anton8ffb9c32017-08-31 22:45:38716 {local_stream_->label()}, video_channel_);
pbos5214a0a2016-12-16 23:39:11717 video_track_->set_enabled(true);
718
719 // Sender is not ready to send (no SSRC) so no option should have been set.
720 EXPECT_EQ(rtc::Optional<bool>(),
721 video_media_channel_->options().is_screencast);
722
723 // Verify that the content hint is accounted for when video_rtp_sender_ does
724 // get enabled.
725 video_rtp_sender_->SetSsrc(kVideoSsrc);
726 EXPECT_EQ(rtc::Optional<bool>(true),
727 video_media_channel_->options().is_screencast);
728
729 // And removing the hint should go back to false (to verify that false was
730 // default correctly).
731 video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
732 EXPECT_EQ(rtc::Optional<bool>(false),
733 video_media_channel_->options().is_screencast);
734
735 DestroyVideoRtpSender();
736}
737
deadbeef20cb0c12017-02-02 04:27:00738TEST_F(RtpSenderReceiverTest, AudioSenderHasDtmfSender) {
739 CreateAudioRtpSender();
740 EXPECT_NE(nullptr, audio_rtp_sender_->GetDtmfSender());
741}
742
743TEST_F(RtpSenderReceiverTest, VideoSenderDoesNotHaveDtmfSender) {
744 CreateVideoRtpSender();
745 EXPECT_EQ(nullptr, video_rtp_sender_->GetDtmfSender());
746}
747
748// Test that the DTMF sender is really using |voice_channel_|, and thus returns
749// true/false from CanSendDtmf based on what |voice_channel_| returns.
750TEST_F(RtpSenderReceiverTest, CanInsertDtmf) {
751 AddDtmfCodec();
752 CreateAudioRtpSender();
753 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
754 ASSERT_NE(nullptr, dtmf_sender);
755 EXPECT_TRUE(dtmf_sender->CanInsertDtmf());
756}
757
758TEST_F(RtpSenderReceiverTest, CanNotInsertDtmf) {
759 CreateAudioRtpSender();
760 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
761 ASSERT_NE(nullptr, dtmf_sender);
762 // DTMF codec has not been added, as it was in the above test.
763 EXPECT_FALSE(dtmf_sender->CanInsertDtmf());
764}
765
766TEST_F(RtpSenderReceiverTest, InsertDtmf) {
767 AddDtmfCodec();
768 CreateAudioRtpSender();
769 auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
770 ASSERT_NE(nullptr, dtmf_sender);
771
772 EXPECT_EQ(0U, voice_media_channel_->dtmf_info_queue().size());
773
774 // Insert DTMF
775 const int expected_duration = 90;
776 dtmf_sender->InsertDtmf("012", expected_duration, 100);
777
778 // Verify
779 ASSERT_EQ_WAIT(3U, voice_media_channel_->dtmf_info_queue().size(),
780 kDefaultTimeout);
781 const uint32_t send_ssrc =
782 voice_media_channel_->send_streams()[0].first_ssrc();
783 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[0],
784 send_ssrc, 0, expected_duration));
785 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[1],
786 send_ssrc, 1, expected_duration));
787 EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[2],
788 send_ssrc, 2, expected_duration));
789}
790
791// Make sure the signal from "GetOnDestroyedSignal()" fires when the sender is
792// destroyed, which is needed for the DTMF sender.
793TEST_F(RtpSenderReceiverTest, TestOnDestroyedSignal) {
794 CreateAudioRtpSender();
795 EXPECT_FALSE(audio_sender_destroyed_signal_fired_);
796 audio_rtp_sender_ = nullptr;
797 EXPECT_TRUE(audio_sender_destroyed_signal_fired_);
798}
799
deadbeef70ab1a12015-09-28 23:53:55800} // namespace webrtc