Change TWCC send interval to reduce overhead on low BW situations.

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.
  */
 
+#include <memory>
+#include <utility>
+
+#include "webrtc/test/gmock.h"
+#include "webrtc/test/gtest.h"
+
+#include "webrtc/base/test/mock_ratetracker.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/system_wrappers/include/clock.h"
-#include "webrtc/test/gmock.h"
-#include "webrtc/test/gtest.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Invoke;
 using ::testing::Return;
 
 namespace webrtc {
 
 class MockPacketRouter : public PacketRouter {
  public:
   MOCK_METHOD1(SendFeedback, bool(rtcp::TransportFeedback* packet));
 };
 
 class RemoteEstimatorProxyTest : public ::testing::Test {
  public:
-  RemoteEstimatorProxyTest() : clock_(0), proxy_(&clock_, &router_) {}
+  RemoteEstimatorProxyTest()
+      : clock_(0),
+        received_bitrate_tracker_bps_(
+            new testing::NiceMock<rtc::MockRateTracker>()),
+        mock_received_bitrate_tracker_bps_(received_bitrate_tracker_bps_.get()),
+        proxy_(&clock_, &router_, std::move(received_bitrate_tracker_bps_)) {}
 
  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::kDefaultProcessIntervalMs);
+        RemoteEstimatorProxy::kHighBitrateProcessIntervalMs);
     proxy_.Process();
   }
 
   SimulatedClock clock_;
   testing::StrictMock<MockPacketRouter> router_;
+  std::unique_ptr<testing::NiceMock<rtc::MockRateTracker>>
+      received_bitrate_tracker_bps_;
+  testing::NiceMock<rtc::MockRateTracker>* mock_received_bitrate_tracker_bps_;

[stefan-webrtc, 2016/10/17 18:55:21]

Instead of using a mock I'd suggest that we call IncomingPacket() with the right
packet size and interval to simulate the bitrate we want to test with. That more
fully tests the functionality, and avoids having to create a mock class.

+
   RemoteEstimatorProxy proxy_;
 
   const size_t kDefaultPacketSize = 100;
   const uint32_t kMediaSsrc = 456;
   const uint16_t kBaseSeq = 10;
   const int64_t kBaseTimeMs = 123;
   const int64_t kMaxSmallDeltaMs =
       (rtcp::TransportFeedback::kDeltaScaleFactor * 0xFF) / 1000;
 };
 
@@ skipping 282 matching lines @@
         EXPECT_EQ(kBaseTimeMs - 1,
                   (packet->GetBaseTimeUs() + delta_vec[0]) / 1000);
         EXPECT_EQ(kTimeoutTimeMs - kBaseTimeMs, delta_vec[1] / 1000);
         EXPECT_EQ(1, delta_vec[2] / 1000);
         return true;
       }));
 
   Process();
 }
 
+TEST_F(RemoteEstimatorProxyTest, AddPaketToIncomingBitrateTracker) {
+  EXPECT_CALL(*mock_received_bitrate_tracker_bps_,
+              AddSamples(kDefaultPacketSize * 8));
+  IncomingPacket(kBaseSeq, kBaseTimeMs);
+}
+
+TEST_F(RemoteEstimatorProxyTest,
+       TimeUntilNextProcessIsHightOnLowIncomingBitrate) {
+  EXPECT_CALL(*mock_received_bitrate_tracker_bps_, TotalSampleCount())
+      .WillRepeatedly(
+          Return(RemoteEstimatorProxy::kMinPacketCountRecievedBitrate + 1));
+  EXPECT_CALL(*mock_received_bitrate_tracker_bps_, ComputeRate())
+      .WillRepeatedly(
+          Return(RemoteEstimatorProxy::kSwitchToLowBitrateProcessIntervalBps));
+  Process();
+  EXPECT_EQ(RemoteEstimatorProxy::kLowBitrateProcessIntervalMs,
+            proxy_.TimeUntilNextProcess());
+}
+
+TEST_F(RemoteEstimatorProxyTest,
+       TimeUntilNextProcessIsLowOnHightIncomingBitrate) {
+  EXPECT_CALL(*mock_received_bitrate_tracker_bps_, TotalSampleCount())
+      .WillRepeatedly(
+          Return(RemoteEstimatorProxy::kMinPacketCountRecievedBitrate + 1));
+  EXPECT_CALL(*mock_received_bitrate_tracker_bps_, ComputeRate())
+      .WillRepeatedly(
+          Return(RemoteEstimatorProxy::kSwitchToHighBitrateProcessIntervalBps));
+  Process();
+  EXPECT_EQ(RemoteEstimatorProxy::kHighBitrateProcessIntervalMs,
+            proxy_.TimeUntilNextProcess());
+}
+
 }  // namespace webrtc