blob: 479340c520246025fc8a0edaa815b77f9c10547f [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
Anton Sukhanov4f08faa2019-05-21 18:12:5711#include "pc/channel.h"
12
Yves Gerey3e707812018-11-28 15:47:4913#include <cstdint>
kwiberg31022942016-03-11 22:18:2114#include <memory>
Mirko Bonadeic61ce0d2017-11-21 16:04:2015#include <utility>
kwiberg31022942016-03-11 22:18:2116
Mirko Bonadei92ea95e2017-09-15 04:47:3117#include "api/array_view.h"
Yves Gerey3e707812018-11-28 15:47:4918#include "api/audio_options.h"
Steve Anton10542f22019-01-11 17:11:0019#include "api/rtp_parameters.h"
Yves Gerey3e707812018-11-28 15:47:4920#include "media/base/codec.h"
Steve Anton10542f22019-01-11 17:11:0021#include "media/base/fake_media_engine.h"
22#include "media/base/fake_rtp.h"
23#include "media/base/media_channel.h"
24#include "p2p/base/candidate_pair_interface.h"
25#include "p2p/base/fake_dtls_transport.h"
26#include "p2p/base/fake_packet_transport.h"
27#include "p2p/base/ice_transport_internal.h"
28#include "p2p/base/p2p_constants.h"
Steve Anton10542f22019-01-11 17:11:0029#include "pc/dtls_srtp_transport.h"
30#include "pc/jsep_transport.h"
31#include "pc/rtp_transport.h"
Yves Gerey3e707812018-11-28 15:47:4932#include "rtc_base/arraysize.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3133#include "rtc_base/buffer.h"
Steve Anton10542f22019-01-11 17:11:0034#include "rtc_base/byte_order.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3135#include "rtc_base/checks.h"
Steve Anton10542f22019-01-11 17:11:0036#include "rtc_base/rtc_certificate.h"
37#include "rtc_base/ssl_identity.h"
Mirta Dvornicic479a3c02019-06-04 13:38:5038#include "test/gmock.h"
Yves Gerey3e707812018-11-28 15:47:4939#include "test/gtest.h"
henrike@webrtc.org28e20752013-07-10 00:45:3640
zhihuangb2cdd932017-01-20 00:54:2541using cricket::DtlsTransportInternal;
henrike@webrtc.org28e20752013-07-10 00:45:3642using cricket::FakeVoiceMediaChannel;
Amit Hilbuchbcd39d42019-01-26 01:13:5643using cricket::RidDescription;
44using cricket::RidDirection;
henrike@webrtc.org28e20752013-07-10 00:45:3645using cricket::StreamParams;
Steve Anton4e70a722017-11-28 22:57:1046using webrtc::RtpTransceiverDirection;
Steve Anton3828c062017-12-06 18:34:5147using webrtc::SdpType;
henrike@webrtc.org28e20752013-07-10 00:45:3648
Danil Chapovalov33b01f22016-05-11 17:55:2749namespace {
50const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1);
51const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1);
52const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1);
perkj26752742016-10-24 08:21:1653const cricket::VideoCodec kH264Codec(97, "H264");
54const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC");
Danil Chapovalov33b01f22016-05-11 17:55:2755const cricket::DataCodec kGoogleDataCodec(101, "google-data");
56const uint32_t kSsrc1 = 0x1111;
57const uint32_t kSsrc2 = 0x2222;
Zhi Huang365381f2018-04-13 23:44:3458const uint32_t kSsrc3 = 0x3333;
59const uint32_t kSsrc4 = 0x4444;
Danil Chapovalov33b01f22016-05-11 17:55:2760const int kAudioPts[] = {0, 8};
61const int kVideoPts[] = {97, 99};
62enum class NetworkIsWorker { Yes, No };
Niels Möller02284852018-01-17 09:22:4763
Danil Chapovalov33b01f22016-05-11 17:55:2764} // namespace
henrike@webrtc.org28e20752013-07-10 00:45:3665
deadbeefcbecd352015-09-23 18:50:2766template <class ChannelT,
67 class MediaChannelT,
68 class ContentT,
69 class CodecT,
70 class MediaInfoT,
71 class OptionsT>
henrike@webrtc.org28e20752013-07-10 00:45:3672class Traits {
73 public:
74 typedef ChannelT Channel;
75 typedef MediaChannelT MediaChannel;
76 typedef ContentT Content;
77 typedef CodecT Codec;
78 typedef MediaInfoT MediaInfo;
Fredrik Solenbergb071a192015-09-17 14:42:5679 typedef OptionsT Options;
henrike@webrtc.org28e20752013-07-10 00:45:3680};
81
henrike@webrtc.org28e20752013-07-10 00:45:3682class VoiceTraits : public Traits<cricket::VoiceChannel,
83 cricket::FakeVoiceMediaChannel,
84 cricket::AudioContentDescription,
85 cricket::AudioCodec,
Fredrik Solenbergb071a192015-09-17 14:42:5686 cricket::VoiceMediaInfo,
deadbeefcbecd352015-09-23 18:50:2787 cricket::AudioOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:3688
89class VideoTraits : public Traits<cricket::VideoChannel,
90 cricket::FakeVideoMediaChannel,
91 cricket::VideoContentDescription,
92 cricket::VideoCodec,
Fredrik Solenbergb071a192015-09-17 14:42:5693 cricket::VideoMediaInfo,
deadbeefcbecd352015-09-23 18:50:2794 cricket::VideoOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:3695
deadbeef953c2ce2017-01-09 22:53:4196class DataTraits : public Traits<cricket::RtpDataChannel,
henrike@webrtc.org28e20752013-07-10 00:45:3697 cricket::FakeDataMediaChannel,
Harald Alvestrand5fc28b12019-05-13 11:36:1698 cricket::RtpDataContentDescription,
99 cricket::RtpDataCodec,
Fredrik Solenbergb071a192015-09-17 14:42:56100 cricket::DataMediaInfo,
deadbeefcbecd352015-09-23 18:50:27101 cricket::DataOptions> {};
henrike@webrtc.org28e20752013-07-10 00:45:36102
deadbeef953c2ce2017-01-09 22:53:41103// Base class for Voice/Video/RtpDataChannel tests
Yves Gerey665174f2018-06-19 13:03:05104template <class T>
Mirko Bonadei6a489f22019-04-09 13:11:12105class ChannelTest : public ::testing::Test, public sigslot::has_slots<> {
henrike@webrtc.org28e20752013-07-10 00:45:36106 public:
deadbeefac22f702017-01-13 05:59:29107 enum Flags {
108 RTCP_MUX = 0x1,
deadbeefac22f702017-01-13 05:59:29109 SSRC_MUX = 0x8,
110 DTLS = 0x10,
deadbeef5bd5ca32017-02-10 19:31:50111 // Use BaseChannel with PacketTransportInternal rather than
deadbeeff5346592017-01-25 05:51:21112 // DtlsTransportInternal.
deadbeef7914b8c2017-04-21 10:23:33113 RAW_PACKET_TRANSPORT = 0x20,
deadbeefac22f702017-01-13 05:59:29114 };
henrike@webrtc.org28e20752013-07-10 00:45:36115
Peter Boström34fbfff2015-09-24 17:20:30116 ChannelTest(bool verify_playout,
Danil Chapovalov33b01f22016-05-11 17:55:27117 rtc::ArrayView<const uint8_t> rtp_data,
118 rtc::ArrayView<const uint8_t> rtcp_data,
119 NetworkIsWorker network_is_worker)
Peter Boström34fbfff2015-09-24 17:20:30120 : verify_playout_(verify_playout),
Danil Chapovalov33b01f22016-05-11 17:55:27121 rtp_packet_(rtp_data.data(), rtp_data.size()),
deadbeeff5346592017-01-25 05:51:21122 rtcp_packet_(rtcp_data.data(), rtcp_data.size()) {
Danil Chapovalov33b01f22016-05-11 17:55:27123 if (network_is_worker == NetworkIsWorker::Yes) {
124 network_thread_ = rtc::Thread::Current();
125 } else {
126 network_thread_keeper_ = rtc::Thread::Create();
127 network_thread_keeper_->SetName("Network", nullptr);
Danil Chapovalov33b01f22016-05-11 17:55:27128 network_thread_ = network_thread_keeper_.get();
129 }
Danil Chapovalov33b01f22016-05-11 17:55:27130 }
henrike@webrtc.org28e20752013-07-10 00:45:36131
henrike@webrtc.org28e20752013-07-10 00:45:36132 void CreateChannels(int flags1, int flags2) {
Mirko Bonadei317a1f02019-09-17 15:06:18133 CreateChannels(std::make_unique<typename T::MediaChannel>(
Steve Anton8699a322017-11-06 23:53:33134 nullptr, typename T::Options()),
Mirko Bonadei317a1f02019-09-17 15:06:18135 std::make_unique<typename T::MediaChannel>(
Steve Anton8699a322017-11-06 23:53:33136 nullptr, typename T::Options()),
Danil Chapovalov33b01f22016-05-11 17:55:27137 flags1, flags2);
henrike@webrtc.org28e20752013-07-10 00:45:36138 }
Steve Anton8699a322017-11-06 23:53:33139 void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1,
140 std::unique_ptr<typename T::MediaChannel> ch2,
Danil Chapovalov33b01f22016-05-11 17:55:27141 int flags1,
142 int flags2) {
deadbeeff5346592017-01-25 05:51:21143 // Network thread is started in CreateChannels, to allow the test to
144 // configure a fake clock before any threads are spawned and attempt to
145 // access the time.
146 if (network_thread_keeper_) {
147 network_thread_keeper_->Start();
148 }
Zhi Huange830e682018-03-30 17:48:35149
deadbeeff5346592017-01-25 05:51:21150 // Make sure if using raw packet transports, they're used for both
151 // channels.
152 RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT);
Danil Chapovalov33b01f22016-05-11 17:55:27153 rtc::Thread* worker_thread = rtc::Thread::Current();
Steve Anton8699a322017-11-06 23:53:33154 media_channel1_ = ch1.get();
155 media_channel2_ = ch2.get();
deadbeef5bd5ca32017-02-10 19:31:50156 rtc::PacketTransportInternal* rtp1 = nullptr;
157 rtc::PacketTransportInternal* rtcp1 = nullptr;
158 rtc::PacketTransportInternal* rtp2 = nullptr;
159 rtc::PacketTransportInternal* rtcp2 = nullptr;
deadbeeff5346592017-01-25 05:51:21160 // Based on flags, create fake DTLS or raw packet transports.
161 if (flags1 & RAW_PACKET_TRANSPORT) {
162 fake_rtp_packet_transport1_.reset(
163 new rtc::FakePacketTransport("channel1_rtp"));
164 rtp1 = fake_rtp_packet_transport1_.get();
Zhi Huange830e682018-03-30 17:48:35165 if (!(flags1 & RTCP_MUX)) {
deadbeeff5346592017-01-25 05:51:21166 fake_rtcp_packet_transport1_.reset(
167 new rtc::FakePacketTransport("channel1_rtcp"));
168 rtcp1 = fake_rtcp_packet_transport1_.get();
169 }
170 } else {
171 // Confirmed to work with KT_RSA and KT_ECDSA.
172 fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
173 "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP));
174 rtp1 = fake_rtp_dtls_transport1_.get();
Zhi Huange830e682018-03-30 17:48:35175 if (!(flags1 & RTCP_MUX)) {
deadbeeff5346592017-01-25 05:51:21176 fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport(
177 "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP));
178 rtcp1 = fake_rtcp_dtls_transport1_.get();
179 }
180 if (flags1 & DTLS) {
Harald Alvestrand8515d5a2020-03-20 21:51:32181 auto cert1 = rtc::RTCCertificate::Create(
182 rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT));
deadbeeff5346592017-01-25 05:51:21183 fake_rtp_dtls_transport1_->SetLocalCertificate(cert1);
184 if (fake_rtcp_dtls_transport1_) {
185 fake_rtcp_dtls_transport1_->SetLocalCertificate(cert1);
186 }
187 }
188 }
189 // Based on flags, create fake DTLS or raw packet transports.
190 if (flags2 & RAW_PACKET_TRANSPORT) {
191 fake_rtp_packet_transport2_.reset(
192 new rtc::FakePacketTransport("channel2_rtp"));
193 rtp2 = fake_rtp_packet_transport2_.get();
Zhi Huange830e682018-03-30 17:48:35194 if (!(flags2 & RTCP_MUX)) {
deadbeeff5346592017-01-25 05:51:21195 fake_rtcp_packet_transport2_.reset(
196 new rtc::FakePacketTransport("channel2_rtcp"));
197 rtcp2 = fake_rtcp_packet_transport2_.get();
198 }
199 } else {
200 // Confirmed to work with KT_RSA and KT_ECDSA.
201 fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
202 "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP));
203 rtp2 = fake_rtp_dtls_transport2_.get();
Zhi Huange830e682018-03-30 17:48:35204 if (!(flags2 & RTCP_MUX)) {
deadbeeff5346592017-01-25 05:51:21205 fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport(
206 "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP));
207 rtcp2 = fake_rtcp_dtls_transport2_.get();
208 }
209 if (flags2 & DTLS) {
Harald Alvestrand8515d5a2020-03-20 21:51:32210 auto cert2 = rtc::RTCCertificate::Create(
211 rtc::SSLIdentity::Create("session2", rtc::KT_DEFAULT));
deadbeeff5346592017-01-25 05:51:21212 fake_rtp_dtls_transport2_->SetLocalCertificate(cert2);
213 if (fake_rtcp_dtls_transport2_) {
214 fake_rtcp_dtls_transport2_->SetLocalCertificate(cert2);
215 }
216 }
217 }
Zhi Huange830e682018-03-30 17:48:35218 rtp_transport1_ = CreateRtpTransportBasedOnFlags(
219 fake_rtp_packet_transport1_.get(), fake_rtcp_packet_transport1_.get(),
220 fake_rtp_dtls_transport1_.get(), fake_rtcp_dtls_transport1_.get(),
221 flags1);
222 rtp_transport2_ = CreateRtpTransportBasedOnFlags(
223 fake_rtp_packet_transport2_.get(), fake_rtcp_packet_transport2_.get(),
224 fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get(),
225 flags2);
226
Amit Hilbuchbcd39d42019-01-26 01:13:56227 channel1_ = CreateChannel(worker_thread, network_thread_, std::move(ch1),
228 rtp_transport1_.get(), flags1);
229 channel2_ = CreateChannel(worker_thread, network_thread_, std::move(ch2),
230 rtp_transport2_.get(), flags2);
deadbeefac22f702017-01-13 05:59:29231 channel1_->SignalRtcpMuxFullyActive.connect(
deadbeeff5346592017-01-25 05:51:21232 this, &ChannelTest<T>::OnRtcpMuxFullyActive1);
deadbeefac22f702017-01-13 05:59:29233 channel2_->SignalRtcpMuxFullyActive.connect(
deadbeeff5346592017-01-25 05:51:21234 this, &ChannelTest<T>::OnRtcpMuxFullyActive2);
Yves Gerey665174f2018-06-19 13:03:05235 CreateContent(flags1, kPcmuCodec, kH264Codec, &local_media_content1_);
236 CreateContent(flags2, kPcmuCodec, kH264Codec, &local_media_content2_);
henrike@webrtc.org28e20752013-07-10 00:45:36237 CopyContent(local_media_content1_, &remote_media_content1_);
238 CopyContent(local_media_content2_, &remote_media_content2_);
239
henrike@webrtc.org28e20752013-07-10 00:45:36240 // Add stream information (SSRC) to the local content but not to the remote
241 // content. This means that we per default know the SSRC of what we send but
242 // not what we receive.
243 AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_);
244 AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_);
245
246 // If SSRC_MUX is used we also need to know the SSRC of the incoming stream.
247 if (flags1 & SSRC_MUX) {
248 AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_);
249 }
250 if (flags2 & SSRC_MUX) {
251 AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_);
252 }
253 }
Steve Anton8699a322017-11-06 23:53:33254 std::unique_ptr<typename T::Channel> CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:27255 rtc::Thread* worker_thread,
256 rtc::Thread* network_thread,
Steve Anton8699a322017-11-06 23:53:33257 std::unique_ptr<typename T::MediaChannel> ch,
Zhi Huange830e682018-03-30 17:48:35258 webrtc::RtpTransportInternal* rtp_transport,
Sebastian Jansson1b83a9e2019-09-18 16:22:12259 int flags);
henrike@webrtc.org28e20752013-07-10 00:45:36260
Zhi Huange830e682018-03-30 17:48:35261 std::unique_ptr<webrtc::RtpTransportInternal> CreateRtpTransportBasedOnFlags(
262 rtc::PacketTransportInternal* rtp_packet_transport,
263 rtc::PacketTransportInternal* rtcp_packet_transport,
264 DtlsTransportInternal* rtp_dtls_transport,
265 DtlsTransportInternal* rtcp_dtls_transport,
266 int flags) {
267 if (flags & RTCP_MUX) {
268 rtcp_packet_transport = nullptr;
269 rtcp_dtls_transport = nullptr;
270 }
271
272 if (flags & DTLS) {
273 return CreateDtlsSrtpTransport(rtp_dtls_transport, rtcp_dtls_transport);
274 } else {
275 if (flags & RAW_PACKET_TRANSPORT) {
276 return CreateUnencryptedTransport(rtp_packet_transport,
277 rtcp_packet_transport);
278 } else {
279 return CreateUnencryptedTransport(rtp_dtls_transport,
280 rtcp_dtls_transport);
281 }
282 }
283 }
284
285 std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedTransport(
286 rtc::PacketTransportInternal* rtp_packet_transport,
287 rtc::PacketTransportInternal* rtcp_packet_transport) {
Mirko Bonadei317a1f02019-09-17 15:06:18288 auto rtp_transport = std::make_unique<webrtc::RtpTransport>(
Karl Wiberg918f50c2018-07-05 09:40:33289 rtcp_packet_transport == nullptr);
Zhi Huange830e682018-03-30 17:48:35290
291 rtp_transport->SetRtpPacketTransport(rtp_packet_transport);
292 if (rtcp_packet_transport) {
293 rtp_transport->SetRtcpPacketTransport(rtcp_packet_transport);
294 }
295 return rtp_transport;
296 }
297
298 std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport(
299 cricket::DtlsTransportInternal* rtp_dtls_transport,
300 cricket::DtlsTransportInternal* rtcp_dtls_transport) {
Mirko Bonadei317a1f02019-09-17 15:06:18301 auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>(
Zhi Huang365381f2018-04-13 23:44:34302 rtcp_dtls_transport == nullptr);
Zhi Huange830e682018-03-30 17:48:35303
304 dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport,
305 rtcp_dtls_transport);
306 return dtls_srtp_transport;
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_,
Steve Anton3828c062017-12-06 18:34:51334 SdpType::kOffer, 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_,
Steve Anton3828c062017-12-06 18:34:51338 SdpType::kOffer, 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_,
Steve Anton3828c062017-12-06 18:34:51342 SdpType::kAnswer, 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_,
Steve Anton3828c062017-12-06 18:34:51351 SdpType::kAnswer, 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_,
Steve Anton3828c062017-12-06 18:34:51356 SdpType::kOffer, 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_,
Steve Anton3828c062017-12-06 18:34:51360 SdpType::kOffer, 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_,
Steve Anton3828c062017-12-06 18:34:51367 SdpType::kPrAnswer, NULL);
henrike@webrtc.org28e20752013-07-10 00:45:36368 if (result) {
369 channel2_->Enable(true);
370 result = channel1_->SetRemoteContent(&remote_media_content2_,
Steve Anton3828c062017-12-06 18:34:51371 SdpType::kPrAnswer, 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_,
Steve Anton3828c062017-12-06 18:34:51379 SdpType::kAnswer, 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_,
Steve Anton3828c062017-12-06 18:34:51382 SdpType::kAnswer, 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
Danil Chapovalov33b01f22016-05-11 17:55:27403 void SendRtp1() {
404 media_channel1_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
405 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36406 }
Danil Chapovalov33b01f22016-05-11 17:55:27407 void SendRtp2() {
408 media_channel2_->SendRtp(rtp_packet_.data(), rtp_packet_.size(),
409 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36410 }
henrike@webrtc.org28e20752013-07-10 00:45:36411 // Methods to send custom data.
Danil Chapovalov33b01f22016-05-11 17:55:27412 void SendCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
413 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
414 media_channel1_->SendRtp(data.data(), data.size(), rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36415 }
Danil Chapovalov33b01f22016-05-11 17:55:27416 void SendCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
417 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
418 media_channel2_->SendRtp(data.data(), data.size(), rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36419 }
Danil Chapovalov33b01f22016-05-11 17:55:27420
henrike@webrtc.org28e20752013-07-10 00:45:36421 bool CheckRtp1() {
Danil Chapovalov33b01f22016-05-11 17:55:27422 return media_channel1_->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36423 }
424 bool CheckRtp2() {
Danil Chapovalov33b01f22016-05-11 17:55:27425 return media_channel2_->CheckRtp(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36426 }
henrike@webrtc.org28e20752013-07-10 00:45:36427 // Methods to check custom data.
Peter Boström0c4e06b2015-10-07 10:23:21428 bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) {
Danil Chapovalov33b01f22016-05-11 17:55:27429 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
430 return media_channel1_->CheckRtp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36431 }
Peter Boström0c4e06b2015-10-07 10:23:21432 bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) {
Danil Chapovalov33b01f22016-05-11 17:55:27433 rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type);
434 return media_channel2_->CheckRtp(data.data(), data.size());
henrike@webrtc.org28e20752013-07-10 00:45:36435 }
Danil Chapovalov33b01f22016-05-11 17:55:27436 rtc::Buffer CreateRtpData(uint32_t ssrc, int sequence_number, int pl_type) {
437 rtc::Buffer data(rtp_packet_.data(), rtp_packet_.size());
henrike@webrtc.org28e20752013-07-10 00:45:36438 // Set SSRC in the rtp packet copy.
Danil Chapovalov33b01f22016-05-11 17:55:27439 rtc::SetBE32(data.data() + 8, ssrc);
440 rtc::SetBE16(data.data() + 2, sequence_number);
buildbot@webrtc.org5ee0f052014-05-05 20:18:08441 if (pl_type >= 0) {
Danil Chapovalov33b01f22016-05-11 17:55:27442 rtc::Set8(data.data(), 1, static_cast<uint8_t>(pl_type));
buildbot@webrtc.org5ee0f052014-05-05 20:18:08443 }
henrike@webrtc.org28e20752013-07-10 00:45:36444 return data;
445 }
henrike@webrtc.org28e20752013-07-10 00:45:36446
Yves Gerey665174f2018-06-19 13:03:05447 bool CheckNoRtp1() { return media_channel1_->CheckNoRtp(); }
448 bool CheckNoRtp2() { return media_channel2_->CheckNoRtp(); }
henrike@webrtc.org28e20752013-07-10 00:45:36449
450 void CreateContent(int flags,
451 const cricket::AudioCodec& audio_codec,
452 const cricket::VideoCodec& video_codec,
453 typename T::Content* content) {
454 // overridden in specialized classes
455 }
456 void CopyContent(const typename T::Content& source,
457 typename T::Content* content) {
458 // overridden in specialized classes
459 }
460
Steve Anton18ee1d52017-09-11 18:32:35461 // Creates a MediaContent with one stream.
henrike@webrtc.org28e20752013-07-10 00:45:36462 // kPcmuCodec is used as audio codec and kH264Codec is used as video codec.
Steve Anton18ee1d52017-09-11 18:32:35463 typename T::Content* CreateMediaContentWithStream(uint32_t ssrc) {
464 typename T::Content* content = new typename T::Content();
Zhi Huange830e682018-03-30 17:48:35465 CreateContent(0, kPcmuCodec, kH264Codec, content);
Steve Anton18ee1d52017-09-11 18:32:35466 AddLegacyStreamInContent(ssrc, 0, content);
467 return content;
henrike@webrtc.org28e20752013-07-10 00:45:36468 }
469
ossu292d6582016-03-17 09:31:13470 // Will manage the lifetime of a CallThread, making sure it's
471 // destroyed before this object goes out of scope.
472 class ScopedCallThread {
473 public:
Danil Chapovalov33b01f22016-05-11 17:55:27474 template <class FunctorT>
Artem Titovd8bd7502019-01-09 20:10:00475 explicit ScopedCallThread(FunctorT&& functor)
Danil Chapovalovb877e712019-11-29 14:19:27476 : thread_(rtc::Thread::Create()) {
ossu292d6582016-03-17 09:31:13477 thread_->Start();
Danil Chapovalovb877e712019-11-29 14:19:27478 thread_->PostTask(RTC_FROM_HERE, std::forward<FunctorT>(functor));
ossu292d6582016-03-17 09:31:13479 }
480
Danil Chapovalov33b01f22016-05-11 17:55:27481 ~ScopedCallThread() { thread_->Stop(); }
ossu292d6582016-03-17 09:31:13482
Danil Chapovalov33b01f22016-05-11 17:55:27483 rtc::Thread* thread() { return thread_.get(); }
ossu292d6582016-03-17 09:31:13484
485 private:
Danil Chapovalov33b01f22016-05-11 17:55:27486 std::unique_ptr<rtc::Thread> thread_;
ossu292d6582016-03-17 09:31:13487 };
henrike@webrtc.org28e20752013-07-10 00:45:36488
henrike@webrtc.org28e20752013-07-10 00:45:36489 bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) {
490 return false; // overridden in specialized classes
491 }
492
deadbeeff5346592017-01-25 05:51:21493 void OnRtcpMuxFullyActive1(const std::string&) {
494 rtcp_mux_activated_callbacks1_++;
495 }
496 void OnRtcpMuxFullyActive2(const std::string&) {
497 rtcp_mux_activated_callbacks2_++;
498 }
henrike@webrtc.org28e20752013-07-10 00:45:36499
Honghai Zhangcc411c02016-03-30 00:27:21500 cricket::CandidatePairInterface* last_selected_candidate_pair() {
501 return last_selected_candidate_pair_;
502 }
503
Peter Boström0c4e06b2015-10-07 10:23:21504 void AddLegacyStreamInContent(uint32_t ssrc,
505 int flags,
506 typename T::Content* content) {
henrike@webrtc.org28e20752013-07-10 00:45:36507 // Base implementation.
508 }
509
510 // Tests that can be used by derived classes.
511
512 // Basic sanity check.
513 void TestInit() {
514 CreateChannels(0, 0);
Zhi Huangcf990f52017-09-22 19:12:30515 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:36516 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30517 if (verify_playout_) {
518 EXPECT_FALSE(media_channel1_->playout());
519 }
henrike@webrtc.org28e20752013-07-10 00:45:36520 EXPECT_TRUE(media_channel1_->codecs().empty());
521 EXPECT_TRUE(media_channel1_->recv_streams().empty());
522 EXPECT_TRUE(media_channel1_->rtp_packets().empty());
henrike@webrtc.org28e20752013-07-10 00:45:36523 }
524
525 // Test that SetLocalContent and SetRemoteContent properly configure
526 // the codecs.
527 void TestSetContents() {
528 CreateChannels(0, 0);
529 typename T::Content content;
530 CreateContent(0, kPcmuCodec, kH264Codec, &content);
Steve Anton3828c062017-12-06 18:34:51531 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36532 EXPECT_EQ(0U, media_channel1_->codecs().size());
Steve Anton3828c062017-12-06 18:34:51533 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36534 ASSERT_EQ(1U, media_channel1_->codecs().size());
Yves Gerey665174f2018-06-19 13:03:05535 EXPECT_TRUE(
536 CodecMatches(content.codecs()[0], media_channel1_->codecs()[0]));
henrike@webrtc.org28e20752013-07-10 00:45:36537 }
538
Johannes Kron9190b822018-10-29 10:22:05539 // Test that SetLocalContent and SetRemoteContent properly configure
540 // extmap-allow-mixed.
541 void TestSetContentsExtmapAllowMixedCaller(bool offer, bool answer) {
542 // For a caller, SetLocalContent() is called first with an offer and next
543 // SetRemoteContent() is called with the answer.
544 CreateChannels(0, 0);
545 typename T::Content content;
546 CreateContent(0, kPcmuCodec, kH264Codec, &content);
547 auto offer_enum = offer ? (T::Content::kSession) : (T::Content::kNo);
548 auto answer_enum = answer ? (T::Content::kSession) : (T::Content::kNo);
549 content.set_extmap_allow_mixed_enum(offer_enum);
550 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, NULL));
551 content.set_extmap_allow_mixed_enum(answer_enum);
552 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
553 EXPECT_EQ(answer, media_channel1_->ExtmapAllowMixed());
554 }
555 void TestSetContentsExtmapAllowMixedCallee(bool offer, bool answer) {
556 // For a callee, SetRemoteContent() is called first with an offer and next
557 // SetLocalContent() is called with the answer.
558 CreateChannels(0, 0);
559 typename T::Content content;
560 CreateContent(0, kPcmuCodec, kH264Codec, &content);
561 auto offer_enum = offer ? (T::Content::kSession) : (T::Content::kNo);
562 auto answer_enum = answer ? (T::Content::kSession) : (T::Content::kNo);
563 content.set_extmap_allow_mixed_enum(offer_enum);
564 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kOffer, NULL));
565 content.set_extmap_allow_mixed_enum(answer_enum);
566 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kAnswer, NULL));
567 EXPECT_EQ(answer, media_channel1_->ExtmapAllowMixed());
568 }
569
henrike@webrtc.org28e20752013-07-10 00:45:36570 // Test that SetLocalContent and SetRemoteContent properly deals
571 // with an empty offer.
572 void TestSetContentsNullOffer() {
573 CreateChannels(0, 0);
574 typename T::Content content;
Steve Anton3828c062017-12-06 18:34:51575 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36576 CreateContent(0, kPcmuCodec, kH264Codec, &content);
577 EXPECT_EQ(0U, media_channel1_->codecs().size());
Steve Anton3828c062017-12-06 18:34:51578 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36579 ASSERT_EQ(1U, media_channel1_->codecs().size());
Yves Gerey665174f2018-06-19 13:03:05580 EXPECT_TRUE(
581 CodecMatches(content.codecs()[0], media_channel1_->codecs()[0]));
henrike@webrtc.org28e20752013-07-10 00:45:36582 }
583
584 // Test that SetLocalContent and SetRemoteContent properly set RTCP
585 // mux.
586 void TestSetContentsRtcpMux() {
deadbeefac22f702017-01-13 05:59:29587 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:36588 typename T::Content content;
589 CreateContent(0, kPcmuCodec, kH264Codec, &content);
590 // Both sides agree on mux. Should no longer be a separate RTCP channel.
591 content.set_rtcp_mux(true);
Steve Anton3828c062017-12-06 18:34:51592 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, NULL));
593 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36594 // Only initiator supports mux. Should still have a separate RTCP channel.
Steve Anton3828c062017-12-06 18:34:51595 EXPECT_TRUE(channel2_->SetLocalContent(&content, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36596 content.set_rtcp_mux(false);
Steve Anton3828c062017-12-06 18:34:51597 EXPECT_TRUE(channel2_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36598 }
599
600 // Test that SetLocalContent and SetRemoteContent properly set RTCP
601 // mux when a provisional answer is received.
602 void TestSetContentsRtcpMuxWithPrAnswer() {
deadbeefac22f702017-01-13 05:59:29603 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:36604 typename T::Content content;
605 CreateContent(0, kPcmuCodec, kH264Codec, &content);
606 content.set_rtcp_mux(true);
Steve Anton3828c062017-12-06 18:34:51607 EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, NULL));
608 EXPECT_TRUE(
609 channel1_->SetRemoteContent(&content, SdpType::kPrAnswer, NULL));
deadbeeff5346592017-01-25 05:51:21610 // Both sides agree on mux. Should signal RTCP mux as fully activated.
611 EXPECT_EQ(0, rtcp_mux_activated_callbacks1_);
Steve Anton3828c062017-12-06 18:34:51612 EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
deadbeeff5346592017-01-25 05:51:21613 EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
henrike@webrtc.org28e20752013-07-10 00:45:36614 // Only initiator supports mux. Should still have a separate RTCP channel.
Steve Anton3828c062017-12-06 18:34:51615 EXPECT_TRUE(channel2_->SetLocalContent(&content, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36616 content.set_rtcp_mux(false);
Steve Anton3828c062017-12-06 18:34:51617 EXPECT_TRUE(
618 channel2_->SetRemoteContent(&content, SdpType::kPrAnswer, NULL));
619 EXPECT_TRUE(channel2_->SetRemoteContent(&content, SdpType::kAnswer, NULL));
deadbeeff5346592017-01-25 05:51:21620 EXPECT_EQ(0, rtcp_mux_activated_callbacks2_);
henrike@webrtc.org28e20752013-07-10 00:45:36621 }
622
henrike@webrtc.org28e20752013-07-10 00:45:36623 // Test that SetLocalContent and SetRemoteContent properly
624 // handles adding and removing StreamParams when the action is a full
Steve Anton3828c062017-12-06 18:34:51625 // SdpType::kOffer / SdpType::kAnswer.
henrike@webrtc.org28e20752013-07-10 00:45:36626 void TestChangeStreamParamsInContent() {
627 cricket::StreamParams stream1;
628 stream1.groupid = "group1";
629 stream1.id = "stream1";
630 stream1.ssrcs.push_back(kSsrc1);
631 stream1.cname = "stream1_cname";
632
633 cricket::StreamParams stream2;
634 stream2.groupid = "group1";
635 stream2.id = "stream2";
636 stream2.ssrcs.push_back(kSsrc2);
637 stream2.cname = "stream2_cname";
638
639 // Setup a call where channel 1 send |stream1| to channel 2.
640 CreateChannels(0, 0);
641 typename T::Content content1;
642 CreateContent(0, kPcmuCodec, kH264Codec, &content1);
643 content1.AddStream(stream1);
Steve Anton3828c062017-12-06 18:34:51644 EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36645 EXPECT_TRUE(channel1_->Enable(true));
646 EXPECT_EQ(1u, media_channel1_->send_streams().size());
647
Steve Anton3828c062017-12-06 18:34:51648 EXPECT_TRUE(channel2_->SetRemoteContent(&content1, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36649 EXPECT_EQ(1u, media_channel2_->recv_streams().size());
deadbeeff5346592017-01-25 05:51:21650 ConnectFakeTransports();
henrike@webrtc.org28e20752013-07-10 00:45:36651
652 // Channel 2 do not send anything.
653 typename T::Content content2;
654 CreateContent(0, kPcmuCodec, kH264Codec, &content2);
Steve Anton3828c062017-12-06 18:34:51655 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36656 EXPECT_EQ(0u, media_channel1_->recv_streams().size());
Steve Anton3828c062017-12-06 18:34:51657 EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36658 EXPECT_TRUE(channel2_->Enable(true));
659 EXPECT_EQ(0u, media_channel2_->send_streams().size());
660
Danil Chapovalov33b01f22016-05-11 17:55:27661 SendCustomRtp1(kSsrc1, 0);
662 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36663 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0));
664
665 // Let channel 2 update the content by sending |stream2| and enable SRTP.
666 typename T::Content content3;
Zhi Huange830e682018-03-30 17:48:35667 CreateContent(0, kPcmuCodec, kH264Codec, &content3);
henrike@webrtc.org28e20752013-07-10 00:45:36668 content3.AddStream(stream2);
Steve Anton3828c062017-12-06 18:34:51669 EXPECT_TRUE(channel2_->SetLocalContent(&content3, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36670 ASSERT_EQ(1u, media_channel2_->send_streams().size());
671 EXPECT_EQ(stream2, media_channel2_->send_streams()[0]);
672
Steve Anton3828c062017-12-06 18:34:51673 EXPECT_TRUE(channel1_->SetRemoteContent(&content3, SdpType::kOffer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36674 ASSERT_EQ(1u, media_channel1_->recv_streams().size());
675 EXPECT_EQ(stream2, media_channel1_->recv_streams()[0]);
676
677 // Channel 1 replies but stop sending stream1.
678 typename T::Content content4;
Zhi Huange830e682018-03-30 17:48:35679 CreateContent(0, kPcmuCodec, kH264Codec, &content4);
Steve Anton3828c062017-12-06 18:34:51680 EXPECT_TRUE(channel1_->SetLocalContent(&content4, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36681 EXPECT_EQ(0u, media_channel1_->send_streams().size());
682
Steve Anton3828c062017-12-06 18:34:51683 EXPECT_TRUE(channel2_->SetRemoteContent(&content4, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36684 EXPECT_EQ(0u, media_channel2_->recv_streams().size());
685
Danil Chapovalov33b01f22016-05-11 17:55:27686 SendCustomRtp2(kSsrc2, 0);
687 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36688 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0));
689 }
690
691 // Test that we only start playout and sending at the right times.
692 void TestPlayoutAndSendingStates() {
693 CreateChannels(0, 0);
Peter Boström34fbfff2015-09-24 17:20:30694 if (verify_playout_) {
695 EXPECT_FALSE(media_channel1_->playout());
696 }
henrike@webrtc.org28e20752013-07-10 00:45:36697 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30698 if (verify_playout_) {
699 EXPECT_FALSE(media_channel2_->playout());
700 }
henrike@webrtc.org28e20752013-07-10 00:45:36701 EXPECT_FALSE(media_channel2_->sending());
702 EXPECT_TRUE(channel1_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30703 if (verify_playout_) {
704 EXPECT_FALSE(media_channel1_->playout());
705 }
henrike@webrtc.org28e20752013-07-10 00:45:36706 EXPECT_FALSE(media_channel1_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54707 EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
Steve Anton3828c062017-12-06 18:34:51708 SdpType::kOffer, NULL));
Peter Boström34fbfff2015-09-24 17:20:30709 if (verify_playout_) {
710 EXPECT_TRUE(media_channel1_->playout());
711 }
henrike@webrtc.org28e20752013-07-10 00:45:36712 EXPECT_FALSE(media_channel1_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54713 EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_,
Steve Anton3828c062017-12-06 18:34:51714 SdpType::kOffer, NULL));
Peter Boström34fbfff2015-09-24 17:20:30715 if (verify_playout_) {
716 EXPECT_FALSE(media_channel2_->playout());
717 }
henrike@webrtc.org28e20752013-07-10 00:45:36718 EXPECT_FALSE(media_channel2_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54719 EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_,
Steve Anton3828c062017-12-06 18:34:51720 SdpType::kAnswer, NULL));
Peter Boström34fbfff2015-09-24 17:20:30721 if (verify_playout_) {
722 EXPECT_FALSE(media_channel2_->playout());
723 }
henrike@webrtc.org28e20752013-07-10 00:45:36724 EXPECT_FALSE(media_channel2_->sending());
deadbeeff5346592017-01-25 05:51:21725 ConnectFakeTransports();
Peter Boström34fbfff2015-09-24 17:20:30726 if (verify_playout_) {
727 EXPECT_TRUE(media_channel1_->playout());
728 }
henrike@webrtc.org28e20752013-07-10 00:45:36729 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30730 if (verify_playout_) {
731 EXPECT_FALSE(media_channel2_->playout());
732 }
henrike@webrtc.org28e20752013-07-10 00:45:36733 EXPECT_FALSE(media_channel2_->sending());
734 EXPECT_TRUE(channel2_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30735 if (verify_playout_) {
736 EXPECT_TRUE(media_channel2_->playout());
737 }
henrike@webrtc.org28e20752013-07-10 00:45:36738 EXPECT_TRUE(media_channel2_->sending());
sergeyu@chromium.org4b26e2e2014-01-15 23:15:54739 EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_,
Steve Anton3828c062017-12-06 18:34:51740 SdpType::kAnswer, NULL));
Peter Boström34fbfff2015-09-24 17:20:30741 if (verify_playout_) {
742 EXPECT_TRUE(media_channel1_->playout());
743 }
henrike@webrtc.org28e20752013-07-10 00:45:36744 EXPECT_TRUE(media_channel1_->sending());
745 }
746
henrike@webrtc.org28e20752013-07-10 00:45:36747 // Test that changing the MediaContentDirection in the local and remote
748 // session description start playout and sending at the right time.
749 void TestMediaContentDirection() {
750 CreateChannels(0, 0);
751 typename T::Content content1;
752 CreateContent(0, kPcmuCodec, kH264Codec, &content1);
753 typename T::Content content2;
754 CreateContent(0, kPcmuCodec, kH264Codec, &content2);
755 // Set |content2| to be InActive.
Steve Anton4e70a722017-11-28 22:57:10756 content2.set_direction(RtpTransceiverDirection::kInactive);
henrike@webrtc.org28e20752013-07-10 00:45:36757
758 EXPECT_TRUE(channel1_->Enable(true));
759 EXPECT_TRUE(channel2_->Enable(true));
Peter Boström34fbfff2015-09-24 17:20:30760 if (verify_playout_) {
761 EXPECT_FALSE(media_channel1_->playout());
762 }
henrike@webrtc.org28e20752013-07-10 00:45:36763 EXPECT_FALSE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30764 if (verify_playout_) {
765 EXPECT_FALSE(media_channel2_->playout());
766 }
henrike@webrtc.org28e20752013-07-10 00:45:36767 EXPECT_FALSE(media_channel2_->sending());
768
Steve Anton3828c062017-12-06 18:34:51769 EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, NULL));
770 EXPECT_TRUE(channel2_->SetRemoteContent(&content1, SdpType::kOffer, NULL));
771 EXPECT_TRUE(
772 channel2_->SetLocalContent(&content2, SdpType::kPrAnswer, NULL));
773 EXPECT_TRUE(
774 channel1_->SetRemoteContent(&content2, SdpType::kPrAnswer, NULL));
deadbeeff5346592017-01-25 05:51:21775 ConnectFakeTransports();
henrike@webrtc.org28e20752013-07-10 00:45:36776
Peter Boström34fbfff2015-09-24 17:20:30777 if (verify_playout_) {
778 EXPECT_TRUE(media_channel1_->playout());
779 }
henrike@webrtc.org28e20752013-07-10 00:45:36780 EXPECT_FALSE(media_channel1_->sending()); // remote InActive
Peter Boström34fbfff2015-09-24 17:20:30781 if (verify_playout_) {
782 EXPECT_FALSE(media_channel2_->playout()); // local InActive
783 }
henrike@webrtc.org28e20752013-07-10 00:45:36784 EXPECT_FALSE(media_channel2_->sending()); // local InActive
785
786 // Update |content2| to be RecvOnly.
Steve Anton4e70a722017-11-28 22:57:10787 content2.set_direction(RtpTransceiverDirection::kRecvOnly);
Steve Anton3828c062017-12-06 18:34:51788 EXPECT_TRUE(
789 channel2_->SetLocalContent(&content2, SdpType::kPrAnswer, NULL));
790 EXPECT_TRUE(
791 channel1_->SetRemoteContent(&content2, SdpType::kPrAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36792
Peter Boström34fbfff2015-09-24 17:20:30793 if (verify_playout_) {
794 EXPECT_TRUE(media_channel1_->playout());
795 }
henrike@webrtc.org28e20752013-07-10 00:45:36796 EXPECT_TRUE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30797 if (verify_playout_) {
798 EXPECT_TRUE(media_channel2_->playout()); // local RecvOnly
799 }
henrike@webrtc.org28e20752013-07-10 00:45:36800 EXPECT_FALSE(media_channel2_->sending()); // local RecvOnly
801
802 // Update |content2| to be SendRecv.
Steve Anton4e70a722017-11-28 22:57:10803 content2.set_direction(RtpTransceiverDirection::kSendRecv);
Steve Anton3828c062017-12-06 18:34:51804 EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kAnswer, NULL));
805 EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, NULL));
henrike@webrtc.org28e20752013-07-10 00:45:36806
Peter Boström34fbfff2015-09-24 17:20:30807 if (verify_playout_) {
808 EXPECT_TRUE(media_channel1_->playout());
809 }
henrike@webrtc.org28e20752013-07-10 00:45:36810 EXPECT_TRUE(media_channel1_->sending());
Peter Boström34fbfff2015-09-24 17:20:30811 if (verify_playout_) {
812 EXPECT_TRUE(media_channel2_->playout());
813 }
henrike@webrtc.org28e20752013-07-10 00:45:36814 EXPECT_TRUE(media_channel2_->sending());
815 }
816
Honghai Zhangcc411c02016-03-30 00:27:21817 // Tests that when the transport channel signals a candidate pair change
818 // event, the media channel will receive a call on the network route change.
819 void TestNetworkRouteChanges() {
eladalon05b07bb2017-08-24 14:40:16820 static constexpr uint16_t kLocalNetId = 1;
821 static constexpr uint16_t kRemoteNetId = 2;
822 static constexpr int kLastPacketId = 100;
Zhi Huang942bc2e2017-11-13 21:26:07823 // Ipv4(20) + UDP(8).
824 static constexpr int kTransportOverheadPerPacket = 28;
Zhi Huangcf6e24a2018-02-21 18:40:07825 static constexpr int kSrtpOverheadPerPacket = 10;
Danil Chapovalov33b01f22016-05-11 17:55:27826
Zhi Huangcf6e24a2018-02-21 18:40:07827 CreateChannels(DTLS, DTLS);
828 SendInitiate();
Honghai Zhangcc411c02016-03-30 00:27:21829
Honghai Zhangcc411c02016-03-30 00:27:21830 typename T::MediaChannel* media_channel1 =
831 static_cast<typename T::MediaChannel*>(channel1_->media_channel());
Danil Chapovalov33b01f22016-05-11 17:55:27832 ASSERT_TRUE(media_channel1);
Honghai Zhangcc411c02016-03-30 00:27:21833
Zhi Huang942bc2e2017-11-13 21:26:07834 // Need to wait for the threads before calling
835 // |set_num_network_route_changes| because the network route would be set
836 // when creating the channel.
837 WaitForThreads();
Danil Chapovalov33b01f22016-05-11 17:55:27838 media_channel1->set_num_network_route_changes(0);
deadbeeff5346592017-01-25 05:51:21839 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
Zhi Huang942bc2e2017-11-13 21:26:07840 rtc::NetworkRoute network_route;
Danil Chapovalov33b01f22016-05-11 17:55:27841 // The transport channel becomes disconnected.
Zhi Huang942bc2e2017-11-13 21:26:07842 fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
Danil Chapovalov66cadcc2018-06-19 14:47:43843 absl::optional<rtc::NetworkRoute>(network_route));
Danil Chapovalov33b01f22016-05-11 17:55:27844 });
845 WaitForThreads();
846 EXPECT_EQ(1, media_channel1->num_network_route_changes());
Honghai Zhangcc411c02016-03-30 00:27:21847 EXPECT_FALSE(media_channel1->last_network_route().connected);
Danil Chapovalov33b01f22016-05-11 17:55:27848 media_channel1->set_num_network_route_changes(0);
Honghai Zhangcc411c02016-03-30 00:27:21849
eladalon05b07bb2017-08-24 14:40:16850 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
Zhi Huang942bc2e2017-11-13 21:26:07851 rtc::NetworkRoute network_route;
852 network_route.connected = true;
Jonas Oreland71fda362020-03-20 15:11:56853 network_route.local =
854 rtc::RouteEndpoint::CreateWithNetworkId(kLocalNetId);
855 network_route.remote =
856 rtc::RouteEndpoint::CreateWithNetworkId(kRemoteNetId);
Zhi Huang942bc2e2017-11-13 21:26:07857 network_route.last_sent_packet_id = kLastPacketId;
858 network_route.packet_overhead = kTransportOverheadPerPacket;
Danil Chapovalov33b01f22016-05-11 17:55:27859 // The transport channel becomes connected.
Zhi Huang942bc2e2017-11-13 21:26:07860 fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged(
861
Danil Chapovalov66cadcc2018-06-19 14:47:43862 absl::optional<rtc::NetworkRoute>(network_route));
Danil Chapovalov33b01f22016-05-11 17:55:27863 });
864 WaitForThreads();
865 EXPECT_EQ(1, media_channel1->num_network_route_changes());
Sebastian Janssonaf2adda2018-12-04 10:16:19866 EXPECT_TRUE(media_channel1->last_network_route().connected);
867 EXPECT_EQ(kLocalNetId,
Jonas Oreland71fda362020-03-20 15:11:56868 media_channel1->last_network_route().local.network_id());
Sebastian Janssonaf2adda2018-12-04 10:16:19869 EXPECT_EQ(kRemoteNetId,
Jonas Oreland71fda362020-03-20 15:11:56870 media_channel1->last_network_route().remote.network_id());
Danil Chapovalov33b01f22016-05-11 17:55:27871 EXPECT_EQ(kLastPacketId,
Honghai Zhang52dce73f2016-03-31 19:37:31872 media_channel1->last_network_route().last_sent_packet_id);
Zhi Huangcf6e24a2018-02-21 18:40:07873 EXPECT_EQ(kTransportOverheadPerPacket + kSrtpOverheadPerPacket,
michaelt79e05882016-11-08 10:50:09874 media_channel1->transport_overhead_per_packet());
Honghai Zhangcc411c02016-03-30 00:27:21875 }
876
henrike@webrtc.org28e20752013-07-10 00:45:36877 // Test setting up a call.
878 void TestCallSetup() {
879 CreateChannels(0, 0);
Zhi Huangcf990f52017-09-22 19:12:30880 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:36881 EXPECT_TRUE(SendInitiate());
Peter Boström34fbfff2015-09-24 17:20:30882 if (verify_playout_) {
883 EXPECT_TRUE(media_channel1_->playout());
884 }
henrike@webrtc.org28e20752013-07-10 00:45:36885 EXPECT_FALSE(media_channel1_->sending());
886 EXPECT_TRUE(SendAccept());
Zhi Huangcf990f52017-09-22 19:12:30887 EXPECT_FALSE(channel1_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:36888 EXPECT_TRUE(media_channel1_->sending());
889 EXPECT_EQ(1U, media_channel1_->codecs().size());
Peter Boström34fbfff2015-09-24 17:20:30890 if (verify_playout_) {
891 EXPECT_TRUE(media_channel2_->playout());
892 }
henrike@webrtc.org28e20752013-07-10 00:45:36893 EXPECT_TRUE(media_channel2_->sending());
894 EXPECT_EQ(1U, media_channel2_->codecs().size());
895 }
896
897 // Test that we don't crash if packets are sent during call teardown
898 // when RTCP mux is enabled. This is a regression test against a specific
899 // race condition that would only occur when a RTCP packet was sent during
900 // teardown of a channel on which RTCP mux was enabled.
901 void TestCallTeardownRtcpMux() {
902 class LastWordMediaChannel : public T::MediaChannel {
903 public:
Fredrik Solenbergb071a192015-09-17 14:42:56904 LastWordMediaChannel() : T::MediaChannel(NULL, typename T::Options()) {}
henrike@webrtc.org28e20752013-07-10 00:45:36905 ~LastWordMediaChannel() {
stefanc1aeaf02015-10-15 14:26:07906 T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame),
907 rtc::PacketOptions());
henrike@webrtc.org28e20752013-07-10 00:45:36908 T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
909 }
910 };
Mirko Bonadei317a1f02019-09-17 15:06:18911 CreateChannels(std::make_unique<LastWordMediaChannel>(),
912 std::make_unique<LastWordMediaChannel>(), RTCP_MUX,
Karl Wiberg918f50c2018-07-05 09:40:33913 RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:36914 EXPECT_TRUE(SendInitiate());
915 EXPECT_TRUE(SendAccept());
deadbeeff5346592017-01-25 05:51:21916 EXPECT_TRUE(Terminate());
henrike@webrtc.org28e20752013-07-10 00:45:36917 }
918
919 // Send voice RTP data to the other side and ensure it gets there.
920 void SendRtpToRtp() {
Zhi Huange830e682018-03-30 17:48:35921 CreateChannels(RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:36922 EXPECT_TRUE(SendInitiate());
923 EXPECT_TRUE(SendAccept());
Bjorn A Mellem3a1b9272019-05-24 23:13:08924 EXPECT_TRUE(channel1_->rtp_transport()->rtcp_mux_enabled());
925 EXPECT_TRUE(channel2_->rtp_transport()->rtcp_mux_enabled());
Danil Chapovalov33b01f22016-05-11 17:55:27926 SendRtp1();
927 SendRtp2();
928 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36929 EXPECT_TRUE(CheckRtp1());
930 EXPECT_TRUE(CheckRtp2());
931 EXPECT_TRUE(CheckNoRtp1());
932 EXPECT_TRUE(CheckNoRtp2());
933 }
934
Danil Chapovalovdae07ba2016-05-13 23:43:50935 void TestDeinit() {
deadbeefac22f702017-01-13 05:59:29936 CreateChannels(0, 0);
Danil Chapovalovdae07ba2016-05-13 23:43:50937 EXPECT_TRUE(SendInitiate());
938 EXPECT_TRUE(SendAccept());
939 SendRtp1();
940 SendRtp2();
Danil Chapovalovdae07ba2016-05-13 23:43:50941 // Do not wait, destroy channels.
942 channel1_.reset(nullptr);
943 channel2_.reset(nullptr);
944 }
945
Zhi Huange830e682018-03-30 17:48:35946 void SendDtlsSrtpToDtlsSrtp(int flags1, int flags2) {
947 CreateChannels(flags1 | DTLS, flags2 | DTLS);
Zhi Huangcf990f52017-09-22 19:12:30948 EXPECT_FALSE(channel1_->srtp_active());
949 EXPECT_FALSE(channel2_->srtp_active());
henrike@webrtc.org28e20752013-07-10 00:45:36950 EXPECT_TRUE(SendInitiate());
Danil Chapovalov33b01f22016-05-11 17:55:27951 WaitForThreads();
952 EXPECT_TRUE(channel1_->writable());
953 EXPECT_TRUE(channel2_->writable());
henrike@webrtc.org28e20752013-07-10 00:45:36954 EXPECT_TRUE(SendAccept());
Zhi Huangcf990f52017-09-22 19:12:30955 EXPECT_TRUE(channel1_->srtp_active());
956 EXPECT_TRUE(channel2_->srtp_active());
Danil Chapovalov33b01f22016-05-11 17:55:27957 SendRtp1();
958 SendRtp2();
Danil Chapovalov33b01f22016-05-11 17:55:27959 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:36960 EXPECT_TRUE(CheckRtp1());
961 EXPECT_TRUE(CheckRtp2());
962 EXPECT_TRUE(CheckNoRtp1());
963 EXPECT_TRUE(CheckNoRtp2());
henrike@webrtc.org28e20752013-07-10 00:45:36964 }
965
966 // Test that we can send and receive early media when a provisional answer is
967 // sent and received. The test uses SRTP, RTCP mux and SSRC mux.
968 void SendEarlyMediaUsingRtcpMuxSrtp() {
Yves Gerey665174f2018-06-19 13:03:05969 int sequence_number1_1 = 0, sequence_number2_2 = 0;
henrike@webrtc.org28e20752013-07-10 00:45:36970
Yves Gerey665174f2018-06-19 13:03:05971 CreateChannels(SSRC_MUX | RTCP_MUX | DTLS, SSRC_MUX | RTCP_MUX | DTLS);
972 EXPECT_TRUE(SendOffer());
973 EXPECT_TRUE(SendProvisionalAnswer());
974 EXPECT_TRUE(channel1_->srtp_active());
975 EXPECT_TRUE(channel2_->srtp_active());
Bjorn A Mellem3a1b9272019-05-24 23:13:08976 EXPECT_TRUE(channel1_->rtp_transport()->rtcp_mux_enabled());
977 EXPECT_TRUE(channel2_->rtp_transport()->rtcp_mux_enabled());
Yves Gerey665174f2018-06-19 13:03:05978 WaitForThreads(); // Wait for 'sending' flag go through network thread.
Yves Gerey665174f2018-06-19 13:03:05979 SendCustomRtp1(kSsrc1, ++sequence_number1_1);
980 WaitForThreads();
Yves Gerey665174f2018-06-19 13:03:05981 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
henrike@webrtc.org28e20752013-07-10 00:45:36982
Yves Gerey665174f2018-06-19 13:03:05983 // Send packets from callee and verify that it is received.
Yves Gerey665174f2018-06-19 13:03:05984 SendCustomRtp2(kSsrc2, ++sequence_number2_2);
985 WaitForThreads();
Yves Gerey665174f2018-06-19 13:03:05986 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
henrike@webrtc.org28e20752013-07-10 00:45:36987
Yves Gerey665174f2018-06-19 13:03:05988 // Complete call setup and ensure everything is still OK.
989 EXPECT_TRUE(SendFinalAnswer());
990 EXPECT_TRUE(channel1_->srtp_active());
991 EXPECT_TRUE(channel2_->srtp_active());
Yves Gerey665174f2018-06-19 13:03:05992 SendCustomRtp1(kSsrc1, ++sequence_number1_1);
Yves Gerey665174f2018-06-19 13:03:05993 SendCustomRtp2(kSsrc2, ++sequence_number2_2);
994 WaitForThreads();
Yves Gerey665174f2018-06-19 13:03:05995 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
Yves Gerey665174f2018-06-19 13:03:05996 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
henrike@webrtc.org28e20752013-07-10 00:45:36997 }
998
999 // Test that we properly send RTP without SRTP from a thread.
1000 void SendRtpToRtpOnThread() {
deadbeefac22f702017-01-13 05:59:291001 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361002 EXPECT_TRUE(SendInitiate());
1003 EXPECT_TRUE(SendAccept());
Danil Chapovalov33b01f22016-05-11 17:55:271004 ScopedCallThread send_rtp1([this] { SendRtp1(); });
1005 ScopedCallThread send_rtp2([this] { SendRtp2(); });
Bjorn A Mellemd0704ce2019-10-10 17:49:531006 rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread()};
Danil Chapovalov33b01f22016-05-11 17:55:271007 WaitForThreads(involved_threads);
1008 EXPECT_TRUE(CheckRtp1());
1009 EXPECT_TRUE(CheckRtp2());
henrike@webrtc.org28e20752013-07-10 00:45:361010 EXPECT_TRUE(CheckNoRtp1());
1011 EXPECT_TRUE(CheckNoRtp2());
henrike@webrtc.org28e20752013-07-10 00:45:361012 }
1013
henrike@webrtc.org28e20752013-07-10 00:45:361014 // Test that the mediachannel retains its sending state after the transport
1015 // becomes non-writable.
1016 void SendWithWritabilityLoss() {
Zhi Huange830e682018-03-30 17:48:351017 CreateChannels(RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:361018 EXPECT_TRUE(SendInitiate());
1019 EXPECT_TRUE(SendAccept());
Bjorn A Mellem3a1b9272019-05-24 23:13:081020 EXPECT_TRUE(channel1_->rtp_transport()->rtcp_mux_enabled());
1021 EXPECT_TRUE(channel2_->rtp_transport()->rtcp_mux_enabled());
Danil Chapovalov33b01f22016-05-11 17:55:271022 SendRtp1();
1023 SendRtp2();
1024 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361025 EXPECT_TRUE(CheckRtp1());
1026 EXPECT_TRUE(CheckRtp2());
1027 EXPECT_TRUE(CheckNoRtp1());
1028 EXPECT_TRUE(CheckNoRtp2());
1029
wu@webrtc.org97077a32013-10-25 21:18:331030 // Lose writability, which should fail.
deadbeeff5346592017-01-25 05:51:211031 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1032 fake_rtp_dtls_transport1_->SetWritable(false);
1033 });
Danil Chapovalov33b01f22016-05-11 17:55:271034 SendRtp1();
1035 SendRtp2();
1036 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361037 EXPECT_TRUE(CheckRtp1());
1038 EXPECT_TRUE(CheckNoRtp2());
1039
1040 // Regain writability
deadbeeff5346592017-01-25 05:51:211041 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1042 fake_rtp_dtls_transport1_->SetWritable(true);
1043 });
henrike@webrtc.org28e20752013-07-10 00:45:361044 EXPECT_TRUE(media_channel1_->sending());
Danil Chapovalov33b01f22016-05-11 17:55:271045 SendRtp1();
1046 SendRtp2();
1047 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361048 EXPECT_TRUE(CheckRtp1());
1049 EXPECT_TRUE(CheckRtp2());
1050 EXPECT_TRUE(CheckNoRtp1());
1051 EXPECT_TRUE(CheckNoRtp2());
1052
1053 // Lose writability completely
deadbeeff5346592017-01-25 05:51:211054 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
1055 bool asymmetric = true;
1056 fake_rtp_dtls_transport1_->SetDestination(nullptr, asymmetric);
1057 });
henrike@webrtc.org28e20752013-07-10 00:45:361058 EXPECT_TRUE(media_channel1_->sending());
1059
wu@webrtc.org97077a32013-10-25 21:18:331060 // Should fail also.
Danil Chapovalov33b01f22016-05-11 17:55:271061 SendRtp1();
1062 SendRtp2();
1063 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361064 EXPECT_TRUE(CheckRtp1());
1065 EXPECT_TRUE(CheckNoRtp2());
zhihuangb2cdd932017-01-20 00:54:251066 EXPECT_TRUE(CheckNoRtp1());
henrike@webrtc.org28e20752013-07-10 00:45:361067
1068 // Gain writability back
Taylor Brandstetter5d97a9a2016-06-10 21:17:271069 network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
deadbeeff5346592017-01-25 05:51:211070 bool asymmetric = true;
1071 fake_rtp_dtls_transport1_->SetDestination(fake_rtp_dtls_transport2_.get(),
1072 asymmetric);
Taylor Brandstetter5d97a9a2016-06-10 21:17:271073 });
henrike@webrtc.org28e20752013-07-10 00:45:361074 EXPECT_TRUE(media_channel1_->sending());
Danil Chapovalov33b01f22016-05-11 17:55:271075 SendRtp1();
1076 SendRtp2();
1077 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361078 EXPECT_TRUE(CheckRtp1());
1079 EXPECT_TRUE(CheckRtp2());
1080 EXPECT_TRUE(CheckNoRtp1());
1081 EXPECT_TRUE(CheckNoRtp2());
1082 }
1083
Yves Gerey665174f2018-06-19 13:03:051084 void SendBundleToBundle(const int* pl_types,
1085 int len,
1086 bool rtcp_mux,
1087 bool secure) {
buildbot@webrtc.org5ee0f052014-05-05 20:18:081088 ASSERT_EQ(2, len);
henrike@webrtc.org28e20752013-07-10 00:45:361089 int sequence_number1_1 = 0, sequence_number2_2 = 0;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081090 // Only pl_type1 was added to the bundle filter for both |channel1_|
1091 // and |channel2_|.
1092 int pl_type1 = pl_types[0];
1093 int pl_type2 = pl_types[1];
deadbeefac22f702017-01-13 05:59:291094 int flags = SSRC_MUX;
Zhi Huange830e682018-03-30 17:48:351095 if (secure)
1096 flags |= DTLS;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081097 if (rtcp_mux) {
1098 flags |= RTCP_MUX;
buildbot@webrtc.org5ee0f052014-05-05 20:18:081099 }
1100 CreateChannels(flags, flags);
henrike@webrtc.org28e20752013-07-10 00:45:361101 EXPECT_TRUE(SendInitiate());
henrike@webrtc.org28e20752013-07-10 00:45:361102 EXPECT_TRUE(SendAccept());
buildbot@webrtc.org5ee0f052014-05-05 20:18:081103
1104 // Both channels can receive pl_type1 only.
Danil Chapovalov33b01f22016-05-11 17:55:271105 SendCustomRtp1(kSsrc1, ++sequence_number1_1, pl_type1);
1106 SendCustomRtp2(kSsrc2, ++sequence_number2_2, pl_type1);
1107 WaitForThreads();
buildbot@webrtc.org5ee0f052014-05-05 20:18:081108 EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1, pl_type1));
buildbot@webrtc.org5ee0f052014-05-05 20:18:081109 EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2, pl_type1));
1110 EXPECT_TRUE(CheckNoRtp1());
1111 EXPECT_TRUE(CheckNoRtp2());
1112
Zhi Huang365381f2018-04-13 23:44:341113 SendCustomRtp1(kSsrc3, ++sequence_number1_1, pl_type2);
1114 SendCustomRtp2(kSsrc4, ++sequence_number2_2, pl_type2);
Danil Chapovalov33b01f22016-05-11 17:55:271115 WaitForThreads();
Zhi Huang365381f2018-04-13 23:44:341116 EXPECT_FALSE(CheckCustomRtp2(kSsrc3, sequence_number1_1, pl_type2));
1117 EXPECT_FALSE(CheckCustomRtp1(kSsrc4, sequence_number2_2, pl_type2));
henrike@webrtc.org28e20752013-07-10 00:45:361118 }
1119
henrike@webrtc.org28e20752013-07-10 00:45:361120 void TestSetContentFailure() {
1121 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361122
Peter Thatchera6d24442015-07-10 04:26:361123 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351124 std::unique_ptr<typename T::Content> content(
1125 CreateMediaContentWithStream(1));
1126
henrike@webrtc.org28e20752013-07-10 00:45:361127 media_channel1_->set_fail_set_recv_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351128 EXPECT_FALSE(
Steve Anton3828c062017-12-06 18:34:511129 channel1_->SetLocalContent(content.get(), SdpType::kOffer, &err));
Steve Anton18ee1d52017-09-11 18:32:351130 EXPECT_FALSE(
Steve Anton3828c062017-12-06 18:34:511131 channel1_->SetLocalContent(content.get(), SdpType::kAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361132
henrike@webrtc.org28e20752013-07-10 00:45:361133 media_channel1_->set_fail_set_send_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351134 EXPECT_FALSE(
Steve Anton3828c062017-12-06 18:34:511135 channel1_->SetRemoteContent(content.get(), SdpType::kOffer, &err));
Steve Anton18ee1d52017-09-11 18:32:351136
henrike@webrtc.org28e20752013-07-10 00:45:361137 media_channel1_->set_fail_set_send_codecs(true);
Steve Anton18ee1d52017-09-11 18:32:351138 EXPECT_FALSE(
Steve Anton3828c062017-12-06 18:34:511139 channel1_->SetRemoteContent(content.get(), SdpType::kAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361140 }
1141
1142 void TestSendTwoOffers() {
1143 CreateChannels(0, 0);
1144
Peter Thatchera6d24442015-07-10 04:26:361145 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351146 std::unique_ptr<typename T::Content> content1(
1147 CreateMediaContentWithStream(1));
1148 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511149 channel1_->SetLocalContent(content1.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361150 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1151
Steve Anton18ee1d52017-09-11 18:32:351152 std::unique_ptr<typename T::Content> content2(
1153 CreateMediaContentWithStream(2));
1154 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511155 channel1_->SetLocalContent(content2.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361156 EXPECT_FALSE(media_channel1_->HasSendStream(1));
1157 EXPECT_TRUE(media_channel1_->HasSendStream(2));
1158 }
1159
1160 void TestReceiveTwoOffers() {
1161 CreateChannels(0, 0);
1162
Peter Thatchera6d24442015-07-10 04:26:361163 std::string err;
Steve Anton18ee1d52017-09-11 18:32:351164 std::unique_ptr<typename T::Content> content1(
1165 CreateMediaContentWithStream(1));
1166 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511167 channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361168 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1169
Steve Anton18ee1d52017-09-11 18:32:351170 std::unique_ptr<typename T::Content> content2(
1171 CreateMediaContentWithStream(2));
1172 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511173 channel1_->SetRemoteContent(content2.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361174 EXPECT_FALSE(media_channel1_->HasRecvStream(1));
1175 EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1176 }
1177
1178 void TestSendPrAnswer() {
1179 CreateChannels(0, 0);
1180
Peter Thatchera6d24442015-07-10 04:26:361181 std::string err;
1182 // Receive offer
Steve Anton18ee1d52017-09-11 18:32:351183 std::unique_ptr<typename T::Content> content1(
1184 CreateMediaContentWithStream(1));
1185 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511186 channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361187 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1188
Peter Thatchera6d24442015-07-10 04:26:361189 // Send PR answer
Steve Anton18ee1d52017-09-11 18:32:351190 std::unique_ptr<typename T::Content> content2(
1191 CreateMediaContentWithStream(2));
1192 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511193 channel1_->SetLocalContent(content2.get(), SdpType::kPrAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361194 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1195 EXPECT_TRUE(media_channel1_->HasSendStream(2));
1196
Peter Thatchera6d24442015-07-10 04:26:361197 // Send answer
Steve Anton18ee1d52017-09-11 18:32:351198 std::unique_ptr<typename T::Content> content3(
1199 CreateMediaContentWithStream(3));
1200 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511201 channel1_->SetLocalContent(content3.get(), SdpType::kAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361202 EXPECT_TRUE(media_channel1_->HasRecvStream(1));
1203 EXPECT_FALSE(media_channel1_->HasSendStream(2));
1204 EXPECT_TRUE(media_channel1_->HasSendStream(3));
1205 }
1206
1207 void TestReceivePrAnswer() {
1208 CreateChannels(0, 0);
1209
Peter Thatchera6d24442015-07-10 04:26:361210 std::string err;
1211 // Send offer
Steve Anton18ee1d52017-09-11 18:32:351212 std::unique_ptr<typename T::Content> content1(
1213 CreateMediaContentWithStream(1));
1214 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511215 channel1_->SetLocalContent(content1.get(), SdpType::kOffer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361216 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1217
Peter Thatchera6d24442015-07-10 04:26:361218 // Receive PR answer
Steve Anton18ee1d52017-09-11 18:32:351219 std::unique_ptr<typename T::Content> content2(
1220 CreateMediaContentWithStream(2));
Steve Anton3828c062017-12-06 18:34:511221 EXPECT_TRUE(
1222 channel1_->SetRemoteContent(content2.get(), SdpType::kPrAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361223 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1224 EXPECT_TRUE(media_channel1_->HasRecvStream(2));
1225
Peter Thatchera6d24442015-07-10 04:26:361226 // Receive answer
Steve Anton18ee1d52017-09-11 18:32:351227 std::unique_ptr<typename T::Content> content3(
1228 CreateMediaContentWithStream(3));
1229 EXPECT_TRUE(
Steve Anton3828c062017-12-06 18:34:511230 channel1_->SetRemoteContent(content3.get(), SdpType::kAnswer, &err));
henrike@webrtc.org28e20752013-07-10 00:45:361231 EXPECT_TRUE(media_channel1_->HasSendStream(1));
1232 EXPECT_FALSE(media_channel1_->HasRecvStream(2));
1233 EXPECT_TRUE(media_channel1_->HasRecvStream(3));
1234 }
1235
zstein56162b92017-04-24 23:54:351236 void TestOnTransportReadyToSend() {
deadbeefac22f702017-01-13 05:59:291237 CreateChannels(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361238 EXPECT_FALSE(media_channel1_->ready_to_send());
Danil Chapovalov33b01f22016-05-11 17:55:271239
zstein56162b92017-04-24 23:54:351240 channel1_->OnTransportReadyToSend(true);
Danil Chapovalov33b01f22016-05-11 17:55:271241 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361242 EXPECT_TRUE(media_channel1_->ready_to_send());
1243
zstein56162b92017-04-24 23:54:351244 channel1_->OnTransportReadyToSend(false);
Danil Chapovalov33b01f22016-05-11 17:55:271245 WaitForThreads();
henrike@webrtc.org28e20752013-07-10 00:45:361246 EXPECT_FALSE(media_channel1_->ready_to_send());
henrike@webrtc.org28e20752013-07-10 00:45:361247 }
1248
skvladdc1c62c2016-03-17 02:07:431249 bool SetRemoteContentWithBitrateLimit(int remote_limit) {
1250 typename T::Content content;
1251 CreateContent(0, kPcmuCodec, kH264Codec, &content);
1252 content.set_bandwidth(remote_limit);
Steve Anton3828c062017-12-06 18:34:511253 return channel1_->SetRemoteContent(&content, SdpType::kOffer, NULL);
skvladdc1c62c2016-03-17 02:07:431254 }
1255
Danil Chapovalov66cadcc2018-06-19 14:47:431256 webrtc::RtpParameters BitrateLimitedParameters(absl::optional<int> limit) {
skvladdc1c62c2016-03-17 02:07:431257 webrtc::RtpParameters parameters;
1258 webrtc::RtpEncodingParameters encoding;
Mirko Bonadei05cf6be2019-01-31 20:38:121259 encoding.max_bitrate_bps = limit;
skvladdc1c62c2016-03-17 02:07:431260 parameters.encodings.push_back(encoding);
1261 return parameters;
1262 }
1263
1264 void VerifyMaxBitrate(const webrtc::RtpParameters& parameters,
Danil Chapovalov66cadcc2018-06-19 14:47:431265 absl::optional<int> expected_bitrate) {
skvladdc1c62c2016-03-17 02:07:431266 EXPECT_EQ(1UL, parameters.encodings.size());
1267 EXPECT_EQ(expected_bitrate, parameters.encodings[0].max_bitrate_bps);
1268 }
1269
1270 void DefaultMaxBitrateIsUnlimited() {
1271 CreateChannels(0, 0);
Steve Anton3828c062017-12-06 18:34:511272 EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_,
1273 SdpType::kOffer, NULL));
skvladdc1c62c2016-03-17 02:07:431274 EXPECT_EQ(media_channel1_->max_bps(), -1);
deadbeefe702b302017-02-04 20:09:011275 VerifyMaxBitrate(media_channel1_->GetRtpSendParameters(kSsrc1),
Danil Chapovalov66cadcc2018-06-19 14:47:431276 absl::nullopt);
skvladdc1c62c2016-03-17 02:07:431277 }
1278
Zhi Huange830e682018-03-30 17:48:351279 // Test that when a channel gets new RtpTransport with a call to
1280 // |SetRtpTransport|, the socket options from the old RtpTransport is merged
1281 // with the options on the new one.
1282
Steve Anton8a63f782017-10-23 20:08:531283 // For example, audio and video may use separate socket options, but initially
1284 // be unbundled, then later become bundled. When this happens, their preferred
1285 // socket options should be merged to the underlying transport they share.
1286 void SocketOptionsMergedOnSetTransport() {
1287 constexpr int kSndBufSize = 4000;
1288 constexpr int kRcvBufSize = 8000;
1289
Zhi Huange830e682018-03-30 17:48:351290 CreateChannels(DTLS, DTLS);
Steve Anton8a63f782017-10-23 20:08:531291
1292 channel1_->SetOption(cricket::BaseChannel::ST_RTP,
1293 rtc::Socket::Option::OPT_SNDBUF, kSndBufSize);
1294 channel2_->SetOption(cricket::BaseChannel::ST_RTP,
1295 rtc::Socket::Option::OPT_RCVBUF, kRcvBufSize);
1296
Zhi Huange830e682018-03-30 17:48:351297 new_rtp_transport_ = CreateDtlsSrtpTransport(
Bjorn A Mellem3a1b9272019-05-24 23:13:081298 fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get());
Zhi Huange830e682018-03-30 17:48:351299 channel1_->SetRtpTransport(new_rtp_transport_.get());
Steve Anton8a63f782017-10-23 20:08:531300
1301 int option_val;
Bjorn A Mellem3a1b9272019-05-24 23:13:081302 ASSERT_TRUE(fake_rtp_dtls_transport2_->GetOption(
1303 rtc::Socket::Option::OPT_SNDBUF, &option_val));
Steve Anton8a63f782017-10-23 20:08:531304 EXPECT_EQ(kSndBufSize, option_val);
Bjorn A Mellem3a1b9272019-05-24 23:13:081305 ASSERT_TRUE(fake_rtp_dtls_transport2_->GetOption(
1306 rtc::Socket::Option::OPT_RCVBUF, &option_val));
Steve Anton8a63f782017-10-23 20:08:531307 EXPECT_EQ(kRcvBufSize, option_val);
1308 }
1309
Amit Hilbuchbcd39d42019-01-26 01:13:561310 void CreateSimulcastContent(const std::vector<std::string>& rids,
1311 typename T::Content* content) {
1312 std::vector<RidDescription> rid_descriptions;
Courtney Edwards134c6992020-03-03 10:36:351313 for (const std::string& name : rids) {
Amit Hilbuchbcd39d42019-01-26 01:13:561314 rid_descriptions.push_back(RidDescription(name, RidDirection::kSend));
1315 }
1316
1317 StreamParams stream;
1318 stream.set_rids(rid_descriptions);
1319 CreateContent(0, kPcmuCodec, kH264Codec, content);
1320 // This is for unified plan, so there can be only one StreamParams.
1321 content->mutable_streams().clear();
1322 content->AddStream(stream);
1323 }
1324
1325 void VerifySimulcastStreamParams(const StreamParams& expected,
1326 const typename T::Channel* channel) {
1327 const std::vector<StreamParams>& streams = channel->local_streams();
1328 ASSERT_EQ(1u, streams.size());
1329 const StreamParams& result = streams[0];
1330 EXPECT_EQ(expected.rids(), result.rids());
1331 EXPECT_TRUE(result.has_ssrcs());
1332 EXPECT_EQ(expected.rids().size() * 2, result.ssrcs.size());
1333 std::vector<uint32_t> primary_ssrcs;
1334 result.GetPrimarySsrcs(&primary_ssrcs);
1335 EXPECT_EQ(expected.rids().size(), primary_ssrcs.size());
1336 }
1337
1338 void TestUpdateLocalStreamsWithSimulcast() {
1339 CreateChannels(0, 0);
1340 typename T::Content content1, content2, content3;
1341 CreateSimulcastContent({"f", "h", "q"}, &content1);
1342 EXPECT_TRUE(
1343 channel1_->SetLocalContent(&content1, SdpType::kOffer, nullptr));
1344 VerifySimulcastStreamParams(content1.streams()[0], channel1_.get());
1345 StreamParams stream1 = channel1_->local_streams()[0];
1346
1347 // Create a similar offer. SetLocalContent should not remove and add.
1348 CreateSimulcastContent({"f", "h", "q"}, &content2);
1349 EXPECT_TRUE(
1350 channel1_->SetLocalContent(&content2, SdpType::kOffer, nullptr));
1351 VerifySimulcastStreamParams(content2.streams()[0], channel1_.get());
1352 StreamParams stream2 = channel1_->local_streams()[0];
1353 // Check that the streams are identical (SSRCs didn't change).
1354 EXPECT_EQ(stream1, stream2);
1355
1356 // Create third offer that has same RIDs in different order.
1357 CreateSimulcastContent({"f", "q", "h"}, &content3);
1358 EXPECT_TRUE(
1359 channel1_->SetLocalContent(&content3, SdpType::kOffer, nullptr));
1360 VerifySimulcastStreamParams(content3.streams()[0], channel1_.get());
1361 }
1362
henrike@webrtc.org28e20752013-07-10 00:45:361363 protected:
Danil Chapovalov33b01f22016-05-11 17:55:271364 void WaitForThreads() { WaitForThreads(rtc::ArrayView<rtc::Thread*>()); }
1365 static void ProcessThreadQueue(rtc::Thread* thread) {
1366 RTC_DCHECK(thread->IsCurrent());
1367 while (!thread->empty()) {
1368 thread->ProcessMessages(0);
1369 }
1370 }
1371 void WaitForThreads(rtc::ArrayView<rtc::Thread*> threads) {
1372 // |threads| and current thread post packets to network thread.
1373 for (rtc::Thread* thread : threads) {
Taylor Brandstetter5d97a9a2016-06-10 21:17:271374 thread->Invoke<void>(RTC_FROM_HERE,
1375 [thread] { ProcessThreadQueue(thread); });
Danil Chapovalov33b01f22016-05-11 17:55:271376 }
1377 ProcessThreadQueue(rtc::Thread::Current());
1378 // Network thread move them around and post back to worker = current thread.
1379 if (!network_thread_->IsCurrent()) {
1380 network_thread_->Invoke<void>(
Taylor Brandstetter5d97a9a2016-06-10 21:17:271381 RTC_FROM_HERE, [this] { ProcessThreadQueue(network_thread_); });
Danil Chapovalov33b01f22016-05-11 17:55:271382 }
1383 // Worker thread = current Thread process received messages.
1384 ProcessThreadQueue(rtc::Thread::Current());
1385 }
Peter Boström34fbfff2015-09-24 17:20:301386 // TODO(pbos): Remove playout from all media channels and let renderers mute
1387 // themselves.
1388 const bool verify_playout_;
Danil Chapovalov33b01f22016-05-11 17:55:271389 std::unique_ptr<rtc::Thread> network_thread_keeper_;
1390 rtc::Thread* network_thread_;
deadbeeff5346592017-01-25 05:51:211391 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport1_;
1392 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport1_;
1393 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport2_;
1394 std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport2_;
1395 std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport1_;
1396 std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport1_;
1397 std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport2_;
1398 std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport2_;
Zhi Huange830e682018-03-30 17:48:351399 std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport1_;
1400 std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport2_;
1401 std::unique_ptr<webrtc::RtpTransportInternal> new_rtp_transport_;
henrike@webrtc.org28e20752013-07-10 00:45:361402 cricket::FakeMediaEngine media_engine_;
1403 // The media channels are owned by the voice channel objects below.
deadbeeff5346592017-01-25 05:51:211404 typename T::MediaChannel* media_channel1_ = nullptr;
1405 typename T::MediaChannel* media_channel2_ = nullptr;
kwiberg31022942016-03-11 22:18:211406 std::unique_ptr<typename T::Channel> channel1_;
1407 std::unique_ptr<typename T::Channel> channel2_;
henrike@webrtc.org28e20752013-07-10 00:45:361408 typename T::Content local_media_content1_;
1409 typename T::Content local_media_content2_;
1410 typename T::Content remote_media_content1_;
1411 typename T::Content remote_media_content2_;
henrike@webrtc.org28e20752013-07-10 00:45:361412 // The RTP and RTCP packets to send in the tests.
Danil Chapovalov33b01f22016-05-11 17:55:271413 rtc::Buffer rtp_packet_;
1414 rtc::Buffer rtcp_packet_;
deadbeeff5346592017-01-25 05:51:211415 int rtcp_mux_activated_callbacks1_ = 0;
1416 int rtcp_mux_activated_callbacks2_ = 0;
Honghai Zhangcc411c02016-03-30 00:27:211417 cricket::CandidatePairInterface* last_selected_candidate_pair_;
Amit Hilbuchbcd39d42019-01-26 01:13:561418 rtc::UniqueRandomIdGenerator ssrc_generator_;
henrike@webrtc.org28e20752013-07-10 00:45:361419};
1420
Yves Gerey665174f2018-06-19 13:03:051421template <>
Sebastian Jansson1b83a9e2019-09-18 16:22:121422std::unique_ptr<cricket::VoiceChannel> ChannelTest<VoiceTraits>::CreateChannel(
1423 rtc::Thread* worker_thread,
1424 rtc::Thread* network_thread,
1425 std::unique_ptr<cricket::FakeVoiceMediaChannel> ch,
1426 webrtc::RtpTransportInternal* rtp_transport,
1427 int flags) {
Sebastian Jansson1b83a9e2019-09-18 16:22:121428 rtc::Thread* signaling_thread = rtc::Thread::Current();
1429 auto channel = std::make_unique<cricket::VoiceChannel>(
1430 worker_thread, network_thread, signaling_thread, std::move(ch),
1431 cricket::CN_AUDIO, (flags & DTLS) != 0, webrtc::CryptoOptions(),
1432 &ssrc_generator_);
Niels Möller2a707032020-06-16 14:39:131433 channel->Init_w(rtp_transport);
Sebastian Jansson1b83a9e2019-09-18 16:22:121434 return channel;
1435}
1436
1437template <>
henrike@webrtc.org28e20752013-07-10 00:45:361438void ChannelTest<VoiceTraits>::CreateContent(
1439 int flags,
1440 const cricket::AudioCodec& audio_codec,
1441 const cricket::VideoCodec& video_codec,
1442 cricket::AudioContentDescription* audio) {
1443 audio->AddCodec(audio_codec);
1444 audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
henrike@webrtc.org28e20752013-07-10 00:45:361445}
1446
Yves Gerey665174f2018-06-19 13:03:051447template <>
henrike@webrtc.org28e20752013-07-10 00:45:361448void ChannelTest<VoiceTraits>::CopyContent(
1449 const cricket::AudioContentDescription& source,
1450 cricket::AudioContentDescription* audio) {
1451 *audio = source;
1452}
1453
Yves Gerey665174f2018-06-19 13:03:051454template <>
henrike@webrtc.org28e20752013-07-10 00:45:361455bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1,
1456 const cricket::AudioCodec& c2) {
1457 return c1.name == c2.name && c1.clockrate == c2.clockrate &&
Yves Gerey665174f2018-06-19 13:03:051458 c1.bitrate == c2.bitrate && c1.channels == c2.channels;
henrike@webrtc.org28e20752013-07-10 00:45:361459}
1460
Peter Boström0c4e06b2015-10-07 10:23:211461template <>
henrike@webrtc.org28e20752013-07-10 00:45:361462void ChannelTest<VoiceTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:211463 uint32_t ssrc,
1464 int flags,
1465 cricket::AudioContentDescription* audio) {
henrike@webrtc.org28e20752013-07-10 00:45:361466 audio->AddLegacyStream(ssrc);
1467}
1468
Danil Chapovalov33b01f22016-05-11 17:55:271469class VoiceChannelSingleThreadTest : public ChannelTest<VoiceTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:361470 public:
solenberg1dd98f32015-09-10 08:57:141471 typedef ChannelTest<VoiceTraits> Base;
Danil Chapovalov33b01f22016-05-11 17:55:271472 VoiceChannelSingleThreadTest()
1473 : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::Yes) {}
1474};
1475
1476class VoiceChannelDoubleThreadTest : public ChannelTest<VoiceTraits> {
1477 public:
1478 typedef ChannelTest<VoiceTraits> Base;
1479 VoiceChannelDoubleThreadTest()
1480 : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::No) {}
henrike@webrtc.org28e20752013-07-10 00:45:361481};
1482
jbauch5869f502017-06-29 19:31:361483class VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest
Yves Gerey665174f2018-06-19 13:03:051484 : public ChannelTest<VoiceTraits> {
jbauch5869f502017-06-29 19:31:361485 public:
1486 typedef ChannelTest<VoiceTraits> Base;
1487 VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest()
Yves Gerey665174f2018-06-19 13:03:051488 : Base(true,
1489 kPcmuFrameWithExtensions,
1490 kRtcpReport,
1491 NetworkIsWorker::Yes) {}
jbauch5869f502017-06-29 19:31:361492};
1493
1494class VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest
Yves Gerey665174f2018-06-19 13:03:051495 : public ChannelTest<VoiceTraits> {
jbauch5869f502017-06-29 19:31:361496 public:
1497 typedef ChannelTest<VoiceTraits> Base;
1498 VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest()
Yves Gerey665174f2018-06-19 13:03:051499 : Base(true, kPcmuFrameWithExtensions, kRtcpReport, NetworkIsWorker::No) {
1500 }
jbauch5869f502017-06-29 19:31:361501};
1502
henrike@webrtc.org28e20752013-07-10 00:45:361503// override to add NULL parameter
deadbeefcbecd352015-09-23 18:50:271504template <>
Steve Anton8699a322017-11-06 23:53:331505std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:271506 rtc::Thread* worker_thread,
1507 rtc::Thread* network_thread,
Steve Anton8699a322017-11-06 23:53:331508 std::unique_ptr<cricket::FakeVideoMediaChannel> ch,
Zhi Huange830e682018-03-30 17:48:351509 webrtc::RtpTransportInternal* rtp_transport,
jbauchcb560652016-08-04 12:20:321510 int flags) {
deadbeeff5346592017-01-25 05:51:211511 rtc::Thread* signaling_thread = rtc::Thread::Current();
Mirko Bonadei317a1f02019-09-17 15:06:181512 auto channel = std::make_unique<cricket::VideoChannel>(
Steve Anton8699a322017-11-06 23:53:331513 worker_thread, network_thread, signaling_thread, std::move(ch),
Amit Hilbuchbcd39d42019-01-26 01:13:561514 cricket::CN_VIDEO, (flags & DTLS) != 0, webrtc::CryptoOptions(),
1515 &ssrc_generator_);
Niels Möller2a707032020-06-16 14:39:131516 channel->Init_w(rtp_transport);
henrike@webrtc.org28e20752013-07-10 00:45:361517 return channel;
1518}
1519
Yves Gerey665174f2018-06-19 13:03:051520template <>
henrike@webrtc.org28e20752013-07-10 00:45:361521void ChannelTest<VideoTraits>::CreateContent(
1522 int flags,
1523 const cricket::AudioCodec& audio_codec,
1524 const cricket::VideoCodec& video_codec,
1525 cricket::VideoContentDescription* video) {
1526 video->AddCodec(video_codec);
1527 video->set_rtcp_mux((flags & RTCP_MUX) != 0);
henrike@webrtc.org28e20752013-07-10 00:45:361528}
1529
Yves Gerey665174f2018-06-19 13:03:051530template <>
henrike@webrtc.org28e20752013-07-10 00:45:361531void ChannelTest<VideoTraits>::CopyContent(
1532 const cricket::VideoContentDescription& source,
1533 cricket::VideoContentDescription* video) {
1534 *video = source;
1535}
1536
Yves Gerey665174f2018-06-19 13:03:051537template <>
henrike@webrtc.org28e20752013-07-10 00:45:361538bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1,
1539 const cricket::VideoCodec& c2) {
perkj26752742016-10-24 08:21:161540 return c1.name == c2.name;
henrike@webrtc.org28e20752013-07-10 00:45:361541}
1542
Peter Boström0c4e06b2015-10-07 10:23:211543template <>
henrike@webrtc.org28e20752013-07-10 00:45:361544void ChannelTest<VideoTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:211545 uint32_t ssrc,
1546 int flags,
1547 cricket::VideoContentDescription* video) {
henrike@webrtc.org28e20752013-07-10 00:45:361548 video->AddLegacyStream(ssrc);
1549}
1550
Danil Chapovalov33b01f22016-05-11 17:55:271551class VideoChannelSingleThreadTest : public ChannelTest<VideoTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:361552 public:
solenberg1dd98f32015-09-10 08:57:141553 typedef ChannelTest<VideoTraits> Base;
Danil Chapovalov33b01f22016-05-11 17:55:271554 VideoChannelSingleThreadTest()
1555 : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::Yes) {}
henrike@webrtc.org28e20752013-07-10 00:45:361556};
1557
Danil Chapovalov33b01f22016-05-11 17:55:271558class VideoChannelDoubleThreadTest : public ChannelTest<VideoTraits> {
1559 public:
1560 typedef ChannelTest<VideoTraits> Base;
1561 VideoChannelDoubleThreadTest()
1562 : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::No) {}
1563};
henrike@webrtc.org28e20752013-07-10 00:45:361564
Kári Tristan Helgason8b35df72017-09-25 12:46:431565TEST_F(VoiceChannelSingleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:361566 Base::TestInit();
1567 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
1568 EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
1569}
1570
Danil Chapovalovdae07ba2016-05-13 23:43:501571TEST_F(VoiceChannelSingleThreadTest, TestDeinit) {
1572 Base::TestDeinit();
1573}
1574
Danil Chapovalov33b01f22016-05-11 17:55:271575TEST_F(VoiceChannelSingleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:361576 Base::TestSetContents();
1577}
1578
Johannes Kron9190b822018-10-29 10:22:051579TEST_F(VoiceChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) {
1580 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true);
1581}
1582
1583TEST_F(VoiceChannelSingleThreadTest,
1584 TestSetContentsExtmapAllowMixedNotSupportedAsCaller) {
1585 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false);
1586}
1587
1588TEST_F(VoiceChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) {
1589 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true);
1590}
1591
1592TEST_F(VoiceChannelSingleThreadTest,
1593 TestSetContentsExtmapAllowMixedNotSupportedAsCallee) {
1594 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false);
1595}
1596
Danil Chapovalov33b01f22016-05-11 17:55:271597TEST_F(VoiceChannelSingleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:361598 Base::TestSetContentsNullOffer();
1599}
1600
Danil Chapovalov33b01f22016-05-11 17:55:271601TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:361602 Base::TestSetContentsRtcpMux();
1603}
1604
Danil Chapovalov33b01f22016-05-11 17:55:271605TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361606 Base::TestSetContentsRtcpMux();
1607}
1608
Danil Chapovalov33b01f22016-05-11 17:55:271609TEST_F(VoiceChannelSingleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:361610 Base::TestChangeStreamParamsInContent();
1611}
1612
Danil Chapovalov33b01f22016-05-11 17:55:271613TEST_F(VoiceChannelSingleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:361614 Base::TestPlayoutAndSendingStates();
1615}
1616
Danil Chapovalov33b01f22016-05-11 17:55:271617TEST_F(VoiceChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:361618 Base::TestMediaContentDirection();
1619}
1620
Danil Chapovalov33b01f22016-05-11 17:55:271621TEST_F(VoiceChannelSingleThreadTest, TestNetworkRouteChanges) {
Honghai Zhangcc411c02016-03-30 00:27:211622 Base::TestNetworkRouteChanges();
1623}
1624
Danil Chapovalov33b01f22016-05-11 17:55:271625TEST_F(VoiceChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:361626 Base::TestCallSetup();
1627}
1628
Danil Chapovalov33b01f22016-05-11 17:55:271629TEST_F(VoiceChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:361630 Base::TestCallTeardownRtcpMux();
1631}
1632
Danil Chapovalov33b01f22016-05-11 17:55:271633TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:361634 Base::SendRtpToRtp();
1635}
1636
Danil Chapovalov33b01f22016-05-11 17:55:271637TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Zhi Huange830e682018-03-30 17:48:351638 Base::SendDtlsSrtpToDtlsSrtp(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361639}
1640
Danil Chapovalov33b01f22016-05-11 17:55:271641TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Zhi Huange830e682018-03-30 17:48:351642 Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX);
deadbeeff5346592017-01-25 05:51:211643}
1644
Danil Chapovalov33b01f22016-05-11 17:55:271645TEST_F(VoiceChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:361646 Base::SendEarlyMediaUsingRtcpMuxSrtp();
1647}
1648
Danil Chapovalov33b01f22016-05-11 17:55:271649TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:361650 Base::SendRtpToRtpOnThread();
1651}
1652
Danil Chapovalov33b01f22016-05-11 17:55:271653TEST_F(VoiceChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:361654 Base::SendWithWritabilityLoss();
1655}
1656
Danil Chapovalov33b01f22016-05-11 17:55:271657TEST_F(VoiceChannelSingleThreadTest, TestSetContentFailure) {
henrike@webrtc.org28e20752013-07-10 00:45:361658 Base::TestSetContentFailure();
1659}
1660
Danil Chapovalov33b01f22016-05-11 17:55:271661TEST_F(VoiceChannelSingleThreadTest, TestSendTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:361662 Base::TestSendTwoOffers();
1663}
1664
Danil Chapovalov33b01f22016-05-11 17:55:271665TEST_F(VoiceChannelSingleThreadTest, TestReceiveTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:361666 Base::TestReceiveTwoOffers();
1667}
1668
Danil Chapovalov33b01f22016-05-11 17:55:271669TEST_F(VoiceChannelSingleThreadTest, TestSendPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361670 Base::TestSendPrAnswer();
1671}
1672
Danil Chapovalov33b01f22016-05-11 17:55:271673TEST_F(VoiceChannelSingleThreadTest, TestReceivePrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361674 Base::TestReceivePrAnswer();
1675}
1676
zstein56162b92017-04-24 23:54:351677TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSend) {
1678 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:361679}
1680
Danil Chapovalov33b01f22016-05-11 17:55:271681TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundle) {
tfarina5237aaf2015-11-11 07:44:301682 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false);
henrike@webrtc.org28e20752013-07-10 00:45:361683}
1684
Danil Chapovalov33b01f22016-05-11 17:55:271685TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleSecure) {
tfarina5237aaf2015-11-11 07:44:301686 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true);
buildbot@webrtc.org5ee0f052014-05-05 20:18:081687}
1688
Danil Chapovalov33b01f22016-05-11 17:55:271689TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) {
tfarina5237aaf2015-11-11 07:44:301690 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false);
buildbot@webrtc.org5ee0f052014-05-05 20:18:081691}
1692
Danil Chapovalov33b01f22016-05-11 17:55:271693TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
tfarina5237aaf2015-11-11 07:44:301694 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true);
henrike@webrtc.org28e20752013-07-10 00:45:361695}
1696
Danil Chapovalov33b01f22016-05-11 17:55:271697TEST_F(VoiceChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) {
skvlade0d46372016-04-08 05:59:221698 Base::DefaultMaxBitrateIsUnlimited();
skvladdc1c62c2016-03-17 02:07:431699}
1700
Steve Anton8a63f782017-10-23 20:08:531701TEST_F(VoiceChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
1702 Base::SocketOptionsMergedOnSetTransport();
1703}
1704
Danil Chapovalov33b01f22016-05-11 17:55:271705// VoiceChannelDoubleThreadTest
1706TEST_F(VoiceChannelDoubleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:361707 Base::TestInit();
Danil Chapovalov33b01f22016-05-11 17:55:271708 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
1709 EXPECT_TRUE(media_channel1_->dtmf_info_queue().empty());
henrike@webrtc.org28e20752013-07-10 00:45:361710}
1711
Danil Chapovalovdae07ba2016-05-13 23:43:501712TEST_F(VoiceChannelDoubleThreadTest, TestDeinit) {
1713 Base::TestDeinit();
1714}
1715
Danil Chapovalov33b01f22016-05-11 17:55:271716TEST_F(VoiceChannelDoubleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:361717 Base::TestSetContents();
1718}
1719
Johannes Kron9190b822018-10-29 10:22:051720TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) {
1721 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true);
1722}
1723
1724TEST_F(VoiceChannelDoubleThreadTest,
1725 TestSetContentsExtmapAllowMixedNotSupportedAsCaller) {
1726 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false);
1727}
1728
1729TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) {
1730 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true);
1731}
1732
1733TEST_F(VoiceChannelDoubleThreadTest,
1734 TestSetContentsExtmapAllowMixedNotSupportedAsCallee) {
1735 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false);
1736}
1737
Danil Chapovalov33b01f22016-05-11 17:55:271738TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:361739 Base::TestSetContentsNullOffer();
1740}
1741
Danil Chapovalov33b01f22016-05-11 17:55:271742TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:361743 Base::TestSetContentsRtcpMux();
1744}
1745
Danil Chapovalov33b01f22016-05-11 17:55:271746TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361747 Base::TestSetContentsRtcpMux();
1748}
1749
Danil Chapovalov33b01f22016-05-11 17:55:271750TEST_F(VoiceChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:361751 Base::TestChangeStreamParamsInContent();
1752}
1753
Danil Chapovalov33b01f22016-05-11 17:55:271754TEST_F(VoiceChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:361755 Base::TestPlayoutAndSendingStates();
1756}
1757
Danil Chapovalov33b01f22016-05-11 17:55:271758TEST_F(VoiceChannelDoubleThreadTest, TestMediaContentDirection) {
1759 Base::TestMediaContentDirection();
1760}
1761
1762TEST_F(VoiceChannelDoubleThreadTest, TestNetworkRouteChanges) {
1763 Base::TestNetworkRouteChanges();
1764}
1765
1766TEST_F(VoiceChannelDoubleThreadTest, TestCallSetup) {
1767 Base::TestCallSetup();
1768}
1769
1770TEST_F(VoiceChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
1771 Base::TestCallTeardownRtcpMux();
1772}
1773
1774TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtp) {
1775 Base::SendRtpToRtp();
1776}
1777
Danil Chapovalov33b01f22016-05-11 17:55:271778TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Zhi Huange830e682018-03-30 17:48:351779 Base::SendDtlsSrtpToDtlsSrtp(0, 0);
Danil Chapovalov33b01f22016-05-11 17:55:271780}
1781
1782TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Zhi Huange830e682018-03-30 17:48:351783 Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX);
deadbeeff5346592017-01-25 05:51:211784}
1785
Danil Chapovalov33b01f22016-05-11 17:55:271786TEST_F(VoiceChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
1787 Base::SendEarlyMediaUsingRtcpMuxSrtp();
1788}
1789
1790TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtpOnThread) {
1791 Base::SendRtpToRtpOnThread();
1792}
1793
Danil Chapovalov33b01f22016-05-11 17:55:271794TEST_F(VoiceChannelDoubleThreadTest, SendWithWritabilityLoss) {
1795 Base::SendWithWritabilityLoss();
1796}
1797
Danil Chapovalov33b01f22016-05-11 17:55:271798TEST_F(VoiceChannelDoubleThreadTest, TestSetContentFailure) {
1799 Base::TestSetContentFailure();
1800}
1801
1802TEST_F(VoiceChannelDoubleThreadTest, TestSendTwoOffers) {
1803 Base::TestSendTwoOffers();
1804}
1805
1806TEST_F(VoiceChannelDoubleThreadTest, TestReceiveTwoOffers) {
1807 Base::TestReceiveTwoOffers();
1808}
1809
1810TEST_F(VoiceChannelDoubleThreadTest, TestSendPrAnswer) {
1811 Base::TestSendPrAnswer();
1812}
1813
1814TEST_F(VoiceChannelDoubleThreadTest, TestReceivePrAnswer) {
1815 Base::TestReceivePrAnswer();
1816}
1817
zstein56162b92017-04-24 23:54:351818TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSend) {
1819 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:271820}
1821
Danil Chapovalov33b01f22016-05-11 17:55:271822TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundle) {
1823 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false);
1824}
1825
1826TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleSecure) {
1827 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true);
1828}
1829
1830TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) {
1831 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false);
1832}
1833
1834TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
1835 Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true);
1836}
1837
1838TEST_F(VoiceChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) {
1839 Base::DefaultMaxBitrateIsUnlimited();
1840}
1841
Steve Anton8a63f782017-10-23 20:08:531842TEST_F(VoiceChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
1843 Base::SocketOptionsMergedOnSetTransport();
1844}
1845
Danil Chapovalov33b01f22016-05-11 17:55:271846// VideoChannelSingleThreadTest
1847TEST_F(VideoChannelSingleThreadTest, TestInit) {
1848 Base::TestInit();
1849}
1850
Danil Chapovalovdae07ba2016-05-13 23:43:501851TEST_F(VideoChannelSingleThreadTest, TestDeinit) {
1852 Base::TestDeinit();
1853}
1854
Danil Chapovalov33b01f22016-05-11 17:55:271855TEST_F(VideoChannelSingleThreadTest, TestSetContents) {
1856 Base::TestSetContents();
1857}
1858
Johannes Kron9190b822018-10-29 10:22:051859TEST_F(VideoChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) {
1860 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true);
1861}
1862
1863TEST_F(VideoChannelSingleThreadTest,
1864 TestSetContentsExtmapAllowMixedNotSupportedAsCaller) {
1865 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false);
1866}
1867
1868TEST_F(VideoChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) {
1869 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true);
1870}
1871
1872TEST_F(VideoChannelSingleThreadTest,
1873 TestSetContentsExtmapAllowMixedNotSupportedAsCallee) {
1874 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false);
1875}
1876
Danil Chapovalov33b01f22016-05-11 17:55:271877TEST_F(VideoChannelSingleThreadTest, TestSetContentsNullOffer) {
1878 Base::TestSetContentsNullOffer();
1879}
1880
1881TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMux) {
1882 Base::TestSetContentsRtcpMux();
1883}
1884
1885TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
1886 Base::TestSetContentsRtcpMux();
1887}
1888
Danil Chapovalov33b01f22016-05-11 17:55:271889TEST_F(VideoChannelSingleThreadTest, TestChangeStreamParamsInContent) {
1890 Base::TestChangeStreamParamsInContent();
1891}
1892
1893TEST_F(VideoChannelSingleThreadTest, TestPlayoutAndSendingStates) {
1894 Base::TestPlayoutAndSendingStates();
1895}
1896
Danil Chapovalov33b01f22016-05-11 17:55:271897TEST_F(VideoChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:361898 Base::TestMediaContentDirection();
1899}
1900
Danil Chapovalov33b01f22016-05-11 17:55:271901TEST_F(VideoChannelSingleThreadTest, TestNetworkRouteChanges) {
Honghai Zhangcc411c02016-03-30 00:27:211902 Base::TestNetworkRouteChanges();
1903}
1904
Danil Chapovalov33b01f22016-05-11 17:55:271905TEST_F(VideoChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:361906 Base::TestCallSetup();
1907}
1908
Danil Chapovalov33b01f22016-05-11 17:55:271909TEST_F(VideoChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:361910 Base::TestCallTeardownRtcpMux();
1911}
1912
Danil Chapovalov33b01f22016-05-11 17:55:271913TEST_F(VideoChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:361914 Base::SendRtpToRtp();
1915}
1916
Danil Chapovalov33b01f22016-05-11 17:55:271917TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Zhi Huange830e682018-03-30 17:48:351918 Base::SendDtlsSrtpToDtlsSrtp(0, 0);
henrike@webrtc.org28e20752013-07-10 00:45:361919}
1920
Danil Chapovalov33b01f22016-05-11 17:55:271921TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Zhi Huange830e682018-03-30 17:48:351922 Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX);
henrike@webrtc.org28e20752013-07-10 00:45:361923}
1924
Danil Chapovalov33b01f22016-05-11 17:55:271925TEST_F(VideoChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
henrike@webrtc.org28e20752013-07-10 00:45:361926 Base::SendEarlyMediaUsingRtcpMuxSrtp();
1927}
1928
Danil Chapovalov33b01f22016-05-11 17:55:271929TEST_F(VideoChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:361930 Base::SendRtpToRtpOnThread();
1931}
1932
Danil Chapovalov33b01f22016-05-11 17:55:271933TEST_F(VideoChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:361934 Base::SendWithWritabilityLoss();
1935}
1936
Danil Chapovalov33b01f22016-05-11 17:55:271937TEST_F(VideoChannelSingleThreadTest, TestSetContentFailure) {
henrike@webrtc.org28e20752013-07-10 00:45:361938 Base::TestSetContentFailure();
1939}
1940
Danil Chapovalov33b01f22016-05-11 17:55:271941TEST_F(VideoChannelSingleThreadTest, TestSendTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:361942 Base::TestSendTwoOffers();
1943}
1944
Danil Chapovalov33b01f22016-05-11 17:55:271945TEST_F(VideoChannelSingleThreadTest, TestReceiveTwoOffers) {
henrike@webrtc.org28e20752013-07-10 00:45:361946 Base::TestReceiveTwoOffers();
1947}
1948
Danil Chapovalov33b01f22016-05-11 17:55:271949TEST_F(VideoChannelSingleThreadTest, TestSendPrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361950 Base::TestSendPrAnswer();
1951}
1952
Danil Chapovalov33b01f22016-05-11 17:55:271953TEST_F(VideoChannelSingleThreadTest, TestReceivePrAnswer) {
henrike@webrtc.org28e20752013-07-10 00:45:361954 Base::TestReceivePrAnswer();
1955}
1956
Danil Chapovalov33b01f22016-05-11 17:55:271957TEST_F(VideoChannelSingleThreadTest, SendBundleToBundle) {
tfarina5237aaf2015-11-11 07:44:301958 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false);
henrike@webrtc.org28e20752013-07-10 00:45:361959}
1960
Danil Chapovalov33b01f22016-05-11 17:55:271961TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleSecure) {
tfarina5237aaf2015-11-11 07:44:301962 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true);
buildbot@webrtc.org5ee0f052014-05-05 20:18:081963}
1964
Danil Chapovalov33b01f22016-05-11 17:55:271965TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) {
tfarina5237aaf2015-11-11 07:44:301966 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
buildbot@webrtc.org5ee0f052014-05-05 20:18:081967}
1968
Danil Chapovalov33b01f22016-05-11 17:55:271969TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
tfarina5237aaf2015-11-11 07:44:301970 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
henrike@webrtc.org28e20752013-07-10 00:45:361971}
1972
zstein56162b92017-04-24 23:54:351973TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSend) {
1974 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:361975}
1976
Danil Chapovalov33b01f22016-05-11 17:55:271977TEST_F(VideoChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) {
skvladdc1c62c2016-03-17 02:07:431978 Base::DefaultMaxBitrateIsUnlimited();
1979}
1980
Steve Anton8a63f782017-10-23 20:08:531981TEST_F(VideoChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
1982 Base::SocketOptionsMergedOnSetTransport();
1983}
1984
Amit Hilbuchbcd39d42019-01-26 01:13:561985TEST_F(VideoChannelSingleThreadTest, UpdateLocalStreamsWithSimulcast) {
1986 Base::TestUpdateLocalStreamsWithSimulcast();
1987}
1988
Mirta Dvornicic479a3c02019-06-04 13:38:501989TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) {
1990 const cricket::VideoCodec kVp8Codec(97, "VP8");
1991 cricket::VideoCodec vp9_codec(98, "VP9");
1992 vp9_codec.packetization = cricket::kPacketizationParamRaw;
1993 cricket::VideoContentDescription video;
1994 video.set_codecs({kVp8Codec, vp9_codec});
1995
1996 CreateChannels(0, 0);
1997
1998 EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, NULL));
1999 EXPECT_THAT(media_channel1_->send_codecs(), testing::IsEmpty());
2000 ASSERT_THAT(media_channel1_->recv_codecs(), testing::SizeIs(2));
2001 EXPECT_TRUE(media_channel1_->recv_codecs()[0].Matches(kVp8Codec));
2002 EXPECT_EQ(media_channel1_->recv_codecs()[0].packetization, absl::nullopt);
2003 EXPECT_TRUE(media_channel1_->recv_codecs()[1].Matches(vp9_codec));
2004 EXPECT_EQ(media_channel1_->recv_codecs()[1].packetization,
2005 cricket::kPacketizationParamRaw);
2006}
2007
2008TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) {
2009 const cricket::VideoCodec kVp8Codec(97, "VP8");
2010 cricket::VideoCodec vp9_codec(98, "VP9");
2011 vp9_codec.packetization = cricket::kPacketizationParamRaw;
2012 cricket::VideoContentDescription video;
2013 video.set_codecs({kVp8Codec, vp9_codec});
2014
2015 CreateChannels(0, 0);
2016
2017 EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kOffer, NULL));
2018 EXPECT_THAT(media_channel1_->recv_codecs(), testing::IsEmpty());
2019 ASSERT_THAT(media_channel1_->send_codecs(), testing::SizeIs(2));
2020 EXPECT_TRUE(media_channel1_->send_codecs()[0].Matches(kVp8Codec));
2021 EXPECT_EQ(media_channel1_->send_codecs()[0].packetization, absl::nullopt);
2022 EXPECT_TRUE(media_channel1_->send_codecs()[1].Matches(vp9_codec));
2023 EXPECT_EQ(media_channel1_->send_codecs()[1].packetization,
2024 cricket::kPacketizationParamRaw);
2025}
2026
2027TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) {
2028 const cricket::VideoCodec kVp8Codec(97, "VP8");
2029 cricket::VideoCodec vp9_codec(98, "VP9");
2030 vp9_codec.packetization = cricket::kPacketizationParamRaw;
2031 cricket::VideoContentDescription video;
2032 video.set_codecs({kVp8Codec, vp9_codec});
2033
2034 CreateChannels(0, 0);
2035
2036 EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, NULL));
2037 EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kAnswer, NULL));
2038 ASSERT_THAT(media_channel1_->recv_codecs(), testing::SizeIs(2));
2039 EXPECT_TRUE(media_channel1_->recv_codecs()[0].Matches(kVp8Codec));
2040 EXPECT_EQ(media_channel1_->recv_codecs()[0].packetization, absl::nullopt);
2041 EXPECT_TRUE(media_channel1_->recv_codecs()[1].Matches(vp9_codec));
2042 EXPECT_EQ(media_channel1_->recv_codecs()[1].packetization,
2043 cricket::kPacketizationParamRaw);
2044 EXPECT_THAT(media_channel1_->send_codecs(), testing::SizeIs(2));
2045 EXPECT_TRUE(media_channel1_->send_codecs()[0].Matches(kVp8Codec));
2046 EXPECT_EQ(media_channel1_->send_codecs()[0].packetization, absl::nullopt);
2047 EXPECT_TRUE(media_channel1_->send_codecs()[1].Matches(vp9_codec));
2048 EXPECT_EQ(media_channel1_->send_codecs()[1].packetization,
2049 cricket::kPacketizationParamRaw);
2050}
2051
2052TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) {
2053 const cricket::VideoCodec kLocalCodec(98, "VP8");
2054 cricket::VideoCodec remote_codec(99, "VP8");
2055 remote_codec.packetization = cricket::kPacketizationParamRaw;
2056 cricket::VideoContentDescription local_video;
2057 local_video.set_codecs({kLocalCodec});
2058 cricket::VideoContentDescription remote_video;
2059 remote_video.set_codecs({remote_codec});
2060
2061 CreateChannels(0, 0);
2062
2063 EXPECT_TRUE(
2064 channel1_->SetRemoteContent(&remote_video, SdpType::kOffer, NULL));
2065 EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kAnswer, NULL));
2066 ASSERT_THAT(media_channel1_->recv_codecs(), testing::SizeIs(1));
2067 EXPECT_EQ(media_channel1_->recv_codecs()[0].packetization, absl::nullopt);
2068 ASSERT_THAT(media_channel1_->send_codecs(), testing::SizeIs(1));
2069 EXPECT_EQ(media_channel1_->send_codecs()[0].packetization, absl::nullopt);
2070}
2071
2072TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) {
2073 cricket::VideoCodec local_codec(98, "VP8");
2074 local_codec.packetization = cricket::kPacketizationParamRaw;
2075 const cricket::VideoCodec kRemoteCodec(99, "VP8");
2076 cricket::VideoContentDescription local_video;
2077 local_video.set_codecs({local_codec});
2078 cricket::VideoContentDescription remote_video;
2079 remote_video.set_codecs({kRemoteCodec});
2080
2081 CreateChannels(0, 0);
2082
2083 EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kOffer, NULL));
2084 EXPECT_TRUE(
2085 channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, NULL));
2086 ASSERT_THAT(media_channel1_->recv_codecs(), testing::SizeIs(1));
2087 EXPECT_EQ(media_channel1_->recv_codecs()[0].packetization, absl::nullopt);
2088 ASSERT_THAT(media_channel1_->send_codecs(), testing::SizeIs(1));
2089 EXPECT_EQ(media_channel1_->send_codecs()[0].packetization, absl::nullopt);
2090}
2091
2092TEST_F(VideoChannelSingleThreadTest,
2093 TestSetRemoteAnswerWithInvalidPacketization) {
2094 cricket::VideoCodec local_codec(98, "VP8");
2095 local_codec.packetization = cricket::kPacketizationParamRaw;
2096 cricket::VideoCodec remote_codec(99, "VP8");
2097 remote_codec.packetization = "unknownpacketizationattributevalue";
2098 cricket::VideoContentDescription local_video;
2099 local_video.set_codecs({local_codec});
2100 cricket::VideoContentDescription remote_video;
2101 remote_video.set_codecs({remote_codec});
2102
2103 CreateChannels(0, 0);
2104
2105 EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kOffer, NULL));
2106 EXPECT_FALSE(
2107 channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, NULL));
2108 ASSERT_THAT(media_channel1_->recv_codecs(), testing::SizeIs(1));
2109 EXPECT_EQ(media_channel1_->recv_codecs()[0].packetization,
2110 cricket::kPacketizationParamRaw);
2111 EXPECT_THAT(media_channel1_->send_codecs(), testing::IsEmpty());
2112}
2113
2114TEST_F(VideoChannelSingleThreadTest,
2115 TestSetLocalAnswerWithInvalidPacketization) {
2116 cricket::VideoCodec local_codec(98, "VP8");
2117 local_codec.packetization = cricket::kPacketizationParamRaw;
2118 const cricket::VideoCodec kRemoteCodec(99, "VP8");
2119 cricket::VideoContentDescription local_video;
2120 local_video.set_codecs({local_codec});
2121 cricket::VideoContentDescription remote_video;
2122 remote_video.set_codecs({kRemoteCodec});
2123
2124 CreateChannels(0, 0);
2125
2126 EXPECT_TRUE(
2127 channel1_->SetRemoteContent(&remote_video, SdpType::kOffer, NULL));
2128 EXPECT_FALSE(
2129 channel1_->SetLocalContent(&local_video, SdpType::kAnswer, NULL));
2130 EXPECT_THAT(media_channel1_->recv_codecs(), testing::IsEmpty());
2131 ASSERT_THAT(media_channel1_->send_codecs(), testing::SizeIs(1));
2132 EXPECT_EQ(media_channel1_->send_codecs()[0].packetization, absl::nullopt);
2133}
2134
Danil Chapovalov33b01f22016-05-11 17:55:272135// VideoChannelDoubleThreadTest
2136TEST_F(VideoChannelDoubleThreadTest, TestInit) {
2137 Base::TestInit();
2138}
henrike@webrtc.org28e20752013-07-10 00:45:362139
Danil Chapovalovdae07ba2016-05-13 23:43:502140TEST_F(VideoChannelDoubleThreadTest, TestDeinit) {
2141 Base::TestDeinit();
2142}
2143
Danil Chapovalov33b01f22016-05-11 17:55:272144TEST_F(VideoChannelDoubleThreadTest, TestSetContents) {
2145 Base::TestSetContents();
2146}
2147
Johannes Kron9190b822018-10-29 10:22:052148TEST_F(VideoChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) {
2149 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true);
2150}
2151
2152TEST_F(VideoChannelDoubleThreadTest,
2153 TestSetContentsExtmapAllowMixedNotSupportedAsCaller) {
2154 Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false);
2155}
2156
2157TEST_F(VideoChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) {
2158 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true);
2159}
2160
2161TEST_F(VideoChannelDoubleThreadTest,
2162 TestSetContentsExtmapAllowMixedNotSupportedAsCallee) {
2163 Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false);
2164}
2165
Danil Chapovalov33b01f22016-05-11 17:55:272166TEST_F(VideoChannelDoubleThreadTest, TestSetContentsNullOffer) {
2167 Base::TestSetContentsNullOffer();
2168}
2169
2170TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMux) {
2171 Base::TestSetContentsRtcpMux();
2172}
2173
2174TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) {
2175 Base::TestSetContentsRtcpMux();
2176}
2177
Danil Chapovalov33b01f22016-05-11 17:55:272178TEST_F(VideoChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
2179 Base::TestChangeStreamParamsInContent();
2180}
2181
2182TEST_F(VideoChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
2183 Base::TestPlayoutAndSendingStates();
2184}
2185
Danil Chapovalov33b01f22016-05-11 17:55:272186TEST_F(VideoChannelDoubleThreadTest, TestMediaContentDirection) {
2187 Base::TestMediaContentDirection();
2188}
2189
2190TEST_F(VideoChannelDoubleThreadTest, TestNetworkRouteChanges) {
2191 Base::TestNetworkRouteChanges();
2192}
2193
2194TEST_F(VideoChannelDoubleThreadTest, TestCallSetup) {
2195 Base::TestCallSetup();
2196}
2197
2198TEST_F(VideoChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
2199 Base::TestCallTeardownRtcpMux();
2200}
2201
2202TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtp) {
2203 Base::SendRtpToRtp();
2204}
2205
Danil Chapovalov33b01f22016-05-11 17:55:272206TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) {
Zhi Huange830e682018-03-30 17:48:352207 Base::SendDtlsSrtpToDtlsSrtp(0, 0);
Danil Chapovalov33b01f22016-05-11 17:55:272208}
2209
2210TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
Zhi Huange830e682018-03-30 17:48:352211 Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX);
Danil Chapovalov33b01f22016-05-11 17:55:272212}
2213
2214TEST_F(VideoChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) {
2215 Base::SendEarlyMediaUsingRtcpMuxSrtp();
2216}
2217
2218TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtpOnThread) {
2219 Base::SendRtpToRtpOnThread();
2220}
2221
Danil Chapovalov33b01f22016-05-11 17:55:272222TEST_F(VideoChannelDoubleThreadTest, SendWithWritabilityLoss) {
2223 Base::SendWithWritabilityLoss();
2224}
2225
Danil Chapovalov33b01f22016-05-11 17:55:272226TEST_F(VideoChannelDoubleThreadTest, TestSetContentFailure) {
2227 Base::TestSetContentFailure();
2228}
2229
2230TEST_F(VideoChannelDoubleThreadTest, TestSendTwoOffers) {
2231 Base::TestSendTwoOffers();
2232}
2233
2234TEST_F(VideoChannelDoubleThreadTest, TestReceiveTwoOffers) {
2235 Base::TestReceiveTwoOffers();
2236}
2237
2238TEST_F(VideoChannelDoubleThreadTest, TestSendPrAnswer) {
2239 Base::TestSendPrAnswer();
2240}
2241
2242TEST_F(VideoChannelDoubleThreadTest, TestReceivePrAnswer) {
2243 Base::TestReceivePrAnswer();
2244}
2245
Danil Chapovalov33b01f22016-05-11 17:55:272246TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundle) {
2247 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false);
2248}
2249
2250TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleSecure) {
2251 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true);
2252}
2253
2254TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) {
2255 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
2256}
2257
2258TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
2259 Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
2260}
2261
zstein56162b92017-04-24 23:54:352262TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSend) {
2263 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:272264}
2265
Danil Chapovalov33b01f22016-05-11 17:55:272266TEST_F(VideoChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) {
2267 Base::DefaultMaxBitrateIsUnlimited();
2268}
2269
Steve Anton8a63f782017-10-23 20:08:532270TEST_F(VideoChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
2271 Base::SocketOptionsMergedOnSetTransport();
2272}
2273
deadbeef953c2ce2017-01-09 22:53:412274// RtpDataChannelSingleThreadTest
2275class RtpDataChannelSingleThreadTest : public ChannelTest<DataTraits> {
henrike@webrtc.org28e20752013-07-10 00:45:362276 public:
Danil Chapovalov33b01f22016-05-11 17:55:272277 typedef ChannelTest<DataTraits> Base;
deadbeef953c2ce2017-01-09 22:53:412278 RtpDataChannelSingleThreadTest()
Danil Chapovalov33b01f22016-05-11 17:55:272279 : Base(true, kDataPacket, kRtcpReport, NetworkIsWorker::Yes) {}
2280};
2281
deadbeef953c2ce2017-01-09 22:53:412282// RtpDataChannelDoubleThreadTest
2283class RtpDataChannelDoubleThreadTest : public ChannelTest<DataTraits> {
Danil Chapovalov33b01f22016-05-11 17:55:272284 public:
2285 typedef ChannelTest<DataTraits> Base;
deadbeef953c2ce2017-01-09 22:53:412286 RtpDataChannelDoubleThreadTest()
Danil Chapovalov33b01f22016-05-11 17:55:272287 : Base(true, kDataPacket, kRtcpReport, NetworkIsWorker::No) {}
henrike@webrtc.org28e20752013-07-10 00:45:362288};
2289
2290// Override to avoid engine channel parameter.
deadbeefcbecd352015-09-23 18:50:272291template <>
Steve Anton8699a322017-11-06 23:53:332292std::unique_ptr<cricket::RtpDataChannel> ChannelTest<DataTraits>::CreateChannel(
Danil Chapovalov33b01f22016-05-11 17:55:272293 rtc::Thread* worker_thread,
2294 rtc::Thread* network_thread,
Steve Anton8699a322017-11-06 23:53:332295 std::unique_ptr<cricket::FakeDataMediaChannel> ch,
Zhi Huange830e682018-03-30 17:48:352296 webrtc::RtpTransportInternal* rtp_transport,
jbauchcb560652016-08-04 12:20:322297 int flags) {
deadbeeff5346592017-01-25 05:51:212298 rtc::Thread* signaling_thread = rtc::Thread::Current();
Mirko Bonadei317a1f02019-09-17 15:06:182299 auto channel = std::make_unique<cricket::RtpDataChannel>(
Steve Anton8699a322017-11-06 23:53:332300 worker_thread, network_thread, signaling_thread, std::move(ch),
Amit Hilbuchbcd39d42019-01-26 01:13:562301 cricket::CN_DATA, (flags & DTLS) != 0, webrtc::CryptoOptions(),
2302 &ssrc_generator_);
Niels Möller2a707032020-06-16 14:39:132303 channel->Init_w(rtp_transport);
henrike@webrtc.org28e20752013-07-10 00:45:362304 return channel;
2305}
2306
Danil Chapovalov33b01f22016-05-11 17:55:272307template <>
henrike@webrtc.org28e20752013-07-10 00:45:362308void ChannelTest<DataTraits>::CreateContent(
2309 int flags,
2310 const cricket::AudioCodec& audio_codec,
2311 const cricket::VideoCodec& video_codec,
Harald Alvestrand5fc28b12019-05-13 11:36:162312 cricket::RtpDataContentDescription* data) {
henrike@webrtc.org28e20752013-07-10 00:45:362313 data->AddCodec(kGoogleDataCodec);
2314 data->set_rtcp_mux((flags & RTCP_MUX) != 0);
henrike@webrtc.org28e20752013-07-10 00:45:362315}
2316
Danil Chapovalov33b01f22016-05-11 17:55:272317template <>
henrike@webrtc.org28e20752013-07-10 00:45:362318void ChannelTest<DataTraits>::CopyContent(
Harald Alvestrand5fc28b12019-05-13 11:36:162319 const cricket::RtpDataContentDescription& source,
2320 cricket::RtpDataContentDescription* data) {
henrike@webrtc.org28e20752013-07-10 00:45:362321 *data = source;
2322}
2323
Danil Chapovalov33b01f22016-05-11 17:55:272324template <>
henrike@webrtc.org28e20752013-07-10 00:45:362325bool ChannelTest<DataTraits>::CodecMatches(const cricket::DataCodec& c1,
2326 const cricket::DataCodec& c2) {
2327 return c1.name == c2.name;
2328}
2329
Peter Boström0c4e06b2015-10-07 10:23:212330template <>
henrike@webrtc.org28e20752013-07-10 00:45:362331void ChannelTest<DataTraits>::AddLegacyStreamInContent(
Peter Boström0c4e06b2015-10-07 10:23:212332 uint32_t ssrc,
2333 int flags,
Harald Alvestrand5fc28b12019-05-13 11:36:162334 cricket::RtpDataContentDescription* data) {
henrike@webrtc.org28e20752013-07-10 00:45:362335 data->AddLegacyStream(ssrc);
2336}
2337
deadbeef953c2ce2017-01-09 22:53:412338TEST_F(RtpDataChannelSingleThreadTest, TestInit) {
henrike@webrtc.org28e20752013-07-10 00:45:362339 Base::TestInit();
2340 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2341}
2342
deadbeef953c2ce2017-01-09 22:53:412343TEST_F(RtpDataChannelSingleThreadTest, TestDeinit) {
Danil Chapovalovdae07ba2016-05-13 23:43:502344 Base::TestDeinit();
2345}
2346
deadbeef953c2ce2017-01-09 22:53:412347TEST_F(RtpDataChannelSingleThreadTest, TestSetContents) {
henrike@webrtc.org28e20752013-07-10 00:45:362348 Base::TestSetContents();
2349}
2350
deadbeef953c2ce2017-01-09 22:53:412351TEST_F(RtpDataChannelSingleThreadTest, TestSetContentsNullOffer) {
henrike@webrtc.org28e20752013-07-10 00:45:362352 Base::TestSetContentsNullOffer();
2353}
2354
deadbeef953c2ce2017-01-09 22:53:412355TEST_F(RtpDataChannelSingleThreadTest, TestSetContentsRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362356 Base::TestSetContentsRtcpMux();
2357}
2358
deadbeef953c2ce2017-01-09 22:53:412359TEST_F(RtpDataChannelSingleThreadTest, TestChangeStreamParamsInContent) {
henrike@webrtc.org28e20752013-07-10 00:45:362360 Base::TestChangeStreamParamsInContent();
2361}
2362
deadbeef953c2ce2017-01-09 22:53:412363TEST_F(RtpDataChannelSingleThreadTest, TestPlayoutAndSendingStates) {
henrike@webrtc.org28e20752013-07-10 00:45:362364 Base::TestPlayoutAndSendingStates();
2365}
2366
deadbeef953c2ce2017-01-09 22:53:412367TEST_F(RtpDataChannelSingleThreadTest, TestMediaContentDirection) {
henrike@webrtc.org28e20752013-07-10 00:45:362368 Base::TestMediaContentDirection();
2369}
2370
deadbeef953c2ce2017-01-09 22:53:412371TEST_F(RtpDataChannelSingleThreadTest, TestCallSetup) {
henrike@webrtc.org28e20752013-07-10 00:45:362372 Base::TestCallSetup();
2373}
2374
deadbeef953c2ce2017-01-09 22:53:412375TEST_F(RtpDataChannelSingleThreadTest, TestCallTeardownRtcpMux) {
henrike@webrtc.org28e20752013-07-10 00:45:362376 Base::TestCallTeardownRtcpMux();
2377}
2378
zstein56162b92017-04-24 23:54:352379TEST_F(RtpDataChannelSingleThreadTest, TestOnTransportReadyToSend) {
2380 Base::TestOnTransportReadyToSend();
henrike@webrtc.org28e20752013-07-10 00:45:362381}
2382
deadbeef953c2ce2017-01-09 22:53:412383TEST_F(RtpDataChannelSingleThreadTest, SendRtpToRtp) {
henrike@webrtc.org28e20752013-07-10 00:45:362384 Base::SendRtpToRtp();
2385}
2386
deadbeef953c2ce2017-01-09 22:53:412387TEST_F(RtpDataChannelSingleThreadTest, SendRtpToRtpOnThread) {
henrike@webrtc.org28e20752013-07-10 00:45:362388 Base::SendRtpToRtpOnThread();
2389}
2390
deadbeef953c2ce2017-01-09 22:53:412391TEST_F(RtpDataChannelSingleThreadTest, SendWithWritabilityLoss) {
henrike@webrtc.org28e20752013-07-10 00:45:362392 Base::SendWithWritabilityLoss();
2393}
2394
Steve Anton8a63f782017-10-23 20:08:532395TEST_F(RtpDataChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) {
2396 Base::SocketOptionsMergedOnSetTransport();
2397}
2398
deadbeef953c2ce2017-01-09 22:53:412399TEST_F(RtpDataChannelSingleThreadTest, TestSendData) {
Danil Chapovalov33b01f22016-05-11 17:55:272400 CreateChannels(0, 0);
2401 EXPECT_TRUE(SendInitiate());
2402 EXPECT_TRUE(SendAccept());
2403
2404 cricket::SendDataParams params;
2405 params.ssrc = 42;
2406 unsigned char data[] = {'f', 'o', 'o'};
2407 rtc::CopyOnWriteBuffer payload(data, 3);
2408 cricket::SendDataResult result;
2409 ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
2410 EXPECT_EQ(params.ssrc, media_channel1_->last_sent_data_params().ssrc);
2411 EXPECT_EQ("foo", media_channel1_->last_sent_data());
2412}
2413
deadbeef953c2ce2017-01-09 22:53:412414TEST_F(RtpDataChannelDoubleThreadTest, TestInit) {
Danil Chapovalov33b01f22016-05-11 17:55:272415 Base::TestInit();
2416 EXPECT_FALSE(media_channel1_->IsStreamMuted(0));
2417}
2418
deadbeef953c2ce2017-01-09 22:53:412419TEST_F(RtpDataChannelDoubleThreadTest, TestDeinit) {
Danil Chapovalovdae07ba2016-05-13 23:43:502420 Base::TestDeinit();
2421}
2422
deadbeef953c2ce2017-01-09 22:53:412423TEST_F(RtpDataChannelDoubleThreadTest, TestSetContents) {
Danil Chapovalov33b01f22016-05-11 17:55:272424 Base::TestSetContents();
2425}
2426
deadbeef953c2ce2017-01-09 22:53:412427TEST_F(RtpDataChannelDoubleThreadTest, TestSetContentsNullOffer) {
Danil Chapovalov33b01f22016-05-11 17:55:272428 Base::TestSetContentsNullOffer();
2429}
2430
deadbeef953c2ce2017-01-09 22:53:412431TEST_F(RtpDataChannelDoubleThreadTest, TestSetContentsRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:272432 Base::TestSetContentsRtcpMux();
2433}
2434
deadbeef953c2ce2017-01-09 22:53:412435TEST_F(RtpDataChannelDoubleThreadTest, TestChangeStreamParamsInContent) {
Danil Chapovalov33b01f22016-05-11 17:55:272436 Base::TestChangeStreamParamsInContent();
2437}
2438
deadbeef953c2ce2017-01-09 22:53:412439TEST_F(RtpDataChannelDoubleThreadTest, TestPlayoutAndSendingStates) {
Danil Chapovalov33b01f22016-05-11 17:55:272440 Base::TestPlayoutAndSendingStates();
2441}
2442
deadbeef953c2ce2017-01-09 22:53:412443TEST_F(RtpDataChannelDoubleThreadTest, TestMediaContentDirection) {
Danil Chapovalov33b01f22016-05-11 17:55:272444 Base::TestMediaContentDirection();
2445}
2446
deadbeef953c2ce2017-01-09 22:53:412447TEST_F(RtpDataChannelDoubleThreadTest, TestCallSetup) {
Danil Chapovalov33b01f22016-05-11 17:55:272448 Base::TestCallSetup();
2449}
2450
deadbeef953c2ce2017-01-09 22:53:412451TEST_F(RtpDataChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
Danil Chapovalov33b01f22016-05-11 17:55:272452 Base::TestCallTeardownRtcpMux();
2453}
2454
zstein56162b92017-04-24 23:54:352455TEST_F(RtpDataChannelDoubleThreadTest, TestOnTransportReadyToSend) {
2456 Base::TestOnTransportReadyToSend();
Danil Chapovalov33b01f22016-05-11 17:55:272457}
2458
deadbeef953c2ce2017-01-09 22:53:412459TEST_F(RtpDataChannelDoubleThreadTest, SendRtpToRtp) {
Danil Chapovalov33b01f22016-05-11 17:55:272460 Base::SendRtpToRtp();
2461}
2462
deadbeef953c2ce2017-01-09 22:53:412463TEST_F(RtpDataChannelDoubleThreadTest, SendRtpToRtpOnThread) {
Danil Chapovalov33b01f22016-05-11 17:55:272464 Base::SendRtpToRtpOnThread();
2465}
2466
deadbeef953c2ce2017-01-09 22:53:412467TEST_F(RtpDataChannelDoubleThreadTest, SendWithWritabilityLoss) {
Danil Chapovalov33b01f22016-05-11 17:55:272468 Base::SendWithWritabilityLoss();
2469}
2470
Steve Anton8a63f782017-10-23 20:08:532471TEST_F(RtpDataChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) {
2472 Base::SocketOptionsMergedOnSetTransport();
2473}
2474
deadbeef953c2ce2017-01-09 22:53:412475TEST_F(RtpDataChannelDoubleThreadTest, TestSendData) {
henrike@webrtc.org28e20752013-07-10 00:45:362476 CreateChannels(0, 0);
2477 EXPECT_TRUE(SendInitiate());
2478 EXPECT_TRUE(SendAccept());
2479
2480 cricket::SendDataParams params;
2481 params.ssrc = 42;
Yves Gerey665174f2018-06-19 13:03:052482 unsigned char data[] = {'f', 'o', 'o'};
jbaucheec21bd2016-03-20 13:15:432483 rtc::CopyOnWriteBuffer payload(data, 3);
henrike@webrtc.org28e20752013-07-10 00:45:362484 cricket::SendDataResult result;
2485 ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
Yves Gerey665174f2018-06-19 13:03:052486 EXPECT_EQ(params.ssrc, media_channel1_->last_sent_data_params().ssrc);
henrike@webrtc.org28e20752013-07-10 00:45:362487 EXPECT_EQ("foo", media_channel1_->last_sent_data());
2488}
2489
henrike@webrtc.org28e20752013-07-10 00:45:362490// TODO(pthatcher): TestSetReceiver?