Switch CriticalSectionWrapper->rtc::CriticalSection in modules/audio_coding.

webrtc/modules/audio_coding/test/Channel.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/audio_coding/test/Channel.h"
 
 #include <assert.h>
 #include <iostream>
 
 #include "webrtc/base/format_macros.h"
 #include "webrtc/system_wrappers/include/tick_util.h"
-#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 
 namespace webrtc {
 
 int32_t Channel::SendData(FrameType frameType,
                           uint8_t payloadType,
                           uint32_t timeStamp,
                           const uint8_t* payloadData,
                           size_t payloadSize,
                           const RTPFragmentationHeader* fragmentation) {
   WebRtcRTPHeader rtpInfo;
@@ skipping 59 matching lines @@
         _leftChannel = false;
         rtpInfo.type.Audio.channel = 1;
       } else {
         memcpy(&rtpInfo, &_rtpInfo, sizeof(WebRtcRTPHeader));
         _leftChannel = true;
         rtpInfo.type.Audio.channel = 2;
       }
     }
   }
 
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   if (_saveBitStream) {
     //fwrite(payloadData, sizeof(uint8_t), payloadSize, _bitStreamFile);
   }
 
   if (!_isStereo) {
     CalcStatistics(rtpInfo, payloadSize);
   }
   _useLastFrameSize = false;
   _lastInTimestamp = timeStamp;
   _totalBytes += payloadDataSize;
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
 
   if (_useFECTestWithPacketLoss) {
     _packetLoss += 1;
     if (_packetLoss == 3) {
       _packetLoss = 0;
       return 0;
     }
   }
 
   if (num_packets_to_drop_ > 0) {
@@ skipping 98 matching lines @@
     _payloadStats[n].lastTimestamp = rtpInfo.header.timestamp;
     _payloadStats[n].payloadType = rtpInfo.header.payloadType;
     memset(_payloadStats[n].frameSizeStats, 0, MAX_NUM_FRAMESIZES *
            sizeof(ACMTestFrameSizeStats));
   }
 }
 
 Channel::Channel(int16_t chID)
     : _receiverACM(NULL),
       _seqNo(0),
-      _channelCritSect(CriticalSectionWrapper::CreateCriticalSection()),
       _bitStreamFile(NULL),
       _saveBitStream(false),
       _lastPayloadType(-1),
       _isStereo(false),
       _leftChannel(true),
       _lastInTimestamp(0),
       _useLastFrameSize(false),
       _lastFrameSizeSample(0),
       _packetLoss(0),
       _useFECTestWithPacketLoss(false),
