Use SequenceChecker(SequenceChecker::kDetached) in a few places.

This CL is partly a test to see if there's an impact on binary size:
- Not a big difference for binaries (decrease): -776b to -4Kb
- For libraries (libwebrtc.a) it actually increases the size: +40Kb

Secondarily this CL is basically to introduce this pattern to the
code base. In terms of LOC, this makes things slightly more compact.

From:

  class Foo {
   public:
     Foo() {
       checker_.Detach();
     }
   private:
    SequenceChecker checker_;
  };

To:

  class Foo {
   public:
     Foo() = default;
   private:
    SequenceChecker checker_{SequenceChecker::kDetached};
  };

Bug: none
Change-Id: I59fc34ccea10847e13455a349851ce9a0af458e3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/299020
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39664}

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

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);

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_;

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);
 }

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;

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(

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_);

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);

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_;

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;

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_);
 };

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_);

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_) {

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_

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_;

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_);

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_;
 };

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_);

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.

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_);

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_;

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(

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_

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() {}

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())

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_;
   };