Migrates probing end-to-end test to scenario test.

The previous tests ran in real-time making them flaky, so they were
disabled on a number of platforms.
This CL ports the tests 1:1 (sort of) to use the scenario test
framework which runs with simulated time and much less risk of
flakiness.

Bug: webrtc:10155
Change-Id: I6281f57d73883c8aaa91964e9cfa58d9b47779fa
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/186941
Commit-Queue: Erik Språng <[email protected]>
Reviewed-by: Sebastian Jansson <[email protected]>
Cr-Commit-Position: refs/heads/master@{#32333}

Author: Erik Språng

test/scenario/BUILD.gn

@@ -168,6 +168,7 @@ if (rtc_include_tests) {
     testonly = true
     sources = [
       "performance_stats_unittest.cc",
+      "probing_test.cc",
       "scenario_unittest.cc",
       "stats_collection_unittest.cc",
       "video_stream_unittest.cc",

test/scenario/call_client.cc

@@ -269,6 +269,13 @@ DataRate CallClient::padding_rate() const {
   return network_controller_factory_.GetUpdate().pacer_config->pad_rate();
 }
 
+void CallClient::UpdateBitrateConstraints(
+    const BitrateConstraints& constraints) {
+  SendTask([this, &constraints]() {
+    call_->GetTransportControllerSend()->SetSdpBitrateParameters(constraints);
+  });
+}
+
 void CallClient::OnPacketReceived(EmulatedIpPacket packet) {
   MediaType media_type = MediaType::ANY;
   if (!RtpHeaderParser::IsRtcp(packet.cdata(), packet.data.size())) {

test/scenario/call_client.h

@@ -109,6 +109,7 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   DataRate target_rate() const;
   DataRate stable_target_rate() const;
   DataRate padding_rate() const;
+  void UpdateBitrateConstraints(const BitrateConstraints& constraints);
 
   void OnPacketReceived(EmulatedIpPacket packet) override;
   std::unique_ptr<RtcEventLogOutput> GetLogWriter(std::string name);

test/scenario/probing_test.cc

@@ -0,0 +1,133 @@
+/*
+ *  Copyright 2020 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 "test/gtest.h"
+#include "test/scenario/scenario.h"
+
+namespace webrtc {
+namespace test {
+
+TEST(ProbingTest, InitialProbingRampsUpTargetRateWhenNetworkIsGood) {
+  Scenario s;
+  NetworkSimulationConfig good_network;
+  good_network.bandwidth = DataRate::KilobitsPerSec(2000);
+
+  VideoStreamConfig video_config;
+  video_config.encoder.codec =
+      VideoStreamConfig::Encoder::Codec::kVideoCodecVP8;
+  CallClientConfig send_config;
+  auto* caller = s.CreateClient("caller", send_config);
+  auto* callee = s.CreateClient("callee", CallClientConfig());
+  auto route =
+      s.CreateRoutes(caller, {s.CreateSimulationNode(good_network)}, callee,
+                     {s.CreateSimulationNode(NetworkSimulationConfig())});
+  s.CreateVideoStream(route->forward(), video_config);
+
+  s.RunFor(TimeDelta::Seconds(1));
+  EXPECT_GE(DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps),
+            3 * send_config.transport.rates.start_rate);
+}
+
+TEST(ProbingTest, MidCallProbingRampupTriggeredByUpdatedBitrateConstraints) {
+  Scenario s;
+
+  const DataRate kStartRate = DataRate::KilobitsPerSec(300);
+  const DataRate kConstrainedRate = DataRate::KilobitsPerSec(100);
+  const DataRate kHighRate = DataRate::KilobitsPerSec(2500);
+
+  VideoStreamConfig video_config;
+  video_config.encoder.codec =
+      VideoStreamConfig::Encoder::Codec::kVideoCodecVP8;
+  CallClientConfig send_call_config;
+  send_call_config.transport.rates.start_rate = kStartRate;
+  send_call_config.transport.rates.max_rate = kHighRate * 2;
+  auto* caller = s.CreateClient("caller", send_call_config);
+  auto* callee = s.CreateClient("callee", CallClientConfig());
+  auto route = s.CreateRoutes(
+      caller, {s.CreateSimulationNode(NetworkSimulationConfig())}, callee,
+      {s.CreateSimulationNode(NetworkSimulationConfig())});
+  s.CreateVideoStream(route->forward(), video_config);
+
+  // Wait until initial probing rampup is done and then set a low max bitrate.
+  s.RunFor(TimeDelta::Seconds(1));
+  EXPECT_GE(DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps),
+            5 * send_call_config.transport.rates.start_rate);
+  BitrateConstraints bitrate_config;
+  bitrate_config.max_bitrate_bps = kConstrainedRate.bps();
+  caller->UpdateBitrateConstraints(bitrate_config);
+
+  // Wait until the low send bitrate has taken effect, and then set a much
+  // higher max bitrate.
+  s.RunFor(TimeDelta::Seconds(2));
+  EXPECT_LT(DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps),
+            kConstrainedRate * 1.1);
+  bitrate_config.max_bitrate_bps = 2 * kHighRate.bps();
+  caller->UpdateBitrateConstraints(bitrate_config);
+
+  // Check that the max send bitrate is reached quicker than would be possible
+  // with simple AIMD rate control.
+  s.RunFor(TimeDelta::Seconds(1));
+  EXPECT_GE(DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps),
+            kHighRate);
+}
+
+TEST(ProbingTest, ProbesRampsUpWhenVideoEncoderConfigChanges) {
+  Scenario s;
+  const DataRate kStartRate = DataRate::KilobitsPerSec(50);
+  const DataRate kHdRate = DataRate::KilobitsPerSec(3250);
+
+  // Set up 3-layer simulcast.
+  VideoStreamConfig video_config;
+  video_config.encoder.codec =
+      VideoStreamConfig::Encoder::Codec::kVideoCodecVP8;
+  video_config.encoder.layers.spatial = 3;
+  video_config.source.generator.width = 1280;
+  video_config.source.generator.height = 720;
+
+  CallClientConfig send_call_config;
+  send_call_config.transport.rates.start_rate = kStartRate;
+  send_call_config.transport.rates.max_rate = kHdRate * 2;
+  auto* caller = s.CreateClient("caller", send_call_config);
+  auto* callee = s.CreateClient("callee", CallClientConfig());
+  auto send_net =
+      s.CreateMutableSimulationNode([&](NetworkSimulationConfig* c) {
+        c->bandwidth = DataRate::KilobitsPerSec(200);
+      });
+  auto route =
+      s.CreateRoutes(caller, {send_net->node()}, callee,
+                     {s.CreateSimulationNode(NetworkSimulationConfig())});
+  auto* video_stream = s.CreateVideoStream(route->forward(), video_config);
+
+  // Only QVGA enabled initially. Run until initial probing is done and BWE
+  // has settled.
+  video_stream->send()->UpdateActiveLayers({true, false, false});
+  s.RunFor(TimeDelta::Seconds(2));
+
+  // Remove network constraints and run for a while more, BWE should be much
+  // less than required HD rate.
+  send_net->UpdateConfig([&](NetworkSimulationConfig* c) {
+    c->bandwidth = DataRate::PlusInfinity();
+  });
+  s.RunFor(TimeDelta::Seconds(2));
+
+  DataRate bandwidth =
+      DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps);
+  EXPECT_LT(bandwidth, kHdRate / 4);
+
+  // Enable all layers, triggering a probe.
+  video_stream->send()->UpdateActiveLayers({true, true, true});
+
+  // Run for a short while and verify BWE has ramped up fast.
+  s.RunFor(TimeDelta::Seconds(2));
+  EXPECT_GT(DataRate::BitsPerSec(caller->GetStats().send_bandwidth_bps),
+            kHdRate);
+}
+
+}  // namespace test
+}  // namespace webrtc

test/scenario/video_stream.cc

@@ -463,7 +463,8 @@ void SendVideoStream::UpdateConfig(
       }
     }
     // TODO(srte): Add more conditions that should cause reconfiguration.
-    if (prior_config.encoder.max_framerate != config_.encoder.max_framerate) {
+    if (prior_config.encoder.max_framerate != config_.encoder.max_framerate ||
+        prior_config.encoder.max_data_rate != config_.encoder.max_data_rate) {
       VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
       send_stream_->ReconfigureVideoEncoder(std::move(encoder_config));
     }
@@ -479,14 +480,12 @@ void SendVideoStream::UpdateActiveLayers(std::vector<bool> active_layers) {
     if (config_.encoder.codec ==
         VideoStreamConfig::Encoder::Codec::kVideoCodecVP8) {
       send_stream_->UpdateActiveSimulcastLayers(active_layers);
-    } else {
-      VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
-      RTC_CHECK_EQ(encoder_config.simulcast_layers.size(),
-                   active_layers.size());
-      for (size_t i = 0; i < encoder_config.simulcast_layers.size(); ++i)
-        encoder_config.simulcast_layers[i].active = active_layers[i];
-      send_stream_->ReconfigureVideoEncoder(std::move(encoder_config));
     }
+    VideoEncoderConfig encoder_config = CreateVideoEncoderConfig(config_);
+    RTC_CHECK_EQ(encoder_config.simulcast_layers.size(), active_layers.size());
+    for (size_t i = 0; i < encoder_config.simulcast_layers.size(); ++i)
+      encoder_config.simulcast_layers[i].active = active_layers[i];
+    send_stream_->ReconfigureVideoEncoder(std::move(encoder_config));
   });
 }
 

video/BUILD.gn

@@ -540,7 +540,6 @@ if (rtc_include_tests) {
       "end_to_end_tests/multi_stream_tester.h",
       "end_to_end_tests/multi_stream_tests.cc",
       "end_to_end_tests/network_state_tests.cc",
-      "end_to_end_tests/probing_tests.cc",
       "end_to_end_tests/retransmission_tests.cc",
       "end_to_end_tests/rtp_rtcp_tests.cc",
       "end_to_end_tests/ssrc_tests.cc",