Remove ALL usage of CriticalSectionWrapper.

webrtc/modules/video_coding/jitter_buffer.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webrtc/modules/video_coding/jitter_buffer.h"
 
 #include <assert.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/frame_buffer.h"
 #include "webrtc/modules/video_coding/inter_frame_delay.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/modules/video_coding/jitter_buffer_common.h"
 #include "webrtc/modules/video_coding/jitter_estimator.h"
 #include "webrtc/modules/video_coding/packet.h"
 #include "webrtc/system_wrappers/include/clock.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 // Interval for updating SS data.
 static const uint32_t kSsCleanupIntervalSec = 60;
 
 // Use this rtt if no value has been reported.
 static const int64_t kDefaultRtt = 200;
@@ skipping 173 matching lines @@
     }
   }
 }
 
 VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
                                  std::unique_ptr<EventWrapper> event,
                                  NackSender* nack_sender,
                                  KeyFrameRequestSender* keyframe_request_sender)
     : clock_(clock),
       running_(false),
-      crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
       frame_event_(std::move(event)),
       max_number_of_frames_(kStartNumberOfFrames),
       free_frames_(),
       decodable_frames_(),
       incomplete_frames_(),
       last_decoded_state_(),
       first_packet_since_reset_(true),
       stats_callback_(nullptr),
       incoming_frame_rate_(0),
       incoming_frame_count_(0),
@@ skipping 30 matching lines @@
     delete *it;
   }
   for (FrameList::iterator it = incomplete_frames_.begin();
        it != incomplete_frames_.end(); ++it) {
     delete it->second;
   }
   for (FrameList::iterator it = decodable_frames_.begin();
        it != decodable_frames_.end(); ++it) {
     delete it->second;
   }
