Reland of Unify rtcp packet setters

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 431 matching lines @@
   // The timestamp of this RTCP packet should be estimated as the timestamp of
   // the frame being captured at this moment. We are calculating that
   // timestamp as the last frame's timestamp + the time since the last frame
   // was captured.
   uint32_t rtp_timestamp =
       timestamp_offset_ + last_rtp_timestamp_ +
       (clock_->TimeInMilliseconds() - last_frame_capture_time_ms_) *
           (ctx.feedback_state_.frequency_hz / 1000);
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
-  report->From(ssrc_);
-  report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
-  report->WithRtpTimestamp(rtp_timestamp);
-  report->WithPacketCount(ctx.feedback_state_.packets_sent);
-  report->WithOctetCount(ctx.feedback_state_.media_bytes_sent);
+  report->SetSenderSsrc(ssrc_);
+  report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+  report->SetRtpTimestamp(rtp_timestamp);
+  report->SetPacketCount(ctx.feedback_state_.packets_sent);
+  report->SetOctetCount(ctx.feedback_state_.media_bytes_sent);
 
   for (auto it : report_blocks_)
-    report->WithReportBlock(it.second);
+    report->AddReportBlock(it.second);
 
   report_blocks_.clear();
 
   return std::unique_ptr<rtcp::RtcpPacket>(report);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
     const RtcpContext& ctx) {
   size_t length_cname = cname_.length();
   RTC_CHECK_LT(length_cname, static_cast<size_t>(RTCP_CNAME_SIZE));
 
   rtcp::Sdes* sdes = new rtcp::Sdes();
-  sdes->WithCName(ssrc_, cname_);
+  sdes->AddCName(ssrc_, cname_);
 
   for (const auto it : csrc_cnames_)
-    sdes->WithCName(it.first, it.second);
+    sdes->AddCName(it.first, it.second);
 
   return std::unique_ptr<rtcp::RtcpPacket>(sdes);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
   rtcp::ReceiverReport* report = new rtcp::ReceiverReport();
-  report->From(ssrc_);
+  report->SetSenderSsrc(ssrc_);
   for (auto it : report_blocks_)
-    report->WithReportBlock(it.second);
+    report->AddReportBlock(it.second);
 
   report_blocks_.clear();
   return std::unique_ptr<rtcp::RtcpPacket>(report);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
   rtcp::Pli* pli = new rtcp::Pli();
-  pli->From(ssrc_);
-  pli->To(remote_ssrc_);
+  pli->SetSenderSsrc(ssrc_);
+  pli->SetMediaSsrc(remote_ssrc_);
 
   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.
 
   rtcp::Fir* fir = new rtcp::Fir();
-  fir->From(ssrc_);
-  fir->WithRequestTo(remote_ssrc_, sequence_number_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);
 
   return std::unique_ptr<rtcp::RtcpPacket>(fir);
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |            First        |        Number           | PictureID |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
   rtcp::Sli* sli = new rtcp::Sli();
-  sli->From(ssrc_);
-  sli->To(remote_ssrc_);
+  sli->SetSenderSsrc(ssrc_);
+  sli->SetMediaSsrc(remote_ssrc_);
   // Crop picture id to 6 least significant bits.
-  sli->WithPictureId(ctx.picture_id_ & 0x3F);
+  sli->AddPictureId(ctx.picture_id_ & 0x3F);
 
   return std::unique_ptr<rtcp::RtcpPacket>(sli);
 }
 
 /*
     0                   1                   2                   3
     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |      PB       |0| Payload Type|    Native RPSI bit string     |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    |   defined per codec          ...                | Padding (0) |
    +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 /*
 *    Note: not generic made for VP8
 */
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
     const RtcpContext& ctx) {
   if (ctx.feedback_state_.send_payload_type == 0xFF)
     return nullptr;
 
   rtcp::Rpsi* rpsi = new rtcp::Rpsi();
-  rpsi->From(ssrc_);
-  rpsi->To(remote_ssrc_);
-  rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type);
-  rpsi->WithPictureId(ctx.picture_id_);
+  rpsi->SetSenderSsrc(ssrc_);
+  rpsi->SetMediaSsrc(remote_ssrc_);
+  rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type);
+  rpsi->SetPictureId(ctx.picture_id_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(rpsi);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
     const RtcpContext& ctx) {
   rtcp::Remb* remb = new rtcp::Remb();
-  remb->From(ssrc_);
-  for (uint32_t ssrc : remb_ssrcs_)
-    remb->AppliesTo(ssrc);
-  remb->WithBitrateBps(remb_bitrate_);
+  remb->SetSenderSsrc(ssrc_);
+  remb->SetBitrateBps(remb_bitrate_);
+  remb->SetSsrcs(remb_ssrcs_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::REMB");
 
   return std::unique_ptr<rtcp::RtcpPacket>(remb);
 }
 
 void RTCPSender::SetTargetBitrate(unsigned int target_bitrate) {
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   tmmbr_send_bps_ = target_bitrate;
@@ skipping 38 matching lines @@
         // Did not enter bounding set, no meaning to send this request.
         return nullptr;
       }
     }
   }
 
   if (!tmmbr_send_bps_)
     return nullptr;
 
   rtcp::Tmmbr* tmmbr = new rtcp::Tmmbr();
