Reland of Unify rtcp packet setters

webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy_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 49 matching lines @@
 };
 
 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(1u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[0]);
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
         EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq, kBaseTimeMs + 1000);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(1u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[0]);
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
         EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
@@ skipping 10 matching lines @@
   Process();
 
   // Second feedback starts with a missing packet (DROP kBaseSeq + 2).
   IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(2u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kNotReceived,
                   status_vec[0]);
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[1]);
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
         EXPECT_EQ(kBaseTimeMs + 3000,
                   (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, SendsFeedbackWithVaryingDeltas) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kMaxSmallDeltaMs);
   IncomingPacket(kBaseSeq + 2, kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(3u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[0]);
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[1]);
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedLargeDelta,
                   status_vec[2]);
@@ skipping 15 matching lines @@
 
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta);
 
   InSequence s;
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(1u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[0]);
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
         EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
       }))
       .RetiresOnSaturation();
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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();
         EXPECT_EQ(1u, status_vec.size());
         EXPECT_EQ(rtcp::TransportFeedback::StatusSymbol::kReceivedSmallDelta,
                   status_vec[0]);
         std::vector<int64_t> delta_vec = packet->GetReceiveDeltasUs();
         EXPECT_EQ(1u, delta_vec.size());
         EXPECT_EQ(kBaseTimeMs + kTooLargeDelta,
                   (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
       }))
       .RetiresOnSaturation();
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, GracefullyHandlesReorderingAndWrap) {
   const int64_t kDeltaMs = 1000;
   const uint16_t kLargeSeq = 62762;
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kLargeSeq, kBaseTimeMs + kDeltaMs);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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());
         EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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());
         EXPECT_EQ(kBaseTimeMs, (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         EXPECT_EQ(2, delta_vec[1] / 1000);
         return true;
       }));
 
   Process();
 
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1);
 
   EXPECT_CALL(router_, SendFeedback(_))
       .Times(1)
       .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());
         EXPECT_EQ(kBaseTimeMs + 1,
                   (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         EXPECT_EQ(1, delta_vec[1] / 1000);
         return true;
       }));
 
   Process();
@@ skipping 57 matching lines @@
                   (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         EXPECT_EQ(kTimeoutTimeMs - kBaseTimeMs, delta_vec[1] / 1000);
         EXPECT_EQ(1, delta_vec[2] / 1000);
         return true;
       }));
 
   Process();
 }
 
 }  // namespace webrtc