-  delete crit_sect_;
 }
 
 void VCMJitterBuffer::UpdateHistograms() {
   if (num_packets_ <= 0 || !running_) {
     return;
   }
   int64_t elapsed_sec =
       (clock_->TimeInMilliseconds() - time_first_packet_ms_) / 1000;
   if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
     return;
@@ skipping 11 matching lines @@
         "WebRTC.Video.CompleteFramesReceivedPerSecond",
         static_cast<int>((total_frames / elapsed_sec) + 0.5f));
     RTC_HISTOGRAM_COUNTS_1000(
         "WebRTC.Video.KeyFramesReceivedInPermille",
         static_cast<int>(
             (receive_statistics_.key_frames * 1000.0f / total_frames) + 0.5f));
   }
 }
 
 void VCMJitterBuffer::Start() {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   running_ = true;
   incoming_frame_count_ = 0;
   incoming_frame_rate_ = 0;
   incoming_bit_count_ = 0;
   incoming_bit_rate_ = 0;
   time_last_incoming_frame_count_ = clock_->TimeInMilliseconds();
   receive_statistics_ = FrameCounts();
 
   num_consecutive_old_packets_ = 0;
   num_packets_ = 0;
   num_duplicated_packets_ = 0;
   num_discarded_packets_ = 0;
   time_first_packet_ms_ = 0;
 
   // Start in a non-signaled state.
   waiting_for_completion_.frame_size = 0;
   waiting_for_completion_.timestamp = 0;
   waiting_for_completion_.latest_packet_time = -1;
   first_packet_since_reset_ = true;
   rtt_ms_ = kDefaultRtt;
   last_decoded_state_.Reset();
 
   decodable_frames_.Reset(&free_frames_);
   incomplete_frames_.Reset(&free_frames_);
 }
 
 void VCMJitterBuffer::Stop() {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   UpdateHistograms();
   running_ = false;
   last_decoded_state_.Reset();
 
   // Make sure we wake up any threads waiting on these events.
   frame_event_->Set();
 }
 
 bool VCMJitterBuffer::Running() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return running_;
 }
 
 void VCMJitterBuffer::Flush() {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   decodable_frames_.Reset(&free_frames_);
   incomplete_frames_.Reset(&free_frames_);
   last_decoded_state_.Reset();  // TODO(mikhal): sync reset.
   num_consecutive_old_packets_ = 0;
   // Also reset the jitter and delay estimates
   jitter_estimate_.Reset();
   inter_frame_delay_.Reset(clock_->TimeInMilliseconds());
   waiting_for_completion_.frame_size = 0;
   waiting_for_completion_.timestamp = 0;
   waiting_for_completion_.latest_packet_time = -1;
   first_packet_since_reset_ = true;
   missing_sequence_numbers_.clear();
 }
 
 // Get received key and delta frames
 FrameCounts VCMJitterBuffer::FrameStatistics() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return receive_statistics_;
 }
 
 int VCMJitterBuffer::num_packets() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return num_packets_;
 }
 
 int VCMJitterBuffer::num_duplicated_packets() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return num_duplicated_packets_;
 }
 
 int VCMJitterBuffer::num_discarded_packets() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return num_discarded_packets_;
 }
 
 // Calculate framerate and bitrate.
 void VCMJitterBuffer::IncomingRateStatistics(unsigned int* framerate,
                                              unsigned int* bitrate) {
   assert(framerate);
   assert(bitrate);
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   const int64_t now = clock_->TimeInMilliseconds();
   int64_t diff = now - time_last_incoming_frame_count_;
   if (diff < 1000 && incoming_frame_rate_ > 0 && incoming_bit_rate_ > 0) {
     // Make sure we report something even though less than
     // 1 second has passed since last update.
     *framerate = incoming_frame_rate_;
     *bitrate = incoming_bit_rate_;
   } else if (incoming_frame_count_ != 0) {
     // We have received frame(s) since last call to this function
 
@@ skipping 36 matching lines @@
     *framerate = 0;
     *bitrate = 0;
     incoming_frame_rate_ = 0;
     incoming_bit_rate_ = 0;
   }
 }
 
 // Returns immediately or a |max_wait_time_ms| ms event hang waiting for a
 // complete frame, |max_wait_time_ms| decided by caller.
 VCMEncodedFrame* VCMJitterBuffer::NextCompleteFrame(uint32_t max_wait_time_ms) {
-  crit_sect_->Enter();
+  crit_sect_.Enter();
   if (!running_) {
-    crit_sect_->Leave();
+    crit_sect_.Leave();
     return nullptr;
   }
   CleanUpOldOrEmptyFrames();
 
   if (decodable_frames_.empty() ||
       decodable_frames_.Front()->GetState() != kStateComplete) {
     const int64_t end_wait_time_ms =
         clock_->TimeInMilliseconds() + max_wait_time_ms;
     int64_t wait_time_ms = max_wait_time_ms;
     while (wait_time_ms > 0) {
-      crit_sect_->Leave();
+      crit_sect_.Leave();
       const EventTypeWrapper ret =
           frame_event_->Wait(static_cast<uint32_t>(wait_time_ms));
-      crit_sect_->Enter();
+      crit_sect_.Enter();
       if (ret == kEventSignaled) {
         // Are we shutting down the jitter buffer?
         if (!running_) {
-          crit_sect_->Leave();
+          crit_sect_.Leave();
           return nullptr;
         }
         // Finding oldest frame ready for decoder.
         CleanUpOldOrEmptyFrames();
         if (decodable_frames_.empty() ||
             decodable_frames_.Front()->GetState() != kStateComplete) {
           wait_time_ms = end_wait_time_ms - clock_->TimeInMilliseconds();
         } else {
           break;
         }
       } else {
         break;
       }
     }
   }
   if (decodable_frames_.empty() ||
       decodable_frames_.Front()->GetState() != kStateComplete) {
-    crit_sect_->Leave();
+    crit_sect_.Leave();
     return nullptr;
   }
   VCMEncodedFrame* encoded_frame = decodable_frames_.Front();
-  crit_sect_->Leave();
+  crit_sect_.Leave();
   return encoded_frame;
 }
 
 bool VCMJitterBuffer::NextMaybeIncompleteTimestamp(uint32_t* timestamp) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   if (!running_) {
     return false;
   }
   if (decode_error_mode_ == kNoErrors) {
     // No point to continue, as we are not decoding with errors.
     return false;
   }
 
   CleanUpOldOrEmptyFrames();
 
