Delete VieRemb class, move functionality to PacketRouter.

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 34 matching lines @@
   int64_t timestamp_us = feedback_packet.GetBaseTimeUs();
   for (const auto& rtp_packet_received : feedback_packet.GetReceivedPackets()) {
     timestamp_us += rtp_packet_received.delta_us();
     timestamps.push_back(timestamp_us / 1000);
   }
   return timestamps;
 }
 
 class MockPacketRouter : public PacketRouter {
  public:
-  MOCK_METHOD1(SendFeedback, bool(rtcp::TransportFeedback* feedback_packet));
+  MOCK_METHOD1(SendTransportFeedback,
+               bool(rtcp::TransportFeedback* feedback_packet));
 };
 
 class RemoteEstimatorProxyTest : public ::testing::Test {
  public:
   RemoteEstimatorProxyTest() : clock_(0), proxy_(&clock_, &router_) {}
 
  protected:
   void IncomingPacket(uint16_t seq, int64_t time_ms) {
     RTPHeader header;
     header.extension.hasTransportSequenceNumber = true;
     header.extension.transportSequenceNumber = seq;
     header.ssrc = kMediaSsrc;
     proxy_.IncomingPacket(time_ms, kDefaultPacketSize, header);
   }
 
   void Process() {
     clock_.AdvanceTimeMilliseconds(
         RemoteEstimatorProxy::kDefaultSendIntervalMs);
     proxy_.Process();
   }
 
   SimulatedClock clock_;
   testing::StrictMock<MockPacketRouter> router_;
   RemoteEstimatorProxy proxy_;
 };
 
 TEST_F(RemoteEstimatorProxyTest, SendsSinglePacketFeedback) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq));
         EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs));
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, DuplicatedPackets) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq, kBaseTimeMs + 1000);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq));
         EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs));
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, FeedbackWithMissingStart) {
   // First feedback.
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1000);
-  EXPECT_CALL(router_, SendFeedback(_)).WillOnce(Return(true));
+  EXPECT_CALL(router_, SendTransportFeedback(_)).WillOnce(Return(true));
   Process();
 
   // Second feedback starts with a missing packet (DROP kBaseSeq + 2).
   IncomingPacket(kBaseSeq + 3, kBaseTimeMs + 3000);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq + 2, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet),
                     ElementsAre(kBaseSeq + 3));
         EXPECT_THAT(TimestampsMs(*feedback_packet),
                     ElementsAre(kBaseTimeMs + 3000));
         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(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet),
                     ElementsAre(kBaseSeq, kBaseSeq + 1, kBaseSeq + 2));
         EXPECT_THAT(TimestampsMs(*feedback_packet),
                     ElementsAre(kBaseTimeMs, kBaseTimeMs + kMaxSmallDeltaMs,
                                 kBaseTimeMs + (2 * kMaxSmallDeltaMs) + 1));
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, SendsFragmentedFeedback) {
   static constexpr int64_t kTooLargeDelta =
       rtcp::TransportFeedback::kDeltaScaleFactor * (1 << 16);
 
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + kTooLargeDelta);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet), ElementsAre(kBaseSeq));
         EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs));
         return true;
       }))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq + 1, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet),
                     ElementsAre(kBaseSeq + 1));
         EXPECT_THAT(TimestampsMs(*feedback_packet),
                     ElementsAre(kBaseTimeMs + kTooLargeDelta));
         return true;
       }));
 
   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(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs));
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, ResendsTimestampsOnReordering) {
   IncomingPacket(kBaseSeq, kBaseTimeMs);
   IncomingPacket(kBaseSeq + 2, kBaseTimeMs + 2);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet),
                     ElementsAre(kBaseSeq, kBaseSeq + 2));
         EXPECT_THAT(TimestampsMs(*feedback_packet),
                     ElementsAre(kBaseTimeMs, kBaseTimeMs + 2));
         return true;
       }));
 
   Process();
 
   IncomingPacket(kBaseSeq + 1, kBaseTimeMs + 1);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq + 1, feedback_packet->GetBaseSequence());
         EXPECT_EQ(kMediaSsrc, feedback_packet->media_ssrc());
 
         EXPECT_THAT(SequenceNumbers(*feedback_packet),
                     ElementsAre(kBaseSeq + 1, kBaseSeq + 2));
         EXPECT_THAT(TimestampsMs(*feedback_packet),
                     ElementsAre(kBaseTimeMs + 1, kBaseTimeMs + 2));
         return true;
       }));
 
   Process();
 }
 
 TEST_F(RemoteEstimatorProxyTest, RemovesTimestampsOutOfScope) {
   const int64_t kTimeoutTimeMs =
       kBaseTimeMs + RemoteEstimatorProxy::kBackWindowMs;
 
   IncomingPacket(kBaseSeq + 2, kBaseTimeMs);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(Invoke([](rtcp::TransportFeedback* feedback_packet) {
         EXPECT_EQ(kBaseSeq + 2, feedback_packet->GetBaseSequence());
 
         EXPECT_THAT(TimestampsMs(*feedback_packet), ElementsAre(kBaseTimeMs));
         return true;
       }));
 
   Process();
 
   IncomingPacket(kBaseSeq + 3, kTimeoutTimeMs);  // kBaseSeq + 2 times out here.
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(
           Invoke([kTimeoutTimeMs](rtcp::TransportFeedback* feedback_packet) {
             EXPECT_EQ(kBaseSeq + 3, feedback_packet->GetBaseSequence());
 
             EXPECT_THAT(TimestampsMs(*feedback_packet),
                         ElementsAre(kTimeoutTimeMs));
             return true;
           }));
 
   Process();
 
   // New group, with sequence starting below the first so that they may be
   // retransmitted.
   IncomingPacket(kBaseSeq, kBaseTimeMs - 1);
   IncomingPacket(kBaseSeq + 1, kTimeoutTimeMs - 1);
 
-  EXPECT_CALL(router_, SendFeedback(_))
+  EXPECT_CALL(router_, SendTransportFeedback(_))
       .WillOnce(
           Invoke([kTimeoutTimeMs](rtcp::TransportFeedback* feedback_packet) {
             EXPECT_EQ(kBaseSeq, feedback_packet->GetBaseSequence());
 
             EXPECT_THAT(SequenceNumbers(*feedback_packet),
                         ElementsAre(kBaseSeq, kBaseSeq + 1, kBaseSeq + 3));
             EXPECT_THAT(TimestampsMs(*feedback_packet),
                         ElementsAre(kBaseTimeMs - 1, kTimeoutTimeMs - 1,
                                     kTimeoutTimeMs));
             return true;
@@ skipping 38 matching lines @@
 
 TEST_F(RemoteEstimatorProxyTest, TwccReportsUse5PercentOfAvailableBandwidth) {
   Process();
   proxy_.OnBitrateChanged(80000);
   // 80kbps * 0.05 = TwccReportSize(68B * 8b/B) * 1000ms / SendInterval(136ms)
   EXPECT_EQ(136, proxy_.TimeUntilNextProcess());
 }
 
 }  // namespace
 }  // namespace webrtc