[Splitting] TMMBRHelp class simplifted (and disappear because become too simple)

webrtc/modules/rtp_rtcp/source/rtcp_receiver_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 111 matching lines @@
       readyForDelete(false) {
 }
 
 RTCPReceiveInformation::~RTCPReceiveInformation() {
 }
 
 // Increase size of TMMBRSet if needed, and also take care of
 // the _tmmbrSetTimeouts vector.
 void RTCPReceiveInformation::VerifyAndAllocateTMMBRSet(
     const uint32_t minimumSize) {
-  if (minimumSize > TmmbrSet.sizeOfSet()) {
-    TmmbrSet.VerifyAndAllocateSetKeepingData(minimumSize);
+  if (minimumSize > TmmbrSet.capacity()) {
+    TmmbrSet.reserve(minimumSize);
     // make sure that our buffers are big enough
     _tmmbrSetTimeouts.reserve(minimumSize);
   }
 }
 
 void RTCPReceiveInformation::InsertTMMBRItem(
     const uint32_t senderSSRC,
     const RTCPUtility::RTCPPacketRTPFBTMMBRItem& TMMBRItem,
     const int64_t currentTimeMS) {
   // serach to see if we have it in our list
-  for (uint32_t i = 0; i < TmmbrSet.lengthOfSet(); i++)  {
-    if (TmmbrSet.Ssrc(i) == senderSSRC) {
+  for (uint32_t i = 0; i < TmmbrSet.size(); i++) {
+    if (TmmbrSet[i].ssrc() == senderSSRC) {
       // we already have this SSRC in our list update it
-      TmmbrSet.SetEntry(i,
-                        TMMBRItem.MaxTotalMediaBitRate,
-                        TMMBRItem.MeasuredOverhead,
-                        senderSSRC);
+      TmmbrSet[i].set_bitrate_bps(1000 * TMMBRItem.MaxTotalMediaBitRate);
+      TmmbrSet[i].set_packet_overhead(TMMBRItem.MeasuredOverhead);
       _tmmbrSetTimeouts[i] = currentTimeMS;
       return;
     }
   }
-  VerifyAndAllocateTMMBRSet(TmmbrSet.lengthOfSet() + 1);
-  TmmbrSet.AddEntry(TMMBRItem.MaxTotalMediaBitRate,
-                    TMMBRItem.MeasuredOverhead,
-                    senderSSRC);
+  VerifyAndAllocateTMMBRSet(TmmbrSet.capacity() + 1);
+  TmmbrSet.push_back(rtcp::TmmbItem(senderSSRC,
+                                    TMMBRItem.MaxTotalMediaBitRate * 1000,
+                                    TMMBRItem.MeasuredOverhead));
   _tmmbrSetTimeouts.push_back(currentTimeMS);
 }
 
-int32_t RTCPReceiveInformation::GetTMMBRSet(
-    const uint32_t sourceIdx,
-    const uint32_t targetIdx,
-    TMMBRSet* candidateSet,
-    const int64_t currentTimeMS) {
-  if (sourceIdx >= TmmbrSet.lengthOfSet()) {
-    return -1;
+void RTCPReceiveInformation::GetTMMBRSet(
+    int64_t current_time_ms,
+    std::vector<rtcp::TmmbItem>* candidates) {
+  for (size_t i = 0; i < TmmbrSet.size();) {
+    // use audio define since we don't know what interval the remote peer is
+    // using
+    if (current_time_ms - _tmmbrSetTimeouts[i] > 5 * RTCP_INTERVAL_AUDIO_MS) {
+      // value timed out
+      TmmbrSet.erase(TmmbrSet.begin() + i);
+      _tmmbrSetTimeouts.erase(_tmmbrSetTimeouts.begin() + i);
+    } else {
+      candidates->push_back(TmmbrSet[i]);
+      ++i;
+    }
   }
-  if (targetIdx >= candidateSet->sizeOfSet()) {
-    return -1;
-  }
-  // use audio define since we don't know what interval the remote peer is using
-  if (currentTimeMS - _tmmbrSetTimeouts[sourceIdx] >
-      5 * RTCP_INTERVAL_AUDIO_MS) {
-    // value timed out
-    TmmbrSet.RemoveEntry(sourceIdx);
-    _tmmbrSetTimeouts.erase(_tmmbrSetTimeouts.begin() + sourceIdx);
-    return -1;
-  }
-  candidateSet->SetEntry(targetIdx,
-                         TmmbrSet.Tmmbr(sourceIdx),
-                         TmmbrSet.PacketOH(sourceIdx),
-                         TmmbrSet.Ssrc(sourceIdx));
-  return 0;
 }
 
 void RTCPReceiveInformation::VerifyAndAllocateBoundingSet(
     const uint32_t minimumSize) {
-  TmmbnBoundingSet.VerifyAndAllocateSet(minimumSize);
+  TmmbnBoundingSet.clear();
+  TmmbnBoundingSet.reserve(minimumSize);
 }
 }  // namespace RTCPHelp
 }  // namespace webrtc