Take smaller interface for RtpRtcp::Configuration::receive_statistics

webrtc/modules/rtp_rtcp/source/rtcp_sender.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 121 matching lines @@
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
   const NtpTime now_;
 };
 
 RTCPSender::RTCPSender(
     bool audio,
     Clock* clock,
-    ReceiveStatistics* receive_statistics,
+    ReceiveStatisticsProvider* receive_statistics,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcEventLog* event_log,
     Transport* outgoing_transport)
     : audio_(audio),
       clock_(clock),
       random_(clock_->TimeInMicroseconds()),
       method_(RtcpMode::kOff),
       event_log_(event_log),
       transport_(outgoing_transport),
       using_nack_(false),
@@ skipping 676 matching lines @@
     RTC_DCHECK(!(IsFlagPresent(kRtcpSr) && IsFlagPresent(kRtcpRr)));
   }
 }
 
 std::vector<rtcp::ReportBlock> RTCPSender::CreateReportBlocks(
     const FeedbackState& feedback_state) {
   std::vector<rtcp::ReportBlock> result;
   if (!receive_statistics_)
     return result;
 
-  StatisticianMap statisticians = receive_statistics_->GetActiveStatisticians();
-  result.reserve(statisticians.size());
-  for (auto& statistician : statisticians) {
-    // Do we have receive statistics to send?
-    RtcpStatistics stats;
-    if (!statistician.second->GetStatistics(&stats, true))
-      continue;
-    // TODO(danilchap): Support sending more than |RTCP_MAX_REPORT_BLOCKS| per
-    // compound rtcp packet when single rtcp module is used for multiple media
-    // streams.
-    if (result.size() >= RTCP_MAX_REPORT_BLOCKS) {
-      LOG(LS_WARNING) << "Too many report blocks.";
-      continue;
-    }
-    result.emplace_back();
-    rtcp::ReportBlock& block = result.back();
-    block.SetMediaSsrc(statistician.first);
-    block.SetFractionLost(stats.fraction_lost);
-    if (!block.SetCumulativeLost(stats.cumulative_lost)) {
-      LOG(LS_WARNING) << "Cumulative lost is oversized.";
-      result.pop_back();
-      continue;
-    }
-    block.SetExtHighestSeqNum(stats.extended_max_sequence_number);
-    block.SetJitter(stats.jitter);
-  }
+  // TODO(danilchap): Support sending more than |RTCP_MAX_REPORT_BLOCKS| per
+  // compound rtcp packet when single rtcp module is used for multiple media
+  // streams.
+  result = receive_statistics_->RtcpReportBlocks(RTCP_MAX_REPORT_BLOCKS);

[eladalon, 2017/07/27 09:07:31]

nit: Consider not passing this RFC-defined constant, but rather having the
function aware of it itself.

[danilchap, 2017/07/27 10:04:32]

I did that initially, but then introduce this parameter instead for two reasons.
a) One of the shortly-coming CLs plan to call RtcpReportBlocks function passing
1 instead of the constant (it is only test code, but still).
b) In the future, while resolving TODO just above the line, RtcpSender will pass
different values. Those might depend on mtu, presense of other rtcp message,
etc, i.e. responsibility of rtcp sender, but not statistic calculator.

[eladalon, 2017/07/27 10:40:18]

Acknowledged.

 
   if (!result.empty() && ((feedback_state.last_rr_ntp_secs != 0) ||
                           (feedback_state.last_rr_ntp_frac != 0))) {
     // Get our NTP as late as possible to avoid a race.
     uint32_t now = CompactNtp(clock_->CurrentNtpTime());
 
     uint32_t receive_time = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receive_time <<= 16;
     receive_time += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
@@ skipping 132 matching lines @@
     max_packet_size = max_packet_size_;
   }
 
   RTC_DCHECK_LE(max_packet_size, IP_PACKET_SIZE);
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_packet_size, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc