TMMBRHelp moved from member object/base class to stack object,

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 65 matching lines @@
 TMMBRHelp::~TMMBRHelp() {
   delete [] _ptrIntersectionBoundingSet;
   delete [] _ptrMaxPRBoundingSet;
   _ptrIntersectionBoundingSet = 0;
   _ptrMaxPRBoundingSet = 0;
 }
 
 TMMBRSet*
 TMMBRHelp::VerifyAndAllocateBoundingSet(uint32_t minimumSize)
 {
-    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;
 }
 
 TMMBRSet*
 TMMBRHelp::VerifyAndAllocateCandidateSet(uint32_t minimumSize)
 {
-    rtc::CritScope lock(&_criticalSection);
-
     _candidateSet.VerifyAndAllocateSet(minimumSize);
     return &_candidateSet;
 }
 
 TMMBRSet*
 TMMBRHelp::CandidateSet()
 {
     return &_candidateSet;
 }
 
 int32_t
 TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet)
 {
-    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),
                                   _candidateSet.PacketOH(i),
@@ skipping 21 matching lines @@
         }
         boundingSet = &_boundingSet;
     }
     return numBoundingSet;
 }
 
 
 int32_t
 TMMBRHelp::FindTMMBRBoundingSet(int32_t numCandidates, TMMBRSet& candidateSet)
 {
-    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)
             {
                 _boundingSet.AddEntry(candidateSet.Tmmbr(i),
@@ skipping 183 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 {
-  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 {
-  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