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.
  */
 
@@ skipping 42 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());

[philipel, 2016/08/09 12:00:24]

Earlier if we failed to find a bounding set then it would result in -1 to be
returned from RTCPReceiver::UpdateTMMBR. I can't find any place where the return
value of RTCPReceiver::UpdateTMMBR is actually used.

So this looks like a potential change in behavior, but the question is if bad
input can trigger these DCHECKS or if it is a programming error. If bad input
can trigger this then don't use DCHECKS.

[danilchap, 2016/08/09 13:02:13]

yes, DCHECK shouldn't be used to validate bad input.

This DCHECKS state that function below can't return empty bounding set nor can
it return more items in bounding set than was in the candidate set. i.e. there
is no such thing as 'failed to find a bounding set' for non-empty candidate set.
I dare to put those DCHECKS only after that function was cleaned.

   }
-  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