Replaced CriticalSectionWrapper with rtc::CriticalSection in rtp_rtcp module

webrtc/modules/rtp_rtcp/source/tmmbr_help.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.
  */
 
@@ skipping 49 matching lines @@
 void TMMBRSet::SwapEntries(uint32_t i, uint32_t j) {
   using std::swap;
   swap((*this)[i], (*this)[j]);
 }
 
 void TMMBRSet::ClearEntry(uint32_t idx) {
   SetEntry(idx, 0, 0, 0);
 }
 
 TMMBRHelp::TMMBRHelp()
-    : _criticalSection(CriticalSectionWrapper::CreateCriticalSection()),
-      _candidateSet(),
+    : _candidateSet(),
       _boundingSet(),
       _boundingSetToSend(),
       _ptrIntersectionBoundingSet(NULL),
       _ptrMaxPRBoundingSet(NULL) {
 }
 
 TMMBRHelp::~TMMBRHelp() {
   delete [] _ptrIntersectionBoundingSet;
   delete [] _ptrMaxPRBoundingSet;
   _ptrIntersectionBoundingSet = 0;
   _ptrMaxPRBoundingSet = 0;
-  delete _criticalSection;
 }
 
 TMMBRSet*
 TMMBRHelp::VerifyAndAllocateBoundingSet(uint32_t minimumSize)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     if(minimumSize > _boundingSet.capacity())
     {
         // make sure that our buffers are big enough
         if(_ptrIntersectionBoundingSet)
         {
             delete [] _ptrIntersectionBoundingSet;
             delete [] _ptrMaxPRBoundingSet;
         }
         _ptrIntersectionBoundingSet = new float[minimumSize];
         _ptrMaxPRBoundingSet = new float[minimumSize];
     }
     _boundingSet.VerifyAndAllocateSet(minimumSize);
     return &_boundingSet;
 }
 
 TMMBRSet* TMMBRHelp::BoundingSet() {
   return &_boundingSet;
 }
 
 int32_t
 TMMBRHelp::SetTMMBRBoundingSetToSend(const TMMBRSet* boundingSetToSend)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     if (boundingSetToSend == NULL)
     {
         _boundingSetToSend.clearSet();
         return 0;
     }
 
     VerifyAndAllocateBoundingSetToSend(boundingSetToSend->lengthOfSet());
     _boundingSetToSend.clearSet();
     for (uint32_t i = 0; i < boundingSetToSend->lengthOfSet(); i++)
     {
         // cap at our configured max bitrate
         uint32_t bitrate = boundingSetToSend->Tmmbr(i);
         _boundingSetToSend.SetEntry(i, bitrate,
                                     boundingSetToSend->PacketOH(i),
                                     boundingSetToSend->Ssrc(i));
     }
     return 0;
 }
 
 int32_t
 TMMBRHelp::VerifyAndAllocateBoundingSetToSend(uint32_t minimumSize)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     _boundingSetToSend.VerifyAndAllocateSet(minimumSize);
     return 0;
 }
 
 TMMBRSet*
 TMMBRHelp::VerifyAndAllocateCandidateSet(uint32_t minimumSize)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     _candidateSet.VerifyAndAllocateSet(minimumSize);
     return &_candidateSet;
 }
 
 TMMBRSet*
 TMMBRHelp::CandidateSet()
 {
     return &_candidateSet;
 }
 
 TMMBRSet*
 TMMBRHelp::BoundingSetToSend()
 {
     return &_boundingSetToSend;
 }
 
 int32_t
 TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     // Work on local variable, will be modified
     TMMBRSet    candidateSet;
     candidateSet.VerifyAndAllocateSet(_candidateSet.capacity());
 
     for (uint32_t i = 0; i < _candidateSet.size(); i++)
     {
         if(_candidateSet.Tmmbr(i))
         {
             candidateSet.AddEntry(_candidateSet.Tmmbr(i),
@@ skipping 22 matching lines @@
         }
         boundingSet = &_boundingSet;
     }
     return numBoundingSet;
 }
 
 
 int32_t
 TMMBRHelp::FindTMMBRBoundingSet(int32_t numCandidates, TMMBRSet& candidateSet)
 {
-    CriticalSectionScoped lock(_criticalSection);
+    rtc::CritScope lock(&_criticalSection);
 
     uint32_t numBoundingSet = 0;
     VerifyAndAllocateBoundingSet(candidateSet.capacity());
 
     if (numCandidates == 1)
     {
         for (uint32_t i = 0; i < candidateSet.size(); i++)
         {
             if (candidateSet.Tmmbr(i) > 0)
             {
@@ skipping 184 matching lines @@
         }
 
         // 9. Go back to step 5 if any tuple remains in candidate list
     } while (numCandidates > 0);
 
     return numBoundingSet;
 }
 
 bool TMMBRHelp::IsOwner(const uint32_t ssrc,
                         const uint32_t length) const {
-  CriticalSectionScoped lock(_criticalSection);
+  rtc::CritScope lock(&_criticalSection);
 
   if (length == 0) {
     // Empty bounding set.
     return false;
   }
   for(uint32_t i = 0;
       (i < length) && (i < _boundingSet.size()); ++i) {
     if(_boundingSet.Ssrc(i) == ssrc) {
       return true;
     }
   }
   return false;
 }
 
 bool TMMBRHelp::CalcMinBitRate( uint32_t* minBitrateKbit) const {
-  CriticalSectionScoped lock(_criticalSection);
+  rtc::CritScope lock(&_criticalSection);
 
   if (_candidateSet.size() == 0) {
     // Empty bounding set.
     return false;
   }
   *minBitrateKbit = std::numeric_limits<uint32_t>::max();
 
   for (uint32_t i = 0; i < _candidateSet.lengthOfSet(); ++i) {
     uint32_t curNetBitRateKbit = _candidateSet.Tmmbr(i);
     if (curNetBitRateKbit < MIN_VIDEO_BW_MANAGEMENT_BITRATE) {
       curNetBitRateKbit = MIN_VIDEO_BW_MANAGEMENT_BITRATE;
     }
     *minBitrateKbit = curNetBitRateKbit < *minBitrateKbit ?
         curNetBitRateKbit : *minBitrateKbit;
   }
   return true;
 }
 }  // namespace webrtc