Delete VieRemb class, move functionality to PacketRouter.

webrtc/modules/congestion_controller/congestion_controller_unittest.cc

 /*
  *  Copyright (c) 2016 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 10 matching lines @@
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 using testing::_;
 using testing::AtLeast;
 using testing::NiceMock;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 
+namespace webrtc {
+
 namespace {
 const webrtc::PacedPacketInfo kPacingInfo0(0, 5, 2000);
 const webrtc::PacedPacketInfo kPacingInfo1(1, 8, 4000);
 
 // Helper to convert some time format to resolution used in absolute send time
 // header extension, rounded upwards. |t| is the time to convert, in some
 // resolution. |denom| is the value to divide |t| by to get whole seconds,
 // e.g. |denom| = 1000 if |t| is in milliseconds.
 uint32_t AbsSendTime(int64_t t, int64_t denom) {
   return (((t << 18) + (denom >> 1)) / denom) & 0x00fffffful;
 }
 
+class MockPacketRouter : public PacketRouter {
+ public:
+  MOCK_METHOD2(OnReceiveBitrateChanged,
+               void(const std::vector<uint32_t>& ssrcs,
+                    uint32_t bitrate));
+};
+
+const uint32_t kInitialBitrateBps = 60000;
+
 }  // namespace
 
-namespace webrtc {
 namespace test {
 
 class CongestionControllerTest : public ::testing::Test {
  protected:
   CongestionControllerTest() : clock_(123456), target_bitrate_observer_(this) {}
   ~CongestionControllerTest() override {}
 
   void SetUp() override {
     pacer_ = new NiceMock<MockPacedSender>();
     std::unique_ptr<PacedSender> pacer(pacer_);  // Passes ownership.
@@ skipping 80 matching lines @@
 
   SimulatedClock clock_;
   StrictMock<MockCongestionObserver> observer_;
   TargetBitrateObserver target_bitrate_observer_;
   NiceMock<MockPacedSender>* pacer_;
   NiceMock<MockRemoteBitrateObserver> remote_bitrate_observer_;
   NiceMock<MockRtcEventLog> event_log_;
   std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
   PacketRouter packet_router_;
   std::unique_ptr<CongestionController> controller_;
-  const uint32_t kInitialBitrateBps = 60000;
 
   rtc::Optional<uint32_t> target_bitrate_bps_;
 };
 
 TEST_F(CongestionControllerTest, OnNetworkChanged) {
   // Test no change.
   clock_.AdvanceTimeMilliseconds(25);
   controller_->Process();
 
   EXPECT_CALL(observer_, OnNetworkChanged(kInitialBitrateBps * 2, _, _, _));
@@ skipping 171 matching lines @@
   clock_.AdvanceTimeMilliseconds(25);
   controller_->Process();
 
   EXPECT_CALL(observer_, OnNetworkChanged(_, _, _, testing::Ne(0)));
   EXPECT_CALL(*pacer_, SetEstimatedBitrate(_));
   bandwidth_observer_->OnReceivedEstimatedBitrate(kInitialBitrateBps * 2);
   clock_.AdvanceTimeMilliseconds(25);
   controller_->Process();
 }
 
-TEST_F(CongestionControllerTest, OnReceivedPacketWithAbsSendTime) {
-  NiceMock<MockCongestionObserver> observer;
-  StrictMock<MockRemoteBitrateObserver> remote_bitrate_observer;
-  std::unique_ptr<PacedSender> pacer(new NiceMock<MockPacedSender>());
-  controller_.reset(
-      new CongestionController(&clock_, &observer, &remote_bitrate_observer,
-                               &event_log_, &packet_router_, std::move(pacer)));
+TEST(ReceiveSideCongestionControllerTest, OnReceivedPacketWithAbsSendTime) {
+  StrictMock<MockPacketRouter> packet_router;
+  SimulatedClock clock_(123456);
+
+  ReceiveSideCongestionController controller(&clock_, &packet_router);
 
   size_t payload_size = 1000;
   RTPHeader header;
   header.ssrc = 0x11eb21c;
   header.extension.hasAbsoluteSendTime = true;
 
   std::vector<unsigned int> ssrcs;
-  EXPECT_CALL(remote_bitrate_observer, OnReceiveBitrateChanged(_, _))
+  EXPECT_CALL(packet_router, OnReceiveBitrateChanged(_, _))
       .WillRepeatedly(SaveArg<0>(&ssrcs));
 
   for (int i = 0; i < 10; ++i) {
     clock_.AdvanceTimeMilliseconds((1000 * payload_size) / kInitialBitrateBps);
     int64_t now_ms = clock_.TimeInMilliseconds();
     header.extension.absoluteSendTime = AbsSendTime(now_ms, 1000);
-    controller_->OnReceivedPacket(now_ms, payload_size, header);
+    controller.OnReceivedPacket(now_ms, payload_size, header);
   }
 
   ASSERT_EQ(1u, ssrcs.size());
   EXPECT_EQ(header.ssrc, ssrcs[0]);
 }
 
 TEST_F(CongestionControllerTest, ProbeOnRouteChange) {
   testing::Mock::VerifyAndClearExpectations(pacer_);
   EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 6));
   EXPECT_CALL(*pacer_, CreateProbeCluster(kInitialBitrateBps * 12));
@@ skipping 110 matching lines @@
   ASSERT_TRUE(target_bitrate_bps_);
 
   // Repeat, but this time with a building delay, and make sure that the
   // estimation is adjusted downwards.
   uint32_t bitrate_before_delay = *target_bitrate_bps_;
   PacketTransmissionAndFeedbackBlock(&seq_num, kRunTimeMs, 50);
   EXPECT_LT(*target_bitrate_bps_, bitrate_before_delay);
 }
 }  // namespace test
 }  // namespace webrtc