From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../pc/peer_connection_signaling_unittest.cc | 1355 ++++++++++++++++++++ 1 file changed, 1355 insertions(+) create mode 100644 third_party/libwebrtc/pc/peer_connection_signaling_unittest.cc (limited to 'third_party/libwebrtc/pc/peer_connection_signaling_unittest.cc') diff --git a/third_party/libwebrtc/pc/peer_connection_signaling_unittest.cc b/third_party/libwebrtc/pc/peer_connection_signaling_unittest.cc new file mode 100644 index 0000000000..3ff890ab6a --- /dev/null +++ b/third_party/libwebrtc/pc/peer_connection_signaling_unittest.cc @@ -0,0 +1,1355 @@ +/* + * 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. + */ + +// This file contains tests that check the PeerConnection's signaling state +// machine, as well as tests that check basic, media-agnostic aspects of SDP. + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "absl/types/optional.h" +#include "api/audio/audio_mixer.h" +#include "api/audio_codecs/builtin_audio_decoder_factory.h" +#include "api/audio_codecs/builtin_audio_encoder_factory.h" +#include "api/create_peerconnection_factory.h" +#include "api/dtls_transport_interface.h" +#include "api/jsep.h" +#include "api/media_types.h" +#include "api/peer_connection_interface.h" +#include "api/rtc_error.h" +#include "api/rtp_receiver_interface.h" +#include "api/rtp_sender_interface.h" +#include "api/rtp_transceiver_interface.h" +#include "api/scoped_refptr.h" +#include "api/set_local_description_observer_interface.h" +#include "api/set_remote_description_observer_interface.h" +#include "api/video_codecs/builtin_video_decoder_factory.h" +#include "api/video_codecs/builtin_video_encoder_factory.h" +#include "media/base/codec.h" +#include "modules/audio_device/include/audio_device.h" +#include "modules/audio_processing/include/audio_processing.h" +#include "p2p/base/port_allocator.h" +#include "pc/peer_connection.h" +#include "pc/peer_connection_proxy.h" +#include "pc/peer_connection_wrapper.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/rtc_certificate.h" +#include "rtc_base/rtc_certificate_generator.h" +#include "rtc_base/string_encode.h" +#include "rtc_base/thread.h" +#include "test/gtest.h" +#ifdef WEBRTC_ANDROID +#include "pc/test/android_test_initializer.h" +#endif +#include "pc/test/fake_audio_capture_module.h" +#include "pc/test/fake_rtc_certificate_generator.h" +#include "rtc_base/gunit.h" +#include "rtc_base/virtual_socket_server.h" + +namespace webrtc { + +using SignalingState = PeerConnectionInterface::SignalingState; +using RTCConfiguration = PeerConnectionInterface::RTCConfiguration; +using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions; +using ::testing::Bool; +using ::testing::Combine; +using ::testing::Values; + +namespace { +const int64_t kWaitTimeout = 10000; +} // namespace + +class PeerConnectionWrapperForSignalingTest : public PeerConnectionWrapper { + public: + using PeerConnectionWrapper::PeerConnectionWrapper; + + bool initial_offerer() { + return GetInternalPeerConnection()->initial_offerer(); + } + + PeerConnection* GetInternalPeerConnection() { + auto* pci = + static_cast*>( + pc()); + return static_cast(pci->internal()); + } +}; + +class ExecuteFunctionOnCreateSessionDescriptionObserver + : public CreateSessionDescriptionObserver { + public: + ExecuteFunctionOnCreateSessionDescriptionObserver( + std::function function) + : function_(std::move(function)) {} + ~ExecuteFunctionOnCreateSessionDescriptionObserver() override { + RTC_DCHECK(was_called_); + } + + bool was_called() const { return was_called_; } + + void OnSuccess(SessionDescriptionInterface* desc) override { + RTC_DCHECK(!was_called_); + was_called_ = true; + function_(desc); + } + + void OnFailure(RTCError error) override { RTC_DCHECK_NOTREACHED(); } + + private: + bool was_called_ = false; + std::function function_; +}; + +class PeerConnectionSignalingBaseTest : public ::testing::Test { + protected: + typedef std::unique_ptr WrapperPtr; + + explicit PeerConnectionSignalingBaseTest(SdpSemantics sdp_semantics) + : vss_(new rtc::VirtualSocketServer()), + main_(vss_.get()), + sdp_semantics_(sdp_semantics) { +#ifdef WEBRTC_ANDROID + InitializeAndroidObjects(); +#endif + pc_factory_ = CreatePeerConnectionFactory( + rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(), + rtc::scoped_refptr(FakeAudioCaptureModule::Create()), + CreateBuiltinAudioEncoderFactory(), CreateBuiltinAudioDecoderFactory(), + CreateBuiltinVideoEncoderFactory(), CreateBuiltinVideoDecoderFactory(), + nullptr /* audio_mixer */, nullptr /* audio_processing */); + } + + WrapperPtr CreatePeerConnection() { + return CreatePeerConnection(RTCConfiguration()); + } + + WrapperPtr CreatePeerConnection(const RTCConfiguration& config) { + auto observer = std::make_unique(); + 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()); + return std::make_unique( + pc_factory_, result.MoveValue(), std::move(observer)); + } + + // Accepts the same arguments as CreatePeerConnection and adds default audio + // and video tracks. + template + WrapperPtr CreatePeerConnectionWithAudioVideo(Args&&... args) { + auto wrapper = CreatePeerConnection(std::forward(args)...); + if (!wrapper) { + return nullptr; + } + wrapper->AddAudioTrack("a"); + wrapper->AddVideoTrack("v"); + return wrapper; + } + + int NumberOfDtlsTransports(const WrapperPtr& pc_wrapper) { + std::set transports; + auto transceivers = pc_wrapper->pc()->GetTransceivers(); + + for (auto& transceiver : transceivers) { + if (transceiver->sender()->dtls_transport()) { + EXPECT_TRUE(transceiver->receiver()->dtls_transport()); + EXPECT_EQ(transceiver->sender()->dtls_transport().get(), + transceiver->receiver()->dtls_transport().get()); + transports.insert(transceiver->sender()->dtls_transport().get()); + } else { + // If one transceiver is missing, they all should be. + EXPECT_EQ(0UL, transports.size()); + } + } + return transports.size(); + } + + bool HasDtlsTransport(const WrapperPtr& pc_wrapper) { + return NumberOfDtlsTransports(pc_wrapper) > 0; + } + + std::unique_ptr vss_; + rtc::AutoSocketServerThread main_; + rtc::scoped_refptr pc_factory_; + const SdpSemantics sdp_semantics_; +}; + +class PeerConnectionSignalingTest + : public PeerConnectionSignalingBaseTest, + public ::testing::WithParamInterface { + protected: + PeerConnectionSignalingTest() : PeerConnectionSignalingBaseTest(GetParam()) {} +}; + +TEST_P(PeerConnectionSignalingTest, SetLocalOfferTwiceWorks) { + auto caller = CreatePeerConnection(); + + EXPECT_TRUE(caller->SetLocalDescription(caller->CreateOffer())); + EXPECT_TRUE(caller->SetLocalDescription(caller->CreateOffer())); +} + +TEST_P(PeerConnectionSignalingTest, SetRemoteOfferTwiceWorks) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + + EXPECT_TRUE(callee->SetRemoteDescription(caller->CreateOffer())); + EXPECT_TRUE(callee->SetRemoteDescription(caller->CreateOffer())); +} + +TEST_P(PeerConnectionSignalingTest, FailToSetNullLocalDescription) { + auto caller = CreatePeerConnection(); + std::string error; + ASSERT_FALSE(caller->SetLocalDescription(nullptr, &error)); + EXPECT_EQ("SessionDescription is NULL.", error); +} + +TEST_P(PeerConnectionSignalingTest, FailToSetNullRemoteDescription) { + auto caller = CreatePeerConnection(); + std::string error; + ASSERT_FALSE(caller->SetRemoteDescription(nullptr, &error)); + EXPECT_EQ("SessionDescription is NULL.", error); +} + +// The following parameterized test verifies that calls to various signaling +// methods on PeerConnection will succeed/fail depending on what is the +// PeerConnection's signaling state. Note that the test tries many different +// forms of SignalingState::kClosed by arriving at a valid state then calling +// `Close()`. This is intended to catch cases where the PeerConnection signaling +// method ignores the closed flag but may work/not work because of the single +// state the PeerConnection was created in before it was closed. + +class PeerConnectionSignalingStateTest + : public PeerConnectionSignalingBaseTest, + public ::testing::WithParamInterface< + std::tuple> { + protected: + PeerConnectionSignalingStateTest() + : PeerConnectionSignalingBaseTest(std::get<0>(GetParam())), + state_under_test_(std::make_tuple(std::get<1>(GetParam()), + std::get<2>(GetParam()))) {} + + RTCConfiguration GetConfig() { + RTCConfiguration config; + config.certificates.push_back( + FakeRTCCertificateGenerator::GenerateCertificate()); + return config; + } + + WrapperPtr CreatePeerConnectionUnderTest() { + return CreatePeerConnectionInState(state_under_test_); + } + + WrapperPtr CreatePeerConnectionInState(SignalingState state) { + return CreatePeerConnectionInState(std::make_tuple(state, false)); + } + + WrapperPtr CreatePeerConnectionInState( + std::tuple state_tuple) { + SignalingState state = std::get<0>(state_tuple); + bool closed = std::get<1>(state_tuple); + + auto wrapper = CreatePeerConnectionWithAudioVideo(GetConfig()); + switch (state) { + case SignalingState::kStable: { + break; + } + case SignalingState::kHaveLocalOffer: { + wrapper->SetLocalDescription(wrapper->CreateOffer()); + break; + } + case SignalingState::kHaveLocalPrAnswer: { + auto caller = CreatePeerConnectionWithAudioVideo(GetConfig()); + wrapper->SetRemoteDescription(caller->CreateOffer()); + auto answer = wrapper->CreateAnswer(); + wrapper->SetLocalDescription( + CloneSessionDescriptionAsType(answer.get(), SdpType::kPrAnswer)); + break; + } + case SignalingState::kHaveRemoteOffer: { + auto caller = CreatePeerConnectionWithAudioVideo(GetConfig()); + wrapper->SetRemoteDescription(caller->CreateOffer()); + break; + } + case SignalingState::kHaveRemotePrAnswer: { + auto callee = CreatePeerConnectionWithAudioVideo(GetConfig()); + callee->SetRemoteDescription(wrapper->CreateOfferAndSetAsLocal()); + auto answer = callee->CreateAnswer(); + wrapper->SetRemoteDescription( + CloneSessionDescriptionAsType(answer.get(), SdpType::kPrAnswer)); + break; + } + case SignalingState::kClosed: { + RTC_DCHECK_NOTREACHED() + << "Set the second member of the tuple to true to " + "achieve a closed state from an existing, valid " + "state."; + } + } + + RTC_DCHECK_EQ(state, wrapper->pc()->signaling_state()); + + if (closed) { + wrapper->pc()->Close(); + RTC_DCHECK_EQ(SignalingState::kClosed, wrapper->signaling_state()); + } + + return wrapper; + } + + std::tuple state_under_test_; +}; + +TEST_P(PeerConnectionSignalingStateTest, CreateOffer) { + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() != SignalingState::kClosed) { + EXPECT_TRUE(wrapper->CreateOffer()); + } else { + std::string error; + ASSERT_FALSE(wrapper->CreateOffer(RTCOfferAnswerOptions(), &error)); + EXPECT_PRED_FORMAT2(AssertStartsWith, error, + "CreateOffer called when PeerConnection is closed."); + } +} + +TEST_P(PeerConnectionSignalingStateTest, CreateAnswer) { + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kHaveLocalPrAnswer || + wrapper->signaling_state() == SignalingState::kHaveRemoteOffer) { + EXPECT_TRUE(wrapper->CreateAnswer()); + } else { + std::string error; + ASSERT_FALSE(wrapper->CreateAnswer(RTCOfferAnswerOptions(), &error)); + EXPECT_EQ(error, + "PeerConnection cannot create an answer in a state other than " + "have-remote-offer or have-local-pranswer."); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetLocalOffer) { + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kStable || + wrapper->signaling_state() == SignalingState::kHaveLocalOffer) { + // Need to call CreateOffer on the PeerConnection under test, otherwise when + // setting the local offer it will want to verify the DTLS fingerprint + // against the locally generated certificate, but without a call to + // CreateOffer the certificate will never be generated. + EXPECT_TRUE(wrapper->SetLocalDescription(wrapper->CreateOffer())); + } else { + auto wrapper_for_offer = + CreatePeerConnectionInState(SignalingState::kHaveLocalOffer); + auto offer = + CloneSessionDescription(wrapper_for_offer->pc()->local_description()); + + std::string error; + ASSERT_FALSE(wrapper->SetLocalDescription(std::move(offer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set local offer sdp: Called in wrong state:"); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetLocalPrAnswer) { + auto wrapper_for_pranswer = + CreatePeerConnectionInState(SignalingState::kHaveLocalPrAnswer); + auto pranswer = + CloneSessionDescription(wrapper_for_pranswer->pc()->local_description()); + + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kHaveLocalPrAnswer || + wrapper->signaling_state() == SignalingState::kHaveRemoteOffer) { + EXPECT_TRUE(wrapper->SetLocalDescription(std::move(pranswer))); + } else { + std::string error; + ASSERT_FALSE(wrapper->SetLocalDescription(std::move(pranswer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set local pranswer sdp: Called in wrong state:"); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetLocalAnswer) { + auto wrapper_for_answer = + CreatePeerConnectionInState(SignalingState::kHaveRemoteOffer); + auto answer = wrapper_for_answer->CreateAnswer(); + + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kHaveLocalPrAnswer || + wrapper->signaling_state() == SignalingState::kHaveRemoteOffer) { + EXPECT_TRUE(wrapper->SetLocalDescription(std::move(answer))); + } else { + std::string error; + ASSERT_FALSE(wrapper->SetLocalDescription(std::move(answer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set local answer sdp: Called in wrong state:"); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetRemoteOffer) { + auto wrapper_for_offer = + CreatePeerConnectionInState(SignalingState::kHaveRemoteOffer); + auto offer = + CloneSessionDescription(wrapper_for_offer->pc()->remote_description()); + + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kStable || + wrapper->signaling_state() == SignalingState::kHaveRemoteOffer) { + EXPECT_TRUE(wrapper->SetRemoteDescription(std::move(offer))); + } else { + std::string error; + ASSERT_FALSE(wrapper->SetRemoteDescription(std::move(offer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set remote offer sdp: Called in wrong state:"); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetRemotePrAnswer) { + auto wrapper_for_pranswer = + CreatePeerConnectionInState(SignalingState::kHaveRemotePrAnswer); + auto pranswer = + CloneSessionDescription(wrapper_for_pranswer->pc()->remote_description()); + + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kHaveLocalOffer || + wrapper->signaling_state() == SignalingState::kHaveRemotePrAnswer) { + EXPECT_TRUE(wrapper->SetRemoteDescription(std::move(pranswer))); + } else { + std::string error; + ASSERT_FALSE(wrapper->SetRemoteDescription(std::move(pranswer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set remote pranswer sdp: Called in wrong state:"); + } +} + +TEST_P(PeerConnectionSignalingStateTest, SetRemoteAnswer) { + auto wrapper_for_answer = + CreatePeerConnectionInState(SignalingState::kHaveRemoteOffer); + auto answer = wrapper_for_answer->CreateAnswer(); + + auto wrapper = CreatePeerConnectionUnderTest(); + if (wrapper->signaling_state() == SignalingState::kHaveLocalOffer || + wrapper->signaling_state() == SignalingState::kHaveRemotePrAnswer) { + EXPECT_TRUE(wrapper->SetRemoteDescription(std::move(answer))); + } else { + std::string error; + ASSERT_FALSE(wrapper->SetRemoteDescription(std::move(answer), &error)); + EXPECT_PRED_FORMAT2( + AssertStartsWith, error, + "Failed to set remote answer sdp: Called in wrong state:"); + } +} + +INSTANTIATE_TEST_SUITE_P(PeerConnectionSignalingTest, + PeerConnectionSignalingStateTest, + Combine(Values(SdpSemantics::kPlanB_DEPRECATED, + SdpSemantics::kUnifiedPlan), + Values(SignalingState::kStable, + SignalingState::kHaveLocalOffer, + SignalingState::kHaveLocalPrAnswer, + SignalingState::kHaveRemoteOffer, + SignalingState::kHaveRemotePrAnswer), + Bool())); + +// Test that CreateAnswer fails if a round of offer/answer has been done and +// the PeerConnection is in the stable state. +TEST_P(PeerConnectionSignalingTest, CreateAnswerFailsIfStable) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + + ASSERT_TRUE(caller->ExchangeOfferAnswerWith(callee.get())); + + ASSERT_EQ(SignalingState::kStable, caller->signaling_state()); + EXPECT_FALSE(caller->CreateAnswer()); + + ASSERT_EQ(SignalingState::kStable, callee->signaling_state()); + EXPECT_FALSE(callee->CreateAnswer()); +} + +// According to https://tools.ietf.org/html/rfc3264#section-8, the session id +// stays the same but the version must be incremented if a later, different +// session description is generated. These two tests verify that is the case for +// both offers and answers. +TEST_P(PeerConnectionSignalingTest, + SessionVersionIncrementedInSubsequentDifferentOffer) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + + auto original_offer = caller->CreateOfferAndSetAsLocal(); + const std::string original_id = original_offer->session_id(); + const std::string original_version = original_offer->session_version(); + + ASSERT_TRUE(callee->SetRemoteDescription(std::move(original_offer))); + ASSERT_TRUE(caller->SetRemoteDescription(callee->CreateAnswer())); + + // Add track to get a different offer. + caller->AddAudioTrack("a"); + + auto later_offer = caller->CreateOffer(); + + EXPECT_EQ(original_id, later_offer->session_id()); + EXPECT_LT(rtc::FromString(original_version), + rtc::FromString(later_offer->session_version())); +} +TEST_P(PeerConnectionSignalingTest, + SessionVersionIncrementedInSubsequentDifferentAnswer) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + + ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal())); + + auto original_answer = callee->CreateAnswer(); + const std::string original_id = original_answer->session_id(); + const std::string original_version = original_answer->session_version(); + + // Add track to get a different answer. + callee->AddAudioTrack("a"); + + auto later_answer = callee->CreateAnswer(); + + EXPECT_EQ(original_id, later_answer->session_id()); + EXPECT_LT(rtc::FromString(original_version), + rtc::FromString(later_answer->session_version())); +} + +TEST_P(PeerConnectionSignalingTest, InitiatorFlagSetOnCallerAndNotOnCallee) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnectionWithAudioVideo(); + + EXPECT_FALSE(caller->initial_offerer()); + EXPECT_FALSE(callee->initial_offerer()); + + ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal())); + + EXPECT_TRUE(caller->initial_offerer()); + EXPECT_FALSE(callee->initial_offerer()); + + ASSERT_TRUE( + caller->SetRemoteDescription(callee->CreateAnswerAndSetAsLocal())); + + EXPECT_TRUE(caller->initial_offerer()); + EXPECT_FALSE(callee->initial_offerer()); +} + +// Test creating a PeerConnection, request multiple offers, destroy the +// PeerConnection and make sure we get success/failure callbacks for all of the +// requests. +// Background: crbug.com/507307 +TEST_P(PeerConnectionSignalingTest, CreateOffersAndShutdown) { + auto caller = CreatePeerConnection(); + + RTCOfferAnswerOptions options; + options.offer_to_receive_audio = + RTCOfferAnswerOptions::kOfferToReceiveMediaTrue; + + rtc::scoped_refptr observers[100]; + for (auto& observer : observers) { + observer = rtc::make_ref_counted(); + caller->pc()->CreateOffer(observer.get(), options); + } + + // Destroy the PeerConnection. + caller.reset(nullptr); + + for (auto& observer : observers) { + // We expect to have received a notification now even if the PeerConnection + // was terminated. The offer creation may or may not have succeeded, but we + // must have received a notification. + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + } +} + +// Similar to the above test, but by closing the PC first the CreateOffer() will +// fail "early", which triggers a codepath where the PeerConnection is +// reponsible for invoking the observer, instead of the normal codepath where +// the WebRtcSessionDescriptionFactory is responsible for it. +TEST_P(PeerConnectionSignalingTest, CloseCreateOfferAndShutdown) { + auto caller = CreatePeerConnection(); + auto observer = rtc::make_ref_counted(); + caller->pc()->Close(); + caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions()); + caller.reset(nullptr); + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); +} + +TEST_P(PeerConnectionSignalingTest, + ImplicitCreateOfferAndShutdownWithOldObserver) { + auto caller = CreatePeerConnection(); + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription(observer.get()); + caller.reset(nullptr); + // The old observer does not get invoked because posted messages are lost. + EXPECT_FALSE(observer->called()); +} + +TEST_P(PeerConnectionSignalingTest, ImplicitCreateOfferAndShutdown) { + auto caller = CreatePeerConnection(); + auto observer = rtc::make_ref_counted(); + caller->pc()->SetLocalDescription(observer); + caller.reset(nullptr); + // The new observer gets invoked because it is called immediately. + EXPECT_TRUE(observer->called()); + EXPECT_FALSE(observer->error().ok()); +} + +TEST_P(PeerConnectionSignalingTest, + CloseBeforeImplicitCreateOfferAndShutdownWithOldObserver) { + auto caller = CreatePeerConnection(); + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->Close(); + caller->pc()->SetLocalDescription(observer.get()); + caller.reset(nullptr); + // The old observer does not get invoked because posted messages are lost. + EXPECT_FALSE(observer->called()); +} + +TEST_P(PeerConnectionSignalingTest, CloseBeforeImplicitCreateOfferAndShutdown) { + auto caller = CreatePeerConnection(); + auto observer = rtc::make_ref_counted(); + caller->pc()->Close(); + caller->pc()->SetLocalDescription(observer); + caller.reset(nullptr); + // The new observer gets invoked because it is called immediately. + EXPECT_TRUE(observer->called()); + EXPECT_FALSE(observer->error().ok()); +} + +TEST_P(PeerConnectionSignalingTest, + CloseAfterImplicitCreateOfferAndShutdownWithOldObserver) { + auto caller = CreatePeerConnection(); + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription(observer.get()); + caller->pc()->Close(); + caller.reset(nullptr); + // The old observer does not get invoked because posted messages are lost. + EXPECT_FALSE(observer->called()); +} + +TEST_P(PeerConnectionSignalingTest, CloseAfterImplicitCreateOfferAndShutdown) { + auto caller = CreatePeerConnection(); + auto observer = rtc::make_ref_counted(); + caller->pc()->SetLocalDescription(observer); + caller->pc()->Close(); + caller.reset(nullptr); + // The new observer gets invoked because it is called immediately. + EXPECT_TRUE(observer->called()); + EXPECT_FALSE(observer->error().ok()); +} + +TEST_P(PeerConnectionSignalingTest, + SetLocalDescriptionNewObserverIsInvokedImmediately) { + auto caller = CreatePeerConnection(); + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + auto observer = rtc::make_ref_counted(); + caller->pc()->SetLocalDescription(std::move(offer), observer); + // The new observer is invoked immediately. + EXPECT_TRUE(observer->called()); + EXPECT_TRUE(observer->error().ok()); +} + +TEST_P(PeerConnectionSignalingTest, + SetLocalDescriptionOldObserverIsInvokedInAPostedMessage) { + auto caller = CreatePeerConnection(); + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription(observer.get(), offer.release()); + // The old observer is not invoked immediately. + EXPECT_FALSE(observer->called()); + // Process all currently pending messages by waiting for a posted task to run. + bool checkpoint_reached = false; + rtc::Thread::Current()->PostTask( + [&checkpoint_reached] { checkpoint_reached = true; }); + EXPECT_TRUE_WAIT(checkpoint_reached, kWaitTimeout); + // If resolving the observer was pending, it must now have been called. + EXPECT_TRUE(observer->called()); +} + +TEST_P(PeerConnectionSignalingTest, SetRemoteDescriptionExecutesImmediately) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnection(); + + // This offer will cause receivers to be created. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + // By not waiting for the observer's callback we can verify that the operation + // executed immediately. + callee->pc()->SetRemoteDescription( + std::move(offer), + rtc::make_ref_counted()); + EXPECT_EQ(2u, callee->pc()->GetReceivers().size()); +} + +TEST_P(PeerConnectionSignalingTest, CreateOfferBlocksSetRemoteDescription) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnection(); + + // This offer will cause receivers to be created. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + EXPECT_EQ(0u, callee->pc()->GetReceivers().size()); + auto offer_observer = + rtc::make_ref_counted(); + // Synchronously invoke CreateOffer() and SetRemoteDescription(). The + // SetRemoteDescription() operation should be chained to be executed + // asynchronously, when CreateOffer() completes. + callee->pc()->CreateOffer(offer_observer.get(), RTCOfferAnswerOptions()); + callee->pc()->SetRemoteDescription( + std::move(offer), + rtc::make_ref_counted()); + // CreateOffer() is asynchronous; without message processing this operation + // should not have completed. + EXPECT_FALSE(offer_observer->called()); + // Due to chaining, the receivers should not have been created by the offer + // yet. + EXPECT_EQ(0u, callee->pc()->GetReceivers().size()); + // EXPECT_TRUE_WAIT causes messages to be processed... + EXPECT_TRUE_WAIT(offer_observer->called(), kWaitTimeout); + // Now that the offer has been completed, SetRemoteDescription() will have + // been executed next in the chain. + EXPECT_EQ(2u, callee->pc()->GetReceivers().size()); +} + +TEST_P(PeerConnectionSignalingTest, + ParameterlessSetLocalDescriptionCreatesOffer) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription(observer.get()); + + // The offer is created asynchronously; message processing is needed for it to + // complete. + EXPECT_FALSE(observer->called()); + EXPECT_FALSE(caller->pc()->pending_local_description()); + EXPECT_EQ(PeerConnection::kStable, caller->signaling_state()); + + // Wait for messages to be processed. + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + EXPECT_TRUE(observer->result()); + EXPECT_TRUE(caller->pc()->pending_local_description()); + EXPECT_EQ(SdpType::kOffer, + caller->pc()->pending_local_description()->GetType()); + EXPECT_EQ(PeerConnection::kHaveLocalOffer, caller->signaling_state()); +} + +TEST_P(PeerConnectionSignalingTest, + ParameterlessSetLocalDescriptionCreatesAnswer) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnectionWithAudioVideo(); + + callee->SetRemoteDescription(caller->CreateOffer()); + EXPECT_EQ(PeerConnection::kHaveRemoteOffer, callee->signaling_state()); + + auto observer = MockSetSessionDescriptionObserver::Create(); + callee->pc()->SetLocalDescription(observer.get()); + + // The answer is created asynchronously; message processing is needed for it + // to complete. + EXPECT_FALSE(observer->called()); + EXPECT_FALSE(callee->pc()->current_local_description()); + + // Wait for messages to be processed. + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + EXPECT_TRUE(observer->result()); + EXPECT_TRUE(callee->pc()->current_local_description()); + EXPECT_EQ(SdpType::kAnswer, + callee->pc()->current_local_description()->GetType()); + EXPECT_EQ(PeerConnection::kStable, callee->signaling_state()); +} + +TEST_P(PeerConnectionSignalingTest, + ParameterlessSetLocalDescriptionFullExchange) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnectionWithAudioVideo(); + + // SetLocalDescription(), implicitly creating an offer. + auto caller_set_local_description_observer = + MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription( + caller_set_local_description_observer.get()); + EXPECT_TRUE_WAIT(caller_set_local_description_observer->called(), + kWaitTimeout); + ASSERT_TRUE(caller->pc()->pending_local_description()); + + // SetRemoteDescription(offer) + auto callee_set_remote_description_observer = + MockSetSessionDescriptionObserver::Create(); + callee->pc()->SetRemoteDescription( + callee_set_remote_description_observer.get(), + CloneSessionDescription(caller->pc()->pending_local_description()) + .release()); + + // SetLocalDescription(), implicitly creating an answer. + auto callee_set_local_description_observer = + MockSetSessionDescriptionObserver::Create(); + callee->pc()->SetLocalDescription( + callee_set_local_description_observer.get()); + EXPECT_TRUE_WAIT(callee_set_local_description_observer->called(), + kWaitTimeout); + // Chaining guarantees SetRemoteDescription() happened before + // SetLocalDescription(). + EXPECT_TRUE(callee_set_remote_description_observer->called()); + EXPECT_TRUE(callee->pc()->current_local_description()); + + // SetRemoteDescription(answer) + auto caller_set_remote_description_observer = + MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetRemoteDescription( + caller_set_remote_description_observer.get(), + CloneSessionDescription(callee->pc()->current_local_description()) + .release()); + EXPECT_TRUE_WAIT(caller_set_remote_description_observer->called(), + kWaitTimeout); + + EXPECT_EQ(PeerConnection::kStable, caller->signaling_state()); + EXPECT_EQ(PeerConnection::kStable, callee->signaling_state()); +} + +TEST_P(PeerConnectionSignalingTest, + ParameterlessSetLocalDescriptionCloseBeforeCreatingOffer) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->Close(); + caller->pc()->SetLocalDescription(observer.get()); + + // The operation should fail asynchronously. + EXPECT_FALSE(observer->called()); + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + EXPECT_FALSE(observer->result()); + // This did not affect the signaling state. + EXPECT_EQ(PeerConnection::kClosed, caller->pc()->signaling_state()); + EXPECT_EQ( + "SetLocalDescription failed to create session description - " + "SetLocalDescription called when PeerConnection is closed.", + observer->error()); +} + +TEST_P(PeerConnectionSignalingTest, + ParameterlessSetLocalDescriptionCloseWhileCreatingOffer) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + auto observer = MockSetSessionDescriptionObserver::Create(); + caller->pc()->SetLocalDescription(observer.get()); + caller->pc()->Close(); + + // The operation should fail asynchronously. + EXPECT_FALSE(observer->called()); + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + EXPECT_FALSE(observer->result()); + // This did not affect the signaling state. + EXPECT_EQ(PeerConnection::kClosed, caller->pc()->signaling_state()); + EXPECT_EQ( + "SetLocalDescription failed to create session description - " + "CreateOffer failed because the session was shut down", + observer->error()); +} + +TEST_P(PeerConnectionSignalingTest, UnsupportedContentType) { + auto caller = CreatePeerConnection(); + + // Call setRemoteDescription with a m= line we don't understand. + std::string sdp = + "v=0\r\n" + "o=- 18446744069414584320 18446462598732840960 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "m=bogus 9 FOO 0 8\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=mid:bogusmid\r\n"; + std::unique_ptr remote_description = + webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); + + EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); + + // Assert we respond back with something meaningful. + auto answer = caller->CreateAnswer(); + ASSERT_EQ(answer->description()->contents().size(), 1u); + EXPECT_NE(answer->description() + ->contents()[0] + .media_description() + ->as_unsupported(), + nullptr); + EXPECT_EQ(answer->description() + ->contents()[0] + .media_description() + ->as_unsupported() + ->media_type(), + "bogus"); + EXPECT_TRUE(answer->description()->contents()[0].rejected); + EXPECT_EQ(answer->description()->contents()[0].mid(), "bogusmid"); + EXPECT_EQ( + answer->description()->contents()[0].media_description()->protocol(), + "FOO"); + EXPECT_FALSE( + answer->description()->contents()[0].media_description()->has_codecs()); + + EXPECT_TRUE(caller->SetLocalDescription(std::move(answer))); + + // Assert we keep this in susequent offers. + auto offer = caller->CreateOffer(); + EXPECT_EQ(offer->description() + ->contents()[0] + .media_description() + ->as_unsupported() + ->media_type(), + "bogus"); + EXPECT_TRUE(offer->description()->contents()[0].rejected); + EXPECT_EQ(offer->description()->contents()[0].media_description()->protocol(), + "FOO"); + EXPECT_EQ(offer->description()->contents()[0].mid(), "bogusmid"); + EXPECT_FALSE( + offer->description()->contents()[0].media_description()->has_codecs()); + EXPECT_TRUE(caller->SetLocalDescription(std::move(offer))); +} + +TEST_P(PeerConnectionSignalingTest, ReceiveFlexFec) { + auto caller = CreatePeerConnection(); + + std::string sdp = + "v=0\r\n" + "o=- 8403615332048243445 2 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "a=group:BUNDLE 0\r\n" + "m=video 9 UDP/TLS/RTP/SAVPF 102 122\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=rtcp:9 IN IP4 0.0.0.0\r\n" + "a=ice-ufrag:IZeV\r\n" + "a=ice-pwd:uaZhQD4rYM/Tta2qWBT1Bbt4\r\n" + "a=ice-options:trickle\r\n" + "a=fingerprint:sha-256 " + "D8:6C:3D:FA:23:E2:2C:63:11:2D:D0:86:BE:C4:D0:65:F9:42:F7:1C:06:04:27:E6:" + "1C:2C:74:01:8D:50:67:23\r\n" + "a=setup:actpass\r\n" + "a=mid:0\r\n" + "a=sendrecv\r\n" + "a=msid:stream track\r\n" + "a=rtcp-mux\r\n" + "a=rtcp-rsize\r\n" + "a=rtpmap:102 VP8/90000\r\n" + "a=rtcp-fb:102 goog-remb\r\n" + "a=rtcp-fb:102 transport-cc\r\n" + "a=rtcp-fb:102 ccm fir\r\n" + "a=rtcp-fb:102 nack\r\n" + "a=rtcp-fb:102 nack pli\r\n" + "a=rtpmap:122 flexfec-03/90000\r\n" + "a=fmtp:122 repair-window=10000000\r\n" + "a=ssrc-group:FEC-FR 1224551896 1953032773\r\n" + "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n" + "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n"; + std::unique_ptr remote_description = + webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); + + EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); + + auto answer = caller->CreateAnswer(); + ASSERT_EQ(answer->description()->contents().size(), 1u); + ASSERT_NE( + answer->description()->contents()[0].media_description()->as_video(), + nullptr); + auto codecs = answer->description() + ->contents()[0] + .media_description() + ->as_video() + ->codecs(); + ASSERT_EQ(codecs.size(), 2u); + EXPECT_EQ(codecs[1].name, "flexfec-03"); + + EXPECT_TRUE(caller->SetLocalDescription(std::move(answer))); +} + +TEST_P(PeerConnectionSignalingTest, ReceiveFlexFecReoffer) { + auto caller = CreatePeerConnection(); + + std::string sdp = + "v=0\r\n" + "o=- 8403615332048243445 2 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "a=group:BUNDLE 0\r\n" + "m=video 9 UDP/TLS/RTP/SAVPF 102 35\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=rtcp:9 IN IP4 0.0.0.0\r\n" + "a=ice-ufrag:IZeV\r\n" + "a=ice-pwd:uaZhQD4rYM/Tta2qWBT1Bbt4\r\n" + "a=ice-options:trickle\r\n" + "a=fingerprint:sha-256 " + "D8:6C:3D:FA:23:E2:2C:63:11:2D:D0:86:BE:C4:D0:65:F9:42:F7:1C:06:04:27:E6:" + "1C:2C:74:01:8D:50:67:23\r\n" + "a=setup:actpass\r\n" + "a=mid:0\r\n" + "a=sendrecv\r\n" + "a=msid:stream track\r\n" + "a=rtcp-mux\r\n" + "a=rtcp-rsize\r\n" + "a=rtpmap:102 VP8/90000\r\n" + "a=rtcp-fb:102 goog-remb\r\n" + "a=rtcp-fb:102 transport-cc\r\n" + "a=rtcp-fb:102 ccm fir\r\n" + "a=rtcp-fb:102 nack\r\n" + "a=rtcp-fb:102 nack pli\r\n" + "a=rtpmap:35 flexfec-03/90000\r\n" + "a=fmtp:35 repair-window=10000000\r\n" + "a=ssrc-group:FEC-FR 1224551896 1953032773\r\n" + "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n" + "a=ssrc:1953032773 cname:/exJcmhSLpyu9FgV\r\n"; + std::unique_ptr remote_description = + webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); + + EXPECT_TRUE(caller->SetRemoteDescription(std::move(remote_description))); + + auto answer = caller->CreateAnswer(); + ASSERT_EQ(answer->description()->contents().size(), 1u); + ASSERT_NE( + answer->description()->contents()[0].media_description()->as_video(), + nullptr); + auto codecs = answer->description() + ->contents()[0] + .media_description() + ->as_video() + ->codecs(); + ASSERT_EQ(codecs.size(), 2u); + EXPECT_EQ(codecs[1].name, "flexfec-03"); + EXPECT_EQ(codecs[1].id, 35); + + EXPECT_TRUE(caller->SetLocalDescription(std::move(answer))); + + // This generates a collision for AV1 which needs to be remapped. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + auto offer_codecs = offer->description() + ->contents()[0] + .media_description() + ->as_video() + ->codecs(); + auto flexfec_it = std::find_if( + offer_codecs.begin(), offer_codecs.end(), + [](const cricket::Codec& codec) { return codec.name == "flexfec-03"; }); + ASSERT_EQ(flexfec_it->id, 35); + auto av1_it = std::find_if( + offer_codecs.begin(), offer_codecs.end(), + [](const cricket::Codec& codec) { return codec.name == "AV1"; }); + if (av1_it != offer_codecs.end()) { + ASSERT_NE(av1_it->id, 35); + } +} + +TEST_P(PeerConnectionSignalingTest, MidAttributeMaxLength) { + auto caller = CreatePeerConnection(); + + std::string sdp = + "v=0\r\n" + "o=- 8403615332048243445 2 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "m=video 9 UDP/TLS/RTP/SAVPF 102\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=rtcp:9 IN IP4 0.0.0.0\r\n" + "a=ice-ufrag:IZeV\r\n" + "a=ice-pwd:uaZhQD4rYM/Tta2qWBT1Bbt4\r\n" + "a=ice-options:trickle\r\n" + "a=fingerprint:sha-256 " + "D8:6C:3D:FA:23:E2:2C:63:11:2D:D0:86:BE:C4:D0:65:F9:42:F7:1C:06:04:27:E6:" + "1C:2C:74:01:8D:50:67:23\r\n" + "a=setup:actpass\r\n" + // Too long mid attribute. + "a=mid:0123456789012345678901234567890123\r\n" + "a=sendrecv\r\n" + "a=msid:stream track\r\n" + "a=rtcp-mux\r\n" + "a=rtcp-rsize\r\n" + "a=rtpmap:102 VP8/90000\r\n" + "a=rtcp-fb:102 goog-remb\r\n" + "a=rtcp-fb:102 transport-cc\r\n" + "a=rtcp-fb:102 ccm fir\r\n" + "a=rtcp-fb:102 nack\r\n" + "a=rtcp-fb:102 nack pli\r\n" + "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"; + std::unique_ptr remote_description = + webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); + + EXPECT_FALSE(caller->SetRemoteDescription(std::move(remote_description))); +} + +INSTANTIATE_TEST_SUITE_P(PeerConnectionSignalingTest, + PeerConnectionSignalingTest, + Values(SdpSemantics::kPlanB_DEPRECATED, + SdpSemantics::kUnifiedPlan)); + +class PeerConnectionSignalingUnifiedPlanTest + : public PeerConnectionSignalingBaseTest { + protected: + PeerConnectionSignalingUnifiedPlanTest() + : PeerConnectionSignalingBaseTest(SdpSemantics::kUnifiedPlan) {} +}; + +// We verify that SetLocalDescription() executed immediately by verifying that +// the transceiver mid values got assigned. SLD executing immeditately is not +// unique to Unified Plan, but the transceivers used to verify this are only +// available in Unified Plan. +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + SetLocalDescriptionExecutesImmediatelyUsingOldObserver) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + // This offer will cause transceiver mids to get assigned. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + // By not waiting for the observer's callback we can verify that the operation + // executed immediately. The old observer is invoked in a posted message, so + // waiting for it would not ensure synchronicity. + RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value()); + caller->pc()->SetLocalDescription( + rtc::make_ref_counted().get(), + offer.release()); + EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value()); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + SetLocalDescriptionExecutesImmediatelyUsingNewObserver) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + // This offer will cause transceiver mids to get assigned. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + // Verify that mids were assigned without waiting for the observer. (However, + // the new observer should also be invoked synchronously - as is ensured by + // other tests.) + RTC_DCHECK(!caller->pc()->GetTransceivers()[0]->mid().has_value()); + caller->pc()->SetLocalDescription( + std::move(offer), + rtc::make_ref_counted()); + EXPECT_TRUE(caller->pc()->GetTransceivers()[0]->mid().has_value()); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + SetLocalDescriptionExecutesImmediatelyInsideCreateOfferCallback) { + auto caller = CreatePeerConnectionWithAudioVideo(); + + // This offer will cause transceiver mids to get assigned. + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + auto offer_observer = + rtc::make_ref_counted( + [pc = caller->pc()](SessionDescriptionInterface* desc) { + // By not waiting for the observer's callback we can verify that the + // operation executed immediately. + RTC_DCHECK(!pc->GetTransceivers()[0]->mid().has_value()); + pc->SetLocalDescription( + rtc::make_ref_counted() + .get(), + desc); + EXPECT_TRUE(pc->GetTransceivers()[0]->mid().has_value()); + }); + caller->pc()->CreateOffer(offer_observer.get(), RTCOfferAnswerOptions()); + EXPECT_TRUE_WAIT(offer_observer->was_called(), kWaitTimeout); +} + +// Test that transports are shown in the sender/receiver API after offer/answer. +// This only works in Unified Plan. +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + DtlsTransportsInstantiateInOfferAnswer) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnection(); + + EXPECT_FALSE(HasDtlsTransport(caller)); + EXPECT_FALSE(HasDtlsTransport(callee)); + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + caller->SetLocalDescription(CloneSessionDescription(offer.get())); + EXPECT_TRUE(HasDtlsTransport(caller)); + callee->SetRemoteDescription(std::move(offer)); + EXPECT_FALSE(HasDtlsTransport(callee)); + auto answer = callee->CreateAnswer(RTCOfferAnswerOptions()); + callee->SetLocalDescription(CloneSessionDescription(answer.get())); + EXPECT_TRUE(HasDtlsTransport(callee)); + caller->SetRemoteDescription(std::move(answer)); + EXPECT_TRUE(HasDtlsTransport(caller)); + + ASSERT_EQ(SignalingState::kStable, caller->signaling_state()); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, DtlsTransportsMergeWhenBundled) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnection(); + + EXPECT_FALSE(HasDtlsTransport(caller)); + EXPECT_FALSE(HasDtlsTransport(callee)); + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + caller->SetLocalDescription(CloneSessionDescription(offer.get())); + EXPECT_EQ(2, NumberOfDtlsTransports(caller)); + callee->SetRemoteDescription(std::move(offer)); + auto answer = callee->CreateAnswer(RTCOfferAnswerOptions()); + callee->SetLocalDescription(CloneSessionDescription(answer.get())); + caller->SetRemoteDescription(std::move(answer)); + EXPECT_EQ(1, NumberOfDtlsTransports(caller)); + + ASSERT_EQ(SignalingState::kStable, caller->signaling_state()); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + DtlsTransportsAreSeparateeWhenUnbundled) { + auto caller = CreatePeerConnectionWithAudioVideo(); + auto callee = CreatePeerConnection(); + + EXPECT_FALSE(HasDtlsTransport(caller)); + EXPECT_FALSE(HasDtlsTransport(callee)); + RTCOfferAnswerOptions unbundle_options; + unbundle_options.use_rtp_mux = false; + auto offer = caller->CreateOffer(unbundle_options); + caller->SetLocalDescription(CloneSessionDescription(offer.get())); + EXPECT_EQ(2, NumberOfDtlsTransports(caller)); + callee->SetRemoteDescription(std::move(offer)); + auto answer = callee->CreateAnswer(RTCOfferAnswerOptions()); + callee->SetLocalDescription(CloneSessionDescription(answer.get())); + EXPECT_EQ(2, NumberOfDtlsTransports(callee)); + caller->SetRemoteDescription(std::move(answer)); + EXPECT_EQ(2, NumberOfDtlsTransports(caller)); + + ASSERT_EQ(SignalingState::kStable, caller->signaling_state()); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + ShouldFireNegotiationNeededWhenNoChangesArePending) { + auto caller = CreatePeerConnection(); + EXPECT_FALSE(caller->observer()->has_negotiation_needed_event()); + auto transceiver = + caller->AddTransceiver(cricket::MEDIA_TYPE_AUDIO, RtpTransceiverInit()); + EXPECT_TRUE(caller->observer()->has_negotiation_needed_event()); + EXPECT_TRUE(caller->pc()->ShouldFireNegotiationNeededEvent( + caller->observer()->latest_negotiation_needed_event())); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + SuppressNegotiationNeededWhenOperationChainIsNotEmpty) { + auto caller = CreatePeerConnection(); + EXPECT_FALSE(caller->observer()->has_negotiation_needed_event()); + auto transceiver = + caller->AddTransceiver(cricket::MEDIA_TYPE_AUDIO, RtpTransceiverInit()); + EXPECT_TRUE(caller->observer()->has_negotiation_needed_event()); + + auto observer = rtc::make_ref_counted(); + caller->pc()->CreateOffer(observer.get(), RTCOfferAnswerOptions()); + // For this test to work, the operation has to be pending, i.e. the observer + // has not yet been invoked. + EXPECT_FALSE(observer->called()); + // Because the Operations Chain is not empty, the event is now suppressed. + EXPECT_FALSE(caller->pc()->ShouldFireNegotiationNeededEvent( + caller->observer()->latest_negotiation_needed_event())); + caller->observer()->clear_latest_negotiation_needed_event(); + + // When the Operations Chain becomes empty again, a new negotiation needed + // event will be generated that is not suppressed. + EXPECT_TRUE_WAIT(observer->called(), kWaitTimeout); + EXPECT_TRUE(caller->observer()->has_negotiation_needed_event()); + EXPECT_TRUE(caller->pc()->ShouldFireNegotiationNeededEvent( + caller->observer()->latest_negotiation_needed_event())); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, + SuppressNegotiationNeededWhenSignalingStateIsNotStable) { + auto caller = CreatePeerConnection(); + auto callee = CreatePeerConnection(); + auto offer = caller->CreateOffer(RTCOfferAnswerOptions()); + + EXPECT_FALSE(caller->observer()->has_negotiation_needed_event()); + auto transceiver = + callee->AddTransceiver(cricket::MEDIA_TYPE_AUDIO, RtpTransceiverInit()); + EXPECT_TRUE(callee->observer()->has_negotiation_needed_event()); + + // Change signaling state (to "have-remote-offer") by setting a remote offer. + callee->SetRemoteDescription(std::move(offer)); + // Because the signaling state is not "stable", the event is now suppressed. + EXPECT_FALSE(callee->pc()->ShouldFireNegotiationNeededEvent( + callee->observer()->latest_negotiation_needed_event())); + callee->observer()->clear_latest_negotiation_needed_event(); + + // Upon rolling back to "stable", a new negotiation needed event will be + // generated that is not suppressed. + callee->SetLocalDescription(CreateSessionDescription(SdpType::kRollback, "")); + EXPECT_TRUE(callee->observer()->has_negotiation_needed_event()); + EXPECT_TRUE(callee->pc()->ShouldFireNegotiationNeededEvent( + callee->observer()->latest_negotiation_needed_event())); +} + +TEST_F(PeerConnectionSignalingUnifiedPlanTest, RtxReofferApt) { + auto callee = CreatePeerConnection(); + + std::string sdp = + "v=0\r\n" + "o=- 8403615332048243445 2 IN IP4 127.0.0.1\r\n" + "s=-\r\n" + "t=0 0\r\n" + "m=video 9 UDP/TLS/RTP/SAVPF 102\r\n" + "c=IN IP4 0.0.0.0\r\n" + "a=rtcp:9 IN IP4 0.0.0.0\r\n" + "a=ice-ufrag:IZeV\r\n" + "a=ice-pwd:uaZhQD4rYM/Tta2qWBT1Bbt4\r\n" + "a=ice-options:trickle\r\n" + "a=fingerprint:sha-256 " + "D8:6C:3D:FA:23:E2:2C:63:11:2D:D0:86:BE:C4:D0:65:F9:42:F7:1C:06:04:27:E6:" + "1C:2C:74:01:8D:50:67:23\r\n" + "a=setup:actpass\r\n" + "a=mid:0\r\n" + "a=sendrecv\r\n" + "a=msid:stream track\r\n" + "a=rtcp-mux\r\n" + "a=rtcp-rsize\r\n" + "a=rtpmap:102 VP8/90000\r\n" + "a=rtcp-fb:102 goog-remb\r\n" + "a=rtcp-fb:102 transport-cc\r\n" + "a=rtcp-fb:102 ccm fir\r\n" + "a=rtcp-fb:102 nack\r\n" + "a=rtcp-fb:102 nack pli\r\n" + "a=ssrc:1224551896 cname:/exJcmhSLpyu9FgV\r\n"; + std::unique_ptr remote_description = + webrtc::CreateSessionDescription(SdpType::kOffer, sdp, nullptr); + + EXPECT_TRUE(callee->SetRemoteDescription(std::move(remote_description))); + + auto answer = callee->CreateAnswer(RTCOfferAnswerOptions()); + EXPECT_TRUE( + callee->SetLocalDescription(CloneSessionDescription(answer.get()))); + + callee->pc()->GetTransceivers()[0]->StopStandard(); + auto reoffer = callee->CreateOffer(RTCOfferAnswerOptions()); + auto codecs = reoffer->description() + ->contents()[0] + .media_description() + ->as_video() + ->codecs(); + ASSERT_GT(codecs.size(), 2u); + EXPECT_EQ(codecs[0].name, "VP8"); + EXPECT_EQ(codecs[1].name, "rtx"); + auto apt_it = codecs[1].params.find("apt"); + ASSERT_NE(apt_it, codecs[1].params.end()); + // The apt should match the id from the remote offer. + EXPECT_EQ(apt_it->second, rtc::ToString(codecs[0].id)); + EXPECT_EQ(apt_it->second, "102"); +} + +} // namespace webrtc -- cgit v1.2.3