commit 6deec38edef45e7505330eb892f9c75b7e6f6ba4
author Markus Handell <handellm@webrtc.org> Tue Jul 07 12:17:12 2020 +0200
committer Commit Bot <commit-bot@chromium.org> Tue Jul 07 11:41:21 2020 +0000
tree 595dd2286799a8de82bfe79d6b23867447735da4
parent fb6f975401972635a644c0db06c135b4c0aaef4a

Migrate modules/video_coding to webrtc::Mutex.

Bug: webrtc:11567
Change-Id: I8023fbe7595f7ba8ae7c7db3583fc2e560ec3df2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/178803
Commit-Queue: Markus Handell <handellm@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31644}

modules/video_coding/timing.cc

diff --git a/modules/video_coding/timing.cc b/modules/video_coding/timing.cc
index c62c848..f046edf 100644
--- a/modules/video_coding/timing.cc
+++ b/modules/video_coding/timing.cc
@@ -47,7 +47,7 @@
 }
 
 void VCMTiming::Reset() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   ts_extrapolator_->Reset(clock_->TimeInMilliseconds());
   codec_timer_.reset(new VCMCodecTimer());
   render_delay_ms_ = kDefaultRenderDelayMs;
@@ -58,32 +58,32 @@
 }
 
 void VCMTiming::set_render_delay(int render_delay_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   render_delay_ms_ = render_delay_ms;
 }
 
 void VCMTiming::set_min_playout_delay(int min_playout_delay_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   min_playout_delay_ms_ = min_playout_delay_ms;
 }
 
 int VCMTiming::min_playout_delay() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return min_playout_delay_ms_;
 }
 
 void VCMTiming::set_max_playout_delay(int max_playout_delay_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   max_playout_delay_ms_ = max_playout_delay_ms;
 }
 
 int VCMTiming::max_playout_delay() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return max_playout_delay_ms_;
 }
 
 void VCMTiming::SetJitterDelay(int jitter_delay_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   if (jitter_delay_ms != jitter_delay_ms_) {
     jitter_delay_ms_ = jitter_delay_ms;
     // When in initial state, set current delay to minimum delay.
@@ -94,7 +94,7 @@
 }
 
 void VCMTiming::UpdateCurrentDelay(uint32_t frame_timestamp) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   int target_delay_ms = TargetDelayInternal();
 
   if (current_delay_ms_ == 0) {
@@ -135,7 +135,7 @@
 
 void VCMTiming::UpdateCurrentDelay(int64_t render_time_ms,
                                    int64_t actual_decode_time_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   uint32_t target_delay_ms = TargetDelayInternal();
   int64_t delayed_ms =
       actual_decode_time_ms -
@@ -158,20 +158,20 @@
 }
 
 void VCMTiming::StopDecodeTimer(int32_t decode_time_ms, int64_t now_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   codec_timer_->AddTiming(decode_time_ms, now_ms);
   assert(decode_time_ms >= 0);
   ++num_decoded_frames_;
 }
 
 void VCMTiming::IncomingTimestamp(uint32_t time_stamp, int64_t now_ms) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   ts_extrapolator_->Update(now_ms, time_stamp);
 }
 
 int64_t VCMTiming::RenderTimeMs(uint32_t frame_timestamp,
                                 int64_t now_ms) const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return RenderTimeMsInternal(frame_timestamp, now_ms);
 }
 
@@ -202,7 +202,7 @@
 
 int64_t VCMTiming::MaxWaitingTime(int64_t render_time_ms,
                                   int64_t now_ms) const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
 
   const int64_t max_wait_time_ms =
       render_time_ms - now_ms - RequiredDecodeTimeMs() - render_delay_ms_;
@@ -211,7 +211,7 @@
 }
 
 int VCMTiming::TargetVideoDelay() const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return TargetDelayInternal();
 }
 
@@ -226,7 +226,7 @@
                            int* jitter_buffer_ms,
                            int* min_playout_delay_ms,
                            int* render_delay_ms) const {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   *max_decode_ms = RequiredDecodeTimeMs();
   *current_delay_ms = current_delay_ms_;
   *target_delay_ms = TargetDelayInternal();
@@ -237,12 +237,12 @@
 }
 
 void VCMTiming::SetTimingFrameInfo(const TimingFrameInfo& info) {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   timing_frame_info_.emplace(info);
 }
 
 absl::optional<TimingFrameInfo> VCMTiming::GetTimingFrameInfo() {
-  rtc::CritScope cs(&crit_sect_);
+  MutexLock lock(&mutex_);
   return timing_frame_info_;
 }