Remove repeat flag from SendRTCP

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 110 matching lines @@
   size_t bytes_sent_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacketContainer);
 };
 
 class RTCPSender::RtcpContext {
  public:
   RtcpContext(const FeedbackState& feedback_state,
               int32_t nack_size,
               const uint16_t* nack_list,
-              bool repeat,
               uint64_t picture_id,
               NtpTime now)
       : feedback_state_(feedback_state),
         nack_size_(nack_size),
         nack_list_(nack_list),
-        repeat_(repeat),
         picture_id_(picture_id),
         now_(now) {}
 
   const FeedbackState& feedback_state_;
   const int32_t nack_size_;
   const uint16_t* nack_list_;
-  const bool repeat_;
   const uint64_t picture_id_;
   const NtpTime now_;
 };
 
 RTCPSender::RTCPSender(
     bool audio,
     Clock* clock,
     ReceiveStatistics* receive_statistics,
     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
     RtcEventLog* event_log,
@@ skipping 340 matching lines @@
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::PLI");
   ++packet_type_counter_.pli_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_PLICount",
                     ssrc_, packet_type_counter_.pli_packets);
 
   return std::unique_ptr<rtcp::RtcpPacket>(pli);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
-  if (!ctx.repeat_)
-    ++sequence_number_fir_;  // Do not increase if repetition.
+  ++sequence_number_fir_;
 
   rtcp::Fir* fir = new rtcp::Fir();
   fir->SetSenderSsrc(ssrc_);
   fir->AddRequestTo(remote_ssrc_, sequence_number_fir_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::FIR");
   ++packet_type_counter_.fir_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_FIRCount",
                     ssrc_, packet_type_counter_.fir_packets);
@@ skipping 215 matching lines @@
     xr->SetVoipMetric(voip);
   }
 
   return std::move(xr);
 }
 
 int32_t RTCPSender::SendRTCP(const FeedbackState& feedback_state,
                              RTCPPacketType packetType,
                              int32_t nack_size,
                              const uint16_t* nack_list,
-                             bool repeat,
                              uint64_t pictureID) {
   return SendCompoundRTCP(
       feedback_state, std::set<RTCPPacketType>(&packetType, &packetType + 1),
-      nack_size, nack_list, repeat, pictureID);
+      nack_size, nack_list, pictureID);
 }
 
 int32_t RTCPSender::SendCompoundRTCP(
     const FeedbackState& feedback_state,
     const std::set<RTCPPacketType>& packet_types,
     int32_t nack_size,
     const uint16_t* nack_list,
-    bool repeat,
     uint64_t pictureID) {
   PacketContainer container(transport_, event_log_);
   {
     rtc::CritScope lock(&critical_section_rtcp_sender_);
     if (method_ == RtcpMode::kOff) {
       LOG(LS_WARNING) << "Can't send rtcp if it is disabled.";
       return -1;
     }
     // Add all flags as volatile. Non volatile entries will not be overwritten.
     // All new volatile flags added will be consumed by the end of this call.
@@ skipping 12 matching lines @@
       if (sending_ && method_ == RtcpMode::kCompound) {
         // Not allowed to send any RTCP packet without sender report.
         return -1;
       }
     }
 
     if (packet_type_counter_.first_packet_time_ms == -1)
       packet_type_counter_.first_packet_time_ms = clock_->TimeInMilliseconds();
 
     // We need to send our NTP even if we haven't received any reports.
-    RtcpContext context(feedback_state, nack_size, nack_list, repeat, pictureID,
+    RtcpContext context(feedback_state, nack_size, nack_list, pictureID,
                         NtpTime(*clock_));
 
     PrepareReport(feedback_state);
 
     std::unique_ptr<rtcp::RtcpPacket> packet_bye;
 
     auto it = report_flags_.begin();
     while (it != report_flags_.end()) {
       auto builder_it = builders_.find(it->type);
       RTC_DCHECK(builder_it != builders_.end())
@@ skipping 257 matching lines @@
       return false;
   }
 
   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