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"