Unify rtcp packet setters

webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback_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 37 matching lines @@
     if (received_ts == nullptr) {
       temp_deltas.reset(new int64_t[length]);
       GenerateDeltas(received_seq, length, temp_deltas.get());
       received_ts = temp_deltas.get();
     }
 
     expected_seq_.clear();
     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;
         expected_deltas_.push_back(delta);
       }
       last_time = time;
     }
     expected_seq_.insert(expected_seq_.begin(), &received_seq[0],
                          &received_seq[length]);
   }
@@ skipping 252 matching lines @@
   }
 
   FeedbackTester test;
   test.WithExpectedSize(kExpectedSizeBytes);
   test.WithInput(kReceived, kReceiveTimes, kNumPackets);
   test.VerifyPacket();
 }
 
 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();
 
   int64_t accumulated_delta = 0;
   int num_samples = 0;
   for (int64_t delta : deltas) {
     accumulated_delta += delta;
     int64_t expected_time = num_samples * kTooSmallDelta;
     ++num_samples;
 
     EXPECT_NEAR(expected_time, accumulated_delta,
                 TransportFeedback::kDeltaScaleFactor / 2);
   }
 }
 
 TEST(RtcpPacketTest, TransportFeedback_Limits) {
   // Sequence number wrap above 0x8000.
   std::unique_ptr<TransportFeedback> packet(new TransportFeedback());
-  packet->WithBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
-  EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
+  packet->SetBase(0, 0);
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000));
 
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
-  EXPECT_FALSE(packet->WithReceivedPacket(0x8000 + 1, 1000));
+  packet->SetBase(0, 0);
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
+  EXPECT_FALSE(packet->AddReceivedPacket(0x8000 + 1, 1000));
 
   // Packet status count max 0xFFFF.
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, 0);
-  EXPECT_TRUE(packet->WithReceivedPacket(0x0, 0));
-  EXPECT_TRUE(packet->WithReceivedPacket(0x8000, 1000));
-  EXPECT_TRUE(packet->WithReceivedPacket(0xFFFF, 2000));
-  EXPECT_FALSE(packet->WithReceivedPacket(0, 3000));
+  packet->SetBase(0, 0);
+  EXPECT_TRUE(packet->AddReceivedPacket(0x0, 0));
+  EXPECT_TRUE(packet->AddReceivedPacket(0x8000, 1000));
+  EXPECT_TRUE(packet->AddReceivedPacket(0xFFFF, 2000));
+  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->WithReceivedPacket(0, kMaxBaseTime);
+  packet->SetBase(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());
   EXPECT_EQ(kMaxBaseTime, packet->GetBaseTimeUs());
 
   // Base time above maximum value.
   int64_t kTooLargeBaseTime =
       kMaxBaseTime + (TransportFeedback::kDeltaScaleFactor * (1L << 8));
   packet.reset(new TransportFeedback());
-  packet->WithBase(0, kTooLargeBaseTime);
-  packet->WithReceivedPacket(0, kTooLargeBaseTime);
+  packet->SetBase(0, kTooLargeBaseTime);
+  packet->AddReceivedPacket(0, kTooLargeBaseTime);
   raw_packet = packet->Build();
   packet = TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
   EXPECT_NE(kTooLargeBaseTime, packet->GetBaseTimeUs());
 
   // TODO(sprang): Once we support max length lower than RTCP length limit,
   // add back test for max size in bytes.
 }
 
 TEST(RtcpPacketTest, TransportFeedback_Padding) {
   const size_t kExpectedSizeBytes =
       kHeaderSize + kStatusChunkSize + kSmallDeltaSize;
   const size_t kExpectedSizeWords = (kExpectedSizeBytes + 3) / 4;
 
   TransportFeedback feedback;
-  feedback.WithBase(0, 0);
-  EXPECT_TRUE(feedback.WithReceivedPacket(0, 0));
+  feedback.SetBase(0, 0);
+  EXPECT_TRUE(feedback.AddReceivedPacket(0, 0));
 
   rtc::Buffer packet = feedback.Build();
   EXPECT_EQ(kExpectedSizeWords * 4, packet.size());
   ASSERT_GT(kExpectedSizeWords * 4, kExpectedSizeBytes);
   for (size_t i = kExpectedSizeBytes; i < kExpectedSizeWords * 4; ++i)
     EXPECT_EQ(0u, packet.data()[i]);
 
   // Modify packet by adding 4 bytes of padding at the end. Not currently used
   // when we're sending, but need to be able to handle it when receiving.
 
@@ skipping 19 matching lines @@
 TEST(RtcpPacketTest, TransportFeedback_CorrectlySplitsVectorChunks) {
   const int kOneBitVectorCapacity = 14;
   const int64_t kLargeTimeDelta =
       TransportFeedback::kDeltaScaleFactor * (1 << 8);
 
   // Test that a number of small deltas followed by a large delta results in a
   // correct split into multiple chunks, as needed.
 
   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.WithReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
+      feedback.AddReceivedPacket(i, i * 1000);
+    feedback.AddReceivedPacket(deltas, deltas * 1000 + kLargeTimeDelta);
 
     rtc::Buffer serialized_packet = feedback.Build();
     std::unique_ptr<TransportFeedback> deserialized_packet =
         TransportFeedback::ParseFrom(serialized_packet.data(),
                                      serialized_packet.size());
     EXPECT_TRUE(deserialized_packet.get() != nullptr);
   }
 }
 
 }  // namespace
 }  // namespace webrtc