diff options
Diffstat (limited to 'third_party/libwebrtc/pc/channel_unittest.cc')
| -rw-r--r-- | third_party/libwebrtc/pc/channel_unittest.cc | 2336 |
1 files changed, 2336 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/channel_unittest.cc b/third_party/libwebrtc/pc/channel_unittest.cc new file mode 100644 index 0000000000..27ad96aa3f --- /dev/null +++ b/third_party/libwebrtc/pc/channel_unittest.cc @@ -0,0 +1,2336 @@ +/* + * Copyright 2009 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "pc/channel.h" + +#include <stddef.h> + +#include <cstdint> +#include <string> +#include <type_traits> + +#include "absl/functional/any_invocable.h" +#include "api/array_view.h" +#include "api/audio_options.h" +#include "api/rtp_parameters.h" +#include "api/task_queue/pending_task_safety_flag.h" +#include "media/base/codec.h" +#include "media/base/fake_media_engine.h" +#include "media/base/fake_rtp.h" +#include "media/base/media_channel.h" +#include "media/base/media_constants.h" +#include "media/base/rid_description.h" +#include "p2p/base/candidate_pair_interface.h" +#include "p2p/base/dtls_transport_internal.h" +#include "p2p/base/fake_dtls_transport.h" +#include "p2p/base/fake_packet_transport.h" +#include "p2p/base/ice_transport_internal.h" +#include "p2p/base/p2p_constants.h" +#include "p2p/base/packet_transport_internal.h" +#include "pc/dtls_srtp_transport.h" +#include "pc/jsep_transport.h" +#include "pc/rtp_transport.h" +#include "rtc_base/arraysize.h" +#include "rtc_base/buffer.h" +#include "rtc_base/byte_order.h" +#include "rtc_base/checks.h" +#include "rtc_base/rtc_certificate.h" +#include "rtc_base/ssl_identity.h" +#include "rtc_base/task_queue_for_test.h" +#include "test/gmock.h" +#include "test/gtest.h" +#include "test/scoped_key_value_config.h" + +using cricket::DtlsTransportInternal; +using cricket::FakeVoiceMediaChannel; +using cricket::RidDescription; +using cricket::RidDirection; +using cricket::StreamParams; +using webrtc::RtpTransceiverDirection; +using webrtc::SdpType; + +namespace { +const cricket::AudioCodec kPcmuCodec(0, "PCMU", 64000, 8000, 1); +const cricket::AudioCodec kPcmaCodec(8, "PCMA", 64000, 8000, 1); +const cricket::AudioCodec kIsacCodec(103, "ISAC", 40000, 16000, 1); +const cricket::VideoCodec kH264Codec(97, "H264"); +const cricket::VideoCodec kH264SvcCodec(99, "H264-SVC"); +const uint32_t kSsrc1 = 0x1111; +const uint32_t kSsrc2 = 0x2222; +const uint32_t kSsrc3 = 0x3333; +const uint32_t kSsrc4 = 0x4444; +const int kAudioPts[] = {0, 8}; +const int kVideoPts[] = {97, 99}; +enum class NetworkIsWorker { Yes, No }; + +} // namespace + +template <class ChannelT, + class MediaChannelT, + class MediaSendChannelT, + class MediaReceiveChannelT, + class ContentT, + class CodecT, + class MediaInfoT, + class OptionsT> +class Traits { + public: + typedef ChannelT Channel; + typedef MediaChannelT MediaChannel; + typedef MediaSendChannelT MediaSendChannel; + typedef MediaReceiveChannelT MediaReceiveChannel; + typedef ContentT Content; + typedef CodecT Codec; + typedef MediaInfoT MediaInfo; + typedef OptionsT Options; +}; + +class VoiceTraits : public Traits<cricket::VoiceChannel, + cricket::FakeVoiceMediaChannel, + cricket::VoiceMediaSendChannelInterface, + cricket::VoiceMediaReceiveChannelInterface, + cricket::AudioContentDescription, + cricket::AudioCodec, + cricket::VoiceMediaInfo, + cricket::AudioOptions> {}; + +class VideoTraits : public Traits<cricket::VideoChannel, + cricket::FakeVideoMediaChannel, + cricket::VideoMediaSendChannelInterface, + cricket::VideoMediaReceiveChannelInterface, + cricket::VideoContentDescription, + cricket::VideoCodec, + cricket::VideoMediaInfo, + cricket::VideoOptions> {}; + +// Base class for Voice/Video tests +template <class T> +class ChannelTest : public ::testing::Test, public sigslot::has_slots<> { + public: + enum Flags { + RTCP_MUX = 0x1, + SSRC_MUX = 0x8, + DTLS = 0x10, + // Use BaseChannel with PacketTransportInternal rather than + // DtlsTransportInternal. + RAW_PACKET_TRANSPORT = 0x20, + }; + + ChannelTest(bool verify_playout, + rtc::ArrayView<const uint8_t> rtp_data, + rtc::ArrayView<const uint8_t> rtcp_data, + NetworkIsWorker network_is_worker) + : verify_playout_(verify_playout), + rtp_packet_(rtp_data.data(), rtp_data.size()), + rtcp_packet_(rtcp_data.data(), rtcp_data.size()) { + if (network_is_worker == NetworkIsWorker::Yes) { + network_thread_ = rtc::Thread::Current(); + } else { + network_thread_keeper_ = rtc::Thread::Create(); + network_thread_keeper_->SetName("Network", nullptr); + network_thread_ = network_thread_keeper_.get(); + } + RTC_DCHECK(network_thread_); + } + + ~ChannelTest() { + if (network_thread_) { + SendTask(network_thread_, [this]() { + network_thread_safety_->SetNotAlive(); + DeinitChannels(); + }); + } + } + + void CreateChannels(int flags1, int flags2) { + CreateChannels(std::make_unique<typename T::MediaChannel>( + nullptr, typename T::Options(), network_thread_), + std::make_unique<typename T::MediaChannel>( + nullptr, typename T::Options(), network_thread_), + flags1, flags2); + } + void CreateChannels(std::unique_ptr<typename T::MediaChannel> ch1, + std::unique_ptr<typename T::MediaChannel> ch2, + int flags1, + int flags2) { + RTC_DCHECK(!channel1_); + RTC_DCHECK(!channel2_); + + // Network thread is started in CreateChannels, to allow the test to + // configure a fake clock before any threads are spawned and attempt to + // access the time. + if (network_thread_keeper_) { + network_thread_keeper_->Start(); + } + + // Make sure if using raw packet transports, they're used for both + // channels. + RTC_DCHECK_EQ(flags1 & RAW_PACKET_TRANSPORT, flags2 & RAW_PACKET_TRANSPORT); + rtc::Thread* worker_thread = rtc::Thread::Current(); + // Based on flags, create fake DTLS or raw packet transports. + if (flags1 & RAW_PACKET_TRANSPORT) { + fake_rtp_packet_transport1_.reset( + new rtc::FakePacketTransport("channel1_rtp")); + if (!(flags1 & RTCP_MUX)) { + fake_rtcp_packet_transport1_.reset( + new rtc::FakePacketTransport("channel1_rtcp")); + } + } else { + // Confirmed to work with KT_RSA and KT_ECDSA. + fake_rtp_dtls_transport1_.reset(new cricket::FakeDtlsTransport( + "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_)); + if (!(flags1 & RTCP_MUX)) { + fake_rtcp_dtls_transport1_.reset(new cricket::FakeDtlsTransport( + "channel1", cricket::ICE_CANDIDATE_COMPONENT_RTCP, + network_thread_)); + } + if (flags1 & DTLS) { + auto cert1 = rtc::RTCCertificate::Create( + rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT)); + fake_rtp_dtls_transport1_->SetLocalCertificate(cert1); + if (fake_rtcp_dtls_transport1_) { + fake_rtcp_dtls_transport1_->SetLocalCertificate(cert1); + } + } + } + // Based on flags, create fake DTLS or raw packet transports. + if (flags2 & RAW_PACKET_TRANSPORT) { + fake_rtp_packet_transport2_.reset( + new rtc::FakePacketTransport("channel2_rtp")); + if (!(flags2 & RTCP_MUX)) { + fake_rtcp_packet_transport2_.reset( + new rtc::FakePacketTransport("channel2_rtcp")); + } + } else { + // Confirmed to work with KT_RSA and KT_ECDSA. + fake_rtp_dtls_transport2_.reset(new cricket::FakeDtlsTransport( + "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTP, network_thread_)); + if (!(flags2 & RTCP_MUX)) { + fake_rtcp_dtls_transport2_.reset(new cricket::FakeDtlsTransport( + "channel2", cricket::ICE_CANDIDATE_COMPONENT_RTCP, + network_thread_)); + } + if (flags2 & DTLS) { + auto cert2 = rtc::RTCCertificate::Create( + rtc::SSLIdentity::Create("session2", rtc::KT_DEFAULT)); + fake_rtp_dtls_transport2_->SetLocalCertificate(cert2); + if (fake_rtcp_dtls_transport2_) { + fake_rtcp_dtls_transport2_->SetLocalCertificate(cert2); + } + } + } + rtp_transport1_ = CreateRtpTransportBasedOnFlags( + fake_rtp_packet_transport1_.get(), fake_rtcp_packet_transport1_.get(), + fake_rtp_dtls_transport1_.get(), fake_rtcp_dtls_transport1_.get(), + flags1); + rtp_transport2_ = CreateRtpTransportBasedOnFlags( + fake_rtp_packet_transport2_.get(), fake_rtcp_packet_transport2_.get(), + fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get(), + flags2); + + channel1_ = CreateChannel(worker_thread, network_thread_, std::move(ch1), + rtp_transport1_.get(), flags1); + channel2_ = CreateChannel(worker_thread, network_thread_, std::move(ch2), + rtp_transport2_.get(), flags2); + CreateContent(flags1, kPcmuCodec, kH264Codec, &local_media_content1_); + CreateContent(flags2, kPcmuCodec, kH264Codec, &local_media_content2_); + CopyContent(local_media_content1_, &remote_media_content1_); + CopyContent(local_media_content2_, &remote_media_content2_); + + // Add stream information (SSRC) to the local content but not to the remote + // content. This means that we per default know the SSRC of what we send but + // not what we receive. + AddLegacyStreamInContent(kSsrc1, flags1, &local_media_content1_); + AddLegacyStreamInContent(kSsrc2, flags2, &local_media_content2_); + + // If SSRC_MUX is used we also need to know the SSRC of the incoming stream. + if (flags1 & SSRC_MUX) { + AddLegacyStreamInContent(kSsrc1, flags1, &remote_media_content1_); + } + if (flags2 & SSRC_MUX) { + AddLegacyStreamInContent(kSsrc2, flags2, &remote_media_content2_); + } + } + std::unique_ptr<typename T::Channel> CreateChannel( + rtc::Thread* worker_thread, + rtc::Thread* network_thread, + std::unique_ptr<typename T::MediaChannel> ch, + webrtc::RtpTransportInternal* rtp_transport, + int flags); + + std::unique_ptr<webrtc::RtpTransportInternal> CreateRtpTransportBasedOnFlags( + rtc::PacketTransportInternal* rtp_packet_transport, + rtc::PacketTransportInternal* rtcp_packet_transport, + DtlsTransportInternal* rtp_dtls_transport, + DtlsTransportInternal* rtcp_dtls_transport, + int flags) { + if (flags & RTCP_MUX) { + rtcp_packet_transport = nullptr; + rtcp_dtls_transport = nullptr; + } + + if (flags & DTLS) { + return CreateDtlsSrtpTransport(rtp_dtls_transport, rtcp_dtls_transport); + } else { + if (flags & RAW_PACKET_TRANSPORT) { + return CreateUnencryptedTransport(rtp_packet_transport, + rtcp_packet_transport); + } else { + return CreateUnencryptedTransport(rtp_dtls_transport, + rtcp_dtls_transport); + } + } + } + + // Unininitializes the channels on the network thread. + void DeinitChannels() { + if (!channel1_ && !channel2_) + return; + SendTask(network_thread_, [this]() { + if (channel1_) { + RTC_DCHECK_RUN_ON(channel1_->network_thread()); + channel1_->SetRtpTransport(nullptr); + } + if (channel2_) { + RTC_DCHECK_RUN_ON(channel2_->network_thread()); + channel2_->SetRtpTransport(nullptr); + } + }); + } + + std::unique_ptr<webrtc::RtpTransport> CreateUnencryptedTransport( + rtc::PacketTransportInternal* rtp_packet_transport, + rtc::PacketTransportInternal* rtcp_packet_transport) { + auto rtp_transport = std::make_unique<webrtc::RtpTransport>( + rtcp_packet_transport == nullptr); + + SendTask(network_thread_, + [&rtp_transport, rtp_packet_transport, rtcp_packet_transport] { + rtp_transport->SetRtpPacketTransport(rtp_packet_transport); + if (rtcp_packet_transport) { + rtp_transport->SetRtcpPacketTransport(rtcp_packet_transport); + } + }); + return rtp_transport; + } + + std::unique_ptr<webrtc::DtlsSrtpTransport> CreateDtlsSrtpTransport( + cricket::DtlsTransportInternal* rtp_dtls_transport, + cricket::DtlsTransportInternal* rtcp_dtls_transport) { + auto dtls_srtp_transport = std::make_unique<webrtc::DtlsSrtpTransport>( + rtcp_dtls_transport == nullptr, field_trials_); + + SendTask(network_thread_, + [&dtls_srtp_transport, rtp_dtls_transport, rtcp_dtls_transport] { + dtls_srtp_transport->SetDtlsTransports(rtp_dtls_transport, + rtcp_dtls_transport); + }); + return dtls_srtp_transport; + } + + void ConnectFakeTransports() { + SendTask(network_thread_, [this] { + bool asymmetric = false; + // Depending on test flags, could be using DTLS or raw packet transport. + if (fake_rtp_dtls_transport1_ && fake_rtp_dtls_transport2_) { + fake_rtp_dtls_transport1_->SetDestination( + fake_rtp_dtls_transport2_.get(), asymmetric); + } + if (fake_rtcp_dtls_transport1_ && fake_rtcp_dtls_transport2_) { + fake_rtcp_dtls_transport1_->SetDestination( + fake_rtcp_dtls_transport2_.get(), asymmetric); + } + if (fake_rtp_packet_transport1_ && fake_rtp_packet_transport2_) { + fake_rtp_packet_transport1_->SetDestination( + fake_rtp_packet_transport2_.get(), asymmetric); + } + if (fake_rtcp_packet_transport1_ && fake_rtcp_packet_transport2_) { + fake_rtcp_packet_transport1_->SetDestination( + fake_rtcp_packet_transport2_.get(), asymmetric); + } + }); + // The transport becoming writable will asynchronously update the send state + // on the worker thread; since this test uses the main thread as the worker + // thread, we must process the message queue for this to occur. + WaitForThreads(); + } + + bool SendInitiate() { + std::string err; + bool result = channel1_->SetLocalContent(&local_media_content1_, + SdpType::kOffer, err); + if (result) { + channel1_->Enable(true); + FlushCurrentThread(); + result = channel2_->SetRemoteContent(&remote_media_content1_, + SdpType::kOffer, err); + if (result) { + ConnectFakeTransports(); + result = channel2_->SetLocalContent(&local_media_content2_, + SdpType::kAnswer, err); + } + } + return result; + } + + bool SendAccept() { + channel2_->Enable(true); + FlushCurrentThread(); + std::string err; + return channel1_->SetRemoteContent(&remote_media_content2_, + SdpType::kAnswer, err); + } + + bool SendOffer() { + std::string err; + bool result = channel1_->SetLocalContent(&local_media_content1_, + SdpType::kOffer, err); + if (result) { + channel1_->Enable(true); + result = channel2_->SetRemoteContent(&remote_media_content1_, + SdpType::kOffer, err); + } + return result; + } + + bool SendProvisionalAnswer() { + std::string err; + bool result = channel2_->SetLocalContent(&local_media_content2_, + SdpType::kPrAnswer, err); + if (result) { + channel2_->Enable(true); + result = channel1_->SetRemoteContent(&remote_media_content2_, + SdpType::kPrAnswer, err); + ConnectFakeTransports(); + } + return result; + } + + bool SendFinalAnswer() { + std::string err; + bool result = channel2_->SetLocalContent(&local_media_content2_, + SdpType::kAnswer, err); + if (result) { + result = channel1_->SetRemoteContent(&remote_media_content2_, + SdpType::kAnswer, err); + } + return result; + } + + void SendRtp(typename T::MediaChannel* media_channel, rtc::Buffer data) { + network_thread_->PostTask(webrtc::SafeTask( + network_thread_safety_, [media_channel, data = std::move(data)]() { + media_channel->SendRtp(data.data(), data.size(), + rtc::PacketOptions()); + })); + } + + void SendRtp1() { + SendRtp1(rtc::Buffer(rtp_packet_.data(), rtp_packet_.size())); + } + + void SendRtp1(rtc::Buffer data) { + SendRtp(media_channel1(), std::move(data)); + } + + void SendRtp2() { + SendRtp2(rtc::Buffer(rtp_packet_.data(), rtp_packet_.size())); + } + + void SendRtp2(rtc::Buffer data) { + SendRtp(media_channel2(), std::move(data)); + } + + // Methods to send custom data. + void SendCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) { + SendRtp1(CreateRtpData(ssrc, sequence_number, pl_type)); + } + void SendCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) { + SendRtp2(CreateRtpData(ssrc, sequence_number, pl_type)); + } + + bool CheckRtp1() { + return media_channel1()->CheckRtp(rtp_packet_.data(), rtp_packet_.size()); + } + bool CheckRtp2() { + return media_channel2()->CheckRtp(rtp_packet_.data(), rtp_packet_.size()); + } + // Methods to check custom data. + bool CheckCustomRtp1(uint32_t ssrc, int sequence_number, int pl_type = -1) { + rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type); + return media_channel1()->CheckRtp(data.data(), data.size()); + } + bool CheckCustomRtp2(uint32_t ssrc, int sequence_number, int pl_type = -1) { + rtc::Buffer data = CreateRtpData(ssrc, sequence_number, pl_type); + return media_channel2()->CheckRtp(data.data(), data.size()); + } + rtc::Buffer CreateRtpData(uint32_t ssrc, int sequence_number, int pl_type) { + rtc::Buffer data(rtp_packet_.data(), rtp_packet_.size()); + // Set SSRC in the rtp packet copy. + rtc::SetBE32(data.data() + 8, ssrc); + rtc::SetBE16(data.data() + 2, sequence_number); + if (pl_type >= 0) { + rtc::Set8(data.data(), 1, static_cast<uint8_t>(pl_type)); + } + return data; + } + + bool CheckNoRtp1() { return media_channel1()->CheckNoRtp(); } + bool CheckNoRtp2() { return media_channel2()->CheckNoRtp(); } + + void CreateContent(int flags, + const cricket::AudioCodec& audio_codec, + const cricket::VideoCodec& video_codec, + typename T::Content* content) { + // overridden in specialized classes + } + void CopyContent(const typename T::Content& source, + typename T::Content* content) { + // overridden in specialized classes + } + + // Creates a MediaContent with one stream. + // kPcmuCodec is used as audio codec and kH264Codec is used as video codec. + typename T::Content* CreateMediaContentWithStream(uint32_t ssrc) { + typename T::Content* content = new typename T::Content(); + CreateContent(0, kPcmuCodec, kH264Codec, content); + AddLegacyStreamInContent(ssrc, 0, content); + return content; + } + + // Will manage the lifetime of a CallThread, making sure it's + // destroyed before this object goes out of scope. + class ScopedCallThread { + public: + explicit ScopedCallThread(absl::AnyInvocable<void() &&> functor) + : thread_(rtc::Thread::Create()) { + thread_->Start(); + thread_->PostTask(std::move(functor)); + } + + ~ScopedCallThread() { thread_->Stop(); } + + rtc::Thread* thread() { return thread_.get(); } + + private: + std::unique_ptr<rtc::Thread> thread_; + }; + + bool CodecMatches(const typename T::Codec& c1, const typename T::Codec& c2) { + return false; // overridden in specialized classes + } + + cricket::CandidatePairInterface* last_selected_candidate_pair() { + return last_selected_candidate_pair_; + } + + void AddLegacyStreamInContent(uint32_t ssrc, + int flags, + typename T::Content* content) { + // Base implementation. + } + + // Utility method that calls BaseChannel::srtp_active() on the network thread + // and returns the result. The `srtp_active()` state is maintained on the + // network thread, which callers need to factor in. + bool IsSrtpActive(std::unique_ptr<typename T::Channel>& channel) { + RTC_DCHECK(channel.get()); + bool result; + SendTask(network_thread_, [&] { result = channel->srtp_active(); }); + return result; + } + + // Returns true iff the transport is set for a channel and rtcp_mux_enabled() + // returns true. + bool IsRtcpMuxEnabled(std::unique_ptr<typename T::Channel>& channel) { + RTC_DCHECK(channel.get()); + bool result; + SendTask(network_thread_, [&] { + result = channel->rtp_transport() && + channel->rtp_transport()->rtcp_mux_enabled(); + }); + return result; + } + + // Tests that can be used by derived classes. + + // Basic sanity check. + void TestInit() { + CreateChannels(0, 0); + EXPECT_FALSE(IsSrtpActive(channel1_)); + EXPECT_FALSE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_FALSE(media_channel1()->playout()); + } + EXPECT_TRUE(media_channel1()->codecs().empty()); + EXPECT_TRUE(media_channel1()->recv_streams().empty()); + EXPECT_TRUE(media_channel1()->rtp_packets().empty()); + // Basic sanity test for send and receive channel objects + EXPECT_EQ(channel1_->media_send_channel()->media_type(), + media_channel1()->media_type()); + EXPECT_EQ(channel1_->media_receive_channel()->media_type(), + media_channel1()->media_type()); + } + + // Test that SetLocalContent and SetRemoteContent properly configure + // the codecs. + void TestSetContents() { + CreateChannels(0, 0); + typename T::Content content; + CreateContent(0, kPcmuCodec, kH264Codec, &content); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err)); + EXPECT_EQ(0U, media_channel1()->codecs().size()); + EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err)); + ASSERT_EQ(1U, media_channel1()->codecs().size()); + EXPECT_TRUE( + CodecMatches(content.codecs()[0], media_channel1()->codecs()[0])); + } + + // Test that SetLocalContent and SetRemoteContent properly configure + // extmap-allow-mixed. + void TestSetContentsExtmapAllowMixedCaller(bool offer, bool answer) { + // For a caller, SetLocalContent() is called first with an offer and next + // SetRemoteContent() is called with the answer. + CreateChannels(0, 0); + typename T::Content content; + CreateContent(0, kPcmuCodec, kH264Codec, &content); + auto offer_enum = offer ? (T::Content::kSession) : (T::Content::kNo); + auto answer_enum = answer ? (T::Content::kSession) : (T::Content::kNo); + content.set_extmap_allow_mixed_enum(offer_enum); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err)); + content.set_extmap_allow_mixed_enum(answer_enum); + EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err)); + EXPECT_EQ(answer, media_send_channel1()->ExtmapAllowMixed()); + } + void TestSetContentsExtmapAllowMixedCallee(bool offer, bool answer) { + // For a callee, SetRemoteContent() is called first with an offer and next + // SetLocalContent() is called with the answer. + CreateChannels(0, 0); + typename T::Content content; + CreateContent(0, kPcmuCodec, kH264Codec, &content); + auto offer_enum = offer ? (T::Content::kSession) : (T::Content::kNo); + auto answer_enum = answer ? (T::Content::kSession) : (T::Content::kNo); + content.set_extmap_allow_mixed_enum(offer_enum); + std::string err; + EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kOffer, err)); + content.set_extmap_allow_mixed_enum(answer_enum); + EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kAnswer, err)); + EXPECT_EQ(answer, media_send_channel1()->ExtmapAllowMixed()); + } + + // Test that SetLocalContent and SetRemoteContent properly deals + // with an empty offer. + void TestSetContentsNullOffer() { + CreateChannels(0, 0); + typename T::Content content; + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err)); + CreateContent(0, kPcmuCodec, kH264Codec, &content); + EXPECT_EQ(0U, media_channel1()->codecs().size()); + EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err)); + ASSERT_EQ(1U, media_channel1()->codecs().size()); + EXPECT_TRUE( + CodecMatches(content.codecs()[0], media_channel1()->codecs()[0])); + } + + // Test that SetLocalContent and SetRemoteContent properly set RTCP + // mux. + void TestSetContentsRtcpMux() { + CreateChannels(0, 0); + typename T::Content content; + CreateContent(0, kPcmuCodec, kH264Codec, &content); + // Both sides agree on mux. Should no longer be a separate RTCP channel. + content.set_rtcp_mux(true); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content, SdpType::kOffer, err)); + EXPECT_TRUE(channel1_->SetRemoteContent(&content, SdpType::kAnswer, err)); + // Only initiator supports mux. Should still have a separate RTCP channel. + EXPECT_TRUE(channel2_->SetLocalContent(&content, SdpType::kOffer, err)); + content.set_rtcp_mux(false); + EXPECT_TRUE(channel2_->SetRemoteContent(&content, SdpType::kAnswer, err)); + } + + // Test that SetLocalContent and SetRemoteContent properly + // handles adding and removing StreamParams when the action is a full + // SdpType::kOffer / SdpType::kAnswer. + void TestChangeStreamParamsInContent() { + cricket::StreamParams stream1; + stream1.id = "stream1"; + stream1.ssrcs.push_back(kSsrc1); + stream1.cname = "stream1_cname"; + + cricket::StreamParams stream2; + stream2.id = "stream2"; + stream2.ssrcs.push_back(kSsrc2); + stream2.cname = "stream2_cname"; + + // Setup a call where channel 1 send `stream1` to channel 2. + CreateChannels(0, 0); + typename T::Content content1; + CreateContent(0, kPcmuCodec, kH264Codec, &content1); + content1.AddStream(stream1); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, err)); + channel1_->Enable(true); + EXPECT_EQ(1u, media_channel1()->send_streams().size()); + + EXPECT_TRUE(channel2_->SetRemoteContent(&content1, SdpType::kOffer, err)); + EXPECT_EQ(1u, media_channel2()->recv_streams().size()); + ConnectFakeTransports(); + + // Channel 2 do not send anything. + typename T::Content content2; + CreateContent(0, kPcmuCodec, kH264Codec, &content2); + EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, err)); + EXPECT_EQ(0u, media_channel1()->recv_streams().size()); + EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kAnswer, err)); + channel2_->Enable(true); + EXPECT_EQ(0u, media_channel2()->send_streams().size()); + + SendCustomRtp1(kSsrc1, 0); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp2(kSsrc1, 0)); + + // Let channel 2 update the content by sending `stream2` and enable SRTP. + typename T::Content content3; + CreateContent(0, kPcmuCodec, kH264Codec, &content3); + content3.AddStream(stream2); + EXPECT_TRUE(channel2_->SetLocalContent(&content3, SdpType::kOffer, err)); + ASSERT_EQ(1u, media_channel2()->send_streams().size()); + EXPECT_EQ(stream2, media_channel2()->send_streams()[0]); + + EXPECT_TRUE(channel1_->SetRemoteContent(&content3, SdpType::kOffer, err)); + ASSERT_EQ(1u, media_channel1()->recv_streams().size()); + EXPECT_EQ(stream2, media_channel1()->recv_streams()[0]); + + // Channel 1 replies but stop sending stream1. + typename T::Content content4; + CreateContent(0, kPcmuCodec, kH264Codec, &content4); + EXPECT_TRUE(channel1_->SetLocalContent(&content4, SdpType::kAnswer, err)); + EXPECT_EQ(0u, media_channel1()->send_streams().size()); + + EXPECT_TRUE(channel2_->SetRemoteContent(&content4, SdpType::kAnswer, err)); + EXPECT_EQ(0u, media_channel2()->recv_streams().size()); + + SendCustomRtp2(kSsrc2, 0); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp1(kSsrc2, 0)); + } + + // Test that we only start playout and sending at the right times. + void TestPlayoutAndSendingStates() { + CreateChannels(0, 0); + if (verify_playout_) { + EXPECT_FALSE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); + } + EXPECT_FALSE(media_channel2()->sending()); + channel1_->Enable(true); + FlushCurrentThread(); + if (verify_playout_) { + EXPECT_FALSE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_, + SdpType::kOffer, err)); + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + EXPECT_TRUE(channel2_->SetRemoteContent(&local_media_content1_, + SdpType::kOffer, err)); + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); + } + EXPECT_FALSE(media_channel2()->sending()); + EXPECT_TRUE(channel2_->SetLocalContent(&local_media_content2_, + SdpType::kAnswer, err)); + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); + } + EXPECT_FALSE(media_channel2()->sending()); + ConnectFakeTransports(); + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); + } + EXPECT_FALSE(media_channel2()->sending()); + channel2_->Enable(true); + FlushCurrentThread(); + if (verify_playout_) { + EXPECT_TRUE(media_channel2()->playout()); + } + EXPECT_TRUE(media_channel2()->sending()); + EXPECT_TRUE(channel1_->SetRemoteContent(&local_media_content2_, + SdpType::kAnswer, err)); + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_TRUE(media_channel1()->sending()); + } + + // Test that changing the MediaContentDirection in the local and remote + // session description start playout and sending at the right time. + void TestMediaContentDirection() { + CreateChannels(0, 0); + typename T::Content content1; + CreateContent(0, kPcmuCodec, kH264Codec, &content1); + typename T::Content content2; + CreateContent(0, kPcmuCodec, kH264Codec, &content2); + // Set `content2` to be InActive. + content2.set_direction(RtpTransceiverDirection::kInactive); + + channel1_->Enable(true); + channel2_->Enable(true); + FlushCurrentThread(); + if (verify_playout_) { + EXPECT_FALSE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); + } + EXPECT_FALSE(media_channel2()->sending()); + + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, err)); + EXPECT_TRUE(channel2_->SetRemoteContent(&content1, SdpType::kOffer, err)); + EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kPrAnswer, err)); + EXPECT_TRUE( + channel1_->SetRemoteContent(&content2, SdpType::kPrAnswer, err)); + ConnectFakeTransports(); + + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); // remote InActive + if (verify_playout_) { + EXPECT_FALSE(media_channel2()->playout()); // local InActive + } + EXPECT_FALSE(media_channel2()->sending()); // local InActive + + // Update `content2` to be RecvOnly. + content2.set_direction(RtpTransceiverDirection::kRecvOnly); + EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kPrAnswer, err)); + EXPECT_TRUE( + channel1_->SetRemoteContent(&content2, SdpType::kPrAnswer, err)); + + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_TRUE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_TRUE(media_channel2()->playout()); // local RecvOnly + } + EXPECT_FALSE(media_channel2()->sending()); // local RecvOnly + + // Update `content2` to be SendRecv. + content2.set_direction(RtpTransceiverDirection::kSendRecv); + EXPECT_TRUE(channel2_->SetLocalContent(&content2, SdpType::kAnswer, err)); + EXPECT_TRUE(channel1_->SetRemoteContent(&content2, SdpType::kAnswer, err)); + + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_TRUE(media_channel1()->sending()); + if (verify_playout_) { + EXPECT_TRUE(media_channel2()->playout()); + } + EXPECT_TRUE(media_channel2()->sending()); + } + + // Tests that when the transport channel signals a candidate pair change + // event, the media channel will receive a call on the network route change. + void TestNetworkRouteChanges() { + static constexpr uint16_t kLocalNetId = 1; + static constexpr uint16_t kRemoteNetId = 2; + static constexpr int kLastPacketId = 100; + // Ipv4(20) + UDP(8). + static constexpr int kTransportOverheadPerPacket = 28; + static constexpr int kSrtpOverheadPerPacket = 10; + + CreateChannels(DTLS, DTLS); + SendInitiate(); + + typename T::MediaChannel* media_channel1 = this->media_channel1(); + ASSERT_TRUE(media_channel1); + + // Need to wait for the threads before calling + // `set_num_network_route_changes` because the network route would be set + // when creating the channel. + WaitForThreads(); + media_channel1->set_num_network_route_changes(0); + SendTask(network_thread_, [this] { + rtc::NetworkRoute network_route; + // The transport channel becomes disconnected. + fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged( + absl::optional<rtc::NetworkRoute>(network_route)); + }); + WaitForThreads(); + EXPECT_EQ(1, media_channel1->num_network_route_changes()); + EXPECT_FALSE(media_channel1->last_network_route().connected); + media_channel1->set_num_network_route_changes(0); + + SendTask(network_thread_, [this] { + rtc::NetworkRoute network_route; + network_route.connected = true; + network_route.local = + rtc::RouteEndpoint::CreateWithNetworkId(kLocalNetId); + network_route.remote = + rtc::RouteEndpoint::CreateWithNetworkId(kRemoteNetId); + network_route.last_sent_packet_id = kLastPacketId; + network_route.packet_overhead = kTransportOverheadPerPacket; + // The transport channel becomes connected. + fake_rtp_dtls_transport1_->ice_transport()->SignalNetworkRouteChanged( + + absl::optional<rtc::NetworkRoute>(network_route)); + }); + WaitForThreads(); + EXPECT_EQ(1, media_channel1->num_network_route_changes()); + EXPECT_TRUE(media_channel1->last_network_route().connected); + EXPECT_EQ(kLocalNetId, + media_channel1->last_network_route().local.network_id()); + EXPECT_EQ(kRemoteNetId, + media_channel1->last_network_route().remote.network_id()); + EXPECT_EQ(kLastPacketId, + media_channel1->last_network_route().last_sent_packet_id); + EXPECT_EQ(kTransportOverheadPerPacket + kSrtpOverheadPerPacket, + media_channel1->transport_overhead_per_packet()); + } + + // Test setting up a call. + void TestCallSetup() { + CreateChannels(0, 0); + EXPECT_FALSE(IsSrtpActive(channel1_)); + EXPECT_TRUE(SendInitiate()); + if (verify_playout_) { + EXPECT_TRUE(media_channel1()->playout()); + } + EXPECT_FALSE(media_channel1()->sending()); + EXPECT_TRUE(SendAccept()); + EXPECT_FALSE(IsSrtpActive(channel1_)); + EXPECT_TRUE(media_channel1()->sending()); + EXPECT_EQ(1U, media_channel1()->codecs().size()); + if (verify_playout_) { + EXPECT_TRUE(media_channel2()->playout()); + } + EXPECT_TRUE(media_channel2()->sending()); + EXPECT_EQ(1U, media_channel2()->codecs().size()); + } + + // Send voice RTP data to the other side and ensure it gets there. + void SendRtpToRtp() { + CreateChannels(RTCP_MUX, RTCP_MUX); + EXPECT_TRUE(SendInitiate()); + EXPECT_TRUE(SendAccept()); + EXPECT_TRUE(IsRtcpMuxEnabled(channel1_)); + EXPECT_TRUE(IsRtcpMuxEnabled(channel2_)); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + } + + void TestDeinit() { + CreateChannels(0, 0); + EXPECT_TRUE(SendInitiate()); + EXPECT_TRUE(SendAccept()); + SendRtp1(); + SendRtp2(); + + DeinitChannels(); + + // Do not wait, destroy channels. + channel1_.reset(nullptr); + channel2_.reset(nullptr); + } + + void SendDtlsSrtpToDtlsSrtp(int flags1, int flags2) { + CreateChannels(flags1 | DTLS, flags2 | DTLS); + EXPECT_FALSE(IsSrtpActive(channel1_)); + EXPECT_FALSE(IsSrtpActive(channel2_)); + EXPECT_TRUE(SendInitiate()); + WaitForThreads(); + EXPECT_TRUE(SendAccept()); + EXPECT_TRUE(IsSrtpActive(channel1_)); + EXPECT_TRUE(IsSrtpActive(channel2_)); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + } + + // Test that we can send and receive early media when a provisional answer is + // sent and received. The test uses SRTP, RTCP mux and SSRC mux. + void SendEarlyMediaUsingRtcpMuxSrtp() { + int sequence_number1_1 = 0, sequence_number2_2 = 0; + + CreateChannels(SSRC_MUX | RTCP_MUX | DTLS, SSRC_MUX | RTCP_MUX | DTLS); + EXPECT_TRUE(SendOffer()); + EXPECT_TRUE(SendProvisionalAnswer()); + EXPECT_TRUE(IsSrtpActive(channel1_)); + EXPECT_TRUE(IsSrtpActive(channel2_)); + EXPECT_TRUE(IsRtcpMuxEnabled(channel1_)); + EXPECT_TRUE(IsRtcpMuxEnabled(channel2_)); + WaitForThreads(); // Wait for 'sending' flag go through network thread. + SendCustomRtp1(kSsrc1, ++sequence_number1_1); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1)); + + // Send packets from callee and verify that it is received. + SendCustomRtp2(kSsrc2, ++sequence_number2_2); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2)); + + // Complete call setup and ensure everything is still OK. + EXPECT_TRUE(SendFinalAnswer()); + EXPECT_TRUE(IsSrtpActive(channel1_)); + EXPECT_TRUE(IsSrtpActive(channel2_)); + SendCustomRtp1(kSsrc1, ++sequence_number1_1); + SendCustomRtp2(kSsrc2, ++sequence_number2_2); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1)); + EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2)); + } + + // Test that we properly send RTP without SRTP from a thread. + void SendRtpToRtpOnThread() { + CreateChannels(0, 0); + EXPECT_TRUE(SendInitiate()); + EXPECT_TRUE(SendAccept()); + ScopedCallThread send_rtp1([this] { SendRtp1(); }); + ScopedCallThread send_rtp2([this] { SendRtp2(); }); + rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread()}; + WaitForThreads(involved_threads); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + } + + // Test that the mediachannel retains its sending state after the transport + // becomes non-writable. + void SendWithWritabilityLoss() { + CreateChannels(RTCP_MUX, RTCP_MUX); + EXPECT_TRUE(SendInitiate()); + EXPECT_TRUE(SendAccept()); + EXPECT_TRUE(IsRtcpMuxEnabled(channel1_)); + EXPECT_TRUE(IsRtcpMuxEnabled(channel2_)); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + + // Lose writability, which should fail. + SendTask(network_thread_, + [this] { fake_rtp_dtls_transport1_->SetWritable(false); }); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + + // Regain writability + SendTask(network_thread_, + [this] { fake_rtp_dtls_transport1_->SetWritable(true); }); + EXPECT_TRUE(media_channel1()->sending()); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + + // Lose writability completely + SendTask(network_thread_, [this] { + bool asymmetric = true; + fake_rtp_dtls_transport1_->SetDestination(nullptr, asymmetric); + }); + EXPECT_TRUE(media_channel1()->sending()); + + // Should fail also. + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + + // Gain writability back + SendTask(network_thread_, [this] { + bool asymmetric = true; + fake_rtp_dtls_transport1_->SetDestination(fake_rtp_dtls_transport2_.get(), + asymmetric); + }); + EXPECT_TRUE(media_channel1()->sending()); + SendRtp1(); + SendRtp2(); + WaitForThreads(); + EXPECT_TRUE(CheckRtp1()); + EXPECT_TRUE(CheckRtp2()); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + } + + void SendBundleToBundle(const int* pl_types, + int len, + bool rtcp_mux, + bool secure) { + ASSERT_EQ(2, len); + int sequence_number1_1 = 0, sequence_number2_2 = 0; + // Only pl_type1 was added to the bundle filter for both `channel1_` + // and `channel2_`. + int pl_type1 = pl_types[0]; + int pl_type2 = pl_types[1]; + int flags = SSRC_MUX; + if (secure) + flags |= DTLS; + if (rtcp_mux) { + flags |= RTCP_MUX; + } + CreateChannels(flags, flags); + EXPECT_TRUE(SendInitiate()); + EXPECT_TRUE(SendAccept()); + + // Both channels can receive pl_type1 only. + SendCustomRtp1(kSsrc1, ++sequence_number1_1, pl_type1); + SendCustomRtp2(kSsrc2, ++sequence_number2_2, pl_type1); + WaitForThreads(); + EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1, pl_type1)); + EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2, pl_type1)); + EXPECT_TRUE(CheckNoRtp1()); + EXPECT_TRUE(CheckNoRtp2()); + + SendCustomRtp1(kSsrc3, ++sequence_number1_1, pl_type2); + SendCustomRtp2(kSsrc4, ++sequence_number2_2, pl_type2); + WaitForThreads(); + EXPECT_FALSE(CheckCustomRtp2(kSsrc3, sequence_number1_1, pl_type2)); + EXPECT_FALSE(CheckCustomRtp1(kSsrc4, sequence_number2_2, pl_type2)); + } + + void TestSetContentFailure() { + CreateChannels(0, 0); + + std::string err; + std::unique_ptr<typename T::Content> content( + CreateMediaContentWithStream(1)); + + media_channel1()->set_fail_set_recv_codecs(true); + EXPECT_FALSE( + channel1_->SetLocalContent(content.get(), SdpType::kOffer, err)); + EXPECT_FALSE( + channel1_->SetLocalContent(content.get(), SdpType::kAnswer, err)); + + media_channel1()->set_fail_set_send_codecs(true); + EXPECT_FALSE( + channel1_->SetRemoteContent(content.get(), SdpType::kOffer, err)); + + media_channel1()->set_fail_set_send_codecs(true); + EXPECT_FALSE( + channel1_->SetRemoteContent(content.get(), SdpType::kAnswer, err)); + } + + void TestSendTwoOffers() { + CreateChannels(0, 0); + + std::string err; + std::unique_ptr<typename T::Content> content1( + CreateMediaContentWithStream(1)); + EXPECT_TRUE( + channel1_->SetLocalContent(content1.get(), SdpType::kOffer, err)); + EXPECT_TRUE(media_channel1()->HasSendStream(1)); + + std::unique_ptr<typename T::Content> content2( + CreateMediaContentWithStream(2)); + EXPECT_TRUE( + channel1_->SetLocalContent(content2.get(), SdpType::kOffer, err)); + EXPECT_FALSE(media_channel1()->HasSendStream(1)); + EXPECT_TRUE(media_channel1()->HasSendStream(2)); + } + + void TestReceiveTwoOffers() { + CreateChannels(0, 0); + + std::string err; + std::unique_ptr<typename T::Content> content1( + CreateMediaContentWithStream(1)); + EXPECT_TRUE( + channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, err)); + EXPECT_TRUE(media_channel1()->HasRecvStream(1)); + + std::unique_ptr<typename T::Content> content2( + CreateMediaContentWithStream(2)); + EXPECT_TRUE( + channel1_->SetRemoteContent(content2.get(), SdpType::kOffer, err)); + EXPECT_FALSE(media_channel1()->HasRecvStream(1)); + EXPECT_TRUE(media_channel1()->HasRecvStream(2)); + } + + void TestSendPrAnswer() { + CreateChannels(0, 0); + + std::string err; + // Receive offer + std::unique_ptr<typename T::Content> content1( + CreateMediaContentWithStream(1)); + EXPECT_TRUE( + channel1_->SetRemoteContent(content1.get(), SdpType::kOffer, err)); + EXPECT_TRUE(media_channel1()->HasRecvStream(1)); + + // Send PR answer + std::unique_ptr<typename T::Content> content2( + CreateMediaContentWithStream(2)); + EXPECT_TRUE( + channel1_->SetLocalContent(content2.get(), SdpType::kPrAnswer, err)); + EXPECT_TRUE(media_channel1()->HasRecvStream(1)); + EXPECT_TRUE(media_channel1()->HasSendStream(2)); + + // Send answer + std::unique_ptr<typename T::Content> content3( + CreateMediaContentWithStream(3)); + EXPECT_TRUE( + channel1_->SetLocalContent(content3.get(), SdpType::kAnswer, err)); + EXPECT_TRUE(media_channel1()->HasRecvStream(1)); + EXPECT_FALSE(media_channel1()->HasSendStream(2)); + EXPECT_TRUE(media_channel1()->HasSendStream(3)); + } + + void TestReceivePrAnswer() { + CreateChannels(0, 0); + + std::string err; + // Send offer + std::unique_ptr<typename T::Content> content1( + CreateMediaContentWithStream(1)); + EXPECT_TRUE( + channel1_->SetLocalContent(content1.get(), SdpType::kOffer, err)); + EXPECT_TRUE(media_channel1()->HasSendStream(1)); + + // Receive PR answer + std::unique_ptr<typename T::Content> content2( + CreateMediaContentWithStream(2)); + EXPECT_TRUE( + channel1_->SetRemoteContent(content2.get(), SdpType::kPrAnswer, err)); + EXPECT_TRUE(media_channel1()->HasSendStream(1)); + EXPECT_TRUE(media_channel1()->HasRecvStream(2)); + + // Receive answer + std::unique_ptr<typename T::Content> content3( + CreateMediaContentWithStream(3)); + EXPECT_TRUE( + channel1_->SetRemoteContent(content3.get(), SdpType::kAnswer, err)); + EXPECT_TRUE(media_channel1()->HasSendStream(1)); + EXPECT_FALSE(media_channel1()->HasRecvStream(2)); + EXPECT_TRUE(media_channel1()->HasRecvStream(3)); + } + + void TestOnTransportReadyToSend() { + CreateChannels(0, 0); + EXPECT_FALSE(media_channel1()->ready_to_send()); + + network_thread_->PostTask( + [this] { channel1_->OnTransportReadyToSend(true); }); + WaitForThreads(); + EXPECT_TRUE(media_channel1()->ready_to_send()); + + network_thread_->PostTask( + [this] { channel1_->OnTransportReadyToSend(false); }); + WaitForThreads(); + EXPECT_FALSE(media_channel1()->ready_to_send()); + } + + bool SetRemoteContentWithBitrateLimit(int remote_limit) { + typename T::Content content; + CreateContent(0, kPcmuCodec, kH264Codec, &content); + content.set_bandwidth(remote_limit); + return channel1_->SetRemoteContent(&content, SdpType::kOffer, NULL); + } + + webrtc::RtpParameters BitrateLimitedParameters(absl::optional<int> limit) { + webrtc::RtpParameters parameters; + webrtc::RtpEncodingParameters encoding; + encoding.max_bitrate_bps = limit; + parameters.encodings.push_back(encoding); + return parameters; + } + + void VerifyMaxBitrate(const webrtc::RtpParameters& parameters, + absl::optional<int> expected_bitrate) { + EXPECT_EQ(1UL, parameters.encodings.size()); + EXPECT_EQ(expected_bitrate, parameters.encodings[0].max_bitrate_bps); + } + + void DefaultMaxBitrateIsUnlimited() { + CreateChannels(0, 0); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&local_media_content1_, + SdpType::kOffer, err)); + EXPECT_EQ(media_channel1()->max_bps(), -1); + VerifyMaxBitrate(media_send_channel1()->GetRtpSendParameters(kSsrc1), + absl::nullopt); + } + + // Test that when a channel gets new RtpTransport with a call to + // `SetRtpTransport`, the socket options from the old RtpTransport is merged + // with the options on the new one. + + // For example, audio and video may use separate socket options, but initially + // be unbundled, then later become bundled. When this happens, their preferred + // socket options should be merged to the underlying transport they share. + void SocketOptionsMergedOnSetTransport() { + constexpr int kSndBufSize = 4000; + constexpr int kRcvBufSize = 8000; + + CreateChannels(DTLS, DTLS); + + new_rtp_transport_ = CreateDtlsSrtpTransport( + fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get()); + + bool rcv_success, send_success; + int rcv_buf, send_buf; + SendTask(network_thread_, [&] { + channel1_->SetOption(cricket::BaseChannel::ST_RTP, + rtc::Socket::Option::OPT_SNDBUF, kSndBufSize); + channel2_->SetOption(cricket::BaseChannel::ST_RTP, + rtc::Socket::Option::OPT_RCVBUF, kRcvBufSize); + channel1_->SetRtpTransport(new_rtp_transport_.get()); + send_success = fake_rtp_dtls_transport2_->GetOption( + rtc::Socket::Option::OPT_SNDBUF, &send_buf); + rcv_success = fake_rtp_dtls_transport2_->GetOption( + rtc::Socket::Option::OPT_RCVBUF, &rcv_buf); + }); + + ASSERT_TRUE(send_success); + EXPECT_EQ(kSndBufSize, send_buf); + ASSERT_TRUE(rcv_success); + EXPECT_EQ(kRcvBufSize, rcv_buf); + } + + void CreateSimulcastContent(const std::vector<std::string>& rids, + typename T::Content* content) { + std::vector<RidDescription> rid_descriptions; + for (const std::string& name : rids) { + rid_descriptions.push_back(RidDescription(name, RidDirection::kSend)); + } + + StreamParams stream; + stream.set_rids(rid_descriptions); + CreateContent(0, kPcmuCodec, kH264Codec, content); + // This is for unified plan, so there can be only one StreamParams. + content->mutable_streams().clear(); + content->AddStream(stream); + } + + void VerifySimulcastStreamParams(const StreamParams& expected, + const typename T::Channel* channel) { + const std::vector<StreamParams>& streams = channel->local_streams(); + ASSERT_EQ(1u, streams.size()); + const StreamParams& result = streams[0]; + EXPECT_EQ(expected.rids(), result.rids()); + EXPECT_TRUE(result.has_ssrcs()); + EXPECT_EQ(expected.rids().size() * 2, result.ssrcs.size()); + std::vector<uint32_t> primary_ssrcs; + result.GetPrimarySsrcs(&primary_ssrcs); + EXPECT_EQ(expected.rids().size(), primary_ssrcs.size()); + } + + void TestUpdateLocalStreamsWithSimulcast() { + CreateChannels(0, 0); + typename T::Content content1, content2, content3; + CreateSimulcastContent({"f", "h", "q"}, &content1); + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&content1, SdpType::kOffer, err)); + VerifySimulcastStreamParams(content1.streams()[0], channel1_.get()); + StreamParams stream1 = channel1_->local_streams()[0]; + + // Create a similar offer. SetLocalContent should not remove and add. + CreateSimulcastContent({"f", "h", "q"}, &content2); + EXPECT_TRUE(channel1_->SetLocalContent(&content2, SdpType::kOffer, err)); + VerifySimulcastStreamParams(content2.streams()[0], channel1_.get()); + StreamParams stream2 = channel1_->local_streams()[0]; + // Check that the streams are identical (SSRCs didn't change). + EXPECT_EQ(stream1, stream2); + + // Create third offer that has same RIDs in different order. + CreateSimulcastContent({"f", "q", "h"}, &content3); + EXPECT_TRUE(channel1_->SetLocalContent(&content3, SdpType::kOffer, err)); + VerifySimulcastStreamParams(content3.streams()[0], channel1_.get()); + } + + protected: + void WaitForThreads() { WaitForThreads(rtc::ArrayView<rtc::Thread*>()); } + static void ProcessThreadQueue(rtc::Thread* thread) { + RTC_DCHECK(thread->IsCurrent()); + while (!thread->empty()) { + thread->ProcessMessages(0); + } + } + static void FlushCurrentThread() { + rtc::Thread::Current()->ProcessMessages(0); + } + void WaitForThreads(rtc::ArrayView<rtc::Thread*> threads) { + // `threads` and current thread post packets to network thread. + for (rtc::Thread* thread : threads) { + SendTask(thread, [thread] { ProcessThreadQueue(thread); }); + } + ProcessThreadQueue(rtc::Thread::Current()); + // Network thread move them around and post back to worker = current thread. + if (!network_thread_->IsCurrent()) { + SendTask(network_thread_, + [this] { ProcessThreadQueue(network_thread_); }); + } + // Worker thread = current Thread process received messages. + ProcessThreadQueue(rtc::Thread::Current()); + } + + // Accessors that return the FakeMedia<type>Channel object. + // Note that these depend on getting the object back that was + // passed to the channel constructor. + typename T::MediaChannel* media_channel1() { + RTC_DCHECK(channel1_); + RTC_DCHECK(channel1_->media_channel()); + return static_cast<typename T::MediaChannel*>(channel1_->media_channel()); + } + + typename T::MediaChannel* media_channel2() { + RTC_DCHECK(channel2_); + RTC_DCHECK(channel2_->media_channel()); + return static_cast<typename T::MediaChannel*>(channel2_->media_channel()); + } + + typename T::MediaSendChannel* media_send_channel1() { + RTC_DCHECK(channel1_); + RTC_DCHECK(channel1_->media_send_channel()); + return channel1_->media_send_channel(); + } + + typename T::MediaSendChannel* media_send_channel2() { + RTC_DCHECK(channel2_); + RTC_DCHECK(channel2_->media_send_channel()); + return channel2_->media_send_channel(); + } + + rtc::AutoThread main_thread_; + // TODO(pbos): Remove playout from all media channels and let renderers mute + // themselves. + const bool verify_playout_; + rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> network_thread_safety_ = + webrtc::PendingTaskSafetyFlag::CreateDetached(); + std::unique_ptr<rtc::Thread> network_thread_keeper_; + rtc::Thread* network_thread_; + std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport1_; + std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport1_; + std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport2_; + std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport2_; + std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport1_; + std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport1_; + std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport2_; + std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport2_; + std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport1_; + std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport2_; + std::unique_ptr<webrtc::RtpTransportInternal> new_rtp_transport_; + cricket::FakeMediaEngine media_engine_; + std::unique_ptr<typename T::Channel> channel1_; + std::unique_ptr<typename T::Channel> channel2_; + typename T::Content local_media_content1_; + typename T::Content local_media_content2_; + typename T::Content remote_media_content1_; + typename T::Content remote_media_content2_; + // The RTP and RTCP packets to send in the tests. + rtc::Buffer rtp_packet_; + rtc::Buffer rtcp_packet_; + cricket::CandidatePairInterface* last_selected_candidate_pair_; + rtc::UniqueRandomIdGenerator ssrc_generator_; + webrtc::test::ScopedKeyValueConfig field_trials_; +}; + +template <> +std::unique_ptr<cricket::VoiceChannel> ChannelTest<VoiceTraits>::CreateChannel( + rtc::Thread* worker_thread, + rtc::Thread* network_thread, + std::unique_ptr<cricket::FakeVoiceMediaChannel> ch, + webrtc::RtpTransportInternal* rtp_transport, + int flags) { + rtc::Thread* signaling_thread = rtc::Thread::Current(); + auto channel = std::make_unique<cricket::VoiceChannel>( + worker_thread, network_thread, signaling_thread, std::move(ch), + cricket::CN_AUDIO, (flags & DTLS) != 0, webrtc::CryptoOptions(), + &ssrc_generator_); + SendTask(network_thread, [&]() { + RTC_DCHECK_RUN_ON(channel->network_thread()); + channel->SetRtpTransport(rtp_transport); + }); + return channel; +} + +template <> +void ChannelTest<VoiceTraits>::CreateContent( + int flags, + const cricket::AudioCodec& audio_codec, + const cricket::VideoCodec& video_codec, + cricket::AudioContentDescription* audio) { + audio->AddCodec(audio_codec); + audio->set_rtcp_mux((flags & RTCP_MUX) != 0); +} + +template <> +void ChannelTest<VoiceTraits>::CopyContent( + const cricket::AudioContentDescription& source, + cricket::AudioContentDescription* audio) { + *audio = source; +} + +template <> +bool ChannelTest<VoiceTraits>::CodecMatches(const cricket::AudioCodec& c1, + const cricket::AudioCodec& c2) { + return c1.name == c2.name && c1.clockrate == c2.clockrate && + c1.bitrate == c2.bitrate && c1.channels == c2.channels; +} + +template <> +void ChannelTest<VoiceTraits>::AddLegacyStreamInContent( + uint32_t ssrc, + int flags, + cricket::AudioContentDescription* audio) { + audio->AddLegacyStream(ssrc); +} + +class VoiceChannelSingleThreadTest : public ChannelTest<VoiceTraits> { + public: + typedef ChannelTest<VoiceTraits> Base; + VoiceChannelSingleThreadTest() + : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::Yes) {} +}; + +class VoiceChannelDoubleThreadTest : public ChannelTest<VoiceTraits> { + public: + typedef ChannelTest<VoiceTraits> Base; + VoiceChannelDoubleThreadTest() + : Base(true, kPcmuFrame, kRtcpReport, NetworkIsWorker::No) {} +}; + +class VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest + : public ChannelTest<VoiceTraits> { + public: + typedef ChannelTest<VoiceTraits> Base; + VoiceChannelWithEncryptedRtpHeaderExtensionsSingleThreadTest() + : Base(true, + kPcmuFrameWithExtensions, + kRtcpReport, + NetworkIsWorker::Yes) {} +}; + +class VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest + : public ChannelTest<VoiceTraits> { + public: + typedef ChannelTest<VoiceTraits> Base; + VoiceChannelWithEncryptedRtpHeaderExtensionsDoubleThreadTest() + : Base(true, kPcmuFrameWithExtensions, kRtcpReport, NetworkIsWorker::No) { + } +}; + +// override to add NULL parameter +template <> +std::unique_ptr<cricket::VideoChannel> ChannelTest<VideoTraits>::CreateChannel( + rtc::Thread* worker_thread, + rtc::Thread* network_thread, + std::unique_ptr<cricket::FakeVideoMediaChannel> ch, + webrtc::RtpTransportInternal* rtp_transport, + int flags) { + rtc::Thread* signaling_thread = rtc::Thread::Current(); + auto channel = std::make_unique<cricket::VideoChannel>( + worker_thread, network_thread, signaling_thread, std::move(ch), + cricket::CN_VIDEO, (flags & DTLS) != 0, webrtc::CryptoOptions(), + &ssrc_generator_); + SendTask(network_thread, [&]() { + RTC_DCHECK_RUN_ON(channel->network_thread()); + channel->SetRtpTransport(rtp_transport); + }); + return channel; +} + +template <> +void ChannelTest<VideoTraits>::CreateContent( + int flags, + const cricket::AudioCodec& audio_codec, + const cricket::VideoCodec& video_codec, + cricket::VideoContentDescription* video) { + video->AddCodec(video_codec); + video->set_rtcp_mux((flags & RTCP_MUX) != 0); +} + +template <> +void ChannelTest<VideoTraits>::CopyContent( + const cricket::VideoContentDescription& source, + cricket::VideoContentDescription* video) { + *video = source; +} + +template <> +bool ChannelTest<VideoTraits>::CodecMatches(const cricket::VideoCodec& c1, + const cricket::VideoCodec& c2) { + return c1.name == c2.name; +} + +template <> +void ChannelTest<VideoTraits>::AddLegacyStreamInContent( + uint32_t ssrc, + int flags, + cricket::VideoContentDescription* video) { + video->AddLegacyStream(ssrc); +} + +class VideoChannelSingleThreadTest : public ChannelTest<VideoTraits> { + public: + typedef ChannelTest<VideoTraits> Base; + VideoChannelSingleThreadTest() + : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::Yes) {} +}; + +class VideoChannelDoubleThreadTest : public ChannelTest<VideoTraits> { + public: + typedef ChannelTest<VideoTraits> Base; + VideoChannelDoubleThreadTest() + : Base(false, kH264Packet, kRtcpReport, NetworkIsWorker::No) {} +}; + +TEST_F(VoiceChannelSingleThreadTest, TestInit) { + Base::TestInit(); + EXPECT_FALSE(media_channel1()->IsStreamMuted(0)); + EXPECT_TRUE(media_channel1()->dtmf_info_queue().empty()); +} + +TEST_F(VoiceChannelSingleThreadTest, TestDeinit) { + Base::TestDeinit(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContents) { + Base::TestSetContents(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VoiceChannelSingleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VoiceChannelSingleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentsNullOffer) { + Base::TestSetContentsNullOffer(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMux) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestChangeStreamParamsInContent) { + Base::TestChangeStreamParamsInContent(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestPlayoutAndSendingStates) { + Base::TestPlayoutAndSendingStates(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestMediaContentDirection) { + Base::TestMediaContentDirection(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestNetworkRouteChanges) { + Base::TestNetworkRouteChanges(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestCallSetup) { + Base::TestCallSetup(); +} + +TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtp) { + Base::SendRtpToRtp(); +} + +TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) { + Base::SendDtlsSrtpToDtlsSrtp(0, 0); +} + +TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) { + Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX); +} + +TEST_F(VoiceChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) { + Base::SendEarlyMediaUsingRtcpMuxSrtp(); +} + +TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtpOnThread) { + Base::SendRtpToRtpOnThread(); +} + +TEST_F(VoiceChannelSingleThreadTest, SendWithWritabilityLoss) { + Base::SendWithWritabilityLoss(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSetContentFailure) { + Base::TestSetContentFailure(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSendTwoOffers) { + Base::TestSendTwoOffers(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestReceiveTwoOffers) { + Base::TestReceiveTwoOffers(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestSendPrAnswer) { + Base::TestSendPrAnswer(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestReceivePrAnswer) { + Base::TestReceivePrAnswer(); +} + +TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSend) { + Base::TestOnTransportReadyToSend(); +} + +TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundle) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false); +} + +TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleSecure) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true); +} + +TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false); +} + +TEST_F(VoiceChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true); +} + +TEST_F(VoiceChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) { + Base::DefaultMaxBitrateIsUnlimited(); +} + +TEST_F(VoiceChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) { + Base::SocketOptionsMergedOnSetTransport(); +} + +// VoiceChannelDoubleThreadTest +TEST_F(VoiceChannelDoubleThreadTest, TestInit) { + Base::TestInit(); + EXPECT_FALSE(media_channel1()->IsStreamMuted(0)); + EXPECT_TRUE(media_channel1()->dtmf_info_queue().empty()); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestDeinit) { + Base::TestDeinit(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContents) { + Base::TestSetContents(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VoiceChannelDoubleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VoiceChannelDoubleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsNullOffer) { + Base::TestSetContentsNullOffer(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMux) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestChangeStreamParamsInContent) { + Base::TestChangeStreamParamsInContent(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestPlayoutAndSendingStates) { + Base::TestPlayoutAndSendingStates(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestMediaContentDirection) { + Base::TestMediaContentDirection(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestNetworkRouteChanges) { + Base::TestNetworkRouteChanges(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestCallSetup) { + Base::TestCallSetup(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtp) { + Base::SendRtpToRtp(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) { + Base::SendDtlsSrtpToDtlsSrtp(0, 0); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) { + Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) { + Base::SendEarlyMediaUsingRtcpMuxSrtp(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtpOnThread) { + Base::SendRtpToRtpOnThread(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendWithWritabilityLoss) { + Base::SendWithWritabilityLoss(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSetContentFailure) { + Base::TestSetContentFailure(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSendTwoOffers) { + Base::TestSendTwoOffers(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestReceiveTwoOffers) { + Base::TestReceiveTwoOffers(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestSendPrAnswer) { + Base::TestSendPrAnswer(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestReceivePrAnswer) { + Base::TestReceivePrAnswer(); +} + +TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSend) { + Base::TestOnTransportReadyToSend(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundle) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, false); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleSecure) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), false, true); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, false); +} + +TEST_F(VoiceChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) { + Base::SendBundleToBundle(kAudioPts, arraysize(kAudioPts), true, true); +} + +TEST_F(VoiceChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) { + Base::DefaultMaxBitrateIsUnlimited(); +} + +TEST_F(VoiceChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) { + Base::SocketOptionsMergedOnSetTransport(); +} + +// VideoChannelSingleThreadTest +TEST_F(VideoChannelSingleThreadTest, TestInit) { + Base::TestInit(); +} + +TEST_F(VideoChannelSingleThreadTest, TestDeinit) { + Base::TestDeinit(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContents) { + Base::TestSetContents(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VideoChannelSingleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VideoChannelSingleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentsNullOffer) { + Base::TestSetContentsNullOffer(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMux) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VideoChannelSingleThreadTest, TestChangeStreamParamsInContent) { + Base::TestChangeStreamParamsInContent(); +} + +TEST_F(VideoChannelSingleThreadTest, TestPlayoutAndSendingStates) { + Base::TestPlayoutAndSendingStates(); +} + +TEST_F(VideoChannelSingleThreadTest, TestMediaContentDirection) { + Base::TestMediaContentDirection(); +} + +TEST_F(VideoChannelSingleThreadTest, TestNetworkRouteChanges) { + Base::TestNetworkRouteChanges(); +} + +TEST_F(VideoChannelSingleThreadTest, TestCallSetup) { + Base::TestCallSetup(); +} + +TEST_F(VideoChannelSingleThreadTest, SendRtpToRtp) { + Base::SendRtpToRtp(); +} + +TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) { + Base::SendDtlsSrtpToDtlsSrtp(0, 0); +} + +TEST_F(VideoChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) { + Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX); +} + +TEST_F(VideoChannelSingleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) { + Base::SendEarlyMediaUsingRtcpMuxSrtp(); +} + +TEST_F(VideoChannelSingleThreadTest, SendRtpToRtpOnThread) { + Base::SendRtpToRtpOnThread(); +} + +TEST_F(VideoChannelSingleThreadTest, SendWithWritabilityLoss) { + Base::SendWithWritabilityLoss(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetContentFailure) { + Base::TestSetContentFailure(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSendTwoOffers) { + Base::TestSendTwoOffers(); +} + +TEST_F(VideoChannelSingleThreadTest, TestReceiveTwoOffers) { + Base::TestReceiveTwoOffers(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSendPrAnswer) { + Base::TestSendPrAnswer(); +} + +TEST_F(VideoChannelSingleThreadTest, TestReceivePrAnswer) { + Base::TestReceivePrAnswer(); +} + +TEST_F(VideoChannelSingleThreadTest, SendBundleToBundle) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false); +} + +TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleSecure) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true); +} + +TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false); +} + +TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true); +} + +TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSend) { + Base::TestOnTransportReadyToSend(); +} + +TEST_F(VideoChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) { + Base::DefaultMaxBitrateIsUnlimited(); +} + +TEST_F(VideoChannelSingleThreadTest, SocketOptionsMergedOnSetTransport) { + Base::SocketOptionsMergedOnSetTransport(); +} + +TEST_F(VideoChannelSingleThreadTest, UpdateLocalStreamsWithSimulcast) { + Base::TestUpdateLocalStreamsWithSimulcast(); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetLocalOfferWithPacketization) { + const cricket::VideoCodec kVp8Codec(97, "VP8"); + cricket::VideoCodec vp9_codec(98, "VP9"); + vp9_codec.packetization = cricket::kPacketizationParamRaw; + cricket::VideoContentDescription video; + video.set_codecs({kVp8Codec, vp9_codec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, err)); + EXPECT_THAT(media_channel1()->send_codecs(), testing::IsEmpty()); + ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2)); + EXPECT_TRUE( + media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_)); + EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt); + EXPECT_TRUE( + media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_)); + EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization, + cricket::kPacketizationParamRaw); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetRemoteOfferWithPacketization) { + const cricket::VideoCodec kVp8Codec(97, "VP8"); + cricket::VideoCodec vp9_codec(98, "VP9"); + vp9_codec.packetization = cricket::kPacketizationParamRaw; + cricket::VideoContentDescription video; + video.set_codecs({kVp8Codec, vp9_codec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kOffer, err)); + EXPECT_TRUE(err.empty()); + EXPECT_THAT(media_channel1()->recv_codecs(), testing::IsEmpty()); + ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2)); + EXPECT_TRUE( + media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_)); + EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt); + EXPECT_TRUE( + media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_)); + EXPECT_EQ(media_channel1()->send_codecs()[1].packetization, + cricket::kPacketizationParamRaw); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetAnswerWithPacketization) { + const cricket::VideoCodec kVp8Codec(97, "VP8"); + cricket::VideoCodec vp9_codec(98, "VP9"); + vp9_codec.packetization = cricket::kPacketizationParamRaw; + cricket::VideoContentDescription video; + video.set_codecs({kVp8Codec, vp9_codec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&video, SdpType::kOffer, err)); + EXPECT_TRUE(err.empty()); + EXPECT_TRUE(channel1_->SetRemoteContent(&video, SdpType::kAnswer, err)); + EXPECT_TRUE(err.empty()); + ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(2)); + EXPECT_TRUE( + media_channel1()->recv_codecs()[0].Matches(kVp8Codec, &field_trials_)); + EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt); + EXPECT_TRUE( + media_channel1()->recv_codecs()[1].Matches(vp9_codec, &field_trials_)); + EXPECT_EQ(media_channel1()->recv_codecs()[1].packetization, + cricket::kPacketizationParamRaw); + EXPECT_THAT(media_channel1()->send_codecs(), testing::SizeIs(2)); + EXPECT_TRUE( + media_channel1()->send_codecs()[0].Matches(kVp8Codec, &field_trials_)); + EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt); + EXPECT_TRUE( + media_channel1()->send_codecs()[1].Matches(vp9_codec, &field_trials_)); + EXPECT_EQ(media_channel1()->send_codecs()[1].packetization, + cricket::kPacketizationParamRaw); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetLocalAnswerWithoutPacketization) { + const cricket::VideoCodec kLocalCodec(98, "VP8"); + cricket::VideoCodec remote_codec(99, "VP8"); + remote_codec.packetization = cricket::kPacketizationParamRaw; + cricket::VideoContentDescription local_video; + local_video.set_codecs({kLocalCodec}); + cricket::VideoContentDescription remote_video; + remote_video.set_codecs({remote_codec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetRemoteContent(&remote_video, SdpType::kOffer, err)); + EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kAnswer, err)); + ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt); + ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt); +} + +TEST_F(VideoChannelSingleThreadTest, TestSetRemoteAnswerWithoutPacketization) { + cricket::VideoCodec local_codec(98, "VP8"); + local_codec.packetization = cricket::kPacketizationParamRaw; + const cricket::VideoCodec kRemoteCodec(99, "VP8"); + cricket::VideoContentDescription local_video; + local_video.set_codecs({local_codec}); + cricket::VideoContentDescription remote_video; + remote_video.set_codecs({kRemoteCodec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kOffer, err)); + EXPECT_TRUE( + channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, err)); + ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, absl::nullopt); + ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt); +} + +TEST_F(VideoChannelSingleThreadTest, + TestSetRemoteAnswerWithInvalidPacketization) { + cricket::VideoCodec local_codec(98, "VP8"); + local_codec.packetization = cricket::kPacketizationParamRaw; + cricket::VideoCodec remote_codec(99, "VP8"); + remote_codec.packetization = "unknownpacketizationattributevalue"; + cricket::VideoContentDescription local_video; + local_video.set_codecs({local_codec}); + cricket::VideoContentDescription remote_video; + remote_video.set_codecs({remote_codec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetLocalContent(&local_video, SdpType::kOffer, err)); + EXPECT_TRUE(err.empty()); + EXPECT_FALSE( + channel1_->SetRemoteContent(&remote_video, SdpType::kAnswer, err)); + EXPECT_FALSE(err.empty()); + ASSERT_THAT(media_channel1()->recv_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->recv_codecs()[0].packetization, + cricket::kPacketizationParamRaw); + EXPECT_THAT(media_channel1()->send_codecs(), testing::IsEmpty()); +} + +TEST_F(VideoChannelSingleThreadTest, + TestSetLocalAnswerWithInvalidPacketization) { + cricket::VideoCodec local_codec(98, "VP8"); + local_codec.packetization = cricket::kPacketizationParamRaw; + const cricket::VideoCodec kRemoteCodec(99, "VP8"); + cricket::VideoContentDescription local_video; + local_video.set_codecs({local_codec}); + cricket::VideoContentDescription remote_video; + remote_video.set_codecs({kRemoteCodec}); + + CreateChannels(0, 0); + + std::string err; + EXPECT_TRUE(channel1_->SetRemoteContent(&remote_video, SdpType::kOffer, err)); + EXPECT_TRUE(err.empty()); + EXPECT_FALSE(channel1_->SetLocalContent(&local_video, SdpType::kAnswer, err)); + EXPECT_FALSE(err.empty()); + EXPECT_THAT(media_channel1()->recv_codecs(), testing::IsEmpty()); + ASSERT_THAT(media_channel1()->send_codecs(), testing::SizeIs(1)); + EXPECT_EQ(media_channel1()->send_codecs()[0].packetization, absl::nullopt); +} + +// VideoChannelDoubleThreadTest +TEST_F(VideoChannelDoubleThreadTest, TestInit) { + Base::TestInit(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestDeinit) { + Base::TestDeinit(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContents) { + Base::TestSetContents(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VideoChannelDoubleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCaller) { + Base::TestSetContentsExtmapAllowMixedCaller(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentsExtmapAllowMixedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/true); +} + +TEST_F(VideoChannelDoubleThreadTest, + TestSetContentsExtmapAllowMixedNotSupportedAsCallee) { + Base::TestSetContentsExtmapAllowMixedCallee(/*offer=*/true, /*answer=*/false); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentsNullOffer) { + Base::TestSetContentsNullOffer(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMux) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentsRtcpMuxWithPrAnswer) { + Base::TestSetContentsRtcpMux(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestChangeStreamParamsInContent) { + Base::TestChangeStreamParamsInContent(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestPlayoutAndSendingStates) { + Base::TestPlayoutAndSendingStates(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestMediaContentDirection) { + Base::TestMediaContentDirection(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestNetworkRouteChanges) { + Base::TestNetworkRouteChanges(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestCallSetup) { + Base::TestCallSetup(); +} + +TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtp) { + Base::SendRtpToRtp(); +} + +TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) { + Base::SendDtlsSrtpToDtlsSrtp(0, 0); +} + +TEST_F(VideoChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) { + Base::SendDtlsSrtpToDtlsSrtp(RTCP_MUX, RTCP_MUX); +} + +TEST_F(VideoChannelDoubleThreadTest, SendEarlyMediaUsingRtcpMuxSrtp) { + Base::SendEarlyMediaUsingRtcpMuxSrtp(); +} + +TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtpOnThread) { + Base::SendRtpToRtpOnThread(); +} + +TEST_F(VideoChannelDoubleThreadTest, SendWithWritabilityLoss) { + Base::SendWithWritabilityLoss(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSetContentFailure) { + Base::TestSetContentFailure(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSendTwoOffers) { + Base::TestSendTwoOffers(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestReceiveTwoOffers) { + Base::TestReceiveTwoOffers(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestSendPrAnswer) { + Base::TestSendPrAnswer(); +} + +TEST_F(VideoChannelDoubleThreadTest, TestReceivePrAnswer) { + Base::TestReceivePrAnswer(); +} + +TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundle) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, false); +} + +TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleSecure) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), false, true); +} + +TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false); +} + +TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) { + Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true); +} + +TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSend) { + Base::TestOnTransportReadyToSend(); +} + +TEST_F(VideoChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) { + Base::DefaultMaxBitrateIsUnlimited(); +} + +TEST_F(VideoChannelDoubleThreadTest, SocketOptionsMergedOnSetTransport) { + Base::SocketOptionsMergedOnSetTransport(); +} + + +// TODO(pthatcher): TestSetReceiver? |