diff --git a/api/notifier.h b/api/notifier.h
index fc2480e00a..64d5b22ad5 100644
--- a/api/notifier.h
+++ b/api/notifier.h
@@ -25,7 +25,7 @@ namespace webrtc {
 template <class T>
 class Notifier : public T {
  public:
-  Notifier() { sequence_checker_.Detach(); }
+  Notifier() = default;
 
   virtual void RegisterObserver(ObserverInterface* observer) {
     RTC_DCHECK_RUN_ON(&sequence_checker_);
@@ -60,7 +60,8 @@ class Notifier : public T {
   std::list<ObserverInterface*> observers_ RTC_GUARDED_BY(sequence_checker_);
 
  private:
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_{
+      SequenceChecker::kDetached};
 };
 
 }  // namespace webrtc
diff --git a/audio/audio_receive_stream.cc b/audio/audio_receive_stream.cc
index 7430681f45..254ae5f3b6 100644
--- a/audio/audio_receive_stream.cc
+++ b/audio/audio_receive_stream.cc
@@ -112,8 +112,6 @@ AudioReceiveStreamImpl::AudioReceiveStreamImpl(
   RTC_DCHECK(audio_state_);
   RTC_DCHECK(channel_receive_);
 
-  packet_sequence_checker_.Detach();
-
   RTC_DCHECK(packet_router);
   // Configure bandwidth estimation.
   channel_receive_->RegisterReceiverCongestionControlObjects(packet_router);
diff --git a/audio/audio_receive_stream.h b/audio/audio_receive_stream.h
index b0df0a7f0d..db49631638 100644
--- a/audio/audio_receive_stream.h
+++ b/audio/audio_receive_stream.h
@@ -154,7 +154,8 @@ class AudioReceiveStreamImpl final : public webrtc::AudioReceiveStreamInterface,
   // thread, but still serves as a mechanism of grouping together concepts
   // that belong to the network thread. Once the packets are fully delivered
   // on the network thread, this comment will be deleted.
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker packet_sequence_checker_{
+      SequenceChecker::kDetached};
   webrtc::AudioReceiveStreamInterface::Config config_;
   rtc::scoped_refptr<webrtc::AudioState> audio_state_;
   SourceTracker source_tracker_;
diff --git a/audio/audio_state.cc b/audio/audio_state.cc
index 76ff152eea..6f20e7b128 100644
--- a/audio/audio_state.cc
+++ b/audio/audio_state.cc
@@ -32,7 +32,6 @@ AudioState::AudioState(const AudioState::Config& config)
       audio_transport_(config_.audio_mixer.get(),
                        config_.audio_processing.get(),
                        config_.async_audio_processing_factory.get()) {
-  process_thread_checker_.Detach();
   RTC_DCHECK(config_.audio_mixer);
   RTC_DCHECK(config_.audio_device_module);
 }
diff --git a/audio/audio_state.h b/audio/audio_state.h
index 6c2b7aa453..88aaaa3697 100644
--- a/audio/audio_state.h
+++ b/audio/audio_state.h
@@ -65,7 +65,7 @@ class AudioState : public webrtc::AudioState {
   void UpdateNullAudioPollerState() RTC_RUN_ON(&thread_checker_);
 
   SequenceChecker thread_checker_;
-  SequenceChecker process_thread_checker_;
+  SequenceChecker process_thread_checker_{SequenceChecker::kDetached};
   const webrtc::AudioState::Config config_;
   bool recording_enabled_ = true;
   bool playout_enabled_ = true;
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index a8b58c07e3..265cd850b2 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -695,8 +695,6 @@ WebRtcVideoChannel::WebRtcVideoChannel(
                     "WebRTC-Video-DiscardPacketsWithUnknownSsrc")),
       crypto_options_(crypto_options) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
-  network_thread_checker_.Detach();
-
   rtcp_receiver_report_ssrc_ = kDefaultRtcpReceiverReportSsrc;
   sending_ = false;
   recv_codecs_ = MapCodecs(GetPayloadTypesAndDefaultCodecs(
diff --git a/media/engine/webrtc_video_engine.h b/media/engine/webrtc_video_engine.h
index e6c9c28586..2cdd05ffd6 100644
--- a/media/engine/webrtc_video_engine.h
+++ b/media/engine/webrtc_video_engine.h
@@ -613,7 +613,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
 
   webrtc::TaskQueueBase* const worker_thread_;
   webrtc::ScopedTaskSafety task_safety_;
-  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker network_thread_checker_;
+  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker network_thread_checker_{
+      webrtc::SequenceChecker::kDetached};
   RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker thread_checker_;
 
   uint32_t rtcp_receiver_report_ssrc_ RTC_GUARDED_BY(thread_checker_);
diff --git a/media/engine/webrtc_voice_engine.cc b/media/engine/webrtc_voice_engine.cc
index ab9a3fc7b8..a1c5d12c54 100644
--- a/media/engine/webrtc_voice_engine.cc
+++ b/media/engine/webrtc_voice_engine.cc
@@ -305,9 +305,6 @@ WebRtcVoiceEngine::WebRtcVoiceEngine(
       audio_frame_processor_(audio_frame_processor),
       minimized_remsampling_on_mobile_trial_enabled_(
           IsEnabled(trials, "WebRTC-Audio-MinimizeResamplingOnMobile")) {
-  // This may be called from any thread, so detach thread checkers.
-  worker_thread_checker_.Detach();
-  signal_thread_checker_.Detach();
   RTC_LOG(LS_INFO) << "WebRtcVoiceEngine::WebRtcVoiceEngine";
   RTC_DCHECK(decoder_factory);
   RTC_DCHECK(encoder_factory);
@@ -1265,7 +1262,6 @@ WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel(
       audio_config_(config.audio),
       codec_pair_id_(codec_pair_id),
       crypto_options_(crypto_options) {
-  network_thread_checker_.Detach();
   RTC_LOG(LS_VERBOSE) << "WebRtcVoiceMediaChannel::WebRtcVoiceMediaChannel";
   RTC_DCHECK(call);
   SetOptions(options);
diff --git a/media/engine/webrtc_voice_engine.h b/media/engine/webrtc_voice_engine.h
index 6d25397e68..f5d8080723 100644
--- a/media/engine/webrtc_voice_engine.h
+++ b/media/engine/webrtc_voice_engine.h
@@ -110,8 +110,10 @@ class WebRtcVoiceEngine final : public VoiceEngineInterface {
   std::vector<AudioCodec> CollectCodecs(
       const std::vector<webrtc::AudioCodecSpec>& specs) const;
 
-  webrtc::SequenceChecker signal_thread_checker_;
-  webrtc::SequenceChecker worker_thread_checker_;
+  webrtc::SequenceChecker signal_thread_checker_{
+      webrtc::SequenceChecker::kDetached};
+  webrtc::SequenceChecker worker_thread_checker_{
+      webrtc::SequenceChecker::kDetached};
 
   // The audio device module.
   rtc::scoped_refptr<webrtc::AudioDeviceModule> adm_;
@@ -286,7 +288,8 @@ class WebRtcVoiceMediaChannel final : public VoiceMediaChannel,
 
   webrtc::TaskQueueBase* const worker_thread_;
   webrtc::ScopedTaskSafety task_safety_;
-  webrtc::SequenceChecker network_thread_checker_;
+  webrtc::SequenceChecker network_thread_checker_{
+      webrtc::SequenceChecker::kDetached};
 
   WebRtcVoiceEngine* const engine_ = nullptr;
   std::vector<AudioCodec> send_codecs_;
diff --git a/pc/jitter_buffer_delay.cc b/pc/jitter_buffer_delay.cc
index 801cef7215..f22b0650f9 100644
--- a/pc/jitter_buffer_delay.cc
+++ b/pc/jitter_buffer_delay.cc
@@ -22,10 +22,6 @@ constexpr int kMaximumDelayMs = 10000;
 
 namespace webrtc {
 
-JitterBufferDelay::JitterBufferDelay() {
-  worker_thread_checker_.Detach();
-}
-
 void JitterBufferDelay::Set(absl::optional<double> delay_seconds) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
   cached_delay_seconds_ = delay_seconds;
diff --git a/pc/jitter_buffer_delay.h b/pc/jitter_buffer_delay.h
index a6bec01ce7..caf713b045 100644
--- a/pc/jitter_buffer_delay.h
+++ b/pc/jitter_buffer_delay.h
@@ -25,13 +25,14 @@ namespace webrtc {
 // the start of media_channel by caching its request.
 class JitterBufferDelay {
  public:
-  JitterBufferDelay();
+  JitterBufferDelay() = default;
 
   void Set(absl::optional<double> delay_seconds);
   int GetMs() const;
 
  private:
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_checker_{
+      SequenceChecker::kDetached};
   absl::optional<double> cached_delay_seconds_
       RTC_GUARDED_BY(&worker_thread_checker_);
 };
diff --git a/pc/jsep_transport_collection.h b/pc/jsep_transport_collection.h
index 0bb19a3260..f5eba64e96 100644
--- a/pc/jsep_transport_collection.h
+++ b/pc/jsep_transport_collection.h
@@ -44,10 +44,7 @@ namespace webrtc {
 class BundleManager {
  public:
   explicit BundleManager(PeerConnectionInterface::BundlePolicy bundle_policy)
-      : bundle_policy_(bundle_policy) {
-    // Allow constructor to be called on a different thread.
-    sequence_checker_.Detach();
-  }
+      : bundle_policy_(bundle_policy) {}
   const std::vector<std::unique_ptr<cricket::ContentGroup>>& bundle_groups()
       const {
     RTC_DCHECK_RUN_ON(&sequence_checker_);
@@ -76,7 +73,8 @@ class BundleManager {
   // Recalculate established_bundle_groups_by_mid_ from bundle_groups_.
   void RefreshEstablishedBundleGroupsByMid() RTC_RUN_ON(sequence_checker_);
 
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_{
+      SequenceChecker::kDetached};
   PeerConnectionInterface::BundlePolicy bundle_policy_;
   std::vector<std::unique_ptr<cricket::ContentGroup>> bundle_groups_
       RTC_GUARDED_BY(sequence_checker_);
@@ -97,10 +95,7 @@ class JsepTransportCollection {
                               map_change_callback,
                           std::function<void()> state_change_callback)
       : map_change_callback_(map_change_callback),
-        state_change_callback_(state_change_callback) {
-    // Allow constructor to be called on a different thread.
-    sequence_checker_.Detach();
-  }
+        state_change_callback_(state_change_callback) {}
 
   void RegisterTransport(const std::string& mid,
                          std::unique_ptr<cricket::JsepTransport> transport);
@@ -151,7 +146,8 @@ class JsepTransportCollection {
 
   bool IsConsistent();  // For testing only: Verify internal structure.
 
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_{
+      SequenceChecker::kDetached};
   // This member owns the JSEP transports.
   std::map<std::string, std::unique_ptr<cricket::JsepTransport>>
       jsep_transports_by_name_ RTC_GUARDED_BY(sequence_checker_);
diff --git a/pc/test/fake_audio_capture_module.cc b/pc/test/fake_audio_capture_module.cc
index 132328291c..6ffa18c886 100644
--- a/pc/test/fake_audio_capture_module.cc
+++ b/pc/test/fake_audio_capture_module.cc
@@ -44,9 +44,7 @@ FakeAudioCaptureModule::FakeAudioCaptureModule()
       current_mic_level_(kMaxVolume),
       started_(false),
       next_frame_time_(0),
-      frames_received_(0) {
-  process_thread_checker_.Detach();
-}
+      frames_received_(0) {}
 
 FakeAudioCaptureModule::~FakeAudioCaptureModule() {
   if (process_thread_) {
diff --git a/pc/test/fake_audio_capture_module.h b/pc/test/fake_audio_capture_module.h
index 84ddacb26f..c04373cdfd 100644
--- a/pc/test/fake_audio_capture_module.h
+++ b/pc/test/fake_audio_capture_module.h
@@ -229,7 +229,8 @@ class FakeAudioCaptureModule : public webrtc::AudioDeviceModule {
   // Protects variables that are accessed from process_thread_ and
   // the main thread.
   mutable webrtc::Mutex mutex_;
-  webrtc::SequenceChecker process_thread_checker_;
+  webrtc::SequenceChecker process_thread_checker_{
+      webrtc::SequenceChecker::kDetached};
 };
 
 #endif  // PC_TEST_FAKE_AUDIO_CAPTURE_MODULE_H_
diff --git a/pc/test/fake_periodic_video_source.h b/pc/test/fake_periodic_video_source.h
index 871c29cbae..407811578c 100644
--- a/pc/test/fake_periodic_video_source.h
+++ b/pc/test/fake_periodic_video_source.h
@@ -46,7 +46,6 @@ class FakePeriodicVideoSource final
             config.timestamp_offset_ms * rtc::kNumMicrosecsPerMillisec),
         task_queue_(std::make_unique<TaskQueueForTest>(
             "FakePeriodicVideoTrackSource")) {
-    thread_checker_.Detach();
     frame_source_.SetRotation(config.rotation);
 
     TimeDelta frame_interval = TimeDelta::Millis(config.frame_interval_ms);
@@ -86,7 +85,7 @@ class FakePeriodicVideoSource final
   }
 
  private:
-  SequenceChecker thread_checker_;
+  SequenceChecker thread_checker_{SequenceChecker::kDetached};
 
   rtc::VideoBroadcaster broadcaster_;
   cricket::FakeFrameSource frame_source_;
diff --git a/pc/test/integration_test_helpers.cc b/pc/test/integration_test_helpers.cc
index 911ce3f263..3f07c9e826 100644
--- a/pc/test/integration_test_helpers.cc
+++ b/pc/test/integration_test_helpers.cc
@@ -56,9 +56,7 @@ int FindFirstMediaStatsIndexByKind(
 }
 
 TaskQueueMetronome::TaskQueueMetronome(TimeDelta tick_period)
-    : tick_period_(tick_period) {
-  sequence_checker_.Detach();
-}
+    : tick_period_(tick_period) {}
 
 TaskQueueMetronome::~TaskQueueMetronome() {
   RTC_DCHECK_RUN_ON(&sequence_checker_);
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 200a025ca5..8cf18ce2f0 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -186,7 +186,7 @@ class TaskQueueMetronome : public webrtc::Metronome {
 
  private:
   const TimeDelta tick_period_;
-  SequenceChecker sequence_checker_;
+  SequenceChecker sequence_checker_{SequenceChecker::kDetached};
   std::vector<absl::AnyInvocable<void() &&>> callbacks_;
   ScopedTaskSafetyDetached safety_;
 };
diff --git a/pc/video_rtp_track_source.cc b/pc/video_rtp_track_source.cc
index bcfcdcbdf9..e4b333c7c2 100644
--- a/pc/video_rtp_track_source.cc
+++ b/pc/video_rtp_track_source.cc
@@ -19,9 +19,7 @@
 namespace webrtc {
 
 VideoRtpTrackSource::VideoRtpTrackSource(Callback* callback)
-    : VideoTrackSource(true /* remote */), callback_(callback) {
-  worker_sequence_checker_.Detach();
-}
+    : VideoTrackSource(true /* remote */), callback_(callback) {}
 
 void VideoRtpTrackSource::ClearCallback() {
   RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
diff --git a/pc/video_rtp_track_source.h b/pc/video_rtp_track_source.h
index a9e43f6667..bf7da99f98 100644
--- a/pc/video_rtp_track_source.h
+++ b/pc/video_rtp_track_source.h
@@ -76,7 +76,8 @@ class VideoRtpTrackSource : public VideoTrackSource {
       rtc::VideoSinkInterface<RecordableEncodedFrame>* sink) override;
 
  private:
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_sequence_checker_{
+      SequenceChecker::kDetached};
   // `broadcaster_` is needed since the decoder can only handle one sink.
   // It might be better if the decoder can handle multiple sinks and consider
   // the VideoSinkWants.
diff --git a/pc/video_track_source.cc b/pc/video_track_source.cc
index 64e99cc064..d4b7f55055 100644
--- a/pc/video_track_source.cc
+++ b/pc/video_track_source.cc
@@ -15,9 +15,7 @@
 namespace webrtc {
 
 VideoTrackSource::VideoTrackSource(bool remote)
-    : state_(kInitializing), remote_(remote) {
-  worker_thread_checker_.Detach();
-}
+    : state_(kInitializing), remote_(remote) {}
 
 void VideoTrackSource::SetState(SourceState new_state) {
   RTC_DCHECK_RUN_ON(&signaling_thread_checker_);
diff --git a/pc/video_track_source.h b/pc/video_track_source.h
index 723b10d8f3..6aae178f37 100644
--- a/pc/video_track_source.h
+++ b/pc/video_track_source.h
@@ -62,7 +62,8 @@ class RTC_EXPORT VideoTrackSource : public Notifier<VideoTrackSourceInterface> {
   virtual rtc::VideoSourceInterface<VideoFrame>* source() = 0;
 
  private:
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_checker_;
+  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_thread_checker_{
+      SequenceChecker::kDetached};
   RTC_NO_UNIQUE_ADDRESS SequenceChecker signaling_thread_checker_;
   SourceState state_ RTC_GUARDED_BY(&signaling_thread_checker_);
   const bool remote_;
diff --git a/rtc_base/async_packet_socket.cc b/rtc_base/async_packet_socket.cc
index 1ce0d3b122..465a35d9c2 100644
--- a/rtc_base/async_packet_socket.cc
+++ b/rtc_base/async_packet_socket.cc
@@ -24,10 +24,6 @@ PacketOptions::PacketOptions(DiffServCodePoint dscp) : dscp(dscp) {}
 PacketOptions::PacketOptions(const PacketOptions& other) = default;
 PacketOptions::~PacketOptions() = default;
 
-AsyncPacketSocket::AsyncPacketSocket() {
-  network_checker_.Detach();
-}
-
 AsyncPacketSocket::~AsyncPacketSocket() = default;
 
 void AsyncPacketSocket::SubscribeClose(
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index aa31e25eab..90f2a13945 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -68,7 +68,7 @@ class RTC_EXPORT AsyncPacketSocket : public sigslot::has_slots<> {
     STATE_CONNECTED
   };
 
-  AsyncPacketSocket();
+  AsyncPacketSocket() = default;
   ~AsyncPacketSocket() override;
 
   AsyncPacketSocket(const AsyncPacketSocket&) = delete;
@@ -148,7 +148,8 @@ class RTC_EXPORT AsyncPacketSocket : public sigslot::has_slots<> {
     on_close_.Send(this, err);
   }
 
-  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker network_checker_;
+  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker network_checker_{
+      webrtc::SequenceChecker::kDetached};
 
  private:
   webrtc::CallbackList<AsyncPacketSocket*, int> on_close_
diff --git a/rtc_base/unique_id_generator.h b/rtc_base/unique_id_generator.h
index d103caf2fc..10dd4d3151 100644
--- a/rtc_base/unique_id_generator.h
+++ b/rtc_base/unique_id_generator.h
@@ -53,7 +53,8 @@ class UniqueNumberGenerator {
   bool AddKnownId(TIntegral value);
 
  private:
-  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
+  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_{
+      webrtc::SequenceChecker::kDetached};
   static_assert(std::is_integral<TIntegral>::value, "Must be integral type.");
   TIntegral counter_ RTC_GUARDED_BY(sequence_checker_);
   std::set<TIntegral> known_ids_ RTC_GUARDED_BY(sequence_checker_);
@@ -117,16 +118,12 @@ class UniqueStringGenerator {
 };
 
 template <typename TIntegral>
-UniqueNumberGenerator<TIntegral>::UniqueNumberGenerator() : counter_(0) {
-  sequence_checker_.Detach();
-}
+UniqueNumberGenerator<TIntegral>::UniqueNumberGenerator() : counter_(0) {}
 
 template <typename TIntegral>
 UniqueNumberGenerator<TIntegral>::UniqueNumberGenerator(
     ArrayView<TIntegral> known_ids)
-    : counter_(0), known_ids_(known_ids.begin(), known_ids.end()) {
-  sequence_checker_.Detach();
-}
+    : counter_(0), known_ids_(known_ids.begin(), known_ids.end()) {}
 
 template <typename TIntegral>
 UniqueNumberGenerator<TIntegral>::~UniqueNumberGenerator() {}
diff --git a/rtc_base/weak_ptr.cc b/rtc_base/weak_ptr.cc
index 09807e1705..3bfa71b0b4 100644
--- a/rtc_base/weak_ptr.cc
+++ b/rtc_base/weak_ptr.cc
@@ -16,12 +16,7 @@
 namespace rtc {
 namespace internal {
 
-WeakReference::Flag::Flag() : is_valid_(true) {
-  // Flags only become bound when checked for validity, or invalidated,
-  // so that we can check that later validity/invalidation operations on
-  // the same Flag take place on the same sequence.
-  checker_.Detach();
-}
+WeakReference::Flag::Flag() : is_valid_(true) {}
 
 void WeakReference::Flag::Invalidate() {
   RTC_DCHECK(checker_.IsCurrent())
diff --git a/rtc_base/weak_ptr.h b/rtc_base/weak_ptr.h
index a9e6b3a990..7e75b5b9be 100644
--- a/rtc_base/weak_ptr.h
+++ b/rtc_base/weak_ptr.h
@@ -104,7 +104,8 @@ class WeakReference {
 
     ~Flag() override;
 
-    RTC_NO_UNIQUE_ADDRESS ::webrtc::SequenceChecker checker_;
+    RTC_NO_UNIQUE_ADDRESS ::webrtc::SequenceChecker checker_{
+        webrtc::SequenceChecker::kDetached};
     bool is_valid_;
   };