@@ skipping 19 matching lines @@
     _saveBitStream = true;
     char bitStreamFileName[500];
     sprintf(bitStreamFileName, "bitStream_%d.dat", chID);
     _bitStreamFile = fopen(bitStreamFileName, "wb");
   } else {
     _saveBitStream = false;
   }
 }
 
 Channel::~Channel() {
-  delete _channelCritSect;
 }
 
 void Channel::RegisterReceiverACM(AudioCodingModule* acm) {
   _receiverACM = acm;
   return;
 }
 
 void Channel::ResetStats() {
   int n;
   int k;
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   _lastPayloadType = -1;
   for (n = 0; n < MAX_NUM_PAYLOADS; n++) {
     _payloadStats[n].payloadType = -1;
     _payloadStats[n].newPacket = true;
     for (k = 0; k < MAX_NUM_FRAMESIZES; k++) {
       _payloadStats[n].frameSizeStats[k].frameSizeSample = 0;
       _payloadStats[n].frameSizeStats[k].maxPayloadLen = 0;
       _payloadStats[n].frameSizeStats[k].numPackets = 0;
       _payloadStats[n].frameSizeStats[k].totalPayloadLenByte = 0;
       _payloadStats[n].frameSizeStats[k].totalEncodedSamples = 0;
     }
   }
   _beginTime = TickTime::MillisecondTimestamp();
   _totalBytes = 0;
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
 }
 
 int16_t Channel::Stats(CodecInst& codecInst,
                        ACMTestPayloadStats& payloadStats) {
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   int n;
   payloadStats.payloadType = -1;
   for (n = 0; n < MAX_NUM_PAYLOADS; n++) {
     if (_payloadStats[n].payloadType == codecInst.pltype) {
       memcpy(&payloadStats, &_payloadStats[n], sizeof(ACMTestPayloadStats));
       break;
     }
   }
   if (payloadStats.payloadType == -1) {
-    _channelCritSect->Leave();
+    _channelCritSect.Leave();
     return -1;
   }
   for (n = 0; n < MAX_NUM_FRAMESIZES; n++) {
     if (payloadStats.frameSizeStats[n].frameSizeSample == 0) {
-      _channelCritSect->Leave();
+      _channelCritSect.Leave();
       return 0;
     }
     payloadStats.frameSizeStats[n].usageLenSec = (double) payloadStats
         .frameSizeStats[n].totalEncodedSamples / (double) codecInst.plfreq;
 
     payloadStats.frameSizeStats[n].rateBitPerSec =
         payloadStats.frameSizeStats[n].totalPayloadLenByte * 8
             / payloadStats.frameSizeStats[n].usageLenSec;
 
   }
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
   return 0;
 }
 
 void Channel::Stats(uint32_t* numPackets) {
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   int k;
   int n;
   memset(numPackets, 0, MAX_NUM_PAYLOADS * sizeof(uint32_t));
   for (k = 0; k < MAX_NUM_PAYLOADS; k++) {
     if (_payloadStats[k].payloadType == -1) {
       break;
     }
     numPackets[k] = 0;
     for (n = 0; n < MAX_NUM_FRAMESIZES; n++) {
       if (_payloadStats[k].frameSizeStats[n].frameSizeSample == 0) {
         break;
       }
       numPackets[k] += _payloadStats[k].frameSizeStats[n].numPackets;
     }
   }
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
 }
 
 void Channel::Stats(uint8_t* payloadType, uint32_t* payloadLenByte) {
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
 
   int k;
   int n;
   memset(payloadLenByte, 0, MAX_NUM_PAYLOADS * sizeof(uint32_t));
   for (k = 0; k < MAX_NUM_PAYLOADS; k++) {
     if (_payloadStats[k].payloadType == -1) {
       break;
     }
     payloadType[k] = (uint8_t) _payloadStats[k].payloadType;
     payloadLenByte[k] = 0;
     for (n = 0; n < MAX_NUM_FRAMESIZES; n++) {
       if (_payloadStats[k].frameSizeStats[n].frameSizeSample == 0) {
         break;
       }
       payloadLenByte[k] += (uint16_t) _payloadStats[k].frameSizeStats[n]
           .totalPayloadLenByte;
     }
   }
 
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
 }
 
 void Channel::PrintStats(CodecInst& codecInst) {
   ACMTestPayloadStats payloadStats;
   Stats(codecInst, payloadStats);
   printf("%s %d kHz\n", codecInst.plname, codecInst.plfreq / 1000);
   printf("=====================================================\n");
   if (payloadStats.payloadType == -1) {
     printf("No Packets are sent with payload-type %d (%s)\n\n",
            codecInst.pltype, codecInst.plname);
@@ skipping 18 matching lines @@
            (unsigned int) payloadStats.frameSizeStats[k].numPackets);
     printf("Duration...................... %0.3f sec\n\n",
            payloadStats.frameSizeStats[k].usageLenSec);
 
   }
 
 }
 
 uint32_t Channel::LastInTimestamp() {
   uint32_t timestamp;
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   timestamp = _lastInTimestamp;
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
   return timestamp;
 }
 
 double Channel::BitRate() {
   double rate;
   uint64_t currTime = TickTime::MillisecondTimestamp();
-  _channelCritSect->Enter();
+  _channelCritSect.Enter();
   rate = ((double) _totalBytes * 8.0) / (double) (currTime - _beginTime);
-  _channelCritSect->Leave();
+  _channelCritSect.Leave();
   return rate;
 }
 
 }  // namespace webrtc