diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc index 600d4e2620..5ed1d6a0f3 100644 --- a/call/rtp_transport_controller_send.cc +++ b/call/rtp_transport_controller_send.cc @@ -159,6 +159,31 @@ void RtpTransportControllerSend::DestroyRtpVideoSender( video_rtp_senders_.erase(it); } +void RtpTransportControllerSend::RegisterSendingRtpStream( + RtpRtcpInterface& rtp_module) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + // Allow pacer to send packets using this module. + packet_router_.AddSendRtpModule(&rtp_module, + /*remb_candidate=*/true); +} + +void RtpTransportControllerSend::DeRegisterSendingRtpStream( + RtpRtcpInterface& rtp_module) { + RTC_DCHECK_RUN_ON(&sequence_checker_); + // Disabling media, remove from packet router map to reduce size and + // prevent any stray packets in the pacer from asynchronously arriving + // to a disabled module. + packet_router_.RemoveSendRtpModule(&rtp_module); + // Clear the pacer queue of any packets pertaining to this module. + pacer_.RemovePacketsForSsrc(rtp_module.SSRC()); + if (rtp_module.RtxSsrc().has_value()) { + pacer_.RemovePacketsForSsrc(*rtp_module.RtxSsrc()); + } + if (rtp_module.FlexfecSsrc().has_value()) { + pacer_.RemovePacketsForSsrc(*rtp_module.FlexfecSsrc()); + } +} + void RtpTransportControllerSend::UpdateControlState() { absl::optional update = control_handler_->GetUpdate(); if (!update) diff --git a/call/rtp_transport_controller_send.h b/call/rtp_transport_controller_send.h index c0bca41a2b..6f6f0809a3 100644 --- a/call/rtp_transport_controller_send.h +++ b/call/rtp_transport_controller_send.h @@ -75,6 +75,8 @@ class RtpTransportControllerSend final RtpVideoSenderInterface* rtp_video_sender) override; // Implements RtpTransportControllerSendInterface + void RegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; + void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) override; PacketRouter* packet_router() override; NetworkStateEstimateObserver* network_state_estimate_observer() override; diff --git a/call/rtp_transport_controller_send_interface.h b/call/rtp_transport_controller_send_interface.h index 7edc135037..1938d86c57 100644 --- a/call/rtp_transport_controller_send_interface.h +++ b/call/rtp_transport_controller_send_interface.h @@ -47,6 +47,7 @@ class Transport; class PacketRouter; class RtpVideoSenderInterface; class RtpPacketSender; +class RtpRtcpInterface; struct RtpSenderObservers { RtcpRttStats* rtcp_rtt_stats; @@ -108,6 +109,12 @@ class RtpTransportControllerSendInterface { virtual void DestroyRtpVideoSender( RtpVideoSenderInterface* rtp_video_sender) = 0; + // Register a specific RTP stream as sending. This means that the pacer and + // packet router can send packets using this RTP stream. + virtual void RegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0; + // Pacer and PacketRouter stop using this RTP stream. + virtual void DeRegisterSendingRtpStream(RtpRtcpInterface& rtp_module) = 0; + virtual NetworkStateEstimateObserver* network_state_estimate_observer() = 0; virtual TransportFeedbackObserver* transport_feedback_observer() = 0; diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index 1ace08fa32..580850359c 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -470,85 +470,41 @@ RtpVideoSender::RtpVideoSender( } RtpVideoSender::~RtpVideoSender() { - // TODO(bugs.webrtc.org/13517): Remove once RtpVideoSender gets deleted on the - // transport task queue. - transport_checker_.Detach(); - + RTC_DCHECK_RUN_ON(&transport_checker_); SetActiveModulesLocked( - std::vector(rtp_streams_.size(), /*active=*/false)); - - RTC_DCHECK(!registered_for_feedback_); + /*sending=*/false); } -void RtpVideoSender::Stop() { +void RtpVideoSender::SetSending(bool enabled) { RTC_DCHECK_RUN_ON(&transport_checker_); MutexLock lock(&mutex_); - if (!active_) + if (enabled == active_) { return; - - const std::vector active_modules(rtp_streams_.size(), false); - SetActiveModulesLocked(active_modules); + } + SetActiveModulesLocked(/*sending=*/enabled); } -void RtpVideoSender::SetActiveModules(const std::vector& active_modules) { +void RtpVideoSender::SetActiveModulesLocked(bool sending) { RTC_DCHECK_RUN_ON(&transport_checker_); - MutexLock lock(&mutex_); - return SetActiveModulesLocked(active_modules); -} - -void RtpVideoSender::SetActiveModulesLocked( - const std::vector& active_modules) { - RTC_DCHECK_RUN_ON(&transport_checker_); - RTC_CHECK_EQ(rtp_streams_.size(), active_modules.size()); - active_ = false; - for (size_t i = 0; i < active_modules.size(); ++i) { - if (active_modules[i]) { - active_ = true; - } - + if (active_ == sending) { + return; + } + active_ = sending; + for (size_t i = 0; i < rtp_streams_.size(); ++i) { RtpRtcpInterface& rtp_module = *rtp_streams_[i].rtp_rtcp; - const bool was_active = rtp_module.Sending(); - const bool should_be_active = active_modules[i]; - - rtp_module.SetSendingStatus(active_modules[i]); - - if (was_active && !should_be_active) { - // Disabling media, remove from packet router map to reduce size and - // prevent any stray packets in the pacer from asynchronously arriving - // to a disabled module. - transport_->packet_router()->RemoveSendRtpModule(&rtp_module); - - // Clear the pacer queue of any packets pertaining to this module. - transport_->packet_sender()->RemovePacketsForSsrc(rtp_module.SSRC()); - if (rtp_module.RtxSsrc().has_value()) { - transport_->packet_sender()->RemovePacketsForSsrc( - *rtp_module.RtxSsrc()); - } - if (rtp_module.FlexfecSsrc().has_value()) { - transport_->packet_sender()->RemovePacketsForSsrc( - *rtp_module.FlexfecSsrc()); - } - } - - // If set to false this module won't send media. - rtp_module.SetSendingMediaStatus(active_modules[i]); - - if (!was_active && should_be_active) { - // Turning on media, register with packet router. - transport_->packet_router()->AddSendRtpModule(&rtp_module, - /*remb_candidate=*/true); + rtp_module.SetSendingStatus(sending); + rtp_module.SetSendingMediaStatus(sending); + if (sending) { + transport_->RegisterSendingRtpStream(rtp_module); + } else { + transport_->DeRegisterSendingRtpStream(rtp_module); } } - if (!active_) { - auto* feedback_provider = transport_->GetStreamFeedbackProvider(); - if (registered_for_feedback_) { - feedback_provider->DeRegisterStreamFeedbackObserver(this); - registered_for_feedback_ = false; - } - } else if (!registered_for_feedback_) { - auto* feedback_provider = transport_->GetStreamFeedbackProvider(); + auto* feedback_provider = transport_->GetStreamFeedbackProvider(); + if (!sending) { + feedback_provider->DeRegisterStreamFeedbackObserver(this); + } else { feedback_provider->RegisterStreamFeedbackObserver(rtp_config_.ssrcs, this); - registered_for_feedback_ = true; } } diff --git a/call/rtp_video_sender.h b/call/rtp_video_sender.h index 10b0d19d05..957b46e560 100644 --- a/call/rtp_video_sender.h +++ b/call/rtp_video_sender.h @@ -95,11 +95,7 @@ class RtpVideoSender : public RtpVideoSenderInterface, RtpVideoSender(const RtpVideoSender&) = delete; RtpVideoSender& operator=(const RtpVideoSender&) = delete; - // Sets the sending status of the rtp modules and appropriately sets the - // payload router to active if any rtp modules are active. - void SetActiveModules(const std::vector& active_modules) - RTC_LOCKS_EXCLUDED(mutex_) override; - void Stop() RTC_LOCKS_EXCLUDED(mutex_) override; + void SetSending(bool enabled) RTC_LOCKS_EXCLUDED(mutex_) override; bool IsActive() RTC_LOCKS_EXCLUDED(mutex_) override; void OnNetworkAvailability(bool network_available) @@ -160,7 +156,7 @@ class RtpVideoSender : public RtpVideoSenderInterface, private: bool IsActiveLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); - void SetActiveModulesLocked(const std::vector& active_modules) + void SetActiveModulesLocked(bool sending) RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); void UpdateModuleSendingState() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_); void ConfigureProtection(); @@ -184,7 +180,6 @@ class RtpVideoSender : public RtpVideoSenderInterface, // transport task queue. mutable Mutex mutex_; bool active_ RTC_GUARDED_BY(mutex_); - bool registered_for_feedback_ RTC_GUARDED_BY(transport_checker_) = false; const std::unique_ptr fec_controller_; bool fec_allowed_ RTC_GUARDED_BY(mutex_); diff --git a/call/rtp_video_sender_interface.h b/call/rtp_video_sender_interface.h index 3f2877155a..6bbcb7f46e 100644 --- a/call/rtp_video_sender_interface.h +++ b/call/rtp_video_sender_interface.h @@ -31,12 +31,8 @@ struct FecProtectionParams; class RtpVideoSenderInterface : public EncodedImageCallback, public FecControllerOverride { public: - // Sets the sending status of the rtp modules and appropriately sets the - // RtpVideoSender to active if any rtp modules are active. - // A module will only send packet if beeing active. - virtual void SetActiveModules(const std::vector& active_modules) = 0; - // Set the sending status of all rtp modules to inactive. - virtual void Stop() = 0; + // Sets weather or not RTP packets is allowed to be sent on this sender. + virtual void SetSending(bool enabled) = 0; virtual bool IsActive() = 0; virtual void OnNetworkAvailability(bool network_available) = 0; diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc index cf099afaa3..72234aa409 100644 --- a/call/rtp_video_sender_unittest.cc +++ b/call/rtp_video_sender_unittest.cc @@ -180,17 +180,13 @@ class RtpVideoSenderTestFixture { /*frame_transformer=*/nullptr, field_trials) {} - ~RtpVideoSenderTestFixture() { Stop(); } + ~RtpVideoSenderTestFixture() { SetSending(false); } RtpVideoSender* router() { return router_.get(); } MockTransport& transport() { return transport_; } void AdvanceTime(TimeDelta delta) { time_controller_.AdvanceTime(delta); } - void Stop() { router_->Stop(); } - - void SetActiveModules(const std::vector& active_modules) { - router_->SetActiveModules(active_modules); - } + void SetSending(bool sending) { router_->SetSending(sending); } private: test::ScopedKeyValueConfig field_trials_; @@ -227,20 +223,20 @@ TEST(RtpVideoSenderTest, SendOnOneModule) { EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({false}); + test.SetSending(false); EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); - test.SetActiveModules({true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image, nullptr).error); } -TEST(RtpVideoSenderTest, SendSimulcastSetActive) { +TEST(RtpVideoSenderTest, OnEncodedImageReturnOkWhenSendingTrue) { constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image_1; encoded_image_1.SetRtpTimestamp(1); @@ -254,7 +250,7 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActive) { CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; - test.SetActiveModules({true, true}); + test.SetSending(true); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); @@ -262,20 +258,9 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActive) { encoded_image_2.SetSimulcastIndex(1); EXPECT_EQ(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); - - // Inactive. - test.Stop(); - EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); - EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); } -// Tests how setting individual rtp modules to active affects the overall -// behavior of the payload router. First sets one module to active and checks -// that outgoing data can be sent on this module, and checks that no data can -// be sent if both modules are inactive. -TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { +TEST(RtpVideoSenderTest, OnEncodedImageReturnErrorCodeWhenSendingFalse) { constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image_1; encoded_image_1.SetRtpTimestamp(1); @@ -291,23 +276,15 @@ TEST(RtpVideoSenderTest, SendSimulcastSetActiveModules) { CodecSpecificInfo codec_info; codec_info.codecType = kVideoCodecVP8; - // Only setting one stream to active will still set the payload router to - // active and allow sending data on the active stream. - std::vector active_modules({true, false}); - test.SetActiveModules(active_modules); - EXPECT_EQ(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); - - // Setting both streams to inactive will turn the payload router to + // Setting rtp streams to inactive will turn the payload router to // inactive. - active_modules = {false, false}; - test.SetActiveModules(active_modules); + test.SetSending(false); // An incoming encoded image will not ask the module to send outgoing data // because the payload router is inactive. EXPECT_NE(EncodedImageCallback::Result::OK, test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); EXPECT_NE(EncodedImageCallback::Result::OK, - test.router()->OnEncodedImage(encoded_image_1, &codec_info).error); + test.router()->OnEncodedImage(encoded_image_2, &codec_info).error); } TEST(RtpVideoSenderTest, @@ -324,7 +301,7 @@ TEST(RtpVideoSenderTest, codec_info.codecType = kVideoCodecVP8; RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); // A layer is sent on both rtp streams. test.router()->OnVideoLayersAllocationUpdated( {.active_spatial_layers = {{.rtp_stream_index = 0}, @@ -347,7 +324,7 @@ TEST(RtpVideoSenderTest, TEST(RtpVideoSenderTest, CreateWithNoPreviousStates) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); std::map initial_states = test.router()->GetRtpPayloadStates(); @@ -372,7 +349,7 @@ TEST(RtpVideoSenderTest, CreateWithPreviousStates) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, states); - test.SetActiveModules({true, true}); + test.SetSending(true); std::map initial_states = test.router()->GetRtpPayloadStates(); @@ -412,7 +389,7 @@ TEST(RtpVideoSenderTest, FrameCountCallbacks) { test.router()->OnEncodedImage(encoded_image, nullptr).error); ::testing::Mock::VerifyAndClearExpectations(&callback); - test.SetActiveModules({true}); + test.SetSending(true); FrameCounts frame_counts; EXPECT_CALL(callback, FrameCountUpdated(_, kSsrc1)) @@ -441,7 +418,7 @@ TEST(RtpVideoSenderTest, FrameCountCallbacks) { TEST(RtpVideoSenderTest, DoesNotRetrasmitAckedPackets) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); constexpr uint8_t kPayload = 'a'; EncodedImage encoded_image; @@ -606,7 +583,7 @@ TEST(RtpVideoSenderTest, RetransmitsOnTransportWideLossInfo) { TEST(RtpVideoSenderTest, EarlyRetransmits) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); const uint8_t kPayload[1] = {'a'}; EncodedImage encoded_image; @@ -701,7 +678,7 @@ TEST(RtpVideoSenderTest, EarlyRetransmits) { TEST(RtpVideoSenderTest, SupportsDependencyDescriptor) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -773,7 +750,7 @@ TEST(RtpVideoSenderTest, EXPECT_TRUE(sent_packets.emplace_back(&extensions).Parse(packet)); return true; }); - test.SetActiveModules({true}); + test.SetSending(true); EncodedImage key_frame_image; key_frame_image._frameType = VideoFrameType::kVideoFrameKey; @@ -807,7 +784,7 @@ TEST(RtpVideoSenderTest, TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -863,7 +840,7 @@ TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9) { TEST(RtpVideoSenderTest, SupportsDependencyDescriptorForVp9NotProvidedByEncoder) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -918,7 +895,7 @@ TEST(RtpVideoSenderTest, GenerateDependecyDescriptorForGenericCodecs) { test::ScopedKeyValueConfig field_trials( "WebRTC-GenericCodecDependencyDescriptor/Enabled/"); RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -964,7 +941,7 @@ TEST(RtpVideoSenderTest, GenerateDependecyDescriptorForGenericCodecs) { TEST(RtpVideoSenderTest, SupportsStoppingUsingDependencyDescriptor) { RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -1049,7 +1026,7 @@ TEST(RtpVideoSenderTest, OverheadIsSubtractedFromTargetBitrate) { kRtpHeaderSizeBytes + kTransportPacketOverheadBytes; RtpVideoSenderTestFixture test({kSsrc1}, {}, kPayloadType, {}, &field_trials); test.router()->OnTransportOverheadChanged(kTransportPacketOverheadBytes); - test.SetActiveModules({true}); + test.SetSending(true); { test.router()->OnBitrateUpdated(CreateBitrateAllocationUpdate(300000), @@ -1076,7 +1053,7 @@ TEST(RtpVideoSenderTest, OverheadIsSubtractedFromTargetBitrate) { TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {}); - test.SetActiveModules({true}); + test.SetSending(true); RtpHeaderExtensionMap extensions; extensions.Register( @@ -1127,13 +1104,13 @@ TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { // Disable the sending module and advance time slightly. No packets should be // sent. - test.SetActiveModules({false}); + test.SetSending(false); test.AdvanceTime(TimeDelta::Millis(20)); EXPECT_TRUE(sent_packets.empty()); // Reactive the send module - any packets should have been removed, so nothing // should be transmitted. - test.SetActiveModules({true}); + test.SetSending(true); test.AdvanceTime(TimeDelta::Millis(33)); EXPECT_TRUE(sent_packets.empty()); @@ -1156,7 +1133,7 @@ TEST(RtpVideoSenderTest, ClearsPendingPacketsOnInactivation) { TEST(RtpVideoSenderTest, RetransmitsBaseLayerOnly) { RtpVideoSenderTestFixture test({kSsrc1, kSsrc2}, {kRtxSsrc1, kRtxSsrc2}, kPayloadType, {}); - test.SetActiveModules({true, true}); + test.SetSending(true); test.router()->SetRetransmissionMode(kRetransmitBaseLayer); constexpr uint8_t kPayload = 'a'; diff --git a/call/test/mock_rtp_transport_controller_send.h b/call/test/mock_rtp_transport_controller_send.h index b24e5a59ec..2a0bc233ff 100644 --- a/call/test/mock_rtp_transport_controller_send.h +++ b/call/test/mock_rtp_transport_controller_send.h @@ -50,6 +50,11 @@ class MockRtpTransportControllerSend DestroyRtpVideoSender, (RtpVideoSenderInterface*), (override)); + MOCK_METHOD(void, RegisterSendingRtpStream, (RtpRtcpInterface&), (override)); + MOCK_METHOD(void, + DeRegisterSendingRtpStream, + (RtpRtcpInterface&), + (override)); MOCK_METHOD(PacketRouter*, packet_router, (), (override)); MOCK_METHOD(NetworkStateEstimateObserver*, network_state_estimate_observer, diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc index e5ff2cd727..8c748dd81d 100644 --- a/video/video_send_stream_impl.cc +++ b/video/video_send_stream_impl.cc @@ -627,10 +627,9 @@ bool VideoSendStreamImpl::started() { void VideoSendStreamImpl::Start() { RTC_DCHECK_RUN_ON(&thread_checker_); - const std::vector active_layers(config_.rtp.ssrcs.size(), true); // This sender is allowed to send RTP packets. Start monitoring and allocating // a rate if there is also active encodings. (has_active_encodings_). - rtp_video_sender_->SetActiveModules(active_layers); + rtp_video_sender_->SetSending(true); if (!IsRunning() && has_active_encodings_) { StartupVideoSendStream(); } @@ -681,7 +680,7 @@ void VideoSendStreamImpl::Stop() { return; TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop"); - rtp_video_sender_->Stop(); + rtp_video_sender_->SetSending(false); if (IsRunning()) { StopVideoSendStream(); } diff --git a/video/video_send_stream_impl_unittest.cc b/video/video_send_stream_impl_unittest.cc index e3a1618939..fe5f999a39 100644 --- a/video/video_send_stream_impl_unittest.cc +++ b/video/video_send_stream_impl_unittest.cc @@ -75,6 +75,7 @@ using ::testing::Invoke; using ::testing::Mock; using ::testing::NiceMock; using ::testing::Return; +using ::testing::SaveArg; constexpr int64_t kDefaultInitialBitrateBps = 333000; const double kDefaultBitratePriority = 0.5; @@ -87,8 +88,7 @@ std::string GetAlrProbingExperimentString() { } class MockRtpVideoSender : public RtpVideoSenderInterface { public: - MOCK_METHOD(void, SetActiveModules, (const std::vector&), (override)); - MOCK_METHOD(void, Stop, (), (override)); + MOCK_METHOD(void, SetSending, (bool sending), (override)); MOCK_METHOD(bool, IsActive, (), (override)); MOCK_METHOD(void, OnNetworkAvailability, (bool), (override)); MOCK_METHOD((std::map), @@ -158,19 +158,11 @@ class VideoSendStreamImplTest : public ::testing::Test { .WillRepeatedly(Return(&packet_router_)); EXPECT_CALL(transport_controller_, CreateRtpVideoSender) .WillRepeatedly(Return(&rtp_video_sender_)); - ON_CALL(rtp_video_sender_, Stop()).WillByDefault(::testing::Invoke([&] { - active_modules_.clear(); + ON_CALL(rtp_video_sender_, IsActive()).WillByDefault(Invoke([&]() { + return rtp_sending_; })); - ON_CALL(rtp_video_sender_, IsActive()) - .WillByDefault(::testing::Invoke([&]() { - for (bool enabled : active_modules_) { - if (enabled) - return true; - } - return false; - })); - ON_CALL(rtp_video_sender_, SetActiveModules) - .WillByDefault(::testing::SaveArg<0>(&active_modules_)); + ON_CALL(rtp_video_sender_, SetSending) + .WillByDefault(SaveArg<0>(&rtp_sending_)); } ~VideoSendStreamImplTest() {} @@ -225,7 +217,7 @@ class VideoSendStreamImplTest : public ::testing::Test { NiceMock bitrate_allocator_; NiceMock* video_stream_encoder_ = nullptr; NiceMock rtp_video_sender_; - std::vector active_modules_; + bool rtp_sending_ = false; RtcEventLogNull event_log_; VideoSendStream::Config config_;