-  tmmbr->From(ssrc_);
+  tmmbr->SetSenderSsrc(ssrc_);
   rtcp::TmmbItem request;
   request.set_ssrc(remote_ssrc_);
   request.set_bitrate_bps(tmmbr_send_bps_);
   request.set_packet_overhead(packet_oh_send_);
-  tmmbr->WithTmmbr(request);
+  tmmbr->AddTmmbr(request);
 
   return std::unique_ptr<rtcp::RtcpPacket>(tmmbr);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
     const RtcpContext& ctx) {
   rtcp::Tmmbn* tmmbn = new rtcp::Tmmbn();
-  tmmbn->From(ssrc_);
+  tmmbn->SetSenderSsrc(ssrc_);
   for (const rtcp::TmmbItem& tmmbr : tmmbn_to_send_) {
     if (tmmbr.bitrate_bps() > 0) {
-      tmmbn->WithTmmbr(tmmbr);
+      tmmbn->AddTmmbr(tmmbr);
     }
   }
 
   return std::unique_ptr<rtcp::RtcpPacket>(tmmbn);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
   rtcp::App* app = new rtcp::App();
-  app->From(ssrc_);
-  app->WithSubType(app_sub_type_);
-  app->WithName(app_name_);
-  app->WithData(app_data_.get(), app_length_);
+  app->SetSsrc(ssrc_);
+  app->SetSubType(app_sub_type_);
+  app->SetName(app_name_);
+  app->SetData(app_data_.get(), app_length_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(app);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
     const RtcpContext& ctx) {
   rtcp::Nack* nack = new rtcp::Nack();
-  nack->From(ssrc_);
-  nack->To(remote_ssrc_);
-  nack->WithList(ctx.nack_list_, ctx.nack_size_);
+  nack->SetSenderSsrc(ssrc_);
+  nack->SetMediaSsrc(remote_ssrc_);
+  nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_);
 
   // Report stats.
   NACKStringBuilder stringBuilder;
   for (int idx = 0; idx < ctx.nack_size_; ++idx) {
     stringBuilder.PushNACK(ctx.nack_list_[idx]);
     nack_stats_.ReportRequest(ctx.nack_list_[idx]);
   }
   packet_type_counter_.nack_requests = nack_stats_.requests();
   packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
 
   TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::NACK", "nacks",
                        TRACE_STR_COPY(stringBuilder.GetResult().c_str()));
   ++packet_type_counter_.nack_packets;
   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RTCP_NACKCount",
                     ssrc_, packet_type_counter_.nack_packets);
 
   return std::unique_ptr<rtcp::RtcpPacket>(nack);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
   rtcp::Bye* bye = new rtcp::Bye();
-  bye->From(ssrc_);
-  for (uint32_t csrc : csrcs_)
-    bye->WithCsrc(csrc);
+  bye->SetSenderSsrc(ssrc_);
+  bye->SetCsrcs(csrcs_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(bye);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
     const RtcpContext& ctx) {
 
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
-  xr->From(ssrc_);
+  xr->SetSenderSsrc(ssrc_);
 
   rtcp::Rrtr rrtr;
-  rrtr.WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+  rrtr.SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
 
-  xr->WithRrtr(rrtr);
+  xr->AddRrtr(rrtr);
 
   // TODO(sprang): Merge XR report sending to contain all of RRTR, DLRR, VOIP?
 
   return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
     const RtcpContext& ctx) {
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
-  xr->From(ssrc_);
+  xr->SetSenderSsrc(ssrc_);
 
   rtcp::Dlrr dlrr;
   const RtcpReceiveTimeInfo& info = ctx.feedback_state_.last_xr_rr;
-  dlrr.WithDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR);
+  dlrr.AddDlrrItem(info.sourceSSRC, info.lastRR, info.delaySinceLastRR);
 
