Reland of Unify rtcp packet setters

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 107 matching lines @@
   packets.push_back(PacketInfo(100, 200, 0, 1500, 0));
   packets.push_back(PacketInfo(110, 210, 1, 1500, 0));
   packets.push_back(PacketInfo(120, 220, 2, 1500, 0));
   packets.push_back(PacketInfo(130, 230, 3, 1500, 1));
   packets.push_back(PacketInfo(140, 240, 4, 1500, 1));
 
   for (const PacketInfo& packet : packets)
     OnSentPacket(packet);
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
-                    packets[0].arrival_time_ms * 1000);
+  feedback.SetBase(packets[0].sequence_number,
+                   packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : packets) {
-    EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
-                                            packet.arrival_time_ms * 1000));
+    EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
+                                           packet.arrival_time_ms * 1000));
   }
 
   feedback.Build();
 
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke(
           [packets, this](const std::vector<PacketInfo>& feedback_vector) {
             ComparePacketVectors(packets, feedback_vector);
           }));
@@ skipping 10 matching lines @@
 
   const uint16_t kSendSideDropBefore = 1;
   const uint16_t kReceiveSideDropAfter = 3;
 
   for (const PacketInfo& packet : packets) {
     if (packet.sequence_number >= kSendSideDropBefore)
       OnSentPacket(packet);
   }
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
-                    packets[0].arrival_time_ms * 1000);
+  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,
-                                              packet.arrival_time_ms * 1000));
+      EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
+                                             packet.arrival_time_ms * 1000));
     }
   }
 
   feedback.Build();
 
   std::vector<PacketInfo> expected_packets(
       packets.begin() + kSendSideDropBefore,
       packets.begin() + kReceiveSideDropAfter + 1);
 
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
@@ skipping 16 matching lines @@
                                PacketInfo::kNotAProbe));
   packets.push_back(
       PacketInfo(kHighArrivalTimeMs, 220, 2, 1500, PacketInfo::kNotAProbe));
 
   for (const PacketInfo& packet : packets)
     OnSentPacket(packet);
 
   for (size_t i = 0; i < packets.size(); ++i) {
     std::unique_ptr<rtcp::TransportFeedback> feedback(
         new rtcp::TransportFeedback());
-    feedback->WithBase(packets[i].sequence_number,
-                       packets[i].arrival_time_ms * 1000);
+    feedback->SetBase(packets[i].sequence_number,
+                      packets[i].arrival_time_ms * 1000);
 
-    EXPECT_TRUE(feedback->WithReceivedPacket(
-        packets[i].sequence_number, packets[i].arrival_time_ms * 1000));
+    EXPECT_TRUE(feedback->AddReceivedPacket(packets[i].sequence_number,
+                                            packets[i].arrival_time_ms * 1000));
 
     rtc::Buffer raw_packet = feedback->Build();
     feedback = rtcp::TransportFeedback::ParseFrom(raw_packet.data(),
                                                   raw_packet.size());
 
     std::vector<PacketInfo> expected_packets;
     expected_packets.push_back(packets[i]);
 
     EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
         .Times(1)
@@ skipping 12 matching lines @@
   packets.push_back(PacketInfo(100, 220, 2, 1500, 0));
   std::vector<PacketInfo> expected_packets;
   expected_packets.push_back(packets[2]);
   expected_packets.push_back(packets[1]);
   expected_packets.push_back(packets[0]);
 
   for (const PacketInfo& packet : packets)
     OnSentPacket(packet);
 
   rtcp::TransportFeedback feedback;
-  feedback.WithBase(packets[0].sequence_number,
-                    packets[0].arrival_time_ms * 1000);
+  feedback.SetBase(packets[0].sequence_number,
+                   packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : packets) {
-    EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
-                                            packet.arrival_time_ms * 1000));
+    EXPECT_TRUE(feedback.AddReceivedPacket(packet.sequence_number,
+                                           packet.arrival_time_ms * 1000));
   }
 
   feedback.Build();
 
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke([expected_packets,
                         this](const std::vector<PacketInfo>& feedback_vector) {
         ComparePacketVectors(expected_packets, feedback_vector);
       }));
@@ skipping 43 matching lines @@
   expected_packets.push_back(sent_packets[2]);
 
   // Packets will be added to send history.
   for (const PacketInfo& packet : sent_packets)
     OnSentPacket(packet);
   OnSentPacket(info);
 
   // Create expected feedback and send into adapter.
   std::unique_ptr<rtcp::TransportFeedback> feedback(
       new rtcp::TransportFeedback());
-  feedback->WithBase(sent_packets[0].sequence_number,
-                     sent_packets[0].arrival_time_ms * 1000);
+  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,
-                                             packet.arrival_time_ms * 1000));
+    EXPECT_TRUE(feedback->AddReceivedPacket(packet.sequence_number,
+                                            packet.arrival_time_ms * 1000));
   }
-  EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number,
-                                            info.arrival_time_ms * 1000));
+  EXPECT_FALSE(feedback->AddReceivedPacket(info.sequence_number,
+                                           info.arrival_time_ms * 1000));
 
   rtc::Buffer raw_packet = feedback->Build();
   feedback =
       rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   std::vector<PacketInfo> received_feedback;
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke([expected_packets, &received_feedback](
           const std::vector<PacketInfo>& feedback_vector) {
         EXPECT_EQ(expected_packets.size(), feedback_vector.size());
         received_feedback = feedback_vector;
       }));
   adapter_->OnTransportFeedback(*feedback.get());
 
   // 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);
-  EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number,
-                                           info.arrival_time_ms * 1000));
+  feedback->SetBase(info.sequence_number, info.arrival_time_ms * 1000);
+  EXPECT_TRUE(feedback->AddReceivedPacket(info.sequence_number,
+                                          info.arrival_time_ms * 1000));
   raw_packet = feedback->Build();
   feedback =
       rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke(
           [&received_feedback](const std::vector<PacketInfo>& feedback_vector) {
             EXPECT_EQ(1u, feedback_vector.size());
             received_feedback.push_back(feedback_vector[0]);
           }));
   adapter_->OnTransportFeedback(*feedback.get());
 
   expected_packets.push_back(info);
 
   ComparePacketVectors(expected_packets, received_feedback);
 }
 
 }  // namespace test
 }  // namespace webrtc