blob: 7cc5dec8af7e8e0309e4f39b591fe245f1b780cb [file] [log] [blame]
jlmiller@webrtc.org5f93d0a2015-01-20 21:36:131/*
kjellander65c7f672016-02-12 08:05:012 * Copyright 2009 The WebRTC project authors. All Rights Reserved.
jlmiller@webrtc.org5f93d0a2015-01-20 21:36:133 *
kjellander65c7f672016-02-12 08:05:014 * 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.
jlmiller@webrtc.org5f93d0a2015-01-20 21:36:139 */
henrike@webrtc.org28e20752013-07-10 00:45:3610
kwiberg31022942016-03-11 22:18:2111#include <memory>
Mirko Bonadeic61ce0d2017-11-21 16:04:2012#include <utility>
kwiberg31022942016-03-11 22:18:2113
Mirko Bonadei92ea95e2017-09-15 04:47:3114#include "api/array_view.h"
15#include "media/base/fakemediaengine.h"
16#include "media/base/fakertp.h"
17#include "media/base/mediachannel.h"
18#include "media/base/testutils.h"
19#include "p2p/base/fakecandidatepair.h"
20#include "p2p/base/fakedtlstransport.h"
21#include "p2p/base/fakepackettransport.h"
22#include "pc/channel.h"
23#include "rtc_base/buffer.h"
24#include "rtc_base/checks.h"
25#include "rtc_base/fakeclock.h"
26#include "rtc_base/gunit.h"
27#include "rtc_base/logging.h"
28#include "rtc_base/sslstreamadapter.h"
henrike@webrtc.org28e20752013-07-10 00:45:3629
henrike@webrtc.org28e20752013-07-10 00:45:3630using cricket::CA_OFFER;
31using cricket::CA_PRANSWER;
32using cricket::CA_ANSWER;
zhihuangb2cdd932017-01-20 00:54:2533using cricket::DtlsTransportInternal;
henrike@webrtc.org28e20752013-07-10 00:45:3634using cricket::FakeVoiceMediaChannel;
henrike@webrtc.org28e20752013-07-10 00:45:3635using cricket::StreamParams;
Steve Anton4e70a722017-11-28 22:57:1036using webrtc::RtpTransceiverDirection;
henrike@webrtc.org28e20752013-07-10 00:45:3637
Danil Chapovalov33b01f22016-05-11 17:55:2738namespace {
39const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1);
40const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1);
41const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1);
perkj26752742016-10-24 08:21:1642const cricket::VideoCodec kH264Codec(97, "H264");
43const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC");
Danil Chapovalov33b01f22016-05-11 17:55:2744const cricket::DataCodec kGoogleDataCodec(101, "google-data");
45const uint32_t kSsrc1 = 0x1111;
46const uint32_t kSsrc2 = 0x2222;
Danil Chapovalov33b01f22016-05-11 17:55:2747const int kAudioPts[] = {0, 8};
48const int kVideoPts[] = {97, 99};
49enum class NetworkIsWorker { Yes, No };
deadbeefc6b6e092016-12-01 20:49:2050const int kDefaultTimeout = 10000; // 10 seconds.
Danil Chapovalov33b01f22016-05-11 17:55:2751} // namespace
henrike@webrtc.org28e20752013-07-10 00:45:3652
deadbeefcbecd352015-09-23 18:50:2753template <class ChannelT,
54 class MediaChannelT,
55 class ContentT,
56 class CodecT,
57 class MediaInfoT,
58 class OptionsT>
henrike@webrtc.org28e20752013-07-10 00:45:3659class Traits {
60 public:
61 typedef ChannelT Channel;
62 typedef MediaChannelT MediaChannel;
63 typedef ContentT Content;
64 typedef CodecT Codec;
65 typedef MediaInfoT MediaInfo;
Fredrik Solenbergb071a192015-09-17 14:42:5666 typedef OptionsT Options;
henrike@webrtc.org28e20752013-07-10 00:45:3667};
68
henrike@webrtc.org28e20752013-07-10 00:45:3669class VoiceTraits : public Traits<cricket::VoiceChannel,
70 cricket::FakeVoiceMediaChannel,
71 cricket::AudioContentDescription,
72 cricket::AudioCodec,
Fredrik Solenbergb071a192015-09-17 14:42:5673 cricket::VoiceMediaInfo,
deadbeefcbecd352015-09-23 18:50:2774 cricket::AudioOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:3675
76class VideoTraits : public Traits<cricket::VideoChannel,
77 cricket::FakeVideoMediaChannel,
78 cricket::VideoContentDescription,
79 cricket::VideoCodec,
Fredrik Solenbergb071a192015-09-17 14:42:5680 cricket::VideoMediaInfo,
deadbeefcbecd352015-09-23 18:50:2781 cricket::VideoOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:3682
deadbeef953c2ce2017-01-09 22:53:4183class DataTraits : public Traits<cricket::RtpDataChannel,
henrike@webrtc.org28e20752013-07-10 00:45:3684 cricket::FakeDataMediaChannel,
85 cricket::DataContentDescription,
86 cricket::DataCodec,
Fredrik Solenbergb071a192015-09-17 14:42:5687 cricket::DataMediaInfo,
deadbeefcbecd352015-09-23 18:50:2788 cricket::DataOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:3689
deadbeef953c2ce2017-01-09 22:53:4190// Base class for Voice/Video/RtpDataChannel tests
henrike@webrtc.org28e20752013-07-10 00:45:3691template<class T>
92class ChannelTest : public testing::Test, public sigslot::has_slots<> {
93 public:
deadbeefac22f702017-01-13 05:59:2994 enum Flags {
95 RTCP_MUX = 0x1,
96 RTCP_MUX_REQUIRED = 0x2,
97 SECURE = 0x4,
98 SSRC_MUX = 0x8,
99 DTLS = 0x10,
deadbeef5bd5ca32017-02-10 19:31:50100 // Use BaseChannel with PacketTransportInternal rather than
deadbeeff5346592017-01-25 05:51:21101 // DtlsTransportInternal.
deadbeef7914b8c2017-04-21 10:23:33102 RAW_PACKET_TRANSPORT = 0x20,
jbauch5869f502017-06-29 19:31:36103 GCM_CIPHER = 0x40,
104 ENCRYPTED_HEADERS = 0x80,
deadbeefac22f702017-01-13 05:59:29105 };
henrike@webrtc.org28e20752013-07-10 00:45:36106
Peter Boström34fbfff2015-09-24 17:20:30107 ChannelTest(bool verify_playout,
Danil Chapovalov33b01f22016-05-11 17:55:27108 rtc::ArrayView<const uint8_t> rtp_data,
109 rtc::ArrayView<const uint8_t> rtcp_data,
110 NetworkIsWorker network_is_worker)
Peter Boström34fbfff2015-09-24 17:20:30111 : verify_playout_(verify_playout),
Danil Chapovalov33b01f22016-05-11 17:55:27112 rtp_packet_(rtp_data.data(), rtp_data.size()),
deadbeeff5346592017-01-25 05:51:21113 rtcp_packet_(rtcp_data.data(), rtcp_data.size()) {
Danil Chapovalov33b01f22016-05-11 17:55:27114 if (network_is_worker == NetworkIsWorker::Yes) {
115 network_thread_ = rtc::Thread::Current();
116 } else {
117 network_thread_keeper_ = rtc::Thread::Create();
118 network_thread_keeper_->SetName("Network", nullptr);
Danil Chapovalov33b01f22016-05-11 17:55:27119 network_thread_ = network_thread_keeper_.get();
120 }
Danil Chapovalov33b01f22016-05-11 17:55:27121 }
henrike@webrtc.org28e20752013-07-10 00:45:36122
henrike@webrtc.org28e20752013-07-10 00:45:36123 void CreateChannels(int flags1, int flags2) {
Steve Anton8699a322017-11-06 23:53:33124 CreateChannels(rtc::MakeUnique<typename T::MediaChannel>(
125 nullptr, typename T::Options()),
126 rtc::MakeUnique<typename T::MediaChannel>(
127 nullptr, typename T::Options()),
Danil Chapovalov33b01f22016-05-11 17:55:27128 flags1, flags2);
henrike@webrtc.org28e20752013-07-10 00:45:36129 }
Steve Anton8699a322017-11-06 23:53:33130 void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1,
131 std::unique_ptr<typename T::MediaChannel> ch2,
Danil Chapovalov33b01f22016-05-11 17:55:27132 int flags1,
133 int flags2) {
deadbeeff5346592017-01-25 05:51:21134 // Network thread is started in CreateChannels, to allow the test to
135 // configure a fake clock before any threads are spawned and attempt to
136 // access the time.
137 if (network_thread_keeper_) {
138 network_thread_keeper_->Start();
139 }
deadbeefac22f702017-01-13 05:59:29140 // Make sure RTCP_MUX_REQUIRED isn't set without RTCP_MUX.
deadbeeff5346592017-01-25 05:51:21141 RTC_DCHECK_NE(RTCP_MUX_REQUIRED, flags1 & (RTCP_MUX | RTCP_MUX_REQUIRED));
142 RTC_DCHECK_NE(RTCP_MUX_REQUIRED, flags2 & (RTCP_MUX | RTCP_MUX_REQUIRED));
143 // Make sure if using raw packet transports, they're used for both
144 // channels.
145 RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT);
Danil Chapovalov33b01f22016-05-11 17:55:27146 rtc::Thread* worker_thread = rtc::Thread::Current();
Steve Anton8699a322017-11-06 23:53:33147 media_channel1_ = ch1.get();
148 media_channel2_ = ch2.get();
deadbeef5bd5ca32017-02-10 19:31:50149 rtc::PacketTransportInternal* rtp1 = nullptr;
150 rtc::PacketTransportInternal* rtcp1 = nullptr;
151 rtc::PacketTransportInternal* rtp2 = nullptr;
152 rtc::PacketTransportInternal* rtcp2 = nullptr;
deadbeeff5346592017-01-25 05:51:21153 // Based on flags, create fake DTLS or raw packet transports.
154 if (flags1 & RAW_PACKET_TRANSPORT) {
155 fake_rtp_packet_transport1_.reset(
156 new rtc::FakePacketTransport("channel1_rtp"));
157 rtp1 = fake_rtp_packet_transport1_.get();
158 if (!(flags1 & RTCP_MUX_REQUIRED)) {
159 fake_rtcp_packet_transport1_.reset(
160 new rtc::FakePacketTransport("channel1_rtcp"));
161 rtcp1 = fake_rtcp_packet_transport1_.get();
162 }
163 } else {
164 // Confirmed to work with KT_RSA and KT_ECDSA.
165 fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
166 "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP));
167 rtp1 = fake_rtp_dtls_transport1_.get();
168 if (!(flags1 & RTCP_MUX_REQUIRED)) {
169 fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
170 "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP));
171 rtcp1 = fake_rtcp_dtls_transport1_.get();
172 }
173 if (flags1 & DTLS) {
174 auto cert1 =
175 rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
176 rtc::SSLIdentity::Generate("session1", rtc::KT_DEFAULT)));
177 fake_rtp_dtls_transport1_->SetLocalCertificate(cert1);
178 if (fake_rtcp_dtls_transport1_) {
179 fake_rtcp_dtls_transport1_->SetLocalCertificate(cert1);
180 }
181 }
jbauch5869f502017-06-29 19:31:36182 if (flags1 & ENCRYPTED_HEADERS) {
183 rtc::CryptoOptions crypto_options;
184 crypto_options.enable_encrypted_rtp_header_extensions = true;
185 fake_rtp_dtls_transport1_->SetCryptoOptions(crypto_options);
186 if (fake_rtcp_dtls_transport1_) {
187 fake_rtcp_dtls_transport1_->SetCryptoOptions(crypto_options);
188 }
189 }
190 if (flags1 & GCM_CIPHER) {
191 fake_rtp_dtls_transport1_->SetSrtpCryptoSuite(
192 rtc::SRTP_AEAD_AES_256_GCM);
193 if (fake_rtcp_dtls_transport1_) {
194 fake_rtcp_dtls_transport1_->SetSrtpCryptoSuite(
195 rtc::SRTP_AEAD_AES_256_GCM);
196 }
197 }
deadbeeff5346592017-01-25 05:51:21198 }
199 // Based on flags, create fake DTLS or raw packet transports.
200 if (flags2 & RAW_PACKET_TRANSPORT) {
201 fake_rtp_packet_transport2_.reset(
202 new rtc::FakePacketTransport("channel2_rtp"));
203 rtp2 = fake_rtp_packet_transport2_.get();
204 if (!(flags2 & RTCP_MUX_REQUIRED)) {
205 fake_rtcp_packet_transport2_.reset(
206 new rtc::FakePacketTransport("channel2_rtcp"));
207 rtcp2 = fake_rtcp_packet_transport2_.get();
208 }
209 } else {
210 // Confirmed to work with KT_RSA and KT_ECDSA.
211 fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
212 "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP));
213 rtp2 = fake_rtp_dtls_transport2_.get();
214 if (!(flags2 & RTCP_MUX_REQUIRED)) {
215 fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
216 "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP));
217 rtcp2 = fake_rtcp_dtls_transport2_.get();
218 }
219 if (flags2 & DTLS) {
220 auto cert2 =
221 rtc::RTCCertificate::Create(std::unique_ptr<rtc::SSLIdentity>(
222 rtc::SSLIdentity::Generate("session2", rtc::KT_DEFAULT)));
223 fake_rtp_dtls_transport2_->SetLocalCertificate(cert2);
224 if (fake_rtcp_dtls_transport2_) {
225 fake_rtcp_dtls_transport2_->SetLocalCertificate(cert2);
226 }
227 }
jbauch5869f502017-06-29 19:31:36228 if (flags2 & ENCRYPTED_HEADERS) {
229 rtc::CryptoOptions crypto_options;
230 crypto_options.enable_encrypted_rtp_header_extensions = true;
231 fake_rtp_dtls_transport2_->SetCryptoOptions(crypto_options);
232 if (fake_rtcp_dtls_transport2_) {
233 fake_rtcp_dtls_transport2_->SetCryptoOptions(crypto_options);
234 }
235 }
236 if (flags2 & GCM_CIPHER) {
237 fake_rtp_dtls_transport2_->SetSrtpCryptoSuite(
238 rtc::SRTP_AEAD_AES_256_GCM);
239 if (fake_rtcp_dtls_transport2_) {
240 fake_rtcp_dtls_transport2_->SetSrtpCryptoSuite(
241 rtc::SRTP_AEAD_AES_256_GCM);
242 }
243 }
deadbeeff5346592017-01-25 05:51:21244 }
Steve Anton8699a322017-11-06 23:53:33245 channel1_ =
246 CreateChannel(worker_thread, network_thread_, &media_engine_,
247 std::move(ch1), fake_rtp_dtls_transport1_.get(),
248 fake_rtcp_dtls_transport1_.get(), rtp1, rtcp1, flags1);
249 channel2_ =
250 CreateChannel(worker_thread, network_thread_, &media_engine_,
251 std::move(ch2), fake_rtp_dtls_transport2_.get(),
252 fake_rtcp_dtls_transport2_.get(), rtp2, rtcp2, flags2);
Danil Chapovalov33b01f22016-05-11 17:55:27253 channel1_->SignalMediaMonitor.connect(this,
254 &ChannelTest<T>::OnMediaMonitor1);
255 channel2_->SignalMediaMonitor.connect(this,
256 &ChannelTest<T>::OnMediaMonitor2);
deadbeefac22f702017-01-13 05:59:29257 channel1_->SignalRtcpMuxFullyActive.connect(
deadbeeff5346592017-01-25 05:51:21258 this, &ChannelTest<T>::OnRtcpMuxFullyActive1);
deadbeefac22f702017-01-13 05:59:29259 channel2_->SignalRtcpMuxFullyActive.connect(
deadbeeff5346592017-01-25 05:51:21260 this, &ChannelTest<T>::OnRtcpMuxFullyActive2);
mallinath@webrtc.org19f27e62013-10-13 17:18:27261 if ((flags1 & DTLS) && (flags2 & DTLS)) {
262 flags1 = (flags1 & ~SECURE);
263 flags2 = (flags2 & ~SECURE);
264 }
henrike@webrtc.org28e20752013-07-10 00:45:36265 CreateContent(flags1, kPcmuCodec, kH264Codec,
266 &local_media_content1_);
267 CreateContent(flags2, kPcmuCodec, kH264Codec,
268 &local_media_content2_);
269 CopyContent(local_media_content1_, &remote_media_content1_);
270 CopyContent(local_media_content2_, &remote_media_content2_);
271
henrike@webrtc.org28e20752013-07-10 00:45:36272 // Add stream information (SSRC) to the local content but not to the remote
273 // content. This means that we per default know the SSRC of what we send but
274 // not what we receive.
275 AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_);
276 AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_);
277
278 // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
279 if (flags1 & SSRC_MUX) {
280 AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_);
281 }
282 if (flags2 & SSRC_MUX) {
283 AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
284 }
285 }
Steve Anton8699a322017-11-06 23:53:33286 std::unique_ptr<typename T::Channel> CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:27287 rtc::Thread* worker_thread,
288 rtc::Thread* network_thread,
deadbeefcbecd352015-09-23 18:50:27289 cricket::MediaEngineInterface* engine,
Steve Anton8699a322017-11-06 23:53:33290 std::unique_ptr<typename T::MediaChannel> ch,
deadbeeff5346592017-01-25 05:51:21291 cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
292 cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 19:31:50293 rtc::PacketTransportInternal* fake_rtp_packet_transport,
294 rtc::PacketTransportInternal* fake_rtcp_packet_transport,
jbauchcb560652016-08-04 12:20:32295 int flags) {
deadbeeff5346592017-01-25 05:51:21296 rtc::Thread* signaling_thread = rtc::Thread::Current();
Steve Anton8699a322017-11-06 23:53:33297 auto channel = rtc::MakeUnique<typename T::Channel>(
298 worker_thread, network_thread, signaling_thread, engine, std::move(ch),
deadbeefac22f702017-01-13 05:59:29299 cricket::CN_AUDIO, (flags & RTCP_MUX_REQUIRED) != 0,
300 (flags & SECURE) != 0);
deadbeeff5346592017-01-25 05:51:21301 if (!channel->NeedsRtcpTransport()) {
302 fake_rtcp_dtls_transport = nullptr;
zhihuangf5b251b2017-01-13 03:37:48303 }
Steve Anton8699a322017-11-06 23:53:33304 channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
305 fake_rtp_packet_transport, fake_rtcp_packet_transport);
henrike@webrtc.org28e20752013-07-10 00:45:36306 return channel;
307 }
308
deadbeeff5346592017-01-25 05:51:21309 void ConnectFakeTransports() {
310 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
311 bool asymmetric = false;
312 // Depending on test flags, could be using DTLS or raw packet transport.
313 if (fake_rtp_dtls_transport1_ && fake_rtp_dtls_transport2_) {
314 fake_rtp_dtls_transport1_->SetDestination(
315 fake_rtp_dtls_transport2_.get(), asymmetric);
316 }
317 if (fake_rtcp_dtls_transport1_ && fake_rtcp_dtls_transport2_) {
318 fake_rtcp_dtls_transport1_->SetDestination(
319 fake_rtcp_dtls_transport2_.get(), asymmetric);
320 }
321 if (fake_rtp_packet_transport1_ && fake_rtp_packet_transport2_) {
322 fake_rtp_packet_transport1_->SetDestination(
323 fake_rtp_packet_transport2_.get(), asymmetric);
324 }
325 if (fake_rtcp_packet_transport1_ && fake_rtcp_packet_transport2_) {
326 fake_rtcp_packet_transport1_->SetDestination(
327 fake_rtcp_packet_transport2_.get(), asymmetric);
328 }
329 });
330 }
331
henrike@webrtc.org28e20752013-07-10 00:45:36332 bool SendInitiate() {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54333 bool result = channel1_->SetLocalContent(&local_media_content1_,
334 CA_OFFER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36335 if (result) {
336 channel1_->Enable(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54337 result = channel2_->SetRemoteContent(&remote_media_content1_,
338 CA_OFFER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36339 if (result) {
deadbeeff5346592017-01-25 05:51:21340 ConnectFakeTransports();
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54341 result = channel2_->SetLocalContent(&local_media_content2_,
342 CA_ANSWER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36343 }
344 }
345 return result;
346 }
347
348 bool SendAccept() {
349 channel2_->Enable(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54350 return channel1_->SetRemoteContent(&remote_media_content2_,
351 CA_ANSWER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36352 }
353
354 bool SendOffer() {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54355 bool result = channel1_->SetLocalContent(&local_media_content1_,
356 CA_OFFER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36357 if (result) {
358 channel1_->Enable(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54359 result = channel2_->SetRemoteContent(&remote_media_content1_,
360 CA_OFFER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36361 }
362 return result;
363 }
364
365 bool SendProvisionalAnswer() {
366 bool result = channel2_->SetLocalContent(&local_media_content2_,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54367 CA_PRANSWER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36368 if (result) {
369 channel2_->Enable(true);
370 result = channel1_->SetRemoteContent(&remote_media_content2_,
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54371 CA_PRANSWER, NULL);
deadbeeff5346592017-01-25 05:51:21372 ConnectFakeTransports();
henrike@webrtc.org28e20752013-07-10 00:45:36373 }
374 return result;
375 }
376
377 bool SendFinalAnswer() {
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54378 bool result = channel2_->SetLocalContent(&local_media_content2_,
379 CA_ANSWER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36380 if (result)
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54381 result = channel1_->SetRemoteContent(&remote_media_content2_,
382 CA_ANSWER, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36383 return result;
384 }
385
deadbeeff5346592017-01-25 05:51:21386 bool Terminate() {
henrike@webrtc.org28e20752013-07-10 00:45:36387 channel1_.reset();
388 channel2_.reset();
deadbeeff5346592017-01-25 05:51:21389 fake_rtp_dtls_transport1_.reset();
390 fake_rtcp_dtls_transport1_.reset();
391 fake_rtp_dtls_transport2_.reset();
392 fake_rtcp_dtls_transport2_.reset();
393 fake_rtp_packet_transport1_.reset();
394 fake_rtcp_packet_transport1_.reset();
395 fake_rtp_packet_transport2_.reset();
396 fake_rtcp_packet_transport2_.reset();
397 if (network_thread_keeper_) {
398 network_thread_keeper_.reset();
399 }
henrike@webrtc.org28e20752013-07-10 00:45:36400 return true;
401 }
402
403 bool AddStream1(int id) {
404 return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
405 }
406 bool RemoveStream1(int id) {
407 return channel1_->RemoveRecvStream(id);
408 }
409
Danil Chapovalov33b01f22016-05-11 17:55:27410 void SendRtp1() {
411 media_channel1_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
412 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36413 }
Danil Chapovalov33b01f22016-05-11 17:55:27414 void SendRtp2() {
415 media_channel2_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
416 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36417 }
Danil Chapovalov33b01f22016-05-11 17:55:27418 void SendRtcp1() {
419 media_channel1_->SendRtcp(rtcp_packet_.data(), rtcp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36420 }
Danil Chapovalov33b01f22016-05-11 17:55:27421 void SendRtcp2() {
422 media_channel2_->SendRtcp(rtcp_packet_.data(), rtcp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36423 }
424 // Methods to send custom data.
Danil Chapovalov33b01f22016-05-11 17:55:27425 void SendCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
426 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
427 media_channel1_->SendRtp(data.data(), data.size(), rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36428 }
Danil Chapovalov33b01f22016-05-11 17:55:27429 void SendCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
430 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
431 media_channel2_->SendRtp(data.data(), data.size(), rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36432 }
Danil Chapovalov33b01f22016-05-11 17:55:27433 void SendCustomRtcp1(uint32_t ssrc) {
434 rtc::Buffer data = CreateRtcpData(ssrc);
435 media_channel1_->SendRtcp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36436 }
Danil Chapovalov33b01f22016-05-11 17:55:27437 void SendCustomRtcp2(uint32_t ssrc) {
438 rtc::Buffer data = CreateRtcpData(ssrc);
439 media_channel2_->SendRtcp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36440 }
Danil Chapovalov33b01f22016-05-11 17:55:27441
henrike@webrtc.org28e20752013-07-10 00:45:36442 bool CheckRtp1() {
Danil Chapovalov33b01f22016-05-11 17:55:27443 return media_channel1_->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36444 }
445 bool CheckRtp2() {
Danil Chapovalov33b01f22016-05-11 17:55:27446 return media_channel2_->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36447 }
448 bool CheckRtcp1() {
Danil Chapovalov33b01f22016-05-11 17:55:27449 return media_channel1_->CheckRtcp(rtcp_packet_.data(), rtcp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36450 }
451 bool CheckRtcp2() {
Danil Chapovalov33b01f22016-05-11 17:55:27452 return media_channel2_->CheckRtcp(rtcp_packet_.data(), rtcp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36453 }
454 // Methods to check custom data.
Peter Boström0c4e06b2015-10-07 10:23:21455 bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
Danil Chapovalov33b01f22016-05-11 17:55:27456 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
457 return media_channel1_->CheckRtp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36458 }
Peter Boström0c4e06b2015-10-07 10:23:21459 bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
Danil Chapovalov33b01f22016-05-11 17:55:27460 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
461 return media_channel2_->CheckRtp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36462 }
Peter Boström0c4e06b2015-10-07 10:23:21463 bool CheckCustomRtcp1(uint32_t ssrc) {
Danil Chapovalov33b01f22016-05-11 17:55:27464 rtc::Buffer data = CreateRtcpData(ssrc);
465 return media_channel1_->CheckRtcp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36466 }
Peter Boström0c4e06b2015-10-07 10:23:21467 bool CheckCustomRtcp2(uint32_t ssrc) {
Danil Chapovalov33b01f22016-05-11 17:55:27468 rtc::Buffer data = CreateRtcpData(ssrc);
469 return media_channel2_->CheckRtcp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36470 }
Danil Chapovalov33b01f22016-05-11 17:55:27471 rtc::Buffer CreateRtpData(uint32_t ssrc, int sequence_number, int pl_type) {
472 rtc::Buffer data(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36473 // Set SSRC in the rtp packet copy.
Danil Chapovalov33b01f22016-05-11 17:55:27474 rtc::SetBE32(data.data() + 8, ssrc);
475 rtc::SetBE16(data.data() + 2, sequence_number);
buildbot@webrtc.org5ee0f052014-05-05 20:18:08476 if (pl_type >= 0) {
Danil Chapovalov33b01f22016-05-11 17:55:27477 rtc::Set8(data.data(), 1, static_cast<uint8_t>(pl_type));
buildbot@webrtc.org5ee0f052014-05-05 20:18:08478 }
henrike@webrtc.org28e20752013-07-10 00:45:36479 return data;
480 }
Danil Chapovalov33b01f22016-05-11 17:55:27481 rtc::Buffer CreateRtcpData(uint32_t ssrc) {
482 rtc::Buffer data(rtcp_packet_.data(), rtcp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36483 // Set SSRC in the rtcp packet copy.
Danil Chapovalov33b01f22016-05-11 17:55:27484 rtc::SetBE32(data.data() + 4, ssrc);
henrike@webrtc.org28e20752013-07-10 00:45:36485 return data;
486 }
487
488 bool CheckNoRtp1() {
489 return media_channel1_->CheckNoRtp();
490 }
491 bool CheckNoRtp2() {
492 return media_channel2_->CheckNoRtp();
493 }
494 bool CheckNoRtcp1() {
495 return media_channel1_->CheckNoRtcp();
496 }
497 bool CheckNoRtcp2() {
498 return media_channel2_->CheckNoRtcp();
499 }
500
501 void CreateContent(int flags,
502 const cricket::AudioCodec& audio_codec,
503 const cricket::VideoCodec& video_codec,
504 typename T::Content* content) {
505 // overridden in specialized classes
506 }
507 void CopyContent(const typename T::Content& source,
508 typename T::Content* content) {
509 // overridden in specialized classes
510 }
511
Steve Anton18ee1d52017-09-11 18:32:35512 // Creates a MediaContent with one stream.
henrike@webrtc.org28e20752013-07-10 00:45:36513 // kPcmuCodec is used as audio codec and kH264Codec is used as video codec.
Steve Anton18ee1d52017-09-11 18:32:35514 typename T::Content* CreateMediaContentWithStream(uint32_t ssrc) {
515 typename T::Content* content = new typename T::Content();
516 CreateContent(SECURE, kPcmuCodec, kH264Codec, content);
517 AddLegacyStreamInContent(ssrc, 0, content);
518 return content;
henrike@webrtc.org28e20752013-07-10 00:45:36519 }
520
ossu292d6582016-03-17 09:31:13521 // Will manage the lifetime of a CallThread, making sure it's
522 // destroyed before this object goes out of scope.
523 class ScopedCallThread {
524 public:
Danil Chapovalov33b01f22016-05-11 17:55:27525 template <class FunctorT>
Steve Anton36b29d12017-10-30 16:57:42526 explicit ScopedCallThread(const FunctorT& functor)
Danil Chapovalov33b01f22016-05-11 17:55:27527 : thread_(rtc::Thread::Create()),
528 task_(new rtc::FunctorMessageHandler<void, FunctorT>(functor)) {
ossu292d6582016-03-17 09:31:13529 thread_->Start();
Taylor Brandstetter5d97a9a2016-06-10 21:17:27530 thread_->Post(RTC_FROM_HERE, task_.get());
ossu292d6582016-03-17 09:31:13531 }
532
Danil Chapovalov33b01f22016-05-11 17:55:27533 ~ScopedCallThread() { thread_->Stop(); }
ossu292d6582016-03-17 09:31:13534
Danil Chapovalov33b01f22016-05-11 17:55:27535 rtc::Thread* thread() { return thread_.get(); }
ossu292d6582016-03-17 09:31:13536
537 private:
Danil Chapovalov33b01f22016-05-11 17:55:27538 std::unique_ptr<rtc::Thread> thread_;
539 std::unique_ptr<rtc::MessageHandler> task_;
ossu292d6582016-03-17 09:31:13540 };
henrike@webrtc.org28e20752013-07-10 00:45:36541
henrike@webrtc.org28e20752013-07-10 00:45:36542 bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) {
543 return false; // overridden in specialized classes
544 }
545
Danil Chapovalov33b01f22016-05-11 17:55:27546 void OnMediaMonitor1(typename T::Channel* channel,
547 const typename T::MediaInfo& info) {
548 RTC_DCHECK_EQ(channel, channel1_.get());
549 media_info_callbacks1_++;
550 }
551 void OnMediaMonitor2(typename T::Channel* channel,
552 const typename T::MediaInfo& info) {
553 RTC_DCHECK_EQ(channel, channel2_.get());
554 media_info_callbacks2_++;
henrike@webrtc.org28e20752013-07-10 00:45:36555 }
deadbeeff5346592017-01-25 05:51:21556 void OnRtcpMuxFullyActive1(const std::string&) {
557 rtcp_mux_activated_callbacks1_++;
558 }
559 void OnRtcpMuxFullyActive2(const std::string&) {
560 rtcp_mux_activated_callbacks2_++;
561 }
henrike@webrtc.org28e20752013-07-10 00:45:36562
Honghai Zhangcc411c02016-03-30 00:27:21563 cricket::CandidatePairInterface* last_selected_candidate_pair() {
564 return last_selected_candidate_pair_;
565 }
566
Peter Boström0c4e06b2015-10-07 10:23:21567 void AddLegacyStreamInContent(uint32_t ssrc,
568 int flags,
569 typename T::Content* content) {
henrike@webrtc.org28e20752013-07-10 00:45:36570 // Base implementation.
571 }
572
573 // Tests that can be used by derived classes.
574
575 // Basic sanity check.
576 void TestInit() {
577 CreateChannels(0, 0);
Zhi Huangcf990f52017-09-22 19:12:30578 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:36579 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30580 if (verify_playout_) {
581 EXPECT_FALSE(media_channel1_->playout());
582 }
henrike@webrtc.org28e20752013-07-10 00:45:36583 EXPECT_TRUE(media_channel1_->codecs().empty());
584 EXPECT_TRUE(media_channel1_->recv_streams().empty());
585 EXPECT_TRUE(media_channel1_->rtp_packets().empty());
586 EXPECT_TRUE(media_channel1_->rtcp_packets().empty());
587 }
588
589 // Test that SetLocalContent and SetRemoteContent properly configure
590 // the codecs.
591 void TestSetContents() {
592 CreateChannels(0, 0);
593 typename T::Content content;
594 CreateContent(0, kPcmuCodec, kH264Codec, &content);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54595 EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36596 EXPECT_EQ(0U, media_channel1_->codecs().size());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54597 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36598 ASSERT_EQ(1U, media_channel1_->codecs().size());
599 EXPECT_TRUE(CodecMatches(content.codecs()[0],
600 media_channel1_->codecs()[0]));
601 }
602
603 // Test that SetLocalContent and SetRemoteContent properly deals
604 // with an empty offer.
605 void TestSetContentsNullOffer() {
606 CreateChannels(0, 0);
607 typename T::Content content;
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54608 EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36609 CreateContent(0, kPcmuCodec, kH264Codec, &content);
610 EXPECT_EQ(0U, media_channel1_->codecs().size());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54611 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36612 ASSERT_EQ(1U, media_channel1_->codecs().size());
613 EXPECT_TRUE(CodecMatches(content.codecs()[0],
614 media_channel1_->codecs()[0]));
615 }
616
617 // Test that SetLocalContent and SetRemoteContent properly set RTCP
618 // mux.
619 void TestSetContentsRtcpMux() {
deadbeefac22f702017-01-13 05:59:29620 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:36621 typename T::Content content;
622 CreateContent(0, kPcmuCodec, kH264Codec, &content);
623 // Both sides agree on mux. Should no longer be a separate RTCP channel.
624 content.set_rtcp_mux(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54625 EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
626 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36627 // Only initiator supports mux. Should still have a separate RTCP channel.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54628 EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36629 content.set_rtcp_mux(false);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54630 EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36631 }
632
633 // Test that SetLocalContent and SetRemoteContent properly set RTCP
634 // mux when a provisional answer is received.
635 void TestSetContentsRtcpMuxWithPrAnswer() {
deadbeefac22f702017-01-13 05:59:29636 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:36637 typename T::Content content;
638 CreateContent(0, kPcmuCodec, kH264Codec, &content);
639 content.set_rtcp_mux(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54640 EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
641 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER, NULL));
deadbeeff5346592017-01-25 05:51:21642 // Both sides agree on mux. Should signal RTCP mux as fully activated.
643 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54644 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
deadbeeff5346592017-01-25 05:51:21645 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
henrike@webrtc.org28e20752013-07-10 00:45:36646 // Only initiator supports mux. Should still have a separate RTCP channel.
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54647 EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36648 content.set_rtcp_mux(false);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54649 EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER, NULL));
650 EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
deadbeeff5346592017-01-25 05:51:21651 EXPECT_EQ(0, rtcp_mux_activated_callbacks2_);
henrike@webrtc.org28e20752013-07-10 00:45:36652 }
653
henrike@webrtc.org28e20752013-07-10 00:45:36654 // Test that Add/RemoveStream properly forward to the media channel.
655 void TestStreams() {
656 CreateChannels(0, 0);
657 EXPECT_TRUE(AddStream1(1));
658 EXPECT_TRUE(AddStream1(2));
659 EXPECT_EQ(2U, media_channel1_->recv_streams().size());
660 EXPECT_TRUE(RemoveStream1(2));
661 EXPECT_EQ(1U, media_channel1_->recv_streams().size());
662 EXPECT_TRUE(RemoveStream1(1));
663 EXPECT_EQ(0U, media_channel1_->recv_streams().size());
664 }
665
henrike@webrtc.org28e20752013-07-10 00:45:36666 // Test that SetLocalContent and SetRemoteContent properly
667 // handles adding and removing StreamParams when the action is a full
668 // CA_OFFER / CA_ANSWER.
669 void TestChangeStreamParamsInContent() {
670 cricket::StreamParams stream1;
671 stream1.groupid = "group1";
672 stream1.id = "stream1";
673 stream1.ssrcs.push_back(kSsrc1);
674 stream1.cname = "stream1_cname";
675
676 cricket::StreamParams stream2;
677 stream2.groupid = "group1";
678 stream2.id = "stream2";
679 stream2.ssrcs.push_back(kSsrc2);
680 stream2.cname = "stream2_cname";
681
682 // Setup a call where channel 1 send |stream1| to channel 2.
683 CreateChannels(0, 0);
684 typename T::Content content1;
685 CreateContent(0, kPcmuCodec, kH264Codec, &content1);
686 content1.AddStream(stream1);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54687 EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36688 EXPECT_TRUE(channel1_->Enable(true));
689 EXPECT_EQ(1u, media_channel1_->send_streams().size());
690
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54691 EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36692 EXPECT_EQ(1u, media_channel2_->recv_streams().size());
deadbeeff5346592017-01-25 05:51:21693 ConnectFakeTransports();
henrike@webrtc.org28e20752013-07-10 00:45:36694
695 // Channel 2 do not send anything.
696 typename T::Content content2;
697 CreateContent(0, kPcmuCodec, kH264Codec, &content2);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54698 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36699 EXPECT_EQ(0u, media_channel1_->recv_streams().size());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54700 EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36701 EXPECT_TRUE(channel2_->Enable(true));
702 EXPECT_EQ(0u, media_channel2_->send_streams().size());
703
Danil Chapovalov33b01f22016-05-11 17:55:27704 SendCustomRtp1(kSsrc1, 0);
705 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36706 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
707
708 // Let channel 2 update the content by sending |stream2| and enable SRTP.
709 typename T::Content content3;
710 CreateContent(SECURE, kPcmuCodec, kH264Codec, &content3);
711 content3.AddStream(stream2);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54712 EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36713 ASSERT_EQ(1u, media_channel2_->send_streams().size());
714 EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
715
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54716 EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36717 ASSERT_EQ(1u, media_channel1_->recv_streams().size());
718 EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
719
720 // Channel 1 replies but stop sending stream1.
721 typename T::Content content4;
722 CreateContent(SECURE, kPcmuCodec, kH264Codec, &content4);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54723 EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36724 EXPECT_EQ(0u, media_channel1_->send_streams().size());
725
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54726 EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36727 EXPECT_EQ(0u, media_channel2_->recv_streams().size());
728
Zhi Huangcf990f52017-09-22 19:12:30729 EXPECT_TRUE(channel1_->srtp_active());
730 EXPECT_TRUE(channel2_->srtp_active());
Danil Chapovalov33b01f22016-05-11 17:55:27731 SendCustomRtp2(kSsrc2, 0);
732 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36733 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
734 }
735
jbauch5869f502017-06-29 19:31:36736 enum EncryptedHeaderTestScenario {
737 // Offer/Answer are processed before DTLS completes.
738 DEFAULT,
739 // DTLS completes before any Offer/Answer have been sent.
740 DTLS_BEFORE_OFFER_ANSWER,
741 // DTLS completes after channel 2 has processed (remote) Offer and (local)
742 // Answer.
743 DTLS_AFTER_CHANNEL2_READY,
744 };
745
746 // Test that encrypted header extensions are working and can be changed when
747 // sending a new OFFER/ANSWER.
748 void TestChangeEncryptedHeaderExtensions(int flags,
749 EncryptedHeaderTestScenario scenario = DEFAULT) {
750 RTC_CHECK(scenario == 0 || (flags & DTLS));
751 struct PacketListener : public sigslot::has_slots<> {
752 PacketListener() {}
753 void OnReadPacket(rtc::PacketTransportInternal* transport,
754 const char* data, size_t size, const rtc::PacketTime& time,
755 int flags) {
756 CompareHeaderExtensions(
757 reinterpret_cast<const char*>(kPcmuFrameWithExtensions),
758 sizeof(kPcmuFrameWithExtensions), data, size, encrypted_headers,
759 false);
760 }
761 std::vector<int> encrypted_headers;
762 } packet_listener1, packet_listener2;
763
764 cricket::StreamParams stream1;
765 stream1.groupid = "group1";
766 stream1.id = "stream1";
767 stream1.ssrcs.push_back(kSsrc1);
768 stream1.cname = "stream1_cname";
769
770 cricket::StreamParams stream2;
771 stream2.groupid = "group1";
772 stream2.id = "stream2";
773 stream2.ssrcs.push_back(kSsrc2);
774 stream2.cname = "stream2_cname";
775
776 // Use SRTP when testing encrypted extensions.
777 int channel_flags = flags | SECURE | ENCRYPTED_HEADERS;
778 // Enable SDES if channel is not using DTLS.
779 int content_flags = (channel_flags & DTLS) == 0 ? SECURE : 0;
780
781 // kPcmuFrameWithExtensions contains RTP extension headers with ids 1-4.
782 // Make sure to use URIs that are supported for encryption.
783 cricket::RtpHeaderExtensions extensions1;
784 extensions1.push_back(
785 RtpExtension(RtpExtension::kAudioLevelUri, 10));
786 extensions1.push_back(
787 RtpExtension(RtpExtension::kAudioLevelUri, 1, true));
788
789 cricket::RtpHeaderExtensions extensions2;
790 extensions2.push_back(
791 RtpExtension(RtpExtension::kAudioLevelUri, 10));
792 extensions2.push_back(
793 RtpExtension(RtpExtension::kAudioLevelUri, 2, true));
794 extensions2.push_back(
795 RtpExtension(RtpExtension::kVideoRotationUri, 3));
796 extensions2.push_back(
797 RtpExtension(RtpExtension::kTimestampOffsetUri, 4, true));
798
799 // Setup a call where channel 1 send |stream1| to channel 2.
800 CreateChannels(channel_flags, channel_flags);
801 fake_rtp_dtls_transport1_->fake_ice_transport()->SignalReadPacket.connect(
802 &packet_listener1, &PacketListener::OnReadPacket);
803 fake_rtp_dtls_transport2_->fake_ice_transport()->SignalReadPacket.connect(
804 &packet_listener2, &PacketListener::OnReadPacket);
805
806 if (scenario == DTLS_BEFORE_OFFER_ANSWER) {
807 ConnectFakeTransports();
808 WaitForThreads();
809 }
810
811 typename T::Content content1;
812 CreateContent(content_flags, kPcmuCodec, kH264Codec, &content1);
813 content1.AddStream(stream1);
814 content1.set_rtp_header_extensions(extensions1);
815 EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
816 EXPECT_TRUE(channel1_->Enable(true));
817 EXPECT_EQ(1u, media_channel1_->send_streams().size());
818 packet_listener1.encrypted_headers.push_back(1);
819
820 EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
821 EXPECT_EQ(1u, media_channel2_->recv_streams().size());
822
823 // Channel 2 sends back |stream2|.
824 typename T::Content content2;
825 CreateContent(content_flags, kPcmuCodec, kH264Codec, &content2);
826 content2.AddStream(stream2);
827 content2.set_rtp_header_extensions(extensions1);
828 EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
829 EXPECT_TRUE(channel2_->Enable(true));
830 EXPECT_EQ(1u, media_channel2_->send_streams().size());
831 packet_listener2.encrypted_headers.push_back(1);
832
833 if (scenario == DTLS_AFTER_CHANNEL2_READY) {
834 ConnectFakeTransports();
835 WaitForThreads();
836 }
837
838 if (scenario == DTLS_BEFORE_OFFER_ANSWER ||
839 scenario == DTLS_AFTER_CHANNEL2_READY) {
840 // In both scenarios with partially completed Offer/Answer, sending
841 // packets from Channel 2 to Channel 1 should work.
842 SendCustomRtp2(kSsrc2, 0);
843 WaitForThreads();
844 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
845 }
846
847 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
848 EXPECT_EQ(1u, media_channel1_->recv_streams().size());
849
850 if (scenario == DEFAULT) {
851 ConnectFakeTransports();
852 WaitForThreads();
853 }
854
855 SendCustomRtp1(kSsrc1, 0);
856 SendCustomRtp2(kSsrc2, 0);
857 WaitForThreads();
858 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
859 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
860
861 // Let channel 2 update the encrypted header extensions.
862 typename T::Content content3;
863 CreateContent(content_flags, kPcmuCodec, kH264Codec, &content3);
864 content3.AddStream(stream2);
865 content3.set_rtp_header_extensions(extensions2);
866 EXPECT_TRUE(channel2_->SetLocalContent(&content3, CA_OFFER, NULL));
867 ASSERT_EQ(1u, media_channel2_->send_streams().size());
868 EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
869 packet_listener2.encrypted_headers.clear();
870 packet_listener2.encrypted_headers.push_back(2);
871 packet_listener2.encrypted_headers.push_back(4);
872
873 EXPECT_TRUE(channel1_->SetRemoteContent(&content3, CA_OFFER, NULL));
874 ASSERT_EQ(1u, media_channel1_->recv_streams().size());
875 EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
876
877 // Channel 1 is already sending the new encrypted extensions. These
878 // can be decrypted by channel 2. Channel 2 is still sending the old
879 // encrypted extensions (which can be decrypted by channel 1).
880
881 if (flags & DTLS) {
882 // DTLS supports updating the encrypted extensions with only the OFFER
883 // being processed. For SDES both the OFFER and ANSWER must have been
884 // processed to update encrypted extensions, so we can't check this case.
885 SendCustomRtp1(kSsrc1, 0);
886 SendCustomRtp2(kSsrc2, 0);
887 WaitForThreads();
888 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
889 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
890 }
891
892 // Channel 1 replies with the same extensions.
893 typename T::Content content4;
894 CreateContent(content_flags, kPcmuCodec, kH264Codec, &content4);
895 content4.AddStream(stream1);
896 content4.set_rtp_header_extensions(extensions2);
897 EXPECT_TRUE(channel1_->SetLocalContent(&content4, CA_ANSWER, NULL));
898 EXPECT_EQ(1u, media_channel1_->send_streams().size());
899 packet_listener1.encrypted_headers.clear();
900 packet_listener1.encrypted_headers.push_back(2);
901 packet_listener1.encrypted_headers.push_back(4);
902
903 EXPECT_TRUE(channel2_->SetRemoteContent(&content4, CA_ANSWER, NULL));
904 EXPECT_EQ(1u, media_channel2_->recv_streams().size());
905
906 SendCustomRtp1(kSsrc1, 0);
907 SendCustomRtp2(kSsrc2, 0);
908 WaitForThreads();
909 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
910 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
911 }
912
henrike@webrtc.org28e20752013-07-10 00:45:36913 // Test that we only start playout and sending at the right times.
914 void TestPlayoutAndSendingStates() {
915 CreateChannels(0, 0);
Peter Boström34fbfff2015-09-24 17:20:30916 if (verify_playout_) {
917 EXPECT_FALSE(media_channel1_->playout());
918 }
henrike@webrtc.org28e20752013-07-10 00:45:36919 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30920 if (verify_playout_) {
921 EXPECT_FALSE(media_channel2_->playout());
922 }
henrike@webrtc.org28e20752013-07-10 00:45:36923 EXPECT_FALSE(media_channel2_->sending());
924 EXPECT_TRUE(channel1_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30925 if (verify_playout_) {
926 EXPECT_FALSE(media_channel1_->playout());
927 }
henrike@webrtc.org28e20752013-07-10 00:45:36928 EXPECT_FALSE(media_channel1_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54929 EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
930 CA_OFFER, NULL));
Peter Boström34fbfff2015-09-24 17:20:30931 if (verify_playout_) {
932 EXPECT_TRUE(media_channel1_->playout());
933 }
henrike@webrtc.org28e20752013-07-10 00:45:36934 EXPECT_FALSE(media_channel1_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54935 EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_,
936 CA_OFFER, NULL));
Peter Boström34fbfff2015-09-24 17:20:30937 if (verify_playout_) {
938 EXPECT_FALSE(media_channel2_->playout());
939 }
henrike@webrtc.org28e20752013-07-10 00:45:36940 EXPECT_FALSE(media_channel2_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54941 EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_,
942 CA_ANSWER, NULL));
Peter Boström34fbfff2015-09-24 17:20:30943 if (verify_playout_) {
944 EXPECT_FALSE(media_channel2_->playout());
945 }
henrike@webrtc.org28e20752013-07-10 00:45:36946 EXPECT_FALSE(media_channel2_->sending());
deadbeeff5346592017-01-25 05:51:21947 ConnectFakeTransports();
Peter Boström34fbfff2015-09-24 17:20:30948 if (verify_playout_) {
949 EXPECT_TRUE(media_channel1_->playout());
950 }
henrike@webrtc.org28e20752013-07-10 00:45:36951 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30952 if (verify_playout_) {
953 EXPECT_FALSE(media_channel2_->playout());
954 }
henrike@webrtc.org28e20752013-07-10 00:45:36955 EXPECT_FALSE(media_channel2_->sending());
956 EXPECT_TRUE(channel2_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30957 if (verify_playout_) {
958 EXPECT_TRUE(media_channel2_->playout());
959 }
henrike@webrtc.org28e20752013-07-10 00:45:36960 EXPECT_TRUE(media_channel2_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54961 EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_,
962 CA_ANSWER, NULL));
Peter Boström34fbfff2015-09-24 17:20:30963 if (verify_playout_) {
964 EXPECT_TRUE(media_channel1_->playout());
965 }
henrike@webrtc.org28e20752013-07-10 00:45:36966 EXPECT_TRUE(media_channel1_->sending());
967 }
968
henrike@webrtc.org28e20752013-07-10 00:45:36969 // Test that changing the MediaContentDirection in the local and remote
970 // session description start playout and sending at the right time.
971 void TestMediaContentDirection() {
972 CreateChannels(0, 0);
973 typename T::Content content1;
974 CreateContent(0, kPcmuCodec, kH264Codec, &content1);
975 typename T::Content content2;
976 CreateContent(0, kPcmuCodec, kH264Codec, &content2);
977 // Set |content2| to be InActive.
Steve Anton4e70a722017-11-28 22:57:10978 content2.set_direction(RtpTransceiverDirection::kInactive);
henrike@webrtc.org28e20752013-07-10 00:45:36979
980 EXPECT_TRUE(channel1_->Enable(true));
981 EXPECT_TRUE(channel2_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30982 if (verify_playout_) {
983 EXPECT_FALSE(media_channel1_->playout());
984 }
henrike@webrtc.org28e20752013-07-10 00:45:36985 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30986 if (verify_playout_) {
987 EXPECT_FALSE(media_channel2_->playout());
988 }
henrike@webrtc.org28e20752013-07-10 00:45:36989 EXPECT_FALSE(media_channel2_->sending());
990
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54991 EXPECT_TRUE(channel1_->SetLocalContent(&content1, CA_OFFER, NULL));
992 EXPECT_TRUE(channel2_->SetRemoteContent(&content1, CA_OFFER, NULL));
993 EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
994 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
deadbeeff5346592017-01-25 05:51:21995 ConnectFakeTransports();
henrike@webrtc.org28e20752013-07-10 00:45:36996
Peter Boström34fbfff2015-09-24 17:20:30997 if (verify_playout_) {
998 EXPECT_TRUE(media_channel1_->playout());
999 }
henrike@webrtc.org28e20752013-07-10 00:45:361000 EXPECT_FALSE(media_channel1_->sending()); // remote InActive
Peter Boström34fbfff2015-09-24 17:20:301001 if (verify_playout_) {
1002 EXPECT_FALSE(media_channel2_->playout()); // local InActive
1003 }
henrike@webrtc.org28e20752013-07-10 00:45:361004 EXPECT_FALSE(media_channel2_->sending()); // local InActive
1005
1006 // Update |content2| to be RecvOnly.
Steve Anton4e70a722017-11-28 22:57:101007 content2.set_direction(RtpTransceiverDirection::kRecvOnly);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:541008 EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_PRANSWER, NULL));
1009 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_PRANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:361010
Peter Boström34fbfff2015-09-24 17:20:301011 if (verify_playout_) {
1012 EXPECT_TRUE(media_channel1_->playout());
1013 }
henrike@webrtc.org28e20752013-07-10 00:45:361014 EXPECT_TRUE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:301015 if (verify_playout_) {
1016 EXPECT_TRUE(media_channel2_->playout()); // local RecvOnly
1017 }
henrike@webrtc.org28e20752013-07-10 00:45:361018 EXPECT_FALSE(media_channel2_->sending()); // local RecvOnly
1019
1020 // Update |content2| to be SendRecv.
Steve Anton4e70a722017-11-28 22:57:101021 content2.set_direction(RtpTransceiverDirection::kSendRecv);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:541022 EXPECT_TRUE(channel2_->SetLocalContent(&content2, CA_ANSWER, NULL));
1023 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, CA_ANSWER, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:361024
Peter Boström34fbfff2015-09-24 17:20:301025 if (verify_playout_) {
1026 EXPECT_TRUE(media_channel1_->playout());
1027 }
henrike@webrtc.org28e20752013-07-10 00:45:361028 EXPECT_TRUE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:301029 if (verify_playout_) {
1030 EXPECT_TRUE(media_channel2_->playout());
1031 }
henrike@webrtc.org28e20752013-07-10 00:45:361032 EXPECT_TRUE(media_channel2_->sending());
1033 }
1034
Honghai Zhangcc411c02016-03-30 00:27:211035 // Tests that when the transport channel signals a candidate pair change
1036 // event, the media channel will receive a call on the network route change.
1037 void TestNetworkRouteChanges() {
eladalon05b07bb2017-08-24 14:40:161038 static constexpr uint16_t kLocalNetId = 1;
1039 static constexpr uint16_t kRemoteNetId = 2;
1040 static constexpr int kLastPacketId = 100;
Zhi Huang942bc2e2017-11-13 21:26:071041 // Ipv4(20) + UDP(8).
1042 static constexpr int kTransportOverheadPerPacket = 28;
Danil Chapovalov33b01f22016-05-11 17:55:271043
Honghai Zhangcc411c02016-03-30 00:27:211044 CreateChannels(0, 0);
1045
Honghai Zhangcc411c02016-03-30 00:27:211046 typename T::MediaChannel* media_channel1 =
1047 static_cast<typename T::MediaChannel*>(channel1_->media_channel());
Danil Chapovalov33b01f22016-05-11 17:55:271048 ASSERT_TRUE(media_channel1);
Honghai Zhangcc411c02016-03-30 00:27:211049
Zhi Huang942bc2e2017-11-13 21:26:071050 // Need to wait for the threads before calling
1051 // |set_num_network_route_changes| because the network route would be set
1052 // when creating the channel.
1053 WaitForThreads();
Danil Chapovalov33b01f22016-05-11 17:55:271054 media_channel1->set_num_network_route_changes(0);
deadbeeff5346592017-01-25 05:51:211055 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
Zhi Huang942bc2e2017-11-13 21:26:071056 rtc::NetworkRoute network_route;
Danil Chapovalov33b01f22016-05-11 17:55:271057 // The transport channel becomes disconnected.
Zhi Huang942bc2e2017-11-13 21:26:071058 fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
1059
1060 rtc::Optional<rtc::NetworkRoute>(network_route));
Danil Chapovalov33b01f22016-05-11 17:55:271061 });
1062 WaitForThreads();
1063 EXPECT_EQ(1, media_channel1->num_network_route_changes());
Honghai Zhangcc411c02016-03-30 00:27:211064 EXPECT_FALSE(media_channel1->last_network_route().connected);
Danil Chapovalov33b01f22016-05-11 17:55:271065 media_channel1->set_num_network_route_changes(0);
Honghai Zhangcc411c02016-03-30 00:27:211066
eladalon05b07bb2017-08-24 14:40:161067 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
Zhi Huang942bc2e2017-11-13 21:26:071068 rtc::NetworkRoute network_route;
1069 network_route.connected = true;
1070 network_route.local_network_id = kLocalNetId;
1071 network_route.remote_network_id = kRemoteNetId;
1072 network_route.last_sent_packet_id = kLastPacketId;
1073 network_route.packet_overhead = kTransportOverheadPerPacket;
Danil Chapovalov33b01f22016-05-11 17:55:271074 // The transport channel becomes connected.
Zhi Huang942bc2e2017-11-13 21:26:071075 fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
1076
1077 rtc::Optional<rtc::NetworkRoute>(network_route));
Danil Chapovalov33b01f22016-05-11 17:55:271078 });
1079 WaitForThreads();
1080 EXPECT_EQ(1, media_channel1->num_network_route_changes());
honghaiz059e1832016-06-24 18:03:551081 rtc::NetworkRoute expected_network_route(true, kLocalNetId, kRemoteNetId,
Danil Chapovalov33b01f22016-05-11 17:55:271082 kLastPacketId);
Honghai Zhangcc411c02016-03-30 00:27:211083 EXPECT_EQ(expected_network_route, media_channel1->last_network_route());
Danil Chapovalov33b01f22016-05-11 17:55:271084 EXPECT_EQ(kLastPacketId,
Honghai Zhang52dce73f2016-03-31 19:37:311085 media_channel1->last_network_route().last_sent_packet_id);
michaelt79e05882016-11-08 10:50:091086 EXPECT_EQ(kTransportOverheadPerPacket,
1087 media_channel1->transport_overhead_per_packet());
Honghai Zhangcc411c02016-03-30 00:27:211088 }
1089
henrike@webrtc.org28e20752013-07-10 00:45:361090 // Test setting up a call.
1091 void TestCallSetup() {
1092 CreateChannels(0, 0);
Zhi Huangcf990f52017-09-22 19:12:301093 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:361094 EXPECT_TRUE(SendInitiate());
Peter Boström34fbfff2015-09-24 17:20:301095 if (verify_playout_) {
1096 EXPECT_TRUE(media_channel1_->playout());
1097 }
henrike@webrtc.org28e20752013-07-10 00:45:361098 EXPECT_FALSE(media_channel1_->sending());
1099 EXPECT_TRUE(SendAccept());
Zhi Huangcf990f52017-09-22 19:12:301100 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:361101 EXPECT_TRUE(media_channel1_->sending());
1102 EXPECT_EQ(1U, media_channel1_->codecs().size());
Peter Boström34fbfff2015-09-24 17:20:301103 if (verify_playout_) {
1104 EXPECT_TRUE(media_channel2_->playout());
1105 }
henrike@webrtc.org28e20752013-07-10 00:45:361106 EXPECT_TRUE(media_channel2_->sending());
1107 EXPECT_EQ(1U, media_channel2_->codecs().size());
1108 }
1109
1110 // Test that we don't crash if packets are sent during call teardown
1111 // when RTCP mux is enabled. This is a regression test against a specific
1112 // race condition that would only occur when a RTCP packet was sent during
1113 // teardown of a channel on which RTCP mux was enabled.
1114 void TestCallTeardownRtcpMux() {
1115 class LastWordMediaChannel : public T::MediaChannel {
1116 public:
Fredrik Solenbergb071a192015-09-17 14:42:561117 LastWordMediaChannel() : T::MediaChannel(NULL, typename T::Options()) {}
henrike@webrtc.org28e20752013-07-10 00:45:361118 ~LastWordMediaChannel() {
stefanc1aeaf02015-10-15 14:26:071119 T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame),
1120 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:361121 T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
1122 }
1123 };
Steve Anton8699a322017-11-06 23:53:331124 CreateChannels(rtc::MakeUnique<LastWordMediaChannel>(),
1125 rtc::MakeUnique<LastWordMediaChannel>(), RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:361126 EXPECT_TRUE(SendInitiate());
1127 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211128 EXPECT_TRUE(Terminate());
henrike@webrtc.org28e20752013-07-10 00:45:361129 }
1130
1131 // Send voice RTP data to the other side and ensure it gets there.
1132 void SendRtpToRtp() {
deadbeefac22f702017-01-13 05:59:291133 CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
henrike@webrtc.org28e20752013-07-10 00:45:361134 EXPECT_TRUE(SendInitiate());
1135 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211136 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1137 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271138 SendRtp1();
1139 SendRtp2();
1140 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361141 EXPECT_TRUE(CheckRtp1());
1142 EXPECT_TRUE(CheckRtp2());
1143 EXPECT_TRUE(CheckNoRtp1());
1144 EXPECT_TRUE(CheckNoRtp2());
1145 }
1146
Danil Chapovalovdae07ba2016-05-13 23:43:501147 void TestDeinit() {
deadbeefac22f702017-01-13 05:59:291148 CreateChannels(0, 0);
Danil Chapovalovdae07ba2016-05-13 23:43:501149 EXPECT_TRUE(SendInitiate());
1150 EXPECT_TRUE(SendAccept());
1151 SendRtp1();
1152 SendRtp2();
1153 SendRtcp1();
1154 SendRtcp2();
1155 // Do not wait, destroy channels.
1156 channel1_.reset(nullptr);
1157 channel2_.reset(nullptr);
1158 }
1159
deadbeefac22f702017-01-13 05:59:291160 // Check that RTCP can be transmitted between both sides.
henrike@webrtc.org28e20752013-07-10 00:45:361161 void SendRtcpToRtcp() {
deadbeefac22f702017-01-13 05:59:291162 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361163 EXPECT_TRUE(SendInitiate());
1164 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211165 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1166 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271167 SendRtcp1();
1168 SendRtcp2();
1169 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361170 EXPECT_TRUE(CheckRtcp1());
1171 EXPECT_TRUE(CheckRtcp2());
1172 EXPECT_TRUE(CheckNoRtcp1());
1173 EXPECT_TRUE(CheckNoRtcp2());
1174 }
1175
1176 // Check that RTCP is transmitted if only the initiator supports mux.
1177 void SendRtcpMuxToRtcp() {
deadbeefac22f702017-01-13 05:59:291178 CreateChannels(RTCP_MUX, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361179 EXPECT_TRUE(SendInitiate());
1180 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211181 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1182 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271183 SendRtcp1();
1184 SendRtcp2();
1185 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361186 EXPECT_TRUE(CheckRtcp1());
1187 EXPECT_TRUE(CheckRtcp2());
1188 EXPECT_TRUE(CheckNoRtcp1());
1189 EXPECT_TRUE(CheckNoRtcp2());
1190 }
1191
1192 // Check that RTP and RTCP are transmitted ok when both sides support mux.
1193 void SendRtcpMuxToRtcpMux() {
deadbeefac22f702017-01-13 05:59:291194 CreateChannels(RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:361195 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211196 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1197 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
1198 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
henrike@webrtc.org28e20752013-07-10 00:45:361199 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211200 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1201 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
Danil Chapovalov33b01f22016-05-11 17:55:271202 SendRtp1();
1203 SendRtp2();
1204 SendRtcp1();
1205 SendRtcp2();
1206 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361207 EXPECT_TRUE(CheckRtp1());
1208 EXPECT_TRUE(CheckRtp2());
1209 EXPECT_TRUE(CheckNoRtp1());
1210 EXPECT_TRUE(CheckNoRtp2());
1211 EXPECT_TRUE(CheckRtcp1());
1212 EXPECT_TRUE(CheckRtcp2());
1213 EXPECT_TRUE(CheckNoRtcp1());
1214 EXPECT_TRUE(CheckNoRtcp2());
1215 }
1216
Peter Thatcheraf55ccc2015-05-21 14:48:411217 // Check that RTP and RTCP are transmitted ok when both sides
1218 // support mux and one the offerer requires mux.
1219 void SendRequireRtcpMuxToRtcpMux() {
deadbeefac22f702017-01-13 05:59:291220 CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX);
Peter Thatcheraf55ccc2015-05-21 14:48:411221 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211222 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1223 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
Peter Thatcheraf55ccc2015-05-21 14:48:411224 EXPECT_TRUE(SendAccept());
Danil Chapovalov33b01f22016-05-11 17:55:271225 SendRtp1();
1226 SendRtp2();
1227 SendRtcp1();
1228 SendRtcp2();
1229 WaitForThreads();
Peter Thatcheraf55ccc2015-05-21 14:48:411230 EXPECT_TRUE(CheckRtp1());
1231 EXPECT_TRUE(CheckRtp2());
1232 EXPECT_TRUE(CheckNoRtp1());
1233 EXPECT_TRUE(CheckNoRtp2());
1234 EXPECT_TRUE(CheckRtcp1());
1235 EXPECT_TRUE(CheckRtcp2());
1236 EXPECT_TRUE(CheckNoRtcp1());
1237 EXPECT_TRUE(CheckNoRtcp2());
1238 }
1239
1240 // Check that RTP and RTCP are transmitted ok when both sides
deadbeefac22f702017-01-13 05:59:291241 // support mux and only the answerer requires rtcp mux.
Peter Thatcheraf55ccc2015-05-21 14:48:411242 void SendRtcpMuxToRequireRtcpMux() {
deadbeefac22f702017-01-13 05:59:291243 CreateChannels(RTCP_MUX, RTCP_MUX | RTCP_MUX_REQUIRED);
Peter Thatcheraf55ccc2015-05-21 14:48:411244 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211245 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1246 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
1247 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
Peter Thatcheraf55ccc2015-05-21 14:48:411248 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211249 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1250 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
Danil Chapovalov33b01f22016-05-11 17:55:271251 SendRtp1();
1252 SendRtp2();
1253 SendRtcp1();
1254 SendRtcp2();
1255 WaitForThreads();
Peter Thatcheraf55ccc2015-05-21 14:48:411256 EXPECT_TRUE(CheckRtp1());
1257 EXPECT_TRUE(CheckRtp2());
1258 EXPECT_TRUE(CheckNoRtp1());
1259 EXPECT_TRUE(CheckNoRtp2());
1260 EXPECT_TRUE(CheckRtcp1());
1261 EXPECT_TRUE(CheckRtcp2());
1262 EXPECT_TRUE(CheckNoRtcp1());
1263 EXPECT_TRUE(CheckNoRtcp2());
1264 }
1265
1266 // Check that RTP and RTCP are transmitted ok when both sides
1267 // require mux.
1268 void SendRequireRtcpMuxToRequireRtcpMux() {
deadbeefac22f702017-01-13 05:59:291269 CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
Peter Thatcheraf55ccc2015-05-21 14:48:411270 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211271 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1272 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
Peter Thatcheraf55ccc2015-05-21 14:48:411273 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211274 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271275 SendRtp1();
1276 SendRtp2();
1277 SendRtcp1();
1278 SendRtcp2();
1279 WaitForThreads();
Peter Thatcheraf55ccc2015-05-21 14:48:411280 EXPECT_TRUE(CheckRtp1());
1281 EXPECT_TRUE(CheckRtp2());
1282 EXPECT_TRUE(CheckNoRtp1());
1283 EXPECT_TRUE(CheckNoRtp2());
1284 EXPECT_TRUE(CheckRtcp1());
1285 EXPECT_TRUE(CheckRtcp2());
1286 EXPECT_TRUE(CheckNoRtcp1());
1287 EXPECT_TRUE(CheckNoRtcp2());
1288 }
1289
1290 // Check that SendAccept fails if the answerer doesn't support mux
1291 // and the offerer requires it.
1292 void SendRequireRtcpMuxToNoRtcpMux() {
deadbeefac22f702017-01-13 05:59:291293 CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, 0);
Peter Thatcheraf55ccc2015-05-21 14:48:411294 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211295 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1296 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
Peter Thatcheraf55ccc2015-05-21 14:48:411297 EXPECT_FALSE(SendAccept());
1298 }
1299
henrike@webrtc.org28e20752013-07-10 00:45:361300 // Check that RTCP data sent by the initiator before the accept is not muxed.
1301 void SendEarlyRtcpMuxToRtcp() {
deadbeefac22f702017-01-13 05:59:291302 CreateChannels(RTCP_MUX, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361303 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211304 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1305 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
henrike@webrtc.org28e20752013-07-10 00:45:361306
1307 // RTCP can be sent before the call is accepted, if the transport is ready.
1308 // It should not be muxed though, as the remote side doesn't support mux.
Danil Chapovalov33b01f22016-05-11 17:55:271309 SendRtcp1();
1310 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361311 EXPECT_TRUE(CheckNoRtp2());
1312 EXPECT_TRUE(CheckRtcp2());
1313
1314 // Send RTCP packet from callee and verify that it is received.
Danil Chapovalov33b01f22016-05-11 17:55:271315 SendRtcp2();
1316 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361317 EXPECT_TRUE(CheckNoRtp1());
1318 EXPECT_TRUE(CheckRtcp1());
1319
1320 // Complete call setup and ensure everything is still OK.
1321 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211322 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271323 SendRtcp1();
1324 SendRtcp2();
1325 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361326 EXPECT_TRUE(CheckRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361327 EXPECT_TRUE(CheckRtcp1());
1328 }
1329
1330
1331 // Check that RTCP data is not muxed until both sides have enabled muxing,
1332 // but that we properly demux before we get the accept message, since there
1333 // is a race between RTP data and the jingle accept.
1334 void SendEarlyRtcpMuxToRtcpMux() {
deadbeefac22f702017-01-13 05:59:291335 CreateChannels(RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:361336 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211337 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1338 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
henrike@webrtc.org28e20752013-07-10 00:45:361339
1340 // RTCP can't be sent yet, since the RTCP transport isn't writable, and
1341 // we haven't yet received the accept that says we should mux.
Danil Chapovalov33b01f22016-05-11 17:55:271342 SendRtcp1();
1343 WaitForThreads();
1344 EXPECT_TRUE(CheckNoRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361345
1346 // Send muxed RTCP packet from callee and verify that it is received.
Danil Chapovalov33b01f22016-05-11 17:55:271347 SendRtcp2();
1348 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361349 EXPECT_TRUE(CheckNoRtp1());
1350 EXPECT_TRUE(CheckRtcp1());
1351
1352 // Complete call setup and ensure everything is still OK.
deadbeeff5346592017-01-25 05:51:211353 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
henrike@webrtc.org28e20752013-07-10 00:45:361354 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211355 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1356 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
Danil Chapovalov33b01f22016-05-11 17:55:271357 SendRtcp1();
1358 SendRtcp2();
1359 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361360 EXPECT_TRUE(CheckRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361361 EXPECT_TRUE(CheckRtcp1());
1362 }
1363
1364 // Test that we properly send SRTP with RTCP in both directions.
deadbeef7914b8c2017-04-21 10:23:331365 // You can pass in DTLS, RTCP_MUX, and RAW_PACKET_TRANSPORT as flags.
henrike@webrtc.org28e20752013-07-10 00:45:361366 void SendSrtpToSrtp(int flags1_in = 0, int flags2_in = 0) {
deadbeef7914b8c2017-04-21 10:23:331367 RTC_CHECK((flags1_in & ~(RTCP_MUX | DTLS | RAW_PACKET_TRANSPORT)) == 0);
1368 RTC_CHECK((flags2_in & ~(RTCP_MUX | DTLS | RAW_PACKET_TRANSPORT)) == 0);
henrike@webrtc.org28e20752013-07-10 00:45:361369
deadbeefac22f702017-01-13 05:59:291370 int flags1 = SECURE | flags1_in;
1371 int flags2 = SECURE | flags2_in;
henrike@webrtc.org28e20752013-07-10 00:45:361372 bool dtls1 = !!(flags1_in & DTLS);
1373 bool dtls2 = !!(flags2_in & DTLS);
1374 CreateChannels(flags1, flags2);
Zhi Huangcf990f52017-09-22 19:12:301375 EXPECT_FALSE(channel1_->srtp_active());
1376 EXPECT_FALSE(channel2_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:361377 EXPECT_TRUE(SendInitiate());
Danil Chapovalov33b01f22016-05-11 17:55:271378 WaitForThreads();
1379 EXPECT_TRUE(channel1_->writable());
1380 EXPECT_TRUE(channel2_->writable());
henrike@webrtc.org28e20752013-07-10 00:45:361381 EXPECT_TRUE(SendAccept());
Zhi Huangcf990f52017-09-22 19:12:301382 EXPECT_TRUE(channel1_->srtp_active());
1383 EXPECT_TRUE(channel2_->srtp_active());
1384 EXPECT_EQ(dtls1 && dtls2, channel1_->dtls_active());
1385 EXPECT_EQ(dtls1 && dtls2, channel2_->dtls_active());
Danil Chapovalov33b01f22016-05-11 17:55:271386 SendRtp1();
1387 SendRtp2();
1388 SendRtcp1();
1389 SendRtcp2();
1390 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361391 EXPECT_TRUE(CheckRtp1());
1392 EXPECT_TRUE(CheckRtp2());
1393 EXPECT_TRUE(CheckNoRtp1());
1394 EXPECT_TRUE(CheckNoRtp2());
1395 EXPECT_TRUE(CheckRtcp1());
1396 EXPECT_TRUE(CheckRtcp2());
1397 EXPECT_TRUE(CheckNoRtcp1());
1398 EXPECT_TRUE(CheckNoRtcp2());
1399 }
1400
Zhi Huangcd3fc5d2017-11-29 18:41:571401 // Test that the DTLS to SDES fallback is not supported and the negotiation
1402 // between DTLS to SDES end points will fail.
1403 void SendDtlsToSdesNotSupported() {
1404 int flags1 = SECURE | DTLS;
1405 int flags2 = SECURE;
1406 CreateChannels(flags1, flags2);
1407 EXPECT_FALSE(channel1_->srtp_active());
1408 EXPECT_FALSE(channel2_->srtp_active());
1409 EXPECT_FALSE(SendInitiate());
1410 }
1411
henrike@webrtc.org28e20752013-07-10 00:45:361412 // Test that we properly handling SRTP negotiating down to RTP.
1413 void SendSrtpToRtp() {
deadbeefac22f702017-01-13 05:59:291414 CreateChannels(SECURE, 0);
Zhi Huangcf990f52017-09-22 19:12:301415 EXPECT_FALSE(channel1_->srtp_active());
1416 EXPECT_FALSE(channel2_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:361417 EXPECT_TRUE(SendInitiate());
1418 EXPECT_TRUE(SendAccept());
Zhi Huangcf990f52017-09-22 19:12:301419 EXPECT_FALSE(channel1_->srtp_active());
1420 EXPECT_FALSE(channel2_->srtp_active());
Danil Chapovalov33b01f22016-05-11 17:55:271421 SendRtp1();
1422 SendRtp2();
1423 SendRtcp1();
1424 SendRtcp2();
1425 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361426 EXPECT_TRUE(CheckRtp1());
1427 EXPECT_TRUE(CheckRtp2());
1428 EXPECT_TRUE(CheckNoRtp1());
1429 EXPECT_TRUE(CheckNoRtp2());
1430 EXPECT_TRUE(CheckRtcp1());
1431 EXPECT_TRUE(CheckRtcp2());
1432 EXPECT_TRUE(CheckNoRtcp1());
1433 EXPECT_TRUE(CheckNoRtcp2());
1434 }
1435
1436 // Test that we can send and receive early media when a provisional answer is
1437 // sent and received. The test uses SRTP, RTCP mux and SSRC mux.
1438 void SendEarlyMediaUsingRtcpMuxSrtp() {
1439 int sequence_number1_1 = 0, sequence_number2_2 = 0;
1440
deadbeefac22f702017-01-13 05:59:291441 CreateChannels(SSRC_MUX | RTCP_MUX | SECURE,
1442 SSRC_MUX | RTCP_MUX | SECURE);
henrike@webrtc.org28e20752013-07-10 00:45:361443 EXPECT_TRUE(SendOffer());
1444 EXPECT_TRUE(SendProvisionalAnswer());
Zhi Huangcf990f52017-09-22 19:12:301445 EXPECT_TRUE(channel1_->srtp_active());
1446 EXPECT_TRUE(channel2_->srtp_active());
deadbeeff5346592017-01-25 05:51:211447 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1448 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271449 WaitForThreads(); // Wait for 'sending' flag go through network thread.
1450 SendCustomRtcp1(kSsrc1);
1451 SendCustomRtp1(kSsrc1, ++sequence_number1_1);
1452 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361453 EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:361454 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
1455
1456 // Send packets from callee and verify that it is received.
Danil Chapovalov33b01f22016-05-11 17:55:271457 SendCustomRtcp2(kSsrc2);
1458 SendCustomRtp2(kSsrc2, ++sequence_number2_2);
1459 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361460 EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:361461 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1462
1463 // Complete call setup and ensure everything is still OK.
deadbeeff5346592017-01-25 05:51:211464 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
1465 EXPECT_EQ(0, rtcp_mux_activated_callbacks2_);
henrike@webrtc.org28e20752013-07-10 00:45:361466 EXPECT_TRUE(SendFinalAnswer());
deadbeeff5346592017-01-25 05:51:211467 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1468 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
1469 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
1470 EXPECT_EQ(1, rtcp_mux_activated_callbacks2_);
Zhi Huangcf990f52017-09-22 19:12:301471 EXPECT_TRUE(channel1_->srtp_active());
1472 EXPECT_TRUE(channel2_->srtp_active());
Danil Chapovalov33b01f22016-05-11 17:55:271473 SendCustomRtcp1(kSsrc1);
1474 SendCustomRtp1(kSsrc1, ++sequence_number1_1);
1475 SendCustomRtcp2(kSsrc2);
1476 SendCustomRtp2(kSsrc2, ++sequence_number2_2);
1477 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361478 EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:361479 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
henrike@webrtc.org28e20752013-07-10 00:45:361480 EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:361481 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
1482 }
1483
1484 // Test that we properly send RTP without SRTP from a thread.
1485 void SendRtpToRtpOnThread() {
deadbeefac22f702017-01-13 05:59:291486 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361487 EXPECT_TRUE(SendInitiate());
1488 EXPECT_TRUE(SendAccept());
Danil Chapovalov33b01f22016-05-11 17:55:271489 ScopedCallThread send_rtp1([this] { SendRtp1(); });
1490 ScopedCallThread send_rtp2([this] { SendRtp2(); });
1491 ScopedCallThread send_rtcp1([this] { SendRtcp1(); });
1492 ScopedCallThread send_rtcp2([this] { SendRtcp2(); });
1493 rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread(),
1494 send_rtcp1.thread(),
1495 send_rtcp2.thread()};
1496 WaitForThreads(involved_threads);
1497 EXPECT_TRUE(CheckRtp1());
1498 EXPECT_TRUE(CheckRtp2());
henrike@webrtc.org28e20752013-07-10 00:45:361499 EXPECT_TRUE(CheckNoRtp1());
1500 EXPECT_TRUE(CheckNoRtp2());
Danil Chapovalov33b01f22016-05-11 17:55:271501 EXPECT_TRUE(CheckRtcp1());
1502 EXPECT_TRUE(CheckRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361503 EXPECT_TRUE(CheckNoRtcp1());
1504 EXPECT_TRUE(CheckNoRtcp2());
1505 }
1506
1507 // Test that we properly send SRTP with RTCP from a thread.
1508 void SendSrtpToSrtpOnThread() {
deadbeefac22f702017-01-13 05:59:291509 CreateChannels(SECURE, SECURE);
henrike@webrtc.org28e20752013-07-10 00:45:361510 EXPECT_TRUE(SendInitiate());
1511 EXPECT_TRUE(SendAccept());
Danil Chapovalov33b01f22016-05-11 17:55:271512 ScopedCallThread send_rtp1([this] { SendRtp1(); });
1513 ScopedCallThread send_rtp2([this] { SendRtp2(); });
1514 ScopedCallThread send_rtcp1([this] { SendRtcp1(); });
1515 ScopedCallThread send_rtcp2([this] { SendRtcp2(); });
1516 rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread(),
1517 send_rtcp1.thread(),
1518 send_rtcp2.thread()};
1519 WaitForThreads(involved_threads);
1520 EXPECT_TRUE(CheckRtp1());
1521 EXPECT_TRUE(CheckRtp2());
henrike@webrtc.org28e20752013-07-10 00:45:361522 EXPECT_TRUE(CheckNoRtp1());
1523 EXPECT_TRUE(CheckNoRtp2());
Danil Chapovalov33b01f22016-05-11 17:55:271524 EXPECT_TRUE(CheckRtcp1());
1525 EXPECT_TRUE(CheckRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361526 EXPECT_TRUE(CheckNoRtcp1());
1527 EXPECT_TRUE(CheckNoRtcp2());
1528 }
1529
1530 // Test that the mediachannel retains its sending state after the transport
1531 // becomes non-writable.
1532 void SendWithWritabilityLoss() {
deadbeefac22f702017-01-13 05:59:291533 CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
henrike@webrtc.org28e20752013-07-10 00:45:361534 EXPECT_TRUE(SendInitiate());
1535 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211536 EXPECT_FALSE(channel1_->NeedsRtcpTransport());
1537 EXPECT_FALSE(channel2_->NeedsRtcpTransport());
Danil Chapovalov33b01f22016-05-11 17:55:271538 SendRtp1();
1539 SendRtp2();
1540 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361541 EXPECT_TRUE(CheckRtp1());
1542 EXPECT_TRUE(CheckRtp2());
1543 EXPECT_TRUE(CheckNoRtp1());
1544 EXPECT_TRUE(CheckNoRtp2());
1545
wu@webrtc.org97077a32013-10-25 21:18:331546 // Lose writability, which should fail.
deadbeeff5346592017-01-25 05:51:211547 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1548 fake_rtp_dtls_transport1_->SetWritable(false);
1549 });
Danil Chapovalov33b01f22016-05-11 17:55:271550 SendRtp1();
1551 SendRtp2();
1552 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361553 EXPECT_TRUE(CheckRtp1());
1554 EXPECT_TRUE(CheckNoRtp2());
1555
1556 // Regain writability
deadbeeff5346592017-01-25 05:51:211557 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1558 fake_rtp_dtls_transport1_->SetWritable(true);
1559 });
henrike@webrtc.org28e20752013-07-10 00:45:361560 EXPECT_TRUE(media_channel1_->sending());
Danil Chapovalov33b01f22016-05-11 17:55:271561 SendRtp1();
1562 SendRtp2();
1563 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361564 EXPECT_TRUE(CheckRtp1());
1565 EXPECT_TRUE(CheckRtp2());
1566 EXPECT_TRUE(CheckNoRtp1());
1567 EXPECT_TRUE(CheckNoRtp2());
1568
1569 // Lose writability completely
deadbeeff5346592017-01-25 05:51:211570 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1571 bool asymmetric = true;
1572 fake_rtp_dtls_transport1_->SetDestination(nullptr, asymmetric);
1573 });
henrike@webrtc.org28e20752013-07-10 00:45:361574 EXPECT_TRUE(media_channel1_->sending());
1575
wu@webrtc.org97077a32013-10-25 21:18:331576 // Should fail also.
Danil Chapovalov33b01f22016-05-11 17:55:271577 SendRtp1();
1578 SendRtp2();
1579 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361580 EXPECT_TRUE(CheckRtp1());
1581 EXPECT_TRUE(CheckNoRtp2());
zhihuangb2cdd932017-01-20 00:54:251582 EXPECT_TRUE(CheckNoRtp1());
henrike@webrtc.org28e20752013-07-10 00:45:361583
1584 // Gain writability back
Taylor Brandstetter5d97a9a2016-06-10 21:17:271585 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
deadbeeff5346592017-01-25 05:51:211586 bool asymmetric = true;
1587 fake_rtp_dtls_transport1_->SetDestination(fake_rtp_dtls_transport2_.get(),
1588 asymmetric);
Taylor Brandstetter5d97a9a2016-06-10 21:17:271589 });
henrike@webrtc.org28e20752013-07-10 00:45:361590 EXPECT_TRUE(media_channel1_->sending());
Danil Chapovalov33b01f22016-05-11 17:55:271591 SendRtp1();
1592 SendRtp2();
1593 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361594 EXPECT_TRUE(CheckRtp1());
1595 EXPECT_TRUE(CheckRtp2());
1596 EXPECT_TRUE(CheckNoRtp1());
1597 EXPECT_TRUE(CheckNoRtp2());
1598 }
1599
buildbot@webrtc.org5ee0f052014-05-05 20:18:081600 void SendBundleToBundle(
1601 const int* pl_types, int len, bool rtcp_mux, bool secure) {
1602 ASSERT_EQ(2, len);
henrike@webrtc.org28e20752013-07-10 00:45:361603 int sequence_number1_1 = 0, sequence_number2_2 = 0;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081604 // Only pl_type1 was added to the bundle filter for both |channel1_|
1605 // and |channel2_|.
1606 int pl_type1 = pl_types[0];
1607 int pl_type2 = pl_types[1];
deadbeefac22f702017-01-13 05:59:291608 int flags = SSRC_MUX;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081609 if (secure) flags |= SECURE;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081610 if (rtcp_mux) {
1611 flags |= RTCP_MUX;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081612 }
1613 CreateChannels(flags, flags);
henrike@webrtc.org28e20752013-07-10 00:45:361614 EXPECT_TRUE(SendInitiate());
deadbeeff5346592017-01-25 05:51:211615 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1616 EXPECT_EQ(rtcp_mux, !channel2_->NeedsRtcpTransport());
henrike@webrtc.org28e20752013-07-10 00:45:361617 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211618 EXPECT_EQ(rtcp_mux, !channel1_->NeedsRtcpTransport());
1619 EXPECT_EQ(rtcp_mux, !channel2_->NeedsRtcpTransport());
zstein3dcf0e92017-06-01 20:22:421620 EXPECT_TRUE(channel1_->HandlesPayloadType(pl_type1));
1621 EXPECT_TRUE(channel2_->HandlesPayloadType(pl_type1));
1622 EXPECT_FALSE(channel1_->HandlesPayloadType(pl_type2));
1623 EXPECT_FALSE(channel2_->HandlesPayloadType(pl_type2));
buildbot@webrtc.org5ee0f052014-05-05 20:18:081624
1625 // Both channels can receive pl_type1 only.
Danil Chapovalov33b01f22016-05-11 17:55:271626 SendCustomRtp1(kSsrc1, ++sequence_number1_1, pl_type1);
1627 SendCustomRtp2(kSsrc2, ++sequence_number2_2, pl_type1);
1628 WaitForThreads();
buildbot@webrtc.org5ee0f052014-05-05 20:18:081629 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1, pl_type1));
buildbot@webrtc.org5ee0f052014-05-05 20:18:081630 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2, pl_type1));
1631 EXPECT_TRUE(CheckNoRtp1());
1632 EXPECT_TRUE(CheckNoRtp2());
1633
1634 // RTCP test
Danil Chapovalov33b01f22016-05-11 17:55:271635 SendCustomRtp1(kSsrc1, ++sequence_number1_1, pl_type2);
1636 SendCustomRtp2(kSsrc2, ++sequence_number2_2, pl_type2);
1637 WaitForThreads();
buildbot@webrtc.org5ee0f052014-05-05 20:18:081638 EXPECT_FALSE(CheckCustomRtp2(kSsrc1, sequence_number1_1, pl_type2));
buildbot@webrtc.org5ee0f052014-05-05 20:18:081639 EXPECT_FALSE(CheckCustomRtp1(kSsrc2, sequence_number2_2, pl_type2));
1640
Danil Chapovalov33b01f22016-05-11 17:55:271641 SendCustomRtcp1(kSsrc1);
1642 SendCustomRtcp2(kSsrc2);
1643 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361644 EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
1645 EXPECT_TRUE(CheckNoRtcp1());
1646 EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
1647 EXPECT_TRUE(CheckNoRtcp2());
henrike@webrtc.org28e20752013-07-10 00:45:361648
Danil Chapovalov33b01f22016-05-11 17:55:271649 SendCustomRtcp1(kSsrc2);
1650 SendCustomRtcp2(kSsrc1);
1651 WaitForThreads();
pbos482b12e2015-11-16 18:19:581652 // Bundle filter shouldn't filter out any RTCP.
1653 EXPECT_TRUE(CheckCustomRtcp1(kSsrc1));
1654 EXPECT_TRUE(CheckCustomRtcp2(kSsrc2));
henrike@webrtc.org28e20752013-07-10 00:45:361655 }
1656
deadbeefc6b6e092016-12-01 20:49:201657 // Test that the media monitor can be run and gives callbacks.
henrike@webrtc.org28e20752013-07-10 00:45:361658 void TestMediaMonitor() {
henrike@webrtc.org28e20752013-07-10 00:45:361659 CreateChannels(0, 0);
1660 EXPECT_TRUE(SendInitiate());
1661 EXPECT_TRUE(SendAccept());
1662 channel1_->StartMediaMonitor(100);
1663 channel2_->StartMediaMonitor(100);
1664 // Ensure we get callbacks and stop.
deadbeefc6b6e092016-12-01 20:49:201665 EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kDefaultTimeout);
1666 EXPECT_TRUE_WAIT(media_info_callbacks2_ > 0, kDefaultTimeout);
henrike@webrtc.org28e20752013-07-10 00:45:361667 channel1_->StopMediaMonitor();
1668 channel2_->StopMediaMonitor();
1669 // Ensure a restart of a stopped monitor works.
1670 channel1_->StartMediaMonitor(100);
deadbeefc6b6e092016-12-01 20:49:201671 EXPECT_TRUE_WAIT(media_info_callbacks1_ > 0, kDefaultTimeout);
henrike@webrtc.org28e20752013-07-10 00:45:361672 channel1_->StopMediaMonitor();
1673 // Ensure stopping a stopped monitor is OK.
1674 channel1_->StopMediaMonitor();
1675 }
1676
henrike@webrtc.org28e20752013-07-10 00:45:361677 void TestSetContentFailure() {
1678 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361679
Peter Thatchera6d24442015-07-10 04:26:361680 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351681 std::unique_ptr<typename T::Content> content(
1682 CreateMediaContentWithStream(1));
1683
henrike@webrtc.org28e20752013-07-10 00:45:361684 media_channel1_->set_fail_set_recv_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351685 EXPECT_FALSE(
1686 channel1_->SetLocalContent(content.get(), cricket::CA_OFFER, &err));
1687 EXPECT_FALSE(
1688 channel1_->SetLocalContent(content.get(), cricket::CA_ANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361689
henrike@webrtc.org28e20752013-07-10 00:45:361690 media_channel1_->set_fail_set_send_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351691 EXPECT_FALSE(
1692 channel1_->SetRemoteContent(content.get(), cricket::CA_OFFER, &err));
1693
henrike@webrtc.org28e20752013-07-10 00:45:361694 media_channel1_->set_fail_set_send_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351695 EXPECT_FALSE(
1696 channel1_->SetRemoteContent(content.get(), cricket::CA_ANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361697 }
1698
1699 void TestSendTwoOffers() {
1700 CreateChannels(0, 0);
1701
Peter Thatchera6d24442015-07-10 04:26:361702 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351703 std::unique_ptr<typename T::Content> content1(
1704 CreateMediaContentWithStream(1));
1705 EXPECT_TRUE(
1706 channel1_->SetLocalContent(content1.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361707 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1708
Steve Anton18ee1d52017-09-11 18:32:351709 std::unique_ptr<typename T::Content> content2(
1710 CreateMediaContentWithStream(2));
1711 EXPECT_TRUE(
1712 channel1_->SetLocalContent(content2.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361713 EXPECT_FALSE(media_channel1_->HasSendStream(1));
1714 EXPECT_TRUE(media_channel1_->HasSendStream(2));
1715 }
1716
1717 void TestReceiveTwoOffers() {
1718 CreateChannels(0, 0);
1719
Peter Thatchera6d24442015-07-10 04:26:361720 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351721 std::unique_ptr<typename T::Content> content1(
1722 CreateMediaContentWithStream(1));
1723 EXPECT_TRUE(
1724 channel1_->SetRemoteContent(content1.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361725 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1726
Steve Anton18ee1d52017-09-11 18:32:351727 std::unique_ptr<typename T::Content> content2(
1728 CreateMediaContentWithStream(2));
1729 EXPECT_TRUE(
1730 channel1_->SetRemoteContent(content2.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361731 EXPECT_FALSE(media_channel1_->HasRecvStream(1));
1732 EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1733 }
1734
1735 void TestSendPrAnswer() {
1736 CreateChannels(0, 0);
1737
Peter Thatchera6d24442015-07-10 04:26:361738 std::string err;
1739 // Receive offer
Steve Anton18ee1d52017-09-11 18:32:351740 std::unique_ptr<typename T::Content> content1(
1741 CreateMediaContentWithStream(1));
1742 EXPECT_TRUE(
1743 channel1_->SetRemoteContent(content1.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361744 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1745
Peter Thatchera6d24442015-07-10 04:26:361746 // Send PR answer
Steve Anton18ee1d52017-09-11 18:32:351747 std::unique_ptr<typename T::Content> content2(
1748 CreateMediaContentWithStream(2));
1749 EXPECT_TRUE(
1750 channel1_->SetLocalContent(content2.get(), cricket::CA_PRANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361751 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1752 EXPECT_TRUE(media_channel1_->HasSendStream(2));
1753
Peter Thatchera6d24442015-07-10 04:26:361754 // Send answer
Steve Anton18ee1d52017-09-11 18:32:351755 std::unique_ptr<typename T::Content> content3(
1756 CreateMediaContentWithStream(3));
1757 EXPECT_TRUE(
1758 channel1_->SetLocalContent(content3.get(), cricket::CA_ANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361759 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1760 EXPECT_FALSE(media_channel1_->HasSendStream(2));
1761 EXPECT_TRUE(media_channel1_->HasSendStream(3));
1762 }
1763
1764 void TestReceivePrAnswer() {
1765 CreateChannels(0, 0);
1766
Peter Thatchera6d24442015-07-10 04:26:361767 std::string err;
1768 // Send offer
Steve Anton18ee1d52017-09-11 18:32:351769 std::unique_ptr<typename T::Content> content1(
1770 CreateMediaContentWithStream(1));
1771 EXPECT_TRUE(
1772 channel1_->SetLocalContent(content1.get(), cricket::CA_OFFER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361773 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1774
Peter Thatchera6d24442015-07-10 04:26:361775 // Receive PR answer
Steve Anton18ee1d52017-09-11 18:32:351776 std::unique_ptr<typename T::Content> content2(
1777 CreateMediaContentWithStream(2));
1778 EXPECT_TRUE(channel1_->SetRemoteContent(content2.get(),
1779 cricket::CA_PRANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361780 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1781 EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1782
Peter Thatchera6d24442015-07-10 04:26:361783 // Receive answer
Steve Anton18ee1d52017-09-11 18:32:351784 std::unique_ptr<typename T::Content> content3(
1785 CreateMediaContentWithStream(3));
1786 EXPECT_TRUE(
1787 channel1_->SetRemoteContent(content3.get(), cricket::CA_ANSWER, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361788 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1789 EXPECT_FALSE(media_channel1_->HasRecvStream(2));
1790 EXPECT_TRUE(media_channel1_->HasRecvStream(3));
1791 }
1792
1793 void TestFlushRtcp() {
deadbeefac22f702017-01-13 05:59:291794 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361795 EXPECT_TRUE(SendInitiate());
1796 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:211797 EXPECT_TRUE(channel1_->NeedsRtcpTransport());
1798 EXPECT_TRUE(channel2_->NeedsRtcpTransport());
henrike@webrtc.org28e20752013-07-10 00:45:361799
1800 // Send RTCP1 from a different thread.
Danil Chapovalov33b01f22016-05-11 17:55:271801 ScopedCallThread send_rtcp([this] { SendRtcp1(); });
henrike@webrtc.org28e20752013-07-10 00:45:361802 // The sending message is only posted. channel2_ should be empty.
1803 EXPECT_TRUE(CheckNoRtcp2());
Danil Chapovalov33b01f22016-05-11 17:55:271804 rtc::Thread* wait_for[] = {send_rtcp.thread()};
1805 WaitForThreads(wait_for); // Ensure rtcp was posted
henrike@webrtc.org28e20752013-07-10 00:45:361806
1807 // When channel1_ is deleted, the RTCP packet should be sent out to
1808 // channel2_.
1809 channel1_.reset();
Danil Chapovalov33b01f22016-05-11 17:55:271810 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361811 EXPECT_TRUE(CheckRtcp2());
1812 }
1813
zstein56162b92017-04-24 23:54:351814 void TestOnTransportReadyToSend() {
deadbeefac22f702017-01-13 05:59:291815 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361816 EXPECT_FALSE(media_channel1_->ready_to_send());
Danil Chapovalov33b01f22016-05-11 17:55:271817
zstein56162b92017-04-24 23:54:351818 channel1_->OnTransportReadyToSend(true);
Danil Chapovalov33b01f22016-05-11 17:55:271819 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361820 EXPECT_TRUE(media_channel1_->ready_to_send());
1821
zstein56162b92017-04-24 23:54:351822 channel1_->OnTransportReadyToSend(false);
Danil Chapovalov33b01f22016-05-11 17:55:271823 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361824 EXPECT_FALSE(media_channel1_->ready_to_send());
henrike@webrtc.org28e20752013-07-10 00:45:361825 }
1826
zstein56162b92017-04-24 23:54:351827 void TestOnTransportReadyToSendWithRtcpMux() {
deadbeefac22f702017-01-13 05:59:291828 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361829 typename T::Content content;
1830 CreateContent(0, kPcmuCodec, kH264Codec, &content);
deadbeeff5346592017-01-25 05:51:211831 // Both sides agree on mux. Should signal that RTCP mux is fully active.
henrike@webrtc.org28e20752013-07-10 00:45:361832 content.set_rtcp_mux(true);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:541833 EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
deadbeeff5346592017-01-25 05:51:211834 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
sergeyu@chromium.org4b26e2e2014-01-15 23:15:541835 EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
deadbeeff5346592017-01-25 05:51:211836 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
1837 cricket::FakeDtlsTransport* rtp = fake_rtp_dtls_transport1_.get();
henrike@webrtc.org28e20752013-07-10 00:45:361838 EXPECT_FALSE(media_channel1_->ready_to_send());
1839 // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
1840 // should trigger the MediaChannel's OnReadyToSend.
Taylor Brandstetter5d97a9a2016-06-10 21:17:271841 network_thread_->Invoke<void>(RTC_FROM_HERE,
1842 [rtp] { rtp->SignalReadyToSend(rtp); });
Danil Chapovalov33b01f22016-05-11 17:55:271843 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361844 EXPECT_TRUE(media_channel1_->ready_to_send());
Danil Chapovalov33b01f22016-05-11 17:55:271845
zstein56162b92017-04-24 23:54:351846 // TODO(zstein): Find a way to test this without making
1847 // OnTransportReadyToSend public.
1848 network_thread_->Invoke<void>(
1849 RTC_FROM_HERE, [this] { channel1_->OnTransportReadyToSend(false); });
Danil Chapovalov33b01f22016-05-11 17:55:271850 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361851 EXPECT_FALSE(media_channel1_->ready_to_send());
1852 }
1853
skvladdc1c62c2016-03-17 02:07:431854 bool SetRemoteContentWithBitrateLimit(int remote_limit) {
1855 typename T::Content content;
1856 CreateContent(0, kPcmuCodec, kH264Codec, &content);
1857 content.set_bandwidth(remote_limit);
1858 return channel1_->SetRemoteContent(&content, CA_OFFER, NULL);
1859 }
1860
deadbeefe702b302017-02-04 20:09:011861 webrtc::RtpParameters BitrateLimitedParameters(rtc::Optional<int> limit) {
skvladdc1c62c2016-03-17 02:07:431862 webrtc::RtpParameters parameters;
1863 webrtc::RtpEncodingParameters encoding;
Mirko Bonadeic61ce0d2017-11-21 16:04:201864 encoding.max_bitrate_bps = std::move(limit);
skvladdc1c62c2016-03-17 02:07:431865 parameters.encodings.push_back(encoding);
1866 return parameters;
1867 }
1868
1869 void VerifyMaxBitrate(const webrtc::RtpParameters& parameters,
deadbeefe702b302017-02-04 20:09:011870 rtc::Optional<int> expected_bitrate) {
skvladdc1c62c2016-03-17 02:07:431871 EXPECT_EQ(1UL, parameters.encodings.size());
1872 EXPECT_EQ(expected_bitrate, parameters.encodings[0].max_bitrate_bps);
1873 }
1874
1875 void DefaultMaxBitrateIsUnlimited() {
1876 CreateChannels(0, 0);
1877 EXPECT_TRUE(
1878 channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, NULL));
1879 EXPECT_EQ(media_channel1_->max_bps(), -1);
deadbeefe702b302017-02-04 20:09:011880 VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1),
Oskar Sundbom36f8f3e2017-11-16 09:54:271881 rtc::nullopt);
skvladdc1c62c2016-03-17 02:07:431882 }
1883
1884 void CanChangeMaxBitrate() {
1885 CreateChannels(0, 0);
1886 EXPECT_TRUE(
1887 channel1_->SetLocalContent(&local_media_content1_, CA_OFFER, NULL));
1888
Taylor Brandstetterdb0cd9e2016-05-16 18:40:301889 EXPECT_TRUE(channel1_->SetRtpSendParameters(
Oskar Sundbom36f8f3e2017-11-16 09:54:271890 kSsrc1, BitrateLimitedParameters(1000)));
1891 VerifyMaxBitrate(channel1_->GetRtpSendParameters(kSsrc1), 1000);
1892 VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1), 1000);
skvladdc1c62c2016-03-17 02:07:431893 EXPECT_EQ(-1, media_channel1_->max_bps());
1894
deadbeefe702b302017-02-04 20:09:011895 EXPECT_TRUE(channel1_->SetRtpSendParameters(
Oskar Sundbom36f8f3e2017-11-16 09:54:271896 kSsrc1, BitrateLimitedParameters(rtc::nullopt)));
1897 VerifyMaxBitrate(channel1_->GetRtpSendParameters(kSsrc1), rtc::nullopt);
deadbeefe702b302017-02-04 20:09:011898 VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1),
Oskar Sundbom36f8f3e2017-11-16 09:54:271899 rtc::nullopt);
skvladdc1c62c2016-03-17 02:07:431900 EXPECT_EQ(-1, media_channel1_->max_bps());
1901 }
1902
Steve Anton8a63f782017-10-23 20:08:531903 // Test that when a channel gets new transports with a call to
1904 // |SetTransports|, the socket options from the old transports are merged with
1905 // the options on the new transport.
1906 // For example, audio and video may use separate socket options, but initially
1907 // be unbundled, then later become bundled. When this happens, their preferred
1908 // socket options should be merged to the underlying transport they share.
1909 void SocketOptionsMergedOnSetTransport() {
1910 constexpr int kSndBufSize = 4000;
1911 constexpr int kRcvBufSize = 8000;
1912
1913 CreateChannels(0, 0);
1914
1915 channel1_->SetOption(cricket::BaseChannel::ST_RTP,
1916 rtc::Socket::Option::OPT_SNDBUF, kSndBufSize);
1917 channel2_->SetOption(cricket::BaseChannel::ST_RTP,
1918 rtc::Socket::Option::OPT_RCVBUF, kRcvBufSize);
1919
1920 channel1_->SetTransports(channel2_->rtp_dtls_transport(),
1921 channel2_->rtcp_dtls_transport());
1922
1923 int option_val;
1924 ASSERT_TRUE(channel1_->rtp_dtls_transport()->GetOption(
1925 rtc::Socket::Option::OPT_SNDBUF, &option_val));
1926 EXPECT_EQ(kSndBufSize, option_val);
1927 ASSERT_TRUE(channel1_->rtp_dtls_transport()->GetOption(
1928 rtc::Socket::Option::OPT_RCVBUF, &option_val));
1929 EXPECT_EQ(kRcvBufSize, option_val);
1930 }
1931
henrike@webrtc.org28e20752013-07-10 00:45:361932 protected:
Danil Chapovalov33b01f22016-05-11 17:55:271933 void WaitForThreads() { WaitForThreads(rtc::ArrayView<rtc::Thread*>()); }
1934 static void ProcessThreadQueue(rtc::Thread* thread) {
1935 RTC_DCHECK(thread->IsCurrent());
1936 while (!thread->empty()) {
1937 thread->ProcessMessages(0);
1938 }
1939 }
1940 void WaitForThreads(rtc::ArrayView<rtc::Thread*> threads) {
1941 // |threads| and current thread post packets to network thread.
1942 for (rtc::Thread* thread : threads) {
Taylor Brandstetter5d97a9a2016-06-10 21:17:271943 thread->Invoke<void>(RTC_FROM_HERE,
1944 [thread] { ProcessThreadQueue(thread); });
Danil Chapovalov33b01f22016-05-11 17:55:271945 }
1946 ProcessThreadQueue(rtc::Thread::Current());
1947 // Network thread move them around and post back to worker = current thread.
1948 if (!network_thread_->IsCurrent()) {
1949 network_thread_->Invoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 21:17:271950 RTC_FROM_HERE, [this] { ProcessThreadQueue(network_thread_); });
Danil Chapovalov33b01f22016-05-11 17:55:271951 }
1952 // Worker thread = current Thread process received messages.
1953 ProcessThreadQueue(rtc::Thread::Current());
1954 }
Peter Boström34fbfff2015-09-24 17:20:301955 // TODO(pbos): Remove playout from all media channels and let renderers mute
1956 // themselves.
1957 const bool verify_playout_;
Danil Chapovalov33b01f22016-05-11 17:55:271958 std::unique_ptr<rtc::Thread> network_thread_keeper_;
1959 rtc::Thread* network_thread_;
deadbeeff5346592017-01-25 05:51:211960 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport1_;
1961 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport1_;
1962 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport2_;
1963 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport2_;
1964 std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport1_;
1965 std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport1_;
1966 std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport2_;
1967 std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport2_;
henrike@webrtc.org28e20752013-07-10 00:45:361968 cricket::FakeMediaEngine media_engine_;
1969 // The media channels are owned by the voice channel objects below.
deadbeeff5346592017-01-25 05:51:211970 typename T::MediaChannel* media_channel1_ = nullptr;
1971 typename T::MediaChannel* media_channel2_ = nullptr;
kwiberg31022942016-03-11 22:18:211972 std::unique_ptr<typename T::Channel> channel1_;
1973 std::unique_ptr<typename T::Channel> channel2_;
henrike@webrtc.org28e20752013-07-10 00:45:361974 typename T::Content local_media_content1_;
1975 typename T::Content local_media_content2_;
1976 typename T::Content remote_media_content1_;
1977 typename T::Content remote_media_content2_;
henrike@webrtc.org28e20752013-07-10 00:45:361978 // The RTP and RTCP packets to send in the tests.
Danil Chapovalov33b01f22016-05-11 17:55:271979 rtc::Buffer rtp_packet_;
1980 rtc::Buffer rtcp_packet_;
deadbeeff5346592017-01-25 05:51:211981 int media_info_callbacks1_ = 0;
1982 int media_info_callbacks2_ = 0;
1983 int rtcp_mux_activated_callbacks1_ = 0;
1984 int rtcp_mux_activated_callbacks2_ = 0;
Honghai Zhangcc411c02016-03-30 00:27:211985 cricket::CandidatePairInterface* last_selected_candidate_pair_;
henrike@webrtc.org28e20752013-07-10 00:45:361986};
1987
henrike@webrtc.org28e20752013-07-10 00:45:361988template<>
1989void ChannelTest<VoiceTraits>::CreateContent(
1990 int flags,
1991 const cricket::AudioCodec& audio_codec,
1992 const cricket::VideoCodec& video_codec,
1993 cricket::AudioContentDescription* audio) {
1994 audio->AddCodec(audio_codec);
1995 audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
Zhi Huangcd3fc5d2017-11-29 18:41:571996 if ((flags & SECURE) && !(flags & DTLS)) {
henrike@webrtc.org28e20752013-07-10 00:45:361997 audio->AddCrypto(cricket::CryptoParams(
Guo-wei Shieh456696a2015-10-01 04:48:541998 1, rtc::CS_AES_CM_128_HMAC_SHA1_32,
1999 "inline:" + rtc::CreateRandomString(40), std::string()));
henrike@webrtc.org28e20752013-07-10 00:45:362000 }
2001}
2002
2003template<>
2004void ChannelTest<VoiceTraits>::CopyContent(
2005 const cricket::AudioContentDescription& source,
2006 cricket::AudioContentDescription* audio) {
2007 *audio = source;
2008}
2009
2010template<>
2011bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1,
2012 const cricket::AudioCodec& c2) {
2013 return c1.name == c2.name && c1.clockrate == c2.clockrate &&
2014 c1.bitrate == c2.bitrate && c1.channels == c2.channels;
2015}
2016
Peter Boström0c4e06b2015-10-07 10:23:212017template <>
henrike@webrtc.org28e20752013-07-10 00:45:362018void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:212019 uint32_t ssrc,
2020 int flags,
2021 cricket::AudioContentDescription* audio) {
henrike@webrtc.org28e20752013-07-10 00:45:362022 audio->AddLegacyStream(ssrc);
2023}
2024
Danil Chapovalov33b01f22016-05-11 17:55:272025class VoiceChannelSingleThreadTest : public ChannelTest<VoiceTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:362026 public:
solenberg1dd98f32015-09-10 08:57:142027 typedef ChannelTest<VoiceTraits> Base;
Danil Chapovalov33b01f22016-05-11 17:55:272028 VoiceChannelSingleThreadTest()
2029 : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::Yes) {}
2030};
2031
2032class VoiceChannelDoubleThreadTest : public ChannelTest<VoiceTraits> {
2033 public:
2034 typedef ChannelTest<VoiceTraits> Base;
2035 VoiceChannelDoubleThreadTest()
2036 : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::No) {}
henrike@webrtc.org28e20752013-07-10 00:45:362037};
2038
jbauch5869f502017-06-29 19:31:362039class VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest
2040 : public ChannelTest<VoiceTraits> {
2041 public:
2042 typedef ChannelTest<VoiceTraits> Base;
2043 VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest()
2044 : Base(true, kPcmuFrameWithExtensions, kRtcpReport,
2045 NetworkIsWorker::Yes) {}
2046};
2047
2048class VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest
2049 : public ChannelTest<VoiceTraits> {
2050 public:
2051 typedef ChannelTest<VoiceTraits> Base;
2052 VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest()
2053 : Base(true, kPcmuFrameWithExtensions, kRtcpReport,
2054 NetworkIsWorker::No) {}
2055};
2056
henrike@webrtc.org28e20752013-07-10 00:45:362057// override to add NULL parameter
deadbeefcbecd352015-09-23 18:50:272058template <>
Steve Anton8699a322017-11-06 23:53:332059std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:272060 rtc::Thread* worker_thread,
2061 rtc::Thread* network_thread,
deadbeefcbecd352015-09-23 18:50:272062 cricket::MediaEngineInterface* engine,
Steve Anton8699a322017-11-06 23:53:332063 std::unique_ptr<cricket::FakeVideoMediaChannel> ch,
deadbeeff5346592017-01-25 05:51:212064 cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
2065 cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 19:31:502066 rtc::PacketTransportInternal* fake_rtp_packet_transport,
2067 rtc::PacketTransportInternal* fake_rtcp_packet_transport,
jbauchcb560652016-08-04 12:20:322068 int flags) {
deadbeeff5346592017-01-25 05:51:212069 rtc::Thread* signaling_thread = rtc::Thread::Current();
Steve Anton8699a322017-11-06 23:53:332070 auto channel = rtc::MakeUnique<cricket::VideoChannel>(
2071 worker_thread, network_thread, signaling_thread, std::move(ch),
2072 cricket::CN_VIDEO, (flags & RTCP_MUX_REQUIRED) != 0,
2073 (flags & SECURE) != 0);
deadbeeff5346592017-01-25 05:51:212074 if (!channel->NeedsRtcpTransport()) {
2075 fake_rtcp_dtls_transport = nullptr;
zhihuangf5b251b2017-01-13 03:37:482076 }
Steve Anton8699a322017-11-06 23:53:332077 channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
2078 fake_rtp_packet_transport, fake_rtcp_packet_transport);
henrike@webrtc.org28e20752013-07-10 00:45:362079 return channel;
2080}
2081
2082// override to add 0 parameter
2083template<>
2084bool ChannelTest<VideoTraits>::AddStream1(int id) {
2085 return channel1_->AddRecvStream(cricket::StreamParams::CreateLegacy(id));
2086}
2087
2088template<>
2089void ChannelTest<VideoTraits>::CreateContent(
2090 int flags,
2091 const cricket::AudioCodec& audio_codec,
2092 const cricket::VideoCodec& video_codec,
2093 cricket::VideoContentDescription* video) {
2094 video->AddCodec(video_codec);
2095 video->set_rtcp_mux((flags & RTCP_MUX) != 0);
2096 if (flags & SECURE) {
2097 video->AddCrypto(cricket::CryptoParams(
Guo-wei Shieh456696a2015-10-01 04:48:542098 1, rtc::CS_AES_CM_128_HMAC_SHA1_80,
2099 "inline:" + rtc::CreateRandomString(40), std::string()));
henrike@webrtc.org28e20752013-07-10 00:45:362100 }
2101}
2102
2103template<>
2104void ChannelTest<VideoTraits>::CopyContent(
2105 const cricket::VideoContentDescription& source,
2106 cricket::VideoContentDescription* video) {
2107 *video = source;
2108}
2109
2110template<>
2111bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1,
2112 const cricket::VideoCodec& c2) {
perkj26752742016-10-24 08:21:162113 return c1.name == c2.name;
henrike@webrtc.org28e20752013-07-10 00:45:362114}
2115
Peter Boström0c4e06b2015-10-07 10:23:212116template <>
henrike@webrtc.org28e20752013-07-10 00:45:362117void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:212118 uint32_t ssrc,
2119 int flags,
2120 cricket::VideoContentDescription* video) {
henrike@webrtc.org28e20752013-07-10 00:45:362121 video->AddLegacyStream(ssrc);
2122}
2123
Danil Chapovalov33b01f22016-05-11 17:55:272124class VideoChannelSingleThreadTest : public ChannelTest<VideoTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:362125 public:
solenberg1dd98f32015-09-10 08:57:142126 typedef ChannelTest<VideoTraits> Base;
Danil Chapovalov33b01f22016-05-11 17:55:272127 VideoChannelSingleThreadTest()
2128 : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::Yes) {}
henrike@webrtc.org28e20752013-07-10 00:45:362129};
2130
Danil Chapovalov33b01f22016-05-11 17:55:272131class VideoChannelDoubleThreadTest : public ChannelTest<VideoTraits> {
2132 public:
2133 typedef ChannelTest<VideoTraits> Base;
2134 VideoChannelDoubleThreadTest()
2135 : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::No) {}
2136};
henrike@webrtc.org28e20752013-07-10 00:45:362137
KĂ¡ri Tristan Helgason8b35df72017-09-25 12:46:432138TEST_F(VoiceChannelSingleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:362139 Base::TestInit();
2140 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2141 EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
2142}
2143
Danil Chapovalovdae07ba2016-05-13 23:43:502144TEST_F(VoiceChannelSingleThreadTest, TestDeinit) {
2145 Base::TestDeinit();
2146}
2147
Danil Chapovalov33b01f22016-05-11 17:55:272148TEST_F(VoiceChannelSingleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:362149 Base::TestSetContents();
2150}
2151
Danil Chapovalov33b01f22016-05-11 17:55:272152TEST_F(VoiceChannelSingleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:362153 Base::TestSetContentsNullOffer();
2154}
2155
Danil Chapovalov33b01f22016-05-11 17:55:272156TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362157 Base::TestSetContentsRtcpMux();
2158}
2159
Danil Chapovalov33b01f22016-05-11 17:55:272160TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:362161 Base::TestSetContentsRtcpMux();
2162}
2163
Danil Chapovalov33b01f22016-05-11 17:55:272164TEST_F(VoiceChannelSingleThreadTest, TestStreams) {
henrike@webrtc.org28e20752013-07-10 00:45:362165 Base::TestStreams();
2166}
2167
Danil Chapovalov33b01f22016-05-11 17:55:272168TEST_F(VoiceChannelSingleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:362169 Base::TestChangeStreamParamsInContent();
2170}
2171
jbauch5869f502017-06-29 19:31:362172TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2173 TestChangeEncryptedHeaderExtensionsDtls) {
2174 int flags = DTLS;
2175 Base::TestChangeEncryptedHeaderExtensions(flags);
2176}
2177
2178TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2179 TestChangeEncryptedHeaderExtensionsDtlsScenario1) {
2180 int flags = DTLS;
2181 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_BEFORE_OFFER_ANSWER);
2182}
2183
2184TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2185 TestChangeEncryptedHeaderExtensionsDtlsScenario2) {
2186 int flags = DTLS;
2187 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_AFTER_CHANNEL2_READY);
2188}
2189
2190TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2191 TestChangeEncryptedHeaderExtensionsDtlsGcm) {
2192 int flags = DTLS | GCM_CIPHER;
2193 Base::TestChangeEncryptedHeaderExtensions(flags);
2194}
2195
2196TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2197 TestChangeEncryptedHeaderExtensionsDtlsGcmScenario1) {
2198 int flags = DTLS | GCM_CIPHER;
2199 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_BEFORE_OFFER_ANSWER);
2200}
2201
2202TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2203 TestChangeEncryptedHeaderExtensionsDtlsGcmScenario2) {
2204 int flags = DTLS | GCM_CIPHER;
2205 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_AFTER_CHANNEL2_READY);
2206}
2207
2208TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest,
2209 TestChangeEncryptedHeaderExtensionsSDES) {
2210 int flags = 0;
2211 Base::TestChangeEncryptedHeaderExtensions(flags);
2212}
2213
Danil Chapovalov33b01f22016-05-11 17:55:272214TEST_F(VoiceChannelSingleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:362215 Base::TestPlayoutAndSendingStates();
2216}
2217
Danil Chapovalov33b01f22016-05-11 17:55:272218TEST_F(VoiceChannelSingleThreadTest, TestMuteStream) {
solenberg1dd98f32015-09-10 08:57:142219 CreateChannels(0, 0);
2220 // Test that we can Mute the default channel even though the sending SSRC
2221 // is unknown.
2222 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
solenberg1dd98f32015-09-10 08:57:142223 EXPECT_TRUE(channel1_->SetAudioSend(0, false, nullptr, nullptr));
solenbergdfc8f4f2015-10-01 09:31:102224 EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
2225 EXPECT_TRUE(channel1_->SetAudioSend(0, true, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142226 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2227
2228 // Test that we can not mute an unknown SSRC.
solenbergdfc8f4f2015-10-01 09:31:102229 EXPECT_FALSE(channel1_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142230
2231 SendInitiate();
2232 // After the local session description has been set, we can mute a stream
2233 // with its SSRC.
solenberg1dd98f32015-09-10 08:57:142234 EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
solenbergdfc8f4f2015-10-01 09:31:102235 EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
2236 EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142237 EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:362238}
2239
Danil Chapovalov33b01f22016-05-11 17:55:272240TEST_F(VoiceChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:362241 Base::TestMediaContentDirection();
2242}
2243
Danil Chapovalov33b01f22016-05-11 17:55:272244TEST_F(VoiceChannelSingleThreadTest, TestNetworkRouteChanges) {
Honghai Zhangcc411c02016-03-30 00:27:212245 Base::TestNetworkRouteChanges();
2246}
2247
Danil Chapovalov33b01f22016-05-11 17:55:272248TEST_F(VoiceChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:362249 Base::TestCallSetup();
2250}
2251
Danil Chapovalov33b01f22016-05-11 17:55:272252TEST_F(VoiceChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362253 Base::TestCallTeardownRtcpMux();
2254}
2255
Danil Chapovalov33b01f22016-05-11 17:55:272256TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362257 Base::SendRtpToRtp();
2258}
2259
Danil Chapovalov33b01f22016-05-11 17:55:272260TEST_F(VoiceChannelSingleThreadTest, SendRtcpToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362261 Base::SendRtcpToRtcp();
2262}
2263
Danil Chapovalov33b01f22016-05-11 17:55:272264TEST_F(VoiceChannelSingleThreadTest, SendRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362265 Base::SendRtcpMuxToRtcp();
2266}
2267
Danil Chapovalov33b01f22016-05-11 17:55:272268TEST_F(VoiceChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362269 Base::SendRtcpMuxToRtcpMux();
2270}
2271
Danil Chapovalov33b01f22016-05-11 17:55:272272TEST_F(VoiceChannelSingleThreadTest, SendRequireRtcpMuxToRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412273 Base::SendRequireRtcpMuxToRtcpMux();
2274}
2275
Danil Chapovalov33b01f22016-05-11 17:55:272276TEST_F(VoiceChannelSingleThreadTest, SendRtcpMuxToRequireRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412277 Base::SendRtcpMuxToRequireRtcpMux();
2278}
2279
Danil Chapovalov33b01f22016-05-11 17:55:272280TEST_F(VoiceChannelSingleThreadTest, SendRequireRtcpMuxToRequireRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412281 Base::SendRequireRtcpMuxToRequireRtcpMux();
2282}
2283
Danil Chapovalov33b01f22016-05-11 17:55:272284TEST_F(VoiceChannelSingleThreadTest, SendRequireRtcpMuxToNoRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412285 Base::SendRequireRtcpMuxToNoRtcpMux();
2286}
2287
Danil Chapovalov33b01f22016-05-11 17:55:272288TEST_F(VoiceChannelSingleThreadTest, SendEarlyRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362289 Base::SendEarlyRtcpMuxToRtcp();
2290}
2291
Danil Chapovalov33b01f22016-05-11 17:55:272292TEST_F(VoiceChannelSingleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362293 Base::SendEarlyRtcpMuxToRtcpMux();
2294}
2295
Danil Chapovalov33b01f22016-05-11 17:55:272296TEST_F(VoiceChannelSingleThreadTest, SendSrtpToSrtpRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362297 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2298}
2299
Danil Chapovalov33b01f22016-05-11 17:55:272300TEST_F(VoiceChannelSingleThreadTest, SendSrtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362301 Base::SendSrtpToSrtp();
2302}
2303
Danil Chapovalov33b01f22016-05-11 17:55:272304TEST_F(VoiceChannelSingleThreadTest, SendSrtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362305 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2306}
2307
Danil Chapovalov33b01f22016-05-11 17:55:272308TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToSrtp) {
Zhi Huangcd3fc5d2017-11-29 18:41:572309 Base::SendDtlsToSdesNotSupported();
henrike@webrtc.org28e20752013-07-10 00:45:362310}
2311
Danil Chapovalov33b01f22016-05-11 17:55:272312TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362313 Base::SendSrtpToSrtp(DTLS, DTLS);
2314}
2315
Danil Chapovalov33b01f22016-05-11 17:55:272316TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362317 Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
2318}
2319
deadbeeff5346592017-01-25 05:51:212320// Test using the channel with a raw packet interface, as opposed to a DTLS
2321// transport interface.
2322TEST_F(VoiceChannelSingleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
2323 Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
2324}
2325
Danil Chapovalov33b01f22016-05-11 17:55:272326TEST_F(VoiceChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362327 Base::SendEarlyMediaUsingRtcpMuxSrtp();
2328}
2329
Danil Chapovalov33b01f22016-05-11 17:55:272330TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:362331 Base::SendRtpToRtpOnThread();
2332}
2333
Danil Chapovalov33b01f22016-05-11 17:55:272334TEST_F(VoiceChannelSingleThreadTest, SendSrtpToSrtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:362335 Base::SendSrtpToSrtpOnThread();
2336}
2337
Danil Chapovalov33b01f22016-05-11 17:55:272338TEST_F(VoiceChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:362339 Base::SendWithWritabilityLoss();
2340}
2341
Danil Chapovalov33b01f22016-05-11 17:55:272342TEST_F(VoiceChannelSingleThreadTest, TestMediaMonitor) {
henrike@webrtc.org28e20752013-07-10 00:45:362343 Base::TestMediaMonitor();
2344}
2345
henrike@webrtc.org28e20752013-07-10 00:45:362346// Test that InsertDtmf properly forwards to the media channel.
Danil Chapovalov33b01f22016-05-11 17:55:272347TEST_F(VoiceChannelSingleThreadTest, TestInsertDtmf) {
henrike@webrtc.org28e20752013-07-10 00:45:362348 CreateChannels(0, 0);
2349 EXPECT_TRUE(SendInitiate());
2350 EXPECT_TRUE(SendAccept());
2351 EXPECT_EQ(0U, media_channel1_->dtmf_info_queue().size());
2352
solenberg1d63dd02015-12-02 20:35:092353 EXPECT_TRUE(channel1_->InsertDtmf(1, 3, 100));
2354 EXPECT_TRUE(channel1_->InsertDtmf(2, 5, 110));
2355 EXPECT_TRUE(channel1_->InsertDtmf(3, 7, 120));
henrike@webrtc.org28e20752013-07-10 00:45:362356
henrike@webrtc.org9de257d2013-07-17 14:42:532357 ASSERT_EQ(3U, media_channel1_->dtmf_info_queue().size());
henrike@webrtc.org28e20752013-07-10 00:45:362358 EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[0],
solenberg1d63dd02015-12-02 20:35:092359 1, 3, 100));
henrike@webrtc.org9de257d2013-07-17 14:42:532360 EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[1],
solenberg1d63dd02015-12-02 20:35:092361 2, 5, 110));
henrike@webrtc.org9de257d2013-07-17 14:42:532362 EXPECT_TRUE(CompareDtmfInfo(media_channel1_->dtmf_info_queue()[2],
solenberg1d63dd02015-12-02 20:35:092363 3, 7, 120));
henrike@webrtc.org28e20752013-07-10 00:45:362364}
2365
Danil Chapovalov33b01f22016-05-11 17:55:272366TEST_F(VoiceChannelSingleThreadTest, TestSetContentFailure) {
henrike@webrtc.org28e20752013-07-10 00:45:362367 Base::TestSetContentFailure();
2368}
2369
Danil Chapovalov33b01f22016-05-11 17:55:272370TEST_F(VoiceChannelSingleThreadTest, TestSendTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:362371 Base::TestSendTwoOffers();
2372}
2373
Danil Chapovalov33b01f22016-05-11 17:55:272374TEST_F(VoiceChannelSingleThreadTest, TestReceiveTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:362375 Base::TestReceiveTwoOffers();
2376}
2377
Danil Chapovalov33b01f22016-05-11 17:55:272378TEST_F(VoiceChannelSingleThreadTest, TestSendPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:362379 Base::TestSendPrAnswer();
2380}
2381
Danil Chapovalov33b01f22016-05-11 17:55:272382TEST_F(VoiceChannelSingleThreadTest, TestReceivePrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:362383 Base::TestReceivePrAnswer();
2384}
2385
Danil Chapovalov33b01f22016-05-11 17:55:272386TEST_F(VoiceChannelSingleThreadTest, TestFlushRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362387 Base::TestFlushRtcp();
2388}
2389
zstein56162b92017-04-24 23:54:352390TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSend) {
2391 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:362392}
2393
zstein56162b92017-04-24 23:54:352394TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
2395 Base::TestOnTransportReadyToSendWithRtcpMux();
henrike@webrtc.org28e20752013-07-10 00:45:362396}
2397
henrike@webrtc.org28e20752013-07-10 00:45:362398// Test that we can scale the output volume properly for 1:1 calls.
Danil Chapovalov33b01f22016-05-11 17:55:272399TEST_F(VoiceChannelSingleThreadTest, TestScaleVolume1to1Call) {
deadbeefac22f702017-01-13 05:59:292400 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:362401 EXPECT_TRUE(SendInitiate());
2402 EXPECT_TRUE(SendAccept());
solenberg4bac9c52015-10-09 09:32:532403 double volume;
henrike@webrtc.org28e20752013-07-10 00:45:362404
solenberg4bac9c52015-10-09 09:32:532405 // Default is (1.0).
2406 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2407 EXPECT_DOUBLE_EQ(1.0, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362408 // invalid ssrc.
solenberg4bac9c52015-10-09 09:32:532409 EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
henrike@webrtc.org28e20752013-07-10 00:45:362410
solenberg4bac9c52015-10-09 09:32:532411 // Set scale to (1.5).
2412 EXPECT_TRUE(channel1_->SetOutputVolume(0, 1.5));
2413 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2414 EXPECT_DOUBLE_EQ(1.5, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362415
solenberg4bac9c52015-10-09 09:32:532416 // Set scale to (0).
2417 EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
2418 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2419 EXPECT_DOUBLE_EQ(0.0, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362420}
2421
2422// Test that we can scale the output volume properly for multiway calls.
Danil Chapovalov33b01f22016-05-11 17:55:272423TEST_F(VoiceChannelSingleThreadTest, TestScaleVolumeMultiwayCall) {
deadbeefac22f702017-01-13 05:59:292424 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:362425 EXPECT_TRUE(SendInitiate());
2426 EXPECT_TRUE(SendAccept());
2427 EXPECT_TRUE(AddStream1(1));
2428 EXPECT_TRUE(AddStream1(2));
2429
solenberg4bac9c52015-10-09 09:32:532430 double volume;
2431 // Default is (1.0).
2432 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2433 EXPECT_DOUBLE_EQ(1.0, volume);
2434 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2435 EXPECT_DOUBLE_EQ(1.0, volume);
2436 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2437 EXPECT_DOUBLE_EQ(1.0, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362438 // invalid ssrc.
solenberg4bac9c52015-10-09 09:32:532439 EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
henrike@webrtc.org28e20752013-07-10 00:45:362440
solenberg4bac9c52015-10-09 09:32:532441 // Set scale to (1.5) for ssrc = 1.
2442 EXPECT_TRUE(channel1_->SetOutputVolume(1, 1.5));
2443 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2444 EXPECT_DOUBLE_EQ(1.5, volume);
2445 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2446 EXPECT_DOUBLE_EQ(1.0, volume);
2447 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2448 EXPECT_DOUBLE_EQ(1.0, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362449
solenberg4bac9c52015-10-09 09:32:532450 // Set scale to (0) for all ssrcs.
2451 EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
2452 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2453 EXPECT_DOUBLE_EQ(0.0, volume);
2454 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2455 EXPECT_DOUBLE_EQ(0.0, volume);
2456 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2457 EXPECT_DOUBLE_EQ(0.0, volume);
henrike@webrtc.org28e20752013-07-10 00:45:362458}
2459
Danil Chapovalov33b01f22016-05-11 17:55:272460TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundle) {
tfarina5237aaf2015-11-11 07:44:302461 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false);
henrike@webrtc.org28e20752013-07-10 00:45:362462}
2463
Danil Chapovalov33b01f22016-05-11 17:55:272464TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleSecure) {
tfarina5237aaf2015-11-11 07:44:302465 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true);
buildbot@webrtc.org5ee0f052014-05-05 20:18:082466}
2467
Danil Chapovalov33b01f22016-05-11 17:55:272468TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) {
tfarina5237aaf2015-11-11 07:44:302469 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false);
buildbot@webrtc.org5ee0f052014-05-05 20:18:082470}
2471
Danil Chapovalov33b01f22016-05-11 17:55:272472TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
tfarina5237aaf2015-11-11 07:44:302473 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true);
henrike@webrtc.org28e20752013-07-10 00:45:362474}
2475
Danil Chapovalov33b01f22016-05-11 17:55:272476TEST_F(VoiceChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) {
skvlade0d46372016-04-08 05:59:222477 Base::DefaultMaxBitrateIsUnlimited();
skvladdc1c62c2016-03-17 02:07:432478}
2479
Danil Chapovalov33b01f22016-05-11 17:55:272480TEST_F(VoiceChannelSingleThreadTest, CanChangeMaxBitrate) {
skvlade0d46372016-04-08 05:59:222481 Base::CanChangeMaxBitrate();
skvladdc1c62c2016-03-17 02:07:432482}
2483
Steve Anton8a63f782017-10-23 20:08:532484TEST_F(VoiceChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
2485 Base::SocketOptionsMergedOnSetTransport();
2486}
2487
Danil Chapovalov33b01f22016-05-11 17:55:272488// VoiceChannelDoubleThreadTest
2489TEST_F(VoiceChannelDoubleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:362490 Base::TestInit();
Danil Chapovalov33b01f22016-05-11 17:55:272491 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2492 EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
henrike@webrtc.org28e20752013-07-10 00:45:362493}
2494
Danil Chapovalovdae07ba2016-05-13 23:43:502495TEST_F(VoiceChannelDoubleThreadTest, TestDeinit) {
2496 Base::TestDeinit();
2497}
2498
Danil Chapovalov33b01f22016-05-11 17:55:272499TEST_F(VoiceChannelDoubleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:362500 Base::TestSetContents();
2501}
2502
Danil Chapovalov33b01f22016-05-11 17:55:272503TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:362504 Base::TestSetContentsNullOffer();
2505}
2506
Danil Chapovalov33b01f22016-05-11 17:55:272507TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362508 Base::TestSetContentsRtcpMux();
2509}
2510
Danil Chapovalov33b01f22016-05-11 17:55:272511TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:362512 Base::TestSetContentsRtcpMux();
2513}
2514
Danil Chapovalov33b01f22016-05-11 17:55:272515TEST_F(VoiceChannelDoubleThreadTest, TestStreams) {
henrike@webrtc.org28e20752013-07-10 00:45:362516 Base::TestStreams();
2517}
2518
Danil Chapovalov33b01f22016-05-11 17:55:272519TEST_F(VoiceChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:362520 Base::TestChangeStreamParamsInContent();
2521}
2522
jbauch5869f502017-06-29 19:31:362523TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2524 TestChangeEncryptedHeaderExtensionsDtls) {
2525 int flags = DTLS;
2526 Base::TestChangeEncryptedHeaderExtensions(flags);
2527}
2528
2529TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2530 TestChangeEncryptedHeaderExtensionsDtlsScenario1) {
2531 int flags = DTLS;
2532 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_BEFORE_OFFER_ANSWER);
2533}
2534
2535TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2536 TestChangeEncryptedHeaderExtensionsDtlsScenario2) {
2537 int flags = DTLS;
2538 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_AFTER_CHANNEL2_READY);
2539}
2540
2541TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2542 TestChangeEncryptedHeaderExtensionsDtlsGcm) {
2543 int flags = DTLS | GCM_CIPHER;
2544 Base::TestChangeEncryptedHeaderExtensions(flags);
2545}
2546
2547TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2548 TestChangeEncryptedHeaderExtensionsDtlsGcmScenario1) {
2549 int flags = DTLS | GCM_CIPHER;
2550 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_BEFORE_OFFER_ANSWER);
2551}
2552
2553TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2554 TestChangeEncryptedHeaderExtensionsDtlsGcmScenario2) {
2555 int flags = DTLS | GCM_CIPHER;
2556 Base::TestChangeEncryptedHeaderExtensions(flags, DTLS_AFTER_CHANNEL2_READY);
2557}
2558
2559TEST_F(VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest,
2560 TestChangeEncryptedHeaderExtensionsSDES) {
2561 int flags = 0;
2562 Base::TestChangeEncryptedHeaderExtensions(flags);
2563}
2564
Danil Chapovalov33b01f22016-05-11 17:55:272565TEST_F(VoiceChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:362566 Base::TestPlayoutAndSendingStates();
2567}
2568
Danil Chapovalov33b01f22016-05-11 17:55:272569TEST_F(VoiceChannelDoubleThreadTest, TestMuteStream) {
2570 CreateChannels(0, 0);
2571 // Test that we can Mute the default channel even though the sending SSRC
2572 // is unknown.
2573 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2574 EXPECT_TRUE(channel1_->SetAudioSend(0, false, nullptr, nullptr));
2575 EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
2576 EXPECT_TRUE(channel1_->SetAudioSend(0, true, nullptr, nullptr));
2577 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2578
2579 // Test that we can not mute an unknown SSRC.
2580 EXPECT_FALSE(channel1_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
2581
2582 SendInitiate();
2583 // After the local session description has been set, we can mute a stream
2584 // with its SSRC.
2585 EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, false, nullptr, nullptr));
2586 EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
2587 EXPECT_TRUE(channel1_->SetAudioSend(kSsrc1, true, nullptr, nullptr));
2588 EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
2589}
2590
2591TEST_F(VoiceChannelDoubleThreadTest, TestMediaContentDirection) {
2592 Base::TestMediaContentDirection();
2593}
2594
2595TEST_F(VoiceChannelDoubleThreadTest, TestNetworkRouteChanges) {
2596 Base::TestNetworkRouteChanges();
2597}
2598
2599TEST_F(VoiceChannelDoubleThreadTest, TestCallSetup) {
2600 Base::TestCallSetup();
2601}
2602
2603TEST_F(VoiceChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
2604 Base::TestCallTeardownRtcpMux();
2605}
2606
2607TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtp) {
2608 Base::SendRtpToRtp();
2609}
2610
Danil Chapovalov33b01f22016-05-11 17:55:272611TEST_F(VoiceChannelDoubleThreadTest, SendRtcpToRtcp) {
2612 Base::SendRtcpToRtcp();
2613}
2614
2615TEST_F(VoiceChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
2616 Base::SendRtcpMuxToRtcp();
2617}
2618
2619TEST_F(VoiceChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
2620 Base::SendRtcpMuxToRtcpMux();
2621}
2622
2623TEST_F(VoiceChannelDoubleThreadTest, SendRequireRtcpMuxToRtcpMux) {
2624 Base::SendRequireRtcpMuxToRtcpMux();
2625}
2626
2627TEST_F(VoiceChannelDoubleThreadTest, SendRtcpMuxToRequireRtcpMux) {
2628 Base::SendRtcpMuxToRequireRtcpMux();
2629}
2630
2631TEST_F(VoiceChannelDoubleThreadTest, SendRequireRtcpMuxToRequireRtcpMux) {
2632 Base::SendRequireRtcpMuxToRequireRtcpMux();
2633}
2634
2635TEST_F(VoiceChannelDoubleThreadTest, SendRequireRtcpMuxToNoRtcpMux) {
2636 Base::SendRequireRtcpMuxToNoRtcpMux();
2637}
2638
2639TEST_F(VoiceChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcp) {
2640 Base::SendEarlyRtcpMuxToRtcp();
2641}
2642
2643TEST_F(VoiceChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
2644 Base::SendEarlyRtcpMuxToRtcpMux();
2645}
2646
2647TEST_F(VoiceChannelDoubleThreadTest, SendSrtpToSrtpRtcpMux) {
2648 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2649}
2650
2651TEST_F(VoiceChannelDoubleThreadTest, SendSrtpToRtp) {
2652 Base::SendSrtpToSrtp();
2653}
2654
2655TEST_F(VoiceChannelDoubleThreadTest, SendSrtcpMux) {
2656 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2657}
2658
2659TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToSrtp) {
Zhi Huangcd3fc5d2017-11-29 18:41:572660 Base::SendDtlsToSdesNotSupported();
Danil Chapovalov33b01f22016-05-11 17:55:272661}
2662
2663TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Danil Chapovalov33b01f22016-05-11 17:55:272664 Base::SendSrtpToSrtp(DTLS, DTLS);
2665}
2666
2667TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:272668 Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
2669}
2670
deadbeeff5346592017-01-25 05:51:212671// Test using the channel with a raw packet interface, as opposed to a DTLS
2672// transport interface.
2673TEST_F(VoiceChannelDoubleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
2674 Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
2675}
2676
Danil Chapovalov33b01f22016-05-11 17:55:272677TEST_F(VoiceChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
2678 Base::SendEarlyMediaUsingRtcpMuxSrtp();
2679}
2680
2681TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtpOnThread) {
2682 Base::SendRtpToRtpOnThread();
2683}
2684
2685TEST_F(VoiceChannelDoubleThreadTest, SendSrtpToSrtpOnThread) {
2686 Base::SendSrtpToSrtpOnThread();
2687}
2688
2689TEST_F(VoiceChannelDoubleThreadTest, SendWithWritabilityLoss) {
2690 Base::SendWithWritabilityLoss();
2691}
2692
2693TEST_F(VoiceChannelDoubleThreadTest, TestMediaMonitor) {
2694 Base::TestMediaMonitor();
2695}
2696
2697// Test that InsertDtmf properly forwards to the media channel.
2698TEST_F(VoiceChannelDoubleThreadTest, TestInsertDtmf) {
2699 CreateChannels(0, 0);
2700 EXPECT_TRUE(SendInitiate());
2701 EXPECT_TRUE(SendAccept());
2702 EXPECT_EQ(0U, media_channel1_->dtmf_info_queue().size());
2703
2704 EXPECT_TRUE(channel1_->InsertDtmf(1, 3, 100));
2705 EXPECT_TRUE(channel1_->InsertDtmf(2, 5, 110));
2706 EXPECT_TRUE(channel1_->InsertDtmf(3, 7, 120));
2707
2708 ASSERT_EQ(3U, media_channel1_->dtmf_info_queue().size());
2709 EXPECT_TRUE(
2710 CompareDtmfInfo(media_channel1_->dtmf_info_queue()[0], 1, 3, 100));
2711 EXPECT_TRUE(
2712 CompareDtmfInfo(media_channel1_->dtmf_info_queue()[1], 2, 5, 110));
2713 EXPECT_TRUE(
2714 CompareDtmfInfo(media_channel1_->dtmf_info_queue()[2], 3, 7, 120));
2715}
2716
2717TEST_F(VoiceChannelDoubleThreadTest, TestSetContentFailure) {
2718 Base::TestSetContentFailure();
2719}
2720
2721TEST_F(VoiceChannelDoubleThreadTest, TestSendTwoOffers) {
2722 Base::TestSendTwoOffers();
2723}
2724
2725TEST_F(VoiceChannelDoubleThreadTest, TestReceiveTwoOffers) {
2726 Base::TestReceiveTwoOffers();
2727}
2728
2729TEST_F(VoiceChannelDoubleThreadTest, TestSendPrAnswer) {
2730 Base::TestSendPrAnswer();
2731}
2732
2733TEST_F(VoiceChannelDoubleThreadTest, TestReceivePrAnswer) {
2734 Base::TestReceivePrAnswer();
2735}
2736
2737TEST_F(VoiceChannelDoubleThreadTest, TestFlushRtcp) {
2738 Base::TestFlushRtcp();
2739}
2740
zstein56162b92017-04-24 23:54:352741TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSend) {
2742 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:272743}
2744
zstein56162b92017-04-24 23:54:352745TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
2746 Base::TestOnTransportReadyToSendWithRtcpMux();
Danil Chapovalov33b01f22016-05-11 17:55:272747}
2748
2749// Test that we can scale the output volume properly for 1:1 calls.
2750TEST_F(VoiceChannelDoubleThreadTest, TestScaleVolume1to1Call) {
deadbeefac22f702017-01-13 05:59:292751 CreateChannels(0, 0);
Danil Chapovalov33b01f22016-05-11 17:55:272752 EXPECT_TRUE(SendInitiate());
2753 EXPECT_TRUE(SendAccept());
2754 double volume;
2755
2756 // Default is (1.0).
2757 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2758 EXPECT_DOUBLE_EQ(1.0, volume);
2759 // invalid ssrc.
2760 EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
2761
2762 // Set scale to (1.5).
2763 EXPECT_TRUE(channel1_->SetOutputVolume(0, 1.5));
2764 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2765 EXPECT_DOUBLE_EQ(1.5, volume);
2766
2767 // Set scale to (0).
2768 EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
2769 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2770 EXPECT_DOUBLE_EQ(0.0, volume);
2771}
2772
2773// Test that we can scale the output volume properly for multiway calls.
2774TEST_F(VoiceChannelDoubleThreadTest, TestScaleVolumeMultiwayCall) {
deadbeefac22f702017-01-13 05:59:292775 CreateChannels(0, 0);
Danil Chapovalov33b01f22016-05-11 17:55:272776 EXPECT_TRUE(SendInitiate());
2777 EXPECT_TRUE(SendAccept());
2778 EXPECT_TRUE(AddStream1(1));
2779 EXPECT_TRUE(AddStream1(2));
2780
2781 double volume;
2782 // Default is (1.0).
2783 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2784 EXPECT_DOUBLE_EQ(1.0, volume);
2785 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2786 EXPECT_DOUBLE_EQ(1.0, volume);
2787 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2788 EXPECT_DOUBLE_EQ(1.0, volume);
2789 // invalid ssrc.
2790 EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
2791
2792 // Set scale to (1.5) for ssrc = 1.
2793 EXPECT_TRUE(channel1_->SetOutputVolume(1, 1.5));
2794 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2795 EXPECT_DOUBLE_EQ(1.5, volume);
2796 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2797 EXPECT_DOUBLE_EQ(1.0, volume);
2798 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2799 EXPECT_DOUBLE_EQ(1.0, volume);
2800
2801 // Set scale to (0) for all ssrcs.
2802 EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
2803 EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
2804 EXPECT_DOUBLE_EQ(0.0, volume);
2805 EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
2806 EXPECT_DOUBLE_EQ(0.0, volume);
2807 EXPECT_TRUE(media_channel1_->GetOutputVolume(2, &volume));
2808 EXPECT_DOUBLE_EQ(0.0, volume);
2809}
2810
2811TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundle) {
2812 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false);
2813}
2814
2815TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleSecure) {
2816 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true);
2817}
2818
2819TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) {
2820 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false);
2821}
2822
2823TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
2824 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true);
2825}
2826
2827TEST_F(VoiceChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) {
2828 Base::DefaultMaxBitrateIsUnlimited();
2829}
2830
2831TEST_F(VoiceChannelDoubleThreadTest, CanChangeMaxBitrate) {
2832 Base::CanChangeMaxBitrate();
2833}
2834
Steve Anton8a63f782017-10-23 20:08:532835TEST_F(VoiceChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
2836 Base::SocketOptionsMergedOnSetTransport();
2837}
2838
Danil Chapovalov33b01f22016-05-11 17:55:272839// VideoChannelSingleThreadTest
2840TEST_F(VideoChannelSingleThreadTest, TestInit) {
2841 Base::TestInit();
2842}
2843
Danil Chapovalovdae07ba2016-05-13 23:43:502844TEST_F(VideoChannelSingleThreadTest, TestDeinit) {
2845 Base::TestDeinit();
2846}
2847
Danil Chapovalov33b01f22016-05-11 17:55:272848TEST_F(VideoChannelSingleThreadTest, TestSetContents) {
2849 Base::TestSetContents();
2850}
2851
2852TEST_F(VideoChannelSingleThreadTest, TestSetContentsNullOffer) {
2853 Base::TestSetContentsNullOffer();
2854}
2855
2856TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMux) {
2857 Base::TestSetContentsRtcpMux();
2858}
2859
2860TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
2861 Base::TestSetContentsRtcpMux();
2862}
2863
Danil Chapovalov33b01f22016-05-11 17:55:272864TEST_F(VideoChannelSingleThreadTest, TestStreams) {
2865 Base::TestStreams();
2866}
2867
Danil Chapovalov33b01f22016-05-11 17:55:272868TEST_F(VideoChannelSingleThreadTest, TestChangeStreamParamsInContent) {
2869 Base::TestChangeStreamParamsInContent();
2870}
2871
2872TEST_F(VideoChannelSingleThreadTest, TestPlayoutAndSendingStates) {
2873 Base::TestPlayoutAndSendingStates();
2874}
2875
2876TEST_F(VideoChannelSingleThreadTest, TestMuteStream) {
solenberg1dd98f32015-09-10 08:57:142877 CreateChannels(0, 0);
2878 // Test that we can Mute the default channel even though the sending SSRC
2879 // is unknown.
2880 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
deadbeef5a4a75a2016-06-02 23:23:382881 EXPECT_TRUE(channel1_->SetVideoSend(0, false, nullptr, nullptr));
solenbergdfc8f4f2015-10-01 09:31:102882 EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
deadbeef5a4a75a2016-06-02 23:23:382883 EXPECT_TRUE(channel1_->SetVideoSend(0, true, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142884 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2885 // Test that we can not mute an unknown SSRC.
deadbeef5a4a75a2016-06-02 23:23:382886 EXPECT_FALSE(channel1_->SetVideoSend(kSsrc1, false, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142887 SendInitiate();
2888 // After the local session description has been set, we can mute a stream
2889 // with its SSRC.
deadbeef5a4a75a2016-06-02 23:23:382890 EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, false, nullptr, nullptr));
solenbergdfc8f4f2015-10-01 09:31:102891 EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
deadbeef5a4a75a2016-06-02 23:23:382892 EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, true, nullptr, nullptr));
solenberg1dd98f32015-09-10 08:57:142893 EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
henrike@webrtc.org28e20752013-07-10 00:45:362894}
2895
Danil Chapovalov33b01f22016-05-11 17:55:272896TEST_F(VideoChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:362897 Base::TestMediaContentDirection();
2898}
2899
Danil Chapovalov33b01f22016-05-11 17:55:272900TEST_F(VideoChannelSingleThreadTest, TestNetworkRouteChanges) {
Honghai Zhangcc411c02016-03-30 00:27:212901 Base::TestNetworkRouteChanges();
2902}
2903
Danil Chapovalov33b01f22016-05-11 17:55:272904TEST_F(VideoChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:362905 Base::TestCallSetup();
2906}
2907
Danil Chapovalov33b01f22016-05-11 17:55:272908TEST_F(VideoChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362909 Base::TestCallTeardownRtcpMux();
2910}
2911
Danil Chapovalov33b01f22016-05-11 17:55:272912TEST_F(VideoChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362913 Base::SendRtpToRtp();
2914}
2915
Danil Chapovalov33b01f22016-05-11 17:55:272916TEST_F(VideoChannelSingleThreadTest, SendRtcpToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362917 Base::SendRtcpToRtcp();
2918}
2919
Danil Chapovalov33b01f22016-05-11 17:55:272920TEST_F(VideoChannelSingleThreadTest, SendRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362921 Base::SendRtcpMuxToRtcp();
2922}
2923
Danil Chapovalov33b01f22016-05-11 17:55:272924TEST_F(VideoChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362925 Base::SendRtcpMuxToRtcpMux();
2926}
2927
Danil Chapovalov33b01f22016-05-11 17:55:272928TEST_F(VideoChannelSingleThreadTest, SendRequireRtcpMuxToRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412929 Base::SendRequireRtcpMuxToRtcpMux();
2930}
2931
Danil Chapovalov33b01f22016-05-11 17:55:272932TEST_F(VideoChannelSingleThreadTest, SendRtcpMuxToRequireRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412933 Base::SendRtcpMuxToRequireRtcpMux();
2934}
2935
Danil Chapovalov33b01f22016-05-11 17:55:272936TEST_F(VideoChannelSingleThreadTest, SendRequireRtcpMuxToRequireRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412937 Base::SendRequireRtcpMuxToRequireRtcpMux();
2938}
2939
Danil Chapovalov33b01f22016-05-11 17:55:272940TEST_F(VideoChannelSingleThreadTest, SendRequireRtcpMuxToNoRtcpMux) {
Peter Thatcheraf55ccc2015-05-21 14:48:412941 Base::SendRequireRtcpMuxToNoRtcpMux();
2942}
2943
Danil Chapovalov33b01f22016-05-11 17:55:272944TEST_F(VideoChannelSingleThreadTest, SendEarlyRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:362945 Base::SendEarlyRtcpMuxToRtcp();
2946}
2947
Danil Chapovalov33b01f22016-05-11 17:55:272948TEST_F(VideoChannelSingleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362949 Base::SendEarlyRtcpMuxToRtcpMux();
2950}
2951
Danil Chapovalov33b01f22016-05-11 17:55:272952TEST_F(VideoChannelSingleThreadTest, SendSrtpToSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362953 Base::SendSrtpToSrtp();
2954}
2955
Danil Chapovalov33b01f22016-05-11 17:55:272956TEST_F(VideoChannelSingleThreadTest, SendSrtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362957 Base::SendSrtpToSrtp();
2958}
2959
Danil Chapovalov33b01f22016-05-11 17:55:272960TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToSrtp) {
Zhi Huangcd3fc5d2017-11-29 18:41:572961 Base::SendDtlsToSdesNotSupported();
henrike@webrtc.org28e20752013-07-10 00:45:362962}
2963
Danil Chapovalov33b01f22016-05-11 17:55:272964TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362965 Base::SendSrtpToSrtp(DTLS, DTLS);
2966}
2967
Danil Chapovalov33b01f22016-05-11 17:55:272968TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362969 Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
2970}
2971
deadbeeff5346592017-01-25 05:51:212972// Test using the channel with a raw packet interface, as opposed to a DTLS
2973// transport interface.
2974TEST_F(VideoChannelSingleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
2975 Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
2976}
2977
Danil Chapovalov33b01f22016-05-11 17:55:272978TEST_F(VideoChannelSingleThreadTest, SendSrtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362979 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
2980}
2981
Danil Chapovalov33b01f22016-05-11 17:55:272982TEST_F(VideoChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362983 Base::SendEarlyMediaUsingRtcpMuxSrtp();
2984}
2985
Danil Chapovalov33b01f22016-05-11 17:55:272986TEST_F(VideoChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:362987 Base::SendRtpToRtpOnThread();
2988}
2989
Danil Chapovalov33b01f22016-05-11 17:55:272990TEST_F(VideoChannelSingleThreadTest, SendSrtpToSrtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:362991 Base::SendSrtpToSrtpOnThread();
2992}
2993
Danil Chapovalov33b01f22016-05-11 17:55:272994TEST_F(VideoChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:362995 Base::SendWithWritabilityLoss();
2996}
2997
Danil Chapovalov33b01f22016-05-11 17:55:272998TEST_F(VideoChannelSingleThreadTest, TestMediaMonitor) {
henrike@webrtc.org28e20752013-07-10 00:45:362999 Base::TestMediaMonitor();
3000}
3001
Danil Chapovalov33b01f22016-05-11 17:55:273002TEST_F(VideoChannelSingleThreadTest, TestSetContentFailure) {
henrike@webrtc.org28e20752013-07-10 00:45:363003 Base::TestSetContentFailure();
3004}
3005
Danil Chapovalov33b01f22016-05-11 17:55:273006TEST_F(VideoChannelSingleThreadTest, TestSendTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:363007 Base::TestSendTwoOffers();
3008}
3009
Danil Chapovalov33b01f22016-05-11 17:55:273010TEST_F(VideoChannelSingleThreadTest, TestReceiveTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:363011 Base::TestReceiveTwoOffers();
3012}
3013
Danil Chapovalov33b01f22016-05-11 17:55:273014TEST_F(VideoChannelSingleThreadTest, TestSendPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:363015 Base::TestSendPrAnswer();
3016}
3017
Danil Chapovalov33b01f22016-05-11 17:55:273018TEST_F(VideoChannelSingleThreadTest, TestReceivePrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:363019 Base::TestReceivePrAnswer();
3020}
3021
Danil Chapovalov33b01f22016-05-11 17:55:273022TEST_F(VideoChannelSingleThreadTest, TestFlushRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:363023 Base::TestFlushRtcp();
3024}
3025
Danil Chapovalov33b01f22016-05-11 17:55:273026TEST_F(VideoChannelSingleThreadTest, SendBundleToBundle) {
tfarina5237aaf2015-11-11 07:44:303027 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false);
henrike@webrtc.org28e20752013-07-10 00:45:363028}
3029
Danil Chapovalov33b01f22016-05-11 17:55:273030TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleSecure) {
tfarina5237aaf2015-11-11 07:44:303031 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true);
buildbot@webrtc.org5ee0f052014-05-05 20:18:083032}
3033
Danil Chapovalov33b01f22016-05-11 17:55:273034TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) {
tfarina5237aaf2015-11-11 07:44:303035 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
buildbot@webrtc.org5ee0f052014-05-05 20:18:083036}
3037
Danil Chapovalov33b01f22016-05-11 17:55:273038TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
tfarina5237aaf2015-11-11 07:44:303039 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
henrike@webrtc.org28e20752013-07-10 00:45:363040}
3041
zstein56162b92017-04-24 23:54:353042TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSend) {
3043 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:363044}
3045
zstein56162b92017-04-24 23:54:353046TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
3047 Base::TestOnTransportReadyToSendWithRtcpMux();
henrike@webrtc.org28e20752013-07-10 00:45:363048}
3049
Danil Chapovalov33b01f22016-05-11 17:55:273050TEST_F(VideoChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) {
skvladdc1c62c2016-03-17 02:07:433051 Base::DefaultMaxBitrateIsUnlimited();
3052}
3053
Danil Chapovalov33b01f22016-05-11 17:55:273054TEST_F(VideoChannelSingleThreadTest, CanChangeMaxBitrate) {
skvladdc1c62c2016-03-17 02:07:433055 Base::CanChangeMaxBitrate();
3056}
3057
Steve Anton8a63f782017-10-23 20:08:533058TEST_F(VideoChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
3059 Base::SocketOptionsMergedOnSetTransport();
3060}
3061
Danil Chapovalov33b01f22016-05-11 17:55:273062// VideoChannelDoubleThreadTest
3063TEST_F(VideoChannelDoubleThreadTest, TestInit) {
3064 Base::TestInit();
3065}
henrike@webrtc.org28e20752013-07-10 00:45:363066
Danil Chapovalovdae07ba2016-05-13 23:43:503067TEST_F(VideoChannelDoubleThreadTest, TestDeinit) {
3068 Base::TestDeinit();
3069}
3070
Danil Chapovalov33b01f22016-05-11 17:55:273071TEST_F(VideoChannelDoubleThreadTest, TestSetContents) {
3072 Base::TestSetContents();
3073}
3074
3075TEST_F(VideoChannelDoubleThreadTest, TestSetContentsNullOffer) {
3076 Base::TestSetContentsNullOffer();
3077}
3078
3079TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMux) {
3080 Base::TestSetContentsRtcpMux();
3081}
3082
3083TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
3084 Base::TestSetContentsRtcpMux();
3085}
3086
Danil Chapovalov33b01f22016-05-11 17:55:273087TEST_F(VideoChannelDoubleThreadTest, TestStreams) {
3088 Base::TestStreams();
3089}
3090
Danil Chapovalov33b01f22016-05-11 17:55:273091TEST_F(VideoChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
3092 Base::TestChangeStreamParamsInContent();
3093}
3094
3095TEST_F(VideoChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
3096 Base::TestPlayoutAndSendingStates();
3097}
3098
3099TEST_F(VideoChannelDoubleThreadTest, TestMuteStream) {
3100 CreateChannels(0, 0);
3101 // Test that we can Mute the default channel even though the sending SSRC
3102 // is unknown.
3103 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
deadbeef5a4a75a2016-06-02 23:23:383104 EXPECT_TRUE(channel1_->SetVideoSend(0, false, nullptr, nullptr));
Danil Chapovalov33b01f22016-05-11 17:55:273105 EXPECT_TRUE(media_channel1_->IsStreamMuted(0));
deadbeef5a4a75a2016-06-02 23:23:383106 EXPECT_TRUE(channel1_->SetVideoSend(0, true, nullptr, nullptr));
Danil Chapovalov33b01f22016-05-11 17:55:273107 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
3108 // Test that we can not mute an unknown SSRC.
deadbeef5a4a75a2016-06-02 23:23:383109 EXPECT_FALSE(channel1_->SetVideoSend(kSsrc1, false, nullptr, nullptr));
Danil Chapovalov33b01f22016-05-11 17:55:273110 SendInitiate();
3111 // After the local session description has been set, we can mute a stream
3112 // with its SSRC.
deadbeef5a4a75a2016-06-02 23:23:383113 EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, false, nullptr, nullptr));
Danil Chapovalov33b01f22016-05-11 17:55:273114 EXPECT_TRUE(media_channel1_->IsStreamMuted(kSsrc1));
deadbeef5a4a75a2016-06-02 23:23:383115 EXPECT_TRUE(channel1_->SetVideoSend(kSsrc1, true, nullptr, nullptr));
Danil Chapovalov33b01f22016-05-11 17:55:273116 EXPECT_FALSE(media_channel1_->IsStreamMuted(kSsrc1));
3117}
3118
3119TEST_F(VideoChannelDoubleThreadTest, TestMediaContentDirection) {
3120 Base::TestMediaContentDirection();
3121}
3122
3123TEST_F(VideoChannelDoubleThreadTest, TestNetworkRouteChanges) {
3124 Base::TestNetworkRouteChanges();
3125}
3126
3127TEST_F(VideoChannelDoubleThreadTest, TestCallSetup) {
3128 Base::TestCallSetup();
3129}
3130
3131TEST_F(VideoChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
3132 Base::TestCallTeardownRtcpMux();
3133}
3134
3135TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtp) {
3136 Base::SendRtpToRtp();
3137}
3138
Danil Chapovalov33b01f22016-05-11 17:55:273139TEST_F(VideoChannelDoubleThreadTest, SendRtcpToRtcp) {
3140 Base::SendRtcpToRtcp();
3141}
3142
3143TEST_F(VideoChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
3144 Base::SendRtcpMuxToRtcp();
3145}
3146
3147TEST_F(VideoChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
3148 Base::SendRtcpMuxToRtcpMux();
3149}
3150
3151TEST_F(VideoChannelDoubleThreadTest, SendRequireRtcpMuxToRtcpMux) {
3152 Base::SendRequireRtcpMuxToRtcpMux();
3153}
3154
3155TEST_F(VideoChannelDoubleThreadTest, SendRtcpMuxToRequireRtcpMux) {
3156 Base::SendRtcpMuxToRequireRtcpMux();
3157}
3158
3159TEST_F(VideoChannelDoubleThreadTest, SendRequireRtcpMuxToRequireRtcpMux) {
3160 Base::SendRequireRtcpMuxToRequireRtcpMux();
3161}
3162
3163TEST_F(VideoChannelDoubleThreadTest, SendRequireRtcpMuxToNoRtcpMux) {
3164 Base::SendRequireRtcpMuxToNoRtcpMux();
3165}
3166
3167TEST_F(VideoChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcp) {
3168 Base::SendEarlyRtcpMuxToRtcp();
3169}
3170
3171TEST_F(VideoChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
3172 Base::SendEarlyRtcpMuxToRtcpMux();
3173}
3174
3175TEST_F(VideoChannelDoubleThreadTest, SendSrtpToSrtp) {
3176 Base::SendSrtpToSrtp();
3177}
3178
3179TEST_F(VideoChannelDoubleThreadTest, SendSrtpToRtp) {
3180 Base::SendSrtpToSrtp();
3181}
3182
3183TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToSrtp) {
Zhi Huangcd3fc5d2017-11-29 18:41:573184 Base::SendDtlsToSdesNotSupported();
Danil Chapovalov33b01f22016-05-11 17:55:273185}
3186
3187TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Danil Chapovalov33b01f22016-05-11 17:55:273188 Base::SendSrtpToSrtp(DTLS, DTLS);
3189}
3190
3191TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273192 Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
3193}
3194
deadbeeff5346592017-01-25 05:51:213195// Test using the channel with a raw packet interface, as opposed to a DTLS
3196// transport interface.
3197TEST_F(VideoChannelDoubleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
3198 Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
3199}
3200
Danil Chapovalov33b01f22016-05-11 17:55:273201TEST_F(VideoChannelDoubleThreadTest, SendSrtcpMux) {
3202 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
3203}
3204
3205TEST_F(VideoChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
3206 Base::SendEarlyMediaUsingRtcpMuxSrtp();
3207}
3208
3209TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtpOnThread) {
3210 Base::SendRtpToRtpOnThread();
3211}
3212
3213TEST_F(VideoChannelDoubleThreadTest, SendSrtpToSrtpOnThread) {
3214 Base::SendSrtpToSrtpOnThread();
3215}
3216
3217TEST_F(VideoChannelDoubleThreadTest, SendWithWritabilityLoss) {
3218 Base::SendWithWritabilityLoss();
3219}
3220
3221TEST_F(VideoChannelDoubleThreadTest, TestMediaMonitor) {
3222 Base::TestMediaMonitor();
3223}
3224
3225TEST_F(VideoChannelDoubleThreadTest, TestSetContentFailure) {
3226 Base::TestSetContentFailure();
3227}
3228
3229TEST_F(VideoChannelDoubleThreadTest, TestSendTwoOffers) {
3230 Base::TestSendTwoOffers();
3231}
3232
3233TEST_F(VideoChannelDoubleThreadTest, TestReceiveTwoOffers) {
3234 Base::TestReceiveTwoOffers();
3235}
3236
3237TEST_F(VideoChannelDoubleThreadTest, TestSendPrAnswer) {
3238 Base::TestSendPrAnswer();
3239}
3240
3241TEST_F(VideoChannelDoubleThreadTest, TestReceivePrAnswer) {
3242 Base::TestReceivePrAnswer();
3243}
3244
3245TEST_F(VideoChannelDoubleThreadTest, TestFlushRtcp) {
3246 Base::TestFlushRtcp();
3247}
3248
3249TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundle) {
3250 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false);
3251}
3252
3253TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleSecure) {
3254 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true);
3255}
3256
3257TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) {
3258 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
3259}
3260
3261TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
3262 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
3263}
3264
zstein56162b92017-04-24 23:54:353265TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSend) {
3266 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:273267}
3268
zstein56162b92017-04-24 23:54:353269TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
3270 Base::TestOnTransportReadyToSendWithRtcpMux();
Danil Chapovalov33b01f22016-05-11 17:55:273271}
3272
3273TEST_F(VideoChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) {
3274 Base::DefaultMaxBitrateIsUnlimited();
3275}
3276
3277TEST_F(VideoChannelDoubleThreadTest, CanChangeMaxBitrate) {
3278 Base::CanChangeMaxBitrate();
3279}
3280
Steve Anton8a63f782017-10-23 20:08:533281TEST_F(VideoChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
3282 Base::SocketOptionsMergedOnSetTransport();
3283}
3284
deadbeef953c2ce2017-01-09 22:53:413285// RtpDataChannelSingleThreadTest
3286class RtpDataChannelSingleThreadTest : public ChannelTest<DataTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:363287 public:
Danil Chapovalov33b01f22016-05-11 17:55:273288 typedef ChannelTest<DataTraits> Base;
deadbeef953c2ce2017-01-09 22:53:413289 RtpDataChannelSingleThreadTest()
Danil Chapovalov33b01f22016-05-11 17:55:273290 : Base(true, kDataPacket, kRtcpReport, NetworkIsWorker::Yes) {}
3291};
3292
deadbeef953c2ce2017-01-09 22:53:413293// RtpDataChannelDoubleThreadTest
3294class RtpDataChannelDoubleThreadTest : public ChannelTest<DataTraits> {
Danil Chapovalov33b01f22016-05-11 17:55:273295 public:
3296 typedef ChannelTest<DataTraits> Base;
deadbeef953c2ce2017-01-09 22:53:413297 RtpDataChannelDoubleThreadTest()
Danil Chapovalov33b01f22016-05-11 17:55:273298 : Base(true, kDataPacket, kRtcpReport, NetworkIsWorker::No) {}
henrike@webrtc.org28e20752013-07-10 00:45:363299};
3300
3301// Override to avoid engine channel parameter.
deadbeefcbecd352015-09-23 18:50:273302template <>
Steve Anton8699a322017-11-06 23:53:333303std::unique_ptr<cricket::RtpDataChannel> ChannelTest<DataTraits>::CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:273304 rtc::Thread* worker_thread,
3305 rtc::Thread* network_thread,
deadbeefcbecd352015-09-23 18:50:273306 cricket::MediaEngineInterface* engine,
Steve Anton8699a322017-11-06 23:53:333307 std::unique_ptr<cricket::FakeDataMediaChannel> ch,
deadbeeff5346592017-01-25 05:51:213308 cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
3309 cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
deadbeef5bd5ca32017-02-10 19:31:503310 rtc::PacketTransportInternal* fake_rtp_packet_transport,
3311 rtc::PacketTransportInternal* fake_rtcp_packet_transport,
jbauchcb560652016-08-04 12:20:323312 int flags) {
deadbeeff5346592017-01-25 05:51:213313 rtc::Thread* signaling_thread = rtc::Thread::Current();
Steve Anton8699a322017-11-06 23:53:333314 auto channel = rtc::MakeUnique<cricket::RtpDataChannel>(
3315 worker_thread, network_thread, signaling_thread, std::move(ch),
3316 cricket::CN_DATA, (flags & RTCP_MUX_REQUIRED) != 0,
3317 (flags & SECURE) != 0);
deadbeeff5346592017-01-25 05:51:213318 if (!channel->NeedsRtcpTransport()) {
3319 fake_rtcp_dtls_transport = nullptr;
zhihuangf5b251b2017-01-13 03:37:483320 }
Steve Anton8699a322017-11-06 23:53:333321 channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
3322 fake_rtp_packet_transport, fake_rtcp_packet_transport);
henrike@webrtc.org28e20752013-07-10 00:45:363323 return channel;
3324}
3325
Danil Chapovalov33b01f22016-05-11 17:55:273326template <>
henrike@webrtc.org28e20752013-07-10 00:45:363327void ChannelTest<DataTraits>::CreateContent(
3328 int flags,
3329 const cricket::AudioCodec& audio_codec,
3330 const cricket::VideoCodec& video_codec,
3331 cricket::DataContentDescription* data) {
3332 data->AddCodec(kGoogleDataCodec);
3333 data->set_rtcp_mux((flags & RTCP_MUX) != 0);
3334 if (flags & SECURE) {
3335 data->AddCrypto(cricket::CryptoParams(
Guo-wei Shieh456696a2015-10-01 04:48:543336 1, rtc::CS_AES_CM_128_HMAC_SHA1_32,
3337 "inline:" + rtc::CreateRandomString(40), std::string()));
henrike@webrtc.org28e20752013-07-10 00:45:363338 }
3339}
3340
Danil Chapovalov33b01f22016-05-11 17:55:273341template <>
henrike@webrtc.org28e20752013-07-10 00:45:363342void ChannelTest<DataTraits>::CopyContent(
3343 const cricket::DataContentDescription& source,
3344 cricket::DataContentDescription* data) {
3345 *data = source;
3346}
3347
Danil Chapovalov33b01f22016-05-11 17:55:273348template <>
henrike@webrtc.org28e20752013-07-10 00:45:363349bool ChannelTest<DataTraits>::CodecMatches(const cricket::DataCodec& c1,
3350 const cricket::DataCodec& c2) {
3351 return c1.name == c2.name;
3352}
3353
Peter Boström0c4e06b2015-10-07 10:23:213354template <>
henrike@webrtc.org28e20752013-07-10 00:45:363355void ChannelTest<DataTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:213356 uint32_t ssrc,
3357 int flags,
3358 cricket::DataContentDescription* data) {
henrike@webrtc.org28e20752013-07-10 00:45:363359 data->AddLegacyStream(ssrc);
3360}
3361
deadbeef953c2ce2017-01-09 22:53:413362TEST_F(RtpDataChannelSingleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:363363 Base::TestInit();
3364 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
3365}
3366
deadbeef953c2ce2017-01-09 22:53:413367TEST_F(RtpDataChannelSingleThreadTest, TestDeinit) {
Danil Chapovalovdae07ba2016-05-13 23:43:503368 Base::TestDeinit();
3369}
3370
deadbeef953c2ce2017-01-09 22:53:413371TEST_F(RtpDataChannelSingleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:363372 Base::TestSetContents();
3373}
3374
deadbeef953c2ce2017-01-09 22:53:413375TEST_F(RtpDataChannelSingleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:363376 Base::TestSetContentsNullOffer();
3377}
3378
deadbeef953c2ce2017-01-09 22:53:413379TEST_F(RtpDataChannelSingleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:363380 Base::TestSetContentsRtcpMux();
3381}
3382
deadbeef953c2ce2017-01-09 22:53:413383TEST_F(RtpDataChannelSingleThreadTest, TestStreams) {
henrike@webrtc.org28e20752013-07-10 00:45:363384 Base::TestStreams();
3385}
3386
deadbeef953c2ce2017-01-09 22:53:413387TEST_F(RtpDataChannelSingleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:363388 Base::TestChangeStreamParamsInContent();
3389}
3390
deadbeef953c2ce2017-01-09 22:53:413391TEST_F(RtpDataChannelSingleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:363392 Base::TestPlayoutAndSendingStates();
3393}
3394
deadbeef953c2ce2017-01-09 22:53:413395TEST_F(RtpDataChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:363396 Base::TestMediaContentDirection();
3397}
3398
deadbeef953c2ce2017-01-09 22:53:413399TEST_F(RtpDataChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:363400 Base::TestCallSetup();
3401}
3402
deadbeef953c2ce2017-01-09 22:53:413403TEST_F(RtpDataChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:363404 Base::TestCallTeardownRtcpMux();
3405}
3406
zstein56162b92017-04-24 23:54:353407TEST_F(RtpDataChannelSingleThreadTest, TestOnTransportReadyToSend) {
3408 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:363409}
3410
zstein56162b92017-04-24 23:54:353411TEST_F(RtpDataChannelSingleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
3412 Base::TestOnTransportReadyToSendWithRtcpMux();
henrike@webrtc.org28e20752013-07-10 00:45:363413}
3414
deadbeef953c2ce2017-01-09 22:53:413415TEST_F(RtpDataChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:363416 Base::SendRtpToRtp();
3417}
3418
deadbeef953c2ce2017-01-09 22:53:413419TEST_F(RtpDataChannelSingleThreadTest, SendRtcpToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:363420 Base::SendRtcpToRtcp();
3421}
3422
deadbeef953c2ce2017-01-09 22:53:413423TEST_F(RtpDataChannelSingleThreadTest, SendRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:363424 Base::SendRtcpMuxToRtcp();
3425}
3426
deadbeef953c2ce2017-01-09 22:53:413427TEST_F(RtpDataChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:363428 Base::SendRtcpMuxToRtcpMux();
3429}
3430
deadbeef953c2ce2017-01-09 22:53:413431TEST_F(RtpDataChannelSingleThreadTest, SendEarlyRtcpMuxToRtcp) {
henrike@webrtc.org28e20752013-07-10 00:45:363432 Base::SendEarlyRtcpMuxToRtcp();
3433}
3434
deadbeef953c2ce2017-01-09 22:53:413435TEST_F(RtpDataChannelSingleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:363436 Base::SendEarlyRtcpMuxToRtcpMux();
3437}
3438
deadbeef953c2ce2017-01-09 22:53:413439TEST_F(RtpDataChannelSingleThreadTest, SendSrtpToSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:363440 Base::SendSrtpToSrtp();
3441}
3442
deadbeef953c2ce2017-01-09 22:53:413443TEST_F(RtpDataChannelSingleThreadTest, SendSrtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:363444 Base::SendSrtpToSrtp();
3445}
3446
deadbeef953c2ce2017-01-09 22:53:413447TEST_F(RtpDataChannelSingleThreadTest, SendSrtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:363448 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
3449}
3450
deadbeef953c2ce2017-01-09 22:53:413451TEST_F(RtpDataChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:363452 Base::SendRtpToRtpOnThread();
3453}
3454
deadbeef953c2ce2017-01-09 22:53:413455TEST_F(RtpDataChannelSingleThreadTest, SendSrtpToSrtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:363456 Base::SendSrtpToSrtpOnThread();
3457}
3458
deadbeef953c2ce2017-01-09 22:53:413459TEST_F(RtpDataChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:363460 Base::SendWithWritabilityLoss();
3461}
3462
deadbeef953c2ce2017-01-09 22:53:413463TEST_F(RtpDataChannelSingleThreadTest, TestMediaMonitor) {
henrike@webrtc.org28e20752013-07-10 00:45:363464 Base::TestMediaMonitor();
3465}
3466
Steve Anton8a63f782017-10-23 20:08:533467TEST_F(RtpDataChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
3468 Base::SocketOptionsMergedOnSetTransport();
3469}
3470
deadbeef953c2ce2017-01-09 22:53:413471TEST_F(RtpDataChannelSingleThreadTest, TestSendData) {
Danil Chapovalov33b01f22016-05-11 17:55:273472 CreateChannels(0, 0);
3473 EXPECT_TRUE(SendInitiate());
3474 EXPECT_TRUE(SendAccept());
3475
3476 cricket::SendDataParams params;
3477 params.ssrc = 42;
3478 unsigned char data[] = {'f', 'o', 'o'};
3479 rtc::CopyOnWriteBuffer payload(data, 3);
3480 cricket::SendDataResult result;
3481 ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
3482 EXPECT_EQ(params.ssrc, media_channel1_->last_sent_data_params().ssrc);
3483 EXPECT_EQ("foo", media_channel1_->last_sent_data());
3484}
3485
deadbeef953c2ce2017-01-09 22:53:413486TEST_F(RtpDataChannelDoubleThreadTest, TestInit) {
Danil Chapovalov33b01f22016-05-11 17:55:273487 Base::TestInit();
3488 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
3489}
3490
deadbeef953c2ce2017-01-09 22:53:413491TEST_F(RtpDataChannelDoubleThreadTest, TestDeinit) {
Danil Chapovalovdae07ba2016-05-13 23:43:503492 Base::TestDeinit();
3493}
3494
deadbeef953c2ce2017-01-09 22:53:413495TEST_F(RtpDataChannelDoubleThreadTest, TestSetContents) {
Danil Chapovalov33b01f22016-05-11 17:55:273496 Base::TestSetContents();
3497}
3498
deadbeef953c2ce2017-01-09 22:53:413499TEST_F(RtpDataChannelDoubleThreadTest, TestSetContentsNullOffer) {
Danil Chapovalov33b01f22016-05-11 17:55:273500 Base::TestSetContentsNullOffer();
3501}
3502
deadbeef953c2ce2017-01-09 22:53:413503TEST_F(RtpDataChannelDoubleThreadTest, TestSetContentsRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273504 Base::TestSetContentsRtcpMux();
3505}
3506
deadbeef953c2ce2017-01-09 22:53:413507TEST_F(RtpDataChannelDoubleThreadTest, TestStreams) {
Danil Chapovalov33b01f22016-05-11 17:55:273508 Base::TestStreams();
3509}
3510
deadbeef953c2ce2017-01-09 22:53:413511TEST_F(RtpDataChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
Danil Chapovalov33b01f22016-05-11 17:55:273512 Base::TestChangeStreamParamsInContent();
3513}
3514
deadbeef953c2ce2017-01-09 22:53:413515TEST_F(RtpDataChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
Danil Chapovalov33b01f22016-05-11 17:55:273516 Base::TestPlayoutAndSendingStates();
3517}
3518
deadbeef953c2ce2017-01-09 22:53:413519TEST_F(RtpDataChannelDoubleThreadTest, TestMediaContentDirection) {
Danil Chapovalov33b01f22016-05-11 17:55:273520 Base::TestMediaContentDirection();
3521}
3522
deadbeef953c2ce2017-01-09 22:53:413523TEST_F(RtpDataChannelDoubleThreadTest, TestCallSetup) {
Danil Chapovalov33b01f22016-05-11 17:55:273524 Base::TestCallSetup();
3525}
3526
deadbeef953c2ce2017-01-09 22:53:413527TEST_F(RtpDataChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273528 Base::TestCallTeardownRtcpMux();
3529}
3530
zstein56162b92017-04-24 23:54:353531TEST_F(RtpDataChannelDoubleThreadTest, TestOnTransportReadyToSend) {
3532 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:273533}
3534
zstein56162b92017-04-24 23:54:353535TEST_F(RtpDataChannelDoubleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
3536 Base::TestOnTransportReadyToSendWithRtcpMux();
Danil Chapovalov33b01f22016-05-11 17:55:273537}
3538
deadbeef953c2ce2017-01-09 22:53:413539TEST_F(RtpDataChannelDoubleThreadTest, SendRtpToRtp) {
Danil Chapovalov33b01f22016-05-11 17:55:273540 Base::SendRtpToRtp();
3541}
3542
deadbeef953c2ce2017-01-09 22:53:413543TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpToRtcp) {
Danil Chapovalov33b01f22016-05-11 17:55:273544 Base::SendRtcpToRtcp();
3545}
3546
deadbeef953c2ce2017-01-09 22:53:413547TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
Danil Chapovalov33b01f22016-05-11 17:55:273548 Base::SendRtcpMuxToRtcp();
3549}
3550
deadbeef953c2ce2017-01-09 22:53:413551TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273552 Base::SendRtcpMuxToRtcpMux();
3553}
3554
deadbeef953c2ce2017-01-09 22:53:413555TEST_F(RtpDataChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcp) {
Danil Chapovalov33b01f22016-05-11 17:55:273556 Base::SendEarlyRtcpMuxToRtcp();
3557}
3558
deadbeef953c2ce2017-01-09 22:53:413559TEST_F(RtpDataChannelDoubleThreadTest, SendEarlyRtcpMuxToRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273560 Base::SendEarlyRtcpMuxToRtcpMux();
3561}
3562
deadbeef953c2ce2017-01-09 22:53:413563TEST_F(RtpDataChannelDoubleThreadTest, SendSrtpToSrtp) {
Danil Chapovalov33b01f22016-05-11 17:55:273564 Base::SendSrtpToSrtp();
3565}
3566
deadbeef953c2ce2017-01-09 22:53:413567TEST_F(RtpDataChannelDoubleThreadTest, SendSrtpToRtp) {
Danil Chapovalov33b01f22016-05-11 17:55:273568 Base::SendSrtpToSrtp();
3569}
3570
deadbeef953c2ce2017-01-09 22:53:413571TEST_F(RtpDataChannelDoubleThreadTest, SendSrtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:273572 Base::SendSrtpToSrtp(RTCP_MUX, RTCP_MUX);
3573}
3574
deadbeef953c2ce2017-01-09 22:53:413575TEST_F(RtpDataChannelDoubleThreadTest, SendRtpToRtpOnThread) {
Danil Chapovalov33b01f22016-05-11 17:55:273576 Base::SendRtpToRtpOnThread();
3577}
3578
deadbeef953c2ce2017-01-09 22:53:413579TEST_F(RtpDataChannelDoubleThreadTest, SendSrtpToSrtpOnThread) {
Danil Chapovalov33b01f22016-05-11 17:55:273580 Base::SendSrtpToSrtpOnThread();
3581}
3582
deadbeef953c2ce2017-01-09 22:53:413583TEST_F(RtpDataChannelDoubleThreadTest, SendWithWritabilityLoss) {
Danil Chapovalov33b01f22016-05-11 17:55:273584 Base::SendWithWritabilityLoss();
3585}
3586
deadbeef953c2ce2017-01-09 22:53:413587TEST_F(RtpDataChannelDoubleThreadTest, TestMediaMonitor) {
Danil Chapovalov33b01f22016-05-11 17:55:273588 Base::TestMediaMonitor();
3589}
3590
Steve Anton8a63f782017-10-23 20:08:533591TEST_F(RtpDataChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
3592 Base::SocketOptionsMergedOnSetTransport();
3593}
3594
deadbeef953c2ce2017-01-09 22:53:413595TEST_F(RtpDataChannelDoubleThreadTest, TestSendData) {
henrike@webrtc.org28e20752013-07-10 00:45:363596 CreateChannels(0, 0);
3597 EXPECT_TRUE(SendInitiate());
3598 EXPECT_TRUE(SendAccept());
3599
3600 cricket::SendDataParams params;
3601 params.ssrc = 42;
3602 unsigned char data[] = {
3603 'f', 'o', 'o'
3604 };
jbaucheec21bd2016-03-20 13:15:433605 rtc::CopyOnWriteBuffer payload(data, 3);
henrike@webrtc.org28e20752013-07-10 00:45:363606 cricket::SendDataResult result;
3607 ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
3608 EXPECT_EQ(params.ssrc,
3609 media_channel1_->last_sent_data_params().ssrc);
3610 EXPECT_EQ("foo", media_channel1_->last_sent_data());
3611}
3612
deadbeefbad5dad2017-01-18 02:32:353613#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
3614
3615// Verifies some DCHECKs are in place.
3616// Uses VoiceChannel, but any BaseChannel subclass would work.
3617class BaseChannelDeathTest : public testing::Test {
3618 public:
3619 BaseChannelDeathTest()
deadbeeff5346592017-01-25 05:51:213620 : fake_rtp_dtls_transport_("foo", cricket::ICE_CANDIDATE_COMPONENT_RTP),
3621 fake_rtcp_dtls_transport_("foo", cricket::ICE_CANDIDATE_COMPONENT_RTCP),
3622 // RTCP mux not required, SRTP required.
Steve Anton8699a322017-11-06 23:53:333623 voice_channel_(rtc::Thread::Current(),
3624 rtc::Thread::Current(),
3625 rtc::Thread::Current(),
3626 &fake_media_engine_,
3627 rtc::MakeUnique<cricket::FakeVoiceMediaChannel>(
3628 nullptr,
3629 cricket::AudioOptions()),
3630 cricket::CN_AUDIO,
3631 false,
3632 true) {}
deadbeefbad5dad2017-01-18 02:32:353633
3634 protected:
deadbeefbad5dad2017-01-18 02:32:353635 cricket::FakeMediaEngine fake_media_engine_;
deadbeeff5346592017-01-25 05:51:213636 cricket::FakeDtlsTransport fake_rtp_dtls_transport_;
3637 cricket::FakeDtlsTransport fake_rtcp_dtls_transport_;
deadbeefbad5dad2017-01-18 02:32:353638 cricket::VoiceChannel voice_channel_;
deadbeefbad5dad2017-01-18 02:32:353639};
3640
deadbeeff5346592017-01-25 05:51:213641TEST_F(BaseChannelDeathTest, SetTransportsWithNullRtpTransport) {
Steve Anton8699a322017-11-06 23:53:333642 voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
3643 &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
deadbeeff5346592017-01-25 05:51:213644 cricket::FakeDtlsTransport new_rtcp_transport(
3645 "bar", cricket::ICE_CANDIDATE_COMPONENT_RTCP);
3646 EXPECT_DEATH(voice_channel_.SetTransports(nullptr, &new_rtcp_transport), "");
deadbeefbad5dad2017-01-18 02:32:353647}
3648
deadbeeff5346592017-01-25 05:51:213649TEST_F(BaseChannelDeathTest, SetTransportsWithMissingRtcpTransport) {
Steve Anton8699a322017-11-06 23:53:333650 voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
3651 &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
deadbeeff5346592017-01-25 05:51:213652 cricket::FakeDtlsTransport new_rtp_transport(
3653 "bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
3654 EXPECT_DEATH(voice_channel_.SetTransports(&new_rtp_transport, nullptr), "");
deadbeefbad5dad2017-01-18 02:32:353655}
3656
deadbeeff5346592017-01-25 05:51:213657TEST_F(BaseChannelDeathTest, SetTransportsWithUnneededRtcpTransport) {
Steve Anton8699a322017-11-06 23:53:333658 voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
3659 &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
deadbeefbad5dad2017-01-18 02:32:353660 // Activate RTCP muxing, simulating offer/answer negotiation.
3661 cricket::AudioContentDescription content;
3662 content.set_rtcp_mux(true);
3663 ASSERT_TRUE(voice_channel_.SetLocalContent(&content, CA_OFFER, nullptr));
3664 ASSERT_TRUE(voice_channel_.SetRemoteContent(&content, CA_ANSWER, nullptr));
deadbeeff5346592017-01-25 05:51:213665 cricket::FakeDtlsTransport new_rtp_transport(
3666 "bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
3667 cricket::FakeDtlsTransport new_rtcp_transport(
3668 "bar", cricket::ICE_CANDIDATE_COMPONENT_RTCP);
deadbeefbad5dad2017-01-18 02:32:353669 // After muxing is enabled, no RTCP transport should be passed in here.
3670 EXPECT_DEATH(
deadbeeff5346592017-01-25 05:51:213671 voice_channel_.SetTransports(&new_rtp_transport, &new_rtcp_transport),
3672 "");
deadbeefbad5dad2017-01-18 02:32:353673}
3674
3675// This test will probably go away if/when we move the transport name out of
3676// the transport classes and into their parent classes.
deadbeeff5346592017-01-25 05:51:213677TEST_F(BaseChannelDeathTest, SetTransportsWithMismatchingTransportNames) {
Steve Anton8699a322017-11-06 23:53:333678 voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
3679 &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
deadbeeff5346592017-01-25 05:51:213680 cricket::FakeDtlsTransport new_rtp_transport(
3681 "bar", cricket::ICE_CANDIDATE_COMPONENT_RTP);
3682 cricket::FakeDtlsTransport new_rtcp_transport(
3683 "baz", cricket::ICE_CANDIDATE_COMPONENT_RTCP);
deadbeefbad5dad2017-01-18 02:32:353684 EXPECT_DEATH(
deadbeeff5346592017-01-25 05:51:213685 voice_channel_.SetTransports(&new_rtp_transport, &new_rtcp_transport),
3686 "");
3687}
3688
3689// Not expected to support going from DtlsTransportInternal to
deadbeef5bd5ca32017-02-10 19:31:503690// PacketTransportInternal.
deadbeeff5346592017-01-25 05:51:213691TEST_F(BaseChannelDeathTest, SetTransportsDtlsToNonDtls) {
Steve Anton8699a322017-11-06 23:53:333692 voice_channel_.Init_w(&fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_,
3693 &fake_rtp_dtls_transport_, &fake_rtcp_dtls_transport_);
deadbeeff5346592017-01-25 05:51:213694 EXPECT_DEATH(
deadbeef5bd5ca32017-02-10 19:31:503695 voice_channel_.SetTransports(
3696 static_cast<rtc::PacketTransportInternal*>(&fake_rtp_dtls_transport_),
3697 static_cast<rtc::PacketTransportInternal*>(
3698 &fake_rtp_dtls_transport_)),
deadbeeff5346592017-01-25 05:51:213699 "");
3700}
3701
deadbeef5bd5ca32017-02-10 19:31:503702// Not expected to support going from PacketTransportInternal to
deadbeeff5346592017-01-25 05:51:213703// DtlsTransportInternal.
3704TEST_F(BaseChannelDeathTest, SetTransportsNonDtlsToDtls) {
Steve Anton8699a322017-11-06 23:53:333705 voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
3706 &fake_rtcp_dtls_transport_);
deadbeeff5346592017-01-25 05:51:213707 EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
3708 &fake_rtp_dtls_transport_),
3709 "");
deadbeefbad5dad2017-01-18 02:32:353710}
3711
3712#endif // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
3713
henrike@webrtc.org28e20752013-07-10 00:45:363714// TODO(pthatcher): TestSetReceiver?