diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc | |
parent | Initial commit. (diff) | |
download | thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.tar.xz thunderbird-6bf0a5cb5034a7e684dcc3500e841785237ce2dd.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc')
-rw-r--r-- | third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc | 337 |
1 files changed, 337 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc b/third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc new file mode 100644 index 0000000000..3bb2088866 --- /dev/null +++ b/third_party/libwebrtc/pc/peer_connection_data_channel_unittest.cc @@ -0,0 +1,337 @@ +/* + * Copyright 2017 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 <memory> +#include <string> +#include <type_traits> +#include <utility> +#include <vector> + +#include "absl/types/optional.h" +#include "api/call/call_factory_interface.h" +#include "api/jsep.h" +#include "api/media_types.h" +#include "api/peer_connection_interface.h" +#include "api/scoped_refptr.h" +#include "api/sctp_transport_interface.h" +#include "api/task_queue/default_task_queue_factory.h" +#include "api/task_queue/task_queue_factory.h" +#include "api/transport/sctp_transport_factory_interface.h" +#include "media/base/fake_media_engine.h" +#include "media/base/media_engine.h" +#include "p2p/base/p2p_constants.h" +#include "p2p/base/port_allocator.h" +#include "pc/media_session.h" +#include "pc/peer_connection.h" +#include "pc/peer_connection_proxy.h" +#include "pc/peer_connection_wrapper.h" +#include "pc/sctp_transport.h" +#include "pc/sdp_utils.h" +#include "pc/session_description.h" +#include "pc/test/mock_peer_connection_observers.h" +#include "rtc_base/checks.h" +#include "rtc_base/logging.h" +#include "rtc_base/rtc_certificate_generator.h" +#include "rtc_base/thread.h" +#include "test/gmock.h" +#include "test/gtest.h" +#ifdef WEBRTC_ANDROID +#include "pc/test/android_test_initializer.h" +#endif +#include "rtc_base/virtual_socket_server.h" +#include "test/pc/sctp/fake_sctp_transport.h" + +namespace webrtc { + +using RTCConfiguration = PeerConnectionInterface::RTCConfiguration; +using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions; +using ::testing::HasSubstr; +using ::testing::Not; +using ::testing::Values; + +namespace { + +PeerConnectionFactoryDependencies CreatePeerConnectionFactoryDependencies() { + PeerConnectionFactoryDependencies deps; + deps.network_thread = rtc::Thread::Current(); + deps.worker_thread = rtc::Thread::Current(); + deps.signaling_thread = rtc::Thread::Current(); + deps.task_queue_factory = CreateDefaultTaskQueueFactory(); + deps.media_engine = std::make_unique<cricket::FakeMediaEngine>(); + deps.call_factory = CreateCallFactory(); + deps.sctp_factory = std::make_unique<FakeSctpTransportFactory>(); + return deps; +} + +} // namespace + +class PeerConnectionWrapperForDataChannelTest : public PeerConnectionWrapper { + public: + using PeerConnectionWrapper::PeerConnectionWrapper; + + FakeSctpTransportFactory* sctp_transport_factory() { + return sctp_transport_factory_; + } + + void set_sctp_transport_factory( + FakeSctpTransportFactory* sctp_transport_factory) { + sctp_transport_factory_ = sctp_transport_factory; + } + + absl::optional<std::string> sctp_mid() { + return GetInternalPeerConnection()->sctp_mid(); + } + + absl::optional<std::string> sctp_transport_name() { + return GetInternalPeerConnection()->sctp_transport_name(); + } + + PeerConnection* GetInternalPeerConnection() { + auto* pci = + static_cast<PeerConnectionProxyWithInternal<PeerConnectionInterface>*>( + pc()); + return static_cast<PeerConnection*>(pci->internal()); + } + + private: + FakeSctpTransportFactory* sctp_transport_factory_ = nullptr; +}; + +class PeerConnectionDataChannelBaseTest : public ::testing::Test { + protected: + typedef std::unique_ptr<PeerConnectionWrapperForDataChannelTest> WrapperPtr; + + explicit PeerConnectionDataChannelBaseTest(SdpSemantics sdp_semantics) + : vss_(new rtc::VirtualSocketServer()), + main_(vss_.get()), + sdp_semantics_(sdp_semantics) { +#ifdef WEBRTC_ANDROID + InitializeAndroidObjects(); +#endif + } + + WrapperPtr CreatePeerConnection() { + return CreatePeerConnection(RTCConfiguration()); + } + + WrapperPtr CreatePeerConnection(const RTCConfiguration& config) { + return CreatePeerConnection(config, + PeerConnectionFactoryInterface::Options()); + } + + WrapperPtr CreatePeerConnection( + const RTCConfiguration& config, + const PeerConnectionFactoryInterface::Options factory_options) { + auto factory_deps = CreatePeerConnectionFactoryDependencies(); + FakeSctpTransportFactory* fake_sctp_transport_factory = + static_cast<FakeSctpTransportFactory*>(factory_deps.sctp_factory.get()); + rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory = + CreateModularPeerConnectionFactory(std::move(factory_deps)); + pc_factory->SetOptions(factory_options); + auto observer = std::make_unique<MockPeerConnectionObserver>(); + RTCConfiguration modified_config = config; + modified_config.sdp_semantics = sdp_semantics_; + auto result = pc_factory->CreatePeerConnectionOrError( + modified_config, PeerConnectionDependencies(observer.get())); + if (!result.ok()) { + return nullptr; + } + + observer->SetPeerConnectionInterface(result.value().get()); + auto wrapper = std::make_unique<PeerConnectionWrapperForDataChannelTest>( + pc_factory, result.MoveValue(), std::move(observer)); + wrapper->set_sctp_transport_factory(fake_sctp_transport_factory); + return wrapper; + } + + // Accepts the same arguments as CreatePeerConnection and adds a default data + // channel. + template <typename... Args> + WrapperPtr CreatePeerConnectionWithDataChannel(Args&&... args) { + auto wrapper = CreatePeerConnection(std::forward<Args>(args)...); + if (!wrapper) { + return nullptr; + } + EXPECT_TRUE(wrapper->pc()->CreateDataChannelOrError("dc", nullptr).ok()); + return wrapper; + } + + // Changes the SCTP data channel port on the given session description. + void ChangeSctpPortOnDescription(cricket::SessionDescription* desc, + int port) { + auto* data_content = cricket::GetFirstDataContent(desc); + RTC_DCHECK(data_content); + auto* data_desc = data_content->media_description()->as_sctp(); + RTC_DCHECK(data_desc); + data_desc->set_port(port); + } + + std::unique_ptr<rtc::VirtualSocketServer> vss_; + rtc::AutoSocketServerThread main_; + const SdpSemantics sdp_semantics_; +}; + +class PeerConnectionDataChannelTest + : public PeerConnectionDataChannelBaseTest, + public ::testing::WithParamInterface<SdpSemantics> { + protected: + PeerConnectionDataChannelTest() + : PeerConnectionDataChannelBaseTest(GetParam()) {} +}; + +class PeerConnectionDataChannelUnifiedPlanTest + : public PeerConnectionDataChannelBaseTest { + protected: + PeerConnectionDataChannelUnifiedPlanTest() + : PeerConnectionDataChannelBaseTest(SdpSemantics::kUnifiedPlan) {} +}; + +TEST_P(PeerConnectionDataChannelTest, InternalSctpTransportDeletedOnTeardown) { + auto caller = CreatePeerConnectionWithDataChannel(); + + ASSERT_TRUE(caller->SetLocalDescription(caller->CreateOffer())); + EXPECT_TRUE(caller->sctp_transport_factory()->last_fake_sctp_transport()); + + rtc::scoped_refptr<SctpTransportInterface> sctp_transport = + caller->GetInternalPeerConnection()->GetSctpTransport(); + + caller.reset(); + EXPECT_EQ(static_cast<SctpTransport*>(sctp_transport.get())->internal(), + nullptr); +} + +// Test that sctp_mid/sctp_transport_name (used for stats) are correct +// before and after BUNDLE is negotiated. +TEST_P(PeerConnectionDataChannelTest, SctpContentAndTransportNameSetCorrectly) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + + // Initially these fields should be empty. + EXPECT_FALSE(caller->sctp_mid()); + EXPECT_FALSE(caller->sctp_transport_name()); + + // Create offer with audio/video/data. + // Default bundle policy is "balanced", so data should be using its own + // transport. + caller->AddAudioTrack("a"); + caller->AddVideoTrack("v"); + caller->pc()->CreateDataChannelOrError("dc", nullptr); + + auto offer = caller->CreateOffer(); + const auto& offer_contents = offer->description()->contents(); + ASSERT_EQ(cricket::MEDIA_TYPE_AUDIO, + offer_contents[0].media_description()->type()); + std::string audio_mid = offer_contents[0].name; + ASSERT_EQ(cricket::MEDIA_TYPE_DATA, + offer_contents[2].media_description()->type()); + std::string data_mid = offer_contents[2].name; + + ASSERT_TRUE( + caller->SetLocalDescription(CloneSessionDescription(offer.get()))); + ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer))); + + ASSERT_TRUE(caller->sctp_mid()); + EXPECT_EQ(data_mid, *caller->sctp_mid()); + ASSERT_TRUE(caller->sctp_transport_name()); + EXPECT_EQ(data_mid, *caller->sctp_transport_name()); + + // Create answer that finishes BUNDLE negotiation, which means everything + // should be bundled on the first transport (audio). + RTCOfferAnswerOptions options; + options.use_rtp_mux = true; + ASSERT_TRUE( + caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal())); + + ASSERT_TRUE(caller->sctp_mid()); + EXPECT_EQ(data_mid, *caller->sctp_mid()); + ASSERT_TRUE(caller->sctp_transport_name()); + EXPECT_EQ(audio_mid, *caller->sctp_transport_name()); +} + +TEST_P(PeerConnectionDataChannelTest, + CreateOfferWithNoDataChannelsGivesNoDataSection) { + auto caller = CreatePeerConnection(); + auto offer = caller->CreateOffer(); + + EXPECT_FALSE(offer->description()->GetContentByName(cricket::CN_DATA)); + EXPECT_FALSE(offer->description()->GetTransportInfoByName(cricket::CN_DATA)); +} + +TEST_P(PeerConnectionDataChannelTest, + CreateAnswerWithRemoteSctpDataChannelIncludesDataSection) { + auto caller = CreatePeerConnectionWithDataChannel(); + auto callee = CreatePeerConnection(); + + ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal())); + + auto answer = callee->CreateAnswer(); + ASSERT_TRUE(answer); + auto* data_content = cricket::GetFirstDataContent(answer->description()); + ASSERT_TRUE(data_content); + EXPECT_FALSE(data_content->rejected); + EXPECT_TRUE( + answer->description()->GetTransportInfoByName(data_content->name)); +} + +TEST_P(PeerConnectionDataChannelTest, SctpPortPropagatedFromSdpToTransport) { + constexpr int kNewSendPort = 9998; + constexpr int kNewRecvPort = 7775; + + auto caller = CreatePeerConnectionWithDataChannel(); + auto callee = CreatePeerConnectionWithDataChannel(); + + auto offer = caller->CreateOffer(); + ChangeSctpPortOnDescription(offer->description(), kNewSendPort); + ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer))); + + auto answer = callee->CreateAnswer(); + ChangeSctpPortOnDescription(answer->description(), kNewRecvPort); + std::string sdp; + answer->ToString(&sdp); + ASSERT_TRUE(callee->SetLocalDescription(std::move(answer))); + auto* callee_transport = + callee->sctp_transport_factory()->last_fake_sctp_transport(); + ASSERT_TRUE(callee_transport); + EXPECT_EQ(kNewSendPort, callee_transport->remote_port()); + EXPECT_EQ(kNewRecvPort, callee_transport->local_port()); +} + +TEST_P(PeerConnectionDataChannelTest, ModernSdpSyntaxByDefault) { + PeerConnectionInterface::RTCOfferAnswerOptions options; + auto caller = CreatePeerConnectionWithDataChannel(); + auto offer = caller->CreateOffer(options); + EXPECT_FALSE(cricket::GetFirstSctpDataContentDescription(offer->description()) + ->use_sctpmap()); + std::string sdp; + offer->ToString(&sdp); + RTC_LOG(LS_ERROR) << sdp; + EXPECT_THAT(sdp, HasSubstr(" UDP/DTLS/SCTP webrtc-datachannel")); + EXPECT_THAT(sdp, Not(HasSubstr("a=sctpmap:"))); +} + +TEST_P(PeerConnectionDataChannelTest, ObsoleteSdpSyntaxIfSet) { + PeerConnectionInterface::RTCOfferAnswerOptions options; + options.use_obsolete_sctp_sdp = true; + auto caller = CreatePeerConnectionWithDataChannel(); + auto offer = caller->CreateOffer(options); + EXPECT_TRUE(cricket::GetFirstSctpDataContentDescription(offer->description()) + ->use_sctpmap()); + std::string sdp; + offer->ToString(&sdp); + EXPECT_THAT(sdp, Not(HasSubstr(" UDP/DTLS/SCTP webrtc-datachannel"))); + EXPECT_THAT(sdp, HasSubstr("a=sctpmap:")); +} + +INSTANTIATE_TEST_SUITE_P(PeerConnectionDataChannelTest, + PeerConnectionDataChannelTest, + Values(SdpSemantics::kPlanB_DEPRECATED, + SdpSemantics::kUnifiedPlan)); + +} // namespace webrtc |