Reland of Unify rtcp packet setters (patchset #1 id:1 of https://codereview.webrtc.org/2372713005/ )

Reason for revert:
Fix backward compatibility support

Original issue's description:
> Revert of Unify rtcp packet setters (patchset #8 id:130001 of https://codereview.webrtc.org/2348623003/ )
>
> Reason for revert:
> Breaks compilation of internal downstream project.
>
> Original issue's description:
> > Unify rtcp packet setters
> > Renamed setters in rtcp classes
> > from WithField to SetField
> > from WithItem to AddItem or SetItems
> > from From to SetSenderSsrc
> > from To to SetMediaSsrc
> > Some redundant or unsued setters removed.
> > Pass-by-const& replaced with pass-by-value when appropriate.
> >
> > BUG=webrtc:5260
> >
> > Committed: https://crrev.com/20e77c7b8a9f19942ef3c3c4f1fa3888b2cd54ea
> > Cr-Commit-Position: refs/heads/master@{#14393}
>
> TBR=sprang@webrtc.org,stefan@webrtc.org,danilchap@webrtc.org
> # Skipping CQ checks because original CL landed less than 1 days ago.
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=webrtc:5260
>
> Committed: https://crrev.com/efc6e41866662e0922858fbce1d9ee3bdd0637ed
> Cr-Commit-Position: refs/heads/master@{#14400}

TBR=sprang@webrtc.org,stefan@webrtc.org,kjellander@webrtc.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=webrtc:5260

Review-Url: https://codereview.webrtc.org/2370313002
Cr-Commit-Position: refs/heads/master@{#14402}

webrtc/call/rtc_event_log_unittest.cc

@@ -139,15 +139,14 @@ RtpPacketToSend GenerateRtpPacket(const RtpHeaderExtensionMap* extensions,
 
 rtc::Buffer GenerateRtcpPacket(Random* prng) {
   rtcp::ReportBlock report_block;
-  report_block.To(prng->Rand<uint32_t>());  // Remote SSRC.
+  report_block.SetMediaSsrc(prng->Rand<uint32_t>());  // Remote SSRC.
-  report_block.WithFractionLost(prng->Rand(50));
+  report_block.SetFractionLost(prng->Rand(50));
 
   rtcp::SenderReport sender_report;
-  sender_report.From(prng->Rand<uint32_t>());  // Sender SSRC.
+  sender_report.SetSenderSsrc(prng->Rand<uint32_t>());
-  sender_report.WithNtp(
+  sender_report.SetNtp(NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
-      NtpTime(prng->Rand<uint32_t>(), prng->Rand<uint32_t>()));
+  sender_report.SetPacketCount(prng->Rand<uint32_t>());
-  sender_report.WithPacketCount(prng->Rand<uint32_t>());
+  sender_report.AddReportBlock(report_block);
-  sender_report.WithReportBlock(report_block);
 
   return sender_report.Build();
 }

webrtc/modules/pacing/packet_router.cc

@@ -99,7 +99,7 @@ uint16_t PacketRouter::AllocateSequenceNumber() {
 bool PacketRouter::SendFeedback(rtcp::TransportFeedback* packet) {
   rtc::CritScope cs(&modules_crit_);
   for (auto* rtp_module : rtp_modules_) {
-    packet->WithPacketSenderSsrc(rtp_module->SSRC());
+    packet->SetSenderSsrc(rtp_module->SSRC());
     if (rtp_module->SendFeedbackPacket(*packet))
       return true;
   }

webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.cc

@@ -152,15 +152,15 @@ bool RemoteEstimatorProxy::BuildFeedbackPacket(
   // TODO(sprang): Measure receive times in microseconds and remove the
   // conversions below.
   const int64_t first_sequence = it->first;
-  feedback_packet->WithMediaSourceSsrc(media_ssrc_);
+  feedback_packet->SetMediaSsrc(media_ssrc_);
   // Base sequence is the expected next (window_start_seq_). This is known, but
   // we might not have actually received it, so the base time shall be the time
   // of the first received packet in the feedback.
-  feedback_packet->WithBase(static_cast<uint16_t>(window_start_seq_ & 0xFFFF),
+  feedback_packet->SetBase(static_cast<uint16_t>(window_start_seq_ & 0xFFFF),
                            it->second * 1000);
-  feedback_packet->WithFeedbackSequenceNumber(feedback_sequence_++);
+  feedback_packet->SetFeedbackSequenceNumber(feedback_sequence_++);
   for (; it != packet_arrival_times_.end(); ++it) {
-    if (!feedback_packet->WithReceivedPacket(
+    if (!feedback_packet->AddReceivedPacket(
             static_cast<uint16_t>(it->first & 0xFFFF), it->second * 1000)) {
       // If we can't even add the first seq to the feedback packet, we won't be
       // able to build it at all.

webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc

@@ -67,7 +67,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -92,7 +92,7 @@ TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -123,7 +123,7 @@ TEST_F(RemoteEstimatorProxyTest, FeedbackWithMissingStart) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq + 2, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -152,7 +152,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -188,7 +188,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) {
       .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -207,7 +207,7 @@ TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) {
       .WillOnce(Invoke([kTooLargeDelta, this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<rtcp::TransportFeedback::StatusSymbol> status_vec =
             packet->GetStatusVector();
@@ -236,7 +236,7 @@ TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
@@ -256,7 +256,7 @@ TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(2u, delta_vec.size());
@@ -274,7 +274,7 @@ TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) {
       .WillOnce(Invoke([this](rtcp::TransportFeedback* packet) {
         packet->Build();
         EXPECT_EQ(kBaseSeq + 1, packet->GetBaseSequence());
-        EXPECT_EQ(kMediaSsrc, packet->GetMediaSourceSsrc());
+        EXPECT_EQ(kMediaSsrc, packet->media_ssrc());
 
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(2u, delta_vec.size());

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc

@@ -125,11 +125,11 @@ TEST_F(TransportFeedbackAdapterTest, AdaptsFeedbackAndPopulatesSendTimes) {
     OnSentPacket(packet);
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
+  feedback.SetBase(packets[0].sequence_number,
                    packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : packets) {
-    EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
+    EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
                                            packet.arrival_time_ms * 1000));
   }
 
@@ -161,12 +161,12 @@ TEST_F(TransportFeedbackAdapterTest, HandlesDroppedPackets) {
   }
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
+  feedback.SetBase(packets[0].sequence_number,
                    packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : packets) {
     if (packet.sequence_number <= kReceiveSideDropAfter) {
-      EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
+      EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
                                              packet.arrival_time_ms * 1000));
     }
   }
@@ -204,11 +204,11 @@ TEST_F(TransportFeedbackAdapterTest, SendTimeWrapsBothWays) {
   for (size_t i = 0; i < packets.size(); ++i) {
     std::unique_ptr<rtcp::TransportFeedback> feedback(
         new rtcp::TransportFeedback());
-    feedback->WithBase(packets[i].sequence_number,
+    feedback->SetBase(packets[i].sequence_number,
                       packets[i].arrival_time_ms * 1000);
 
-    EXPECT_TRUE(feedback->WithReceivedPacket(
+    EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number,
-        packets[i].sequence_number, packets[i].arrival_time_ms * 1000));
+                                            packets[i].arrival_time_ms * 1000));
 
     rtc::Buffer raw_packet = feedback->Build();
     feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
@@ -241,11 +241,11 @@ TEST_F(TransportFeedbackAdapterTest, HandlesReordering) {
     OnSentPacket(packet);
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
+  feedback.SetBase(packets[0].sequence_number,
                    packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : packets) {
-    EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
+    EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
                                            packet.arrival_time_ms * 1000));
   }
 
@@ -310,14 +310,14 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
   // Create expected feedback and send into adapter.
   std::unique_ptr<rtcp::TransportFeedback> feedback(
       new rtcp::TransportFeedback());
-  feedback->WithBase(sent_packets[0].sequence_number,
+  feedback->SetBase(sent_packets[0].sequence_number,
                     sent_packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : sent_packets) {
-    EXPECT_TRUE(feedback->WithReceivedPacket(packet.sequence_number,
+    EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number,
                                             packet.arrival_time_ms * 1000));
   }
-  EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number,
+  EXPECT_FALSE(feedback->AddReceivedPacket(info.sequence_number,
                                            info.arrival_time_ms * 1000));
 
   rtc::Buffer raw_packet = feedback->Build();
@@ -338,8 +338,8 @@ TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
 
   // Create a new feedback message and add the trailing item.
   feedback.reset(new rtcp::TransportFeedback());
-  feedback->WithBase(info.sequence_number, info.arrival_time_ms * 1000);
+  feedback->SetBase(info.sequence_number, info.arrival_time_ms * 1000);
-  EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number,
+  EXPECT_TRUE(feedback->AddReceivedPacket(info.sequence_number,
                                           info.arrival_time_ms * 1000));
   raw_packet = feedback->Build();
   feedback =

webrtc/modules/rtp_rtcp/source/rtcp_packet.h

@@ -21,16 +21,16 @@ namespace rtcp {
 //
 //  Example:
 //  ReportBlock report_block;
-//  report_block.To(234);
+//  report_block.SetMediaSsrc(234);
-//  report_block.WithFractionLost(10);
+//  report_block.SetFractionLost(10);
 //
 //  ReceiverReport rr;
-//  rr.From(123);
+//  rr.SetSenderSsrc(123);
-//  rr.WithReportBlock(report_block);
+//  rr.AddReportBlock(report_block);
 //
 //  Fir fir;
-//  fir.From(123);
+//  fir.SetSenderSsrc(123);
-//  fir.WithRequestTo(234, 56);
+//  fir.AddRequestTo(234, 56);
 //
 //  size_t length = 0;                     // Builds an intra frame request
 //  uint8_t packet[kPacketSize];           // with sequence number 56.

webrtc/modules/rtp_rtcp/source/rtcp_packet/app.cc

@@ -51,12 +51,12 @@ bool App::Parse(const CommonHeader& packet) {
   return true;
 }
 
-void App::WithSubType(uint8_t subtype) {
+void App::SetSubType(uint8_t subtype) {
   RTC_DCHECK_LE(subtype, 0x1f);
   sub_type_ = subtype;
 }
 
-void App::WithData(const uint8_t* data, size_t data_length) {
+void App::SetData(const uint8_t* data, size_t data_length) {
   RTC_DCHECK(data);
   RTC_DCHECK_EQ(data_length % 4, 0u) << "Data must be 32 bits aligned.";
   RTC_DCHECK_LE(data_length, kMaxDataSize) << "App data size " << data_length

webrtc/modules/rtp_rtcp/source/rtcp_packet/app.h

@@ -28,10 +28,10 @@ class App : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void From(uint32_t ssrc) { ssrc_ = ssrc; }
+  void SetSsrc(uint32_t ssrc) { ssrc_ = ssrc; }
-  void WithSubType(uint8_t subtype);
+  void SetSubType(uint8_t subtype);
-  void WithName(uint32_t name) { name_ = name; }
+  void SetName(uint32_t name) { name_ = name; }
-  void WithData(const uint8_t* data, size_t data_length);
+  void SetData(const uint8_t* data, size_t data_length);
 
   uint8_t sub_type() const { return sub_type_; }
   uint32_t ssrc() const { return ssrc_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/app_unittest.cc

@@ -53,9 +53,9 @@ constexpr uint8_t kPacketWithUnalignedPayload[] = {
 
 TEST(RtcpPacketAppTest, CreateWithoutData) {
   App app;
-  app.From(kSenderSsrc);
+  app.SetSsrc(kSenderSsrc);
-  app.WithSubType(kSubtype);
+  app.SetSubType(kSubtype);
-  app.WithName(kName);
+  app.SetName(kName);
 
   rtc::Buffer raw = app.Build();
 
@@ -75,10 +75,10 @@ TEST(RtcpPacketAppTest, ParseWithoutData) {
 
 TEST(RtcpPacketAppTest, CreateWithData) {
   App app;
-  app.From(kSenderSsrc);
+  app.SetSsrc(kSenderSsrc);
-  app.WithSubType(kSubtype);
+  app.SetSubType(kSubtype);
-  app.WithName(kName);
+  app.SetName(kName);
-  app.WithData(kData, sizeof(kData));
+  app.SetData(kData, sizeof(kData));
 
   rtc::Buffer raw = app.Build();
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.cc

@@ -10,6 +10,8 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
@@ -109,18 +111,18 @@ bool Bye::Create(uint8_t* packet,
   return true;
 }
 
-bool Bye::WithCsrc(uint32_t csrc) {
+bool Bye::SetCsrcs(std::vector<uint32_t> csrcs) {
-  if (csrcs_.size() >= kMaxNumberOfCsrcs) {
+  if (csrcs.size() > kMaxNumberOfCsrcs) {
-    LOG(LS_WARNING) << "Max CSRC size reached.";
+    LOG(LS_WARNING) << "Too many CSRCs for Bye packet.";
     return false;
   }
-  csrcs_.push_back(csrc);
+  csrcs_ = std::move(csrcs);
   return true;
 }
 
-void Bye::WithReason(const std::string& reason) {
+void Bye::SetReason(std::string reason) {
   RTC_DCHECK_LE(reason.size(), 0xffu);
-  reason_ = reason;
+  reason_ = std::move(reason);
 }
 
 size_t Bye::BlockLength() const {

webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h

@@ -32,9 +32,9 @@ class Bye : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
-  bool WithCsrc(uint32_t csrc);
+  bool SetCsrcs(std::vector<uint32_t> csrcs);
-  void WithReason(const std::string& reason);
+  void SetReason(std::string reason);
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }
   const std::vector<uint32_t>& csrcs() const { return csrcs_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/bye_unittest.cc

@@ -26,7 +26,7 @@ const uint32_t kCsrc2 = 0x33343536;
 
 TEST(RtcpPacketByeTest, CreateAndParseWithoutReason) {
   Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
 
   rtc::Buffer raw = bye.Build();
   Bye parsed_bye;
@@ -39,9 +39,8 @@ TEST(RtcpPacketByeTest, CreateAndParseWithoutReason) {
 
 TEST(RtcpPacketByeTest, CreateAndParseWithCsrcs) {
   Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(bye.WithCsrc(kCsrc1));
+  EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2}));
-  EXPECT_TRUE(bye.WithCsrc(kCsrc2));
   EXPECT_TRUE(bye.reason().empty());
 
   rtc::Buffer raw = bye.Build();
@@ -57,10 +56,9 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) {
   Bye bye;
   const std::string kReason = "Some Reason";
 
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(bye.WithCsrc(kCsrc1));
+  EXPECT_TRUE(bye.SetCsrcs({kCsrc1, kCsrc2}));
-  EXPECT_TRUE(bye.WithCsrc(kCsrc2));
+  bye.SetReason(kReason);
-  bye.WithReason(kReason);
 
   rtc::Buffer raw = bye.Build();
   Bye parsed_bye;
@@ -73,20 +71,18 @@ TEST(RtcpPacketByeTest, CreateAndParseWithCsrcsAndAReason) {
 
 TEST(RtcpPacketByeTest, CreateWithTooManyCsrcs) {
   Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
   const int kMaxCsrcs = (1 << 5) - 2;  // 5 bit len, first item is sender SSRC.
-  for (int i = 0; i < kMaxCsrcs; ++i) {
+  EXPECT_TRUE(bye.SetCsrcs(std::vector<uint32_t>(kMaxCsrcs, kCsrc1)));
-    EXPECT_TRUE(bye.WithCsrc(i));
+  EXPECT_FALSE(bye.SetCsrcs(std::vector<uint32_t>(kMaxCsrcs + 1, kCsrc1)));
-  }
-  EXPECT_FALSE(bye.WithCsrc(kMaxCsrcs));
 }
 
 TEST(RtcpPacketByeTest, CreateAndParseWithAReason) {
   Bye bye;
   const std::string kReason = "Some Random Reason";
 
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
-  bye.WithReason(kReason);
+  bye.SetReason(kReason);
 
   rtc::Buffer raw = bye.Build();
   Bye parsed_bye;
@@ -103,8 +99,8 @@ TEST(RtcpPacketByeTest, CreateAndParseWithReasons) {
   for (size_t reminder = 0; reminder < 4; ++reminder) {
     const std::string kReason(4 + reminder, 'a' + reminder);
     Bye bye;
-    bye.From(kSenderSsrc);
+    bye.SetSenderSsrc(kSenderSsrc);
-    bye.WithReason(kReason);
+    bye.SetReason(kReason);
 
     rtc::Buffer raw = bye.Build();
     Bye parsed_bye;
@@ -125,7 +121,7 @@ TEST(RtcpPacketByeTest, ParseEmptyPacket) {
 
 TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) {
   Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
 
   rtc::Buffer raw = bye.Build();
   raw[0]++;  // Damage the packet: increase ssrc count by one.
@@ -136,8 +132,8 @@ TEST(RtcpPacketByeTest, ParseFailOnInvalidSrcCount) {
 
 TEST(RtcpPacketByeTest, ParseFailOnInvalidReasonLength) {
   Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
-  bye.WithReason("18 characters long");
+  bye.SetReason("18 characters long");
 
   rtc::Buffer raw = bye.Build();
   // Damage the packet: decrease payload size by 4 bytes

webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet_unittest.cc

@@ -35,11 +35,11 @@ const uint8_t kSeqNo = 13;
 TEST(RtcpCompoundPacketTest, AppendPacket) {
   CompoundPacket compound;
   Fir fir;
-  fir.WithRequestTo(kRemoteSsrc, kSeqNo);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNo);
   ReportBlock rb;
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(rr.WithReportBlock(rb));
+  EXPECT_TRUE(rr.AddReportBlock(rb));
   compound.Append(&rr);
   compound.Append(&fir);
 
@@ -56,12 +56,12 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
   CompoundPacket root;
   CompoundPacket leaf;
   Fir fir;
-  fir.WithRequestTo(kRemoteSsrc, kSeqNo);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNo);
   Bye bye;
   ReportBlock rb;
 
   ReceiverReport rr;
-  EXPECT_TRUE(rr.WithReportBlock(rb));
+  EXPECT_TRUE(rr.AddReportBlock(rb));
   leaf.Append(&rr);
   leaf.Append(&fir);
 
@@ -83,11 +83,11 @@ TEST(RtcpCompoundPacketTest, AppendPacketWithOwnAppendedPacket) {
 TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
   CompoundPacket compound;
   Fir fir;
-  fir.WithRequestTo(kRemoteSsrc, kSeqNo);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNo);
   ReportBlock rb;
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(rr.WithReportBlock(rb));
+  EXPECT_TRUE(rr.AddReportBlock(rb));
   compound.Append(&rr);
   compound.Append(&fir);
 
@@ -117,11 +117,11 @@ TEST(RtcpCompoundPacketTest, BuildWithInputBuffer) {
 TEST(RtcpCompoundPacketTest, BuildWithTooSmallBuffer_FragmentedSend) {
   CompoundPacket compound;
   Fir fir;
-  fir.WithRequestTo(kRemoteSsrc, kSeqNo);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNo);
   ReportBlock rb;
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(rr.WithReportBlock(rb));
+  EXPECT_TRUE(rr.AddReportBlock(rb));
   compound.Append(&rr);
   compound.Append(&fir);
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.cc

@@ -81,7 +81,7 @@ void Dlrr::Create(uint8_t* buffer) const {
   RTC_DCHECK_EQ(buffer + BlockLength(), write_at);
 }
 
-bool Dlrr::WithDlrrItem(const ReceiveTimeInfo& block) {
+bool Dlrr::AddDlrrItem(const ReceiveTimeInfo& block) {
   if (sub_blocks_.size() >= kMaxNumberOfDlrrItems) {
     LOG(LS_WARNING) << "Max DLRR items reached.";
     return false;
@@ -90,14 +90,14 @@ bool Dlrr::WithDlrrItem(const ReceiveTimeInfo& block) {
   return true;
 }
 
-bool Dlrr::WithDlrrItem(uint32_t ssrc,
+bool Dlrr::AddDlrrItem(uint32_t ssrc,
                        uint32_t last_rr,
                        uint32_t delay_last_rr) {
   ReceiveTimeInfo block;
   block.ssrc = ssrc;
   block.last_rr = last_rr;
   block.delay_since_last_rr = delay_last_rr;
-  return WithDlrrItem(block);
+  return AddDlrrItem(block);
 }
 }  // namespace rtcp
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h

@@ -50,8 +50,8 @@ class Dlrr {
   void Create(uint8_t* buffer) const;
 
   // Max 100 DLRR Items can be added per DLRR report block.
-  bool WithDlrrItem(const ReceiveTimeInfo& time_info);
+  bool AddDlrrItem(const ReceiveTimeInfo& time_info);
-  bool WithDlrrItem(uint32_t ssrc, uint32_t last_rr, uint32_t delay_last_rr);
+  bool AddDlrrItem(uint32_t ssrc, uint32_t last_rr, uint32_t delay_last_rr);
 
   const std::vector<ReceiveTimeInfo>& sub_blocks() const { return sub_blocks_; }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr_unittest.cc

@@ -35,7 +35,7 @@ TEST(RtcpPacketDlrrTest, Empty) {
 
 TEST(RtcpPacketDlrrTest, Create) {
   Dlrr dlrr;
-  EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc, kLastRR, kDelay));
+  EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc, kLastRR, kDelay));
 
   ASSERT_EQ(kBlockSizeBytes, dlrr.BlockLength());
   uint8_t buffer[kBlockSizeBytes];
@@ -73,9 +73,9 @@ TEST(RtcpPacketDlrrTest, ParseFailsOnBadSize) {
 TEST(RtcpPacketDlrrTest, FailsOnTooManySubBlocks) {
   Dlrr dlrr;
   for (size_t i = 1; i <= Dlrr::kMaxNumberOfDlrrItems; ++i) {
-    EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
+    EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
   }
-  EXPECT_FALSE(dlrr.WithDlrrItem(kSsrc, kLastRR, kDelay));
+  EXPECT_FALSE(dlrr.AddDlrrItem(kSsrc, kLastRR, kDelay));
 }
 
 TEST(RtcpPacketDlrrTest, CreateAndParseMaxSubBlocks) {
@@ -85,7 +85,7 @@ TEST(RtcpPacketDlrrTest, CreateAndParseMaxSubBlocks) {
   // Create.
   Dlrr dlrr;
   for (size_t i = 1; i <= Dlrr::kMaxNumberOfDlrrItems; ++i) {
-    EXPECT_TRUE(dlrr.WithDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
+    EXPECT_TRUE(dlrr.AddDlrrItem(kSsrc + i, kLastRR + i, kDelay + i));
   }
   size_t used_buffer_size = dlrr.BlockLength();
   ASSERT_LE(used_buffer_size, kBufferSize);

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.cc

@@ -10,6 +10,8 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
@@ -56,12 +58,12 @@ bool ExtendedJitterReport::Parse(const CommonHeader& packet) {
   return true;
 }
 
-bool ExtendedJitterReport::WithJitter(uint32_t jitter) {
+bool ExtendedJitterReport::SetJitterValues(std::vector<uint32_t> values) {
-  if (inter_arrival_jitters_.size() >= kMaxNumberOfJitters) {
+  if (values.size() > kMaxNumberOfJitterValues) {
-    LOG(LS_WARNING) << "Max inter-arrival jitter items reached.";
+    LOG(LS_WARNING) << "Too many inter-arrival jitter items.";
     return false;
   }
-  inter_arrival_jitters_.push_back(jitter);
+  inter_arrival_jitters_ = std::move(values);
   return true;
 }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report.h

@@ -23,6 +23,7 @@ class CommonHeader;
 class ExtendedJitterReport : public RtcpPacket {
  public:
   static constexpr uint8_t kPacketType = 195;
+  static constexpr size_t kMaxNumberOfJitterValues = 0x1f;
 
   ExtendedJitterReport() {}
   ~ExtendedJitterReport() override {}
@@ -30,9 +31,11 @@ class ExtendedJitterReport : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  bool WithJitter(uint32_t jitter);
+  bool SetJitterValues(std::vector<uint32_t> jitter_values);
 
-  const std::vector<uint32_t>& jitters() { return inter_arrival_jitters_; }
+  const std::vector<uint32_t>& jitter_values() {
+    return inter_arrival_jitters_;
+  }
 
  protected:
   bool Create(uint8_t* packet,
@@ -41,7 +44,6 @@ class ExtendedJitterReport : public RtcpPacket {
               RtcpPacket::PacketReadyCallback* callback) const override;
 
  private:
-  static constexpr size_t kMaxNumberOfJitters = 0x1f;
   static constexpr size_t kJitterSizeBytes = 4;
 
   size_t BlockLength() const override {

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_jitter_report_unittest.cc

@@ -31,44 +31,42 @@ TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithoutItems) {
   ExtendedJitterReport parsed;
   EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
 
-  EXPECT_THAT(parsed.jitters(), IsEmpty());
+  EXPECT_THAT(parsed.jitter_values(), IsEmpty());
 }
 
 TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithOneItem) {
   ExtendedJitterReport ij;
-  EXPECT_TRUE(ij.WithJitter(kJitter1));
+  EXPECT_TRUE(ij.SetJitterValues({kJitter1}));
   rtc::Buffer raw = ij.Build();
 
   ExtendedJitterReport parsed;
   EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
 
-  EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1));
+  EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1));
 }
 
 TEST(RtcpPacketExtendedJitterReportTest, CreateAndParseWithTwoItems) {
   ExtendedJitterReport ij;
-  EXPECT_TRUE(ij.WithJitter(kJitter1));
+  EXPECT_TRUE(ij.SetJitterValues({kJitter1, kJitter2}));
-  EXPECT_TRUE(ij.WithJitter(kJitter2));
   rtc::Buffer raw = ij.Build();
 
   ExtendedJitterReport parsed;
   EXPECT_TRUE(test::ParseSinglePacket(raw, &parsed));
 
-  EXPECT_THAT(parsed.jitters(), ElementsAre(kJitter1, kJitter2));
+  EXPECT_THAT(parsed.jitter_values(), ElementsAre(kJitter1, kJitter2));
 }
 
 TEST(RtcpPacketExtendedJitterReportTest, CreateWithTooManyItems) {
   ExtendedJitterReport ij;
-  const int kMaxIjItems = (1 << 5) - 1;
+  const int kMaxItems = ExtendedJitterReport::kMaxNumberOfJitterValues;
-  for (int i = 0; i < kMaxIjItems; ++i) {
+  EXPECT_FALSE(
-    EXPECT_TRUE(ij.WithJitter(i));
+      ij.SetJitterValues(std::vector<uint32_t>(kMaxItems + 1, kJitter1)));
-  }
+  EXPECT_TRUE(ij.SetJitterValues(std::vector<uint32_t>(kMaxItems, kJitter1)));
-  EXPECT_FALSE(ij.WithJitter(kMaxIjItems));
 }
 
 TEST(RtcpPacketExtendedJitterReportTest, ParseFailsWithTooManyItems) {
   ExtendedJitterReport ij;
-  ij.WithJitter(kJitter1);
+  ij.SetJitterValues({kJitter1});
   rtc::Buffer raw = ij.Build();
   raw[0]++;  // Damage packet: increase jitter count by 1.
   ExtendedJitterReport parsed;

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.cc

@@ -91,7 +91,7 @@ bool ExtendedReports::Parse(const CommonHeader& packet) {
   return true;
 }
 
-bool ExtendedReports::WithRrtr(const Rrtr& rrtr) {
+bool ExtendedReports::AddRrtr(const Rrtr& rrtr) {
   if (rrtr_blocks_.size() >= kMaxNumberOfRrtrBlocks) {
     LOG(LS_WARNING) << "Max RRTR blocks reached.";
     return false;
@@ -100,7 +100,7 @@ bool ExtendedReports::WithRrtr(const Rrtr& rrtr) {
   return true;
 }
 
-bool ExtendedReports::WithDlrr(const Dlrr& dlrr) {
+bool ExtendedReports::AddDlrr(const Dlrr& dlrr) {
   if (dlrr_blocks_.size() >= kMaxNumberOfDlrrBlocks) {
     LOG(LS_WARNING) << "Max DLRR blocks reached.";
     return false;
@@ -109,7 +109,7 @@ bool ExtendedReports::WithDlrr(const Dlrr& dlrr) {
   return true;
 }
 
-bool ExtendedReports::WithVoipMetric(const VoipMetric& voip_metric) {
+bool ExtendedReports::AddVoipMetric(const VoipMetric& voip_metric) {
   if (voip_metric_blocks_.size() >= kMaxNumberOfVoipMetricBlocks) {
     LOG(LS_WARNING) << "Max Voip Metric blocks reached.";
     return false;

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h

@@ -34,12 +34,12 @@ class ExtendedReports : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
 
   // Max 50 items of each of {Rrtr, Dlrr, VoipMetric} allowed per Xr.
-  bool WithRrtr(const Rrtr& rrtr);
+  bool AddRrtr(const Rrtr& rrtr);
-  bool WithDlrr(const Dlrr& dlrr);
+  bool AddDlrr(const Dlrr& dlrr);
-  bool WithVoipMetric(const VoipMetric& voip_metric);
+  bool AddVoipMetric(const VoipMetric& voip_metric);
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }
   const std::vector<Rrtr>& rrtrs() const { return rrtr_blocks_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports_unittest.cc

@@ -110,7 +110,7 @@ NtpTime RtcpPacketExtendedReportsTest::Rand<NtpTime>() {
 template <>
 Rrtr RtcpPacketExtendedReportsTest::Rand<Rrtr>() {
   Rrtr rrtr;
-  rrtr.WithNtp(Rand<NtpTime>());
+  rrtr.SetNtp(Rand<NtpTime>());
   return rrtr;
 }
 
@@ -143,14 +143,14 @@ RTCPVoIPMetric RtcpPacketExtendedReportsTest::Rand<RTCPVoIPMetric>() {
 template <>
 VoipMetric RtcpPacketExtendedReportsTest::Rand<VoipMetric>() {
   VoipMetric voip_metric;
-  voip_metric.To(Rand<uint32_t>());
+  voip_metric.SetMediaSsrc(Rand<uint32_t>());
-  voip_metric.WithVoipMetric(Rand<RTCPVoIPMetric>());
+  voip_metric.SetVoipMetric(Rand<RTCPVoIPMetric>());
   return voip_metric;
 }
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateWithoutReportBlocks) {
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
 
   rtc::Buffer packet = xr.Build();
 
@@ -170,8 +170,8 @@ TEST_F(RtcpPacketExtendedReportsTest, ParseWithoutReportBlocks) {
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithOneRrtrBlock) {
   Rrtr rrtr = Rand<Rrtr>();
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithRrtr(rrtr));
+  EXPECT_TRUE(xr.AddRrtr(rrtr));
   rtc::Buffer packet = xr.Build();
 
   ExtendedReports mparsed;
@@ -186,9 +186,9 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) {
   Rrtr rrtr1 = Rand<Rrtr>();
   Rrtr rrtr2 = Rand<Rrtr>();
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithRrtr(rrtr1));
+  EXPECT_TRUE(xr.AddRrtr(rrtr1));
-  EXPECT_TRUE(xr.WithRrtr(rrtr2));
+  EXPECT_TRUE(xr.AddRrtr(rrtr2));
 
   rtc::Buffer packet = xr.Build();
 
@@ -202,10 +202,10 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoRrtrBlocks) {
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
   Dlrr dlrr;
-  EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithDlrr(dlrr));
+  EXPECT_TRUE(xr.AddDlrr(dlrr));
 
   rtc::Buffer packet = xr.Build();
 
@@ -219,11 +219,11 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithOneSubBlock) {
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
   Dlrr dlrr;
-  EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
-  EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithDlrr(dlrr));
+  EXPECT_TRUE(xr.AddDlrr(dlrr));
 
   rtc::Buffer packet = xr.Build();
 
@@ -237,13 +237,13 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithDlrrWithTwoSubBlocks) {
 
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithTwoDlrrBlocks) {
   Dlrr dlrr1;
-  EXPECT_TRUE(dlrr1.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr1.AddDlrrItem(Rand<ReceiveTimeInfo>()));
   Dlrr dlrr2;
-  EXPECT_TRUE(dlrr2.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr2.AddDlrrItem(Rand<ReceiveTimeInfo>()));
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithDlrr(dlrr1));
+  EXPECT_TRUE(xr.AddDlrr(dlrr1));
-  EXPECT_TRUE(xr.WithDlrr(dlrr2));
+  EXPECT_TRUE(xr.AddDlrr(dlrr2));
 
   rtc::Buffer packet = xr.Build();
 
@@ -259,8 +259,8 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) {
   VoipMetric voip_metric = Rand<VoipMetric>();
 
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithVoipMetric(voip_metric));
+  EXPECT_TRUE(xr.AddVoipMetric(voip_metric));
 
   rtc::Buffer packet = xr.Build();
 
@@ -275,13 +275,13 @@ TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithVoipMetric) {
 TEST_F(RtcpPacketExtendedReportsTest, CreateAndParseWithMultipleReportBlocks) {
   Rrtr rrtr = Rand<Rrtr>();
   Dlrr dlrr;
-  EXPECT_TRUE(dlrr.WithDlrrItem(Rand<ReceiveTimeInfo>()));
+  EXPECT_TRUE(dlrr.AddDlrrItem(Rand<ReceiveTimeInfo>()));
   VoipMetric metric = Rand<VoipMetric>();
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithRrtr(rrtr));
+  EXPECT_TRUE(xr.AddRrtr(rrtr));
-  EXPECT_TRUE(xr.WithDlrr(dlrr));
+  EXPECT_TRUE(xr.AddDlrr(dlrr));
-  EXPECT_TRUE(xr.WithVoipMetric(metric));
+  EXPECT_TRUE(xr.AddVoipMetric(metric));
 
   rtc::Buffer packet = xr.Build();
 
@@ -300,10 +300,10 @@ TEST_F(RtcpPacketExtendedReportsTest, DlrrWithoutItemNotIncludedInPacket) {
   Dlrr dlrr;
   VoipMetric metric = Rand<VoipMetric>();
   ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(xr.WithRrtr(rrtr));
+  EXPECT_TRUE(xr.AddRrtr(rrtr));
-  EXPECT_TRUE(xr.WithDlrr(dlrr));
+  EXPECT_TRUE(xr.AddDlrr(dlrr));
-  EXPECT_TRUE(xr.WithVoipMetric(metric));
+  EXPECT_TRUE(xr.AddVoipMetric(metric));
 
   rtc::Buffer packet = xr.Build();
 
@@ -322,17 +322,17 @@ TEST_F(RtcpPacketExtendedReportsTest, WithTooManyBlocks) {
 
   Rrtr rrtr = Rand<Rrtr>();
   for (size_t i = 0; i < kMaxBlocks; ++i)
-    EXPECT_TRUE(xr.WithRrtr(rrtr));
+    EXPECT_TRUE(xr.AddRrtr(rrtr));
-  EXPECT_FALSE(xr.WithRrtr(rrtr));
+  EXPECT_FALSE(xr.AddRrtr(rrtr));
 
   Dlrr dlrr;
   for (size_t i = 0; i < kMaxBlocks; ++i)
-    EXPECT_TRUE(xr.WithDlrr(dlrr));
+    EXPECT_TRUE(xr.AddDlrr(dlrr));
-  EXPECT_FALSE(xr.WithDlrr(dlrr));
+  EXPECT_FALSE(xr.AddDlrr(dlrr));
 
   VoipMetric voip_metric = Rand<VoipMetric>();
   for (size_t i = 0; i < kMaxBlocks; ++i)
-    EXPECT_TRUE(xr.WithVoipMetric(voip_metric));
+    EXPECT_TRUE(xr.AddVoipMetric(voip_metric));
-  EXPECT_FALSE(xr.WithVoipMetric(voip_metric));
+  EXPECT_FALSE(xr.AddVoipMetric(voip_metric));
 }
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h

@@ -36,8 +36,8 @@ class Fir : public Psfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithRequestTo(uint32_t ssrc, uint8_t seq_num) {
+  void AddRequestTo(uint32_t ssrc, uint8_t seq_num) {
-    items_.push_back(Request(ssrc, seq_num));
+    items_.emplace_back(ssrc, seq_num);
   }
   const std::vector<Request>& requests() const { return items_; }
 
@@ -53,7 +53,7 @@ class Fir : public Psfb {
     return kHeaderLength + kCommonFeedbackLength + kFciLength * items_.size();
   }
   // SSRC of media source is not used in FIR packet. Shadow base functions.
-  void To(uint32_t ssrc);
+  void SetMediaSsrc(uint32_t ssrc);
   uint32_t media_ssrc() const;
 
   std::vector<Request> items_;

webrtc/modules/rtp_rtcp/source/rtcp_packet/fir_unittest.cc

@@ -49,8 +49,8 @@ TEST(RtcpPacketFirTest, Parse) {
 
 TEST(RtcpPacketFirTest, Create) {
   Fir fir;
-  fir.From(kSenderSsrc);
+  fir.SetSenderSsrc(kSenderSsrc);
-  fir.WithRequestTo(kRemoteSsrc, kSeqNr);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNr);
 
   rtc::Buffer packet = fir.Build();
 
@@ -60,9 +60,9 @@ TEST(RtcpPacketFirTest, Create) {
 
 TEST(RtcpPacketFirTest, TwoFciEntries) {
   Fir fir;
-  fir.From(kSenderSsrc);
+  fir.SetSenderSsrc(kSenderSsrc);
-  fir.WithRequestTo(kRemoteSsrc, kSeqNr);
+  fir.AddRequestTo(kRemoteSsrc, kSeqNr);
-  fir.WithRequestTo(kRemoteSsrc + 1, kSeqNr + 1);
+  fir.AddRequestTo(kRemoteSsrc + 1, kSeqNr + 1);
 
   rtc::Buffer packet = fir.Build();
   Fir parsed;

webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.cc

@@ -121,7 +121,7 @@ size_t Nack::BlockLength() const {
          packed_.size() * kNackItemLength;
 }
 
-void Nack::WithList(const uint16_t* nack_list, size_t length) {
+void Nack::SetPacketIds(const uint16_t* nack_list, size_t length) {
   RTC_DCHECK(nack_list);
   RTC_DCHECK(packet_ids_.empty());
   RTC_DCHECK(packed_.empty());

webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h

@@ -30,7 +30,7 @@ class Nack : public Rtpfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithList(const uint16_t* nack_list, size_t length);
+  void SetPacketIds(const uint16_t* nack_list, size_t length);
   const std::vector<uint16_t>& packet_ids() const { return packet_ids_; }
 
  protected:
@@ -48,7 +48,7 @@ class Nack : public Rtpfb {
     uint16_t bitmask;
   };
 
-  void Pack();    // Fills packed_ using packed_ids_. (used in WithList).
+  void Pack();    // Fills packed_ using packed_ids_. (used in SetPacketIds).
   void Unpack();  // Fills packet_ids_ using packed_. (used in Parse).
 
   std::vector<PackedNack> packed_;

webrtc/modules/rtp_rtcp/source/rtcp_packet/nack_unittest.cc

@@ -57,9 +57,9 @@ constexpr uint8_t kTooSmallPacket[] = {
 
 TEST(RtcpPacketNackTest, Create) {
   Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kRemoteSsrc);
+  nack.SetMediaSsrc(kRemoteSsrc);
-  nack.WithList(kList, kListLength);
+  nack.SetPacketIds(kList, kListLength);
 
   rtc::Buffer packet = nack.Build();
 
@@ -79,9 +79,9 @@ TEST(RtcpPacketNackTest, Parse) {
 
 TEST(RtcpPacketNackTest, CreateWrap) {
   Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kRemoteSsrc);
+  nack.SetMediaSsrc(kRemoteSsrc);
-  nack.WithList(kWrapList, kWrapListLength);
+  nack.SetPacketIds(kWrapList, kWrapListLength);
 
   rtc::Buffer packet = nack.Build();
 
@@ -104,9 +104,9 @@ TEST(RtcpPacketNackTest, BadOrder) {
   const size_t kUnorderedListLength =
       sizeof(kUnorderedList) / sizeof(kUnorderedList[0]);
   Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kRemoteSsrc);
+  nack.SetMediaSsrc(kRemoteSsrc);
-  nack.WithList(kUnorderedList, kUnorderedListLength);
+  nack.SetPacketIds(kUnorderedList, kUnorderedListLength);
 
   rtc::Buffer packet = nack.Build();
 
@@ -122,9 +122,9 @@ TEST(RtcpPacketNackTest, CreateFragmented) {
   Nack nack;
   const uint16_t kList[] = {1, 100, 200, 300, 400};
   const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kRemoteSsrc);
+  nack.SetMediaSsrc(kRemoteSsrc);
-  nack.WithList(kList, kListLength);
+  nack.SetPacketIds(kList, kListLength);
 
   class MockPacketReadyCallback : public rtcp::RtcpPacket::PacketReadyCallback {
    public:
@@ -156,9 +156,9 @@ TEST(RtcpPacketNackTest, CreateFailsWithTooSmallBuffer) {
   const uint16_t kList[] = {1};
   const size_t kMinNackBlockSize = 16;
   Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kRemoteSsrc);
+  nack.SetMediaSsrc(kRemoteSsrc);
-  nack.WithList(kList, 1);
+  nack.SetPacketIds(kList, 1);
   class Verifier : public rtcp::RtcpPacket::PacketReadyCallback {
    public:
     void OnPacketReady(uint8_t* data, size_t length) override {

webrtc/modules/rtp_rtcp/source/rtcp_packet/pli_unittest.cc

@@ -40,8 +40,8 @@ TEST(RtcpPacketPliTest, Parse) {
 
 TEST(RtcpPacketPliTest, Create) {
   Pli pli;
-  pli.From(kSenderSsrc);
+  pli.SetSenderSsrc(kSenderSsrc);
-  pli.To(kRemoteSsrc);
+  pli.SetMediaSsrc(kRemoteSsrc);
 
   rtc::Buffer packet = pli.Build();
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/psfb.h

@@ -27,8 +27,8 @@ class Psfb : public RtcpPacket {
   Psfb() : sender_ssrc_(0), media_ssrc_(0) {}
   ~Psfb() override {}
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
-  void To(uint32_t ssrc) { media_ssrc_ = ssrc; }
+  void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; }
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }
   uint32_t media_ssrc() const { return media_ssrc_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request_unittest.cc

@@ -39,8 +39,8 @@ TEST(RtcpPacketRapidResyncRequestTest, Parse) {
 
 TEST(RtcpPacketRapidResyncRequestTest, Create) {
   RapidResyncRequest rrr;
-  rrr.From(kSenderSsrc);
+  rrr.SetSenderSsrc(kSenderSsrc);
-  rrr.To(kRemoteSsrc);
+  rrr.SetMediaSsrc(kRemoteSsrc);
 
   rtc::Buffer packet = rrr.Build();
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.cc

@@ -74,7 +74,7 @@ bool ReceiverReport::Create(uint8_t* packet,
   return true;
 }
 
-bool ReceiverReport::WithReportBlock(const ReportBlock& block) {
+bool ReceiverReport::AddReportBlock(const ReportBlock& block) {
   if (report_blocks_.size() >= kMaxNumberOfReportBlocks) {
     LOG(LS_WARNING) << "Max report blocks reached.";
     return false;

webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h

@@ -32,8 +32,8 @@ class ReceiverReport : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
-  bool WithReportBlock(const ReportBlock& block);
+  bool AddReportBlock(const ReportBlock& block);
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }
   const std::vector<ReportBlock>& report_blocks() const {

webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report_unittest.cc

@@ -65,16 +65,16 @@ TEST(RtcpPacketReceiverReportTest, ParseFailsOnIncorrectSize) {
 
 TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) {
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
   ReportBlock rb;
-  rb.To(kRemoteSsrc);
+  rb.SetMediaSsrc(kRemoteSsrc);
-  rb.WithFractionLost(kFractionLost);
+  rb.SetFractionLost(kFractionLost);
-  rb.WithCumulativeLost(kCumulativeLost);
+  rb.SetCumulativeLost(kCumulativeLost);
-  rb.WithExtHighestSeqNum(kExtHighestSeqNum);
+  rb.SetExtHighestSeqNum(kExtHighestSeqNum);
-  rb.WithJitter(kJitter);
+  rb.SetJitter(kJitter);
-  rb.WithLastSr(kLastSr);
+  rb.SetLastSr(kLastSr);
-  rb.WithDelayLastSr(kDelayLastSr);
+  rb.SetDelayLastSr(kDelayLastSr);
-  rr.WithReportBlock(rb);
+  rr.AddReportBlock(rb);
 
   rtc::Buffer raw = rr.Build();
 
@@ -83,7 +83,7 @@ TEST(RtcpPacketReceiverReportTest, CreateWithOneReportBlock) {
 
 TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) {
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
 
   rtc::Buffer raw = rr.Build();
   ReceiverReport parsed;
@@ -96,13 +96,13 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithoutReportBlocks) {
 TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) {
   ReceiverReport rr;
   ReportBlock rb1;
-  rb1.To(kRemoteSsrc);
+  rb1.SetMediaSsrc(kRemoteSsrc);
   ReportBlock rb2;
-  rb2.To(kRemoteSsrc + 1);
+  rb2.SetMediaSsrc(kRemoteSsrc + 1);
 
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(rr.WithReportBlock(rb1));
+  EXPECT_TRUE(rr.AddReportBlock(rb1));
-  EXPECT_TRUE(rr.WithReportBlock(rb2));
+  EXPECT_TRUE(rr.AddReportBlock(rb2));
 
   rtc::Buffer raw = rr.Build();
   ReceiverReport parsed;
@@ -116,15 +116,15 @@ TEST(RtcpPacketReceiverReportTest, CreateAndParseWithTwoReportBlocks) {
 
 TEST(RtcpPacketReceiverReportTest, CreateWithTooManyReportBlocks) {
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
   const size_t kMaxReportBlocks = (1 << 5) - 1;
   ReportBlock rb;
   for (size_t i = 0; i < kMaxReportBlocks; ++i) {
-    rb.To(kRemoteSsrc + i);
+    rb.SetMediaSsrc(kRemoteSsrc + i);
-    EXPECT_TRUE(rr.WithReportBlock(rb));
+    EXPECT_TRUE(rr.AddReportBlock(rb));
   }
-  rb.To(kRemoteSsrc + kMaxReportBlocks);
+  rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks);
-  EXPECT_FALSE(rr.WithReportBlock(rb));
+  EXPECT_FALSE(rr.AddReportBlock(rb));
 }
 
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.cc

@@ -10,6 +10,8 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
@@ -81,22 +83,12 @@ bool Remb::Parse(const CommonHeader& packet) {
   return true;
 }
 
-bool Remb::AppliesTo(uint32_t ssrc) {
+bool Remb::SetSsrcs(std::vector<uint32_t> ssrcs) {
-  if (ssrcs_.size() >= kMaxNumberOfSsrcs) {
+  if (ssrcs.size() > kMaxNumberOfSsrcs) {
-    LOG(LS_WARNING) << "Max number of REMB feedback SSRCs reached.";
-    return false;
-  }
-  ssrcs_.push_back(ssrc);
-  return true;
-}
-
-bool Remb::AppliesToMany(const std::vector<uint32_t>& ssrcs) {
-  if (ssrcs_.size() + ssrcs.size() > kMaxNumberOfSsrcs) {
     LOG(LS_WARNING) << "Not enough space for all given SSRCs.";
     return false;
   }
-  // Append.
+  ssrcs_ = std::move(ssrcs);
-  ssrcs_.insert(ssrcs_.end(), ssrcs.begin(), ssrcs.end());
   return true;
 }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h

@@ -25,6 +25,7 @@ class CommonHeader;
 class Remb : public Psfb {
  public:
   static constexpr uint8_t kFeedbackMessageType = 15;
+  static constexpr size_t kMaxNumberOfSsrcs = 0xff;
 
   Remb() : bitrate_bps_(0) {}
   ~Remb() override {}
@@ -32,9 +33,8 @@ class Remb : public Psfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  bool AppliesTo(uint32_t ssrc);
+  bool SetSsrcs(std::vector<uint32_t> ssrcs);
-  bool AppliesToMany(const std::vector<uint32_t>& ssrcs);
+  void SetBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; }
-  void WithBitrateBps(uint64_t bitrate_bps) { bitrate_bps_ = bitrate_bps; }
 
   uint64_t bitrate_bps() const { return bitrate_bps_; }
   const std::vector<uint32_t>& ssrcs() const { return ssrcs_; }
@@ -50,11 +50,10 @@ class Remb : public Psfb {
   }
 
  private:
-  static constexpr size_t kMaxNumberOfSsrcs = 0xff;
   static constexpr uint32_t kUniqueIdentifier = 0x52454D42;  // 'R' 'E' 'M' 'B'.
 
   // Media ssrc is unused, shadow base class setter and getter.
-  void To(uint32_t);
+  void SetMediaSsrc(uint32_t);
   uint32_t media_ssrc() const;
 
   uint64_t bitrate_bps_;

webrtc/modules/rtp_rtcp/source/rtcp_packet/remb_unittest.cc

@@ -34,11 +34,10 @@ const size_t kPacketLength = sizeof(kPacket);
 
 TEST(RtcpPacketRembTest, Create) {
   Remb remb;
-  remb.From(kSenderSsrc);
+  remb.SetSenderSsrc(kSenderSsrc);
-  remb.AppliesTo(kRemoteSsrcs[0]);
+  remb.SetSsrcs(
-  remb.AppliesTo(kRemoteSsrcs[1]);
+      std::vector<uint32_t>(std::begin(kRemoteSsrcs), std::end(kRemoteSsrcs)));
-  remb.AppliesTo(kRemoteSsrcs[2]);
+  remb.SetBitrateBps(kBitrateBps);
-  remb.WithBitrateBps(kBitrateBps);
 
   rtc::Buffer packet = remb.Build();
 
@@ -58,8 +57,8 @@ TEST(RtcpPacketRembTest, Parse) {
 
 TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) {
   Remb remb;
-  remb.From(kSenderSsrc);
+  remb.SetSenderSsrc(kSenderSsrc);
-  remb.WithBitrateBps(kBitrateBps);
+  remb.SetBitrateBps(kBitrateBps);
   rtc::Buffer packet = remb.Build();
 
   Remb parsed;
@@ -71,7 +70,7 @@ TEST(RtcpPacketRembTest, CreateAndParseWithoutSsrcs) {
 
 TEST(RtcpPacketRembTest, CreateAndParse64bitBitrate) {
   Remb remb;
-  remb.WithBitrateBps(kBitrateBps64bit);
+  remb.SetBitrateBps(kBitrateBps64bit);
   rtc::Buffer packet = remb.Build();
 
   Remb parsed;
@@ -119,27 +118,11 @@ TEST(RtcpPacketRembTest, ParseFailsWhenSsrcCountMismatchLength) {
 }
 
 TEST(RtcpPacketRembTest, TooManySsrcs) {
-  const size_t kMax = 0xff;
   Remb remb;
-  for (size_t i = 1; i <= kMax; ++i)
+  EXPECT_FALSE(remb.SetSsrcs(
-    EXPECT_TRUE(remb.AppliesTo(kRemoteSsrcs[0] + i));
+      std::vector<uint32_t>(Remb::kMaxNumberOfSsrcs + 1, kRemoteSsrcs[0])));
-  EXPECT_FALSE(remb.AppliesTo(kRemoteSsrcs[0]));
+  EXPECT_TRUE(remb.SetSsrcs(
-}
+      std::vector<uint32_t>(Remb::kMaxNumberOfSsrcs, kRemoteSsrcs[0])));
-
-TEST(RtcpPacketRembTest, TooManySsrcsForBatchAssign) {
-  const uint32_t kRemoteSsrc = kRemoteSsrcs[0];
-  const size_t kMax = 0xff;
-  const std::vector<uint32_t> kAllButOneSsrc(kMax - 1, kRemoteSsrc);
-  const std::vector<uint32_t> kTwoSsrcs(2, kRemoteSsrc);
-
-  Remb remb;
-  EXPECT_TRUE(remb.AppliesToMany(kAllButOneSsrc));
-  // Should be no place for 2 more.
-  EXPECT_FALSE(remb.AppliesToMany(kTwoSsrcs));
-  // But enough place for 1 more.
-  EXPECT_TRUE(remb.AppliesTo(kRemoteSsrc));
-  // But not for another one.
-  EXPECT_FALSE(remb.AppliesTo(kRemoteSsrc));
 }
 
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.cc

@@ -76,7 +76,7 @@ void ReportBlock::Create(uint8_t* buffer) const {
   ByteWriter<uint32_t>::WriteBigEndian(&buffer[20], delay_since_last_sr());
 }
 
-bool ReportBlock::WithCumulativeLost(uint32_t cumulative_lost) {
+bool ReportBlock::SetCumulativeLost(uint32_t cumulative_lost) {
   if (cumulative_lost >= (1u << 24)) {  // Have only 3 bytes to store it.
     LOG(LS_WARNING) << "Cumulative lost is too big to fit into Report Block";
     return false;

webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block.h

@@ -30,17 +30,17 @@ class ReportBlock {
   // Consumes ReportBlock::kLength bytes.
   void Create(uint8_t* buffer) const;
 
-  void To(uint32_t ssrc) { source_ssrc_ = ssrc; }
+  void SetMediaSsrc(uint32_t ssrc) { source_ssrc_ = ssrc; }
-  void WithFractionLost(uint8_t fraction_lost) {
+  void SetFractionLost(uint8_t fraction_lost) {
     fraction_lost_ = fraction_lost;
   }
-  bool WithCumulativeLost(uint32_t cumulative_lost);
+  bool SetCumulativeLost(uint32_t cumulative_lost);
-  void WithExtHighestSeqNum(uint32_t ext_highest_seq_num) {
+  void SetExtHighestSeqNum(uint32_t ext_highest_seq_num) {
     extended_high_seq_num_ = ext_highest_seq_num;
   }
-  void WithJitter(uint32_t jitter) { jitter_ = jitter; }
+  void SetJitter(uint32_t jitter) { jitter_ = jitter; }
-  void WithLastSr(uint32_t last_sr) { last_sr_ = last_sr; }
+  void SetLastSr(uint32_t last_sr) { last_sr_ = last_sr; }
-  void WithDelayLastSr(uint32_t delay_last_sr) {
+  void SetDelayLastSr(uint32_t delay_last_sr) {
     delay_since_last_sr_ = delay_last_sr;
   }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/report_block_unittest.cc

@@ -52,13 +52,13 @@ TEST(RtcpPacketReportBlockTest, ParseAnyData) {
 
 TEST(RtcpPacketReportBlockTest, ParseMatchCreate) {
   ReportBlock rb;
-  rb.To(kRemoteSsrc);
+  rb.SetMediaSsrc(kRemoteSsrc);
-  rb.WithFractionLost(kFractionLost);
+  rb.SetFractionLost(kFractionLost);
-  rb.WithCumulativeLost(kCumulativeLost);
+  rb.SetCumulativeLost(kCumulativeLost);
-  rb.WithExtHighestSeqNum(kExtHighestSeqNum);
+  rb.SetExtHighestSeqNum(kExtHighestSeqNum);
-  rb.WithJitter(kJitter);
+  rb.SetJitter(kJitter);
-  rb.WithLastSr(kLastSr);
+  rb.SetLastSr(kLastSr);
-  rb.WithDelayLastSr(kDelayLastSr);
+  rb.SetDelayLastSr(kDelayLastSr);
 
   uint8_t buffer[kBufferLength];
   rb.Create(buffer);
@@ -78,8 +78,8 @@ TEST(RtcpPacketReportBlockTest, ParseMatchCreate) {
 TEST(RtcpPacketReportBlockTest, ValidateCumulativeLost) {
   const uint32_t kMaxCumulativeLost = 0xffffff;
   ReportBlock rb;
-  EXPECT_FALSE(rb.WithCumulativeLost(kMaxCumulativeLost + 1));
+  EXPECT_FALSE(rb.SetCumulativeLost(kMaxCumulativeLost + 1));
-  EXPECT_TRUE(rb.WithCumulativeLost(kMaxCumulativeLost));
+  EXPECT_TRUE(rb.SetCumulativeLost(kMaxCumulativeLost));
 }
 
 }  // namespace

webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.cc

@@ -130,12 +130,12 @@ bool Rpsi::Create(uint8_t* packet,
   return true;
 }
 
-void Rpsi::WithPayloadType(uint8_t payload) {
+void Rpsi::SetPayloadType(uint8_t payload) {
   RTC_DCHECK_LE(payload, 0x7f);
   payload_type_ = payload;
 }
 
-void Rpsi::WithPictureId(uint64_t picture_id) {
+void Rpsi::SetPictureId(uint64_t picture_id) {
   picture_id_ = picture_id;
   block_length_ = CalculateBlockLength(RequiredBytes(picture_id_));
 }

webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h

@@ -30,8 +30,8 @@ class Rpsi : public Psfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithPayloadType(uint8_t payload);
+  void SetPayloadType(uint8_t payload);
-  void WithPictureId(uint64_t picture_id);
+  void SetPictureId(uint64_t picture_id);
 
   uint8_t payload_type() const { return payload_type_; }
   uint64_t picture_id() const { return picture_id_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi_unittest.cc

@@ -46,10 +46,10 @@ TEST(RtcpPacketRpsiTest, Parse) {
 
 TEST(RtcpPacketRpsiTest, Create) {
   Rpsi rpsi;
-  rpsi.From(kSenderSsrc);
+  rpsi.SetSenderSsrc(kSenderSsrc);
-  rpsi.To(kRemoteSsrc);
+  rpsi.SetMediaSsrc(kRemoteSsrc);
-  rpsi.WithPayloadType(kPayloadType);
+  rpsi.SetPayloadType(kPayloadType);
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
 
@@ -59,8 +59,8 @@ TEST(RtcpPacketRpsiTest, Create) {
 
 TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) {
   Rpsi rpsi;
-  rpsi.From(kSenderSsrc);
+  rpsi.SetSenderSsrc(kSenderSsrc);
-  rpsi.To(kRemoteSsrc);
+  rpsi.SetMediaSsrc(kRemoteSsrc);
 
   rtc::Buffer packet = rpsi.Build();
   packet[3]--;  // Reduce size field by one word (4 bytes).
@@ -71,9 +71,9 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnTooSmallPacket) {
 
 TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) {
   Rpsi rpsi;
-  rpsi.From(kSenderSsrc);
+  rpsi.SetSenderSsrc(kSenderSsrc);
-  rpsi.To(kRemoteSsrc);
+  rpsi.SetMediaSsrc(kRemoteSsrc);
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
   rtc::Buffer packet = rpsi.Build();
   uint8_t* padding_bits = packet.data() + 12;
   uint8_t saved_padding_bits = *padding_bits;
@@ -87,9 +87,9 @@ TEST(RtcpPacketRpsiTest, ParseFailsOnFractionalPaddingBytes) {
 
 TEST(RtcpPacketRpsiTest, ParseFailsOnTooBigPadding) {
   Rpsi rpsi;
-  rpsi.From(kSenderSsrc);
+  rpsi.SetSenderSsrc(kSenderSsrc);
-  rpsi.To(kRemoteSsrc);
+  rpsi.SetMediaSsrc(kRemoteSsrc);
-  rpsi.WithPictureId(1);  // Small picture id that occupy just 1 byte.
+  rpsi.SetPictureId(1);  // Small picture id that occupy just 1 byte.
   rtc::Buffer packet = rpsi.Build();
   uint8_t* padding_bits = packet.data() + 12;
   ASSERT_TRUE(test::ParseSinglePacket(packet, &rpsi));
@@ -112,7 +112,7 @@ TEST(RtcpPacketRpsiTest, WithOneByteNativeString) {
   // 1000001 (7 bits = 1 byte in native string).
   const uint64_t kPictureId = 0x41;
   const uint16_t kNumberOfValidBytes = 1;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
   EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
@@ -127,7 +127,7 @@ TEST(RtcpPacketRpsiTest, WithTwoByteNativeString) {
   // |1 0000001 (7 bits = 1 byte in native string).
   const uint64_t kPictureId = 0x81;
   const uint16_t kNumberOfValidBytes = 2;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
   EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
@@ -142,7 +142,7 @@ TEST(RtcpPacketRpsiTest, WithThreeByteNativeString) {
   // 10000|00 100000|0 1000000 (7 bits = 1 byte in native string).
   const uint64_t kPictureId = 0x102040;
   const uint16_t kNumberOfValidBytes = 3;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
   EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
@@ -157,7 +157,7 @@ TEST(RtcpPacketRpsiTest, WithFourByteNativeString) {
   // 1000|001 00001|01 100001|1 1000010 (7 bits = 1 byte in native string).
   const uint64_t kPictureId = 0x84161C2;
   const uint16_t kNumberOfValidBytes = 4;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
   EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));
@@ -173,7 +173,7 @@ TEST(RtcpPacketRpsiTest, WithMaxPictureId) {
   // 11 111111|1 1111111 (7 bits = 1 byte in native string).
   const uint64_t kPictureId = 0xffffffffffffffff;
   const uint16_t kNumberOfValidBytes = 10;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   rtc::Buffer packet = rpsi.Build();
   EXPECT_EQ(kNumberOfValidBytes, UsedBytes(packet));

webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr.h

@@ -36,7 +36,7 @@ class Rrtr {
   // Consumes Rrtr::kLength bytes.
   void Create(uint8_t* buffer) const;
 
-  void WithNtp(const NtpTime& ntp) { ntp_ = ntp; }
+  void SetNtp(NtpTime ntp) { ntp_ = ntp; }
 
   NtpTime ntp() const { return ntp_; }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/rrtr_unittest.cc

@@ -30,7 +30,7 @@ static_assert(
 TEST(RtcpPacketRrtrTest, Create) {
   uint8_t buffer[Rrtr::kLength];
   Rrtr rrtr;
-  rrtr.WithNtp(NtpTime(kNtpSec, kNtpFrac));
+  rrtr.SetNtp(NtpTime(kNtpSec, kNtpFrac));
 
   rrtr.Create(buffer);
   EXPECT_EQ(0, memcmp(buffer, kBlock, kBlockSizeBytes));

webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h

@@ -27,8 +27,8 @@ class Rtpfb : public RtcpPacket {
   Rtpfb() : sender_ssrc_(0), media_ssrc_(0) {}
   ~Rtpfb() override {}
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
-  void To(uint32_t ssrc) { media_ssrc_ = ssrc; }
+  void SetMediaSsrc(uint32_t ssrc) { media_ssrc_ = ssrc; }
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }
   uint32_t media_ssrc() const { return media_ssrc_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.cc

@@ -10,6 +10,8 @@
 
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
 
+#include <utility>
+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
@@ -137,7 +139,7 @@ bool Sdes::Parse(const CommonHeader& packet) {
   return true;
 }
 
-bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) {
+bool Sdes::AddCName(uint32_t ssrc, std::string cname) {
   RTC_DCHECK_LE(cname.length(), 0xffu);
   if (chunks_.size() >= kMaxNumberOfChunks) {
     LOG(LS_WARNING) << "Max SDES chunks reached.";
@@ -145,7 +147,7 @@ bool Sdes::WithCName(uint32_t ssrc, const std::string& cname) {
   }
   Chunk chunk;
   chunk.ssrc = ssrc;
-  chunk.cname = cname;
+  chunk.cname = std::move(cname);
   chunks_.push_back(chunk);
   block_length_ += ChunkSize(chunk);
   return true;

webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h

@@ -36,7 +36,7 @@ class Sdes : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  bool WithCName(uint32_t ssrc, const std::string& cname);
+  bool AddCName(uint32_t ssrc, std::string cname);
 
   const std::vector<Chunk>& chunks() const { return chunks_; }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes_unittest.cc

@@ -39,7 +39,7 @@ TEST(RtcpPacketSdesTest, CreateAndParseWithOneChunk) {
   const std::string kCname = "alice@host";
 
   Sdes sdes;
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc, kCname));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc, kCname));
 
   rtc::Buffer packet = sdes.Build();
   Sdes sdes_parsed;
@@ -53,12 +53,12 @@ TEST(RtcpPacketSdesTest, CreateAndParseWithOneChunk) {
 
 TEST(RtcpPacketSdesTest, CreateAndParseWithMultipleChunks) {
   Sdes sdes;
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 0, "a"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 0, "a"));
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 1, "ab"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 1, "ab"));
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 2, "abc"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 2, "abc"));
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 3, "abcd"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 3, "abcd"));
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 4, "abcde"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 4, "abcde"));
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc + 5, "abcdef"));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc + 5, "abcdef"));
 
   rtc::Buffer packet = sdes.Build();
   Sdes parsed;
@@ -76,14 +76,14 @@ TEST(RtcpPacketSdesTest, CreateWithTooManyChunks) {
     uint32_t ssrc = kSenderSsrc + i;
     std::ostringstream oss;
     oss << "cname" << i;
-    EXPECT_TRUE(sdes.WithCName(ssrc, oss.str()));
+    EXPECT_TRUE(sdes.AddCName(ssrc, oss.str()));
   }
-  EXPECT_FALSE(sdes.WithCName(kSenderSsrc + kMaxChunks, "foo"));
+  EXPECT_FALSE(sdes.AddCName(kSenderSsrc + kMaxChunks, "foo"));
 }
 
 TEST(RtcpPacketSdesTest, CreateAndParseCnameItemWithEmptyString) {
   Sdes sdes;
-  EXPECT_TRUE(sdes.WithCName(kSenderSsrc, ""));
+  EXPECT_TRUE(sdes.AddCName(kSenderSsrc, ""));
 
   rtc::Buffer packet = sdes.Build();
   Sdes parsed;
@@ -224,7 +224,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
   Sdes source;
   const std::string kAlice = "alice@host";
   const std::string kBob = "bob@host";
-  source.WithCName(kSenderSsrc, kAlice);
+  source.AddCName(kSenderSsrc, kAlice);
 
   rtc::Buffer packet1 = source.Build();
   Sdes middle;
@@ -232,7 +232,7 @@ TEST(RtcpPacketSdesTest, ParsedSdesCanBeReusedForBuilding) {
 
   EXPECT_EQ(source.BlockLength(), middle.BlockLength());
 
-  middle.WithCName(kSenderSsrc + 1, kBob);
+  middle.AddCName(kSenderSsrc + 1, kBob);
 
   rtc::Buffer packet2 = middle.Build();
   Sdes destination;

webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.cc

@@ -105,7 +105,7 @@ bool SenderReport::Create(uint8_t* packet,
   return true;
 }
 
-bool SenderReport::WithReportBlock(const ReportBlock& block) {
+bool SenderReport::AddReportBlock(const ReportBlock& block) {
   if (report_blocks_.size() >= kMaxNumberOfReportBlocks) {
     LOG(LS_WARNING) << "Max report blocks reached.";
     return false;

webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h

@@ -32,18 +32,18 @@ class SenderReport : public RtcpPacket {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void From(uint32_t ssrc) { sender_ssrc_ = ssrc; }
+  void SetSenderSsrc(uint32_t ssrc) { sender_ssrc_ = ssrc; }
-  void WithNtp(NtpTime ntp) { ntp_ = ntp; }
+  void SetNtp(NtpTime ntp) { ntp_ = ntp; }
-  void WithRtpTimestamp(uint32_t rtp_timestamp) {
+  void SetRtpTimestamp(uint32_t rtp_timestamp) {
     rtp_timestamp_ = rtp_timestamp;
   }
-  void WithPacketCount(uint32_t packet_count) {
+  void SetPacketCount(uint32_t packet_count) {
     sender_packet_count_ = packet_count;
   }
-  void WithOctetCount(uint32_t octet_count) {
+  void SetOctetCount(uint32_t octet_count) {
     sender_octet_count_ = octet_count;
   }
-  bool WithReportBlock(const ReportBlock& block);
+  bool AddReportBlock(const ReportBlock& block);
   void ClearReportBlocks() { report_blocks_.clear(); }
 
   uint32_t sender_ssrc() const { return sender_ssrc_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report_unittest.cc

@@ -39,11 +39,11 @@ const uint8_t kPacket[] = {0x80,  200, 0x00, 0x06,
 
 TEST(RtcpPacketSenderReportTest, CreateWithoutReportBlocks) {
   SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
-  sr.WithNtp(kNtp);
+  sr.SetNtp(kNtp);
-  sr.WithRtpTimestamp(kRtpTimestamp);
+  sr.SetRtpTimestamp(kRtpTimestamp);
-  sr.WithPacketCount(kPacketCount);
+  sr.SetPacketCount(kPacketCount);
-  sr.WithOctetCount(kOctetCount);
+  sr.SetOctetCount(kOctetCount);
 
   rtc::Buffer raw = sr.Build();
   EXPECT_THAT(make_tuple(raw.data(), raw.size()), ElementsAreArray(kPacket));
@@ -63,11 +63,11 @@ TEST(RtcpPacketSenderReportTest, ParseWithoutReportBlocks) {
 
 TEST(RtcpPacketSenderReportTest, CreateAndParseWithOneReportBlock) {
   ReportBlock rb;
-  rb.To(kRemoteSsrc);
+  rb.SetMediaSsrc(kRemoteSsrc);
 
   SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(sr.WithReportBlock(rb));
+  EXPECT_TRUE(sr.AddReportBlock(rb));
 
   rtc::Buffer raw = sr.Build();
   SenderReport parsed;
@@ -80,14 +80,14 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithOneReportBlock) {
 
 TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) {
   ReportBlock rb1;
-  rb1.To(kRemoteSsrc);
+  rb1.SetMediaSsrc(kRemoteSsrc);
   ReportBlock rb2;
-  rb2.To(kRemoteSsrc + 1);
+  rb2.SetMediaSsrc(kRemoteSsrc + 1);
 
   SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(sr.WithReportBlock(rb1));
+  EXPECT_TRUE(sr.AddReportBlock(rb1));
-  EXPECT_TRUE(sr.WithReportBlock(rb2));
+  EXPECT_TRUE(sr.AddReportBlock(rb2));
 
   rtc::Buffer raw = sr.Build();
   SenderReport parsed;
@@ -101,15 +101,15 @@ TEST(RtcpPacketSenderReportTest, CreateAndParseWithTwoReportBlocks) {
 
 TEST(RtcpPacketSenderReportTest, CreateWithTooManyReportBlocks) {
   SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   const size_t kMaxReportBlocks = (1 << 5) - 1;
   ReportBlock rb;
   for (size_t i = 0; i < kMaxReportBlocks; ++i) {
-    rb.To(kRemoteSsrc + i);
+    rb.SetMediaSsrc(kRemoteSsrc + i);
-    EXPECT_TRUE(sr.WithReportBlock(rb));
+    EXPECT_TRUE(sr.AddReportBlock(rb));
   }
-  rb.To(kRemoteSsrc + kMaxReportBlocks);
+  rb.SetMediaSsrc(kRemoteSsrc + kMaxReportBlocks);
-  EXPECT_FALSE(sr.WithReportBlock(rb));
+  EXPECT_FALSE(sr.AddReportBlock(rb));
 }
 
 }  // namespace webrtc

webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h

@@ -49,11 +49,13 @@ class Sli : public Psfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithPictureId(uint8_t picture_id,
+  void AddPictureId(uint8_t picture_id) {
-                     uint16_t first_macroblock = 0,
+    items_.emplace_back(picture_id, 0, 0x1fff);
-                     uint16_t number_macroblocks = 0x1fff) {
+  }
-    items_.push_back(
+  void AddPictureId(uint8_t picture_id,
-        Macroblocks(picture_id, first_macroblock, number_macroblocks));
+                    uint16_t first_macroblock,
+                    uint16_t number_macroblocks) {
+    items_.emplace_back(picture_id, first_macroblock, number_macroblocks);
   }
 
   const std::vector<Macroblocks>& macroblocks() const { return items_; }

webrtc/modules/rtp_rtcp/source/rtcp_packet/sli_unittest.cc

@@ -42,9 +42,9 @@ constexpr uint8_t kPacket[] = {0x82,  206, 0x00, 0x03,
 
 TEST(RtcpPacketSliTest, Create) {
   Sli sli;
-  sli.From(kSenderSsrc);
+  sli.SetSenderSsrc(kSenderSsrc);
-  sli.To(kRemoteSsrc);
+  sli.SetMediaSsrc(kRemoteSsrc);
-  sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb);
+  sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb);
 
   rtc::Buffer packet = sli.Build();
 
@@ -67,9 +67,9 @@ TEST(RtcpPacketSliTest, Parse) {
 
 TEST(RtcpPacketSliTest, ParseFailsOnTooSmallPacket) {
   Sli sli;
-  sli.From(kSenderSsrc);
+  sli.SetSenderSsrc(kSenderSsrc);
-  sli.To(kRemoteSsrc);
+  sli.SetMediaSsrc(kRemoteSsrc);
-  sli.WithPictureId(kPictureId, kFirstMb, kNumberOfMb);
+  sli.AddPictureId(kPictureId, kFirstMb, kNumberOfMb);
 
   rtc::Buffer packet = sli.Build();
   packet[3]--;  // Decrease size by 1 word (4 bytes).

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.cc

@@ -70,7 +70,7 @@ bool Tmmbn::Parse(const CommonHeader& packet) {
   return true;
 }
 
-void Tmmbn::WithTmmbr(const TmmbItem& item) {
+void Tmmbn::AddTmmbr(const TmmbItem& item) {
   items_.push_back(item);
 }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h

@@ -34,10 +34,7 @@ class Tmmbn : public Rtpfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithTmmbr(uint32_t ssrc, uint32_t bitrate_kbps, uint16_t overhead) {
+  void AddTmmbr(const TmmbItem& item);
-    WithTmmbr(TmmbItem(ssrc, bitrate_kbps * 1000, overhead));
-  }
-  void WithTmmbr(const TmmbItem& item);
 
   const std::vector<TmmbItem>& items() const { return items_; }
 
@@ -54,7 +51,7 @@ class Tmmbn : public Rtpfb {
   }
 
   // Media ssrc is unused, shadow base class setter and getter.
-  void To(uint32_t ssrc);
+  void SetMediaSsrc(uint32_t ssrc);
   uint32_t media_ssrc() const;
 
   std::vector<TmmbItem> items_;

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn_unittest.cc

@@ -35,8 +35,8 @@ const uint8_t kPacket[] = {0x84, 205,  0x00, 0x04,
 
 TEST(RtcpPacketTmmbnTest, Create) {
   Tmmbn tmmbn;
-  tmmbn.From(kSenderSsrc);
+  tmmbn.SetSenderSsrc(kSenderSsrc);
-  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+  tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
 
   rtc::Buffer packet = tmmbn.Build();
 
@@ -59,7 +59,7 @@ TEST(RtcpPacketTmmbnTest, Parse) {
 
 TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
   Tmmbn tmmbn;
-  tmmbn.From(kSenderSsrc);
+  tmmbn.SetSenderSsrc(kSenderSsrc);
 
   rtc::Buffer packet = tmmbn.Build();
   Tmmbn parsed;
@@ -71,9 +71,9 @@ TEST(RtcpPacketTmmbnTest, CreateAndParseWithoutItems) {
 
 TEST(RtcpPacketTmmbnTest, CreateAndParseWithTwoItems) {
   Tmmbn tmmbn;
-  tmmbn.From(kSenderSsrc);
+  tmmbn.SetSenderSsrc(kSenderSsrc);
-  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+  tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
-  tmmbn.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40));
+  tmmbn.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, 40));
 
   rtc::Buffer packet = tmmbn.Build();
   Tmmbn parsed;

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.cc

@@ -71,7 +71,7 @@ bool Tmmbr::Parse(const CommonHeader& packet) {
   return true;
 }
 
-void Tmmbr::WithTmmbr(const TmmbItem& item) {
+void Tmmbr::AddTmmbr(const TmmbItem& item) {
   items_.push_back(item);
 }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h

@@ -34,7 +34,7 @@ class Tmmbr : public Rtpfb {
   // Parse assumes header is already parsed and validated.
   bool Parse(const CommonHeader& packet);
 
-  void WithTmmbr(const TmmbItem& item);
+  void AddTmmbr(const TmmbItem& item);
 
   const std::vector<TmmbItem>& requests() const { return items_; }
 
@@ -51,7 +51,7 @@ class Tmmbr : public Rtpfb {
   }
 
   // Media ssrc is unused, shadow base class setter.
-  void To(uint32_t ssrc);
+  void SetMediaSsrc(uint32_t ssrc);
 
   std::vector<TmmbItem> items_;
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr_unittest.cc

@@ -35,8 +35,8 @@ const uint8_t kPacket[] = {0x83,  205, 0x00, 0x04,
 
 TEST(RtcpPacketTmmbrTest, Create) {
   Tmmbr tmmbr;
-  tmmbr.From(kSenderSsrc);
+  tmmbr.SetSenderSsrc(kSenderSsrc);
-  tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+  tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
 
   rtc::Buffer packet = tmmbr.Build();
 
@@ -58,9 +58,9 @@ TEST(RtcpPacketTmmbrTest, Parse) {
 
 TEST(RtcpPacketTmmbrTest, CreateAndParseWithTwoEntries) {
   Tmmbr tmmbr;
-  tmmbr.From(kSenderSsrc);
+  tmmbr.SetSenderSsrc(kSenderSsrc);
-  tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
+  tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc, kBitrateBps, kOverhead));
-  tmmbr.WithTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1));
+  tmmbr.AddTmmbr(TmmbItem(kRemoteSsrc + 1, 4 * kBitrateBps, kOverhead + 1));
 
   rtc::Buffer packet = tmmbr.Build();
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.cc

@@ -304,7 +304,7 @@ int64_t TransportFeedback::Unwrap(uint16_t sequence_number) {
   return last_seq_ + delta;
 }
 
-void TransportFeedback::WithBase(uint16_t base_sequence,
+void TransportFeedback::SetBase(uint16_t base_sequence,
                                 int64_t ref_timestamp_us) {
   RTC_DCHECK_EQ(-1, base_seq_);
   RTC_DCHECK_NE(-1, ref_timestamp_us);
@@ -318,11 +318,11 @@ void TransportFeedback::WithBase(uint16_t base_sequence,
   last_timestamp_ = base_time_ * kBaseScaleFactor;
 }
 
-void TransportFeedback::WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
+void TransportFeedback::SetFeedbackSequenceNumber(uint8_t feedback_sequence) {
   feedback_seq_ = feedback_sequence;
 }
 
-bool TransportFeedback::WithReceivedPacket(uint16_t sequence_number,
+bool TransportFeedback::AddReceivedPacket(uint16_t sequence_number,
                                           int64_t timestamp) {
   RTC_DCHECK_NE(-1, base_seq_);
   int64_t seq = Unwrap(sequence_number);

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h

@@ -16,6 +16,7 @@
 #include <vector>
 
 #include "webrtc/base/constructormagic.h"
+#include "webrtc/base/deprecation.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rtpfb.h"
 
 namespace webrtc {
@@ -33,13 +34,11 @@ class TransportFeedback : public Rtpfb {
   TransportFeedback();
   ~TransportFeedback() override;
 
-  void WithPacketSenderSsrc(uint32_t ssrc) { From(ssrc); }
+  void SetBase(uint16_t base_sequence,     // Seq# of first packet in this msg.
-  void WithMediaSourceSsrc(uint32_t ssrc) { To(ssrc); }
-  void WithBase(uint16_t base_sequence,     // Seq# of first packet in this msg.
                int64_t ref_timestamp_us);  // Reference timestamp for this msg.
-  void WithFeedbackSequenceNumber(uint8_t feedback_sequence);
+  void SetFeedbackSequenceNumber(uint8_t feedback_sequence);
   // NOTE: This method requires increasing sequence numbers (excepting wraps).
-  bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us);
+  bool AddReceivedPacket(uint16_t sequence_number, int64_t timestamp_us);
 
   enum class StatusSymbol {
     kNotReceived,
@@ -57,13 +56,27 @@ class TransportFeedback : public Rtpfb {
   // is relative the base time.
   std::vector<int64_t> GetReceiveDeltasUs() const;
 
-  uint32_t GetPacketSenderSsrc() const { return sender_ssrc(); }
-  uint32_t GetMediaSourceSsrc() const { return media_ssrc(); }
-
   bool Parse(const CommonHeader& packet);
   static std::unique_ptr<TransportFeedback> ParseFrom(const uint8_t* buffer,
                                                       size_t length);
 
+  RTC_DEPRECATED
+  void WithPacketSenderSsrc(uint32_t ssrc) { SetSenderSsrc(ssrc); }
+  RTC_DEPRECATED
+  void WithMediaSourceSsrc(uint32_t ssrc) { SetMediaSsrc(ssrc); }
+  RTC_DEPRECATED
+  void WithBase(uint16_t base_sequence, int64_t ref_timestamp_us) {
+    SetBase(base_sequence, ref_timestamp_us);
+  }
+  RTC_DEPRECATED
+  void WithFeedbackSequenceNumber(uint8_t feedback_sequence) {
+    SetFeedbackSequenceNumber(feedback_sequence);
+  }
+  RTC_DEPRECATED
+  bool WithReceivedPacket(uint16_t sequence_number, int64_t timestamp_us) {
+    return AddReceivedPacket(sequence_number, timestamp_us);
+  }
+
  protected:
   bool Create(uint8_t* packet,
               size_t* position,

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_unittest.cc

@@ -55,11 +55,11 @@ class FeedbackTester {
     expected_deltas_.clear();
     feedback_.reset(new TransportFeedback());
 
-    feedback_->WithBase(received_seq[0], received_ts[0]);
+    feedback_->SetBase(received_seq[0], received_ts[0]);
     int64_t last_time = feedback_->GetBaseTimeUs();
     for (int i = 0; i < length; ++i) {
       int64_t time = received_ts[i];
-      EXPECT_TRUE(feedback_->WithReceivedPacket(received_seq[i], time));
+      EXPECT_TRUE(feedback_->AddReceivedPacket(received_seq[i], time));
 
       if (last_time != -1) {
         int64_t delta = time - last_time;
@@ -332,13 +332,13 @@ TEST(RtcpPacketTest, TransportFeedback_OneToTwoBitVectorSplit) {
 
 TEST(RtcpPacketTest, TransportFeedback_Aliasing) {
   TransportFeedback feedback;
-  feedback.WithBase(0, 0);
+  feedback.SetBase(0, 0);
 
   const int kSamples = 100;
   const int64_t kTooSmallDelta = TransportFeedback::kDeltaScaleFactor / 3;
 
   for (int i = 0; i < kSamples; ++i)
-    feedback.WithReceivedPacket(i, i * kTooSmallDelta);
+    feedback.AddReceivedPacket(i, i * kTooSmallDelta);
 
   feedback.Build();
   std::vector<int64_t> deltas = feedback.GetReceiveDeltasUs();
@@ -358,48 +358,48 @@ TEST(RtcpPacketTest, TransportFeedback_Aliasing) {
 TEST(RtcpPacketTest, TransportFeedback_Limits) {
   // Sequence number wrap above 0x8000.
   std::unique_ptr<TransportFeedback> packet(new TransportFeedback());
-  packet->WithBase(0, 0);
+  packet->SetBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
-  EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000));
 
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
+  packet->SetBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
-  EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000));
+  EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, 1000));
 
   // Packet status count max 0xFFFF.
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
+  packet->SetBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
-  EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000));
-  EXPECT_TRUE(packet->WithReceivedPacket(0xFFFF, 2000));
+  EXPECT_TRUE(packet->AddReceivedPacket(0xFFFF, 2000));
-  EXPECT_FALSE(packet->WithReceivedPacket(0, 3000));
+  EXPECT_FALSE(packet->AddReceivedPacket(0, 3000));
 
   // Too large delta.
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
+  packet->SetBase(0, 0);
   int64_t kMaxPositiveTimeDelta = std::numeric_limits<int16_t>::max() *
                                   TransportFeedback::kDeltaScaleFactor;
-  EXPECT_FALSE(packet->WithReceivedPacket(
+  EXPECT_FALSE(packet->AddReceivedPacket(
       1, kMaxPositiveTimeDelta + TransportFeedback::kDeltaScaleFactor));
-  EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxPositiveTimeDelta));
+  EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxPositiveTimeDelta));
 
   // Too large negative delta.
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
+  packet->SetBase(0, 0);
   int64_t kMaxNegativeTimeDelta = std::numeric_limits<int16_t>::min() *
                                   TransportFeedback::kDeltaScaleFactor;
-  EXPECT_FALSE(packet->WithReceivedPacket(
+  EXPECT_FALSE(packet->AddReceivedPacket(
       1, kMaxNegativeTimeDelta - TransportFeedback::kDeltaScaleFactor));
-  EXPECT_TRUE(packet->WithReceivedPacket(1, kMaxNegativeTimeDelta));
+  EXPECT_TRUE(packet->AddReceivedPacket(1, kMaxNegativeTimeDelta));
 
   // Base time at maximum value.
   int64_t kMaxBaseTime =
       static_cast<int64_t>(TransportFeedback::kDeltaScaleFactor) * (1L << 8) *
       ((1L << 23) - 1);
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, kMaxBaseTime);
+  packet->SetBase(0, kMaxBaseTime);
-  packet->WithReceivedPacket(0, kMaxBaseTime);
+  packet->AddReceivedPacket(0, kMaxBaseTime);
   // Serialize and de-serialize (verify 24bit parsing).
   rtc::Buffer raw_packet = packet->Build();
   packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
@@ -409,8 +409,8 @@ TEST(RtcpPacketTest, TransportFeedback_Limits) {
   int64_t kTooLargeBaseTime =
       kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8));
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, kTooLargeBaseTime);
+  packet->SetBase(0, kTooLargeBaseTime);
-  packet->WithReceivedPacket(0, kTooLargeBaseTime);
+  packet->AddReceivedPacket(0, kTooLargeBaseTime);
   raw_packet = packet->Build();
   packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
   EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs());
@@ -425,8 +425,8 @@ TEST(RtcpPacketTest, TransportFeedback_Padding) {
   const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
 
   TransportFeedback feedback;
-  feedback.WithBase(0, 0);
+  feedback.SetBase(0, 0);
-  EXPECT_TRUE(feedback.WithReceivedPacket(0, 0));
+  EXPECT_TRUE(feedback.AddReceivedPacket(0, 0));
 
   rtc::Buffer packet = feedback.Build();
   EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
@@ -466,10 +466,10 @@ TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
 
   for (int deltas = 0; deltas <= kOneBitVectorCapacity + 1; ++deltas) {
     TransportFeedback feedback;
-    feedback.WithBase(0, 0);
+    feedback.SetBase(0, 0);
     for (int i = 0; i < deltas; ++i)
-      feedback.WithReceivedPacket(i, i * 1000);
+      feedback.AddReceivedPacket(i, i * 1000);
-    feedback.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
+    feedback.AddReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
 
     rtc::Buffer serialized_packet = feedback.Build();
     std::unique_ptr<TransportFeedback> deserialized_packet =

webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric.h

@@ -35,8 +35,8 @@ class VoipMetric {
   // Consumes VoipMetric::kLength bytes.
   void Create(uint8_t* buffer) const;
 
-  void To(uint32_t ssrc) { ssrc_ = ssrc; }
+  void SetMediaSsrc(uint32_t ssrc) { ssrc_ = ssrc; }
-  void WithVoipMetric(const RTCPVoIPMetric& voip_metric) {
+  void SetVoipMetric(const RTCPVoIPMetric& voip_metric) {
     voip_metric_ = voip_metric;
   }
 

webrtc/modules/rtp_rtcp/source/rtcp_packet/voip_metric_unittest.cc

@@ -51,8 +51,8 @@ TEST(RtcpPacketVoipMetricTest, Create) {
   metric.JBmax = 0x6667;
   metric.JBabsMax = 0x7778;
   VoipMetric metric_block;
-  metric_block.To(kRemoteSsrc);
+  metric_block.SetMediaSsrc(kRemoteSsrc);
-  metric_block.WithVoipMetric(metric);
+  metric_block.SetVoipMetric(metric);
 
   metric_block.Create(buffer);
   EXPECT_EQ(0, memcmp(buffer, kBlock, kBlockSizeBytes));

webrtc/modules/rtp_rtcp/source/rtcp_packet_unittest.cc

@@ -24,8 +24,8 @@ const uint32_t kSenderSsrc = 0x12345678;
 TEST(RtcpPacketTest, BuildWithTooSmallBuffer) {
   ReportBlock rb;
   ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  EXPECT_TRUE(rr.WithReportBlock(rb));
+  EXPECT_TRUE(rr.AddReportBlock(rb));
 
   const size_t kRrLength = 8;
   const size_t kReportBlockLength = 24;

webrtc/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc

@@ -214,7 +214,7 @@ TEST_F(RtcpReceiverTest, TwoHalfValidRpsiAreIgnored) {
 TEST_F(RtcpReceiverTest, InjectRpsiPacket) {
   const uint64_t kPictureId = 0x123456789;
   rtcp::Rpsi rpsi;
-  rpsi.WithPictureId(kPictureId);
+  rpsi.SetPictureId(kPictureId);
 
   EXPECT_CALL(intra_frame_observer_, OnReceivedRPSI(_, kPictureId));
   InjectRtcpPacket(rpsi);
@@ -226,7 +226,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacket) {
 
   int64_t now = system_clock_.TimeInMilliseconds();
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
   EXPECT_CALL(bandwidth_observer_,
@@ -239,7 +239,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacket) {
 TEST_F(RtcpReceiverTest, InjectSrPacketFromUnknownSender) {
   int64_t now = system_clock_.TimeInMilliseconds();
   rtcp::SenderReport sr;
-  sr.From(kUnknownSenderSsrc);
+  sr.SetSenderSsrc(kUnknownSenderSsrc);
 
   // The parser will handle report blocks in Sender Report from other than his
   // expected peer.
@@ -266,12 +266,12 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesRTT) {
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   rtcp::ReportBlock block;
-  block.To(kReceiverMainSsrc);
+  block.SetMediaSsrc(kReceiverMainSsrc);
-  block.WithLastSr(sent_ntp);
+  block.SetLastSr(sent_ntp);
-  block.WithDelayLastSr(kDelayNtp);
+  block.SetDelayLastSr(kDelayNtp);
-  sr.WithReportBlock(block);
+  sr.AddReportBlock(block);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
@@ -296,12 +296,12 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) {
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   rtcp::ReportBlock block;
-  block.To(kReceiverMainSsrc);
+  block.SetMediaSsrc(kReceiverMainSsrc);
-  block.WithLastSr(sent_ntp);
+  block.SetLastSr(sent_ntp);
-  block.WithDelayLastSr(kDelayNtp);
+  block.SetDelayLastSr(kDelayNtp);
-  sr.WithReportBlock(block);
+  sr.AddReportBlock(block);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
   EXPECT_CALL(bandwidth_observer_,
@@ -316,7 +316,7 @@ TEST_F(RtcpReceiverTest, InjectSrPacketCalculatesNegativeRTTAsOne) {
 TEST_F(RtcpReceiverTest, InjectRrPacket) {
   int64_t now = system_clock_.TimeInMilliseconds();
   rtcp::ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
   EXPECT_CALL(bandwidth_observer_,
@@ -334,10 +334,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacket) {
 TEST_F(RtcpReceiverTest, InjectRrPacketWithReportBlockNotToUsIgnored) {
   int64_t now = system_clock_.TimeInMilliseconds();
   rtcp::ReportBlock rb;
-  rb.To(kNotToUsSsrc);
+  rb.SetMediaSsrc(kNotToUsSsrc);
   rtcp::ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  rr.WithReportBlock(rb);
+  rr.AddReportBlock(rb);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(IsEmpty()));
   EXPECT_CALL(bandwidth_observer_,
@@ -354,10 +354,10 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithOneReportBlock) {
   int64_t now = system_clock_.TimeInMilliseconds();
 
   rtcp::ReportBlock rb;
-  rb.To(kReceiverMainSsrc);
+  rb.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  rr.WithReportBlock(rb);
+  rr.AddReportBlock(rb);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
   EXPECT_CALL(bandwidth_observer_,
@@ -377,19 +377,19 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
   int64_t now = system_clock_.TimeInMilliseconds();
 
   rtcp::ReportBlock rb1;
-  rb1.To(kReceiverMainSsrc);
+  rb1.SetMediaSsrc(kReceiverMainSsrc);
-  rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
+  rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
-  rb1.WithFractionLost(10);
+  rb1.SetFractionLost(10);
 
   rtcp::ReportBlock rb2;
-  rb2.To(kReceiverExtraSsrc);
+  rb2.SetMediaSsrc(kReceiverExtraSsrc);
-  rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
+  rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
-  rb2.WithFractionLost(0);
+  rb2.SetFractionLost(0);
 
   rtcp::ReceiverReport rr1;
-  rr1.From(kSenderSsrc);
+  rr1.SetSenderSsrc(kSenderSsrc);
-  rr1.WithReportBlock(rb1);
+  rr1.AddReportBlock(rb1);
-  rr1.WithReportBlock(rb2);
+  rr1.AddReportBlock(rb2);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(2)));
   EXPECT_CALL(bandwidth_observer_,
@@ -405,21 +405,21 @@ TEST_F(RtcpReceiverTest, InjectRrPacketWithTwoReportBlocks) {
 
   // Insert next receiver report with same ssrc but new values.
   rtcp::ReportBlock rb3;
-  rb3.To(kReceiverMainSsrc);
+  rb3.SetMediaSsrc(kReceiverMainSsrc);
-  rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
+  rb3.SetExtHighestSeqNum(kSequenceNumbers[0]);
-  rb3.WithFractionLost(kFracLost[0]);
+  rb3.SetFractionLost(kFracLost[0]);
-  rb3.WithCumulativeLost(kCumLost[0]);
+  rb3.SetCumulativeLost(kCumLost[0]);
 
   rtcp::ReportBlock rb4;
-  rb4.To(kReceiverExtraSsrc);
+  rb4.SetMediaSsrc(kReceiverExtraSsrc);
-  rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
+  rb4.SetExtHighestSeqNum(kSequenceNumbers[1]);
-  rb4.WithFractionLost(kFracLost[1]);
+  rb4.SetFractionLost(kFracLost[1]);
-  rb4.WithCumulativeLost(kCumLost[1]);
+  rb4.SetCumulativeLost(kCumLost[1]);
 
   rtcp::ReceiverReport rr2;
-  rr2.From(kSenderSsrc);
+  rr2.SetSenderSsrc(kSenderSsrc);
-  rr2.WithReportBlock(rb3);
+  rr2.AddReportBlock(rb3);
-  rr2.WithReportBlock(rb4);
+  rr2.AddReportBlock(rb4);
 
   // Advance time to make 1st sent time and 2nd sent time different.
   system_clock_.AdvanceTimeMilliseconds(500);
@@ -454,13 +454,13 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
   const uint8_t kFracLost[] = {20, 11};
 
   rtcp::ReportBlock rb1;
-  rb1.To(kReceiverMainSsrc);
+  rb1.SetMediaSsrc(kReceiverMainSsrc);
-  rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
+  rb1.SetExtHighestSeqNum(kSequenceNumbers[0]);
-  rb1.WithFractionLost(kFracLost[0]);
+  rb1.SetFractionLost(kFracLost[0]);
-  rb1.WithCumulativeLost(kCumLost[0]);
+  rb1.SetCumulativeLost(kCumLost[0]);
   rtcp::ReceiverReport rr1;
-  rr1.From(kSenderSsrc);
+  rr1.SetSenderSsrc(kSenderSsrc);
-  rr1.WithReportBlock(rb1);
+  rr1.AddReportBlock(rb1);
 
   int64_t now = system_clock_.TimeInMilliseconds();
 
@@ -481,13 +481,13 @@ TEST_F(RtcpReceiverTest, InjectRrPacketsFromTwoRemoteSsrcs) {
   EXPECT_EQ(kSequenceNumbers[0], received_blocks[0].extendedHighSeqNum);
 
   rtcp::ReportBlock rb2;
-  rb2.To(kReceiverMainSsrc);
+  rb2.SetMediaSsrc(kReceiverMainSsrc);
-  rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
+  rb2.SetExtHighestSeqNum(kSequenceNumbers[1]);
-  rb2.WithFractionLost(kFracLost[1]);
+  rb2.SetFractionLost(kFracLost[1]);
-  rb2.WithCumulativeLost(kCumLost[1]);
+  rb2.SetCumulativeLost(kCumLost[1]);
   rtcp::ReceiverReport rr2;
-  rr2.From(kSenderSsrc2);
+  rr2.SetSenderSsrc(kSenderSsrc2);
-  rr2.WithReportBlock(rb2);
+  rr2.AddReportBlock(rb2);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(SizeIs(1)));
   EXPECT_CALL(bandwidth_observer_,
@@ -519,11 +519,11 @@ TEST_F(RtcpReceiverTest, GetRtt) {
       -1, rtcp_receiver_.RTT(kSenderSsrc, nullptr, nullptr, nullptr, nullptr));
 
   rtcp::ReportBlock rb;
-  rb.To(kReceiverMainSsrc);
+  rb.SetMediaSsrc(kReceiverMainSsrc);
 
   rtcp::ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  rr.WithReportBlock(rb);
+  rr.AddReportBlock(rb);
   int64_t now = system_clock_.TimeInMilliseconds();
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
@@ -544,10 +544,10 @@ TEST_F(RtcpReceiverTest, InjectIjWithNoItem) {
 // App packets are ignored.
 TEST_F(RtcpReceiverTest, InjectApp) {
   rtcp::App app;
-  app.WithSubType(30);
+  app.SetSubType(30);
-  app.WithName(0x17a177e);
+  app.SetName(0x17a177e);
   const uint8_t kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
-  app.WithData(kData, sizeof(kData));
+  app.SetData(kData, sizeof(kData));
 
   InjectRtcpPacket(app);
 }
@@ -557,7 +557,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
   MockRtcpCallbackImpl callback;
   rtcp_receiver_.RegisterRtcpStatisticsCallback(&callback);
   rtcp::Sdes sdes;
-  sdes.WithCName(kSenderSsrc, kCname);
+  sdes.AddCName(kSenderSsrc, kCname);
 
   EXPECT_CALL(callback, CNameChanged(StrEq(kCname), kSenderSsrc));
   InjectRtcpPacket(sdes);
@@ -570,7 +570,7 @@ TEST_F(RtcpReceiverTest, InjectSdesWithOneChunk) {
 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
   const char kCname[] = "alice@host";
   rtcp::Sdes sdes;
-  sdes.WithCName(kSenderSsrc, kCname);
+  sdes.AddCName(kSenderSsrc, kCname);
 
   InjectRtcpPacket(sdes);
 
@@ -579,7 +579,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
 
   // Verify that BYE removes the CNAME.
   rtcp::Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
 
   InjectRtcpPacket(bye);
 
@@ -588,13 +588,13 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesCname) {
 
 TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
   rtcp::ReportBlock rb1;
-  rb1.To(kReceiverMainSsrc);
+  rb1.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ReportBlock rb2;
-  rb2.To(kReceiverExtraSsrc);
+  rb2.SetMediaSsrc(kReceiverExtraSsrc);
   rtcp::ReceiverReport rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  rr.WithReportBlock(rb1);
+  rr.AddReportBlock(rb1);
-  rr.WithReportBlock(rb2);
+  rr.AddReportBlock(rb2);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
@@ -606,7 +606,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
 
   // Verify that BYE removes the report blocks.
   rtcp::Bye bye;
-  bye.From(kSenderSsrc);
+  bye.SetSenderSsrc(kSenderSsrc);
 
   InjectRtcpPacket(bye);
 
@@ -626,7 +626,7 @@ TEST_F(RtcpReceiverTest, InjectByePacket_RemovesReportBlocks) {
 
 TEST_F(RtcpReceiverTest, InjectPliPacket) {
   rtcp::Pli pli;
-  pli.To(kReceiverMainSsrc);
+  pli.SetMediaSsrc(kReceiverMainSsrc);
 
   EXPECT_CALL(
       packet_type_counter_observer_,
@@ -639,7 +639,7 @@ TEST_F(RtcpReceiverTest, InjectPliPacket) {
 
 TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
   rtcp::Pli pli;
-  pli.To(kNotToUsSsrc);
+  pli.SetMediaSsrc(kNotToUsSsrc);
 
   EXPECT_CALL(
       packet_type_counter_observer_,
@@ -651,7 +651,7 @@ TEST_F(RtcpReceiverTest, PliPacketNotToUsIgnored) {
 
 TEST_F(RtcpReceiverTest, InjectFirPacket) {
   rtcp::Fir fir;
-  fir.WithRequestTo(kReceiverMainSsrc, 13);
+  fir.AddRequestTo(kReceiverMainSsrc, 13);
 
   EXPECT_CALL(
       packet_type_counter_observer_,
@@ -664,7 +664,7 @@ TEST_F(RtcpReceiverTest, InjectFirPacket) {
 
 TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
   rtcp::Fir fir;
-  fir.WithRequestTo(kNotToUsSsrc, 13);
+  fir.AddRequestTo(kNotToUsSsrc, 13);
 
   EXPECT_CALL(intra_frame_observer_, OnReceivedIntraFrameRequest(_)).Times(0);
   InjectRtcpPacket(fir);
@@ -673,7 +673,7 @@ TEST_F(RtcpReceiverTest, FirPacketNotToUsIgnored) {
 TEST_F(RtcpReceiverTest, InjectSliPacket) {
   const uint8_t kPictureId = 40;
   rtcp::Sli sli;
-  sli.WithPictureId(kPictureId);
+  sli.AddPictureId(kPictureId);
 
   EXPECT_CALL(intra_frame_observer_, OnReceivedSLI(_, kPictureId));
   InjectRtcpPacket(sli);
@@ -681,7 +681,7 @@ TEST_F(RtcpReceiverTest, InjectSliPacket) {
 
 TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
 
   InjectRtcpPacket(xr);
 }
@@ -690,23 +690,23 @@ TEST_F(RtcpReceiverTest, ExtendedReportsPacketWithZeroReportBlocksIgnored) {
 TEST_F(RtcpReceiverTest, InjectExtendedReportsVoipPacket) {
   const uint8_t kLossRate = 123;
   rtcp::VoipMetric voip_metric;
-  voip_metric.To(kReceiverMainSsrc);
+  voip_metric.SetMediaSsrc(kReceiverMainSsrc);
   RTCPVoIPMetric metric;
   metric.lossRate = kLossRate;
-  voip_metric.WithVoipMetric(metric);
+  voip_metric.SetVoipMetric(metric);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithVoipMetric(voip_metric);
+  xr.AddVoipMetric(voip_metric);
 
   InjectRtcpPacket(xr);
 }
 
 TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
   rtcp::VoipMetric voip_metric;
-  voip_metric.To(kNotToUsSsrc);
+  voip_metric.SetMediaSsrc(kNotToUsSsrc);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithVoipMetric(voip_metric);
+  xr.AddVoipMetric(voip_metric);
 
   InjectRtcpPacket(xr);
 }
@@ -714,10 +714,10 @@ TEST_F(RtcpReceiverTest, ExtendedReportsVoipPacketNotToUsIgnored) {
 TEST_F(RtcpReceiverTest, InjectExtendedReportsReceiverReferenceTimePacket) {
   const NtpTime kNtp(0x10203, 0x40506);
   rtcp::Rrtr rrtr;
-  rrtr.WithNtp(kNtp);
+  rrtr.SetNtp(kNtp);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithRrtr(rrtr);
+  xr.AddRrtr(rrtr);
 
   RtcpReceiveTimeInfo rrtime;
   EXPECT_FALSE(rtcp_receiver_.LastReceivedXrReferenceTimeInfo(&rrtime));
@@ -739,10 +739,10 @@ TEST_F(RtcpReceiverTest, ExtendedReportsDlrrPacketNotToUsIgnored) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kNotToUsSsrc, 0x12345, 0x67890);
+  dlrr.AddDlrrItem(kNotToUsSsrc, 0x12345, 0x67890);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
 
   InjectRtcpPacket(xr);
 
@@ -758,10 +758,10 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithSubBlock) {
   EXPECT_FALSE(rtcp_receiver_.GetAndResetXrRrRtt(&rtt_ms));
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
 
   InjectRtcpPacket(xr);
 
@@ -777,12 +777,12 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsDlrrPacketWithMultipleSubBlocks) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, kLastRR, kDelay);
-  dlrr.WithDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890);
+  dlrr.AddDlrrItem(kReceiverMainSsrc + 1, 0x12345, 0x67890);
-  dlrr.WithDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890);
+  dlrr.AddDlrrItem(kReceiverMainSsrc + 2, 0x12345, 0x67890);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
 
   InjectRtcpPacket(xr);
 
@@ -798,14 +798,14 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithMultipleReportBlocks) {
 
   rtcp::Rrtr rrtr;
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
-  metric.To(kReceiverMainSsrc);
+  metric.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithRrtr(rrtr);
+  xr.AddRrtr(rrtr);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
-  xr.WithVoipMetric(metric);
+  xr.AddVoipMetric(metric);
 
   InjectRtcpPacket(xr);
 
@@ -820,14 +820,14 @@ TEST_F(RtcpReceiverTest, InjectExtendedReportsPacketWithUnknownReportBlock) {
 
   rtcp::Rrtr rrtr;
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, 0x12345, 0x67890);
   rtcp::VoipMetric metric;
-  metric.To(kReceiverMainSsrc);
+  metric.SetMediaSsrc(kReceiverMainSsrc);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithRrtr(rrtr);
+  xr.AddRrtr(rrtr);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
-  xr.WithVoipMetric(metric);
+  xr.AddVoipMetric(metric);
 
   rtc::Buffer packet = xr.Build();
   // Modify the DLRR block to have an unsupported block type, from 5 to 6.
@@ -861,10 +861,10 @@ TEST_F(RtcpReceiverTest, RttCalculatedAfterExtendedReportsDlrr) {
   system_clock_.AdvanceTimeMilliseconds(kRttMs + kDelayMs);
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
 
   InjectRtcpPacket(xr);
 
@@ -884,10 +884,10 @@ TEST_F(RtcpReceiverTest, XrDlrrCalculatesNegativeRttAsOne) {
   rtcp_receiver_.SetRtcpXrRrtrStatus(true);
 
   rtcp::Dlrr dlrr;
-  dlrr.WithDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
+  dlrr.AddDlrrItem(kReceiverMainSsrc, sent_ntp, kDelayNtp);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithDlrr(dlrr);
+  xr.AddDlrr(dlrr);
 
   InjectRtcpPacket(xr);
 
@@ -906,10 +906,10 @@ TEST_F(RtcpReceiverTest, GetLastReceivedExtendedReportsReferenceTimeInfo) {
   const uint32_t kNtpMid = CompactNtp(kNtp);
 
   rtcp::Rrtr rrtr;
-  rrtr.WithNtp(kNtp);
+  rrtr.SetNtp(kNtp);
   rtcp::ExtendedReports xr;
-  xr.From(kSenderSsrc);
+  xr.SetSenderSsrc(kSenderSsrc);
-  xr.WithRrtr(rrtr);
+  xr.AddRrtr(rrtr);
 
   InjectRtcpPacket(xr);
 
@@ -935,11 +935,11 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
 
   // Add a RR and advance the clock just enough to not trigger a timeout.
   rtcp::ReportBlock rb1;
-  rb1.To(kReceiverMainSsrc);
+  rb1.SetMediaSsrc(kReceiverMainSsrc);
-  rb1.WithExtHighestSeqNum(kSequenceNumber);
+  rb1.SetExtHighestSeqNum(kSequenceNumber);
   rtcp::ReceiverReport rr1;
-  rr1.From(kSenderSsrc);
+  rr1.SetSenderSsrc(kSenderSsrc);
-  rr1.WithReportBlock(rb1);
+  rr1.AddReportBlock(rb1);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
@@ -970,11 +970,11 @@ TEST_F(RtcpReceiverTest, ReceiveReportTimeout) {
 
   // Add a new RR with increase sequence number to reset timers.
   rtcp::ReportBlock rb2;
-  rb2.To(kReceiverMainSsrc);
+  rb2.SetMediaSsrc(kReceiverMainSsrc);
-  rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
+  rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
   rtcp::ReceiverReport rr2;
-  rr2.From(kSenderSsrc);
+  rr2.SetSenderSsrc(kSenderSsrc);
-  rr2.WithReportBlock(rb2);
+  rr2.AddReportBlock(rb2);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
@@ -1004,10 +1004,10 @@ TEST_F(RtcpReceiverTest, TmmbrReceivedWithNoIncomingPacket) {
 TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
   const uint32_t kBitrateBps = 30000;
   rtcp::Tmmbr tmmbr;
-  tmmbr.From(kSenderSsrc);
+  tmmbr.SetSenderSsrc(kSenderSsrc);
-  tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0));
+  tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, kBitrateBps, 0));
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
@@ -1027,11 +1027,11 @@ TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
 TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
   const uint32_t kBitrateBps = 30000;
   rtcp::Tmmbr tmmbr;
-  tmmbr.From(kSenderSsrc);
+  tmmbr.SetSenderSsrc(kSenderSsrc);
-  tmmbr.WithTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0));
+  tmmbr.AddTmmbr(rtcp::TmmbItem(kNotToUsSsrc, kBitrateBps, 0));
 
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
@@ -1046,10 +1046,10 @@ TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
 
 TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
   rtcp::Tmmbr tmmbr;
-  tmmbr.From(kSenderSsrc);
+  tmmbr.SetSenderSsrc(kSenderSsrc);
-  tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0));
+  tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 0, 0));
   rtcp::SenderReport sr;
-  sr.From(kSenderSsrc);
+  sr.SetSenderSsrc(kSenderSsrc);
   rtcp::CompoundPacket compound;
   compound.Append(&sr);
   compound.Append(&tmmbr);
@@ -1067,10 +1067,10 @@ TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
   // The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
   for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
     rtcp::Tmmbr tmmbr;
-    tmmbr.From(ssrc);
+    tmmbr.SetSenderSsrc(ssrc);
-    tmmbr.WithTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0));
+    tmmbr.AddTmmbr(rtcp::TmmbItem(kReceiverMainSsrc, 30000, 0));
     rtcp::SenderReport sr;
-    sr.From(ssrc);
+    sr.SetSenderSsrc(ssrc);
     rtcp::CompoundPacket compound;
     compound.Append(&sr);
     compound.Append(&tmmbr);
@@ -1108,15 +1108,15 @@ TEST_F(RtcpReceiverTest, Callbacks) {
 
   // First packet, all numbers should just propagate.
   rtcp::ReportBlock rb1;
-  rb1.To(kReceiverMainSsrc);
+  rb1.SetMediaSsrc(kReceiverMainSsrc);
-  rb1.WithExtHighestSeqNum(kSequenceNumber);
+  rb1.SetExtHighestSeqNum(kSequenceNumber);
-  rb1.WithFractionLost(kFractionLoss);
+  rb1.SetFractionLost(kFractionLoss);
-  rb1.WithCumulativeLost(kCumulativeLoss);
+  rb1.SetCumulativeLost(kCumulativeLoss);
-  rb1.WithJitter(kJitter);
+  rb1.SetJitter(kJitter);
 
   rtcp::ReceiverReport rr1;
-  rr1.From(kSenderSsrc);
+  rr1.SetSenderSsrc(kSenderSsrc);
-  rr1.WithReportBlock(rb1);
+  rr1.AddReportBlock(rb1);
   EXPECT_CALL(
       callback,
       StatisticsUpdated(
@@ -1134,15 +1134,15 @@ TEST_F(RtcpReceiverTest, Callbacks) {
 
   // Add arbitrary numbers, callback should not be called.
   rtcp::ReportBlock rb2;
-  rb2.To(kReceiverMainSsrc);
+  rb2.SetMediaSsrc(kReceiverMainSsrc);
-  rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
+  rb2.SetExtHighestSeqNum(kSequenceNumber + 1);
-  rb2.WithFractionLost(42);
+  rb2.SetFractionLost(42);
-  rb2.WithCumulativeLost(137);
+  rb2.SetCumulativeLost(137);
-  rb2.WithJitter(4711);
+  rb2.SetJitter(4711);
 
   rtcp::ReceiverReport rr2;
-  rr2.From(kSenderSsrc);
+  rr2.SetSenderSsrc(kSenderSsrc);
-  rr2.WithReportBlock(rb2);
+  rr2.AddReportBlock(rb2);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedRtcpReportBlocks(_));
   EXPECT_CALL(bandwidth_observer_, OnReceivedRtcpReceiverReport(_, _, _));
@@ -1152,10 +1152,10 @@ TEST_F(RtcpReceiverTest, Callbacks) {
 
 TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
   rtcp::TransportFeedback packet;
-  packet.To(kReceiverMainSsrc);
+  packet.SetMediaSsrc(kReceiverMainSsrc);
-  packet.From(kSenderSsrc);
+  packet.SetSenderSsrc(kSenderSsrc);
-  packet.WithBase(1, 1000);
+  packet.SetBase(1, 1000);
-  packet.WithReceivedPacket(1, 1000);
+  packet.AddReceivedPacket(1, 1000);
 
   EXPECT_CALL(
       transport_feedback_observer_,
@@ -1168,8 +1168,8 @@ TEST_F(RtcpReceiverTest, ReceivesTransportFeedback) {
 TEST_F(RtcpReceiverTest, ReceivesRemb) {
   const uint32_t kBitrateBps = 500000;
   rtcp::Remb remb;
-  remb.From(kSenderSsrc);
+  remb.SetSenderSsrc(kSenderSsrc);
-  remb.WithBitrateBps(kBitrateBps);
+  remb.SetBitrateBps(kBitrateBps);
 
   EXPECT_CALL(bandwidth_observer_, OnReceivedEstimatedBitrate(kBitrateBps));
   InjectRtcpPacket(remb);
@@ -1178,15 +1178,15 @@ TEST_F(RtcpReceiverTest, ReceivesRemb) {
 TEST_F(RtcpReceiverTest, HandlesInvalidTransportFeedback) {
   // Send a compound packet with a TransportFeedback followed by something else.
   rtcp::TransportFeedback packet;
-  packet.To(kReceiverMainSsrc);
+  packet.SetMediaSsrc(kReceiverMainSsrc);
-  packet.From(kSenderSsrc);
+  packet.SetSenderSsrc(kSenderSsrc);
-  packet.WithBase(1, 1000);
+  packet.SetBase(1, 1000);
-  packet.WithReceivedPacket(1, 1000);
+  packet.AddReceivedPacket(1, 1000);
 
   static uint32_t kBitrateBps = 50000;
   rtcp::Remb remb;
-  remb.From(kSenderSsrc);
+  remb.SetSenderSsrc(kSenderSsrc);
-  remb.WithBitrateBps(kBitrateBps);
+  remb.SetBitrateBps(kBitrateBps);
   rtcp::CompoundPacket compound;
   compound.Append(&packet);
   compound.Append(&remb);
@@ -1214,9 +1214,9 @@ TEST_F(RtcpReceiverTest, Nack) {
   nack_set.insert(std::begin(kNackList2), std::end(kNackList2));
 
   rtcp::Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kReceiverMainSsrc);
+  nack.SetMediaSsrc(kReceiverMainSsrc);
-  nack.WithList(kNackList1, kNackListLength1);
+  nack.SetPacketIds(kNackList1, kNackListLength1);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList1)));
   EXPECT_CALL(
@@ -1229,9 +1229,9 @@ TEST_F(RtcpReceiverTest, Nack) {
   InjectRtcpPacket(nack);
 
   rtcp::Nack nack2;
-  nack2.From(kSenderSsrc);
+  nack2.SetSenderSsrc(kSenderSsrc);
-  nack2.To(kReceiverMainSsrc);
+  nack2.SetMediaSsrc(kReceiverMainSsrc);
-  nack2.WithList(kNackList2, kNackListLength2);
+  nack2.SetPacketIds(kNackList2, kNackListLength2);
   EXPECT_CALL(rtp_rtcp_impl_, OnReceivedNack(ElementsAreArray(kNackList2)));
   EXPECT_CALL(packet_type_counter_observer_,
               RtcpPacketTypesCounterUpdated(
@@ -1248,9 +1248,9 @@ TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
   const size_t kNackListLength1 = std::end(kNackList1) - std::begin(kNackList1);
 
   rtcp::Nack nack;
-  nack.From(kSenderSsrc);
+  nack.SetSenderSsrc(kSenderSsrc);
-  nack.To(kNotToUsSsrc);
+  nack.SetMediaSsrc(kNotToUsSsrc);
-  nack.WithList(kNackList1, kNackListLength1);
+  nack.SetPacketIds(kNackList1, kNackListLength1);
 
   EXPECT_CALL(packet_type_counter_observer_,
               RtcpPacketTypesCounterUpdated(
@@ -1260,8 +1260,8 @@ TEST_F(RtcpReceiverTest, NackNotForUsIgnored) {
 
 TEST_F(RtcpReceiverTest, ForceSenderReport) {
   rtcp::RapidResyncRequest rr;
-  rr.From(kSenderSsrc);
+  rr.SetSenderSsrc(kSenderSsrc);
-  rr.To(kReceiverMainSsrc);
+  rr.SetMediaSsrc(kReceiverMainSsrc);
 
   EXPECT_CALL(rtp_rtcp_impl_, OnRequestSendReport());
   InjectRtcpPacket(rr);

webrtc/modules/rtp_rtcp/source/rtcp_sender.cc

@@ -449,14 +449,14 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSR(const RtcpContext& ctx) {
           (ctx.feedback_state_.frequency_hz / 1000);
 
   rtcp::SenderReport* report = new rtcp::SenderReport();
-  report->From(ssrc_);
+  report->SetSenderSsrc(ssrc_);
-  report->WithNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
+  report->SetNtp(NtpTime(ctx.ntp_sec_, ctx.ntp_frac_));
-  report->WithRtpTimestamp(rtp_timestamp);
+  report->SetRtpTimestamp(rtp_timestamp);
-  report->WithPacketCount(ctx.feedback_state_.packets_sent);
+  report->SetPacketCount(ctx.feedback_state_.packets_sent);
-  report->WithOctetCount(ctx.feedback_state_.media_bytes_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();
 
@@ -469,19 +469,19 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSDES(
   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);
@@ -489,8 +489,8 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRR(const RtcpContext& ctx) {
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildPLI(const RtcpContext& ctx) {
   rtcp::Pli* pli = new rtcp::Pli();
-  pli->From(ssrc_);
+  pli->SetSenderSsrc(ssrc_);
-  pli->To(remote_ssrc_);
+  pli->SetMediaSsrc(remote_ssrc_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::PLI");
@@ -506,8 +506,8 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
     ++sequence_number_fir_;  // Do not increase if repetition.
 
   rtcp::Fir* fir = new rtcp::Fir();
-  fir->From(ssrc_);
+  fir->SetSenderSsrc(ssrc_);
-  fir->WithRequestTo(remote_ssrc_, sequence_number_fir_);
+  fir->AddRequestTo(remote_ssrc_, sequence_number_fir_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::FIR");
@@ -527,10 +527,10 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildFIR(const RtcpContext& ctx) {
 */
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildSLI(const RtcpContext& ctx) {
   rtcp::Sli* sli = new rtcp::Sli();
-  sli->From(ssrc_);
+  sli->SetSenderSsrc(ssrc_);
-  sli->To(remote_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);
 }
@@ -553,10 +553,10 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
     return nullptr;
 
   rtcp::Rpsi* rpsi = new rtcp::Rpsi();
-  rpsi->From(ssrc_);
+  rpsi->SetSenderSsrc(ssrc_);
-  rpsi->To(remote_ssrc_);
+  rpsi->SetMediaSsrc(remote_ssrc_);
-  rpsi->WithPayloadType(ctx.feedback_state_.send_payload_type);
+  rpsi->SetPayloadType(ctx.feedback_state_.send_payload_type);
-  rpsi->WithPictureId(ctx.picture_id_);
+  rpsi->SetPictureId(ctx.picture_id_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(rpsi);
 }
@@ -564,10 +564,9 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildRPSI(
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildREMB(
     const RtcpContext& ctx) {
   rtcp::Remb* remb = new rtcp::Remb();
-  remb->From(ssrc_);
+  remb->SetSenderSsrc(ssrc_);
-  for (uint32_t ssrc : remb_ssrcs_)
+  remb->SetBitrateBps(remb_bitrate_);
-    remb->AppliesTo(ssrc);
+  remb->SetSsrcs(remb_ssrcs_);
-  remb->WithBitrateBps(remb_bitrate_);
 
   TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                        "RTCPSender::REMB");
@@ -626,12 +625,12 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
     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);
 }
@@ -639,10 +638,10 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBR(
 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);
     }
   }
 
@@ -651,10 +650,10 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildTMMBN(
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
   rtcp::App* app = new rtcp::App();
-  app->From(ssrc_);
+  app->SetSsrc(ssrc_);
-  app->WithSubType(app_sub_type_);
+  app->SetSubType(app_sub_type_);
-  app->WithName(app_name_);
+  app->SetName(app_name_);
-  app->WithData(app_data_.get(), app_length_);
+  app->SetData(app_data_.get(), app_length_);
 
   return std::unique_ptr<rtcp::RtcpPacket>(app);
 }
@@ -662,9 +661,9 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildAPP(const RtcpContext& ctx) {
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
     const RtcpContext& ctx) {
   rtcp::Nack* nack = new rtcp::Nack();
-  nack->From(ssrc_);
+  nack->SetSenderSsrc(ssrc_);
-  nack->To(remote_ssrc_);
+  nack->SetMediaSsrc(remote_ssrc_);
-  nack->WithList(ctx.nack_list_, ctx.nack_size_);
+  nack->SetPacketIds(ctx.nack_list_, ctx.nack_size_);
 
   // Report stats.
   NACKStringBuilder stringBuilder;
@@ -687,9 +686,8 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildNACK(
 
 std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildBYE(const RtcpContext& ctx) {
   rtcp::Bye* bye = new rtcp::Bye();
-  bye->From(ssrc_);
+  bye->SetSenderSsrc(ssrc_);
-  for (uint32_t csrc : csrcs_)
+  bye->SetCsrcs(csrcs_);
-    bye->WithCsrc(csrc);
 
   return std::unique_ptr<rtcp::RtcpPacket>(bye);
 }
@@ -698,12 +696,12 @@ 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?
 
@@ -713,13 +711,13 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildReceiverReferenceTime(
 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);
 }
@@ -728,13 +726,13 @@ std::unique_ptr<rtcp::RtcpPacket> RTCPSender::BuildDlrr(
 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.SetMediaSsrc(remote_ssrc_);
-  voip.WithVoipMetric(xr_voip_metric_);
+  voip.SetVoipMetric(xr_voip_metric_);
 
-  xr->WithVoipMetric(voip);
+  xr->AddVoipMetric(voip);
 
   return std::unique_ptr<rtcp::RtcpPacket>(xr);
 }
@@ -905,16 +903,16 @@ bool RTCPSender::AddReportBlock(const FeedbackState& feedback_state,
   }
   RTC_DCHECK(report_blocks_.find(ssrc) == report_blocks_.end());
   rtcp::ReportBlock* block = &report_blocks_[ssrc];
-  block->To(ssrc);
+  block->SetMediaSsrc(ssrc);
-  block->WithFractionLost(stats.fraction_lost);
+  block->SetFractionLost(stats.fraction_lost);
-  if (!block->WithCumulativeLost(stats.cumulative_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->SetExtHighestSeqNum(stats.extended_max_sequence_number);
-  block->WithJitter(stats.jitter);
+  block->SetJitter(stats.jitter);
-  block->WithLastSr(feedback_state.remote_sr);
+  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.
@@ -934,7 +932,7 @@ bool RTCPSender::AddReportBlock(const FeedbackState& feedback_state,
     receiveTime <<= 16;
     receiveTime += (feedback_state.last_rr_ntp_frac & 0xffff0000) >> 16;
 
-    block->WithDelayLastSr(now - receiveTime);
+    block->SetDelayLastSr(now - receiveTime);
   }
   return true;
 }

webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc

@@ -216,9 +216,9 @@ class RtpRtcpImplTest : public ::testing::Test {
     uint16_t list[1];
     list[0] = sequence_number;
     const uint16_t kListLength = sizeof(list) / sizeof(list[0]);
-    nack.From(sender ? kReceiverSsrc : kSenderSsrc);
+    nack.SetSenderSsrc(sender ? kReceiverSsrc : kSenderSsrc);
-    nack.To(sender ? kSenderSsrc : kReceiverSsrc);
+    nack.SetMediaSsrc(sender ? kSenderSsrc : kReceiverSsrc);
-    nack.WithList(list, kListLength);
+    nack.SetPacketIds(list, kListLength);
     rtc::Buffer packet = nack.Build();
     EXPECT_EQ(0, module->impl_->IncomingRtcpPacket(packet.data(),
                                                    packet.size()));

webrtc/video/end_to_end_tests.cc

@@ -531,10 +531,10 @@ TEST_F(EndToEndTest, ReceivesNackAndRetransmitsAudio) {
       } else {
         // Send a NACK as often as necessary until retransmission is received.
         rtcp::Nack nack;
-        nack.From(local_ssrc_);
+        nack.SetSenderSsrc(local_ssrc_);
-        nack.To(remote_ssrc_);
+        nack.SetMediaSsrc(remote_ssrc_);
         uint16_t nack_list[] = {*sequence_number_to_retransmit_};
-        nack.WithList(nack_list, 1);
+        nack.SetPacketIds(nack_list, 1);
         rtc::Buffer buffer = nack.Build();
 
         EXPECT_TRUE(receive_transport_->SendRtcp(buffer.data(), buffer.size()));