Cleaned out boundingSet member from TMMBRHelp class

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 <algorithm>
 #include <limits>
+#include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 
 namespace webrtc {
 void TMMBRSet::VerifyAndAllocateSet(uint32_t minimumSize) {
   clear();
   reserve(minimumSize);
 }
 
@@ skipping 28 matching lines @@
 
 TMMBRSet* TMMBRHelp::VerifyAndAllocateCandidateSet(uint32_t minimumSize) {
   _candidateSet.VerifyAndAllocateSet(minimumSize);
   return &_candidateSet;
 }
 
 TMMBRSet* TMMBRHelp::CandidateSet() {
   return &_candidateSet;
 }
 
-int32_t TMMBRHelp::FindTMMBRBoundingSet(TMMBRSet*& boundingSet) {
+std::vector<rtcp::TmmbItem> TMMBRHelp::FindTMMBRBoundingSet() {
   // Work on local variable, will be modified
   TMMBRSet candidateSet;
   candidateSet.VerifyAndAllocateSet(_candidateSet.capacity());
 
   for (size_t i = 0; i < _candidateSet.size(); i++) {
     if (_candidateSet.Tmmbr(i)) {
       candidateSet.AddEntry(_candidateSet.Tmmbr(i), _candidateSet.PacketOH(i),
                             _candidateSet.Ssrc(i));
     } else {
       // make sure this is zero if tmmbr = 0
       RTC_DCHECK_EQ(_candidateSet.PacketOH(i), 0u);
       // Old code:
       // _candidateSet.ptrPacketOHSet[i] = 0;
     }
   }
 
   // Number of set candidates
   int32_t numSetCandidates = candidateSet.lengthOfSet();
   // Find bounding set
-  uint32_t numBoundingSet = 0;
+  std::vector<rtcp::TmmbItem> bounding;
   if (numSetCandidates > 0) {
-    FindBoundingSet(std::move(candidateSet), &_boundingSet);
-    numBoundingSet = _boundingSet.size();
-    if (numBoundingSet < 1 || (numBoundingSet > _candidateSet.size())) {
-      return -1;
-    }
-    boundingSet = &_boundingSet;
+    FindBoundingSet(std::move(candidateSet), &bounding);
+    size_t numBoundingSet = bounding.size();
+    RTC_DCHECK_GE(numBoundingSet, 1u);
+    RTC_DCHECK_LE(numBoundingSet, _candidateSet.size());
   }
-  return numBoundingSet;
+  return bounding;
 }
 
 void TMMBRHelp::FindBoundingSet(std::vector<rtcp::TmmbItem> candidates,
                                 std::vector<rtcp::TmmbItem>* bounding_set) {
   RTC_DCHECK(bounding_set);
   RTC_DCHECK(!candidates.empty());
   size_t num_candidates = candidates.size();
 
   if (num_candidates == 1) {
     RTC_DCHECK(candidates[0].bitrate_bps());
@@ skipping 121 matching lines @@
             static_cast<float>(packet_overhead);
       }
       --num_candidates;
       get_new_candidate = true;
     }
 
     // 9. Go back to step 5 if any tuple remains in candidate list.
   }
 }
 
-bool TMMBRHelp::IsOwner(const uint32_t ssrc, const uint32_t length) const {
-  if (length == 0) {
-    // Empty bounding set.
-    return false;
-  }
-  for (size_t i = 0; (i < length) && (i < _boundingSet.size()); ++i) {
-    if (_boundingSet.Ssrc(i) == ssrc) {
+bool TMMBRHelp::IsOwner(const std::vector<rtcp::TmmbItem>& bounding,
+                        uint32_t ssrc) {
+  for (const rtcp::TmmbItem& item : bounding) {
+    if (item.ssrc() == ssrc) {
       return true;
     }
   }
   return false;
 }
 
 bool TMMBRHelp::CalcMinBitRate(uint32_t* minBitrateKbit) const {
   if (_candidateSet.size() == 0) {
     // Empty bounding set.
     return false;
   }
   *minBitrateKbit = std::numeric_limits<uint32_t>::max();
 
   for (size_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