-  xr->WithDlrr(dlrr);
+  xr->AddDlrr(dlrr);
 
   return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
 
 // TODO(sprang): Add a unit test for this, or remove if the code isn't used.
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildVoIPMetric(
     const RtcpContext& context) {
   rtcp::ExtendedReports* xr = new rtcp::ExtendedReports();
-  xr->From(ssrc_);
+  xr->SetSenderSsrc(ssrc_);
 
   rtcp::VoipMetric voip;
-  voip.To(remote_ssrc_);
-  voip.WithVoipMetric(xr_voip_metric_);
+  voip.SetMediaSsrc(remote_ssrc_);
+  voip.SetVoipMetric(xr_voip_metric_);
 
-  xr->WithVoipMetric(voip);
+  xr->AddVoipMetric(voip);
 
   return std::unique_ptr<rtcp::RtcpPacket>(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) {
@@ skipping 150 matching lines @@
   RtcpStatistics stats;
   if (!statistician->GetStatistics(&stats, true))
     return false;
 
   if (report_blocks_.size() >= RTCP_MAX_REPORT_BLOCKS) {
     LOG(LS_WARNING) << "Too many report blocks.";
     return false;
   }
   RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end());
   rtcp::ReportBlock* block = &report_blocks_[ssrc];
-  block->To(ssrc);
-  block->WithFractionLost(stats.fraction_lost);
-  if (!block->WithCumulativeLost(stats.cumulative_lost)) {
+  block->SetMediaSsrc(ssrc);
+  block->SetFractionLost(stats.fraction_lost);
+  if (!block->SetCumulativeLost(stats.cumulative_lost)) {
     report_blocks_.erase(ssrc);
     LOG(LS_WARNING) << "Cumulative lost is oversized.";
     return false;
   }
-  block->WithExtHighestSeqNum(stats.extended_max_sequence_number);
-  block->WithJitter(stats.jitter);
-  block->WithLastSr(feedback_state.remote_sr);
+  block->SetExtHighestSeqNum(stats.extended_max_sequence_number);
+  block->SetJitter(stats.jitter);
+  block->SetLastSr(feedback_state.remote_sr);
 
   // TODO(sprang): Do we really need separate time stamps for each report?
   // Get our NTP as late as possible to avoid a race.
   uint32_t ntp_secs;
   uint32_t ntp_frac;
   clock_->CurrentNtp(ntp_secs, ntp_frac);
 
   // Delay since last received report.
   if ((feedback_state.last_rr_ntp_secs != 0) ||
       (feedback_state.last_rr_ntp_frac != 0)) {
     // Get the 16 lowest bits of seconds and the 16 highest bits of fractions.
     uint32_t now = ntp_secs & 0x0000FFFF;
     now <<= 16;
     now += (ntp_frac & 0xffff0000) >> 16;
 
     uint32_t receiveTime = feedback_state.last_rr_ntp_secs & 0x0000FFFF;
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
-    block->WithDelayLastSr(now - receiveTime);
+    block->SetDelayLastSr(now - receiveTime);
   }
   return true;
 }
 
 void RTCPSender::SetCsrcs(const std::vector<uint32_t>& csrcs) {
   RTC_DCHECK_LE(csrcs.size(), static_cast<size_t>(kRtpCsrcSize));
   rtc::CritScope lock(&critical_section_rtcp_sender_);
   csrcs_ = csrcs;
 }
 
@@ skipping 96 matching lines @@
     // but we can't because of an incorrect warning (C4822) in MVS 2013.
   } sender(transport_, event_log_);
 
   RTC_DCHECK_LE(max_payload_length_, static_cast<size_t>(IP_PACKET_SIZE));
   uint8_t buffer[IP_PACKET_SIZE];
   return packet.BuildExternalBuffer(buffer, max_payload_length_, &sender) &&
          !sender.send_failure_;
 }
 
 }  // namespace webrtc