diff --git a/BUILD.gn b/BUILD.gn index 0c2096b516..bfe6d02ab9 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -489,10 +489,10 @@ if (rtc_include_tests) { "rtc_base:rtc_json_unittests", "rtc_base:rtc_numerics_unittests", "rtc_base:rtc_task_queue_unittests", - "rtc_base:sequenced_task_checker_unittests", "rtc_base:sigslot_unittest", "rtc_base:weak_ptr_unittests", "rtc_base/experiments:experiments_unittests", + "rtc_base/synchronization:sequence_checker_unittests", "rtc_base/task_utils:to_queued_task_unittests", "sdk:sdk_tests", "test/scenario/network:network_emulation_unittests", diff --git a/call/BUILD.gn b/call/BUILD.gn index 11be068620..346cbe2f88 100644 --- a/call/BUILD.gn +++ b/call/BUILD.gn @@ -185,7 +185,7 @@ rtc_source_set("bitrate_allocator") { "../modules/bitrate_controller", "../rtc_base:checks", "../rtc_base:rtc_base_approved", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "../system_wrappers:field_trial", "../system_wrappers:metrics", @@ -244,10 +244,10 @@ rtc_static_library("call") { "../rtc_base:rtc_base_approved", "../rtc_base:rtc_task_queue", "../rtc_base:safe_minmax", - "../rtc_base:sequenced_task_checker", "../rtc_base/experiments:field_trial_parser", "../rtc_base/network:sent_packet", "../rtc_base/synchronization:rw_lock_wrapper", + "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "../system_wrappers:field_trial", "../system_wrappers:metrics", @@ -293,7 +293,7 @@ rtc_source_set("simulated_network") { "../api/units:timestamp", "../rtc_base:checks", "../rtc_base:rtc_base_approved", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/types:optional", ] @@ -324,7 +324,7 @@ rtc_source_set("fake_network") { "../modules/utility", "../rtc_base:checks", "../rtc_base:rtc_base_approved", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "//third_party/abseil-cpp/absl/memory", ] diff --git a/call/bitrate_allocator.cc b/call/bitrate_allocator.cc index 9ddc78653a..9d2705f66c 100644 --- a/call/bitrate_allocator.cc +++ b/call/bitrate_allocator.cc @@ -77,7 +77,7 @@ BitrateAllocator::~BitrateAllocator() { } void BitrateAllocator::UpdateStartRate(uint32_t start_rate_bps) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); last_non_zero_bitrate_bps_ = start_rate_bps; } @@ -100,7 +100,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, uint8_t fraction_loss, int64_t rtt, int64_t bwe_period_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); last_target_bps_ = target_bitrate_bps; last_link_capacity_bps_ = link_capacity_bps; last_non_zero_bitrate_bps_ = @@ -161,7 +161,7 @@ void BitrateAllocator::OnNetworkChanged(uint32_t target_bitrate_bps, void BitrateAllocator::AddObserver(BitrateAllocatorObserver* observer, MediaStreamAllocationConfig config) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); RTC_DCHECK_GT(config.bitrate_priority, 0); RTC_DCHECK(std::isnormal(config.bitrate_priority)); auto it = FindObserverConfig(observer); @@ -254,7 +254,7 @@ void BitrateAllocator::UpdateAllocationLimits() { } void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); auto it = FindObserverConfig(observer); if (it != bitrate_observer_configs_.end()) { @@ -266,7 +266,7 @@ void BitrateAllocator::RemoveObserver(BitrateAllocatorObserver* observer) { int BitrateAllocator::GetStartBitrate( BitrateAllocatorObserver* observer) const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); const auto& it = FindObserverConfig(observer); if (it == bitrate_observer_configs_.end()) { // This observer hasn't been added yet, just give it its fair share. @@ -285,7 +285,7 @@ int BitrateAllocator::GetStartBitrate( void BitrateAllocator::SetBitrateAllocationStrategy( std::unique_ptr bitrate_allocation_strategy) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); bitrate_allocation_strategy_ = std::move(bitrate_allocation_strategy); } diff --git a/call/bitrate_allocator.h b/call/bitrate_allocator.h index bb2d149c80..f35f3f7d7d 100644 --- a/call/bitrate_allocator.h +++ b/call/bitrate_allocator.h @@ -21,7 +21,7 @@ #include "api/call/bitrate_allocation.h" #include "rtc_base/bitrate_allocation_strategy.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" namespace webrtc { @@ -226,7 +226,7 @@ class BitrateAllocator : public BitrateAllocatorInterface { // AudioPriorityBitrateAllocationStrategy. static uint8_t GetTransmissionMaxBitrateMultiplier(); - rtc::SequencedTaskChecker sequenced_checker_; + SequenceChecker sequenced_checker_; LimitObserver* const limit_observer_ RTC_GUARDED_BY(&sequenced_checker_); // Stored in a list to keep track of the insertion order. ObserverConfigs bitrate_observer_configs_ RTC_GUARDED_BY(&sequenced_checker_); diff --git a/call/call.cc b/call/call.cc index 38a4dd5a6d..84f29d80db 100644 --- a/call/call.cc +++ b/call/call.cc @@ -50,9 +50,9 @@ #include "rtc_base/location.h" #include "rtc_base/logging.h" #include "rtc_base/numerics/safe_minmax.h" -#include "rtc_base/sequenced_task_checker.h" #include "rtc_base/strings/string_builder.h" #include "rtc_base/synchronization/rw_lock_wrapper.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/time_utils.h" #include "rtc_base/trace_event.h" @@ -285,7 +285,7 @@ class Call final : public webrtc::Call, const std::unique_ptr call_stats_; const std::unique_ptr bitrate_allocator_; Call::Config config_; - rtc::SequencedTaskChecker configuration_sequence_checker_; + SequenceChecker configuration_sequence_checker_; NetworkState audio_network_state_; NetworkState video_network_state_; @@ -493,7 +493,7 @@ Call::Call(Clock* clock, } Call::~Call() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_CHECK(audio_send_ssrcs_.empty()); RTC_CHECK(video_send_ssrcs_.empty()); @@ -698,14 +698,14 @@ void Call::UpdateReceiveHistograms() { } PacketReceiver* Call::Receiver() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); return this; } webrtc::AudioSendStream* Call::CreateAudioSendStream( const webrtc::AudioSendStream::Config& config) { TRACE_EVENT0("webrtc", "Call::CreateAudioSendStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(media_transport() == config.media_transport); @@ -747,7 +747,7 @@ webrtc::AudioSendStream* Call::CreateAudioSendStream( void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) { TRACE_EVENT0("webrtc", "Call::DestroyAudioSendStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(send_stream != nullptr); send_stream->Stop(); @@ -776,7 +776,7 @@ void Call::DestroyAudioSendStream(webrtc::AudioSendStream* send_stream) { webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( const webrtc::AudioReceiveStream::Config& config) { TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RegisterRateObserver(); event_log_->Log(absl::make_unique( CreateRtcLogStreamConfig(config))); @@ -806,7 +806,7 @@ webrtc::AudioReceiveStream* Call::CreateAudioReceiveStream( void Call::DestroyAudioReceiveStream( webrtc::AudioReceiveStream* receive_stream) { TRACE_EVENT0("webrtc", "Call::DestroyAudioReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(receive_stream != nullptr); webrtc::internal::AudioReceiveStream* audio_receive_stream = static_cast(receive_stream); @@ -836,7 +836,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream( VideoEncoderConfig encoder_config, std::unique_ptr fec_controller) { TRACE_EVENT0("webrtc", "Call::CreateVideoSendStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(media_transport() == config.media_transport); @@ -891,7 +891,7 @@ webrtc::VideoSendStream* Call::CreateVideoSendStream( void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { TRACE_EVENT0("webrtc", "Call::DestroyVideoSendStream"); RTC_DCHECK(send_stream != nullptr); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); send_stream->Stop(); @@ -929,7 +929,7 @@ void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) { webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( webrtc::VideoReceiveStream::Config configuration) { TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); receive_side_cc_.SetSendPeriodicFeedback( SendPeriodicFeedback(configuration.rtp.extensions)); @@ -967,7 +967,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream( void Call::DestroyVideoReceiveStream( webrtc::VideoReceiveStream* receive_stream) { TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(receive_stream != nullptr); VideoReceiveStream* receive_stream_impl = static_cast(receive_stream); @@ -994,7 +994,7 @@ void Call::DestroyVideoReceiveStream( FlexfecReceiveStream* Call::CreateFlexfecReceiveStream( const FlexfecReceiveStream::Config& config) { TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RecoveredPacketReceiver* recovered_packet_receiver = this; @@ -1026,7 +1026,7 @@ FlexfecReceiveStream* Call::CreateFlexfecReceiveStream( void Call::DestroyFlexfecReceiveStream(FlexfecReceiveStream* receive_stream) { TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream"); - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); RTC_DCHECK(receive_stream != nullptr); { @@ -1052,7 +1052,7 @@ RtpTransportControllerSendInterface* Call::GetTransportControllerSend() { Call::Stats Call::GetStats() const { // TODO(solenberg): Some test cases in EndToEndTest use this from a different // thread. Re-enable once that is fixed. - // RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + // RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); Stats stats; // Fetch available send/receive bitrates. std::vector ssrcs; @@ -1101,7 +1101,7 @@ void Call::SetBitrateAllocationStrategy( } void Call::SignalChannelNetworkState(MediaType media, NetworkState state) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); switch (media) { case MediaType::AUDIO: audio_network_state_ = state; @@ -1141,7 +1141,7 @@ void Call::OnAudioTransportOverheadChanged(int transport_overhead_per_packet) { } void Call::UpdateAggregateNetworkState() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); bool have_audio = false; bool have_video = false; @@ -1453,7 +1453,7 @@ PacketReceiver::DeliveryStatus Call::DeliverPacket( MediaType media_type, rtc::CopyOnWriteBuffer packet, int64_t packet_time_us) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&configuration_sequence_checker_); + RTC_DCHECK_RUN_ON(&configuration_sequence_checker_); if (RtpHeaderParser::IsRtcp(packet.cdata(), packet.size())) return DeliverRtcp(media_type, packet.cdata(), packet.size()); diff --git a/logging/BUILD.gn b/logging/BUILD.gn index 8edfe3cdd2..81f24b5f20 100644 --- a/logging/BUILD.gn +++ b/logging/BUILD.gn @@ -264,7 +264,7 @@ rtc_static_library("rtc_event_log_impl_base") { "../rtc_base:rtc_base_approved", "../rtc_base:rtc_task_queue", "../rtc_base:safe_minmax", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/types:optional", ] diff --git a/logging/rtc_event_log/rtc_event_log_impl.cc b/logging/rtc_event_log/rtc_event_log_impl.cc index 1b2e82a1b8..f62f690cd6 100644 --- a/logging/rtc_event_log/rtc_event_log_impl.cc +++ b/logging/rtc_event_log/rtc_event_log_impl.cc @@ -30,7 +30,7 @@ #include "rtc_base/logging.h" #include "rtc_base/numerics/safe_conversions.h" #include "rtc_base/numerics/safe_minmax.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/time_utils.h" @@ -114,7 +114,7 @@ class RtcEventLogImpl final : public RtcEventLog { // Make sure that the event log is "managed" - created/destroyed, as well // as started/stopped - from the same thread/task-queue. - rtc::SequencedTaskChecker owner_sequence_checker_; + SequenceChecker owner_sequence_checker_; // History containing all past configuration events. std::deque> config_history_ @@ -158,7 +158,7 @@ RtcEventLogImpl::RtcEventLogImpl( } RtcEventLogImpl::~RtcEventLogImpl() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_); + RTC_DCHECK_RUN_ON(&owner_sequence_checker_); // If we're logging to the output, this will stop that. Blocking function. StopLogging(); @@ -172,7 +172,7 @@ RtcEventLogImpl::~RtcEventLogImpl() { bool RtcEventLogImpl::StartLogging(std::unique_ptr output, int64_t output_period_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_); + RTC_DCHECK_RUN_ON(&owner_sequence_checker_); RTC_DCHECK(output_period_ms == kImmediateOutput || output_period_ms > 0); @@ -207,7 +207,7 @@ bool RtcEventLogImpl::StartLogging(std::unique_ptr output, } void RtcEventLogImpl::StopLogging() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&owner_sequence_checker_); + RTC_DCHECK_RUN_ON(&owner_sequence_checker_); RTC_LOG(LS_INFO) << "Stopping WebRTC event log."; diff --git a/media/BUILD.gn b/media/BUILD.gn index 3afaf35ca5..f8958495cf 100644 --- a/media/BUILD.gn +++ b/media/BUILD.gn @@ -75,8 +75,8 @@ rtc_static_library("rtc_media_base") { "../rtc_base:rtc_base_approved", "../rtc_base:rtc_task_queue", "../rtc_base:sanitizer", - "../rtc_base:sequenced_task_checker", "../rtc_base:stringutils", + "../rtc_base/synchronization:sequence_checker", ] sources = [ "base/adapted_video_track_source.cc", @@ -167,8 +167,8 @@ rtc_static_library("rtc_simulcast_encoder_adapter") { "../modules/video_coding:video_coding_utility", "../rtc_base:checks", "../rtc_base:rtc_base_approved", - "../rtc_base:sequenced_task_checker", "../rtc_base/experiments:rate_control_settings", + "../rtc_base/synchronization:sequence_checker", "../rtc_base/system:rtc_export", "../system_wrappers", "../system_wrappers:field_trial", diff --git a/media/engine/simulcast_encoder_adapter.cc b/media/engine/simulcast_encoder_adapter.cc index cc26a3013a..09b05456c3 100644 --- a/media/engine/simulcast_encoder_adapter.cc +++ b/media/engine/simulcast_encoder_adapter.cc @@ -144,7 +144,7 @@ SimulcastEncoderAdapter::~SimulcastEncoderAdapter() { } int SimulcastEncoderAdapter::Release() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_); + RTC_DCHECK_RUN_ON(&encoder_queue_); while (!streaminfos_.empty()) { std::unique_ptr encoder = @@ -169,7 +169,7 @@ int SimulcastEncoderAdapter::Release() { int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst, int number_of_cores, size_t max_payload_size) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_); + RTC_DCHECK_RUN_ON(&encoder_queue_); if (number_of_cores < 1) { return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; @@ -339,7 +339,7 @@ int SimulcastEncoderAdapter::InitEncode(const VideoCodec* inst, int SimulcastEncoderAdapter::Encode( const VideoFrame& input_image, const std::vector* frame_types) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_); + RTC_DCHECK_RUN_ON(&encoder_queue_); if (!Initialized()) { return WEBRTC_VIDEO_CODEC_UNINITIALIZED; @@ -438,7 +438,7 @@ int SimulcastEncoderAdapter::Encode( int SimulcastEncoderAdapter::RegisterEncodeCompleteCallback( EncodedImageCallback* callback) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_); + RTC_DCHECK_RUN_ON(&encoder_queue_); encoded_complete_callback_ = callback; return WEBRTC_VIDEO_CODEC_OK; } @@ -446,7 +446,7 @@ int SimulcastEncoderAdapter::RegisterEncodeCompleteCallback( int SimulcastEncoderAdapter::SetRateAllocation( const VideoBitrateAllocation& bitrate, uint32_t new_framerate) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_); + RTC_DCHECK_RUN_ON(&encoder_queue_); if (!Initialized()) { return WEBRTC_VIDEO_CODEC_UNINITIALIZED; diff --git a/media/engine/simulcast_encoder_adapter.h b/media/engine/simulcast_encoder_adapter.h index 202967f975..a7b0361d56 100644 --- a/media/engine/simulcast_encoder_adapter.h +++ b/media/engine/simulcast_encoder_adapter.h @@ -22,7 +22,7 @@ #include "api/video_codecs/sdp_video_format.h" #include "modules/video_coding/include/video_codec_interface.h" #include "rtc_base/atomic_ops.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/system/rtc_export.h" namespace webrtc { @@ -109,7 +109,7 @@ class RTC_EXPORT SimulcastEncoderAdapter : public VideoEncoder { EncoderInfo encoder_info_; // Used for checking the single-threaded access of the encoder interface. - rtc::SequencedTaskChecker encoder_queue_; + SequenceChecker encoder_queue_; // Store encoders in between calls to Release and InitEncode, so they don't // have to be recreated. Remaining encoders are destroyed by the destructor. diff --git a/modules/congestion_controller/rtp/BUILD.gn b/modules/congestion_controller/rtp/BUILD.gn index a075cce448..357e1a6b45 100644 --- a/modules/congestion_controller/rtp/BUILD.gn +++ b/modules/congestion_controller/rtp/BUILD.gn @@ -32,7 +32,7 @@ rtc_source_set("control_handler") { "../../../rtc_base:checks", "../../../rtc_base:rate_limiter", "../../../rtc_base:safe_minmax", - "../../../rtc_base:sequenced_task_checker", + "../../../rtc_base/synchronization:sequence_checker", "../../../system_wrappers", "../../../system_wrappers:field_trial", "../../pacing", diff --git a/modules/congestion_controller/rtp/control_handler.cc b/modules/congestion_controller/rtp/control_handler.cc index 808c195485..9272d99328 100644 --- a/modules/congestion_controller/rtp/control_handler.cc +++ b/modules/congestion_controller/rtp/control_handler.cc @@ -37,22 +37,22 @@ CongestionControlHandler::~CongestionControlHandler() {} void CongestionControlHandler::SetTargetRate( TargetTransferRate new_target_rate) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); last_incoming_ = new_target_rate; } void CongestionControlHandler::SetNetworkAvailability(bool network_available) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); network_available_ = network_available; } void CongestionControlHandler::SetPacerQueue(TimeDelta expected_queue_time) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); pacer_expected_queue_ms_ = expected_queue_time.ms(); } absl::optional CongestionControlHandler::GetUpdate() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_checker_); + RTC_DCHECK_RUN_ON(&sequenced_checker_); if (!last_incoming_.has_value()) return absl::nullopt; TargetTransferRate new_outgoing = *last_incoming_; diff --git a/modules/congestion_controller/rtp/control_handler.h b/modules/congestion_controller/rtp/control_handler.h index cf6d70c1de..554c9e8970 100644 --- a/modules/congestion_controller/rtp/control_handler.h +++ b/modules/congestion_controller/rtp/control_handler.h @@ -19,7 +19,7 @@ #include "api/units/time_delta.h" #include "modules/pacing/paced_sender.h" #include "rtc_base/constructor_magic.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" namespace webrtc { // This is used to observe the network controller state and route calls to @@ -46,7 +46,7 @@ class CongestionControlHandler { const bool disable_pacer_emergency_stop_; int64_t pacer_expected_queue_ms_ = 0; - rtc::SequencedTaskChecker sequenced_checker_; + SequenceChecker sequenced_checker_; RTC_DISALLOW_COPY_AND_ASSIGN(CongestionControlHandler); }; } // namespace webrtc diff --git a/modules/rtp_rtcp/BUILD.gn b/modules/rtp_rtcp/BUILD.gn index 6c2e09e900..32ef465bc7 100644 --- a/modules/rtp_rtcp/BUILD.gn +++ b/modules/rtp_rtcp/BUILD.gn @@ -227,7 +227,7 @@ rtc_static_library("rtp_rtcp") { "../../rtc_base:rtc_base_approved", "../../rtc_base:rtc_numerics", "../../rtc_base:safe_minmax", - "../../rtc_base:sequenced_task_checker", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/system:fallthrough", "../../rtc_base/time:timestamp_extrapolator", "../../system_wrappers", diff --git a/modules/rtp_rtcp/include/flexfec_receiver.h b/modules/rtp_rtcp/include/flexfec_receiver.h index 2426559b0d..e1844a4167 100644 --- a/modules/rtp_rtcp/include/flexfec_receiver.h +++ b/modules/rtp_rtcp/include/flexfec_receiver.h @@ -18,7 +18,7 @@ #include "modules/rtp_rtcp/include/ulpfec_receiver.h" #include "modules/rtp_rtcp/source/forward_error_correction.h" #include "modules/rtp_rtcp/source/rtp_packet_received.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" namespace webrtc { @@ -68,7 +68,7 @@ class FlexfecReceiver { int64_t last_recovered_packet_ms_ RTC_GUARDED_BY(sequence_checker_); FecPacketCounter packet_counter_ RTC_GUARDED_BY(sequence_checker_); - rtc::SequencedTaskChecker sequence_checker_; + SequenceChecker sequence_checker_; }; } // namespace webrtc diff --git a/modules/rtp_rtcp/source/flexfec_receiver.cc b/modules/rtp_rtcp/source/flexfec_receiver.cc index 17509275a3..d9850bf0f8 100644 --- a/modules/rtp_rtcp/source/flexfec_receiver.cc +++ b/modules/rtp_rtcp/source/flexfec_receiver.cc @@ -61,7 +61,7 @@ FlexfecReceiver::FlexfecReceiver( FlexfecReceiver::~FlexfecReceiver() = default; void FlexfecReceiver::OnRtpPacket(const RtpPacketReceived& packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // If this packet was recovered, it might be originating from // ProcessReceivedPacket in this object. To avoid lifetime issues with @@ -79,7 +79,7 @@ void FlexfecReceiver::OnRtpPacket(const RtpPacketReceived& packet) { } FecPacketCounter FlexfecReceiver::GetPacketCounter() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); return packet_counter_; } @@ -87,7 +87,7 @@ FecPacketCounter FlexfecReceiver::GetPacketCounter() const { // recovered packets here. std::unique_ptr FlexfecReceiver::AddReceivedPacket( const RtpPacketReceived& packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // RTP packets with a full base header (12 bytes), but without payload, // could conceivably be useful in the decoding. Therefore we check @@ -145,7 +145,7 @@ std::unique_ptr FlexfecReceiver::AddReceivedPacket( // of non-recovered media packets. void FlexfecReceiver::ProcessReceivedPacket( const ReceivedPacket& received_packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // Decode. erasure_code_->DecodeFec(received_packet, &recovered_packets_); diff --git a/modules/rtp_rtcp/source/rtp_sender_video.h b/modules/rtp_rtcp/source/rtp_sender_video.h index 7144afdded..814efcc4dd 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.h +++ b/modules/rtp_rtcp/source/rtp_sender_video.h @@ -26,7 +26,7 @@ #include "rtc_base/critical_section.h" #include "rtc_base/one_time_event.h" #include "rtc_base/rate_statistics.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" namespace webrtc { diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn index 304dd4f76d..12d02bf067 100644 --- a/modules/video_coding/BUILD.gn +++ b/modules/video_coding/BUILD.gn @@ -165,10 +165,10 @@ rtc_static_library("video_coding") { "../../rtc_base:rtc_base_approved", "../../rtc_base:rtc_numerics", "../../rtc_base:rtc_task_queue", - "../../rtc_base:sequenced_task_checker", "../../rtc_base/experiments:alr_experiment", "../../rtc_base/experiments:jitter_upper_bound_experiment", "../../rtc_base/experiments:rtt_mult_experiment", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/system:fallthrough", "../../rtc_base/third_party/base64", "../../rtc_base/time:timestamp_extrapolator", @@ -255,9 +255,9 @@ rtc_source_set("video_coding_utility") { "../../rtc_base:rtc_base_approved", "../../rtc_base:rtc_numerics", "../../rtc_base:rtc_task_queue", - "../../rtc_base:sequenced_task_checker", "../../rtc_base/experiments:quality_scaling_experiment", "../../rtc_base/experiments:rate_control_settings", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/system:arch", "../../rtc_base/system:file_wrapper", "../../rtc_base/task_utils:repeating_task", @@ -577,7 +577,7 @@ if (rtc_include_tests) { "../../rtc_base:checks", "../../rtc_base:rtc_base_approved", "../../rtc_base:rtc_task_queue", - "../../rtc_base:sequenced_task_checker", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/task_utils:to_queued_task", "../../test:test_support", "../../test:video_test_common", diff --git a/modules/video_coding/codecs/test/videoprocessor.cc b/modules/video_coding/codecs/test/videoprocessor.cc index e2e79aada1..708f6fe1ab 100644 --- a/modules/video_coding/codecs/test/videoprocessor.cc +++ b/modules/video_coding/codecs/test/videoprocessor.cc @@ -226,7 +226,7 @@ VideoProcessor::VideoProcessor(webrtc::VideoEncoder* encoder, } VideoProcessor::~VideoProcessor() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // Explicitly reset codecs, in case they don't do that themselves when they // go out of scope. @@ -242,7 +242,7 @@ VideoProcessor::~VideoProcessor() { } void VideoProcessor::ProcessFrame() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); const size_t frame_number = last_inputed_frame_num_++; // Get input frame and store for future quality calculation. @@ -296,7 +296,7 @@ void VideoProcessor::ProcessFrame() { } void VideoProcessor::SetRates(size_t bitrate_kbps, size_t framerate_fps) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); framerate_fps_ = static_cast(framerate_fps); bitrate_allocation_ = bitrate_allocator_->GetAllocation( static_cast(bitrate_kbps * 1000), framerate_fps_); @@ -333,7 +333,7 @@ int32_t VideoProcessor::VideoProcessorDecodeCompleteCallback::Decoded( void VideoProcessor::FrameEncoded( const webrtc::EncodedImage& encoded_image, const webrtc::CodecSpecificInfo& codec_specific) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // For the highest measurement accuracy of the encode time, the start/stop // time recordings should wrap the Encode call as tightly as possible. @@ -455,7 +455,7 @@ void VideoProcessor::FrameEncoded( void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame, size_t spatial_idx) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // For the highest measurement accuracy of the decode time, the start/stop // time recordings should wrap the Decode call as tightly as possible. @@ -529,7 +529,7 @@ void VideoProcessor::FrameDecoded(const VideoFrame& decoded_frame, void VideoProcessor::DecodeFrame(const EncodedImage& encoded_image, size_t spatial_idx) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); FrameStatistics* frame_stat = stats_->GetFrameWithTimestamp(encoded_image.Timestamp(), spatial_idx); diff --git a/modules/video_coding/codecs/test/videoprocessor.h b/modules/video_coding/codecs/test/videoprocessor.h index 4935796eb9..64f9c5c878 100644 --- a/modules/video_coding/codecs/test/videoprocessor.h +++ b/modules/video_coding/codecs/test/videoprocessor.h @@ -36,7 +36,7 @@ #include "rtc_base/buffer.h" #include "rtc_base/checks.h" #include "rtc_base/constructor_magic.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/thread_checker.h" #include "test/testsupport/frame_reader.h" @@ -250,7 +250,7 @@ class VideoProcessor { int64_t post_encode_time_ns_ RTC_GUARDED_BY(sequence_checker_); // This class must be operated on a TaskQueue. - rtc::SequencedTaskChecker sequence_checker_; + SequenceChecker sequence_checker_; RTC_DISALLOW_COPY_AND_ASSIGN(VideoProcessor); }; diff --git a/modules/video_coding/loss_notification_controller.cc b/modules/video_coding/loss_notification_controller.cc index 44cca34abd..3bab787070 100644 --- a/modules/video_coding/loss_notification_controller.cc +++ b/modules/video_coding/loss_notification_controller.cc @@ -44,7 +44,7 @@ LossNotificationController::LossNotificationController( LossNotificationController::~LossNotificationController() = default; void LossNotificationController::OnReceivedPacket(const VCMPacket& packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); if (!packet.generic_descriptor) { RTC_LOG(LS_WARNING) << "Generic frame descriptor missing. Buggy remote? " @@ -116,7 +116,7 @@ void LossNotificationController::OnAssembledFrame( uint16_t frame_id, bool discardable, rtc::ArrayView frame_dependency_diffs) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); DiscardOldInformation(); // Prevent memory overconsumption. @@ -144,7 +144,7 @@ void LossNotificationController::DiscardOldInformation() { bool LossNotificationController::AllDependenciesDecodable( int64_t unwrapped_frame_id, rtc::ArrayView frame_dependency_diffs) const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); // Due to packet reordering, frame buffering and asynchronous decoders, it is // infeasible to make reliable conclusions on the decodability of a frame @@ -170,7 +170,7 @@ bool LossNotificationController::AllDependenciesDecodable( void LossNotificationController::HandleLoss(uint16_t last_received_seq_num, bool decodability_flag) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); if (last_decodable_non_discardable_) { RTC_DCHECK(AheadOf(last_received_seq_num, diff --git a/modules/video_coding/loss_notification_controller.h b/modules/video_coding/loss_notification_controller.h index 4cdfbb80f9..09f4fef180 100644 --- a/modules/video_coding/loss_notification_controller.h +++ b/modules/video_coding/loss_notification_controller.h @@ -17,7 +17,7 @@ #include "modules/include/module_common_types.h" #include "modules/video_coding/packet.h" #include "rtc_base/numerics/sequence_number_util.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" namespace webrtc { @@ -61,26 +61,25 @@ class LossNotificationController { void HandleLoss(uint16_t last_received_seq_num, bool decodability_flag); KeyFrameRequestSender* const key_frame_request_sender_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); LossNotificationSender* const loss_notification_sender_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); SeqNumUnwrapper frame_id_unwrapper_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); // Tracked to avoid processing repeated frames (buggy/malicious remote). absl::optional last_received_unwrapped_frame_id_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); // Tracked to avoid processing repeated packets. absl::optional last_received_seq_num_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); // Tracked in order to correctly report the potential-decodability of // multi-packet frames. - bool current_frame_potentially_decodable_ - RTC_GUARDED_BY(sequenced_task_checker_); + bool current_frame_potentially_decodable_ RTC_GUARDED_BY(sequence_checker_); // Loss notifications contain the sequence number of the first packet of // the last decodable-and-non-discardable frame. Since this is a bit of @@ -92,15 +91,15 @@ class LossNotificationController { uint16_t first_seq_num; }; absl::optional last_decodable_non_discardable_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); // Track which frames are decodable. Later frames are also decodable if // all of their dependencies can be found in this container. // (Naturally, later frames must also be assemblable to be decodable.) std::set decodable_unwrapped_frame_ids_ - RTC_GUARDED_BY(sequenced_task_checker_); + RTC_GUARDED_BY(sequence_checker_); - rtc::SequencedTaskChecker sequenced_task_checker_; + SequenceChecker sequence_checker_; }; } // namespace webrtc diff --git a/modules/video_coding/utility/quality_scaler.cc b/modules/video_coding/utility/quality_scaler.cc index 4f4bb3b033..54ef76a8eb 100644 --- a/modules/video_coding/utility/quality_scaler.cc +++ b/modules/video_coding/utility/quality_scaler.cc @@ -88,7 +88,7 @@ QualityScaler::QualityScaler(rtc::TaskQueue* task_queue, framedrop_percent_all_(5 * 30), experiment_enabled_(QualityScalingExperiment::Enabled()), observed_enough_frames_(false) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (experiment_enabled_) { config_ = QualityScalingExperiment::GetConfig(); qp_smoother_high_.reset(new QpSmoother(config_.alpha_high)); @@ -105,12 +105,12 @@ QualityScaler::QualityScaler(rtc::TaskQueue* task_queue, } QualityScaler::~QualityScaler() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); check_qp_task_.Stop(); } int64_t QualityScaler::GetSamplingPeriodMs() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (fast_rampup_) { return sampling_period_ms_; } @@ -122,18 +122,18 @@ int64_t QualityScaler::GetSamplingPeriodMs() const { } void QualityScaler::ReportDroppedFrameByMediaOpt() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); framedrop_percent_media_opt_.AddSample(100); framedrop_percent_all_.AddSample(100); } void QualityScaler::ReportDroppedFrameByEncoder() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); framedrop_percent_all_.AddSample(100); } void QualityScaler::ReportQp(int qp, int64_t time_sent_us) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); framedrop_percent_media_opt_.AddSample(0); framedrop_percent_all_.AddSample(0); average_qp_.AddSample(qp); @@ -144,7 +144,7 @@ void QualityScaler::ReportQp(int qp, int64_t time_sent_us) { } void QualityScaler::CheckQp() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); // Should be set through InitEncode -> Should be set by now. RTC_DCHECK_GE(thresholds_.low, 0); @@ -193,13 +193,13 @@ void QualityScaler::CheckQp() { } void QualityScaler::ReportQpLow() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); ClearSamples(); observer_->AdaptUp(AdaptationObserverInterface::AdaptReason::kQuality); } void QualityScaler::ReportQpHigh() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); ClearSamples(); observer_->AdaptDown(AdaptationObserverInterface::AdaptReason::kQuality); // If we've scaled down, wait longer before scaling up again. @@ -209,7 +209,7 @@ void QualityScaler::ReportQpHigh() { } void QualityScaler::ClearSamples() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); framedrop_percent_media_opt_.Reset(); framedrop_percent_all_.Reset(); average_qp_.Reset(); diff --git a/modules/video_coding/utility/quality_scaler.h b/modules/video_coding/utility/quality_scaler.h index 5e7ee0ded5..500d931b58 100644 --- a/modules/video_coding/utility/quality_scaler.h +++ b/modules/video_coding/utility/quality_scaler.h @@ -18,7 +18,7 @@ #include "api/video_codecs/video_encoder.h" #include "rtc_base/experiments/quality_scaling_experiment.h" #include "rtc_base/numerics/moving_average.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #include "rtc_base/task_utils/repeating_task.h" @@ -77,7 +77,7 @@ class QualityScaler { RepeatingTaskHandle check_qp_task_ RTC_GUARDED_BY(&task_checker_); AdaptationObserverInterface* const observer_ RTC_GUARDED_BY(&task_checker_); - rtc::SequencedTaskChecker task_checker_; + SequenceChecker task_checker_; const VideoEncoder::QpThresholds thresholds_; const int64_t sampling_period_ms_; diff --git a/modules/video_coding/video_coding_impl.h b/modules/video_coding/video_coding_impl.h index e0776337ad..4d83047f38 100644 --- a/modules/video_coding/video_coding_impl.h +++ b/modules/video_coding/video_coding_impl.h @@ -25,7 +25,7 @@ #include "modules/video_coding/receiver.h" #include "modules/video_coding/timing.h" #include "rtc_base/one_time_event.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/thread_checker.h" #include "system_wrappers/include/clock.h" diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index 273ad0f34c..8c69b85dd2 100644 --- a/rtc_base/BUILD.gn +++ b/rtc_base/BUILD.gn @@ -228,7 +228,7 @@ rtc_source_set("platform_thread") { ":rtc_task_queue_libevent", ":rtc_task_queue_win", ":rtc_task_queue_stdlib", - ":sequenced_task_checker", + "synchronization:sequence_checker", ] sources = [ "platform_thread.cc", @@ -573,15 +573,6 @@ rtc_source_set("rtc_task_queue_stdlib") { ] } -rtc_source_set("sequenced_task_checker") { - sources = [ - "sequenced_task_checker.h", - ] - deps = [ - "synchronization:sequence_checker", - ] -} - rtc_static_library("weak_ptr") { sources = [ "weak_ptr.cc", @@ -589,8 +580,8 @@ rtc_static_library("weak_ptr") { ] deps = [ ":refcount", - ":sequenced_task_checker", "../api:scoped_refptr", + "synchronization:sequence_checker", ] } @@ -1280,24 +1271,6 @@ if (rtc_include_tests) { ] } - rtc_source_set("sequenced_task_checker_unittests") { - testonly = true - - sources = [ - "sequenced_task_checker_unittest.cc", - ] - deps = [ - ":checks", - ":rtc_base_approved", - ":rtc_base_tests_main", - ":sequenced_task_checker", - ":task_queue_for_test", - "../api:function_view", - "../test:test_support", - "//third_party/abseil-cpp/absl/memory", - ] - } - rtc_source_set("weak_ptr_unittests") { testonly = true diff --git a/rtc_base/sequenced_task_checker.h b/rtc_base/sequenced_task_checker.h deleted file mode 100644 index feaa04c7f9..0000000000 --- a/rtc_base/sequenced_task_checker.h +++ /dev/null @@ -1,26 +0,0 @@ -/* - * Copyright (c) 2016 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. - */ - -#ifndef RTC_BASE_SEQUENCED_TASK_CHECKER_H_ -#define RTC_BASE_SEQUENCED_TASK_CHECKER_H_ - -#include "rtc_base/synchronization/sequence_checker.h" - -namespace rtc { -// TODO(srte): Replace usages of this with SequenceChecker. -class SequencedTaskChecker : public webrtc::SequenceChecker { - public: - bool CalledSequentially() const { return IsCurrent(); } -}; -} // namespace rtc - -#define RTC_DCHECK_CALLED_SEQUENTIALLY(x) RTC_DCHECK_RUN_ON(x) - -#endif // RTC_BASE_SEQUENCED_TASK_CHECKER_H_ diff --git a/rtc_base/sequenced_task_checker_unittest.cc b/rtc_base/sequenced_task_checker_unittest.cc deleted file mode 100644 index bbba290064..0000000000 --- a/rtc_base/sequenced_task_checker_unittest.cc +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Copyright (c) 2016 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 "rtc_base/sequenced_task_checker.h" - -#include -#include - -#include "absl/memory/memory.h" -#include "api/function_view.h" -#include "rtc_base/event.h" -#include "rtc_base/platform_thread.h" -#include "rtc_base/task_queue_for_test.h" -#include "rtc_base/thread_checker.h" -#include "test/gtest.h" - -namespace rtc { -namespace { - -using ::webrtc::TaskQueueForTest; - -// This class is dead code, but its purpose is to make sure that -// SequencedTaskChecker is compatible with the RTC_GUARDED_BY and RTC_RUN_ON -// attributes that are checked at compile-time. -class CompileTimeTestForGuardedBy { - public: - int CalledOnSequence() RTC_RUN_ON(sequence_checker_) { return guarded_; } - - void CallMeFromSequence() { - RTC_DCHECK_RUN_ON(&sequence_checker_) << "Should be called on sequence"; - guarded_ = 41; - } - - private: - int guarded_ RTC_GUARDED_BY(sequence_checker_); - SequencedTaskChecker sequence_checker_; -}; - -void RunOnDifferentThread(FunctionView run) { - struct Object { - static void Run(void* obj) { - auto* me = static_cast(obj); - me->run(); - me->thread_has_run_event.Set(); - } - - FunctionView run; - Event thread_has_run_event; - } object{run}; - - PlatformThread thread(&Object::Run, &object, "thread"); - thread.Start(); - EXPECT_TRUE(object.thread_has_run_event.Wait(1000)); - thread.Stop(); -} - -} // namespace - -TEST(SequencedTaskCheckerTest, CallsAllowedOnSameThread) { - SequencedTaskChecker sequenced_task_checker; - EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); -} - -TEST(SequencedTaskCheckerTest, DestructorAllowedOnDifferentThread) { - auto sequenced_task_checker = absl::make_unique(); - RunOnDifferentThread([&] { - // Verify that the destructor doesn't assert when called on a different - // thread. - sequenced_task_checker.reset(); - }); -} - -TEST(SequencedTaskCheckerTest, Detach) { - SequencedTaskChecker sequenced_task_checker; - sequenced_task_checker.Detach(); - RunOnDifferentThread( - [&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); }); -} - -TEST(SequencedTaskCheckerTest, DetachFromThreadAndUseOnTaskQueue) { - SequencedTaskChecker sequenced_task_checker; - sequenced_task_checker.Detach(); - TaskQueueForTest queue; - queue.SendTask( - [&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); }); -} - -TEST(SequencedTaskCheckerTest, DetachFromTaskQueueAndUseOnThread) { - TaskQueueForTest queue; - queue.SendTask([] { - SequencedTaskChecker sequenced_task_checker; - sequenced_task_checker.Detach(); - RunOnDifferentThread( - [&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); }); - }); -} - -TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) { - SequencedTaskChecker sequenced_task_checker; - RunOnDifferentThread([&] { - EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON); - }); -} - -TEST(SequencedTaskCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) { - SequencedTaskChecker sequenced_task_checker; - TaskQueueForTest queue; - queue.SendTask([&] { - EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON); - }); -} - -TEST(SequencedTaskCheckerTest, DetachFromTaskQueueInDebug) { - SequencedTaskChecker sequenced_task_checker; - sequenced_task_checker.Detach(); - - TaskQueueForTest queue1; - queue1.SendTask( - [&] { EXPECT_TRUE(sequenced_task_checker.CalledSequentially()); }); - - // CalledSequentially should return false in debug builds after moving to - // another task queue. - TaskQueueForTest queue2; - queue2.SendTask([&] { - EXPECT_EQ(sequenced_task_checker.CalledSequentially(), !RTC_DCHECK_IS_ON); - }); -} - -class TestAnnotations { - public: - TestAnnotations() : test_var_(false) {} - - void ModifyTestVar() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&checker_); - test_var_ = true; - } - - private: - bool test_var_ RTC_GUARDED_BY(&checker_); - SequencedTaskChecker checker_; -}; - -TEST(SequencedTaskCheckerTest, TestAnnotations) { - TestAnnotations annotations; - annotations.ModifyTestVar(); -} - -#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) - -void TestAnnotationsOnWrongQueue() { - TestAnnotations annotations; - TaskQueueForTest queue; - queue.SendTask([&] { annotations.ModifyTestVar(); }); -} - -#if RTC_DCHECK_IS_ON -TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueDebug) { - ASSERT_DEATH({ TestAnnotationsOnWrongQueue(); }, ""); -} -#else -TEST(SequencedTaskCheckerTest, TestAnnotationsOnWrongQueueRelease) { - TestAnnotationsOnWrongQueue(); -} -#endif -#endif // GTEST_HAS_DEATH_TEST -} // namespace rtc diff --git a/rtc_base/synchronization/BUILD.gn b/rtc_base/synchronization/BUILD.gn index 975c1a1968..93a3fee8fd 100644 --- a/rtc_base/synchronization/BUILD.gn +++ b/rtc_base/synchronization/BUILD.gn @@ -72,4 +72,22 @@ if (rtc_include_tests) { "../../test:test_support", ] } + + rtc_source_set("sequence_checker_unittests") { + testonly = true + + sources = [ + "sequence_checker_unittest.cc", + ] + deps = [ + ":sequence_checker", + "..:checks", + "..:rtc_base_approved", + "..:rtc_base_tests_main", + "..:task_queue_for_test", + "../../api:function_view", + "../../test:test_support", + "//third_party/abseil-cpp/absl/memory", + ] + } } diff --git a/rtc_base/synchronization/sequence_checker_unittest.cc b/rtc_base/synchronization/sequence_checker_unittest.cc new file mode 100644 index 0000000000..ccdf6bc2d0 --- /dev/null +++ b/rtc_base/synchronization/sequence_checker_unittest.cc @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2016 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 "rtc_base/synchronization/sequence_checker.h" + +#include +#include + +#include "absl/memory/memory.h" +#include "api/function_view.h" +#include "rtc_base/event.h" +#include "rtc_base/platform_thread.h" +#include "rtc_base/task_queue_for_test.h" +#include "rtc_base/thread_checker.h" +#include "test/gtest.h" + +namespace webrtc { +namespace { + +// This class is dead code, but its purpose is to make sure that +// SequenceChecker is compatible with the RTC_GUARDED_BY and RTC_RUN_ON +// attributes that are checked at compile-time. +class CompileTimeTestForGuardedBy { + public: + int CalledOnSequence() RTC_RUN_ON(sequence_checker_) { return guarded_; } + + void CallMeFromSequence() { + RTC_DCHECK_RUN_ON(&sequence_checker_) << "Should be called on sequence"; + guarded_ = 41; + } + + private: + int guarded_ RTC_GUARDED_BY(sequence_checker_); + ::webrtc::SequenceChecker sequence_checker_; +}; + +void RunOnDifferentThread(rtc::FunctionView run) { + struct Object { + static void Run(void* obj) { + auto* me = static_cast(obj); + me->run(); + me->thread_has_run_event.Set(); + } + + rtc::FunctionView run; + rtc::Event thread_has_run_event; + } object{run}; + + rtc::PlatformThread thread(&Object::Run, &object, "thread"); + thread.Start(); + EXPECT_TRUE(object.thread_has_run_event.Wait(1000)); + thread.Stop(); +} + +} // namespace + +TEST(SequenceCheckerTest, CallsAllowedOnSameThread) { + SequenceChecker sequence_checker; + EXPECT_TRUE(sequence_checker.IsCurrent()); +} + +TEST(SequenceCheckerTest, DestructorAllowedOnDifferentThread) { + auto sequence_checker = absl::make_unique(); + RunOnDifferentThread([&] { + // Verify that the destructor doesn't assert when called on a different + // thread. + sequence_checker.reset(); + }); +} + +TEST(SequenceCheckerTest, Detach) { + SequenceChecker sequence_checker; + sequence_checker.Detach(); + RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }); +} + +TEST(SequenceCheckerTest, DetachFromThreadAndUseOnTaskQueue) { + SequenceChecker sequence_checker; + sequence_checker.Detach(); + TaskQueueForTest queue; + queue.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }); +} + +TEST(SequenceCheckerTest, DetachFromTaskQueueAndUseOnThread) { + TaskQueueForTest queue; + queue.SendTask([] { + SequenceChecker sequence_checker; + sequence_checker.Detach(); + RunOnDifferentThread([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }); + }); +} + +TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentThreadInDebug) { + SequenceChecker sequence_checker; + RunOnDifferentThread( + [&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); }); +} + +TEST(SequenceCheckerTest, MethodNotAllowedOnDifferentTaskQueueInDebug) { + SequenceChecker sequence_checker; + TaskQueueForTest queue; + queue.SendTask( + [&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); }); +} + +TEST(SequenceCheckerTest, DetachFromTaskQueueInDebug) { + SequenceChecker sequence_checker; + sequence_checker.Detach(); + + TaskQueueForTest queue1; + queue1.SendTask([&] { EXPECT_TRUE(sequence_checker.IsCurrent()); }); + + // IsCurrent should return false in debug builds after moving to + // another task queue. + TaskQueueForTest queue2; + queue2.SendTask( + [&] { EXPECT_EQ(sequence_checker.IsCurrent(), !RTC_DCHECK_IS_ON); }); +} + +class TestAnnotations { + public: + TestAnnotations() : test_var_(false) {} + + void ModifyTestVar() { + RTC_DCHECK_RUN_ON(&checker_); + test_var_ = true; + } + + private: + bool test_var_ RTC_GUARDED_BY(&checker_); + SequenceChecker checker_; +}; + +TEST(SequenceCheckerTest, TestAnnotations) { + TestAnnotations annotations; + annotations.ModifyTestVar(); +} + +#if GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) + +void TestAnnotationsOnWrongQueue() { + TestAnnotations annotations; + TaskQueueForTest queue; + queue.SendTask([&] { annotations.ModifyTestVar(); }); +} + +#if RTC_DCHECK_IS_ON +TEST(SequenceCheckerTest, TestAnnotationsOnWrongQueueDebug) { + ASSERT_DEATH({ TestAnnotationsOnWrongQueue(); }, ""); +} +#else +TEST(SequenceCheckerTest, TestAnnotationsOnWrongQueueRelease) { + TestAnnotationsOnWrongQueue(); +} +#endif +#endif // GTEST_HAS_DEATH_TEST +} // namespace webrtc diff --git a/rtc_base/task_utils/BUILD.gn b/rtc_base/task_utils/BUILD.gn index e562779c68..7a466a1e8c 100644 --- a/rtc_base/task_utils/BUILD.gn +++ b/rtc_base/task_utils/BUILD.gn @@ -16,12 +16,12 @@ rtc_source_set("repeating_task") { deps = [ ":to_queued_task", "..:logging", - "..:sequenced_task_checker", "..:thread_checker", "..:timeutils", "../../api/task_queue", "../../api/units:time_delta", "../../api/units:timestamp", + "../synchronization:sequence_checker", "//third_party/abseil-cpp/absl/memory", ] } diff --git a/rtc_base/task_utils/repeating_task.h b/rtc_base/task_utils/repeating_task.h index 21ec130143..8549049478 100644 --- a/rtc_base/task_utils/repeating_task.h +++ b/rtc_base/task_utils/repeating_task.h @@ -19,7 +19,7 @@ #include "api/task_queue/task_queue_base.h" #include "api/units/time_delta.h" #include "api/units/timestamp.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_checker.h" namespace webrtc { diff --git a/rtc_base/weak_ptr.cc b/rtc_base/weak_ptr.cc index ad98c24611..09807e1705 100644 --- a/rtc_base/weak_ptr.cc +++ b/rtc_base/weak_ptr.cc @@ -24,13 +24,13 @@ WeakReference::Flag::Flag() : is_valid_(true) { } void WeakReference::Flag::Invalidate() { - RTC_DCHECK(checker_.CalledSequentially()) + RTC_DCHECK(checker_.IsCurrent()) << "WeakPtrs must be invalidated on the same sequence."; is_valid_ = false; } bool WeakReference::Flag::IsValid() const { - RTC_DCHECK(checker_.CalledSequentially()) + RTC_DCHECK(checker_.IsCurrent()) << "WeakPtrs must be checked on the same sequence."; return is_valid_; } diff --git a/rtc_base/weak_ptr.h b/rtc_base/weak_ptr.h index 89969d6edb..80cb7eec67 100644 --- a/rtc_base/weak_ptr.h +++ b/rtc_base/weak_ptr.h @@ -18,7 +18,7 @@ #include "api/scoped_refptr.h" #include "rtc_base/ref_count.h" #include "rtc_base/ref_counted_object.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" // The implementation is borrowed from chromium except that it does not // implement SupportsWeakPtr. @@ -104,7 +104,7 @@ class WeakReference { ~Flag() override; - SequencedTaskChecker checker_; + ::webrtc::SequenceChecker checker_; bool is_valid_; }; diff --git a/rtc_tools/network_tester/BUILD.gn b/rtc_tools/network_tester/BUILD.gn index ca2c04c4f1..e0fb6039c8 100644 --- a/rtc_tools/network_tester/BUILD.gn +++ b/rtc_tools/network_tester/BUILD.gn @@ -51,7 +51,7 @@ if (rtc_enable_protobuf) { "../../rtc_base:protobuf_utils", "../../rtc_base:rtc_base_approved", "../../rtc_base:rtc_task_queue", - "../../rtc_base:sequenced_task_checker", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/third_party/sigslot", "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/types:optional", diff --git a/rtc_tools/network_tester/packet_sender.cc b/rtc_tools/network_tester/packet_sender.cc index ecf9f5b3a0..71e4e5903c 100644 --- a/rtc_tools/network_tester/packet_sender.cc +++ b/rtc_tools/network_tester/packet_sender.cc @@ -96,7 +96,7 @@ PacketSender::~PacketSender() = default; void PacketSender::StartSending() { worker_queue_checker_.Detach(); worker_queue_.PostTask([this]() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); sending_ = true; }); worker_queue_.PostTask(absl::make_unique( @@ -105,18 +105,18 @@ void PacketSender::StartSending() { } void PacketSender::StopSending() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); sending_ = false; test_controller_->OnTestDone(); } bool PacketSender::IsSending() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); return sending_; } void PacketSender::SendPacket() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); NetworkTesterPacket packet; packet.set_type(NetworkTesterPacket::TEST_DATA); packet.set_sequence_number(sequence_number_++); @@ -125,13 +125,13 @@ void PacketSender::SendPacket() { } int64_t PacketSender::GetSendIntervalMs() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); return send_interval_ms_; } void PacketSender::UpdateTestSetting(size_t packet_size, int64_t send_interval_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_queue_checker_); + RTC_DCHECK_RUN_ON(&worker_queue_checker_); send_interval_ms_ = send_interval_ms; packet_size_ = packet_size; } diff --git a/rtc_tools/network_tester/packet_sender.h b/rtc_tools/network_tester/packet_sender.h index c6ec64eb6c..ffc1118e20 100644 --- a/rtc_tools/network_tester/packet_sender.h +++ b/rtc_tools/network_tester/packet_sender.h @@ -17,7 +17,7 @@ #include "api/task_queue/task_queue_factory.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/ignore_wundef.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #ifdef WEBRTC_NETWORK_TESTER_PROTO @@ -49,7 +49,7 @@ class PacketSender { void UpdateTestSetting(size_t packet_size, int64_t send_interval_ms); private: - rtc::SequencedTaskChecker worker_queue_checker_; + SequenceChecker worker_queue_checker_; size_t packet_size_ RTC_GUARDED_BY(worker_queue_checker_); int64_t send_interval_ms_ RTC_GUARDED_BY(worker_queue_checker_); int64_t sequence_number_ RTC_GUARDED_BY(worker_queue_checker_); diff --git a/rtc_tools/network_tester/test_controller.cc b/rtc_tools/network_tester/test_controller.cc index 87fb4c04ce..52007860fd 100644 --- a/rtc_tools/network_tester/test_controller.cc +++ b/rtc_tools/network_tester/test_controller.cc @@ -67,7 +67,7 @@ void TestController::SendData(const NetworkTesterPacket& packet, } void TestController::OnTestDone() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&packet_sender_checker_); + RTC_DCHECK_RUN_ON(&packet_sender_checker_); NetworkTesterPacket packet; packet.set_type(NetworkTesterPacket::TEST_DONE); SendData(packet, absl::nullopt); diff --git a/rtc_tools/network_tester/test_controller.h b/rtc_tools/network_tester/test_controller.h index bde3b04b19..e522025cbb 100644 --- a/rtc_tools/network_tester/test_controller.h +++ b/rtc_tools/network_tester/test_controller.h @@ -23,8 +23,8 @@ #include "rtc_base/constructor_magic.h" #include "rtc_base/critical_section.h" #include "rtc_base/ignore_wundef.h" -#include "rtc_base/sequenced_task_checker.h" #include "rtc_base/socket_address.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/thread_checker.h" @@ -70,7 +70,7 @@ class TestController : public sigslot::has_slots<> { const rtc::SocketAddress& remote_addr, const int64_t& packet_time_us); rtc::ThreadChecker test_controller_thread_checker_; - rtc::SequencedTaskChecker packet_sender_checker_; + SequenceChecker packet_sender_checker_; rtc::BasicPacketSocketFactory socket_factory_; const std::string config_file_path_; PacketLogger packet_logger_; diff --git a/sdk/android/BUILD.gn b/sdk/android/BUILD.gn index 6bc5d5d8de..920503ad94 100644 --- a/sdk/android/BUILD.gn +++ b/sdk/android/BUILD.gn @@ -632,8 +632,8 @@ if (is_android) { "../../rtc_base", "../../rtc_base:checks", "../../rtc_base:rtc_task_queue", - "../../rtc_base:sequenced_task_checker", "../../rtc_base:weak_ptr", + "../../rtc_base/synchronization:sequence_checker", "../../system_wrappers:field_trial", "//third_party/abseil-cpp/absl/memory", "//third_party/libyuv", diff --git a/sdk/android/src/jni/android_media_encoder.cc b/sdk/android/src/jni/android_media_encoder.cc index d39d902c01..dbf2b31659 100644 --- a/sdk/android/src/jni/android_media_encoder.cc +++ b/sdk/android/src/jni/android_media_encoder.cc @@ -32,7 +32,7 @@ #include "rtc_base/bind.h" #include "rtc_base/checks.h" #include "rtc_base/logging.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" #include "rtc_base/weak_ptr.h" @@ -197,7 +197,7 @@ class MediaCodecVideoEncoder : public VideoEncoder { // State that is constant for the lifetime of this object once the ctor // returns. - rtc::SequencedTaskChecker encoder_queue_checker_; + SequenceChecker encoder_queue_checker_; ScopedJavaGlobalRef j_media_codec_video_encoder_; // State that is valid only between InitEncode() and the next Release(). @@ -307,7 +307,7 @@ MediaCodecVideoEncoder::MediaCodecVideoEncoder(JNIEnv* jni, int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings, int32_t /* number_of_cores */, size_t /* max_payload_size */) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); if (codec_settings == NULL) { ALOGE << "NULL VideoCodec instance"; return WEBRTC_VIDEO_CODEC_ERR_PARAMETER; @@ -367,7 +367,7 @@ int32_t MediaCodecVideoEncoder::InitEncode(const VideoCodec* codec_settings, } bool MediaCodecVideoEncoder::ResetCodec() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); ALOGE << "Reset"; if (Release() != WEBRTC_VIDEO_CODEC_OK) { ALOGE << "Releasing codec failed during reset."; @@ -391,7 +391,7 @@ bool MediaCodecVideoEncoder::EncodeTask::Run() { return true; } - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_->encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_->encoder_queue_checker_); JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); @@ -468,7 +468,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width, int kbps, int fps, bool use_surface) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); if (sw_fallback_required_) { return WEBRTC_VIDEO_CODEC_OK; } @@ -595,7 +595,7 @@ int32_t MediaCodecVideoEncoder::InitEncodeInternal(int width, int32_t MediaCodecVideoEncoder::Encode( const VideoFrame& frame, const std::vector* frame_types) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); if (sw_fallback_required_) return WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE; JNIEnv* jni = AttachCurrentThreadIfNeeded(); @@ -753,7 +753,7 @@ int32_t MediaCodecVideoEncoder::Encode( bool MediaCodecVideoEncoder::MaybeReconfigureEncoder(JNIEnv* jni, const VideoFrame& frame) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); bool is_texture = IsTextureFrame(jni, frame); const bool reconfigure_due_to_format = is_texture != use_surface_; @@ -798,7 +798,7 @@ bool MediaCodecVideoEncoder::EncodeByteBuffer(JNIEnv* jni, bool key_frame, const VideoFrame& frame, int input_buffer_index) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); RTC_CHECK(!use_surface_); rtc::scoped_refptr i420_buffer = @@ -861,7 +861,7 @@ bool MediaCodecVideoEncoder::EncodeJavaFrame(JNIEnv* jni, int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback( EncodedImageCallback* callback) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); JNIEnv* jni = AttachCurrentThreadIfNeeded(); ScopedLocalRefFrame local_ref_frame(jni); callback_ = callback; @@ -869,7 +869,7 @@ int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback( } int32_t MediaCodecVideoEncoder::Release() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); if (!inited_) { return WEBRTC_VIDEO_CODEC_OK; } @@ -903,7 +903,7 @@ int32_t MediaCodecVideoEncoder::Release() { int32_t MediaCodecVideoEncoder::SetRateAllocation( const VideoBitrateAllocation& rate_allocation, uint32_t frame_rate) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); const uint32_t new_bit_rate = rate_allocation.get_sum_kbps(); if (sw_fallback_required_) return WEBRTC_VIDEO_CODEC_OK; @@ -937,7 +937,7 @@ VideoEncoder::EncoderInfo MediaCodecVideoEncoder::GetEncoderInfo() const { } bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_); + RTC_DCHECK_RUN_ON(&encoder_queue_checker_); while (true) { ScopedJavaLocalRef j_output_buffer_info = diff --git a/test/BUILD.gn b/test/BUILD.gn index 6486780e84..f16644372c 100644 --- a/test/BUILD.gn +++ b/test/BUILD.gn @@ -592,7 +592,7 @@ rtc_source_set("direct_transport") { "../call:simulated_packet_receiver", "../modules/rtp_rtcp", "../rtc_base:rtc_base_approved", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "//third_party/abseil-cpp/absl/memory", ] @@ -650,7 +650,7 @@ rtc_source_set("fake_video_codecs") { "../rtc_base:checks", "../rtc_base:rtc_base_approved", "../rtc_base:rtc_task_queue", - "../rtc_base:sequenced_task_checker", + "../rtc_base/synchronization:sequence_checker", "../system_wrappers", "//third_party/abseil-cpp/absl/memory", "//third_party/abseil-cpp/absl/types:optional", diff --git a/test/direct_transport.h b/test/direct_transport.h index 15d765edd6..c2efe65bbb 100644 --- a/test/direct_transport.h +++ b/test/direct_transport.h @@ -16,7 +16,7 @@ #include "api/test/simulated_network.h" #include "call/call.h" #include "call/simulated_packet_receiver.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "test/single_threaded_task_queue.h" diff --git a/test/fake_encoder.cc b/test/fake_encoder.cc index ec39f9c421..ac59dfd23b 100644 --- a/test/fake_encoder.cc +++ b/test/fake_encoder.cc @@ -349,13 +349,13 @@ DelayedEncoder::DelayedEncoder(Clock* clock, int delay_ms) } void DelayedEncoder::SetDelay(int delay_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); delay_ms_ = delay_ms; } int32_t DelayedEncoder::Encode(const VideoFrame& input_image, const std::vector* frame_types) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); SleepMs(delay_ms_); @@ -378,7 +378,7 @@ MultithreadedFakeH264Encoder::MultithreadedFakeH264Encoder( int32_t MultithreadedFakeH264Encoder::InitEncode(const VideoCodec* config, int32_t number_of_cores, size_t max_payload_size) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); queue1_ = task_queue_factory_->CreateTaskQueue( "Queue 1", TaskQueueFactory::Priority::NORMAL); @@ -411,7 +411,7 @@ class MultithreadedFakeH264Encoder::EncodeTask : public QueuedTask { int32_t MultithreadedFakeH264Encoder::Encode( const VideoFrame& input_image, const std::vector* frame_types) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); TaskQueueBase* queue = (current_queue_++ % 2 == 0) ? queue1_.get() : queue2_.get(); @@ -433,7 +433,7 @@ int32_t MultithreadedFakeH264Encoder::EncodeCallback( } int32_t MultithreadedFakeH264Encoder::Release() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); queue1_.reset(); queue2_.reset(); diff --git a/test/fake_encoder.h b/test/fake_encoder.h index d09199d875..95b4b20ec4 100644 --- a/test/fake_encoder.h +++ b/test/fake_encoder.h @@ -25,7 +25,7 @@ #include "modules/include/module_common_types.h" #include "modules/video_coding/include/video_codec_interface.h" #include "rtc_base/critical_section.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "system_wrappers/include/clock.h" @@ -127,7 +127,7 @@ class DelayedEncoder : public test::FakeEncoder { private: int delay_ms_ RTC_GUARDED_BY(sequence_checker_); - rtc::SequencedTaskChecker sequence_checker_; + SequenceChecker sequence_checker_; }; // This class implements a multi-threaded fake encoder by posting @@ -161,7 +161,7 @@ class MultithreadedFakeH264Encoder : public test::FakeH264Encoder { RTC_GUARDED_BY(sequence_checker_); std::unique_ptr queue2_ RTC_GUARDED_BY(sequence_checker_); - rtc::SequencedTaskChecker sequence_checker_; + SequenceChecker sequence_checker_; }; } // namespace test diff --git a/test/fake_vp8_encoder.cc b/test/fake_vp8_encoder.cc index 5ea4b4e250..bd92bc6f07 100644 --- a/test/fake_vp8_encoder.cc +++ b/test/fake_vp8_encoder.cc @@ -51,7 +51,7 @@ FakeVP8Encoder::FakeVP8Encoder(Clock* clock) : FakeEncoder(clock) { int32_t FakeVP8Encoder::InitEncode(const VideoCodec* config, int32_t number_of_cores, size_t max_payload_size) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); auto result = FakeEncoder::InitEncode(config, number_of_cores, max_payload_size); if (result != WEBRTC_VIDEO_CODEC_OK) { @@ -75,7 +75,7 @@ void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific, VideoFrameType frame_type, int stream_idx, uint32_t timestamp) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); codec_specific->codecType = kVideoCodecVP8; codec_specific->codecSpecific.VP8.keyIdx = kNoKeyIdx; codec_specific->codecSpecific.VP8.nonReference = false; @@ -87,7 +87,7 @@ void FakeVP8Encoder::PopulateCodecSpecific(CodecSpecificInfo* codec_specific, std::unique_ptr FakeVP8Encoder::EncodeHook( EncodedImage* encoded_image, CodecSpecificInfo* codec_specific) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_); + RTC_DCHECK_RUN_ON(&sequence_checker_); uint8_t stream_idx = encoded_image->SpatialIndex().value_or(0); frame_buffer_controller_->UpdateLayerConfig(stream_idx, encoded_image->Timestamp()); diff --git a/test/fake_vp8_encoder.h b/test/fake_vp8_encoder.h index 932818964b..b5733c8fda 100644 --- a/test/fake_vp8_encoder.h +++ b/test/fake_vp8_encoder.h @@ -23,7 +23,7 @@ #include "api/video_codecs/vp8_temporal_layers.h" #include "modules/include/module_common_types.h" #include "modules/video_coding/include/video_codec_interface.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "system_wrappers/include/clock.h" #include "test/fake_encoder.h" @@ -55,7 +55,7 @@ class FakeVP8Encoder : public FakeEncoder { EncodedImage* encoded_image, CodecSpecificInfo* codec_specific) override; - rtc::SequencedTaskChecker sequence_checker_; + SequenceChecker sequence_checker_; std::unique_ptr frame_buffer_controller_ RTC_GUARDED_BY(sequence_checker_); diff --git a/test/scenario/BUILD.gn b/test/scenario/BUILD.gn index e6f3f465f5..b9d0a8a4c2 100644 --- a/test/scenario/BUILD.gn +++ b/test/scenario/BUILD.gn @@ -128,8 +128,8 @@ if (rtc_include_tests) { "../../rtc_base:rtc_base_tests_utils", "../../rtc_base:rtc_task_queue", "../../rtc_base:safe_minmax", - "../../rtc_base:sequenced_task_checker", "../../rtc_base:task_queue_for_test", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/task_utils:repeating_task", "../../system_wrappers", "../../system_wrappers:field_trial", diff --git a/test/time_controller/BUILD.gn b/test/time_controller/BUILD.gn index eb75af6e3e..54b095cb8c 100644 --- a/test/time_controller/BUILD.gn +++ b/test/time_controller/BUILD.gn @@ -29,7 +29,7 @@ if (rtc_include_tests) { "../../rtc_base", "../../rtc_base:rtc_base_tests_utils", "../../rtc_base:rtc_event", - "../../rtc_base:sequenced_task_checker", + "../../rtc_base/synchronization:sequence_checker", "../../rtc_base/synchronization:yield_policy", "../../rtc_base/task_utils:to_queued_task", "../../system_wrappers", diff --git a/video/BUILD.gn b/video/BUILD.gn index b4b943cb70..ddcbaab266 100644 --- a/video/BUILD.gn +++ b/video/BUILD.gn @@ -94,13 +94,13 @@ rtc_static_library("video") { "../rtc_base:rtc_base_approved", "../rtc_base:rtc_numerics", "../rtc_base:rtc_task_queue", - "../rtc_base:sequenced_task_checker", "../rtc_base:stringutils", "../rtc_base:weak_ptr", "../rtc_base/experiments:alr_experiment", "../rtc_base/experiments:keyframe_interval_settings_experiment", "../rtc_base/experiments:quality_scaling_experiment", "../rtc_base/experiments:rate_control_settings", + "../rtc_base/synchronization:sequence_checker", "../rtc_base/system:fallthrough", "../rtc_base/system:thread_registry", "../rtc_base/task_utils:repeating_task", @@ -203,11 +203,11 @@ rtc_source_set("video_stream_encoder_impl") { "../rtc_base:rtc_event", "../rtc_base:rtc_numerics", "../rtc_base:rtc_task_queue", - "../rtc_base:sequenced_task_checker", "../rtc_base:timeutils", "../rtc_base/experiments:alr_experiment", "../rtc_base/experiments:quality_scaling_experiment", "../rtc_base/experiments:rate_control_settings", + "../rtc_base/synchronization:sequence_checker", "../rtc_base/system:fallthrough", "../rtc_base/task_utils:repeating_task", "../system_wrappers:field_trial", diff --git a/video/overuse_frame_detector.cc b/video/overuse_frame_detector.cc index 24eed97bcb..894a648cf2 100644 --- a/video/overuse_frame_detector.cc +++ b/video/overuse_frame_detector.cc @@ -541,7 +541,7 @@ void OveruseFrameDetector::StartCheckForOveruse( rtc::TaskQueue* task_queue, const CpuOveruseOptions& options, AdaptationObserverInterface* overuse_observer) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); RTC_DCHECK(!check_overuse_task_.Running()); RTC_DCHECK(overuse_observer != nullptr); @@ -554,12 +554,12 @@ void OveruseFrameDetector::StartCheckForOveruse( }); } void OveruseFrameDetector::StopCheckForOveruse() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); check_overuse_task_.Stop(); } void OveruseFrameDetector::EncodedFrameTimeMeasured(int encode_duration_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); encode_usage_percent_ = usage_->Value(); metrics_observer_->OnEncodedFrameTimeMeasured(encode_duration_ms, @@ -567,7 +567,7 @@ void OveruseFrameDetector::EncodedFrameTimeMeasured(int encode_duration_ms) { } bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (num_pixels != num_pixels_) { return true; } @@ -575,7 +575,7 @@ bool OveruseFrameDetector::FrameSizeChanged(int num_pixels) const { } bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (last_capture_time_us_ == -1) return false; return (now_us - last_capture_time_us_) > @@ -585,7 +585,7 @@ bool OveruseFrameDetector::FrameTimeoutDetected(int64_t now_us) const { void OveruseFrameDetector::ResetAll(int num_pixels) { // Reset state, as a result resolution being changed. Do not however change // the current frame rate back to the default. - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); num_pixels_ = num_pixels; usage_->Reset(); last_capture_time_us_ = -1; @@ -595,7 +595,7 @@ void OveruseFrameDetector::ResetAll(int num_pixels) { } void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); RTC_DCHECK_GE(framerate_fps, 0); max_framerate_ = std::min(kMaxFramerate, framerate_fps); usage_->SetMaxSampleDiffMs((1000 / std::max(kMinFramerate, max_framerate_)) * @@ -604,7 +604,7 @@ void OveruseFrameDetector::OnTargetFramerateUpdated(int framerate_fps) { void OveruseFrameDetector::FrameCaptured(const VideoFrame& frame, int64_t time_when_first_seen_us) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (FrameSizeChanged(frame.width() * frame.height()) || FrameTimeoutDetected(time_when_first_seen_us)) { @@ -619,7 +619,7 @@ void OveruseFrameDetector::FrameSent(uint32_t timestamp, int64_t time_sent_in_us, int64_t capture_time_us, absl::optional encode_duration_us) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); encode_duration_us = usage_->FrameSent(timestamp, time_sent_in_us, capture_time_us, encode_duration_us); @@ -631,7 +631,7 @@ void OveruseFrameDetector::FrameSent(uint32_t timestamp, void OveruseFrameDetector::CheckForOveruse( AdaptationObserverInterface* observer) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); RTC_DCHECK(observer); ++num_process_times_; if (num_process_times_ <= options_.min_process_count || @@ -681,7 +681,7 @@ void OveruseFrameDetector::CheckForOveruse( } void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); options_ = options; // Force reset with next frame. num_pixels_ = 0; @@ -689,7 +689,7 @@ void OveruseFrameDetector::SetOptions(const CpuOveruseOptions& options) { } bool OveruseFrameDetector::IsOverusing(int usage_percent) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); if (usage_percent >= options_.high_encode_usage_threshold_percent) { ++checks_above_threshold_; @@ -700,7 +700,7 @@ bool OveruseFrameDetector::IsOverusing(int usage_percent) { } bool OveruseFrameDetector::IsUnderusing(int usage_percent, int64_t time_now) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&task_checker_); + RTC_DCHECK_RUN_ON(&task_checker_); int delay = in_quick_rampup_ ? kQuickRampUpDelayMs : current_rampup_delay_ms_; if (time_now < last_rampup_time_ms_ + delay) return false; diff --git a/video/overuse_frame_detector.h b/video/overuse_frame_detector.h index b63a3aebd3..c65acc2b76 100644 --- a/video/overuse_frame_detector.h +++ b/video/overuse_frame_detector.h @@ -19,7 +19,7 @@ #include "modules/video_coding/utility/quality_scaler.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/numerics/exp_filter.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #include "rtc_base/task_utils/repeating_task.h" #include "rtc_base/thread_annotations.h" @@ -122,7 +122,7 @@ class OveruseFrameDetector { static std::unique_ptr CreateProcessingUsage( const CpuOveruseOptions& options); - rtc::SequencedTaskChecker task_checker_; + SequenceChecker task_checker_; // Owned by the task queue from where StartCheckForOveruse is called. RepeatingTaskHandle check_overuse_task_ RTC_GUARDED_BY(task_checker_); diff --git a/video/rtp_video_stream_receiver.cc b/video/rtp_video_stream_receiver.cc index 0a63c8761e..87b735c624 100644 --- a/video/rtp_video_stream_receiver.cc +++ b/video/rtp_video_stream_receiver.cc @@ -318,7 +318,7 @@ void RtpVideoStreamReceiver::OnRecoveredPacket(const uint8_t* rtp_packet, // This method handles both regular RTP packets and packets recovered // via FlexFEC. void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); if (!receiving_) { return; @@ -480,14 +480,14 @@ absl::optional RtpVideoStreamReceiver::LastReceivedKeyframePacketMs() } void RtpVideoStreamReceiver::AddSecondarySink(RtpPacketSinkInterface* sink) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); RTC_DCHECK(!absl::c_linear_search(secondary_sinks_, sink)); secondary_sinks_.push_back(sink); } void RtpVideoStreamReceiver::RemoveSecondarySink( const RtpPacketSinkInterface* sink) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); auto it = absl::c_find(secondary_sinks_, sink); if (it == secondary_sinks_.end()) { // We might be rolling-back a call whose setup failed mid-way. In such a @@ -610,7 +610,7 @@ void RtpVideoStreamReceiver::ReceivePacket(const RtpPacketReceived& packet) { void RtpVideoStreamReceiver::ParseAndHandleEncapsulatingHeader( const RtpPacketReceived& packet) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); if (packet.PayloadType() == config_.rtp.red_payload_type && packet.payload_size() > 0) { if (packet.payload()[0] == config_.rtp.ulpfec_payload_type) { @@ -648,7 +648,7 @@ void RtpVideoStreamReceiver::NotifyReceiverOfEmptyPacket(uint16_t seq_num) { bool RtpVideoStreamReceiver::DeliverRtcp(const uint8_t* rtcp_packet, size_t rtcp_packet_length) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); if (!receiving_) { return false; @@ -725,12 +725,12 @@ int RtpVideoStreamReceiver::GetUniqueFramesSeen() const { } void RtpVideoStreamReceiver::StartReceive() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); receiving_ = true; } void RtpVideoStreamReceiver::StopReceive() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_task_checker_); + RTC_DCHECK_RUN_ON(&worker_task_checker_); receiving_ = false; } diff --git a/video/rtp_video_stream_receiver.h b/video/rtp_video_stream_receiver.h index 1bc5d8a8b3..7caeedca16 100644 --- a/video/rtp_video_stream_receiver.h +++ b/video/rtp_video_stream_receiver.h @@ -39,7 +39,7 @@ #include "rtc_base/constructor_magic.h" #include "rtc_base/critical_section.h" #include "rtc_base/numerics/sequence_number_util.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_annotations.h" #include "rtc_base/thread_checker.h" #include "video/buffered_frame_decryptor.h" @@ -199,7 +199,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender, ReceiveStatistics* const rtp_receive_statistics_; std::unique_ptr ulpfec_receiver_; - rtc::SequencedTaskChecker worker_task_checker_; + SequenceChecker worker_task_checker_; bool receiving_ RTC_GUARDED_BY(worker_task_checker_); int64_t last_packet_log_ms_ RTC_GUARDED_BY(worker_task_checker_); diff --git a/video/video_receive_stream.cc b/video/video_receive_stream.cc index a03b24f3c5..b9199d8898 100644 --- a/video/video_receive_stream.cc +++ b/video/video_receive_stream.cc @@ -285,7 +285,7 @@ VideoReceiveStream::VideoReceiveStream( new VCMTiming(clock)) {} VideoReceiveStream::~VideoReceiveStream() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); RTC_LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString(); Stop(); if (config_.media_transport) { @@ -296,7 +296,7 @@ VideoReceiveStream::~VideoReceiveStream() { } void VideoReceiveStream::SignalNetworkState(NetworkState state) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); rtp_video_stream_receiver_.SignalNetworkState(state); } @@ -305,12 +305,12 @@ bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) { } void VideoReceiveStream::SetSync(Syncable* audio_syncable) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); rtp_stream_sync_.ConfigureSync(audio_syncable); } void VideoReceiveStream::Start() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); if (decode_thread_.IsRunning()) { return; @@ -396,7 +396,7 @@ void VideoReceiveStream::Start() { } void VideoReceiveStream::Stop() { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); rtp_video_stream_receiver_.StopReceive(); stats_proxy_.OnUniqueFramesCounted( @@ -441,7 +441,7 @@ void VideoReceiveStream::RemoveSecondarySink( } bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); if (delay_ms < kMinBaseMinimumDelayMs || delay_ms > kMaxBaseMinimumDelayMs) { return false; } @@ -453,7 +453,7 @@ bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) { } int VideoReceiveStream::GetBaseMinimumPlayoutDelayMs() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); rtc::CritScope cs(&playout_delay_lock_); return base_minimum_playout_delay_ms_; @@ -499,7 +499,7 @@ void VideoReceiveStream::RequestKeyFrame() { void VideoReceiveStream::OnCompleteFrame( std::unique_ptr frame) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&network_sequence_checker_); + RTC_DCHECK_RUN_ON(&network_sequence_checker_); // TODO(https://bugs.webrtc.org/9974): Consider removing this workaround. int64_t time_now_ms = rtc::TimeMillis(); if (last_complete_frame_time_ms_ > 0 && @@ -533,7 +533,7 @@ void VideoReceiveStream::OnData(uint64_t channel_id, } void VideoReceiveStream::OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_); + RTC_DCHECK_RUN_ON(&module_process_sequence_checker_); frame_buffer_->UpdateRtt(max_rtt_ms); rtp_video_stream_receiver_.UpdateRtt(max_rtt_ms); } @@ -543,12 +543,12 @@ void VideoReceiveStream::OnRttUpdated(int64_t rtt_ms) { } int VideoReceiveStream::id() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&worker_sequence_checker_); + RTC_DCHECK_RUN_ON(&worker_sequence_checker_); return config_.rtp.remote_ssrc; } absl::optional VideoReceiveStream::GetInfo() const { - RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_); + RTC_DCHECK_RUN_ON(&module_process_sequence_checker_); absl::optional info = rtp_video_stream_receiver_.GetSyncInfo(); @@ -565,7 +565,7 @@ uint32_t VideoReceiveStream::GetPlayoutTimestamp() const { } void VideoReceiveStream::SetMinimumPlayoutDelay(int delay_ms) { - RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_); + RTC_DCHECK_RUN_ON(&module_process_sequence_checker_); rtc::CritScope cs(&playout_delay_lock_); syncable_minimum_playout_delay_ms_ = delay_ms; UpdatePlayoutDelays(); diff --git a/video/video_receive_stream.h b/video/video_receive_stream.h index 75f27b3ddd..585a2cc308 100644 --- a/video/video_receive_stream.h +++ b/video/video_receive_stream.h @@ -22,7 +22,7 @@ #include "modules/rtp_rtcp/include/flexfec_receiver.h" #include "modules/video_coding/frame_buffer2.h" #include "modules/video_coding/video_coding_impl.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "system_wrappers/include/clock.h" #include "video/receive_statistics_proxy.h" #include "video/rtp_streams_synchronizer.h" @@ -141,9 +141,9 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream, void UpdatePlayoutDelays() const RTC_EXCLUSIVE_LOCKS_REQUIRED(playout_delay_lock_); - rtc::SequencedTaskChecker worker_sequence_checker_; - rtc::SequencedTaskChecker module_process_sequence_checker_; - rtc::SequencedTaskChecker network_sequence_checker_; + SequenceChecker worker_sequence_checker_; + SequenceChecker module_process_sequence_checker_; + SequenceChecker network_sequence_checker_; TaskQueueFactory* const task_queue_factory_; diff --git a/video/video_send_stream_impl.cc b/video/video_send_stream_impl.cc index f2a77561e8..af074c4819 100644 --- a/video/video_send_stream_impl.cc +++ b/video/video_send_stream_impl.cc @@ -29,7 +29,7 @@ #include "rtc_base/experiments/rate_control_settings.h" #include "rtc_base/logging.h" #include "rtc_base/numerics/safe_conversions.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/thread_checker.h" #include "rtc_base/trace_event.h" #include "system_wrappers/include/clock.h" diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc index badfd8176b..ac17124bb4 100644 --- a/video/video_stream_encoder.cc +++ b/video/video_stream_encoder.cc @@ -228,7 +228,7 @@ class VideoStreamEncoder::VideoSourceProxy { void SetSource(rtc::VideoSourceInterface* source, const DegradationPreference& degradation_preference) { // Called on libjingle's worker thread. - RTC_DCHECK_CALLED_SEQUENTIALLY(&main_checker_); + RTC_DCHECK_RUN_ON(&main_checker_); rtc::VideoSourceInterface* old_source = nullptr; rtc::VideoSinkWants wants; { @@ -434,7 +434,7 @@ class VideoStreamEncoder::VideoSourceProxy { } rtc::CriticalSection crit_; - rtc::SequencedTaskChecker main_checker_; + SequenceChecker main_checker_; VideoStreamEncoder* const video_stream_encoder_; rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(&crit_); DegradationPreference degradation_preference_ RTC_GUARDED_BY(&crit_); diff --git a/video/video_stream_encoder.h b/video/video_stream_encoder.h index 094cbcc56c..61585f705b 100644 --- a/video/video_stream_encoder.h +++ b/video/video_stream_encoder.h @@ -32,7 +32,7 @@ #include "rtc_base/experiments/rate_control_settings.h" #include "rtc_base/race_checker.h" #include "rtc_base/rate_statistics.h" -#include "rtc_base/sequenced_task_checker.h" +#include "rtc_base/synchronization/sequence_checker.h" #include "rtc_base/task_queue.h" #include "video/encoder_bitrate_adjuster.h" #include "video/frame_encode_timer.h"