diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index d2826d5ee1..78f6affe84 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -90,6 +90,7 @@ rtc_library("audio") {
     "../rtc_base:rtc_task_queue",
     "../rtc_base:safe_minmax",
     "../rtc_base/experiments:field_trial_parser",
+    "../rtc_base/synchronization:mutex",
     "../rtc_base/synchronization:sequence_checker",
     "../rtc_base/task_utils:to_queued_task",
     "../system_wrappers",
diff --git a/audio/audio_level.cc b/audio/audio_level.cc
index 06702b4c0d..7874b73f1c 100644
--- a/audio/audio_level.cc
+++ b/audio/audio_level.cc
@@ -22,7 +22,7 @@ AudioLevel::AudioLevel()
 AudioLevel::~AudioLevel() {}
 
 void AudioLevel::Reset() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   abs_max_ = 0;
   count_ = 0;
   current_level_full_range_ = 0;
@@ -31,24 +31,24 @@ void AudioLevel::Reset() {
 }
 
 int16_t AudioLevel::LevelFullRange() const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return current_level_full_range_;
 }
 
 void AudioLevel::ResetLevelFullRange() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   abs_max_ = 0;
   count_ = 0;
   current_level_full_range_ = 0;
 }
 
 double AudioLevel::TotalEnergy() const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return total_energy_;
 }
 
 double AudioLevel::TotalDuration() const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return total_duration_;
 }
 
@@ -63,7 +63,7 @@ void AudioLevel::ComputeLevel(const AudioFrame& audioFrame, double duration) {
 
   // Protect member access using a lock since this method is called on a
   // dedicated audio thread in the RecordedDataIsAvailable() callback.
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
 
   if (abs_value > abs_max_)
     abs_max_ = abs_value;
diff --git a/audio/audio_level.h b/audio/audio_level.h
index 430edb1703..acd1231fe2 100644
--- a/audio/audio_level.h
+++ b/audio/audio_level.h
@@ -11,7 +11,7 @@
 #ifndef AUDIO_AUDIO_LEVEL_H_
 #define AUDIO_AUDIO_LEVEL_H_
 
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
@@ -59,14 +59,14 @@ class AudioLevel {
  private:
   enum { kUpdateFrequency = 10 };
 
-  rtc::CriticalSection crit_sect_;
+  mutable Mutex mutex_;
 
-  int16_t abs_max_ RTC_GUARDED_BY(crit_sect_);
-  int16_t count_ RTC_GUARDED_BY(crit_sect_);
-  int16_t current_level_full_range_ RTC_GUARDED_BY(crit_sect_);
+  int16_t abs_max_ RTC_GUARDED_BY(mutex_);
+  int16_t count_ RTC_GUARDED_BY(mutex_);
+  int16_t current_level_full_range_ RTC_GUARDED_BY(mutex_);
 
-  double total_energy_ RTC_GUARDED_BY(crit_sect_) = 0.0;
-  double total_duration_ RTC_GUARDED_BY(crit_sect_) = 0.0;
+  double total_energy_ RTC_GUARDED_BY(mutex_) = 0.0;
+  double total_duration_ RTC_GUARDED_BY(mutex_) = 0.0;
 };
 
 }  // namespace voe
