Migrate video/ except video/end_to_end_tests and video/adaptation to webrtc::Mutex.

Also migrates test/ partly. Bug: webrtc:11567 Change-Id: If5b2eae65c5f297f364b6e3c67f94946a09b4a96 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178862 Commit-Queue: Markus Handell <handellm@webrtc.org> Reviewed-by: Sebastian Jansson <srte@webrtc.org> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org> Cr-Commit-Position: refs/heads/master@{#31672}
2025-05-13 13:50:40 +01:00 · 2020-07-08 13:13:32 +02:00 · 2020-07-08 13:13:32 +02:00 · a376518817
commit a376518817
parent a9e1b49704
34 changed files with 506 additions and 497 deletions
--- a/test/BUILD.gn
+++ b/test/BUILD.gn
@ -125,6 +125,7 @@ rtc_library("video_test_common") {
    "../rtc_base:rtc_base_approved",
    "../rtc_base:rtc_task_queue",
    "../rtc_base:timeutils",
    "../rtc_base/synchronization:mutex",
    "../rtc_base/task_utils:repeating_task",
    "../system_wrappers",
  ]
@ -763,6 +764,7 @@ rtc_library("fake_video_codecs") {
    "../rtc_base:macromagic",
    "../rtc_base:rtc_task_queue",
    "../rtc_base:timeutils",
    "../rtc_base/synchronization:mutex",
    "../rtc_base/synchronization:sequence_checker",
    "../system_wrappers",
  ]
--- a/test/fake_encoder.cc
+++ b/test/fake_encoder.cc
@ -67,19 +67,19 @@ void FakeEncoder::SetFecControllerOverride(
 void FakeEncoder::SetMaxBitrate(int max_kbps) {
  RTC_DCHECK_GE(max_kbps, -1);  // max_kbps == -1 disables it.
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  max_target_bitrate_kbps_ = max_kbps;
  SetRatesLocked(current_rate_settings_);
 }
 void FakeEncoder::SetQp(int qp) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  qp_ = qp;
 }
 int32_t FakeEncoder::InitEncode(const VideoCodec* config,
                                const Settings& settings) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  config_ = *config;
  current_rate_settings_.bitrate.SetBitrate(0, 0, config_.startBitrate * 1000);
  current_rate_settings_.framerate_fps = config_.maxFramerate;
@ -100,7 +100,7 @@ int32_t FakeEncoder::Encode(const VideoFrame& input_image,
  uint32_t counter;
  absl::optional<int> qp;
  {
-    rtc::CritScope cs(&crit_sect_);
+    MutexLock lock(&mutex_);
    max_framerate = config_.maxFramerate;
    num_simulcast_streams = config_.numberOfSimulcastStreams;
    for (int i = 0; i < num_simulcast_streams; ++i) {
@ -182,7 +182,7 @@ FakeEncoder::FrameInfo FakeEncoder::NextFrame(
    }
  }
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  for (uint8_t i = 0; i < num_simulcast_streams; ++i) {
    if (target_bitrate.GetBitrate(i, 0) > 0) {
      int temporal_id = last_frame_info_.layers.size() > i
@ -232,7 +232,7 @@ FakeEncoder::FrameInfo FakeEncoder::NextFrame(
 int32_t FakeEncoder::RegisterEncodeCompleteCallback(
    EncodedImageCallback* callback) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  callback_ = callback;
  return 0;
 }
@ -242,7 +242,7 @@ int32_t FakeEncoder::Release() {
 }
 void FakeEncoder::SetRates(const RateControlParameters& parameters) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  SetRatesLocked(parameters);
 }
@ -280,7 +280,7 @@ VideoEncoder::EncoderInfo FakeEncoder::GetEncoderInfo() const {
 }
 int FakeEncoder::GetConfiguredInputFramerate() const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
  return static_cast<int>(current_rate_settings_.framerate_fps + 0.5);
 }
@ -295,7 +295,7 @@ std::unique_ptr<RTPFragmentationHeader> FakeH264Encoder::EncodeHook(
  const int kIdrFrequency = 10;
  int current_idr_counter;
  {
-    rtc::CritScope cs(&local_crit_sect_);
+    MutexLock lock(&local_mutex_);
    current_idr_counter = idr_counter_;
    ++idr_counter_;
  }
--- a/test/fake_encoder.h
+++ b/test/fake_encoder.h
@ -26,7 +26,7 @@
 #include "api/video_codecs/video_encoder.h"
 #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/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/clock.h"
@ -40,23 +40,23 @@ class FakeEncoder : public VideoEncoder {
  virtual ~FakeEncoder() = default;
  // Sets max bitrate. Not thread-safe, call before registering the encoder.
-  void SetMaxBitrate(int max_kbps) RTC_LOCKS_EXCLUDED(crit_sect_);
+  void SetMaxBitrate(int max_kbps) RTC_LOCKS_EXCLUDED(mutex_);
-  void SetQp(int qp) RTC_LOCKS_EXCLUDED(crit_sect_);
+  void SetQp(int qp) RTC_LOCKS_EXCLUDED(mutex_);
  void SetFecControllerOverride(
      FecControllerOverride* fec_controller_override) override;
  int32_t InitEncode(const VideoCodec* config, const Settings& settings)
-      RTC_LOCKS_EXCLUDED(crit_sect_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
  int32_t Encode(const VideoFrame& input_image,
                 const std::vector<VideoFrameType>* frame_types)
-      RTC_LOCKS_EXCLUDED(crit_sect_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
  int32_t RegisterEncodeCompleteCallback(EncodedImageCallback* callback)
-      RTC_LOCKS_EXCLUDED(crit_sect_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
  int32_t Release() override;
  void SetRates(const RateControlParameters& parameters)
-      RTC_LOCKS_EXCLUDED(crit_sect_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
-  int GetConfiguredInputFramerate() const RTC_LOCKS_EXCLUDED(crit_sect_);
+  int GetConfiguredInputFramerate() const RTC_LOCKS_EXCLUDED(mutex_);
  EncoderInfo GetEncoderInfo() const override;
  static const char* kImplementationName;
@ -81,7 +81,7 @@ class FakeEncoder : public VideoEncoder {
                      uint8_t num_simulcast_streams,
                      const VideoBitrateAllocation& target_bitrate,
                      SimulcastStream simulcast_streams[kMaxSimulcastStreams],
-                      int framerate) RTC_LOCKS_EXCLUDED(crit_sect_);
+                      int framerate) RTC_LOCKS_EXCLUDED(mutex_);
  // Called before the frame is passed to callback_->OnEncodedImage, to let
  // subclasses fill out codec_specific, possibly modify encodedImage.
@ -91,20 +91,20 @@ class FakeEncoder : public VideoEncoder {
      CodecSpecificInfo* codec_specific);
  void SetRatesLocked(const RateControlParameters& parameters)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_sect_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  FrameInfo last_frame_info_ RTC_GUARDED_BY(crit_sect_);
+  FrameInfo last_frame_info_ RTC_GUARDED_BY(mutex_);
  Clock* const clock_;
-  VideoCodec config_ RTC_GUARDED_BY(crit_sect_);
+  VideoCodec config_ RTC_GUARDED_BY(mutex_);
-  EncodedImageCallback* callback_ RTC_GUARDED_BY(crit_sect_);
+  EncodedImageCallback* callback_ RTC_GUARDED_BY(mutex_);
-  RateControlParameters current_rate_settings_ RTC_GUARDED_BY(crit_sect_);
+  RateControlParameters current_rate_settings_ RTC_GUARDED_BY(mutex_);
-  int max_target_bitrate_kbps_ RTC_GUARDED_BY(crit_sect_);
+  int max_target_bitrate_kbps_ RTC_GUARDED_BY(mutex_);
-  bool pending_keyframe_ RTC_GUARDED_BY(crit_sect_);
+  bool pending_keyframe_ RTC_GUARDED_BY(mutex_);
-  uint32_t counter_ RTC_GUARDED_BY(crit_sect_);
+  uint32_t counter_ RTC_GUARDED_BY(mutex_);
-  rtc::CriticalSection crit_sect_;
+  mutable Mutex mutex_;
  bool used_layers_[kMaxSimulcastStreams];
-  absl::optional<int> qp_ RTC_GUARDED_BY(crit_sect_);
+  absl::optional<int> qp_ RTC_GUARDED_BY(mutex_);
  // Current byte debt to be payed over a number of frames.
  // The debt is acquired by keyframes overshooting the bitrate target.
@ -121,8 +121,8 @@ class FakeH264Encoder : public FakeEncoder {
      EncodedImage* encoded_image,
      CodecSpecificInfo* codec_specific) override;
-  int idr_counter_ RTC_GUARDED_BY(local_crit_sect_);
+  int idr_counter_ RTC_GUARDED_BY(local_mutex_);
-  rtc::CriticalSection local_crit_sect_;
+  Mutex local_mutex_;
 };
 class DelayedEncoder : public test::FakeEncoder {
--- a/test/frame_forwarder.cc
+++ b/test/frame_forwarder.cc
@ -18,14 +18,14 @@ FrameForwarder::FrameForwarder() : sink_(nullptr) {}
 FrameForwarder::~FrameForwarder() {}
 void FrameForwarder::IncomingCapturedFrame(const VideoFrame& video_frame) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (sink_)
    sink_->OnFrame(video_frame);
 }
 void FrameForwarder::AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                                     const rtc::VideoSinkWants& wants) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  AddOrUpdateSinkLocked(sink, wants);
 }
@ -38,13 +38,13 @@ void FrameForwarder::AddOrUpdateSinkLocked(
 }
 void FrameForwarder::RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  RTC_DCHECK_EQ(sink, sink_);
  sink_ = nullptr;
 }
 rtc::VideoSinkWants FrameForwarder::sink_wants() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return sink_wants_;
 }
@ -53,7 +53,7 @@ rtc::VideoSinkWants FrameForwarder::sink_wants_locked() const {
 }
 bool FrameForwarder::has_sinks() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return sink_ != nullptr;
 }
--- a/test/frame_forwarder.h
+++ b/test/frame_forwarder.h
@ -12,7 +12,7 @@
 #include "api/video/video_frame.h"
 #include "api/video/video_source_interface.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 namespace webrtc {
 namespace test {
@ -27,25 +27,25 @@ class FrameForwarder : public rtc::VideoSourceInterface<VideoFrame> {
  ~FrameForwarder() override;
  // Forwards |video_frame| to the registered |sink_|.
  virtual void IncomingCapturedFrame(const VideoFrame& video_frame)
-      RTC_LOCKS_EXCLUDED(crit_);
+      RTC_LOCKS_EXCLUDED(mutex_);
-  rtc::VideoSinkWants sink_wants() const RTC_LOCKS_EXCLUDED(crit_);
+  rtc::VideoSinkWants sink_wants() const RTC_LOCKS_EXCLUDED(mutex_);
-  bool has_sinks() const RTC_LOCKS_EXCLUDED(crit_);
+  bool has_sinks() const RTC_LOCKS_EXCLUDED(mutex_);
 protected:
  rtc::VideoSinkWants sink_wants_locked() const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                       const rtc::VideoSinkWants& wants)
-      RTC_LOCKS_EXCLUDED(crit_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
  void AddOrUpdateSinkLocked(rtc::VideoSinkInterface<VideoFrame>* sink,
                             const rtc::VideoSinkWants& wants)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink)
-      RTC_LOCKS_EXCLUDED(crit_) override;
+      RTC_LOCKS_EXCLUDED(mutex_) override;
-  rtc::CriticalSection crit_;
+  mutable Mutex mutex_;
-  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkInterface<VideoFrame>* sink_ RTC_GUARDED_BY(mutex_);
-  rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkWants sink_wants_ RTC_GUARDED_BY(mutex_);
 };
 }  // namespace test
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@ -128,6 +128,7 @@ rtc_library("video") {
    "../rtc_base/experiments:min_video_bitrate_experiment",
    "../rtc_base/experiments:quality_scaling_experiment",
    "../rtc_base/experiments:rate_control_settings",
    "../rtc_base/synchronization:mutex",
    "../rtc_base/synchronization:sequence_checker",
    "../rtc_base/system:thread_registry",
    "../rtc_base/task_utils:pending_task_safety_flag",
@ -250,6 +251,7 @@ rtc_library("video_stream_encoder_impl") {
    "../rtc_base/experiments:quality_scaler_settings",
    "../rtc_base/experiments:quality_scaling_experiment",
    "../rtc_base/experiments:rate_control_settings",
    "../rtc_base/synchronization:mutex",
    "../rtc_base/synchronization:sequence_checker",
    "../rtc_base/task_utils:repeating_task",
    "../system_wrappers",
@ -326,6 +328,7 @@ if (rtc_include_tests) {
      "../rtc_base:rtc_base_tests_utils",
      "../rtc_base:rtc_numerics",
      "../rtc_base:task_queue_for_test",
      "../rtc_base/synchronization:mutex",
      "../rtc_base/task_utils:repeating_task",
      "../system_wrappers",
      "../test:fake_video_codecs",
--- a/video/call_stats.cc
+++ b/video/call_stats.cc
@ -129,7 +129,7 @@ void CallStats::Process() {
  max_rtt_ms_ = GetMaxRttMs(reports_);
  avg_rtt_ms = GetNewAvgRttMs(reports_, avg_rtt_ms);
  {
-    rtc::CritScope lock(&avg_rtt_ms_lock_);
+    MutexLock lock(&avg_rtt_ms_lock_);
    avg_rtt_ms_ = avg_rtt_ms;
  }
@ -178,7 +178,7 @@ int64_t CallStats::LastProcessedRtt() const {
  // allow only reading this from the process thread (or TQ once we get there)
  // so that the lock isn't necessary.
-  rtc::CritScope cs(&avg_rtt_ms_lock_);
+  MutexLock lock(&avg_rtt_ms_lock_);
  return avg_rtt_ms_;
 }
--- a/video/call_stats.h
+++ b/video/call_stats.h
@ -18,7 +18,7 @@
 #include "modules/include/module_common_types.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_checker.h"
 #include "system_wrappers/include/clock.h"
@ -90,7 +90,7 @@ class CallStats : public Module, public RtcpRttStats {
  int64_t avg_rtt_ms_;
  // Protects |avg_rtt_ms_|.
-  rtc::CriticalSection avg_rtt_ms_lock_;
+  mutable Mutex avg_rtt_ms_lock_;
  // |sum_avg_rtt_ms_|, |num_avg_rtt_| and |time_of_first_rtt_ms_| are only used
  // on the ProcessThread when running. When the Process Thread is not running,
--- a/video/encoder_rtcp_feedback.cc
+++ b/video/encoder_rtcp_feedback.cc
@ -56,7 +56,7 @@ void EncoderRtcpFeedback::OnReceivedIntraFrameRequest(uint32_t ssrc) {
  RTC_DCHECK(HasSsrc(ssrc));
  {
    int64_t now_ms = clock_->TimeInMilliseconds();
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    if (time_last_intra_request_ms_ + min_keyframe_send_interval_ms_ > now_ms) {
      return;
    }
--- a/video/encoder_rtcp_feedback.h
+++ b/video/encoder_rtcp_feedback.h
@ -15,7 +15,7 @@
 #include "api/video/video_stream_encoder_interface.h"
 #include "call/rtp_video_sender_interface.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "system_wrappers/include/clock.h"
 namespace webrtc {
@ -50,8 +50,8 @@ class EncoderRtcpFeedback : public RtcpIntraFrameObserver,
  const RtpVideoSenderInterface* rtp_video_sender_;
  VideoStreamEncoderInterface* const video_stream_encoder_;
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
-  int64_t time_last_intra_request_ms_ RTC_GUARDED_BY(crit_);
+  int64_t time_last_intra_request_ms_ RTC_GUARDED_BY(mutex_);
  const int min_keyframe_send_interval_ms_;
 };
--- a/video/frame_encode_metadata_writer.cc
+++ b/video/frame_encode_metadata_writer.cc
@ -60,7 +60,7 @@ FrameEncodeMetadataWriter::~FrameEncodeMetadataWriter() {}
 void FrameEncodeMetadataWriter::OnEncoderInit(const VideoCodec& codec,
                                              bool internal_source) {
-  rtc::CritScope cs(&lock_);
+  MutexLock lock(&lock_);
  codec_settings_ = codec;
  internal_source_ = internal_source;
 }
@ -68,7 +68,7 @@ void FrameEncodeMetadataWriter::OnEncoderInit(const VideoCodec& codec,
 void FrameEncodeMetadataWriter::OnSetRates(
    const VideoBitrateAllocation& bitrate_allocation,
    uint32_t framerate_fps) {
-  rtc::CritScope cs(&lock_);
+  MutexLock lock(&lock_);
  framerate_fps_ = framerate_fps;
  const size_t num_spatial_layers = NumSpatialLayers();
  if (timing_frames_info_.size() < num_spatial_layers) {
@ -81,7 +81,7 @@ void FrameEncodeMetadataWriter::OnSetRates(
 }
 void FrameEncodeMetadataWriter::OnEncodeStarted(const VideoFrame& frame) {
-  rtc::CritScope cs(&lock_);
+  MutexLock lock(&lock_);
  if (internal_source_) {
    return;
  }
@ -128,7 +128,7 @@ void FrameEncodeMetadataWriter::OnEncodeStarted(const VideoFrame& frame) {
 void FrameEncodeMetadataWriter::FillTimingInfo(size_t simulcast_svc_idx,
                                               EncodedImage* encoded_image) {
-  rtc::CritScope cs(&lock_);
+  MutexLock lock(&lock_);
  absl::optional<size_t> outlier_frame_size;
  absl::optional<int64_t> encode_start_ms;
  uint8_t timing_flags = VideoSendTiming::kNotTriggered;
@ -235,7 +235,7 @@ FrameEncodeMetadataWriter::UpdateBitstream(
 }
 void FrameEncodeMetadataWriter::Reset() {
-  rtc::CritScope cs(&lock_);
+  MutexLock lock(&lock_);
  for (auto& info : timing_frames_info_) {
    info.frames.clear();
  }
--- a/video/frame_encode_metadata_writer.h
+++ b/video/frame_encode_metadata_writer.h
@ -20,7 +20,7 @@
 #include "api/video_codecs/video_codec.h"
 #include "api/video_codecs/video_encoder.h"
 #include "modules/video_coding/include/video_codec_interface.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 namespace webrtc {
@ -69,7 +69,7 @@ class FrameEncodeMetadataWriter {
    std::list<FrameMetadata> frames;
  };
-  rtc::CriticalSection lock_;
+  Mutex lock_;
  EncodedImageCallback* const frame_drop_callback_;
  VideoCodec codec_settings_ RTC_GUARDED_BY(&lock_);
  bool internal_source_ RTC_GUARDED_BY(&lock_);
--- a/video/picture_id_tests.cc
+++ b/video/picture_id_tests.cc
@ -22,6 +22,7 @@
 #include "modules/video_coding/codecs/vp9/include/vp9.h"
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/numerics/sequence_number_util.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/call_test.h"
@ -49,12 +50,12 @@ class PictureIdObserver : public test::RtpRtcpObserver {
        num_ssrcs_to_observe_(1) {}
  void SetExpectedSsrcs(size_t num_expected_ssrcs) {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    num_ssrcs_to_observe_ = num_expected_ssrcs;
  }
  void ResetObservedSsrcs() {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    // Do not clear the timestamp and picture_id, to ensure that we check
    // consistency between reinits and recreations.
    num_packets_sent_.clear();
@ -62,7 +63,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
  }
  void SetMaxExpectedPictureIdGap(int max_expected_picture_id_gap) {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    max_expected_picture_id_gap_ = max_expected_picture_id_gap;
    // Expect smaller gap for |tl0_pic_idx| (running index for temporal_idx 0).
    max_expected_tl0_idx_gap_ = max_expected_picture_id_gap_ / 2;
@ -120,7 +121,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
  // Verify continuity and monotonicity of picture_id sequence.
  void VerifyPictureId(const ParsedPacket& current,
                       const ParsedPacket& last) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(&mutex_) {
    if (current.timestamp == last.timestamp) {
      EXPECT_EQ(last.picture_id, current.picture_id);
      return;  // Same frame.
@ -143,7 +144,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
  }
  void VerifyTl0Idx(const ParsedPacket& current, const ParsedPacket& last) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(&mutex_) {
    if (current.tl0_pic_idx == kNoTl0PicIdx ||
        current.temporal_idx == kNoTemporalIdx) {
      return;  // No temporal layers.
@ -169,7 +170,7 @@ class PictureIdObserver : public test::RtpRtcpObserver {
  }
  Action OnSendRtp(const uint8_t* packet, size_t length) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    ParsedPacket parsed;
    if (!ParsePayload(packet, length, &parsed))
@ -196,14 +197,14 @@ class PictureIdObserver : public test::RtpRtcpObserver {
    return SEND_PACKET;
  }
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
  const std::unique_ptr<VideoRtpDepacketizer> depacketizer_;
-  std::map<uint32_t, ParsedPacket> last_observed_packet_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, ParsedPacket> last_observed_packet_ RTC_GUARDED_BY(mutex_);
-  std::map<uint32_t, size_t> num_packets_sent_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, size_t> num_packets_sent_ RTC_GUARDED_BY(mutex_);
-  int max_expected_picture_id_gap_ RTC_GUARDED_BY(crit_);
+  int max_expected_picture_id_gap_ RTC_GUARDED_BY(mutex_);
-  int max_expected_tl0_idx_gap_ RTC_GUARDED_BY(crit_);
+  int max_expected_tl0_idx_gap_ RTC_GUARDED_BY(mutex_);
-  size_t num_ssrcs_to_observe_ RTC_GUARDED_BY(crit_);
+  size_t num_ssrcs_to_observe_ RTC_GUARDED_BY(mutex_);
-  std::set<uint32_t> observed_ssrcs_ RTC_GUARDED_BY(crit_);
+  std::set<uint32_t> observed_ssrcs_ RTC_GUARDED_BY(mutex_);
 };
 class PictureIdTest : public test::CallTest,
--- a/video/receive_statistics_proxy.cc
+++ b/video/receive_statistics_proxy.cc
@ -133,7 +133,7 @@ void ReceiveStatisticsProxy::UpdateHistograms(
  // earlier.
  RTC_DCHECK_RUN_ON(&decode_thread_);
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  char log_stream_buf[8 * 1024];
  rtc::SimpleStringBuilder log_stream(log_stream_buf);
@ -623,7 +623,7 @@ ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
 }
 VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  // Get current frame rates here, as only updating them on new frames prevents
  // us from ever correctly displaying frame rate of 0.
  int64_t now_ms = clock_->TimeInMilliseconds();
@ -654,13 +654,13 @@ VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
 }
 void ReceiveStatisticsProxy::OnIncomingPayloadType(int payload_type) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  stats_.current_payload_type = payload_type;
 }
 void ReceiveStatisticsProxy::OnDecoderImplementationName(
    const char* implementation_name) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  stats_.decoder_implementation_name = implementation_name;
 }
@ -671,7 +671,7 @@ void ReceiveStatisticsProxy::OnFrameBufferTimingsUpdated(
    int jitter_buffer_ms,
    int min_playout_delay_ms,
    int render_delay_ms) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  stats_.max_decode_ms = max_decode_ms;
  stats_.current_delay_ms = current_delay_ms;
  stats_.target_delay_ms = target_delay_ms;
@ -687,13 +687,13 @@ void ReceiveStatisticsProxy::OnFrameBufferTimingsUpdated(
 }
 void ReceiveStatisticsProxy::OnUniqueFramesCounted(int num_unique_frames) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  num_unique_frames_.emplace(num_unique_frames);
 }
 void ReceiveStatisticsProxy::OnTimingFrameInfoUpdated(
    const TimingFrameInfo& info) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (info.flags != VideoSendTiming::kInvalid) {
    int64_t now_ms = clock_->TimeInMilliseconds();
    timing_frame_info_counter_.Add(info, now_ms);
@ -714,14 +714,14 @@ void ReceiveStatisticsProxy::OnTimingFrameInfoUpdated(
 void ReceiveStatisticsProxy::RtcpPacketTypesCounterUpdated(
    uint32_t ssrc,
    const RtcpPacketTypeCounter& packet_counter) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (stats_.ssrc != ssrc)
    return;
  stats_.rtcp_packet_type_counts = packet_counter;
 }
 void ReceiveStatisticsProxy::OnCname(uint32_t ssrc, absl::string_view cname) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  // TODO(pbos): Handle both local and remote ssrcs here and RTC_DCHECK that we
  // receive stats from one of them.
  if (stats_.ssrc != ssrc)
@ -733,7 +733,7 @@ void ReceiveStatisticsProxy::OnDecodedFrame(const VideoFrame& frame,
                                            absl::optional<uint8_t> qp,
                                            int32_t decode_time_ms,
                                            VideoContentType content_type) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  uint64_t now_ms = clock_->TimeInMilliseconds();
@ -799,7 +799,7 @@ void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) {
  RTC_DCHECK_GT(width, 0);
  RTC_DCHECK_GT(height, 0);
  int64_t now_ms = clock_->TimeInMilliseconds();
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  video_quality_observer_->OnRenderedFrame(frame, now_ms);
@ -833,7 +833,7 @@ void ReceiveStatisticsProxy::OnRenderedFrame(const VideoFrame& frame) {
 void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t video_playout_ntp_ms,
                                                 int64_t sync_offset_ms,
                                                 double estimated_freq_khz) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  sync_offset_counter_.Add(std::abs(sync_offset_ms));
  stats_.sync_offset_ms = sync_offset_ms;
  last_estimated_playout_ntp_timestamp_ms_ = video_playout_ntp_ms;
@ -851,7 +851,7 @@ void ReceiveStatisticsProxy::OnSyncOffsetUpdated(int64_t video_playout_ntp_ms,
 void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
                                             size_t size_bytes,
                                             VideoContentType content_type) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (is_keyframe) {
    ++stats_.frame_counts.key_frames;
  } else {
@ -881,13 +881,13 @@ void ReceiveStatisticsProxy::OnCompleteFrame(bool is_keyframe,
 }
 void ReceiveStatisticsProxy::OnDroppedFrames(uint32_t frames_dropped) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  stats_.frames_dropped += frames_dropped;
 }
 void ReceiveStatisticsProxy::OnPreDecode(VideoCodecType codec_type, int qp) {
  RTC_DCHECK_RUN_ON(&decode_thread_);
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  last_codec_type_ = codec_type;
  if (last_codec_type_ == kVideoCodecVP8 && qp != -1) {
    qp_counters_.vp8.Add(qp);
@ -898,7 +898,7 @@ void ReceiveStatisticsProxy::OnPreDecode(VideoCodecType codec_type, int qp) {
 void ReceiveStatisticsProxy::OnStreamInactive() {
  // TODO(sprang): Figure out any other state that should be reset.
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  // Don't report inter-frame delay if stream was paused.
  last_decoded_frame_time_ms_.reset();
  video_quality_observer_->OnStreamInactive();
@ -906,7 +906,7 @@ void ReceiveStatisticsProxy::OnStreamInactive() {
 void ReceiveStatisticsProxy::OnRttUpdate(int64_t avg_rtt_ms,
                                         int64_t max_rtt_ms) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  avg_rtt_ms_ = avg_rtt_ms;
 }
--- a/video/receive_statistics_proxy.h
+++ b/video/receive_statistics_proxy.h
@ -20,12 +20,12 @@
 #include "call/video_receive_stream.h"
 #include "modules/include/module_common_types.h"
 #include "modules/video_coding/include/video_coding_defines.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/numerics/histogram_percentile_counter.h"
 #include "rtc_base/numerics/moving_max_counter.h"
 #include "rtc_base/numerics/sample_counter.h"
 #include "rtc_base/rate_statistics.h"
 #include "rtc_base/rate_tracker.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/thread_checker.h"
 #include "video/quality_threshold.h"
@ -124,19 +124,19 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
    rtc::HistogramPercentileCounter interframe_delay_percentiles;
  };
-  void QualitySample() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void QualitySample() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  // Removes info about old frames and then updates the framerate.
  void UpdateFramerate(int64_t now_ms) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void UpdateDecodeTimeHistograms(int width,
                                  int height,
                                  int decode_time_ms) const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  absl::optional<int64_t> GetCurrentEstimatedPlayoutNtpTimestampMs(
-      int64_t now_ms) const RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      int64_t now_ms) const RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  Clock* const clock_;
  // Ownership of this object lies with the owner of the ReceiveStatisticsProxy
@ -150,52 +150,52 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
  const int64_t start_ms_;
  const bool enable_decode_time_histograms_;
-  rtc::CriticalSection crit_;
+  mutable Mutex mutex_;
-  int64_t last_sample_time_ RTC_GUARDED_BY(crit_);
+  int64_t last_sample_time_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold fps_threshold_ RTC_GUARDED_BY(crit_);
+  QualityThreshold fps_threshold_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold qp_threshold_ RTC_GUARDED_BY(crit_);
+  QualityThreshold qp_threshold_ RTC_GUARDED_BY(mutex_);
-  QualityThreshold variance_threshold_ RTC_GUARDED_BY(crit_);
+  QualityThreshold variance_threshold_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter qp_sample_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter qp_sample_ RTC_GUARDED_BY(mutex_);
-  int num_bad_states_ RTC_GUARDED_BY(crit_);
+  int num_bad_states_ RTC_GUARDED_BY(mutex_);
-  int num_certain_states_ RTC_GUARDED_BY(crit_);
+  int num_certain_states_ RTC_GUARDED_BY(mutex_);
  // Note: The |stats_.rtp_stats| member is not used or populated by this class.
-  mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(crit_);
+  mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(mutex_);
-  RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(crit_);
+  RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(mutex_);
-  RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(crit_);
+  RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter sync_offset_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter sync_offset_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter decode_time_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter decode_time_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter jitter_buffer_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter target_delay_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter target_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter current_delay_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter current_delay_counter_ RTC_GUARDED_BY(mutex_);
-  rtc::SampleCounter delay_counter_ RTC_GUARDED_BY(crit_);
+  rtc::SampleCounter delay_counter_ RTC_GUARDED_BY(mutex_);
  std::unique_ptr<VideoQualityObserver> video_quality_observer_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
  mutable rtc::MovingMaxCounter<int> interframe_delay_max_moving_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
  std::map<VideoContentType, ContentSpecificStats> content_specific_stats_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
-  MaxCounter freq_offset_counter_ RTC_GUARDED_BY(crit_);
+  MaxCounter freq_offset_counter_ RTC_GUARDED_BY(mutex_);
  QpCounters qp_counters_ RTC_GUARDED_BY(decode_thread_);
-  int64_t avg_rtt_ms_ RTC_GUARDED_BY(crit_);
+  int64_t avg_rtt_ms_ RTC_GUARDED_BY(mutex_);
-  mutable std::map<int64_t, size_t> frame_window_ RTC_GUARDED_BY(&crit_);
+  mutable std::map<int64_t, size_t> frame_window_ RTC_GUARDED_BY(&mutex_);
-  VideoContentType last_content_type_ RTC_GUARDED_BY(&crit_);
+  VideoContentType last_content_type_ RTC_GUARDED_BY(&mutex_);
-  VideoCodecType last_codec_type_ RTC_GUARDED_BY(&crit_);
+  VideoCodecType last_codec_type_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> first_frame_received_time_ms_ RTC_GUARDED_BY(&crit_);
+  absl::optional<int64_t> first_frame_received_time_ms_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> first_decoded_frame_time_ms_ RTC_GUARDED_BY(&crit_);
+  absl::optional<int64_t> first_decoded_frame_time_ms_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<int64_t> last_decoded_frame_time_ms_ RTC_GUARDED_BY(&crit_);
+  absl::optional<int64_t> last_decoded_frame_time_ms_ RTC_GUARDED_BY(&mutex_);
-  size_t num_delayed_frames_rendered_ RTC_GUARDED_BY(&crit_);
+  size_t num_delayed_frames_rendered_ RTC_GUARDED_BY(&mutex_);
-  int64_t sum_missed_render_deadline_ms_ RTC_GUARDED_BY(&crit_);
+  int64_t sum_missed_render_deadline_ms_ RTC_GUARDED_BY(&mutex_);
  // Mutable because calling Max() on MovingMaxCounter is not const. Yet it is
  // called from const GetStats().
  mutable rtc::MovingMaxCounter<TimingFrameInfo> timing_frame_info_counter_
-      RTC_GUARDED_BY(&crit_);
+      RTC_GUARDED_BY(&mutex_);
-  absl::optional<int> num_unique_frames_ RTC_GUARDED_BY(crit_);
+  absl::optional<int> num_unique_frames_ RTC_GUARDED_BY(mutex_);
  absl::optional<int64_t> last_estimated_playout_ntp_timestamp_ms_
-      RTC_GUARDED_BY(&crit_);
+      RTC_GUARDED_BY(&mutex_);
  absl::optional<int64_t> last_estimated_playout_time_ms_
-      RTC_GUARDED_BY(&crit_);
+      RTC_GUARDED_BY(&mutex_);
  rtc::ThreadChecker decode_thread_;
  rtc::ThreadChecker network_thread_;
  rtc::ThreadChecker main_thread_;
--- a/video/rtp_streams_synchronizer.cc
+++ b/video/rtp_streams_synchronizer.cc
@ -51,7 +51,7 @@ RtpStreamsSynchronizer::RtpStreamsSynchronizer(Syncable* syncable_video)
 RtpStreamsSynchronizer::~RtpStreamsSynchronizer() = default;
 void RtpStreamsSynchronizer::ConfigureSync(Syncable* syncable_audio) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (syncable_audio == syncable_audio_) {
    // This prevents expensive no-ops.
    return;
@ -76,7 +76,7 @@ void RtpStreamsSynchronizer::Process() {
  RTC_DCHECK_RUN_ON(&process_thread_checker_);
  last_sync_time_ = rtc::TimeNanos();
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (!syncable_audio_) {
    return;
  }
@ -157,7 +157,7 @@ bool RtpStreamsSynchronizer::GetStreamSyncOffsetInMs(
    int64_t* video_playout_ntp_ms,
    int64_t* stream_offset_ms,
    double* estimated_freq_khz) const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (!syncable_audio_) {
    return false;
  }
--- a/video/rtp_streams_synchronizer.h
+++ b/video/rtp_streams_synchronizer.h
@ -17,7 +17,7 @@
 #include <memory>
 #include "modules/include/module.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_checker.h"
 #include "video/stream_synchronization.h"
@ -51,11 +51,11 @@ class RtpStreamsSynchronizer : public Module {
 private:
  Syncable* syncable_video_;
-  rtc::CriticalSection crit_;
+  mutable Mutex mutex_;
-  Syncable* syncable_audio_ RTC_GUARDED_BY(crit_);
+  Syncable* syncable_audio_ RTC_GUARDED_BY(mutex_);
-  std::unique_ptr<StreamSynchronization> sync_ RTC_GUARDED_BY(crit_);
+  std::unique_ptr<StreamSynchronization> sync_ RTC_GUARDED_BY(mutex_);
-  StreamSynchronization::Measurements audio_measurement_ RTC_GUARDED_BY(crit_);
+  StreamSynchronization::Measurements audio_measurement_ RTC_GUARDED_BY(mutex_);
-  StreamSynchronization::Measurements video_measurement_ RTC_GUARDED_BY(crit_);
+  StreamSynchronization::Measurements video_measurement_ RTC_GUARDED_BY(mutex_);
  rtc::ThreadChecker process_thread_checker_;
  int64_t last_sync_time_ RTC_GUARDED_BY(&process_thread_checker_);
--- a/video/rtp_video_stream_receiver.cc
+++ b/video/rtp_video_stream_receiver.cc
@ -121,7 +121,7 @@ RtpVideoStreamReceiver::RtcpFeedbackBuffer::RtcpFeedbackBuffer(
 }
 void RtpVideoStreamReceiver::RtcpFeedbackBuffer::RequestKeyFrame() {
-  rtc::CritScope lock(&cs_);
+  MutexLock lock(&mutex_);
  request_key_frame_ = true;
 }
@ -129,7 +129,7 @@ void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendNack(
    const std::vector<uint16_t>& sequence_numbers,
    bool buffering_allowed) {
  RTC_DCHECK(!sequence_numbers.empty());
-  rtc::CritScope lock(&cs_);
+  MutexLock lock(&mutex_);
  nack_sequence_numbers_.insert(nack_sequence_numbers_.end(),
                                sequence_numbers.cbegin(),
                                sequence_numbers.cend());
@ -146,7 +146,7 @@ void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendLossNotification(
    bool decodability_flag,
    bool buffering_allowed) {
  RTC_DCHECK(buffering_allowed);
-  rtc::CritScope lock(&cs_);
+  MutexLock lock(&mutex_);
  RTC_DCHECK(!lntf_state_)
      << "SendLossNotification() called twice in a row with no call to "
         "SendBufferedRtcpFeedback() in between.";
@ -160,7 +160,7 @@ void RtpVideoStreamReceiver::RtcpFeedbackBuffer::SendBufferedRtcpFeedback() {
 RtpVideoStreamReceiver::RtcpFeedbackBuffer::ConsumedRtcpFeedback
 RtpVideoStreamReceiver::RtcpFeedbackBuffer::ConsumeRtcpFeedback() {
-  rtc::CritScope lock(&cs_);
+  MutexLock lock(&mutex_);
  return ConsumeRtcpFeedbackLocked();
 }
@ -376,7 +376,7 @@ absl::optional<Syncable::Info> RtpVideoStreamReceiver::GetSyncInfo() const {
    return absl::nullopt;
  }
  {
-    rtc::CritScope lock(&sync_info_lock_);
+    MutexLock lock(&sync_info_lock_);
    if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
      return absl::nullopt;
    }
@ -667,7 +667,7 @@ void RtpVideoStreamReceiver::OnRtpPacket(const RtpPacketReceived& packet) {
    // TODO(nisse): Exclude out-of-order packets?
    int64_t now_ms = clock_->TimeInMilliseconds();
    {
-      rtc::CritScope cs(&sync_info_lock_);
+      MutexLock lock(&sync_info_lock_);
      last_received_rtp_timestamp_ = packet.Timestamp();
      last_received_rtp_system_time_ms_ = now_ms;
    }
@ -844,7 +844,7 @@ void RtpVideoStreamReceiver::OnAssembledFrame(
    has_received_frame_ = true;
  }
-  rtc::CritScope lock(&reference_finder_lock_);
+  MutexLock lock(&reference_finder_lock_);
  // Reset |reference_finder_| if |frame| is new and the codec have changed.
  if (current_codec_) {
    bool frame_is_newer =
@ -887,7 +887,7 @@ void RtpVideoStreamReceiver::OnAssembledFrame(
 void RtpVideoStreamReceiver::OnCompleteFrame(
    std::unique_ptr<video_coding::EncodedFrame> frame) {
  {
-    rtc::CritScope lock(&last_seq_num_cs_);
+    MutexLock lock(&last_seq_num_mutex_);
    video_coding::RtpFrameObject* rtp_frame =
        static_cast<video_coding::RtpFrameObject*>(frame.get());
    last_seq_num_for_pic_id_[rtp_frame->id.picture_id] =
@ -900,7 +900,7 @@ void RtpVideoStreamReceiver::OnCompleteFrame(
 void RtpVideoStreamReceiver::OnDecryptedFrame(
    std::unique_ptr<video_coding::RtpFrameObject> frame) {
-  rtc::CritScope lock(&reference_finder_lock_);
+  MutexLock lock(&reference_finder_lock_);
  reference_finder_->ManageFrame(std::move(frame));
 }
@ -967,7 +967,7 @@ void RtpVideoStreamReceiver::RemoveSecondarySink(
 void RtpVideoStreamReceiver::ManageFrame(
    std::unique_ptr<video_coding::RtpFrameObject> frame) {
-  rtc::CritScope lock(&reference_finder_lock_);
+  MutexLock lock(&reference_finder_lock_);
  reference_finder_->ManageFrame(std::move(frame));
 }
@ -1022,7 +1022,7 @@ void RtpVideoStreamReceiver::ParseAndHandleEncapsulatingHeader(
 // correctly calculate frame references.
 void RtpVideoStreamReceiver::NotifyReceiverOfEmptyPacket(uint16_t seq_num) {
  {
-    rtc::CritScope lock(&reference_finder_lock_);
+    MutexLock lock(&reference_finder_lock_);
    reference_finder_->PaddingReceived(seq_num);
  }
  OnInsertedPacket(packet_buffer_.InsertPadding(seq_num));
@ -1086,7 +1086,7 @@ void RtpVideoStreamReceiver::FrameContinuous(int64_t picture_id) {
  int seq_num = -1;
  {
-    rtc::CritScope lock(&last_seq_num_cs_);
+    MutexLock lock(&last_seq_num_mutex_);
    auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
    if (seq_num_it != last_seq_num_for_pic_id_.end())
      seq_num = seq_num_it->second;
@ -1098,7 +1098,7 @@ void RtpVideoStreamReceiver::FrameContinuous(int64_t picture_id) {
 void RtpVideoStreamReceiver::FrameDecoded(int64_t picture_id) {
  int seq_num = -1;
  {
-    rtc::CritScope lock(&last_seq_num_cs_);
+    MutexLock lock(&last_seq_num_mutex_);
    auto seq_num_it = last_seq_num_for_pic_id_.find(picture_id);
    if (seq_num_it != last_seq_num_for_pic_id_.end()) {
      seq_num = seq_num_it->second;
@ -1108,7 +1108,7 @@ void RtpVideoStreamReceiver::FrameDecoded(int64_t picture_id) {
  }
  if (seq_num != -1) {
    packet_buffer_.ClearTo(seq_num);
-    rtc::CritScope lock(&reference_finder_lock_);
+    MutexLock lock(&reference_finder_lock_);
    reference_finder_->ClearTo(seq_num);
  }
 }
--- a/video/rtp_video_stream_receiver.h
+++ b/video/rtp_video_stream_receiver.h
@ -42,9 +42,9 @@
 #include "modules/video_coding/rtp_frame_reference_finder.h"
 #include "modules/video_coding/unique_timestamp_counter.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/numerics/sequence_number_util.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/thread_checker.h"
@ -228,21 +228,21 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
    ~RtcpFeedbackBuffer() override = default;
    // KeyFrameRequestSender implementation.
-    void RequestKeyFrame() RTC_LOCKS_EXCLUDED(cs_) override;
+    void RequestKeyFrame() RTC_LOCKS_EXCLUDED(mutex_) override;
    // NackSender implementation.
    void SendNack(const std::vector<uint16_t>& sequence_numbers,
-                  bool buffering_allowed) RTC_LOCKS_EXCLUDED(cs_) override;
+                  bool buffering_allowed) RTC_LOCKS_EXCLUDED(mutex_) override;
    // LossNotificationSender implementation.
    void SendLossNotification(uint16_t last_decoded_seq_num,
                              uint16_t last_received_seq_num,
                              bool decodability_flag,
                              bool buffering_allowed)
-        RTC_LOCKS_EXCLUDED(cs_) override;
+        RTC_LOCKS_EXCLUDED(mutex_) override;
    // Send all RTCP feedback messages buffered thus far.
-    void SendBufferedRtcpFeedback() RTC_LOCKS_EXCLUDED(cs_);
+    void SendBufferedRtcpFeedback() RTC_LOCKS_EXCLUDED(mutex_);
   private:
    // LNTF-related state.
@ -264,10 +264,10 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
      absl::optional<LossNotificationState> lntf_state;
    };
-    ConsumedRtcpFeedback ConsumeRtcpFeedback() RTC_LOCKS_EXCLUDED(cs_);
+    ConsumedRtcpFeedback ConsumeRtcpFeedback() RTC_LOCKS_EXCLUDED(mutex_);
    ConsumedRtcpFeedback ConsumeRtcpFeedbackLocked()
-        RTC_EXCLUSIVE_LOCKS_REQUIRED(cs_);
+        RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-    // This method is called both with and without cs_ held.
+    // This method is called both with and without mutex_ held.
    void SendRtcpFeedback(ConsumedRtcpFeedback feedback);
    KeyFrameRequestSender* const key_frame_request_sender_;
@ -275,15 +275,15 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
    LossNotificationSender* const loss_notification_sender_;
    // NACKs are accessible from two threads due to nack_module_ being a module.
-    rtc::CriticalSection cs_;
+    Mutex mutex_;
    // Key-frame-request-related state.
-    bool request_key_frame_ RTC_GUARDED_BY(cs_);
+    bool request_key_frame_ RTC_GUARDED_BY(mutex_);
    // NACK-related state.
-    std::vector<uint16_t> nack_sequence_numbers_ RTC_GUARDED_BY(cs_);
+    std::vector<uint16_t> nack_sequence_numbers_ RTC_GUARDED_BY(mutex_);
-    absl::optional<LossNotificationState> lntf_state_ RTC_GUARDED_BY(cs_);
+    absl::optional<LossNotificationState> lntf_state_ RTC_GUARDED_BY(mutex_);
  };
  enum ParseGenericDependenciesResult {
    kDropPacket,
@ -351,15 +351,15 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
  absl::optional<int64_t> video_structure_frame_id_
      RTC_GUARDED_BY(worker_task_checker_);
-  rtc::CriticalSection reference_finder_lock_;
+  Mutex reference_finder_lock_;
  std::unique_ptr<video_coding::RtpFrameReferenceFinder> reference_finder_
      RTC_GUARDED_BY(reference_finder_lock_);
  absl::optional<VideoCodecType> current_codec_;
  uint32_t last_assembled_frame_rtp_timestamp_;
-  rtc::CriticalSection last_seq_num_cs_;
+  Mutex last_seq_num_mutex_;
  std::map<int64_t, uint16_t> last_seq_num_for_pic_id_
-      RTC_GUARDED_BY(last_seq_num_cs_);
+      RTC_GUARDED_BY(last_seq_num_mutex_);
  video_coding::H264SpsPpsTracker tracker_;
  // Maps payload id to the depacketizer.
@ -378,7 +378,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
  // Info for GetSyncInfo is updated on network or worker thread, and queried on
  // the worker thread.
-  rtc::CriticalSection sync_info_lock_;
+  mutable Mutex sync_info_lock_;
  absl::optional<uint32_t> last_received_rtp_timestamp_
      RTC_GUARDED_BY(sync_info_lock_);
  absl::optional<int64_t> last_received_rtp_system_time_ms_
--- a/video/send_delay_stats.cc
+++ b/video/send_delay_stats.cc
@ -41,7 +41,7 @@ SendDelayStats::~SendDelayStats() {
 }
 void SendDelayStats::UpdateHistograms() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  for (const auto& it : send_delay_counters_) {
    AggregatedStats stats = it.second->GetStats();
    if (stats.num_samples >= kMinRequiredPeriodicSamples) {
@ -52,7 +52,7 @@ void SendDelayStats::UpdateHistograms() {
 }
 void SendDelayStats::AddSsrcs(const VideoSendStream::Config& config) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (ssrcs_.size() > kMaxSsrcMapSize)
    return;
  for (const auto& ssrc : config.rtp.ssrcs)
@ -73,7 +73,7 @@ void SendDelayStats::OnSendPacket(uint16_t packet_id,
                                  int64_t capture_time_ms,
                                  uint32_t ssrc) {
  // Packet sent to transport.
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (ssrcs_.find(ssrc) == ssrcs_.end())
    return;
@ -93,7 +93,7 @@ bool SendDelayStats::OnSentPacket(int packet_id, int64_t time_ms) {
  if (packet_id == -1)
    return false;
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  auto it = packets_.find(packet_id);
  if (it == packets_.end())
    return false;
--- a/video/send_delay_stats.h
+++ b/video/send_delay_stats.h
@ -20,7 +20,7 @@
 #include "call/video_send_stream.h"
 #include "modules/include/module_common_types_public.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/clock.h"
 #include "video/stats_counter.h"
@ -66,22 +66,22 @@ class SendDelayStats : public SendPacketObserver {
  void UpdateHistograms();
  void RemoveOld(int64_t now, PacketMap* packets)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  AvgCounter* GetSendDelayCounter(uint32_t ssrc)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  Clock* const clock_;
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
-  PacketMap packets_ RTC_GUARDED_BY(crit_);
+  PacketMap packets_ RTC_GUARDED_BY(mutex_);
-  size_t num_old_packets_ RTC_GUARDED_BY(crit_);
+  size_t num_old_packets_ RTC_GUARDED_BY(mutex_);
-  size_t num_skipped_packets_ RTC_GUARDED_BY(crit_);
+  size_t num_skipped_packets_ RTC_GUARDED_BY(mutex_);
-  std::set<uint32_t> ssrcs_ RTC_GUARDED_BY(crit_);
+  std::set<uint32_t> ssrcs_ RTC_GUARDED_BY(mutex_);
  // Mapped by SSRC.
  std::map<uint32_t, std::unique_ptr<AvgCounter>> send_delay_counters_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
 };
 }  // namespace webrtc
--- a/video/send_statistics_proxy.cc
+++ b/video/send_statistics_proxy.cc
@ -154,7 +154,7 @@ SendStatisticsProxy::SendStatisticsProxy(
 }
 SendStatisticsProxy::~SendStatisticsProxy() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  uma_container_->UpdateHistograms(rtp_config_, stats_);
  int64_t elapsed_sec = (clock_->TimeInMilliseconds() - start_ms_) / 1000;
@ -670,7 +670,7 @@ void SendStatisticsProxy::UmaSamplesContainer::UpdateHistograms(
 void SendStatisticsProxy::OnEncoderReconfigured(
    const VideoEncoderConfig& config,
    const std::vector<VideoStream>& streams) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (content_type_ != config.content_type) {
    uma_container_->UpdateHistograms(rtp_config_, stats_);
@ -687,7 +687,7 @@ void SendStatisticsProxy::OnEncoderReconfigured(
 void SendStatisticsProxy::OnEncodedFrameTimeMeasured(int encode_time_ms,
                                                     int encode_usage_percent) {
  RTC_DCHECK_GE(encode_time_ms, 0);
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  uma_container_->encode_time_counter_.Add(encode_time_ms);
  encode_time_.Apply(1.0f, encode_time_ms);
  stats_.avg_encode_time_ms = std::round(encode_time_.filtered());
@ -697,7 +697,7 @@ void SendStatisticsProxy::OnEncodedFrameTimeMeasured(int encode_time_ms,
 void SendStatisticsProxy::OnSuspendChange(bool is_suspended) {
  int64_t now_ms = clock_->TimeInMilliseconds();
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  stats_.suspended = is_suspended;
  if (is_suspended) {
    // Pause framerate (add min pause time since there may be frames/packets
@ -733,7 +733,7 @@ void SendStatisticsProxy::OnSuspendChange(bool is_suspended) {
 }
 VideoSendStream::Stats SendStatisticsProxy::GetStats() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  PurgeOldStats();
  stats_.input_frame_rate =
      round(uma_container_->input_frame_rate_tracker_.ComputeRate());
@ -803,7 +803,7 @@ VideoSendStream::StreamStats* SendStatisticsProxy::GetStatsEntry(
 }
 void SendStatisticsProxy::OnInactiveSsrc(uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
@ -815,7 +815,7 @@ void SendStatisticsProxy::OnInactiveSsrc(uint32_t ssrc) {
 }
 void SendStatisticsProxy::OnSetEncoderTargetRate(uint32_t bitrate_bps) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (uma_container_->target_rate_updates_.last_ms == -1 && bitrate_bps == 0)
    return;  // Start on first non-zero bitrate, may initially be zero.
@ -914,7 +914,7 @@ void SendStatisticsProxy::UpdateFallbackDisabledStats(
 }
 void SendStatisticsProxy::OnMinPixelLimitReached() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  uma_container_->fallback_info_disabled_.min_pixel_limit_reached = true;
 }
@ -929,7 +929,7 @@ void SendStatisticsProxy::OnSendEncodedImage(
          ? encoded_image.SpatialIndex().value_or(0)
          : 0;
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  ++stats_.frames_encoded;
  // The current encode frame rate is based on previously encoded frames.
  double encode_frame_rate = encoded_frame_rate_tracker_.ComputeRate();
@ -1036,24 +1036,24 @@ void SendStatisticsProxy::OnSendEncodedImage(
 void SendStatisticsProxy::OnEncoderImplementationChanged(
    const std::string& implementation_name) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  encoder_changed_ = EncoderChangeEvent{stats_.encoder_implementation_name,
                                        implementation_name};
  stats_.encoder_implementation_name = implementation_name;
 }
 int SendStatisticsProxy::GetInputFrameRate() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return round(uma_container_->input_frame_rate_tracker_.ComputeRate());
 }
 int SendStatisticsProxy::GetSendFrameRate() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return round(encoded_frame_rate_tracker_.ComputeRate());
 }
 void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  uma_container_->input_frame_rate_tracker_.AddSamples(1);
  uma_container_->input_fps_counter_.Add(1);
  uma_container_->input_width_counter_.Add(width);
@ -1071,7 +1071,7 @@ void SendStatisticsProxy::OnIncomingFrame(int width, int height) {
 }
 void SendStatisticsProxy::OnFrameDropped(DropReason reason) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  switch (reason) {
    case DropReason::kSource:
      ++stats_.frames_dropped_by_capturer;
@ -1092,7 +1092,7 @@ void SendStatisticsProxy::OnFrameDropped(DropReason reason) {
 }
 void SendStatisticsProxy::ClearAdaptationStats() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  adaptation_limitations_.set_cpu_counts(VideoAdaptationCounters());
  adaptation_limitations_.set_quality_counts(VideoAdaptationCounters());
  UpdateAdaptationStats();
@ -1101,7 +1101,7 @@ void SendStatisticsProxy::ClearAdaptationStats() {
 void SendStatisticsProxy::UpdateAdaptationSettings(
    VideoStreamEncoderObserver::AdaptationSettings cpu_settings,
    VideoStreamEncoderObserver::AdaptationSettings quality_settings) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  adaptation_limitations_.UpdateMaskingSettings(cpu_settings, quality_settings);
  SetAdaptTimer(adaptation_limitations_.MaskedCpuCounts(),
                &uma_container_->cpu_adapt_timer_);
@ -1114,7 +1114,7 @@ void SendStatisticsProxy::OnAdaptationChanged(
    VideoAdaptationReason reason,
    const VideoAdaptationCounters& cpu_counters,
    const VideoAdaptationCounters& quality_counters) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  MaskedAdaptationCounts receiver =
      adaptation_limitations_.MaskedQualityCounts();
@ -1208,7 +1208,7 @@ void SendStatisticsProxy::OnBitrateAllocationUpdated(
    spatial_layers[i] = (allocation.GetSpatialLayerSum(i) > 0);
  }
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  bw_limited_layers_ = allocation.is_bw_limited();
  UpdateAdaptationStats();
@ -1231,14 +1231,14 @@ void SendStatisticsProxy::OnBitrateAllocationUpdated(
 // resolution or not. |is_scaled| is a flag indicating if the video is scaled
 // down.
 void SendStatisticsProxy::OnEncoderInternalScalerUpdate(bool is_scaled) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  internal_encoder_scaler_ = is_scaled;
  UpdateAdaptationStats();
 }
 // TODO(asapersson): Include fps changes.
 void SendStatisticsProxy::OnInitialQualityResolutionAdaptDown() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  ++uma_container_->initial_quality_changes_.down;
 }
@ -1274,7 +1274,7 @@ void SendStatisticsProxy::SetAdaptTimer(const MaskedAdaptationCounts& counts,
 void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
    uint32_t ssrc,
    const RtcpPacketTypeCounter& packet_counter) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
@ -1286,7 +1286,7 @@ void SendStatisticsProxy::RtcpPacketTypesCounterUpdated(
 void SendStatisticsProxy::StatisticsUpdated(const RtcpStatistics& statistics,
                                            uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
@ -1297,7 +1297,7 @@ void SendStatisticsProxy::StatisticsUpdated(const RtcpStatistics& statistics,
 void SendStatisticsProxy::OnReportBlockDataUpdated(
    ReportBlockData report_block_data) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats =
      GetStatsEntry(report_block_data.report_block().source_ssrc);
  if (!stats)
@ -1308,7 +1308,7 @@ void SendStatisticsProxy::OnReportBlockDataUpdated(
 void SendStatisticsProxy::DataCountersUpdated(
    const StreamDataCounters& counters,
    uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  RTC_DCHECK(stats) << "DataCountersUpdated reported for unknown ssrc " << ssrc;
@ -1350,7 +1350,7 @@ void SendStatisticsProxy::DataCountersUpdated(
 void SendStatisticsProxy::Notify(uint32_t total_bitrate_bps,
                                 uint32_t retransmit_bitrate_bps,
                                 uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
@ -1361,7 +1361,7 @@ void SendStatisticsProxy::Notify(uint32_t total_bitrate_bps,
 void SendStatisticsProxy::FrameCountUpdated(const FrameCounts& frame_counts,
                                            uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
@ -1373,7 +1373,7 @@ void SendStatisticsProxy::SendSideDelayUpdated(int avg_delay_ms,
                                               int max_delay_ms,
                                               uint64_t total_delay_ms,
                                               uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  VideoSendStream::StreamStats* stats = GetStatsEntry(ssrc);
  if (!stats)
    return;
--- a/video/send_statistics_proxy.h
+++ b/video/send_statistics_proxy.h
@ -25,9 +25,9 @@
 #include "modules/rtp_rtcp/include/report_block_data.h"
 #include "modules/video_coding/include/video_codec_interface.h"
 #include "modules/video_coding/include/video_coding_defines.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/numerics/exp_filter.h"
 #include "rtc_base/rate_tracker.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/clock.h"
 #include "video/quality_limitation_reason_tracker.h"
@ -223,9 +223,9 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
  };
  typedef std::map<uint32_t, Frame, TimestampOlderThan> EncodedFrameMap;
-  void PurgeOldStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void PurgeOldStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  VideoSendStream::StreamStats* GetStatsEntry(uint32_t ssrc)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  struct MaskedAdaptationCounts {
    absl::optional<int> resolution_adaptations = absl::nullopt;
@ -257,52 +257,52 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
  };
  void SetAdaptTimer(const MaskedAdaptationCounts& counts, StatsTimer* timer)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  void UpdateAdaptationStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+  void UpdateAdaptationStats() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void TryUpdateInitialQualityResolutionAdaptUp(
      absl::optional<int> old_quality_downscales,
      absl::optional<int> updated_quality_downscales)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void UpdateEncoderFallbackStats(const CodecSpecificInfo* codec_info,
                                  int pixels,
                                  int simulcast_index)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  void UpdateFallbackDisabledStats(const CodecSpecificInfo* codec_info,
                                   int pixels,
                                   int simulcast_index)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
  Clock* const clock_;
  const std::string payload_name_;
  const RtpConfig rtp_config_;
  const absl::optional<int> fallback_max_pixels_;
  const absl::optional<int> fallback_max_pixels_disabled_;
-  rtc::CriticalSection crit_;
+  mutable Mutex mutex_;
-  VideoEncoderConfig::ContentType content_type_ RTC_GUARDED_BY(crit_);
+  VideoEncoderConfig::ContentType content_type_ RTC_GUARDED_BY(mutex_);
  const int64_t start_ms_;
-  VideoSendStream::Stats stats_ RTC_GUARDED_BY(crit_);
+  VideoSendStream::Stats stats_ RTC_GUARDED_BY(mutex_);
-  std::map<uint32_t, StatsUpdateTimes> update_times_ RTC_GUARDED_BY(crit_);
+  std::map<uint32_t, StatsUpdateTimes> update_times_ RTC_GUARDED_BY(mutex_);
-  rtc::ExpFilter encode_time_ RTC_GUARDED_BY(crit_);
+  rtc::ExpFilter encode_time_ RTC_GUARDED_BY(mutex_);
  QualityLimitationReasonTracker quality_limitation_reason_tracker_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker media_byte_rate_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker media_byte_rate_tracker_ RTC_GUARDED_BY(mutex_);
-  rtc::RateTracker encoded_frame_rate_tracker_ RTC_GUARDED_BY(crit_);
+  rtc::RateTracker encoded_frame_rate_tracker_ RTC_GUARDED_BY(mutex_);
  std::map<uint32_t, std::unique_ptr<rtc::RateTracker>>
-      encoded_frame_rate_trackers_ RTC_GUARDED_BY(crit_);
+      encoded_frame_rate_trackers_ RTC_GUARDED_BY(mutex_);
-  absl::optional<int64_t> last_outlier_timestamp_ RTC_GUARDED_BY(crit_);
+  absl::optional<int64_t> last_outlier_timestamp_ RTC_GUARDED_BY(mutex_);
-  int last_num_spatial_layers_ RTC_GUARDED_BY(crit_);
+  int last_num_spatial_layers_ RTC_GUARDED_BY(mutex_);
-  int last_num_simulcast_streams_ RTC_GUARDED_BY(crit_);
+  int last_num_simulcast_streams_ RTC_GUARDED_BY(mutex_);
  std::array<bool, kMaxSpatialLayers> last_spatial_layer_use_
-      RTC_GUARDED_BY(crit_);
+      RTC_GUARDED_BY(mutex_);
  // Indicates if the latest bitrate allocation had layers disabled by low
  // available bandwidth.
-  bool bw_limited_layers_ RTC_GUARDED_BY(crit_);
+  bool bw_limited_layers_ RTC_GUARDED_BY(mutex_);
  // Indicastes if the encoder internally downscales input image.
-  bool internal_encoder_scaler_ RTC_GUARDED_BY(crit_);
+  bool internal_encoder_scaler_ RTC_GUARDED_BY(mutex_);
-  Adaptations adaptation_limitations_ RTC_GUARDED_BY(crit_);
+  Adaptations adaptation_limitations_ RTC_GUARDED_BY(mutex_);
  struct EncoderChangeEvent {
    std::string previous_encoder_implementation;
@ -374,7 +374,7 @@ class SendStatisticsProxy : public VideoStreamEncoderObserver,
        qp_counters_;  // QP counters mapped by spatial idx.
  };
-  std::unique_ptr<UmaSamplesContainer> uma_container_ RTC_GUARDED_BY(crit_);
+  std::unique_ptr<UmaSamplesContainer> uma_container_ RTC_GUARDED_BY(mutex_);
 };
 }  // namespace webrtc
--- a/video/video_analyzer.cc
+++ b/video/video_analyzer.cc
@ -151,7 +151,7 @@ VideoAnalyzer::VideoAnalyzer(test::LayerFilteringTransport* transport,
 VideoAnalyzer::~VideoAnalyzer() {
  {
-    rtc::CritScope crit(&comparison_lock_);
+    MutexLock lock(&comparison_lock_);
    quit_ = true;
  }
  for (rtc::PlatformThread* thread : comparison_thread_pool_) {
@ -174,25 +174,25 @@ void VideoAnalyzer::SetSource(
 }
 void VideoAnalyzer::SetCall(Call* call) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  RTC_DCHECK(!call_);
  call_ = call;
 }
 void VideoAnalyzer::SetSendStream(VideoSendStream* stream) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  RTC_DCHECK(!send_stream_);
  send_stream_ = stream;
 }
 void VideoAnalyzer::SetReceiveStream(VideoReceiveStream* stream) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  RTC_DCHECK(!receive_stream_);
  receive_stream_ = stream;
 }
 void VideoAnalyzer::SetAudioReceiveStream(AudioReceiveStream* recv_stream) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  RTC_CHECK(!audio_receive_stream_);
  audio_receive_stream_ = recv_stream;
 }
@ -234,7 +234,7 @@ PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket(
    // (FlexFEC and media are sent on different SSRCs, which have different
    // timestamps spaces.)
    // Also ignore packets from wrong SSRC, but include retransmits.
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&lock_);
    int64_t timestamp =
        wrap_handler_.Unwrap(rtp_packet.Timestamp() - rtp_timestamp_delta_);
    recv_times_[timestamp] = clock_->CurrentNtpInMilliseconds();
@ -245,7 +245,7 @@ PacketReceiver::DeliveryStatus VideoAnalyzer::DeliverPacket(
 }
 void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  if (!first_encoded_timestamp_) {
    while (frames_.front().timestamp() != video_frame.timestamp()) {
      ++dropped_frames_before_first_encode_;
@ -257,7 +257,7 @@ void VideoAnalyzer::PreEncodeOnFrame(const VideoFrame& video_frame) {
 }
 void VideoAnalyzer::PostEncodeOnFrame(size_t stream_id, uint32_t timestamp) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  if (!first_sent_timestamp_ && stream_id == selected_stream_) {
    first_sent_timestamp_ = timestamp;
  }
@ -273,7 +273,7 @@ bool VideoAnalyzer::SendRtp(const uint8_t* packet,
  bool result = transport_->SendRtp(packet, length, options);
  {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&lock_);
    if (rtp_timestamp_delta_ == 0 && rtp_packet.Ssrc() == ssrc_to_analyze_) {
      RTC_CHECK(static_cast<bool>(first_sent_timestamp_));
      rtp_timestamp_delta_ = rtp_packet.Timestamp() - *first_sent_timestamp_;
@ -304,7 +304,7 @@ bool VideoAnalyzer::SendRtcp(const uint8_t* packet, size_t length) {
 void VideoAnalyzer::OnFrame(const VideoFrame& video_frame) {
  int64_t render_time_ms = clock_->CurrentNtpInMilliseconds();
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  StartExcludingCpuThreadTime();
@ -361,7 +361,7 @@ void VideoAnalyzer::Wait() {
    int frames_processed;
    int frames_captured;
    {
-      rtc::CritScope crit(&comparison_lock_);
+      MutexLock lock(&comparison_lock_);
      frames_processed = frames_processed_;
      frames_captured = captured_frames_;
    }
@ -401,29 +401,29 @@ void VideoAnalyzer::Wait() {
 }
 void VideoAnalyzer::StartMeasuringCpuProcessTime() {
-  rtc::CritScope lock(&cpu_measurement_lock_);
+  MutexLock lock(&cpu_measurement_lock_);
  cpu_time_ -= rtc::GetProcessCpuTimeNanos();
  wallclock_time_ -= rtc::SystemTimeNanos();
 }
 void VideoAnalyzer::StopMeasuringCpuProcessTime() {
-  rtc::CritScope lock(&cpu_measurement_lock_);
+  MutexLock lock(&cpu_measurement_lock_);
  cpu_time_ += rtc::GetProcessCpuTimeNanos();
  wallclock_time_ += rtc::SystemTimeNanos();
 }
 void VideoAnalyzer::StartExcludingCpuThreadTime() {
-  rtc::CritScope lock(&cpu_measurement_lock_);
+  MutexLock lock(&cpu_measurement_lock_);
  cpu_time_ += rtc::GetThreadCpuTimeNanos();
 }
 void VideoAnalyzer::StopExcludingCpuThreadTime() {
-  rtc::CritScope lock(&cpu_measurement_lock_);
+  MutexLock lock(&cpu_measurement_lock_);
  cpu_time_ -= rtc::GetThreadCpuTimeNanos();
 }
 double VideoAnalyzer::GetCpuUsagePercent() {
-  rtc::CritScope lock(&cpu_measurement_lock_);
+  MutexLock lock(&cpu_measurement_lock_);
  return static_cast<double>(cpu_time_) / wallclock_time_ * 100.0;
 }
@ -456,7 +456,7 @@ bool VideoAnalyzer::IsInSelectedSpatialAndTemporalLayer(
 }
 void VideoAnalyzer::PollStats() {
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  Call::Stats call_stats = call_->GetStats();
  send_bandwidth_bps_.AddSample(call_stats.send_bandwidth_bps);
@ -564,7 +564,7 @@ bool VideoAnalyzer::CompareFrames() {
 }
 bool VideoAnalyzer::PopComparison(VideoAnalyzer::FrameComparison* comparison) {
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  // If AllFramesRecorded() is true, it means we have already popped
  // frames_to_process_ frames from comparisons_, so there is no more work
  // for this thread to be done. frames_processed_ might still be lower if
@ -585,7 +585,7 @@ void VideoAnalyzer::FrameRecorded() {
 }
 bool VideoAnalyzer::AllFramesRecorded() {
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  return AllFramesRecordedLocked();
 }
@ -596,7 +596,7 @@ bool VideoAnalyzer::AllFramesRecordedLocked() {
 }
 bool VideoAnalyzer::FrameProcessed() {
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  ++frames_processed_;
  assert(frames_processed_ <= frames_to_process_);
  return frames_processed_ == frames_to_process_ ||
@ -609,11 +609,11 @@ void VideoAnalyzer::PrintResults() {
  StopMeasuringCpuProcessTime();
  int dropped_frames_diff;
  {
-    rtc::CritScope crit(&crit_);
+    MutexLock lock(&lock_);
    dropped_frames_diff = dropped_frames_before_first_encode_ +
                          dropped_frames_before_rendering_ + frames_.size();
  }
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  PrintResult("psnr", psnr_, "dB", ImproveDirection::kBiggerIsBetter);
  PrintResult("ssim", ssim_, "unitless", ImproveDirection::kBiggerIsBetter);
  PrintResult("sender_time", sender_time_, "ms",
@ -756,7 +756,7 @@ void VideoAnalyzer::PerformFrameComparison(
    ssim = I420SSIM(&*comparison.reference, &*comparison.render);
  }
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  if (psnr >= 0.0 && (!worst_frame_ || worst_frame_->psnr > psnr)) {
    worst_frame_.emplace(FrameWithPsnr{psnr, *comparison.render});
@ -845,7 +845,7 @@ void VideoAnalyzer::PrintResultWithExternalMean(
 void VideoAnalyzer::PrintSamplesToFile() {
  FILE* out = graph_data_output_file_;
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  absl::c_sort(samples_, [](const Sample& A, const Sample& B) -> bool {
    return A.input_time_ms < B.input_time_ms;
  });
@ -876,14 +876,14 @@ void VideoAnalyzer::AddCapturedFrameForComparison(
    const VideoFrame& video_frame) {
  bool must_capture = false;
  {
-    rtc::CritScope lock(&comparison_lock_);
+    MutexLock lock(&comparison_lock_);
    must_capture = captured_frames_ < frames_to_process_;
    if (must_capture) {
      ++captured_frames_;
    }
  }
  if (must_capture) {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&lock_);
    frames_.push_back(video_frame);
  }
 }
@ -906,7 +906,7 @@ void VideoAnalyzer::AddFrameComparison(const VideoFrame& reference,
  if (it != encoded_frame_sizes_.end())
    encoded_frame_sizes_.erase(it);
-  rtc::CritScope crit(&comparison_lock_);
+  MutexLock lock(&comparison_lock_);
  if (comparisons_.size() < kMaxComparisons) {
    comparisons_.push_back(FrameComparison(
        reference, render, dropped, reference.ntp_time_ms(), send_time_ms,
@ -1002,7 +1002,7 @@ void VideoAnalyzer::CapturedFrameForwarder::OnFrame(
    copy.set_ntp_time_ms(clock_->CurrentNtpInMilliseconds());
  copy.set_timestamp(copy.ntp_time_ms() * 90);
  analyzer_->AddCapturedFrameForComparison(copy);
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  ++captured_frames_;
  if (send_stream_input_ && clock_->CurrentTime() <= test_end_ &&
      captured_frames_ <= frames_to_capture_) {
@ -1014,7 +1014,7 @@ void VideoAnalyzer::CapturedFrameForwarder::AddOrUpdateSink(
    rtc::VideoSinkInterface<VideoFrame>* sink,
    const rtc::VideoSinkWants& wants) {
  {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&lock_);
    RTC_DCHECK(!send_stream_input_ || send_stream_input_ == sink);
    send_stream_input_ = sink;
  }
@ -1025,7 +1025,7 @@ void VideoAnalyzer::CapturedFrameForwarder::AddOrUpdateSink(
 void VideoAnalyzer::CapturedFrameForwarder::RemoveSink(
    rtc::VideoSinkInterface<VideoFrame>* sink) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&lock_);
  RTC_DCHECK(sink == send_stream_input_);
  send_stream_input_ = nullptr;
 }
--- a/video/video_analyzer.h
+++ b/video/video_analyzer.h
@ -23,6 +23,7 @@
 #include "rtc_base/event.h"
 #include "rtc_base/numerics/running_statistics.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/time_utils.h"
 #include "test/layer_filtering_transport.h"
 #include "test/rtp_file_writer.h"
@ -154,24 +155,24 @@ class VideoAnalyzer : public PacketReceiver,
   private:
    void OnFrame(const VideoFrame& video_frame)
-        RTC_LOCKS_EXCLUDED(crit_) override;
+        RTC_LOCKS_EXCLUDED(lock_) override;
    // Called when |send_stream_.SetSource()| is called.
    void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                         const rtc::VideoSinkWants& wants)
-        RTC_LOCKS_EXCLUDED(crit_) override;
+        RTC_LOCKS_EXCLUDED(lock_) override;
    // Called by |send_stream_| when |send_stream_.SetSource()| is called.
    void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* sink)
-        RTC_LOCKS_EXCLUDED(crit_) override;
+        RTC_LOCKS_EXCLUDED(lock_) override;
    VideoAnalyzer* const analyzer_;
-    rtc::CriticalSection crit_;
+    Mutex lock_;
    rtc::VideoSinkInterface<VideoFrame>* send_stream_input_
-        RTC_GUARDED_BY(crit_);
+        RTC_GUARDED_BY(lock_);
    VideoSourceInterface<VideoFrame>* video_source_;
    Clock* clock_;
-    int captured_frames_ RTC_GUARDED_BY(crit_);
+    int captured_frames_ RTC_GUARDED_BY(lock_);
    const int frames_to_capture_;
    const Timestamp test_end_;
  };
@ -187,7 +188,7 @@ class VideoAnalyzer : public PacketReceiver,
                          const VideoFrame& render,
                          bool dropped,
                          int64_t render_time_ms)
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(lock_);
  void PollStats() RTC_LOCKS_EXCLUDED(comparison_lock_);
  static void FrameComparisonThread(void* obj);
@ -201,7 +202,7 @@ class VideoAnalyzer : public PacketReceiver,
  // Increase count of number of frames processed. Returns true if this was the
  // last frame to be processed.
  bool FrameProcessed() RTC_LOCKS_EXCLUDED(comparison_lock_);
-  void PrintResults() RTC_LOCKS_EXCLUDED(crit_, comparison_lock_);
+  void PrintResults() RTC_LOCKS_EXCLUDED(lock_, comparison_lock_);
  void PerformFrameComparison(const FrameComparison& comparison)
      RTC_LOCKS_EXCLUDED(comparison_lock_);
  void PrintResult(const char* result_type,
@ -216,7 +217,7 @@ class VideoAnalyzer : public PacketReceiver,
      webrtc::test::ImproveDirection improve_direction);
  void PrintSamplesToFile(void) RTC_LOCKS_EXCLUDED(comparison_lock_);
  void AddCapturedFrameForComparison(const VideoFrame& video_frame)
-      RTC_LOCKS_EXCLUDED(crit_, comparison_lock_);
+      RTC_LOCKS_EXCLUDED(lock_, comparison_lock_);
  Call* call_;
  VideoSendStream* send_stream_;
@ -232,7 +233,7 @@ class VideoAnalyzer : public PacketReceiver,
  const int selected_sl_;
  const int selected_tl_;
-  rtc::CriticalSection comparison_lock_;
+  Mutex comparison_lock_;
  std::vector<Sample> samples_ RTC_GUARDED_BY(comparison_lock_);
  Statistics sender_time_ RTC_GUARDED_BY(comparison_lock_);
  Statistics receiver_time_ RTC_GUARDED_BY(comparison_lock_);
@ -270,7 +271,7 @@ class VideoAnalyzer : public PacketReceiver,
  size_t last_fec_bytes_;
-  rtc::CriticalSection crit_ RTC_ACQUIRED_BEFORE(comparison_lock_)
+  Mutex lock_ RTC_ACQUIRED_BEFORE(comparison_lock_)
      RTC_ACQUIRED_BEFORE(cpu_measurement_lock_);
  const int frames_to_process_;
  const Timestamp test_end_;
@ -278,25 +279,25 @@ class VideoAnalyzer : public PacketReceiver,
  int frames_processed_ RTC_GUARDED_BY(comparison_lock_);
  int captured_frames_ RTC_GUARDED_BY(comparison_lock_);
  int dropped_frames_ RTC_GUARDED_BY(comparison_lock_);
-  int dropped_frames_before_first_encode_ RTC_GUARDED_BY(crit_);
+  int dropped_frames_before_first_encode_ RTC_GUARDED_BY(lock_);
-  int dropped_frames_before_rendering_ RTC_GUARDED_BY(crit_);
+  int dropped_frames_before_rendering_ RTC_GUARDED_BY(lock_);
  int64_t last_render_time_ RTC_GUARDED_BY(comparison_lock_);
  int64_t last_render_delta_ms_ RTC_GUARDED_BY(comparison_lock_);
  int64_t last_unfreeze_time_ms_ RTC_GUARDED_BY(comparison_lock_);
-  uint32_t rtp_timestamp_delta_ RTC_GUARDED_BY(crit_);
+  uint32_t rtp_timestamp_delta_ RTC_GUARDED_BY(lock_);
-  rtc::CriticalSection cpu_measurement_lock_;
+  Mutex cpu_measurement_lock_;
  int64_t cpu_time_ RTC_GUARDED_BY(cpu_measurement_lock_);
  int64_t wallclock_time_ RTC_GUARDED_BY(cpu_measurement_lock_);
-  std::deque<VideoFrame> frames_ RTC_GUARDED_BY(crit_);
+  std::deque<VideoFrame> frames_ RTC_GUARDED_BY(lock_);
-  absl::optional<VideoFrame> last_rendered_frame_ RTC_GUARDED_BY(crit_);
+  absl::optional<VideoFrame> last_rendered_frame_ RTC_GUARDED_BY(lock_);
-  rtc::TimestampWrapAroundHandler wrap_handler_ RTC_GUARDED_BY(crit_);
+  rtc::TimestampWrapAroundHandler wrap_handler_ RTC_GUARDED_BY(lock_);
-  std::map<int64_t, int64_t> send_times_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, int64_t> send_times_ RTC_GUARDED_BY(lock_);
-  std::map<int64_t, int64_t> recv_times_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, int64_t> recv_times_ RTC_GUARDED_BY(lock_);
-  std::map<int64_t, size_t> encoded_frame_sizes_ RTC_GUARDED_BY(crit_);
+  std::map<int64_t, size_t> encoded_frame_sizes_ RTC_GUARDED_BY(lock_);
-  absl::optional<uint32_t> first_encoded_timestamp_ RTC_GUARDED_BY(crit_);
+  absl::optional<uint32_t> first_encoded_timestamp_ RTC_GUARDED_BY(lock_);
-  absl::optional<uint32_t> first_sent_timestamp_ RTC_GUARDED_BY(crit_);
+  absl::optional<uint32_t> first_sent_timestamp_ RTC_GUARDED_BY(lock_);
  const double avg_psnr_threshold_;
  const double avg_ssim_threshold_;
  bool is_quick_test_enabled_;
--- a/video/video_receive_stream.cc
+++ b/video/video_receive_stream.cc
@ -494,7 +494,7 @@ bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) {
    return false;
  }
-  rtc::CritScope cs(&playout_delay_lock_);
+  MutexLock lock(&playout_delay_lock_);
  base_minimum_playout_delay_ms_ = delay_ms;
  UpdatePlayoutDelays();
  return true;
@ -503,7 +503,7 @@ bool VideoReceiveStream::SetBaseMinimumPlayoutDelayMs(int delay_ms) {
 int VideoReceiveStream::GetBaseMinimumPlayoutDelayMs() const {
  RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-  rtc::CritScope cs(&playout_delay_lock_);
+  MutexLock lock(&playout_delay_lock_);
  return base_minimum_playout_delay_ms_;
 }
@ -566,13 +566,13 @@ void VideoReceiveStream::OnCompleteFrame(
  const PlayoutDelay& playout_delay = frame->EncodedImage().playout_delay_;
  if (playout_delay.min_ms >= 0) {
-    rtc::CritScope cs(&playout_delay_lock_);
+    MutexLock lock(&playout_delay_lock_);
    frame_minimum_playout_delay_ms_ = playout_delay.min_ms;
    UpdatePlayoutDelays();
  }
  if (playout_delay.max_ms >= 0) {
-    rtc::CritScope cs(&playout_delay_lock_);
+    MutexLock lock(&playout_delay_lock_);
    frame_maximum_playout_delay_ms_ = playout_delay.max_ms;
    UpdatePlayoutDelays();
  }
@ -619,7 +619,7 @@ void VideoReceiveStream::SetEstimatedPlayoutNtpTimestampMs(
 void VideoReceiveStream::SetMinimumPlayoutDelay(int delay_ms) {
  RTC_DCHECK_RUN_ON(&module_process_sequence_checker_);
-  rtc::CritScope cs(&playout_delay_lock_);
+  MutexLock lock(&playout_delay_lock_);
  syncable_minimum_playout_delay_ms_ = delay_ms;
  UpdatePlayoutDelays();
 }
--- a/video/video_receive_stream.h
+++ b/video/video_receive_stream.h
@ -23,6 +23,7 @@
 #include "modules/rtp_rtcp/source/source_tracker.h"
 #include "modules/video_coding/frame_buffer2.h"
 #include "modules/video_coding/video_receiver2.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/task_queue.h"
 #include "system_wrappers/include/clock.h"
@ -205,7 +206,7 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
  const int max_wait_for_keyframe_ms_;
  const int max_wait_for_frame_ms_;
-  rtc::CriticalSection playout_delay_lock_;
+  mutable Mutex playout_delay_lock_;
  // All of them tries to change current min_playout_delay on |timing_| but
  // source of the change request is different in each case. Among them the
--- a/video/video_send_stream_impl.h
+++ b/video/video_send_stream_impl.h
@ -35,8 +35,8 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/utility/include/process_thread.h"
 #include "modules/video_coding/include/video_codec_interface.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/thread_annotations.h"
@ -164,7 +164,7 @@ class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
  RtpTransportControllerSendInterface* const transport_;
  BitrateAllocatorInterface* const bitrate_allocator_;
-  rtc::CriticalSection ivf_writers_crit_;
+  Mutex ivf_writers_mutex_;
  bool disable_padding_;
  int max_padding_bitrate_;
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@ -33,12 +33,12 @@
 #include "modules/video_coding/codecs/vp8/include/vp8.h"
 #include "modules/video_coding/codecs/vp9/include/vp9.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/event.h"
 #include "rtc_base/experiments/alr_experiment.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/rate_limiter.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/task_utils/to_queued_task.h"
@ -1140,7 +1140,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
            fec_packet_received_ = false;
            ++current_size_rtp_;
-            rtc::CritScope lock(&mutex_);
+            MutexLock lock(&mutex_);
            ++current_size_frame_;
          }
        }
@ -1182,7 +1182,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
    }
    void UpdateConfiguration() {
-      rtc::CritScope lock(&mutex_);
+      MutexLock lock(&mutex_);
      // Increase frame size for next encoded frame, in the context of the
      // encoder thread.
      if (!use_fec_ && current_size_frame_ < static_cast<int32_t>(stop_size_)) {
@ -1247,7 +1247,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
    bool fec_packet_received_;
    size_t current_size_rtp_;
-    rtc::CriticalSection mutex_;
+    Mutex mutex_;
    int current_size_frame_ RTC_GUARDED_BY(mutex_);
  };
@ -1296,7 +1296,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
          : remb_observer_(remb_observer) {}
      void OnFrame(const VideoFrame&) {
-        rtc::CritScope lock(&remb_observer_->crit_);
+        MutexLock lock(&remb_observer_->mutex_);
        if (remb_observer_->test_state_ == kDuringSuspend &&
            ++remb_observer_->suspended_frame_count_ > kSuspendTimeFrames) {
          VideoSendStream::Stats stats = remb_observer_->stream_->GetStats();
@ -1324,7 +1324,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
   private:
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      ++rtp_count_;
      RtpPacket rtp_packet;
      EXPECT_TRUE(rtp_packet.Parse(packet, length));
@ -1361,12 +1361,12 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
    }
    void set_low_remb_bps(int value) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      low_remb_bps_ = value;
    }
    void set_high_remb_bps(int value) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      high_remb_bps_ = value;
    }
@ -1413,7 +1413,7 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
    };
    virtual void SendRtcpFeedback(int remb_value)
-        RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+        RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
      FakeReceiveStatistics receive_stats(kVideoSendSsrcs[0],
                                          last_sequence_number_, rtp_count_, 0);
      RtpRtcpInterface::Configuration config;
@ -1438,13 +1438,13 @@ TEST_F(VideoSendStreamTest, SuspendBelowMinBitrate) {
    CaptureObserver capture_observer_;
    VideoSendStream* stream_;
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
-    TestState test_state_ RTC_GUARDED_BY(crit_);
+    TestState test_state_ RTC_GUARDED_BY(mutex_);
-    int rtp_count_ RTC_GUARDED_BY(crit_);
+    int rtp_count_ RTC_GUARDED_BY(mutex_);
-    int last_sequence_number_ RTC_GUARDED_BY(crit_);
+    int last_sequence_number_ RTC_GUARDED_BY(mutex_);
-    int suspended_frame_count_ RTC_GUARDED_BY(crit_);
+    int suspended_frame_count_ RTC_GUARDED_BY(mutex_);
-    int low_remb_bps_ RTC_GUARDED_BY(crit_);
+    int low_remb_bps_ RTC_GUARDED_BY(mutex_);
-    int high_remb_bps_ RTC_GUARDED_BY(crit_);
+    int high_remb_bps_ RTC_GUARDED_BY(mutex_);
  } test;
  RunBaseTest(&test);
@ -1462,7 +1462,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
   private:
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      last_packet_time_ms_ = clock_->TimeInMilliseconds();
      RtpPacket rtp_packet;
@ -1490,7 +1490,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
    }
    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      const int kNoPacketsThresholdMs = 2000;
      if (test_state_ == kWaitingForNoPackets &&
          (last_packet_time_ms_ &&
@ -1513,7 +1513,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
    void OnFrameGeneratorCapturerCreated(
        test::FrameGeneratorCapturer* frame_generator_capturer) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      capturer_ = frame_generator_capturer;
    }
@ -1532,9 +1532,9 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
    TestState test_state_ = kBeforeStopCapture;
    Clock* const clock_;
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
-    absl::optional<int64_t> last_packet_time_ms_ RTC_GUARDED_BY(crit_);
+    absl::optional<int64_t> last_packet_time_ms_ RTC_GUARDED_BY(mutex_);
-    test::FrameGeneratorCapturer* capturer_ RTC_GUARDED_BY(crit_);
+    test::FrameGeneratorCapturer* capturer_ RTC_GUARDED_BY(mutex_);
  } test;
  RunBaseTest(&test);
@ -1557,7 +1557,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
    }
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      RtpPacket rtp_packet;
      rtp_packet.Parse(packet, length);
@ -1597,16 +1597,16 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
      // rid of this.
      SleepMs(5000);
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        // Expect padding to be a small percentage of total bytes sent.
        EXPECT_LT(padding_length_, .1 * total_length_);
      }
    }
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
    Clock* const clock_;
-    size_t padding_length_ RTC_GUARDED_BY(crit_);
+    size_t padding_length_ RTC_GUARDED_BY(mutex_);
-    size_t total_length_ RTC_GUARDED_BY(crit_);
+    size_t total_length_ RTC_GUARDED_BY(mutex_);
    Call* call_;
  } test;
@ -1946,7 +1946,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
      EXPECT_LE(length, kMaxRtpPacketSize);
-      rtc::CritScope cs(&lock_);
+      MutexLock lock(&lock_);
      if (++packets_sent_ < 100)
        return SEND_PACKET;
      observation_complete_.Set();
@ -1970,7 +1970,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
      EXPECT_TRUE(Wait());
      {
-        rtc::CritScope cs(&lock_);
+        MutexLock lock(&lock_);
        packets_sent_ = 0;
      }
@ -1986,7 +1986,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
   private:
    TaskQueueBase* const task_queue_;
    Call* call_;
-    rtc::CriticalSection lock_;
+    Mutex lock_;
    int packets_sent_ RTC_GUARDED_BY(lock_);
    int transport_overhead_;
    const size_t kMaxRtpPacketSize = 1000;
@ -2162,7 +2162,7 @@ TEST_F(VideoSendStreamTest,
    void WaitForResolution(int width, int height) {
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        if (last_initialized_frame_width_ == width &&
            last_initialized_frame_height_ == height) {
          return;
@ -2171,7 +2171,7 @@ TEST_F(VideoSendStreamTest,
      EXPECT_TRUE(
          init_encode_called_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        EXPECT_EQ(width, last_initialized_frame_width_);
        EXPECT_EQ(height, last_initialized_frame_height_);
      }
@ -2180,7 +2180,7 @@ TEST_F(VideoSendStreamTest,
   private:
    int32_t InitEncode(const VideoCodec* config,
                       const Settings& settings) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      last_initialized_frame_width_ = config->width;
      last_initialized_frame_height_ = config->height;
      ++number_of_initializations_;
@ -2195,11 +2195,11 @@ TEST_F(VideoSendStreamTest,
      return 0;
    }
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
    rtc::Event init_encode_called_;
-    size_t number_of_initializations_ RTC_GUARDED_BY(&crit_);
+    size_t number_of_initializations_ RTC_GUARDED_BY(&mutex_);
-    int last_initialized_frame_width_ RTC_GUARDED_BY(&crit_);
+    int last_initialized_frame_width_ RTC_GUARDED_BY(&mutex_);
-    int last_initialized_frame_height_ RTC_GUARDED_BY(&crit_);
+    int last_initialized_frame_height_ RTC_GUARDED_BY(&mutex_);
  };
  test::NullTransport transport;
@ -2238,21 +2238,21 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
        : FakeEncoder(Clock::GetRealTimeClock()), start_bitrate_kbps_(0) {}
    int32_t InitEncode(const VideoCodec* config,
                       const Settings& settings) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      start_bitrate_kbps_ = config->startBitrate;
      start_bitrate_changed_.Set();
      return FakeEncoder::InitEncode(config, settings);
    }
    void SetRates(const RateControlParameters& parameters) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      start_bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
      start_bitrate_changed_.Set();
      FakeEncoder::SetRates(parameters);
    }
    int GetStartBitrateKbps() const {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return start_bitrate_kbps_;
    }
@ -2262,9 +2262,9 @@ TEST_F(VideoSendStreamTest, CanReconfigureToUseStartBitrateAbovePreviousMax) {
    }
   private:
-    rtc::CriticalSection crit_;
+    mutable Mutex mutex_;
    rtc::Event start_bitrate_changed_;
-    int start_bitrate_kbps_ RTC_GUARDED_BY(crit_);
+    int start_bitrate_kbps_ RTC_GUARDED_BY(mutex_);
  };
  CreateSenderCall();
@ -2311,13 +2311,13 @@ class StartStopBitrateObserver : public test::FakeEncoder {
  StartStopBitrateObserver() : FakeEncoder(Clock::GetRealTimeClock()) {}
  int32_t InitEncode(const VideoCodec* config,
                     const Settings& settings) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    encoder_init_.Set();
    return FakeEncoder::InitEncode(config, settings);
  }
  void SetRates(const RateControlParameters& parameters) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    bitrate_kbps_ = parameters.bitrate.get_sum_kbps();
    bitrate_changed_.Set();
    FakeEncoder::SetRates(parameters);
@ -2331,7 +2331,7 @@ class StartStopBitrateObserver : public test::FakeEncoder {
    do {
      absl::optional<int> bitrate_kbps;
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        bitrate_kbps = bitrate_kbps_;
      }
      if (!bitrate_kbps)
@ -2346,10 +2346,10 @@ class StartStopBitrateObserver : public test::FakeEncoder {
  }
 private:
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
  rtc::Event encoder_init_;
  rtc::Event bitrate_changed_;
-  absl::optional<int> bitrate_kbps_ RTC_GUARDED_BY(crit_);
+  absl::optional<int> bitrate_kbps_ RTC_GUARDED_BY(mutex_);
 };
 // This test that if the encoder use an internal source, VideoEncoder::SetRates
@ -2483,23 +2483,23 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
          released_(false),
          encoder_factory_(this) {}
-    bool IsReleased() RTC_LOCKS_EXCLUDED(crit_) {
+    bool IsReleased() RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return released_;
    }
-    bool IsReadyForEncode() RTC_LOCKS_EXCLUDED(crit_) {
+    bool IsReadyForEncode() RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return IsReadyForEncodeLocked();
    }
-    size_t num_releases() RTC_LOCKS_EXCLUDED(crit_) {
+    size_t num_releases() RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return num_releases_;
    }
   private:
-    bool IsReadyForEncodeLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_) {
+    bool IsReadyForEncodeLocked() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_) {
      return initialized_ && callback_registered_;
    }
@ -2510,8 +2510,8 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
    int32_t InitEncode(const VideoCodec* codecSettings,
                       const Settings& settings) override
-        RTC_LOCKS_EXCLUDED(crit_) {
+        RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_FALSE(initialized_);
      initialized_ = true;
      released_ = false;
@ -2527,15 +2527,15 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
    }
    int32_t RegisterEncodeCompleteCallback(
-        EncodedImageCallback* callback) override RTC_LOCKS_EXCLUDED(crit_) {
+        EncodedImageCallback* callback) override RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_TRUE(initialized_);
      callback_registered_ = true;
      return 0;
    }
-    int32_t Release() override RTC_LOCKS_EXCLUDED(crit_) {
+    int32_t Release() override RTC_LOCKS_EXCLUDED(mutex_) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_TRUE(IsReadyForEncodeLocked());
      EXPECT_FALSE(released_);
      initialized_ = false;
@ -2582,12 +2582,12 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
    }
    TaskQueueBase* const task_queue_;
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
    VideoSendStream* stream_;
-    bool initialized_ RTC_GUARDED_BY(crit_);
+    bool initialized_ RTC_GUARDED_BY(mutex_);
-    bool callback_registered_ RTC_GUARDED_BY(crit_);
+    bool callback_registered_ RTC_GUARDED_BY(mutex_);
-    size_t num_releases_ RTC_GUARDED_BY(crit_);
+    size_t num_releases_ RTC_GUARDED_BY(mutex_);
-    bool released_ RTC_GUARDED_BY(crit_);
+    bool released_ RTC_GUARDED_BY(mutex_);
    test::VideoEncoderProxyFactory encoder_factory_;
    VideoEncoderConfig encoder_config_;
  } test_encoder(task_queue());
@ -2817,7 +2817,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
   private:
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      RtpPacket rtp_packet;
      EXPECT_TRUE(rtp_packet.Parse(packet, length));
      ++rtp_packets_sent_;
@ -2826,7 +2826,7 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
    }
    Action OnSendRtcp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      test::RtcpPacketParser parser;
      EXPECT_TRUE(parser.Parse(packet, length));
@ -2850,9 +2850,9 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
      EXPECT_TRUE(Wait()) << "Timed out while waiting for RTCP sender report.";
    }
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
-    size_t rtp_packets_sent_ RTC_GUARDED_BY(&crit_);
+    size_t rtp_packets_sent_ RTC_GUARDED_BY(&mutex_);
-    size_t media_bytes_sent_ RTC_GUARDED_BY(&crit_);
+    size_t media_bytes_sent_ RTC_GUARDED_BY(&mutex_);
  } test;
  RunBaseTest(&test);
@ -3006,7 +3006,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
    void SetRates(const RateControlParameters& parameters) override {
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        if (target_bitrate_ == parameters.bitrate.get_sum_kbps()) {
          FakeEncoder::SetRates(parameters);
          return;
@ -3023,14 +3023,14 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
      // until the correct value has been observed.
      const int64_t start_time = rtc::TimeMillis();
      do {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        if (target_bitrate_ == expected_bitrate) {
          return;
        }
      } while (bitrate_changed_event_.Wait(
          std::max(int64_t{1}, VideoSendStreamTest::kDefaultTimeoutMs -
                                   (rtc::TimeMillis() - start_time))));
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_EQ(target_bitrate_, expected_bitrate)
          << "Timed out while waiting encoder rate to be set.";
    }
@ -3111,8 +3111,8 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
    rtc::Event create_rate_allocator_event_;
    rtc::Event init_encode_event_;
    rtc::Event bitrate_changed_event_;
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
-    uint32_t target_bitrate_ RTC_GUARDED_BY(&crit_);
+    uint32_t target_bitrate_ RTC_GUARDED_BY(&mutex_);
    int num_rate_allocator_creations_;
    int num_encoder_initializations_;
@ -3160,7 +3160,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
        encoded.SetSpatialIndex(i);
        EncodedImageCallback* callback;
        {
-          rtc::CritScope cs(&crit_sect_);
+          MutexLock lock(&mutex_);
          callback = callback_;
        }
        RTC_DCHECK(callback);
@ -3263,7 +3263,7 @@ class Vp9HeaderObserver : public test::SendTest {
    bool wait = Wait();
    {
      // In case of time out, OnSendRtp might still access frames_sent_;
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_TRUE(wait) << "Test timed out waiting for VP9 packet, num frames "
                        << frames_sent_;
    }
@ -3295,7 +3295,7 @@ class Vp9HeaderObserver : public test::SendTest {
      ++packets_sent_;
      if (rtp_packet.Marker()) {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        ++frames_sent_;
      }
      last_packet_marker_ = rtp_packet.Marker();
@ -3522,7 +3522,7 @@ class Vp9HeaderObserver : public test::SendTest {
  uint32_t last_packet_timestamp_ = 0;
  RTPVideoHeaderVP9 last_vp9_;
  size_t packets_sent_;
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
  size_t frames_sent_;
  int expected_width_;
  int expected_height_;
@ -3813,7 +3813,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
          first_packet_sent_(false) {}
    void SetRates(const RateControlParameters& parameters) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      // Wait for the first sent packet so that videosendstream knows
      // rtp_overhead.
      if (first_packet_sent_) {
@ -3837,7 +3837,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
    }
    Action OnSendRtp(const uint8_t* packet, size_t length) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      first_packet_sent_ = true;
      return SEND_PACKET;
    }
@ -3862,7 +3862,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
      EXPECT_TRUE(
          bitrate_changed_event_.Wait(VideoSendStreamTest::kDefaultTimeoutMs));
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        EXPECT_LE(max_bitrate_bps_, 57760u);
      }
    }
@ -3871,9 +3871,9 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
    TaskQueueBase* const task_queue_;
    test::VideoEncoderProxyFactory encoder_factory_;
    Call* call_;
-    rtc::CriticalSection crit_;
+    Mutex mutex_;
-    uint32_t max_bitrate_bps_ RTC_GUARDED_BY(&crit_);
+    uint32_t max_bitrate_bps_ RTC_GUARDED_BY(&mutex_);
-    bool first_packet_sent_ RTC_GUARDED_BY(&crit_);
+    bool first_packet_sent_ RTC_GUARDED_BY(&mutex_);
    rtc::Event bitrate_changed_event_;
  } test(task_queue());
  RunBaseTest(&test);
@ -3992,7 +3992,7 @@ class ContentSwitchTest : public test::SendTest {
  void OnVideoStreamsCreated(
      VideoSendStream* send_stream,
      const std::vector<VideoReceiveStream*>& receive_streams) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    send_stream_ = send_stream;
  }
@ -4013,7 +4013,7 @@ class ContentSwitchTest : public test::SendTest {
  }
  Action OnSendRtp(const uint8_t* packet, size_t length) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    auto internal_send_peer = test::VideoSendStreamPeer(send_stream_);
    float pacing_factor =
@ -4075,18 +4075,18 @@ class ContentSwitchTest : public test::SendTest {
 private:
  StreamState GetStreamState() {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    return state_;
  }
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
  rtc::Event content_switch_event_;
  Call* call_;
-  StreamState state_ RTC_GUARDED_BY(crit_);
+  StreamState state_ RTC_GUARDED_BY(mutex_);
-  VideoSendStream* send_stream_ RTC_GUARDED_BY(crit_);
+  VideoSendStream* send_stream_ RTC_GUARDED_BY(mutex_);
  VideoSendStream::Config send_stream_config_;
  VideoEncoderConfig encoder_config_;
-  uint32_t packets_sent_ RTC_GUARDED_BY(crit_);
+  uint32_t packets_sent_ RTC_GUARDED_BY(mutex_);
  T* stream_resetter_;
 };
--- a/video/video_source_sink_controller.cc
+++ b/video/video_source_sink_controller.cc
@ -48,7 +48,7 @@ void VideoSourceSinkController::SetSource(
  rtc::VideoSourceInterface<VideoFrame>* old_source;
  rtc::VideoSinkWants wants;
  {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
    old_source = source_;
    source_ = source;
    wants = CurrentSettingsToSinkWants();
@ -61,7 +61,7 @@ void VideoSourceSinkController::SetSource(
 }
 void VideoSourceSinkController::PushSourceSinkSettings() {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  if (!source_)
    return;
  rtc::VideoSinkWants wants = CurrentSettingsToSinkWants();
@ -70,62 +70,62 @@ void VideoSourceSinkController::PushSourceSinkSettings() {
 }
 VideoSourceRestrictions VideoSourceSinkController::restrictions() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return restrictions_;
 }
 absl::optional<size_t> VideoSourceSinkController::pixels_per_frame_upper_limit()
    const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return pixels_per_frame_upper_limit_;
 }
 absl::optional<double> VideoSourceSinkController::frame_rate_upper_limit()
    const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return frame_rate_upper_limit_;
 }
 bool VideoSourceSinkController::rotation_applied() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return rotation_applied_;
 }
 int VideoSourceSinkController::resolution_alignment() const {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  return resolution_alignment_;
 }
 void VideoSourceSinkController::SetRestrictions(
    VideoSourceRestrictions restrictions) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  restrictions_ = std::move(restrictions);
 }
 void VideoSourceSinkController::SetPixelsPerFrameUpperLimit(
    absl::optional<size_t> pixels_per_frame_upper_limit) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  pixels_per_frame_upper_limit_ = std::move(pixels_per_frame_upper_limit);
 }
 void VideoSourceSinkController::SetFrameRateUpperLimit(
    absl::optional<double> frame_rate_upper_limit) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  frame_rate_upper_limit_ = std::move(frame_rate_upper_limit);
 }
 void VideoSourceSinkController::SetRotationApplied(bool rotation_applied) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  rotation_applied_ = rotation_applied;
 }
 void VideoSourceSinkController::SetResolutionAlignment(
    int resolution_alignment) {
-  rtc::CritScope lock(&crit_);
+  MutexLock lock(&mutex_);
  resolution_alignment_ = resolution_alignment;
 }
-// RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_)
+// RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_)
 rtc::VideoSinkWants VideoSourceSinkController::CurrentSettingsToSinkWants()
    const {
  rtc::VideoSinkWants wants;
--- a/video/video_source_sink_controller.h
+++ b/video/video_source_sink_controller.h
@ -18,7 +18,7 @@
 #include "api/video/video_sink_interface.h"
 #include "api/video/video_source_interface.h"
 #include "call/adaptation/video_source_restrictions.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 namespace webrtc {
@ -53,20 +53,20 @@ class VideoSourceSinkController {
 private:
  rtc::VideoSinkWants CurrentSettingsToSinkWants() const
-      RTC_EXCLUSIVE_LOCKS_REQUIRED(crit_);
+      RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  mutable rtc::CriticalSection crit_;
+  mutable Mutex mutex_;
  rtc::VideoSinkInterface<VideoFrame>* const sink_;
-  rtc::VideoSourceInterface<VideoFrame>* source_ RTC_GUARDED_BY(&crit_);
+  rtc::VideoSourceInterface<VideoFrame>* source_ RTC_GUARDED_BY(&mutex_);
  // Pixel and frame rate restrictions.
-  VideoSourceRestrictions restrictions_ RTC_GUARDED_BY(&crit_);
+  VideoSourceRestrictions restrictions_ RTC_GUARDED_BY(&mutex_);
  // Ensures that even if we are not restricted, the sink is never configured
  // above this limit. Example: We are not CPU limited (no |restrictions_|) but
  // our encoder is capped at 30 fps (= |frame_rate_upper_limit_|).
-  absl::optional<size_t> pixels_per_frame_upper_limit_ RTC_GUARDED_BY(&crit_);
+  absl::optional<size_t> pixels_per_frame_upper_limit_ RTC_GUARDED_BY(&mutex_);
-  absl::optional<double> frame_rate_upper_limit_ RTC_GUARDED_BY(&crit_);
+  absl::optional<double> frame_rate_upper_limit_ RTC_GUARDED_BY(&mutex_);
-  bool rotation_applied_ RTC_GUARDED_BY(&crit_) = false;
+  bool rotation_applied_ RTC_GUARDED_BY(&mutex_) = false;
-  int resolution_alignment_ RTC_GUARDED_BY(&crit_) = 1;
+  int resolution_alignment_ RTC_GUARDED_BY(&mutex_) = 1;
 };
 }  // namespace webrtc
--- a/video/video_stream_decoder.h
+++ b/video/video_stream_decoder.h
@ -20,8 +20,8 @@
 #include "api/video/video_sink_interface.h"
 #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
 #include "modules/video_coding/include/video_coding_defines.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/synchronization/mutex.h"
 namespace webrtc {
@ -50,7 +50,7 @@ class VideoStreamDecoder : public VCMReceiveCallback {
 private:
  // Used for all registered callbacks except rendering.
-  rtc::CriticalSection crit_;
+  Mutex mutex_;
  VideoReceiver2* const video_receiver_;
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@ -39,6 +39,7 @@
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/strings/string_builder.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/time_utils.h"
@ -220,18 +221,18 @@ class VideoStreamEncoder::DegradationPreferenceManager
  }
  DegradationPreference degradation_preference() const override {
-    rtc::CritScope crit(&lock_);
+    MutexLock lock(&lock_);
    return effective_degradation_preference_;
  }
  void SetDegradationPreference(DegradationPreference degradation_preference) {
-    rtc::CritScope crit(&lock_);
+    MutexLock lock(&lock_);
    degradation_preference_ = degradation_preference;
    MaybeUpdateEffectiveDegradationPreference();
  }
  void SetIsScreenshare(bool is_screenshare) {
-    rtc::CritScope crit(&lock_);
+    MutexLock lock(&lock_);
    is_screenshare_ = is_screenshare;
    MaybeUpdateEffectiveDegradationPreference();
  }
@ -273,7 +274,7 @@ class VideoStreamEncoder::DegradationPreferenceManager
    }
  }
-  rtc::CriticalSection lock_;
+  mutable Mutex lock_;
  DegradationPreference degradation_preference_ RTC_GUARDED_BY(&lock_);
  bool is_screenshare_ RTC_GUARDED_BY(&lock_);
  DegradationPreference effective_degradation_preference_
--- a/video/video_stream_encoder_unittest.cc
+++ b/video/video_stream_encoder_unittest.cc
@ -39,6 +39,7 @@
 #include "rtc_base/gunit.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/ref_counted_object.h"
 #include "rtc_base/synchronization/mutex.h"
 #include "system_wrappers/include/field_trial.h"
 #include "system_wrappers/include/metrics.h"
 #include "system_wrappers/include/sleep.h"
@ -139,14 +140,14 @@ class CpuOveruseDetectorProxy : public OveruseFrameDetector {
  virtual ~CpuOveruseDetectorProxy() {}
  void OnTargetFramerateUpdated(int framerate_fps) override {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    last_target_framerate_fps_ = framerate_fps;
    OveruseFrameDetector::OnTargetFramerateUpdated(framerate_fps);
    framerate_updated_event_.Set();
  }
  int GetLastTargetFramerate() {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    return last_target_framerate_fps_;
  }
@ -155,7 +156,7 @@ class CpuOveruseDetectorProxy : public OveruseFrameDetector {
  rtc::Event* framerate_updated_event() { return &framerate_updated_event_; }
 private:
-  rtc::CriticalSection lock_;
+  Mutex lock_;
  int last_target_framerate_fps_ RTC_GUARDED_BY(lock_);
  rtc::Event framerate_updated_event_;
 };
@ -499,17 +500,17 @@ class AdaptingFrameForwarder : public test::FrameForwarder {
  ~AdaptingFrameForwarder() override {}
  void set_adaptation_enabled(bool enabled) {
-    rtc::CritScope cs(&crit_);
+    MutexLock lock(&mutex_);
    adaptation_enabled_ = enabled;
  }
  bool adaption_enabled() const {
-    rtc::CritScope cs(&crit_);
+    MutexLock lock(&mutex_);
    return adaptation_enabled_;
  }
  rtc::VideoSinkWants last_wants() const {
-    rtc::CritScope cs(&crit_);
+    MutexLock lock(&mutex_);
    return last_wants_;
  }
@ -558,14 +559,14 @@ class AdaptingFrameForwarder : public test::FrameForwarder {
  void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* sink,
                       const rtc::VideoSinkWants& wants) override {
-    rtc::CritScope cs(&crit_);
+    MutexLock lock(&mutex_);
    last_wants_ = sink_wants_locked();
    adapter_.OnSinkWants(wants);
    test::FrameForwarder::AddOrUpdateSinkLocked(sink, wants);
  }
  cricket::VideoAdapter adapter_;
-  bool adaptation_enabled_ RTC_GUARDED_BY(crit_);
+  bool adaptation_enabled_ RTC_GUARDED_BY(mutex_);
-  rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(crit_);
+  rtc::VideoSinkWants last_wants_ RTC_GUARDED_BY(mutex_);
  absl::optional<int> last_width_;
  absl::optional<int> last_height_;
 };
@ -579,30 +580,30 @@ class MockableSendStatisticsProxy : public SendStatisticsProxy {
      : SendStatisticsProxy(clock, config, content_type) {}
  VideoSendStream::Stats GetStats() override {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    if (mock_stats_)
      return *mock_stats_;
    return SendStatisticsProxy::GetStats();
  }
  int GetInputFrameRate() const override {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    if (mock_stats_)
      return mock_stats_->input_frame_rate;
    return SendStatisticsProxy::GetInputFrameRate();
  }
  void SetMockStats(const VideoSendStream::Stats& stats) {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    mock_stats_.emplace(stats);
  }
  void ResetMockStats() {
-    rtc::CritScope cs(&lock_);
+    MutexLock lock(&lock_);
    mock_stats_.reset();
  }
 private:
-  rtc::CriticalSection lock_;
+  mutable Mutex lock_;
  absl::optional<VideoSendStream::Stats> mock_stats_ RTC_GUARDED_BY(lock_);
 };
@ -830,17 +831,17 @@ class VideoStreamEncoderTest : public ::testing::Test {
    TestEncoder() : FakeEncoder(Clock::GetRealTimeClock()) {}
    VideoCodec codec_config() const {
-      rtc::CritScope lock(&crit_sect_);
+      MutexLock lock(&mutex_);
      return config_;
    }
    void BlockNextEncode() {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      block_next_encode_ = true;
    }
    VideoEncoder::EncoderInfo GetEncoderInfo() const override {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      EncoderInfo info;
      if (initialized_ == EncoderState::kInitialized) {
        if (quality_scaling_) {
@ -863,7 +864,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
    int32_t RegisterEncodeCompleteCallback(
        EncodedImageCallback* callback) override {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      encoded_image_callback_ = callback;
      return FakeEncoder::RegisterEncodeCompleteCallback(callback);
    }
@ -872,60 +873,60 @@ class VideoStreamEncoderTest : public ::testing::Test {
    void CheckLastTimeStampsMatch(int64_t ntp_time_ms,
                                  uint32_t timestamp) const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      EXPECT_EQ(timestamp_, timestamp);
      EXPECT_EQ(ntp_time_ms_, ntp_time_ms);
    }
    void SetQualityScaling(bool b) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      quality_scaling_ = b;
    }
    void SetRequestedResolutionAlignment(int requested_resolution_alignment) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      requested_resolution_alignment_ = requested_resolution_alignment;
    }
    void SetIsHardwareAccelerated(bool is_hardware_accelerated) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      is_hardware_accelerated_ = is_hardware_accelerated;
    }
    void SetTemporalLayersSupported(size_t spatial_idx, bool supported) {
      RTC_DCHECK_LT(spatial_idx, kMaxSpatialLayers);
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      temporal_layers_supported_[spatial_idx] = supported;
    }
    void SetResolutionBitrateLimits(
        std::vector<ResolutionBitrateLimits> thresholds) {
-      rtc::CritScope cs(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      resolution_bitrate_limits_ = thresholds;
    }
    void ForceInitEncodeFailure(bool force_failure) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      force_init_encode_failed_ = force_failure;
    }
    void SimulateOvershoot(double rate_factor) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      rate_factor_ = rate_factor;
    }
    uint32_t GetLastFramerate() const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      return last_framerate_;
    }
    VideoFrame::UpdateRect GetLastUpdateRect() const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      return last_update_rect_;
    }
    const std::vector<VideoFrameType>& LastFrameTypes() const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      return last_frame_types_;
    }
@ -934,27 +935,27 @@ class VideoStreamEncoderTest : public ::testing::Test {
          keyframe ? VideoFrameType::kVideoFrameKey
                   : VideoFrameType::kVideoFrameDelta};
      {
-        rtc::CritScope lock(&local_crit_sect_);
+        MutexLock lock(&local_mutex_);
        last_frame_types_ = frame_type;
      }
      FakeEncoder::Encode(input_image, &frame_type);
    }
    void InjectEncodedImage(const EncodedImage& image) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      encoded_image_callback_->OnEncodedImage(image, nullptr, nullptr);
    }
    void InjectEncodedImage(const EncodedImage& image,
                            const CodecSpecificInfo* codec_specific_info,
                            const RTPFragmentationHeader* fragmentation) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      encoded_image_callback_->OnEncodedImage(image, codec_specific_info,
                                              fragmentation);
    }
    void ExpectNullFrame() {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      expect_null_frame_ = true;
    }
@ -966,12 +967,12 @@ class VideoStreamEncoderTest : public ::testing::Test {
    }
    int GetNumEncoderInitializations() const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      return num_encoder_initializations_;
    }
    int GetNumSetRates() const {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      return num_set_rates_;
    }
@ -980,7 +981,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
                   const std::vector<VideoFrameType>* frame_types) override {
      bool block_encode;
      {
-        rtc::CritScope lock(&local_crit_sect_);
+        MutexLock lock(&local_mutex_);
        if (expect_null_frame_) {
          EXPECT_EQ(input_image.timestamp(), 0u);
          EXPECT_EQ(input_image.width(), 1);
@ -1011,7 +1012,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
                       const Settings& settings) override {
      int res = FakeEncoder::InitEncode(config, settings);
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      EXPECT_EQ(initialized_, EncoderState::kUninitialized);
      ++num_encoder_initializations_;
@ -1033,14 +1034,14 @@ class VideoStreamEncoderTest : public ::testing::Test {
    }
    int32_t Release() override {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      EXPECT_NE(initialized_, EncoderState::kUninitialized);
      initialized_ = EncoderState::kUninitialized;
      return FakeEncoder::Release();
    }
    void SetRates(const RateControlParameters& parameters) {
-      rtc::CritScope lock(&local_crit_sect_);
+      MutexLock lock(&local_mutex_);
      num_set_rates_++;
      VideoBitrateAllocation adjusted_rate_allocation;
      for (size_t si = 0; si < kMaxSpatialLayers; ++si) {
@ -1060,43 +1061,42 @@ class VideoStreamEncoderTest : public ::testing::Test {
      FakeEncoder::SetRates(adjusted_paramters);
    }
-    rtc::CriticalSection local_crit_sect_;
+    mutable Mutex local_mutex_;
    enum class EncoderState {
      kUninitialized,
      kInitializationFailed,
      kInitialized
-    } initialized_ RTC_GUARDED_BY(local_crit_sect_) =
+    } initialized_ RTC_GUARDED_BY(local_mutex_) = EncoderState::kUninitialized;
-        EncoderState::kUninitialized;
+    bool block_next_encode_ RTC_GUARDED_BY(local_mutex_) = false;
    bool block_next_encode_ RTC_GUARDED_BY(local_crit_sect_) = false;
    rtc::Event continue_encode_event_;
-    uint32_t timestamp_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    uint32_t timestamp_ RTC_GUARDED_BY(local_mutex_) = 0;
-    int64_t ntp_time_ms_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int64_t ntp_time_ms_ RTC_GUARDED_BY(local_mutex_) = 0;
-    int last_input_width_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_width_ RTC_GUARDED_BY(local_mutex_) = 0;
-    int last_input_height_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int last_input_height_ RTC_GUARDED_BY(local_mutex_) = 0;
-    bool quality_scaling_ RTC_GUARDED_BY(local_crit_sect_) = true;
+    bool quality_scaling_ RTC_GUARDED_BY(local_mutex_) = true;
-    int requested_resolution_alignment_ RTC_GUARDED_BY(local_crit_sect_) = 1;
+    int requested_resolution_alignment_ RTC_GUARDED_BY(local_mutex_) = 1;
-    bool is_hardware_accelerated_ RTC_GUARDED_BY(local_crit_sect_) = false;
+    bool is_hardware_accelerated_ RTC_GUARDED_BY(local_mutex_) = false;
    std::unique_ptr<Vp8FrameBufferController> frame_buffer_controller_
-        RTC_GUARDED_BY(local_crit_sect_);
+        RTC_GUARDED_BY(local_mutex_);
    absl::optional<bool>
        temporal_layers_supported_[kMaxSpatialLayers] RTC_GUARDED_BY(
-            local_crit_sect_);
+            local_mutex_);
-    bool force_init_encode_failed_ RTC_GUARDED_BY(local_crit_sect_) = false;
+    bool force_init_encode_failed_ RTC_GUARDED_BY(local_mutex_) = false;
-    double rate_factor_ RTC_GUARDED_BY(local_crit_sect_) = 1.0;
+    double rate_factor_ RTC_GUARDED_BY(local_mutex_) = 1.0;
-    uint32_t last_framerate_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    uint32_t last_framerate_ RTC_GUARDED_BY(local_mutex_) = 0;
    absl::optional<VideoEncoder::RateControlParameters>
        last_rate_control_settings_;
-    VideoFrame::UpdateRect last_update_rect_
+    VideoFrame::UpdateRect last_update_rect_ RTC_GUARDED_BY(local_mutex_) = {
-        RTC_GUARDED_BY(local_crit_sect_) = {0, 0, 0, 0};
+        0, 0, 0, 0};
    std::vector<VideoFrameType> last_frame_types_;
    bool expect_null_frame_ = false;
-    EncodedImageCallback* encoded_image_callback_
+    EncodedImageCallback* encoded_image_callback_ RTC_GUARDED_BY(local_mutex_) =
-        RTC_GUARDED_BY(local_crit_sect_) = nullptr;
+        nullptr;
    NiceMock<MockFecControllerOverride> fec_controller_override_;
-    int num_encoder_initializations_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int num_encoder_initializations_ RTC_GUARDED_BY(local_mutex_) = 0;
    std::vector<ResolutionBitrateLimits> resolution_bitrate_limits_
-        RTC_GUARDED_BY(local_crit_sect_);
+        RTC_GUARDED_BY(local_mutex_);
-    int num_set_rates_ RTC_GUARDED_BY(local_crit_sect_) = 0;
+    int num_set_rates_ RTC_GUARDED_BY(local_mutex_) = 0;
  };
  class TestSink : public VideoStreamEncoder::EncoderSink {
@ -1115,7 +1115,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
      if (!encoded_frame_event_.Wait(timeout_ms))
        return false;
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        timestamp = last_timestamp_;
      }
      test_encoder_->CheckLastTimeStampsMatch(expected_ntp_time, timestamp);
@ -1133,7 +1133,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
      uint32_t width = 0;
      uint32_t height = 0;
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        width = last_width_;
        height = last_height_;
      }
@ -1145,7 +1145,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
      int width = 0;
      int height = 0;
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        width = last_width_;
        height = last_height_;
      }
@ -1156,7 +1156,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
    void CheckLastFrameRotationMatches(VideoRotation expected_rotation) {
      VideoRotation rotation;
      {
-        rtc::CritScope lock(&crit_);
+        MutexLock lock(&mutex_);
        rotation = last_rotation_;
      }
      EXPECT_EQ(expected_rotation, rotation);
@ -1169,37 +1169,37 @@ class VideoStreamEncoderTest : public ::testing::Test {
    }
    void SetExpectNoFrames() {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      expect_frames_ = false;
    }
    int number_of_reconfigurations() const {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return number_of_reconfigurations_;
    }
    int last_min_transmit_bitrate() const {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return min_transmit_bitrate_bps_;
    }
    void SetNumExpectedLayers(size_t num_layers) {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      num_expected_layers_ = num_layers;
    }
    int64_t GetLastCaptureTimeMs() const {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return last_capture_time_ms_;
    }
    std::vector<uint8_t> GetLastEncodedImageData() {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return std::move(last_encoded_image_data_);
    }
    RTPFragmentationHeader GetLastFragmentation() {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return std::move(last_fragmentation_);
    }
@ -1208,7 +1208,7 @@ class VideoStreamEncoderTest : public ::testing::Test {
        const EncodedImage& encoded_image,
        const CodecSpecificInfo* codec_specific_info,
        const RTPFragmentationHeader* fragmentation) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      EXPECT_TRUE(expect_frames_);
      last_encoded_image_data_ = std::vector<uint8_t>(
          encoded_image.data(), encoded_image.data() + encoded_image.size());
@ -1237,12 +1237,12 @@ class VideoStreamEncoderTest : public ::testing::Test {
        bool is_svc,
        VideoEncoderConfig::ContentType content_type,
        int min_transmit_bitrate_bps) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      ++number_of_reconfigurations_;
      min_transmit_bitrate_bps_ = min_transmit_bitrate_bps;
    }
-    rtc::CriticalSection crit_;
+    mutable Mutex mutex_;
    TestEncoder* test_encoder_;
    rtc::Event encoded_frame_event_;
    std::vector<uint8_t> last_encoded_image_data_;
@ -1268,21 +1268,21 @@ class VideoStreamEncoderTest : public ::testing::Test {
    std::unique_ptr<VideoBitrateAllocator> CreateVideoBitrateAllocator(
        const VideoCodec& codec) override {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      codec_config_ = codec;
      return bitrate_allocator_factory_->CreateVideoBitrateAllocator(codec);
    }
    VideoCodec codec_config() const {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
      return codec_config_;
    }
   private:
    std::unique_ptr<VideoBitrateAllocatorFactory> bitrate_allocator_factory_;
-    rtc::CriticalSection crit_;
+    mutable Mutex mutex_;
-    VideoCodec codec_config_ RTC_GUARDED_BY(crit_);
+    VideoCodec codec_config_ RTC_GUARDED_BY(mutex_);
  };
  VideoSendStream::Config video_send_config_;