@@ skipping 16 matching lines @@
         oldest_frame->GetState() != kStateComplete) {
       return false;
     }
   }
 
   *timestamp = oldest_frame->TimeStamp();
   return true;
 }
 
 VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   if (!running_) {
     return NULL;
   }
   // Extract the frame with the desired timestamp.
   VCMFrameBuffer* frame = decodable_frames_.PopFrame(timestamp);
   bool continuous = true;
   if (!frame) {
     frame = incomplete_frames_.PopFrame(timestamp);
     if (frame)
       continuous = last_decoded_state_.ContinuousFrame(frame);
@@ skipping 33 matching lines @@
   if ((*frame).IsSessionComplete())
     UpdateAveragePacketsPerFrame(frame->NumPackets());
 
   return frame;
 }
 
 // Release frame when done with decoding. Should never be used to release
 // frames from within the jitter buffer.
 void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) {
   RTC_CHECK(frame != nullptr);
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame);
   RecycleFrameBuffer(frame_buffer);
 }
 
 // Gets frame to use for this timestamp. If no match, get empty frame.
 VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet,
                                              VCMFrameBuffer** frame,
                                              FrameList** frame_list) {
   *frame = incomplete_frames_.PopFrame(packet.timestamp);
   if (*frame != NULL) {
@@ skipping 20 matching lines @@
       return kFlushIndicator;
     }
   }
   (*frame)->Reset();
   return kNoError;
 }
 
 int64_t VCMJitterBuffer::LastPacketTime(const VCMEncodedFrame* frame,
                                         bool* retransmitted) const {
   assert(retransmitted);
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   const VCMFrameBuffer* frame_buffer =
       static_cast<const VCMFrameBuffer*>(frame);
   *retransmitted = (frame_buffer->GetNackCount() > 0);
   return frame_buffer->LatestPacketTimeMs();
 }
 
 VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
                                                  bool* retransmitted) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
 
   ++num_packets_;
   if (num_packets_ == 1) {
     time_first_packet_ms_ = clock_->TimeInMilliseconds();
   }
   // Does this packet belong to an old frame?
   if (last_decoded_state_.IsOldPacket(&packet)) {
     // Account only for media packets.
     if (packet.sizeBytes > 0) {
       num_discarded_packets_++;
@@ skipping 226 matching lines @@
       decoding_state.SetState(frame);
     } else if (frame->TemporalId() <= 0) {
       break;
     } else {
       ++it;
     }
   }
 }
 
 uint32_t VCMJitterBuffer::EstimatedJitterMs() {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   // Compute RTT multiplier for estimation.
   // low_rtt_nackThresholdMs_ == -1 means no FEC.
   double rtt_mult = 1.0f;
   if (low_rtt_nack_threshold_ms_ >= 0 &&
       rtt_ms_ >= low_rtt_nack_threshold_ms_) {
     // For RTTs above low_rtt_nack_threshold_ms_ we don't apply extra delay
     // when waiting for retransmissions.
     rtt_mult = 0.0f;
   }
   return jitter_estimate_.GetJitterEstimate(rtt_mult);
 }
 
 void VCMJitterBuffer::UpdateRtt(int64_t rtt_ms) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   rtt_ms_ = rtt_ms;
   jitter_estimate_.UpdateRtt(rtt_ms);
   if (!WaitForRetransmissions())
     jitter_estimate_.ResetNackCount();
 }
 
 void VCMJitterBuffer::SetNackMode(VCMNackMode mode,
                                   int64_t low_rtt_nack_threshold_ms,
                                   int64_t high_rtt_nack_threshold_ms) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   nack_mode_ = mode;
   if (mode == kNoNack) {
     missing_sequence_numbers_.clear();
   }
   assert(low_rtt_nack_threshold_ms >= -1 && high_rtt_nack_threshold_ms >= -1);
   assert(high_rtt_nack_threshold_ms == -1 ||
          low_rtt_nack_threshold_ms <= high_rtt_nack_threshold_ms);
   assert(low_rtt_nack_threshold_ms > -1 || high_rtt_nack_threshold_ms == -1);
   low_rtt_nack_threshold_ms_ = low_rtt_nack_threshold_ms;
   high_rtt_nack_threshold_ms_ = high_rtt_nack_threshold_ms;
   // Don't set a high start rtt if high_rtt_nack_threshold_ms_ is used, to not
   // disable NACK in |kNack| mode.
   if (rtt_ms_ == kDefaultRtt && high_rtt_nack_threshold_ms_ != -1) {
     rtt_ms_ = 0;
   }
   if (!WaitForRetransmissions()) {
     jitter_estimate_.ResetNackCount();
   }
 }
 
 void VCMJitterBuffer::SetNackSettings(size_t max_nack_list_size,
                                       int max_packet_age_to_nack,
                                       int max_incomplete_time_ms) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   assert(max_packet_age_to_nack >= 0);
   assert(max_incomplete_time_ms_ >= 0);
   max_nack_list_size_ = max_nack_list_size;
   max_packet_age_to_nack_ = max_packet_age_to_nack;
   max_incomplete_time_ms_ = max_incomplete_time_ms;
 }
 
 VCMNackMode VCMJitterBuffer::nack_mode() const {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   return nack_mode_;
 }
 
 int VCMJitterBuffer::NonContinuousOrIncompleteDuration() {
   if (incomplete_frames_.empty()) {
     return 0;
   }
   uint32_t start_timestamp = incomplete_frames_.Front()->TimeStamp();
   if (!decodable_frames_.empty()) {
     start_timestamp = decodable_frames_.Back()->TimeStamp();
   }
   return incomplete_frames_.Back()->TimeStamp() - start_timestamp;
 }
 
 uint16_t VCMJitterBuffer::EstimatedLowSequenceNumber(
     const VCMFrameBuffer& frame) const {
   assert(frame.GetLowSeqNum() >= 0);
   if (frame.HaveFirstPacket())
     return frame.GetLowSeqNum();
 
   // This estimate is not accurate if more than one packet with lower sequence
   // number is lost.
   return frame.GetLowSeqNum() - 1;
 }
 
 std::vector<uint16_t> VCMJitterBuffer::GetNackList(bool* request_key_frame) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   *request_key_frame = false;
   if (nack_mode_ == kNoNack) {
     return std::vector<uint16_t>();
   }
   if (last_decoded_state_.in_initial_state()) {
     VCMFrameBuffer* next_frame = NextFrame();
     const bool first_frame_is_key = next_frame &&
                                     next_frame->FrameType() == kVideoFrameKey &&
                                     next_frame->HaveFirstPacket();
     if (!first_frame_is_key) {
@@ skipping 39 matching lines @@
         DropPacketsFromNackList(EstimatedLowSequenceNumber(*rit->second));
       }
     }
   }
   std::vector<uint16_t> nack_list(missing_sequence_numbers_.begin(),
                                   missing_sequence_numbers_.end());
   return nack_list;
 }
 
 void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   decode_error_mode_ = error_mode;
 }
 
 VCMFrameBuffer* VCMJitterBuffer::NextFrame() const {
   if (!decodable_frames_.empty())
     return decodable_frames_.Front();
   if (!incomplete_frames_.empty())
     return incomplete_frames_.Front();
   return NULL;
 }
@@ skipping 79 matching lines @@
     uint16_t last_decoded_sequence_number) {
   // Erase all sequence numbers from the NACK list which we won't need any
   // longer.
   missing_sequence_numbers_.erase(
       missing_sequence_numbers_.begin(),
       missing_sequence_numbers_.upper_bound(last_decoded_sequence_number));
 }
 
 void VCMJitterBuffer::RegisterStatsCallback(
     VCMReceiveStatisticsCallback* callback) {
-  CriticalSectionScoped cs(crit_sect_);
+  rtc::CritScope cs(&crit_sect_);
   stats_callback_ = callback;
 }
 
 VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
   if (free_frames_.empty()) {
     if (!TryToIncreaseJitterBufferSize()) {
       return NULL;
     }
   }
   VCMFrameBuffer* frame = free_frames_.front();
@@ skipping 163 matching lines @@
   }
   return true;
 }
 
 void VCMJitterBuffer::RecycleFrameBuffer(VCMFrameBuffer* frame) {
   frame->Reset();
   free_frames_.push_back(frame);
 }
 
 }  // namespace webrtc