Replaced CriticalSectionWrapper with rtc::CriticalSection in rtp_rtcp module

webrtc/modules/rtp_rtcp/source/rtp_receiver_audio.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/rtp_rtcp/source/rtp_receiver_audio.h"
 
 #include <assert.h>  // assert
 #include <math.h>   // pow()
 #include <string.h>  // memcpy()
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 RTPReceiverStrategy* RTPReceiverStrategy::CreateAudioStrategy(
     RtpData* data_callback) {
   return new RTPReceiverAudio(data_callback);
 }
 
 RTPReceiverAudio::RTPReceiverAudio(RtpData* data_callback)
     : RTPReceiverStrategy(data_callback),
       TelephoneEventHandler(),
       last_received_frequency_(8000),
       telephone_event_forward_to_decoder_(false),
       telephone_event_payload_type_(-1),
       cng_nb_payload_type_(-1),
       cng_wb_payload_type_(-1),
       cng_swb_payload_type_(-1),
       cng_fb_payload_type_(-1),
       cng_payload_type_(-1),
       g722_payload_type_(-1),
       last_received_g722_(false),
       num_energy_(0),
       current_remote_energy_() {
   last_payload_.Audio.channels = 1;
   memset(current_remote_energy_, 0, sizeof(current_remote_energy_));
 }
 
 // Outband TelephoneEvent(DTMF) detection
 void RTPReceiverAudio::SetTelephoneEventForwardToDecoder(
     bool forward_to_decoder) {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   telephone_event_forward_to_decoder_ = forward_to_decoder;
 }
 
 // Is forwarding of outband telephone events turned on/off?
 bool RTPReceiverAudio::TelephoneEventForwardToDecoder() const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   return telephone_event_forward_to_decoder_;
 }
 
 bool RTPReceiverAudio::TelephoneEventPayloadType(
     int8_t payload_type) const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   return telephone_event_payload_type_ == payload_type;
 }
 
 bool RTPReceiverAudio::CNGPayloadType(int8_t payload_type,
                                       uint32_t* frequency,
                                       bool* cng_payload_type_has_changed) {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   *cng_payload_type_has_changed = false;
 
   //  We can have four CNG on 8000Hz, 16000Hz, 32000Hz and 48000Hz.
   if (cng_nb_payload_type_ == payload_type) {
     *frequency = 8000;
     if (cng_payload_type_ != -1 && cng_payload_type_ != cng_nb_payload_type_)
       *cng_payload_type_has_changed = true;
 
     cng_payload_type_ = cng_nb_payload_type_;
     return true;
@@ skipping 66 matching lines @@
 // -   GSM       frame         N/A             8,000        20         20
 // -   GSM-EFR   frame         N/A             8,000        20         20
 // -   LPC       frame         N/A             8,000        20         20
 // -   MPA       frame         N/A              var.      var.
 // -
 // -   G7221     frame         N/A
 int32_t RTPReceiverAudio::OnNewPayloadTypeCreated(
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     int8_t payload_type,
     uint32_t frequency) {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
 
   if (RtpUtility::StringCompare(payload_name, "telephone-event", 15)) {
     telephone_event_payload_type_ = payload_type;
   }
   if (RtpUtility::StringCompare(payload_name, "cn", 2)) {
     //  we can have three CNG on 8000Hz, 16000Hz and 32000Hz
     if (frequency == 8000) {
       cng_nb_payload_type_ = payload_type;
     } else if (frequency == 16000) {
       cng_wb_payload_type_ = payload_type;
@@ skipping 33 matching lines @@
   }
 
   return ParseAudioCodecSpecific(rtp_header,
                                  payload,
                                  payload_length,
                                  specific_payload.Audio,
                                  is_red);
 }
 
 int RTPReceiverAudio::GetPayloadTypeFrequency() const {
-  CriticalSectionScoped lock(crit_sect_.get());
+  rtc::CritScope lock(&crit_sect_);
   if (last_received_g722_) {
     return 8000;
   }
   return last_received_frequency_;
 }
 
 RTPAliveType RTPReceiverAudio::ProcessDeadOrAlive(
     uint16_t last_payload_length) const {
 
   // Our CNG is 9 bytes; if it's a likely CNG the receiver needs to check
@@ skipping 22 matching lines @@
                                             &cng_payload_type_has_changed);
 
   if (is_cng_payload_type) {
     // Don't do callbacks for DTMF packets.
     *should_discard_changes = true;
     return;
   }
 }
 
 int RTPReceiverAudio::Energy(uint8_t array_of_energy[kRtpCsrcSize]) const {
-  CriticalSectionScoped cs(crit_sect_.get());
+  rtc::CritScope cs(&crit_sect_);
 
   assert(num_energy_ <= kRtpCsrcSize);
 
   if (num_energy_ > 0) {
     memcpy(array_of_energy, current_remote_energy_,
            sizeof(uint8_t) * num_energy_);
   }
   return num_energy_;
 }
 
@@ skipping 21 matching lines @@
     const AudioPayload& audio_specific,
     bool is_red) {
 
   if (payload_length == 0) {
     return 0;
   }
 
   bool telephone_event_packet =
       TelephoneEventPayloadType(rtp_header->header.payloadType);
   if (telephone_event_packet) {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
 
     // RFC 4733 2.3
     // 0                   1                   2                   3
     // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     // |     event     |E|R| volume    |          duration             |
     // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
     //
     if (payload_length % 4 != 0) {
       return -1;
@@ skipping 24 matching lines @@
       }
     }
 
     // RFC 4733 2.5.1.3 & 2.5.2.3 Long-Duration Events
     // should not be a problem since we don't care about the duration
 
     // RFC 4733 See 2.5.1.5. & 2.5.2.4.  Multiple Events in a Packet
   }
 
   {
-    CriticalSectionScoped lock(crit_sect_.get());
+    rtc::CritScope lock(&crit_sect_);
 
     if (!telephone_event_packet) {
       last_received_frequency_ = audio_specific.frequency;
     }
 
     // Check if this is a CNG packet, receiver might want to know
     uint32_t ignored;
     bool also_ignored;
     if (CNGPayloadType(rtp_header->header.payloadType,
                        &ignored,
@@ skipping 27 matching lines @@
     // only one frame in the RED strip the one byte to help NetEq
     return data_callback_->OnReceivedPayloadData(
         payload_data + 1, payload_length - 1, rtp_header);
   }
 
   rtp_header->type.Audio.channel = audio_specific.channels;
   return data_callback_->OnReceivedPayloadData(
       payload_data, payload_length, rtp_header);
 }
 }  // namespace webrtc