TMMBRSet become vector<rtcp::TmmbItem>

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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 
 namespace webrtc {
 TMMBRSet::TMMBRSet() :
-    _sizeOfSet(0),
     _lengthOfSet(0)
 {
 }
 
 TMMBRSet::~TMMBRSet()
 {
-    _sizeOfSet = 0;
     _lengthOfSet = 0;
 }
 
 void
 TMMBRSet::VerifyAndAllocateSet(uint32_t minimumSize)
 {
-    if(minimumSize > _sizeOfSet)
+    if(minimumSize > size())
     {
         // make sure that our buffers are big enough
-        _data.resize(minimumSize);
-        _sizeOfSet = minimumSize;
+        resize(minimumSize);
     }
     // reset memory
-    for(uint32_t i = 0; i < _sizeOfSet; i++)
+    for(uint32_t i = 0; i < size(); i++)
     {
-        _data.at(i).tmmbr = 0;
-        _data.at(i).packet_oh = 0;
-        _data.at(i).ssrc = 0;
+        at(i).set_bitrate_bps(0);

[philipel, 2016/02/23 13:46:39]

replace at() with operator[] since at() does bound checking even in release and
throws an exception(!) if it is out of bounds.

[danilchap, 2016/02/23 14:39:47]

exception is not a problem, still better avoid unnecessary range check.
Done.

+        at(i).set_packet_overhead(0);
+        at(i).set_ssrc(0);
     }
     _lengthOfSet = 0;
 }
 
 void
 TMMBRSet::VerifyAndAllocateSetKeepingData(uint32_t minimumSize)
 {
-    if(minimumSize > _sizeOfSet)
+    if(minimumSize > size())
     {
-        {
-          _data.resize(minimumSize);
-        }
-        _sizeOfSet = minimumSize;
+        resize(minimumSize);
     }
 }
 
 void TMMBRSet::SetEntry(unsigned int i,
                          uint32_t tmmbrSet,
                          uint32_t packetOHSet,
                          uint32_t ssrcSet) {
-  assert(i < _sizeOfSet);
-  _data.at(i).tmmbr = tmmbrSet;
-  _data.at(i).packet_oh = packetOHSet;
-  _data.at(i).ssrc = ssrcSet;
+  assert(i < size());

[philipel, 2016/02/23 13:46:39]

Use RTC_DCHECK instead of assert.

[danilchap, 2016/02/23 14:39:47]

Done.

+  at(i).set_bitrate_bps(tmmbrSet * 1000);

[philipel, 2016/02/23 13:46:39]

Again, replace at() with operator[].

[danilchap, 2016/02/23 14:39:47]

Done.

+  at(i).set_packet_overhead(packetOHSet);
+  at(i).set_ssrc(ssrcSet);
   if (i >= _lengthOfSet) {
     _lengthOfSet = i + 1;
   }
 }
 
 void TMMBRSet::AddEntry(uint32_t tmmbrSet,
                         uint32_t packetOHSet,
                         uint32_t ssrcSet) {
-  assert(_lengthOfSet < _sizeOfSet);
+  assert(_lengthOfSet < size());

[philipel, 2016/02/23 13:46:38]

Use RTC_DCHECK.

[danilchap, 2016/02/23 14:39:47]

Done.

   SetEntry(_lengthOfSet, tmmbrSet, packetOHSet, ssrcSet);
 }
 
 void TMMBRSet::RemoveEntry(uint32_t sourceIdx) {
   assert(sourceIdx < _lengthOfSet);

[philipel, 2016/02/23 13:46:38]

RTC_DCHECK :)

[danilchap, 2016/02/23 14:39:47]

Done.

-  _data.erase(_data.begin() + sourceIdx);
+  erase(begin() + sourceIdx);
   _lengthOfSet--;
-  _data.resize(_sizeOfSet);  // Ensure that size remains the same.
+  resize(size()+1);  // Ensure that size remains the same.
 }
 
 void TMMBRSet::SwapEntries(uint32_t i, uint32_t j) {
-    SetElement temp;
-    temp = _data[i];
-    _data[i] = _data[j];
-    _data[j] = temp;
+  using std::swap;
+  swap(at(i), at(j));

[philipel, 2016/02/23 13:46:38]

Remove line 86 and just go for std::swap instead.
Also replace at() with operator[].

[danilchap, 2016/02/23 14:39:47]

But that is not recommended way to use swap function.
Though I know swap function is not overloaded for TmmbItem, still, TmmnItem is
not trivial type, would rather use general style for swap.

 }
 
 void TMMBRSet::ClearEntry(uint32_t idx) {
   SetEntry(idx, 0, 0, 0);
 }
 
 TMMBRHelp::TMMBRHelp()
     : _criticalSection(CriticalSectionWrapper::CreateCriticalSection()),
       _candidateSet(),
       _boundingSet(),
@@ skipping 366 matching lines @@
     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