diff --git a/audio/audio_send_stream.cc b/audio/audio_send_stream.cc
index 301e42d07c..1856902d5e 100644
--- a/audio/audio_send_stream.cc
+++ b/audio/audio_send_stream.cc
@@ -347,7 +347,7 @@ void AudioSendStream::ConfigureStream(
 
   // Set currently known overhead (used in ANA, opus only).
   {
-    rtc::CritScope cs(&overhead_per_packet_lock_);
+    MutexLock lock(&overhead_per_packet_lock_);
     UpdateOverheadForEncoder();
   }
 
@@ -422,7 +422,7 @@ void AudioSendStream::SendAudioData(std::unique_ptr<AudioFrame> audio_frame) {
     // TODO(https://crbug.com/webrtc/10771): All "media-source" related stats
     // should move from send-streams to the local audio sources or tracks; a
     // send-stream should not be required to read the microphone audio levels.
-    rtc::CritScope cs(&audio_level_lock_);
+    MutexLock lock(&audio_level_lock_);
     audio_level_.ComputeLevel(*audio_frame, duration);
   }
   channel_send_->ProcessAndEncodeAudio(std::move(audio_frame));
@@ -488,7 +488,7 @@ webrtc::AudioSendStream::Stats AudioSendStream::GetStats(
   }
 
   {
-    rtc::CritScope cs(&audio_level_lock_);
+    MutexLock lock(&audio_level_lock_);
     stats.audio_level = audio_level_.LevelFullRange();
     stats.total_input_energy = audio_level_.TotalEnergy();
     stats.total_input_duration = audio_level_.TotalDuration();
@@ -513,7 +513,7 @@ void AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   worker_queue_->PostTask([&]() {
     // Poll if overhead has changed, which it can do if ack triggers us to stop
     // sending mid/rid.
-    rtc::CritScope cs(&overhead_per_packet_lock_);
+    MutexLock lock(&overhead_per_packet_lock_);
     UpdateOverheadForEncoder();
   });
 }
@@ -538,7 +538,7 @@ uint32_t AudioSendStream::OnBitrateUpdated(BitrateAllocationUpdate update) {
 void AudioSendStream::SetTransportOverhead(
     int transport_overhead_per_packet_bytes) {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope cs(&overhead_per_packet_lock_);
+  MutexLock lock(&overhead_per_packet_lock_);
   transport_overhead_per_packet_bytes_ = transport_overhead_per_packet_bytes;
   UpdateOverheadForEncoder();
 }
@@ -570,7 +570,7 @@ void AudioSendStream::UpdateOverheadForEncoder() {
 }
 
 size_t AudioSendStream::TestOnlyGetPerPacketOverheadBytes() const {
-  rtc::CritScope cs(&overhead_per_packet_lock_);
+  MutexLock lock(&overhead_per_packet_lock_);
   return GetPerPacketOverheadBytes();
 }
 
@@ -670,7 +670,7 @@ bool AudioSendStream::SetupSendCodec(const Config& new_config) {
   // Set currently known overhead (used in ANA, opus only).
   // If overhead changes later, it will be updated in UpdateOverheadForEncoder.
   {
-    rtc::CritScope cs(&overhead_per_packet_lock_);
+    MutexLock lock(&overhead_per_packet_lock_);
     size_t overhead = GetPerPacketOverheadBytes();
     if (overhead > 0) {
       encoder->OnReceivedOverhead(overhead);
diff --git a/audio/audio_send_stream.h b/audio/audio_send_stream.h
index 13166d47e7..bb2e7b1e3a 100644
--- a/audio/audio_send_stream.h
+++ b/audio/audio_send_stream.h
@@ -24,6 +24,7 @@
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/experiments/struct_parameters_parser.h"
 #include "rtc_base/race_checker.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread_checker.h"
 
@@ -166,7 +167,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
   int encoder_sample_rate_hz_ = 0;
   size_t encoder_num_channels_ = 0;
   bool sending_ = false;
-  rtc::CriticalSection audio_level_lock_;
+  mutable Mutex audio_level_lock_;
   // Keeps track of audio level, total audio energy and total samples duration.
   // https://w3c.github.io/webrtc-stats/#dom-rtcaudiohandlerstats-totalaudioenergy
   webrtc::voe::AudioLevel audio_level_;
@@ -194,7 +195,7 @@ class AudioSendStream final : public webrtc::AudioSendStream,
       const std::vector<RtpExtension>& extensions);
   static int TransportSeqNumId(const Config& config);
 
-  rtc::CriticalSection overhead_per_packet_lock_;
+  mutable Mutex overhead_per_packet_lock_;
   size_t overhead_per_packet_ RTC_GUARDED_BY(overhead_per_packet_lock_) = 0;
 
   // Current transport overhead (ICE, TURN, etc.)
diff --git a/audio/audio_transport_impl.cc b/audio/audio_transport_impl.cc
index 7648fb948f..11b37ffcf1 100644
--- a/audio/audio_transport_impl.cc
+++ b/audio/audio_transport_impl.cc
@@ -118,7 +118,7 @@ int32_t AudioTransportImpl::RecordedDataIsAvailable(
   size_t send_num_channels = 0;
   bool swap_stereo_channels = false;
   {
-    rtc::CritScope lock(&capture_lock_);
+    MutexLock lock(&capture_lock_);
     send_sample_rate_hz = send_sample_rate_hz_;
     send_num_channels = send_num_channels_;
     swap_stereo_channels = swap_stereo_channels_;
@@ -149,7 +149,7 @@ int32_t AudioTransportImpl::RecordedDataIsAvailable(
   // Copy frame and push to each sending stream. The copy is required since an
   // encoding task will be posted internally to each stream.
   {
-    rtc::CritScope lock(&capture_lock_);
+    MutexLock lock(&capture_lock_);
     typing_noise_detected_ = typing_detected;
 
     RTC_DCHECK_GT(audio_frame->samples_per_channel_, 0);
@@ -237,19 +237,19 @@ void AudioTransportImpl::PullRenderData(int bits_per_sample,
 void AudioTransportImpl::UpdateAudioSenders(std::vector<AudioSender*> senders,
                                             int send_sample_rate_hz,
                                             size_t send_num_channels) {
-  rtc::CritScope lock(&capture_lock_);
+  MutexLock lock(&capture_lock_);
   audio_senders_ = std::move(senders);
   send_sample_rate_hz_ = send_sample_rate_hz;
   send_num_channels_ = send_num_channels;
 }
 
 void AudioTransportImpl::SetStereoChannelSwapping(bool enable) {
-  rtc::CritScope lock(&capture_lock_);
+  MutexLock lock(&capture_lock_);
   swap_stereo_channels_ = enable;
 }
 
 bool AudioTransportImpl::typing_noise_detected() const {
-  rtc::CritScope lock(&capture_lock_);
+  MutexLock lock(&capture_lock_);
   return typing_noise_detected_;
 }
 }  // namespace webrtc
diff --git a/audio/audio_transport_impl.h b/audio/audio_transport_impl.h
index 2d9b4cf3a1..1643a29970 100644
--- a/audio/audio_transport_impl.h
+++ b/audio/audio_transport_impl.h
@@ -20,7 +20,7 @@
 #include "modules/audio_processing/include/audio_processing.h"
 #include "modules/audio_processing/typing_detection.h"
 #include "rtc_base/constructor_magic.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_annotations.h"
 
 namespace webrtc {
@@ -71,7 +71,7 @@ class AudioTransportImpl : public AudioTransport {
   AudioProcessing* audio_processing_ = nullptr;
 
   // Capture side.
-  rtc::CriticalSection capture_lock_;
+  mutable Mutex capture_lock_;
   std::vector<AudioSender*> audio_senders_ RTC_GUARDED_BY(capture_lock_);
   int send_sample_rate_hz_ RTC_GUARDED_BY(capture_lock_) = 8000;
   size_t send_num_channels_ RTC_GUARDED_BY(capture_lock_) = 1;
diff --git a/audio/channel_receive.cc b/audio/channel_receive.cc
index 34b6d097af..9cbaabbbb0 100644
--- a/audio/channel_receive.cc
+++ b/audio/channel_receive.cc
@@ -40,12 +40,12 @@
 #include "modules/rtp_rtcp/source/rtp_rtcp_impl2.h"
 #include "modules/utility/include/process_thread.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/critical_section.h"
 #include "rtc_base/format_macros.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "rtc_base/race_checker.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/thread_checker.h"
 #include "rtc_base/time_utils.h"
 #include "system_wrappers/include/metrics.h"
@@ -188,7 +188,7 @@ class ChannelReceive : public ChannelReceiveInterface {
       rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer);
 
   bool Playing() const {
-    rtc::CritScope lock(&playing_lock_);
+    MutexLock lock(&playing_lock_);
     return playing_;
   }
 
@@ -204,10 +204,10 @@ class ChannelReceive : public ChannelReceiveInterface {
   // audio thread to another, but access is still sequential.
   rtc::RaceChecker audio_thread_race_checker_;
   rtc::RaceChecker video_capture_thread_race_checker_;
-  rtc::CriticalSection _callbackCritSect;
-  rtc::CriticalSection volume_settings_critsect_;
+  Mutex callback_mutex_;
+  Mutex volume_settings_mutex_;
 
-  rtc::CriticalSection playing_lock_;
+  mutable Mutex playing_lock_;
   bool playing_ RTC_GUARDED_BY(&playing_lock_) = false;
 
   RtcEventLog* const event_log_;
@@ -221,7 +221,7 @@ class ChannelReceive : public ChannelReceiveInterface {
 
   // 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_
@@ -237,7 +237,7 @@ class ChannelReceive : public ChannelReceiveInterface {
   // Timestamp of the audio pulled from NetEq.
   absl::optional<uint32_t> jitter_buffer_playout_timestamp_;
 
-  rtc::CriticalSection video_sync_lock_;
+  mutable Mutex video_sync_lock_;
   uint32_t playout_timestamp_rtp_ RTC_GUARDED_BY(video_sync_lock_);
   absl::optional<int64_t> playout_timestamp_rtp_time_ms_
       RTC_GUARDED_BY(video_sync_lock_);
@@ -247,7 +247,7 @@ class ChannelReceive : public ChannelReceiveInterface {
   absl::optional<int64_t> playout_timestamp_ntp_time_ms_
       RTC_GUARDED_BY(video_sync_lock_);
 
-  rtc::CriticalSection ts_stats_lock_;
+  mutable Mutex ts_stats_lock_;
 
   std::unique_ptr<rtc::TimestampWrapAroundHandler> rtp_ts_wraparound_handler_;
   // The rtp timestamp of the first played out audio frame.
@@ -259,10 +259,10 @@ class ChannelReceive : public ChannelReceiveInterface {
   // uses
   ProcessThread* _moduleProcessThreadPtr;
   AudioDeviceModule* _audioDeviceModulePtr;
-  float _outputGain RTC_GUARDED_BY(volume_settings_critsect_);
+  float _outputGain RTC_GUARDED_BY(volume_settings_mutex_);
 
   // An associated send channel.
-  rtc::CriticalSection assoc_send_channel_lock_;
+  mutable Mutex assoc_send_channel_lock_;
   const ChannelSendInterface* associated_send_channel_
       RTC_GUARDED_BY(assoc_send_channel_lock_);
 
@@ -359,7 +359,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
     // scaling/panning, as that applies to the mix operation.
     // External recipients of the audio (e.g. via AudioTrack), will do their
     // own mixing/dynamic processing.
-    rtc::CritScope cs(&_callbackCritSect);
+    MutexLock lock(&callback_mutex_);
     if (audio_sink_) {
       AudioSinkInterface::Data data(
           audio_frame->data(), audio_frame->samples_per_channel_,
@@ -371,7 +371,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
 
   float output_gain = 1.0f;
   {
-    rtc::CritScope cs(&volume_settings_critsect_);
+    MutexLock lock(&volume_settings_mutex_);
     output_gain = _outputGain;
   }
 
@@ -403,7 +403,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
         (GetRtpTimestampRateHz() / 1000);
 
     {
-      rtc::CritScope lock(&ts_stats_lock_);
+      MutexLock lock(&ts_stats_lock_);
       // Compute ntp time.
       audio_frame->ntp_time_ms_ =
           ntp_estimator_.Estimate(audio_frame->timestamp_);
@@ -421,7 +421,7 @@ AudioMixer::Source::AudioFrameInfo ChannelReceive::GetAudioFrameWithInfo(
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.TargetJitterBufferDelayMs",
                               acm_receiver_.TargetDelayMs());
     const int jitter_buffer_delay = acm_receiver_.FilteredCurrentDelayMs();
-    rtc::CritScope lock(&video_sync_lock_);
+    MutexLock lock(&video_sync_lock_);
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverDelayEstimateMs",
                               jitter_buffer_delay + playout_delay_ms_);
     RTC_HISTOGRAM_COUNTS_1000("WebRTC.Audio.ReceiverJitterBufferDelayMs",
@@ -532,19 +532,19 @@ ChannelReceive::~ChannelReceive() {
 
 void ChannelReceive::SetSink(AudioSinkInterface* sink) {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope cs(&_callbackCritSect);
+  MutexLock lock(&callback_mutex_);
   audio_sink_ = sink;
 }
 
 void ChannelReceive::StartPlayout() {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&playing_lock_);
+  MutexLock lock(&playing_lock_);
   playing_ = true;
 }
 
 void ChannelReceive::StopPlayout() {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&playing_lock_);
+  MutexLock lock(&playing_lock_);
   playing_ = false;
   _outputAudioLevel.ResetLevelFullRange();
 }
@@ -570,7 +570,7 @@ void ChannelReceive::OnRtpPacket(const RtpPacketReceived& packet) {
   int64_t now_ms = rtc::TimeMillis();
 
   {
-    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;
   }
@@ -677,7 +677,7 @@ void ChannelReceive::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
   }
 
   {
-    rtc::CritScope lock(&ts_stats_lock_);
+    MutexLock lock(&ts_stats_lock_);
     ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
   }
 }
@@ -699,7 +699,7 @@ double ChannelReceive::GetTotalOutputDuration() const {
 
 void ChannelReceive::SetChannelOutputVolumeScaling(float scaling) {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope cs(&volume_settings_critsect_);
+  MutexLock lock(&volume_settings_mutex_);
   _outputGain = scaling;
 }
 
@@ -759,7 +759,7 @@ CallReceiveStatistics ChannelReceive::GetRTCPStatistics() const {
 
   // --- Timestamps
   {
-    rtc::CritScope lock(&ts_stats_lock_);
+    MutexLock lock(&ts_stats_lock_);
     stats.capture_start_ntp_time_ms_ = capture_start_ntp_time_ms_;
   }
   return stats;
@@ -787,7 +787,7 @@ int ChannelReceive::ResendPackets(const uint16_t* sequence_numbers,
 void ChannelReceive::SetAssociatedSendChannel(
     const ChannelSendInterface* channel) {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&assoc_send_channel_lock_);
+  MutexLock lock(&assoc_send_channel_lock_);
   associated_send_channel_ = channel;
 }
 
@@ -818,7 +818,7 @@ AudioDecodingCallStats ChannelReceive::GetDecodingCallStatistics() const {
 uint32_t ChannelReceive::GetDelayEstimate() const {
   RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
              module_process_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&video_sync_lock_);
+  MutexLock lock(&video_sync_lock_);
   return acm_receiver_.FilteredCurrentDelayMs() + playout_delay_ms_;
 }
 
@@ -838,7 +838,7 @@ bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
                                             int64_t* time_ms) const {
   RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
   {
-    rtc::CritScope lock(&video_sync_lock_);
+    MutexLock lock(&video_sync_lock_);
     if (!playout_timestamp_rtp_time_ms_)
       return false;
     *rtp_timestamp = playout_timestamp_rtp_;
@@ -850,7 +850,7 @@ bool ChannelReceive::GetPlayoutRtpTimestamp(uint32_t* rtp_timestamp,
 void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
                                                        int64_t time_ms) {
   RTC_DCHECK_RUNS_SERIALIZED(&video_capture_thread_race_checker_);
-  rtc::CritScope lock(&video_sync_lock_);
+  MutexLock lock(&video_sync_lock_);
   playout_timestamp_ntp_ = ntp_timestamp_ms;
   playout_timestamp_ntp_time_ms_ = time_ms;
 }
@@ -858,7 +858,7 @@ void ChannelReceive::SetEstimatedPlayoutNtpTimestampMs(int64_t ntp_timestamp_ms,
 absl::optional<int64_t>
 ChannelReceive::GetCurrentEstimatedPlayoutNtpTimestampMs(int64_t now_ms) const {
   RTC_DCHECK(worker_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&video_sync_lock_);
+  MutexLock lock(&video_sync_lock_);
   if (!playout_timestamp_ntp_ || !playout_timestamp_ntp_time_ms_)
     return absl::nullopt;
 
@@ -883,7 +883,7 @@ absl::optional<Syncable::Info> ChannelReceive::GetSyncInfo() const {
     return absl::nullopt;
   }
   {
-    rtc::CritScope cs(&sync_info_lock_);
+    MutexLock lock(&sync_info_lock_);
     if (!last_received_rtp_timestamp_ || !last_received_rtp_system_time_ms_) {
       return absl::nullopt;
     }
@@ -917,7 +917,7 @@ void ChannelReceive::UpdatePlayoutTimestamp(bool rtcp, int64_t now_ms) {
   playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
 
   {
-    rtc::CritScope lock(&video_sync_lock_);
+    MutexLock lock(&video_sync_lock_);
     if (!rtcp && playout_timestamp != playout_timestamp_rtp_) {
       playout_timestamp_rtp_ = playout_timestamp;
       playout_timestamp_rtp_time_ms_ = now_ms;
@@ -947,7 +947,7 @@ int64_t ChannelReceive::GetRTT() const {
   // TODO(nisse): Could we check the return value from the ->RTT() call below,
   // instead of checking if we have any report blocks?
   if (report_blocks.empty()) {
-    rtc::CritScope lock(&assoc_send_channel_lock_);
+    MutexLock lock(&assoc_send_channel_lock_);
     // Tries to get RTT from an associated channel.
     if (!associated_send_channel_) {
       return 0;
diff --git a/audio/channel_send.cc b/audio/channel_send.cc
index 2e7ca72c0d..80e7ab2f47 100644
--- a/audio/channel_send.cc
+++ b/audio/channel_send.cc
@@ -39,6 +39,7 @@
 #include "rtc_base/numerics/safe_conversions.h"
 #include "rtc_base/race_checker.h"
 #include "rtc_base/rate_limiter.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread_checker.h"
 #include "rtc_base/time_utils.h"
@@ -186,7 +187,7 @@ class ChannelSend : public ChannelSendInterface,
   // audio thread to another, but access is still sequential.
   rtc::RaceChecker audio_thread_race_checker_;
 
-  rtc::CriticalSection volume_settings_critsect_;
+  mutable Mutex volume_settings_mutex_;
 
   bool sending_ RTC_GUARDED_BY(&worker_thread_checker_) = false;
 
@@ -201,7 +202,7 @@ class ChannelSend : public ChannelSendInterface,
   // uses
   ProcessThread* const _moduleProcessThreadPtr;
   RmsLevel rms_level_ RTC_GUARDED_BY(encoder_queue_);
-  bool input_mute_ RTC_GUARDED_BY(volume_settings_critsect_);
+  bool input_mute_ RTC_GUARDED_BY(volume_settings_mutex_);
   bool previous_frame_muted_ RTC_GUARDED_BY(encoder_queue_);
   // VoeRTP_RTCP
   // TODO(henrika): can today be accessed on the main thread and on the
@@ -234,8 +235,8 @@ class ChannelSend : public ChannelSendInterface,
   rtc::scoped_refptr<ChannelSendFrameTransformerDelegate>
       frame_transformer_delegate_ RTC_GUARDED_BY(encoder_queue_);
 
-  rtc::CriticalSection bitrate_crit_section_;
-  int configured_bitrate_bps_ RTC_GUARDED_BY(bitrate_crit_section_) = 0;
+  mutable Mutex bitrate_mutex_;
+  int configured_bitrate_bps_ RTC_GUARDED_BY(bitrate_mutex_) = 0;
 
   // Defined last to ensure that there are no running tasks when the other
   // members are destroyed.
@@ -250,20 +251,20 @@ class RtpPacketSenderProxy : public RtpPacketSender {
 
   void SetPacketPacer(RtpPacketSender* rtp_packet_pacer) {
     RTC_DCHECK(thread_checker_.IsCurrent());
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
     rtp_packet_pacer_ = rtp_packet_pacer;
   }
 
   void EnqueuePackets(
       std::vector<std::unique_ptr<RtpPacketToSend>> packets) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
     rtp_packet_pacer_->EnqueuePackets(std::move(packets));
   }
 
  private:
   rtc::ThreadChecker thread_checker_;
-  rtc::CriticalSection crit_;
-  RtpPacketSender* rtp_packet_pacer_ RTC_GUARDED_BY(&crit_);
+  Mutex mutex_;
+  RtpPacketSender* rtp_packet_pacer_ RTC_GUARDED_BY(&mutex_);
 };
 
 class VoERtcpObserver : public RtcpBandwidthObserver {
@@ -273,12 +274,12 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
   ~VoERtcpObserver() override {}
 
   void SetBandwidthObserver(RtcpBandwidthObserver* bandwidth_observer) {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
     bandwidth_observer_ = bandwidth_observer;
   }
 
   void OnReceivedEstimatedBitrate(uint32_t bitrate) override {
-    rtc::CritScope lock(&crit_);
+    MutexLock lock(&mutex_);
     if (bandwidth_observer_) {
       bandwidth_observer_->OnReceivedEstimatedBitrate(bitrate);
     }
@@ -288,7 +289,7 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
                                     int64_t rtt,
                                     int64_t now_ms) override {
     {
-      rtc::CritScope lock(&crit_);
+      MutexLock lock(&mutex_);
       if (bandwidth_observer_) {
         bandwidth_observer_->OnReceivedRtcpReceiverReport(report_blocks, rtt,
                                                           now_ms);
@@ -336,8 +337,8 @@ class VoERtcpObserver : public RtcpBandwidthObserver {
   ChannelSend* owner_;
   // Maps remote side ssrc to extended highest sequence number received.
   std::map<uint32_t, uint32_t> extended_max_sequence_number_;
-  rtc::CriticalSection crit_;
-  RtcpBandwidthObserver* bandwidth_observer_ RTC_GUARDED_BY(crit_);
+  Mutex mutex_;
+  RtcpBandwidthObserver* bandwidth_observer_ RTC_GUARDED_BY(mutex_);
 };
 
 int32_t ChannelSend::SendData(AudioFrameType frameType,
@@ -606,7 +607,7 @@ void ChannelSend::OnBitrateAllocation(BitrateAllocationUpdate update) {
   // rules.
   // RTC_DCHECK(worker_thread_checker_.IsCurrent() ||
   //            module_process_thread_checker_.IsCurrent());
-  rtc::CritScope lock(&bitrate_crit_section_);
+  MutexLock lock(&bitrate_mutex_);
 
   CallEncoder([&](AudioEncoder* encoder) {
     encoder->OnReceivedUplinkAllocation(update);
@@ -616,7 +617,7 @@ void ChannelSend::OnBitrateAllocation(BitrateAllocationUpdate update) {
 }
 
 int ChannelSend::GetBitrate() const {
-  rtc::CritScope lock(&bitrate_crit_section_);
+  MutexLock lock(&bitrate_mutex_);
   return configured_bitrate_bps_;
 }
 
@@ -651,12 +652,12 @@ void ChannelSend::ReceivedRTCPPacket(const uint8_t* data, size_t length) {
 
 void ChannelSend::SetInputMute(bool enable) {
   RTC_DCHECK_RUN_ON(&worker_thread_checker_);
-  rtc::CritScope cs(&volume_settings_critsect_);
+  MutexLock lock(&volume_settings_mutex_);
   input_mute_ = enable;
 }
 
 bool ChannelSend::InputMute() const {
-  rtc::CritScope cs(&volume_settings_critsect_);
+  MutexLock lock(&volume_settings_mutex_);
   return input_mute_;
 }
 
diff --git a/audio/channel_send_frame_transformer_delegate.cc b/audio/channel_send_frame_transformer_delegate.cc
index 53b573eb8b..72a459d897 100644
--- a/audio/channel_send_frame_transformer_delegate.cc
+++ b/audio/channel_send_frame_transformer_delegate.cc
@@ -77,7 +77,7 @@ void ChannelSendFrameTransformerDelegate::Reset() {
   frame_transformer_->UnregisterTransformedFrameCallback();
   frame_transformer_ = nullptr;
 
-  rtc::CritScope lock(&send_lock_);
+  MutexLock lock(&send_lock_);
   send_frame_callback_ = SendFrameCallback();
 }
 
@@ -97,7 +97,7 @@ void ChannelSendFrameTransformerDelegate::Transform(
 
 void ChannelSendFrameTransformerDelegate::OnTransformedFrame(
     std::unique_ptr<TransformableFrameInterface> frame) {
-  rtc::CritScope lock(&send_lock_);
+  MutexLock lock(&send_lock_);
   if (!send_frame_callback_)
     return;
   rtc::scoped_refptr<ChannelSendFrameTransformerDelegate> delegate = this;
@@ -109,7 +109,7 @@ void ChannelSendFrameTransformerDelegate::OnTransformedFrame(
 
 void ChannelSendFrameTransformerDelegate::SendFrame(
     std::unique_ptr<TransformableFrameInterface> frame) const {
-  rtc::CritScope lock(&send_lock_);
+  MutexLock lock(&send_lock_);
   RTC_DCHECK_RUN_ON(encoder_queue_);
   if (!send_frame_callback_)
     return;
diff --git a/audio/channel_send_frame_transformer_delegate.h b/audio/channel_send_frame_transformer_delegate.h
index 5added7b31..531d1bc110 100644
--- a/audio/channel_send_frame_transformer_delegate.h
+++ b/audio/channel_send_frame_transformer_delegate.h
@@ -16,7 +16,7 @@
 #include "api/frame_transformer_interface.h"
 #include "modules/audio_coding/include/audio_coding_module_typedefs.h"
 #include "rtc_base/buffer.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/task_queue.h"
 
@@ -72,7 +72,7 @@ class ChannelSendFrameTransformerDelegate : public TransformedFrameCallback {
   ~ChannelSendFrameTransformerDelegate() override = default;
 
  private:
-  rtc::CriticalSection send_lock_;
+  mutable Mutex send_lock_;
   SendFrameCallback send_frame_callback_ RTC_GUARDED_BY(send_lock_);
   rtc::scoped_refptr<FrameTransformerInterface> frame_transformer_;
   rtc::TaskQueue* encoder_queue_ RTC_GUARDED_BY(send_lock_);
diff --git a/audio/voip/BUILD.gn b/audio/voip/BUILD.gn
index 84a0ad7ab0..52f9d07f17 100644
--- a/audio/voip/BUILD.gn
+++ b/audio/voip/BUILD.gn
@@ -26,6 +26,7 @@ rtc_library("voip_core") {
     "../../modules/utility:utility",
     "../../rtc_base:criticalsection",
     "../../rtc_base:logging",
+    "../../rtc_base/synchronization:mutex",
   ]
   absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
@@ -74,6 +75,7 @@ rtc_library("audio_ingress") {
     "../../rtc_base:logging",
     "../../rtc_base:safe_minmax",
     "../../rtc_base:timeutils",
+    "../../rtc_base/synchronization:mutex",
     "../utility:audio_frame_operations",
   ]
 }
@@ -95,6 +97,7 @@ rtc_library("audio_egress") {
     "../../rtc_base:rtc_task_queue",
     "../../rtc_base:thread_checker",
     "../../rtc_base:timeutils",
+    "../../rtc_base/synchronization:mutex",
     "../utility:audio_frame_operations",
   ]
 }
diff --git a/audio/voip/audio_egress.h b/audio/voip/audio_egress.h
index 20b0bac02f..8ec048f915 100644
--- a/audio/voip/audio_egress.h
+++ b/audio/voip/audio_egress.h
@@ -22,6 +22,7 @@
 #include "modules/rtp_rtcp/include/report_block_data.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
 #include "modules/rtp_rtcp/source/rtp_sender_audio.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/task_queue.h"
 #include "rtc_base/thread_checker.h"
 #include "rtc_base/time_utils.h"
@@ -72,7 +73,7 @@ class AudioEgress : public AudioSender, public AudioPacketizationCallback {
   // Retrieve current encoder format info. This returns encoder format set
   // by SetEncoder() and if encoder is not set, this will return nullopt.
   absl::optional<SdpAudioFormat> GetEncoderFormat() const {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     return encoder_format_;
   }
 
@@ -99,11 +100,11 @@ class AudioEgress : public AudioSender, public AudioPacketizationCallback {
 
  private:
   void SetEncoderFormat(const SdpAudioFormat& encoder_format) {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     encoder_format_ = encoder_format;
   }
 
-  rtc::CriticalSection lock_;
+  mutable Mutex lock_;
 
   // Current encoder format selected by caller.
   absl::optional<SdpAudioFormat> encoder_format_ RTC_GUARDED_BY(lock_);
diff --git a/audio/voip/audio_ingress.cc b/audio/voip/audio_ingress.cc
index 68864eb2e1..560055d4f4 100644
--- a/audio/voip/audio_ingress.cc
+++ b/audio/voip/audio_ingress.cc
@@ -17,7 +17,6 @@
 #include "api/audio_codecs/audio_format.h"
 #include "audio/utility/audio_frame_operations.h"
 #include "modules/audio_coding/include/audio_coding_module.h"
-#include "rtc_base/critical_section.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_minmax.h"
 
@@ -83,7 +82,7 @@ AudioMixer::Source::AudioFrameInfo AudioIngress::GetAudioFrameWithInfo(
     // Compute elapsed and NTP times.
     int64_t unwrap_timestamp;
     {
-      rtc::CritScope lock(&lock_);
+      MutexLock lock(&lock_);
       unwrap_timestamp =
           timestamp_wrap_handler_.Unwrap(audio_frame->timestamp_);
       audio_frame->ntp_time_ms_ =
@@ -107,7 +106,7 @@ AudioMixer::Source::AudioFrameInfo AudioIngress::GetAudioFrameWithInfo(
 void AudioIngress::SetReceiveCodecs(
     const std::map<int, SdpAudioFormat>& codecs) {
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     for (const auto& kv : codecs) {
       receive_codec_info_[kv.first] = kv.second.clockrate_hz;
     }
@@ -125,7 +124,7 @@ void AudioIngress::ReceivedRTPPacket(rtc::ArrayView<const uint8_t> rtp_packet) {
 
   // Set payload type's sampling rate before we feed it into ReceiveStatistics.
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     const auto& it =
         receive_codec_info_.find(rtp_packet_received.PayloadType());
     // If sampling rate info is not available in our received codec set, it
@@ -185,7 +184,7 @@ void AudioIngress::ReceivedRTCPPacket(
   }
 
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     ntp_estimator_.UpdateRtcpTimestamp(rtt, ntp_secs, ntp_frac, rtp_timestamp);
   }
 }
diff --git a/audio/voip/audio_ingress.h b/audio/voip/audio_ingress.h
index 15f7900617..5a8df21f7a 100644
--- a/audio/voip/audio_ingress.h
+++ b/audio/voip/audio_ingress.h
@@ -28,7 +28,7 @@
 #include "modules/rtp_rtcp/include/remote_ntp_time_estimator.h"
 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 #include "rtc_base/time_utils.h"
 
 namespace webrtc {
@@ -131,7 +131,7 @@ class AudioIngress : public AudioMixer::Source {
   // Synchronizaton is handled internally by voe::AudioLevel.
   voe::AudioLevel output_audio_level_;
 
-  rtc::CriticalSection lock_;
+  Mutex lock_;
 
   RemoteNtpTimeEstimator ntp_estimator_ RTC_GUARDED_BY(lock_);
 
diff --git a/audio/voip/voip_core.cc b/audio/voip/voip_core.cc
index 3275f028cd..7292644648 100644
--- a/audio/voip/voip_core.cc
+++ b/audio/voip/voip_core.cc
@@ -15,7 +15,6 @@
 #include <utility>
 
 #include "api/audio_codecs/audio_format.h"
-#include "rtc_base/critical_section.h"
 #include "rtc_base/logging.h"
 
 namespace webrtc {
@@ -134,7 +133,7 @@ absl::optional<ChannelId> VoipCore::CreateChannel(
           process_thread_.get(), audio_mixer_.get(), decoder_factory_);
 
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
 
     channel = static_cast<ChannelId>(next_channel_id_);
     channels_[*channel] = audio_channel;
@@ -154,7 +153,7 @@ void VoipCore::ReleaseChannel(ChannelId channel) {
   // Destroy channel outside of the lock.
   rtc::scoped_refptr<AudioChannel> audio_channel;
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
 
     auto iter = channels_.find(channel);
     if (iter != channels_.end()) {
@@ -170,7 +169,7 @@ void VoipCore::ReleaseChannel(ChannelId channel) {
 rtc::scoped_refptr<AudioChannel> VoipCore::GetChannel(ChannelId channel) {
   rtc::scoped_refptr<AudioChannel> audio_channel;
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     auto iter = channels_.find(channel);
     if (iter != channels_.end()) {
       audio_channel = iter->second;
@@ -191,7 +190,7 @@ bool VoipCore::UpdateAudioTransportWithSenders() {
   int max_sampling_rate = 8000;
   size_t max_num_channels = 1;
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     // Reserve to prevent run time vector re-allocation.
     audio_senders.reserve(channels_.size());
     for (auto kv : channels_) {
@@ -290,7 +289,7 @@ bool VoipCore::StopPlayout(ChannelId channel) {
 
   bool stop_device = true;
   {
-    rtc::CritScope lock(&lock_);
+    MutexLock lock(&lock_);
     for (auto kv : channels_) {
       rtc::scoped_refptr<AudioChannel>& channel = kv.second;
       if (channel->IsPlaying()) {
diff --git a/audio/voip/voip_core.h b/audio/voip/voip_core.h
index 08929d3afd..22a6559981 100644
--- a/audio/voip/voip_core.h
+++ b/audio/voip/voip_core.h
@@ -31,7 +31,7 @@
 #include "modules/audio_mixer/audio_mixer_impl.h"
 #include "modules/audio_processing/include/audio_processing.h"
 #include "modules/utility/include/process_thread.h"
-#include "rtc_base/critical_section.h"
+#include "rtc_base/synchronization/mutex.h"
 
 namespace webrtc {
 
@@ -123,7 +123,7 @@ class VoipCore : public VoipEngine,
   // Must be placed before |channels_| for proper destruction.
   std::unique_ptr<ProcessThread> process_thread_;
 
-  rtc::CriticalSection lock_;
+  Mutex lock_;
 
   // Member to track a next ChannelId for new AudioChannel.
   int next_channel_id_ RTC_GUARDED_BY(lock_) = 0;