Replacing SequencedTaskChecker with SequenceChecker.
Bug: webrtc:9883
Change-Id: I5e3189da2a46e6f4ed1a3c5a5dfd2f7d75a16b5d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/130961
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27518}diff --git a/BUILD.gn b/BUILD.gn
index 0c2096b..bfe6d02 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -489,10 +489,10 @@
"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 11be068..346cbe2 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -185,7 +185,7 @@
"../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_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 @@
"../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 @@
"../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 9ddc786..9d2705f 100644
--- a/call/bitrate_allocator.cc
+++ b/call/bitrate_allocator.cc
@@ -77,7 +77,7 @@
}
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 @@
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::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::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 @@
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 @@
void BitrateAllocator::SetBitrateAllocationStrategy(
std::unique_ptr<rtc::BitrateAllocationStrategy>
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 bb2d149..f35f3f7 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 @@
// 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 38a4dd5..84f29d8 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 @@
const std::unique_ptr<CallStats> call_stats_;
const std::unique_ptr<BitrateAllocator> 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() {
- 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 @@
}
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 @@
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 @@
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<RtcEventAudioReceiveStreamConfig>(
CreateRtcLogStreamConfig(config)));
@@ -806,7 +806,7 @@
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<webrtc::internal::AudioReceiveStream*>(receive_stream);
@@ -836,7 +836,7 @@
VideoEncoderConfig encoder_config,
std::unique_ptr<FecController> 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 @@
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 @@
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 @@
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<VideoReceiveStream*>(receive_stream);
@@ -994,7 +994,7 @@
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 @@
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 @@
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<unsigned int> ssrcs;
@@ -1101,7 +1101,7 @@
}
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::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 @@
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 8edfe3c..81f24b5 100644
--- a/logging/BUILD.gn
+++ b/logging/BUILD.gn
@@ -264,7 +264,7 @@
"../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 1b2e82a..f62f690 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 @@
// 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<std::unique_ptr<RtcEvent>> config_history_
@@ -158,7 +158,7 @@
}
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 @@
bool RtcEventLogImpl::StartLogging(std::unique_ptr<RtcEventLogOutput> 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 @@
}
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 3afaf35..f895849 100644
--- a/media/BUILD.gn
+++ b/media/BUILD.gn
@@ -75,8 +75,8 @@
"../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 @@
"../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 cc26a30..09b0545 100644
--- a/media/engine/simulcast_encoder_adapter.cc
+++ b/media/engine/simulcast_encoder_adapter.cc
@@ -144,7 +144,7 @@
}
int SimulcastEncoderAdapter::Release() {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_);
+ RTC_DCHECK_RUN_ON(&encoder_queue_);
while (!streaminfos_.empty()) {
std::unique_ptr<VideoEncoder> encoder =
@@ -169,7 +169,7 @@
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::Encode(
const VideoFrame& input_image,
const std::vector<VideoFrameType>* 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::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::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 202967f..a7b0361 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 @@
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 a075cce..357e1a6 100644
--- a/modules/congestion_controller/rtp/BUILD.gn
+++ b/modules/congestion_controller/rtp/BUILD.gn
@@ -32,7 +32,7 @@
"../../../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 808c195..9272d99 100644
--- a/modules/congestion_controller/rtp/control_handler.cc
+++ b/modules/congestion_controller/rtp/control_handler.cc
@@ -37,22 +37,22 @@
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<TargetTransferRate> 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 cf6d70c..554c9e8 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 @@
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 6c2e09e..32ef465 100644
--- a/modules/rtp_rtcp/BUILD.gn
+++ b/modules/rtp_rtcp/BUILD.gn
@@ -227,7 +227,7 @@
"../../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 2426559..e1844a4 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 @@
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 1750927..d9850bf 100644
--- a/modules/rtp_rtcp/source/flexfec_receiver.cc
+++ b/modules/rtp_rtcp/source/flexfec_receiver.cc
@@ -61,7 +61,7 @@
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 @@
}
FecPacketCounter FlexfecReceiver::GetPacketCounter() const {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
return packet_counter_;
}
@@ -87,7 +87,7 @@
// recovered packets here.
std::unique_ptr<ReceivedPacket> 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 @@
// 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 7144afd..814efcc 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 304dd4f..12d02bf 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -165,10 +165,10 @@
"../../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_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 @@
"../../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 e2e79aa..708f6fe 100644
--- a/modules/video_coding/codecs/test/videoprocessor.cc
+++ b/modules/video_coding/codecs/test/videoprocessor.cc
@@ -226,7 +226,7 @@
}
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 @@
}
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::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<uint32_t>(framerate_fps);
bitrate_allocation_ = bitrate_allocator_->GetAllocation(
static_cast<uint32_t>(bitrate_kbps * 1000), framerate_fps_);
@@ -333,7 +333,7 @@
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::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::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 4935796..64f9c5c 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 @@
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 44cca34..3bab787 100644
--- a/modules/video_coding/loss_notification_controller.cc
+++ b/modules/video_coding/loss_notification_controller.cc
@@ -44,7 +44,7 @@
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 @@
uint16_t frame_id,
bool discardable,
rtc::ArrayView<const uint16_t> frame_dependency_diffs) {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&sequenced_task_checker_);
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
DiscardOldInformation(); // Prevent memory overconsumption.
@@ -144,7 +144,7 @@
bool LossNotificationController::AllDependenciesDecodable(
int64_t unwrapped_frame_id,
rtc::ArrayView<const uint16_t> 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 @@
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 4cdfbb8..09f4fef 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 @@
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<uint16_t> 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<int64_t> last_received_unwrapped_frame_id_
- RTC_GUARDED_BY(sequenced_task_checker_);
+ RTC_GUARDED_BY(sequence_checker_);
// Tracked to avoid processing repeated packets.
absl::optional<uint16_t> 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 @@
uint16_t first_seq_num;
};
absl::optional<FrameInfo> 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<int64_t> 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 4f4bb3b..54ef76a 100644
--- a/modules/video_coding/utility/quality_scaler.cc
+++ b/modules/video_coding/utility/quality_scaler.cc
@@ -88,7 +88,7 @@
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_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 @@
}
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::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::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::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 5e7ee0d..500d931 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 @@
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 e077633..4d83047 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 273ad0f..8c69b85 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -228,7 +228,7 @@
":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("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 @@
]
deps = [
":refcount",
- ":sequenced_task_checker",
"../api:scoped_refptr",
+ "synchronization:sequence_checker",
]
}
@@ -1280,24 +1271,6 @@
]
}
- 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 feaa04c..0000000
--- 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 bbba290..0000000
--- 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 <memory>
-#include <utility>
-
-#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<void()> run) {
- struct Object {
- static void Run(void* obj) {
- auto* me = static_cast<Object*>(obj);
- me->run();
- me->thread_has_run_event.Set();
- }
-
- FunctionView<void()> 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<SequencedTaskChecker>();
- 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 975c1a1..93a3fee 100644
--- a/rtc_base/synchronization/BUILD.gn
+++ b/rtc_base/synchronization/BUILD.gn
@@ -72,4 +72,22 @@
"../../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 0000000..ccdf6bc
--- /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 <memory>
+#include <utility>
+
+#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<void()> run) {
+ struct Object {
+ static void Run(void* obj) {
+ auto* me = static_cast<Object*>(obj);
+ me->run();
+ me->thread_has_run_event.Set();
+ }
+
+ rtc::FunctionView<void()> 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<SequenceChecker>();
+ 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 e562779..7a466a1 100644
--- a/rtc_base/task_utils/BUILD.gn
+++ b/rtc_base/task_utils/BUILD.gn
@@ -16,12 +16,12 @@
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 21ec130..8549049 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 ad98c24..09807e1 100644
--- a/rtc_base/weak_ptr.cc
+++ b/rtc_base/weak_ptr.cc
@@ -24,13 +24,13 @@
}
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 89969d6..80cb7ee 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 @@
~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 ca2c04c..e0fb603 100644
--- a/rtc_tools/network_tester/BUILD.gn
+++ b/rtc_tools/network_tester/BUILD.gn
@@ -51,7 +51,7 @@
"../../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 ecf9f5b..71e4e59 100644
--- a/rtc_tools/network_tester/packet_sender.cc
+++ b/rtc_tools/network_tester/packet_sender.cc
@@ -96,7 +96,7 @@
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<UpdateTestSettingTask>(
@@ -105,18 +105,18 @@
}
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 @@
}
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 c6ec64e..ffc1118 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 @@
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 87fb4c0..5200786 100644
--- a/rtc_tools/network_tester/test_controller.cc
+++ b/rtc_tools/network_tester/test_controller.cc
@@ -67,7 +67,7 @@
}
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 bde3b04..e522025 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 @@
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 6bc5d5d..920503a 100644
--- a/sdk/android/BUILD.gn
+++ b/sdk/android/BUILD.gn
@@ -632,8 +632,8 @@
"../../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 d39d902..dbf2b31 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 @@
// State that is constant for the lifetime of this object once the ctor
// returns.
- rtc::SequencedTaskChecker encoder_queue_checker_;
+ SequenceChecker encoder_queue_checker_;
ScopedJavaGlobalRef<jobject> j_media_codec_video_encoder_;
// State that is valid only between InitEncode() and the next Release().
@@ -307,7 +307,7 @@
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 @@
}
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 @@
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 @@
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::Encode(
const VideoFrame& frame,
const std::vector<VideoFrameType>* 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 @@
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 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<I420BufferInterface> i420_buffer =
@@ -861,7 +861,7 @@
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::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::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 @@
}
bool MediaCodecVideoEncoder::DeliverPendingOutputs(JNIEnv* jni) {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&encoder_queue_checker_);
+ RTC_DCHECK_RUN_ON(&encoder_queue_checker_);
while (true) {
ScopedJavaLocalRef<jobject> j_output_buffer_info =
diff --git a/test/BUILD.gn b/test/BUILD.gn
index 6486780..f166443 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@@ -592,7 +592,7 @@
"../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_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 15d765e..c2efe65 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 ec39f9c..ac59dfd 100644
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@@ -349,13 +349,13 @@
}
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<VideoFrameType>* frame_types) {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&sequence_checker_);
+ RTC_DCHECK_RUN_ON(&sequence_checker_);
SleepMs(delay_ms_);
@@ -378,7 +378,7 @@
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 @@
int32_t MultithreadedFakeH264Encoder::Encode(
const VideoFrame& input_image,
const std::vector<VideoFrameType>* 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::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 d09199d..95b4b20 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 @@
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 @@
RTC_GUARDED_BY(sequence_checker_);
std::unique_ptr<TaskQueueBase, TaskQueueDeleter> 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 5ea4b4e..bd92bc6 100644
--- a/test/fake_vp8_encoder.cc
+++ b/test/fake_vp8_encoder.cc
@@ -51,7 +51,7 @@
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 @@
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 @@
std::unique_ptr<RTPFragmentationHeader> 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 9328189..b5733c8 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 @@
EncodedImage* encoded_image,
CodecSpecificInfo* codec_specific) override;
- rtc::SequencedTaskChecker sequence_checker_;
+ SequenceChecker sequence_checker_;
std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
RTC_GUARDED_BY(sequence_checker_);
diff --git a/test/scenario/BUILD.gn b/test/scenario/BUILD.gn
index e6f3f46..b9d0a8a 100644
--- a/test/scenario/BUILD.gn
+++ b/test/scenario/BUILD.gn
@@ -128,8 +128,8 @@
"../../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 eb75af6..54b095c 100644
--- a/test/time_controller/BUILD.gn
+++ b/test/time_controller/BUILD.gn
@@ -29,7 +29,7 @@
"../../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 b4b943c..ddcbaab 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -94,13 +94,13 @@
"../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_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 24eed97..894a648 100644
--- a/video/overuse_frame_detector.cc
+++ b/video/overuse_frame_detector.cc
@@ -541,7 +541,7 @@
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::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 @@
}
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::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 @@
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::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::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 @@
int64_t time_sent_in_us,
int64_t capture_time_us,
absl::optional<int> 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::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::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 @@
}
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::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 b63a3ae..c65acc2 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 @@
static std::unique_ptr<ProcessingUsage> 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 0a63c87..87b735c 100644
--- a/video/rtp_video_stream_receiver.cc
+++ b/video/rtp_video_stream_receiver.cc
@@ -318,7 +318,7 @@
// 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 @@
}
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::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 @@
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 @@
}
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 1bc5d8a..7caeedc 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 @@
ReceiveStatistics* const rtp_receive_statistics_;
std::unique_ptr<UlpfecReceiver> 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 a03b24f..b9199d8 100644
--- a/video/video_receive_stream.cc
+++ b/video/video_receive_stream.cc
@@ -285,7 +285,7 @@
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 @@
}
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 @@
}
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::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 @@
}
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 @@
}
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::OnCompleteFrame(
std::unique_ptr<video_coding::EncodedFrame> 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::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 @@
}
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<Syncable::Info> VideoReceiveStream::GetInfo() const {
- RTC_DCHECK_CALLED_SEQUENTIALLY(&module_process_sequence_checker_);
+ RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
absl::optional<Syncable::Info> info =
rtp_video_stream_receiver_.GetSyncInfo();
@@ -565,7 +565,7 @@
}
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 75f27b3..585a2cc 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 @@
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 f2a7756..af074c4 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 badfd81..ac17124 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -228,7 +228,7 @@
void SetSource(rtc::VideoSourceInterface<VideoFrame>* 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<VideoFrame>* old_source = nullptr;
rtc::VideoSinkWants wants;
{
@@ -434,7 +434,7 @@
}
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 094cbcc..61585f7 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"
