Reland "Moved congestion controller to goog_cc folder."

This is a reland of e6cefdf9c572cdce55ff0497ad6e516c76132ee8. Original change's description: > Moved congestion controller to goog_cc folder. > > Bug: webrtc:8415 > Change-Id: I2070da0cacf1dbfc4b6a89285af3e68fd03497ab > Reviewed-on: https://webrtc-review.googlesource.com/43841 > Commit-Queue: Sebastian Jansson <srte@webrtc.org> > Reviewed-by: Björn Terelius <terelius@webrtc.org> > Reviewed-by: Stefan Holmer <stefan@webrtc.org> > Cr-Commit-Position: refs/heads/master@{#21928} Bug: webrtc:8415 Change-Id: Ib5cf8641466655d64ac80f720561817f4cab49a9 Reviewed-on: https://webrtc-review.googlesource.com/53062 Commit-Queue: Sebastian Jansson <srte@webrtc.org> Reviewed-by: Björn Terelius <terelius@webrtc.org> Cr-Commit-Position: refs/heads/master@{#22244}
2018-02-28 16:48:00 +01:00
parent cdff887238
commit fc7ec8e9f8
34 changed files with 239 additions and 219 deletions
--- a/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
+++ b/modules/congestion_controller/goog_cc/probe_controller_unittest.cc
@ -0,0 +1,292 @@
+/*
+ *  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.
+ */
+#include <memory>
+
+#include "modules/congestion_controller/goog_cc/probe_controller.h"
+#include "modules/congestion_controller/network_control/include/network_types.h"
+#include "rtc_base/logging.h"
+#include "system_wrappers/include/clock.h"
+#include "test/gmock.h"
+#include "test/gtest.h"
+
+using testing::_;
+using testing::AtLeast;
+using testing::Field;
+using testing::Matcher;
+using testing::NiceMock;
+using testing::Return;
+
+namespace webrtc {
+namespace webrtc_cc {
+namespace test {
+
+namespace {
+
+constexpr int kMinBitrateBps = 100;
+constexpr int kStartBitrateBps = 300;
+constexpr int kMaxBitrateBps = 10000;
+
+constexpr int kExponentialProbingTimeoutMs = 5000;
+
+constexpr int kAlrProbeInterval = 5000;
+constexpr int kAlrEndedTimeoutMs = 3000;
+constexpr int kBitrateDropTimeoutMs = 5000;
+
+inline Matcher<ProbeClusterConfig> DataRateEqBps(int bps) {
+  return Field(&ProbeClusterConfig::target_data_rate, DataRate::bps(bps));
+}
+class MockNetworkControllerObserver : public NetworkControllerObserver {
+ public:
+  MOCK_METHOD1(OnCongestionWindow, void(CongestionWindow));
+  MOCK_METHOD1(OnPacerConfig, void(PacerConfig));
+  MOCK_METHOD1(OnProbeClusterConfig, void(ProbeClusterConfig));
+  MOCK_METHOD1(OnTargetTransferRate, void(TargetTransferRate));
+};
+}  // namespace
+
+class ProbeControllerTest : public ::testing::Test {
+ protected:
+  ProbeControllerTest() : clock_(100000000L) {
+    probe_controller_.reset(new ProbeController(&cluster_handler_));
+  }
+  ~ProbeControllerTest() override {}
+
+  void SetNetworkAvailable(bool available) {
+    NetworkAvailability msg;
+    msg.at_time = Timestamp::ms(NowMs());
+    msg.network_available = available;
+    probe_controller_->OnNetworkAvailability(msg);
+  }
+
+  int64_t NowMs() { return clock_.TimeInMilliseconds(); }
+
+  SimulatedClock clock_;
+  NiceMock<MockNetworkControllerObserver> cluster_handler_;
+  std::unique_ptr<ProbeController> probe_controller_;
+};
+
+TEST_F(ProbeControllerTest, InitiatesProbingAtStart) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(AtLeast(2));
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+}
+
+TEST_F(ProbeControllerTest, ProbeOnlyWhenNetworkIsUp) {
+  SetNetworkAvailable(false);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(AtLeast(2));
+  SetNetworkAvailable(true);
+}
+
+TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncrease) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(AtLeast(2));
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  // Long enough to time out exponential probing.
+  clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
+  probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
+  probe_controller_->Process(NowMs());
+
+  EXPECT_CALL(cluster_handler_,
+              OnProbeClusterConfig(DataRateEqBps(kMaxBitrateBps + 100)));
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps + 100, NowMs());
+}
+
+TEST_F(ProbeControllerTest, InitiatesProbingOnMaxBitrateIncreaseAtMaxBitrate) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(AtLeast(2));
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  // Long enough to time out exponential probing.
+  clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
+  probe_controller_->SetEstimatedBitrate(kStartBitrateBps, NowMs());
+  probe_controller_->Process(NowMs());
+
+  probe_controller_->SetEstimatedBitrate(kMaxBitrateBps, NowMs());
+  EXPECT_CALL(cluster_handler_,
+              OnProbeClusterConfig(DataRateEqBps(kMaxBitrateBps + 100)));
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps + 100, NowMs());
+}
+
+TEST_F(ProbeControllerTest, TestExponentialProbing) {
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+
+  // Repeated probe should only be sent when estimated bitrate climbs above
+  // 0.7 * 6 * kStartBitrateBps = 1260.
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetEstimatedBitrate(1000, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(DataRateEqBps(2 * 1800)));
+  probe_controller_->SetEstimatedBitrate(1800, NowMs());
+}
+
+TEST_F(ProbeControllerTest, TestExponentialProbingTimeout) {
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+
+  // Advance far enough to cause a time out in waiting for probing result.
+  clock_.AdvanceTimeMilliseconds(kExponentialProbingTimeoutMs);
+  probe_controller_->Process(NowMs());
+
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetEstimatedBitrate(1800, NowMs());
+}
+
+TEST_F(ProbeControllerTest, RequestProbeInAlr) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(DataRateEqBps(0.85 * 500)))
+      .Times(1);
+  probe_controller_->SetAlrStartTimeMs(clock_.TimeInMilliseconds());
+  clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(250, NowMs());
+  probe_controller_->RequestProbe(NowMs());
+}
+
+TEST_F(ProbeControllerTest, RequestProbeWhenAlrEndedRecently) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(DataRateEqBps(0.85 * 500)))
+      .Times(1);
+  probe_controller_->SetAlrStartTimeMs(rtc::nullopt);
+  clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(250, NowMs());
+  probe_controller_->SetAlrEndedTimeMs(clock_.TimeInMilliseconds());
+  clock_.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs - 1);
+  probe_controller_->RequestProbe(NowMs());
+}
+
+TEST_F(ProbeControllerTest, RequestProbeWhenAlrNotEndedRecently) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetAlrStartTimeMs(rtc::nullopt);
+  clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(250, NowMs());
+  probe_controller_->SetAlrEndedTimeMs(clock_.TimeInMilliseconds());
+  clock_.AdvanceTimeMilliseconds(kAlrEndedTimeoutMs + 1);
+  probe_controller_->RequestProbe(NowMs());
+}
+
+TEST_F(ProbeControllerTest, RequestProbeWhenBweDropNotRecent) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetAlrStartTimeMs(clock_.TimeInMilliseconds());
+  clock_.AdvanceTimeMilliseconds(kAlrProbeInterval + 1);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(250, NowMs());
+  clock_.AdvanceTimeMilliseconds(kBitrateDropTimeoutMs + 1);
+  probe_controller_->RequestProbe(NowMs());
+}
+
+TEST_F(ProbeControllerTest, PeriodicProbing) {
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->EnablePeriodicAlrProbing(true);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+
+  int64_t start_time = clock_.TimeInMilliseconds();
+
+  // Expect the controller to send a new probe after 5s has passed.
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(DataRateEqBps(1000)))
+      .Times(1);
+  probe_controller_->SetAlrStartTimeMs(start_time);
+  clock_.AdvanceTimeMilliseconds(5000);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+
+  // The following probe should be sent at 10s into ALR.
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetAlrStartTimeMs(start_time);
+  clock_.AdvanceTimeMilliseconds(4000);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(1);
+  probe_controller_->SetAlrStartTimeMs(start_time);
+  clock_.AdvanceTimeMilliseconds(1000);
+  probe_controller_->Process(NowMs());
+  probe_controller_->SetEstimatedBitrate(500, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+}
+
+TEST_F(ProbeControllerTest, PeriodicProbingAfterReset) {
+  NiceMock<MockNetworkControllerObserver> local_handler;
+  probe_controller_.reset(new ProbeController(&local_handler));
+  int64_t alr_start_time = clock_.TimeInMilliseconds();
+
+  probe_controller_->SetAlrStartTimeMs(alr_start_time);
+  EXPECT_CALL(local_handler, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->EnablePeriodicAlrProbing(true);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+  probe_controller_->Reset(NowMs());
+
+  clock_.AdvanceTimeMilliseconds(10000);
+  probe_controller_->Process(NowMs());
+
+  EXPECT_CALL(local_handler, OnProbeClusterConfig(_)).Times(2);
+  probe_controller_->SetBitrates(kMinBitrateBps, kStartBitrateBps,
+                                 kMaxBitrateBps, NowMs());
+
+  // Make sure we use |kStartBitrateBps| as the estimated bitrate
+  // until SetEstimatedBitrate is called with an updated estimate.
+  clock_.AdvanceTimeMilliseconds(10000);
+  EXPECT_CALL(local_handler,
+              OnProbeClusterConfig(DataRateEqBps(kStartBitrateBps * 2)));
+  probe_controller_->Process(NowMs());
+}
+
+TEST_F(ProbeControllerTest, TestExponentialProbingOverflow) {
+  const int64_t kMbpsMultiplier = 1000000;
+  probe_controller_->SetBitrates(kMinBitrateBps, 10 * kMbpsMultiplier,
+                                 100 * kMbpsMultiplier, NowMs());
+
+  // Verify that probe bitrate is capped at the specified max bitrate.
+  EXPECT_CALL(cluster_handler_,
+              OnProbeClusterConfig(DataRateEqBps(100 * kMbpsMultiplier)));
+  probe_controller_->SetEstimatedBitrate(60 * kMbpsMultiplier, NowMs());
+  testing::Mock::VerifyAndClearExpectations(&cluster_handler_);
+
+  // Verify that repeated probes aren't sent.
+  EXPECT_CALL(cluster_handler_, OnProbeClusterConfig(_)).Times(0);
+  probe_controller_->SetEstimatedBitrate(100 * kMbpsMultiplier, NowMs());
+}
+
+}  // namespace test
+}  // namespace webrtc_cc
+}  // namespace webrtc