Cleanup of network controller handling in Scenario tests.

Removing functionality to choose congestion controller implementation,
using injection instead. Also cleaning up some related functionality
that's no longer needed, such as the injection of event logs into the
factory.

Bug: webrtc:9883
Change-Id: Ia528005625430ae31a15bc88881e2d4ac6ad1d42
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/133890
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27768}

api/transport/goog_cc_factory.h

@@ -43,9 +43,10 @@ class GoogCcNetworkControllerFactory
   GoogCcFactoryConfig factory_config_;
 };
 
+// Deprecated, use GoogCcFactoryConfig to enable feedback only mode instead.
 // Factory to create packet feedback only GoogCC, this can be used for
 // connections providing packet receive time feedback but no other reports.
-class GoogCcFeedbackNetworkControllerFactory
+class RTC_DEPRECATED GoogCcFeedbackNetworkControllerFactory
     : public GoogCcNetworkControllerFactory {
  public:
   explicit GoogCcFeedbackNetworkControllerFactory(RtcEventLog* event_log);

modules/congestion_controller/bbr/bbr_network_controller_unittest.cc

@@ -119,8 +119,6 @@ TEST_F(BbrNetworkControllerTest, UpdatesTargetSendRate) {
   BbrNetworkControllerFactory factory;
   Scenario s("bbr_unit/updates_rate", false);
   CallClientConfig config;
-  config.transport.cc =
-      TransportControllerConfig::CongestionController::kInjected;
   config.transport.cc_factory = &factory;
   config.transport.rates.min_rate = DataRate::kbps(10);
   config.transport.rates.max_rate = DataRate::kbps(1500);

modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc

@@ -49,16 +49,21 @@ int CountBandwidthDips(std::queue<DataRate> bandwidth_history,
   }
   return dips;
 }
+GoogCcNetworkControllerFactory CreateFeedbackOnlyFactory() {
+  GoogCcFactoryConfig config;
+  config.feedback_only = true;
+  return GoogCcNetworkControllerFactory(std::move(config));
+}
 
 const uint32_t kInitialBitrateKbps = 60;
 const DataRate kInitialBitrate = DataRate::kbps(kInitialBitrateKbps);
 const float kDefaultPacingRate = 2.5f;
 
 void UpdatesTargetRateBasedOnLinkCapacity(std::string test_name = "") {
+  auto factory = CreateFeedbackOnlyFactory();
   Scenario s("googcc_unit/target_capacity" + test_name, false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   config.transport.rates.min_rate = DataRate::kbps(10);
   config.transport.rates.max_rate = DataRate::kbps(1500);
   config.transport.rates.start_rate = DataRate::kbps(300);
@@ -235,6 +240,7 @@ TEST_F(GoogCcNetworkControllerTest, ReactsToChangedNetworkConditions) {
 
 // Test congestion window pushback on network delay happens.
 TEST_F(GoogCcNetworkControllerTest, CongestionWindowPushbackOnNetworkDelay) {
+  auto factory = CreateFeedbackOnlyFactory();
   ScopedFieldTrials trial(
       "WebRTC-CongestionWindow/QueueSize:800,MinBitrate:30000/");
   Scenario s("googcc_unit/cwnd_on_delay", false);
@@ -246,8 +252,7 @@ TEST_F(GoogCcNetworkControllerTest, CongestionWindowPushbackOnNetworkDelay) {
   auto ret_net = s.CreateSimulationNode(
       [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); });
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   // Start high so bandwidth drop has max effect.
   config.transport.rates.start_rate = DataRate::kbps(300);
   config.transport.rates.max_rate = DataRate::kbps(2000);
@@ -333,8 +338,6 @@ TEST_F(GoogCcNetworkControllerTest,
   auto ret_net = s.CreateSimulationNode(
       [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); });
   SimulatedTimeClientConfig config;
-  config.transport.cc =
-      TransportControllerConfig::CongestionController::kGoogCc;
   // Start high so bandwidth drop has max effect.
   config.transport.rates.start_rate = DataRate::kbps(1000);
   config.transport.rates.max_rate = DataRate::kbps(2000);
@@ -373,8 +376,6 @@ TEST_F(GoogCcNetworkControllerTest, LimitsToFloorIfRttIsHighInTrial) {
   auto ret_net = s.CreateSimulationNode(
       [](NetworkSimulationConfig* c) { c->delay = TimeDelta::ms(100); });
   SimulatedTimeClientConfig config;
-  config.transport.cc =
-      TransportControllerConfig::CongestionController::kGoogCc;
   config.transport.rates.start_rate = kLinkCapacity;
   SimulatedTimeClient* client = s.CreateSimulatedTimeClient(
       "send", config, {PacketStreamConfig()}, {send_net}, {ret_net});
@@ -396,11 +397,11 @@ TEST_F(GoogCcNetworkControllerTest, UpdatesTargetRateBasedOnLinkCapacity) {
 }
 
 TEST_F(GoogCcNetworkControllerTest, DefaultEstimateVariesInSteadyState) {
+  auto factory = CreateFeedbackOnlyFactory();
   ScopedFieldTrials trial("WebRTC-Bwe-StableBandwidthEstimate/Disabled/");
   Scenario s("googcc_unit/no_stable_varies", false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   NetworkSimulationConfig net_conf;
   net_conf.bandwidth = DataRate::kbps(500);
   net_conf.delay = TimeDelta::ms(100);
@@ -423,11 +424,11 @@ TEST_F(GoogCcNetworkControllerTest, DefaultEstimateVariesInSteadyState) {
 }
 
 TEST_F(GoogCcNetworkControllerTest, StableEstimateDoesNotVaryInSteadyState) {
+  auto factory = CreateFeedbackOnlyFactory();
   ScopedFieldTrials trial("WebRTC-Bwe-StableBandwidthEstimate/Enabled/");
   Scenario s("googcc_unit/stable_is_stable", false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   NetworkSimulationConfig net_conf;
   net_conf.bandwidth = DataRate::kbps(500);
   net_conf.delay = TimeDelta::ms(100);
@@ -458,11 +459,11 @@ TEST_F(GoogCcNetworkControllerTest,
 
 TEST_F(GoogCcNetworkControllerTest,
        LossBasedControlDoesModestBackoffToHighLoss) {
+  auto factory = CreateFeedbackOnlyFactory();
   ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
   Scenario s("googcc_unit/high_loss_channel", false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   config.transport.rates.min_rate = DataRate::kbps(10);
   config.transport.rates.max_rate = DataRate::kbps(1500);
   config.transport.rates.start_rate = DataRate::kbps(300);
@@ -482,11 +483,11 @@ TEST_F(GoogCcNetworkControllerTest,
 }
 
 TEST_F(GoogCcNetworkControllerTest, LossBasedEstimatorCapsRateAtModerateLoss) {
+  auto factory = CreateFeedbackOnlyFactory();
   ScopedFieldTrials trial("WebRTC-Bwe-LossBasedControl/Enabled/");
   Scenario s("googcc_unit/moderate_loss_channel", false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
+  config.transport.cc_factory = &factory;
-      TransportControllerConfig::CongestionController::kGoogCcFeedback;
   config.transport.rates.min_rate = DataRate::kbps(10);
   config.transport.rates.max_rate = DataRate::kbps(5000);
   config.transport.rates.start_rate = DataRate::kbps(300);
@@ -517,9 +518,7 @@ TEST_F(GoogCcNetworkControllerTest, MaintainsLowRateInSafeResetTrial) {
     c->bandwidth = kLinkCapacity;
     c->delay = TimeDelta::ms(10);
   });
-  // TODO(srte): replace with SimulatedTimeClient when it supports probing.
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = kStartRate;
   });
   auto* route = s.CreateRoutes(
@@ -546,9 +545,7 @@ TEST_F(GoogCcNetworkControllerTest, CutsHighRateInSafeResetTrial) {
     c->bandwidth = kLinkCapacity;
     c->delay = TimeDelta::ms(50);
   });
-  // TODO(srte): replace with SimulatedTimeClient when it supports probing.
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = kStartRate;
   });
   auto* route = s.CreateRoutes(
@@ -582,9 +579,7 @@ TEST_F(GoogCcNetworkControllerTest, DetectsHighRateInSafeResetTrial) {
     c->bandwidth = kNewLinkCapacity;
     c->delay = TimeDelta::ms(50);
   });
-  // TODO(srte): replace with SimulatedTimeClient when it supports probing.
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = kStartRate;
   });
   auto* route = s.CreateRoutes(
@@ -621,9 +616,7 @@ TEST_F(GoogCcNetworkControllerTest,
     c->bandwidth = kLinkCapacity;
     c->delay = TimeDelta::ms(50);
   });
-  // TODO(srte): replace with SimulatedTimeClient when it supports pacing.
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = kStartRate;
   });
   auto* route = s.CreateRoutes(
@@ -646,9 +639,7 @@ TEST_F(GoogCcNetworkControllerTest, NoBandwidthTogglingInLossControlTrial) {
     c->delay = TimeDelta::ms(10);
   });
 
-  // TODO(srte): replace with SimulatedTimeClient when it supports probing.
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = DataRate::kbps(300);
   });
   auto* route = s.CreateRoutes(
@@ -680,7 +671,6 @@ TEST_F(GoogCcNetworkControllerTest, NoRttBackoffCollapseWhenVideoStops) {
   });
 
   auto* client = s.CreateClient("send", [&](CallClientConfig* c) {
-    c->transport.cc = TransportControllerConfig::CongestionController::kGoogCc;
     c->transport.rates.start_rate = DataRate::kbps(1000);
   });
   auto* route = s.CreateRoutes(

modules/congestion_controller/goog_cc/test/goog_cc_printer.cc

@@ -58,9 +58,9 @@ NetworkControlUpdate GoogCcStatePrinter::GetState(Timestamp at_time) const {
   return controller_->GetNetworkState(at_time);
 }
 
-GoogCcDebugFactory::GoogCcDebugFactory(RtcEventLog* event_log,
+GoogCcDebugFactory::GoogCcDebugFactory(GoogCcStatePrinter* printer)
-                                       GoogCcStatePrinter* printer)
+    : GoogCcNetworkControllerFactory(GoogCcFactoryConfig()),
-    : GoogCcNetworkControllerFactory(event_log), printer_(printer) {}
+      printer_(printer) {}
 
 std::unique_ptr<NetworkControllerInterface> GoogCcDebugFactory::Create(
     NetworkControllerConfig config) {
@@ -71,18 +71,4 @@ std::unique_ptr<NetworkControllerInterface> GoogCcDebugFactory::Create(
   return controller;
 }
 
-GoogCcFeedbackDebugFactory::GoogCcFeedbackDebugFactory(
-    RtcEventLog* event_log,
-    GoogCcStatePrinter* printer)
-    : GoogCcFeedbackNetworkControllerFactory(event_log), printer_(printer) {}
-
-std::unique_ptr<NetworkControllerInterface> GoogCcFeedbackDebugFactory::Create(
-    NetworkControllerConfig config) {
-  RTC_CHECK(controller_ == nullptr);
-  auto controller = GoogCcFeedbackNetworkControllerFactory::Create(config);
-  controller_ = static_cast<GoogCcNetworkController*>(controller.get());
-  printer_->Attach(controller_);
-  return controller;
-}
-
 }  // namespace webrtc

modules/congestion_controller/goog_cc/test/goog_cc_printer.h

@@ -40,7 +40,7 @@ class GoogCcStatePrinter : public DebugStatePrinter {
 
 class GoogCcDebugFactory : public GoogCcNetworkControllerFactory {
  public:
-  GoogCcDebugFactory(RtcEventLog* event_log, GoogCcStatePrinter* printer);
+  explicit GoogCcDebugFactory(GoogCcStatePrinter* printer);
   std::unique_ptr<NetworkControllerInterface> Create(
       NetworkControllerConfig config) override;
 
@@ -49,18 +49,6 @@ class GoogCcDebugFactory : public GoogCcNetworkControllerFactory {
   GoogCcNetworkController* controller_ = nullptr;
 };
 
-class GoogCcFeedbackDebugFactory
-    : public GoogCcFeedbackNetworkControllerFactory {
- public:
-  GoogCcFeedbackDebugFactory(RtcEventLog* event_log,
-                             GoogCcStatePrinter* printer);
-  std::unique_ptr<NetworkControllerInterface> Create(
-      NetworkControllerConfig config) override;
-
- private:
-  GoogCcStatePrinter* printer_;
-  GoogCcNetworkController* controller_ = nullptr;
-};
 }  // namespace webrtc
 
 #endif  // MODULES_CONGESTION_CONTROLLER_GOOG_CC_TEST_GOOG_CC_PRINTER_H_

modules/congestion_controller/pcc/pcc_network_controller_unittest.cc

@@ -76,8 +76,6 @@ TEST(PccNetworkControllerTest, UpdatesTargetSendRate) {
   PccNetworkControllerFactory factory;
   Scenario s("pcc_unit/updates_rate", false);
   SimulatedTimeClientConfig config;
-  config.transport.cc =
-      TransportControllerConfig::CongestionController::kInjected;
   config.transport.cc_factory = &factory;
   config.transport.rates.min_rate = DataRate::kbps(10);
   config.transport.rates.max_rate = DataRate::kbps(1500);

test/scenario/call_client.cc

@@ -30,6 +30,8 @@ const uint32_t kReceiverLocalAudioSsrc = 0x1234567;
 
 const char* kPriorityStreamId = "priority-track";
 
+constexpr int kEventLogOutputIntervalMs = 5000;
+
 CallClientFakeAudio InitAudio(TimeController* time_controller) {
   CallClientFakeAudio setup;
   auto capturer = TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000);
@@ -50,10 +52,11 @@ CallClientFakeAudio InitAudio(TimeController* time_controller) {
 }
 
 Call* CreateCall(TimeController* time_controller,
+                 RtcEventLog* event_log,
                  CallClientConfig config,
                  LoggingNetworkControllerFactory* network_controller_factory,
                  rtc::scoped_refptr<AudioState> audio_state) {
-  CallConfig call_config(network_controller_factory->GetEventLog());
+  CallConfig call_config(event_log);
   call_config.bitrate_config.max_bitrate_bps =
       config.transport.rates.max_rate.bps_or(-1);
   call_config.bitrate_config.min_bitrate_bps =
@@ -67,66 +70,48 @@ Call* CreateCall(TimeController* time_controller,
                       time_controller->CreateProcessThread("CallModules"),
                       time_controller->CreateProcessThread("Pacer"));
 }
+
+std::unique_ptr<RtcEventLog> CreateEventLog(
+    TaskQueueFactory* task_queue_factory,
+    LogWriterFactoryInterface* log_writer_factory) {
+  if (!log_writer_factory) {
+    return RtcEventLog::CreateNull();
+  }
+  auto event_log = RtcEventLog::Create(RtcEventLog::EncodingType::NewFormat,
+                                       task_queue_factory);
+  bool success = event_log->StartLogging(log_writer_factory->Create(".rtc.dat"),
+                                         kEventLogOutputIntervalMs);
+  RTC_CHECK(success);
+  return event_log;
+}
 }
 
 LoggingNetworkControllerFactory::LoggingNetworkControllerFactory(
-    TimeController* time_controller,
     LogWriterFactoryInterface* log_writer_factory,
-    TransportControllerConfig config)
+    TransportControllerConfig config) {
-    : time_controller_(time_controller) {
+  if (config.cc_factory) {
-  std::unique_ptr<RtcEventLogOutput> cc_out;
+    cc_factory_ = config.cc_factory;
-  if (!log_writer_factory) {
+    if (log_writer_factory)
-    event_log_ = RtcEventLog::CreateNull();
+      RTC_LOG(LS_WARNING)
+          << "Can't log controller state for injected network controllers";
   } else {
-    event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy,
+    if (log_writer_factory) {
-                                     time_controller->GetTaskQueueFactory());
+      auto goog_printer = absl::make_unique<GoogCcStatePrinter>();
-    bool success = event_log_->StartLogging(
+      owned_cc_factory_.reset(new GoogCcDebugFactory(goog_printer.get()));
-        log_writer_factory->Create(".rtc.dat"), RtcEventLog::kImmediateOutput);
+      cc_factory_ = owned_cc_factory_.get();
-    RTC_CHECK(success);
+      cc_printer_.reset(
-    cc_out = log_writer_factory->Create(".cc_state.txt");
+          new ControlStatePrinter(log_writer_factory->Create(".cc_state.txt"),
-  }
+                                  std::move(goog_printer)));
-  switch (config.cc) {
+      cc_printer_->PrintHeaders();
-    case TransportControllerConfig::CongestionController::kGoogCc:
+    } else {
-      if (cc_out) {
+      owned_cc_factory_.reset(
-        auto goog_printer = absl::make_unique<GoogCcStatePrinter>();
+          new GoogCcNetworkControllerFactory(GoogCcFactoryConfig()));
-        owned_cc_factory_.reset(
+      cc_factory_ = owned_cc_factory_.get();
-            new GoogCcDebugFactory(event_log_.get(), goog_printer.get()));
+    }
-        cc_printer_.reset(new ControlStatePrinter(std::move(cc_out),
-                                                  std::move(goog_printer)));
-      } else {
-        owned_cc_factory_.reset(
-            new GoogCcNetworkControllerFactory(event_log_.get()));
-      }
-      break;
-    case TransportControllerConfig::CongestionController::kGoogCcFeedback:
-      if (cc_out) {
-        auto goog_printer = absl::make_unique<GoogCcStatePrinter>();
-        owned_cc_factory_.reset(new GoogCcFeedbackDebugFactory(
-            event_log_.get(), goog_printer.get()));
-        cc_printer_.reset(new ControlStatePrinter(std::move(cc_out),
-                                                  std::move(goog_printer)));
-      } else {
-        owned_cc_factory_.reset(
-            new GoogCcFeedbackNetworkControllerFactory(event_log_.get()));
-      }
-      break;
-    case TransportControllerConfig::CongestionController::kInjected:
-      cc_factory_ = config.cc_factory;
-      if (cc_out)
-        RTC_LOG(LS_WARNING)
-            << "Can't log controller state for injected network controllers";
-      break;
-  }
-  if (cc_printer_)
-    cc_printer_->PrintHeaders();
-  if (owned_cc_factory_) {
-    RTC_DCHECK(!cc_factory_);
-    cc_factory_ = owned_cc_factory_.get();
   }
 }
 
 LoggingNetworkControllerFactory::~LoggingNetworkControllerFactory() {
-  time_controller_->InvokeWithControlledYield([this]() { event_log_.reset(); });
 }
 
 void LoggingNetworkControllerFactory::LogCongestionControllerStats(
@@ -135,10 +120,6 @@ void LoggingNetworkControllerFactory::LogCongestionControllerStats(
     cc_printer_->PrintState(at_time);
 }
 
-RtcEventLog* LoggingNetworkControllerFactory::GetEventLog() const {
-  return event_log_.get();
-}
-
 std::unique_ptr<NetworkControllerInterface>
 LoggingNetworkControllerFactory::Create(NetworkControllerConfig config) {
   return cc_factory_->Create(config);
@@ -155,16 +136,16 @@ CallClient::CallClient(
     : time_controller_(time_controller),
       clock_(time_controller->GetClock()),
       log_writer_factory_(std::move(log_writer_factory)),
-      network_controller_factory_(time_controller,
+      network_controller_factory_(log_writer_factory_.get(), config.transport),
-                                  log_writer_factory_.get(),
-                                  config.transport),
       header_parser_(RtpHeaderParser::Create()),
       task_queue_(time_controller->GetTaskQueueFactory()->CreateTaskQueue(
           "CallClient",
           TaskQueueFactory::Priority::NORMAL)) {
   SendTask([this, config] {
+    event_log_ = CreateEventLog(time_controller_->GetTaskQueueFactory(),
+                                log_writer_factory_.get());
     fake_audio_setup_ = InitAudio(time_controller_);
-    call_.reset(CreateCall(time_controller_, config,
+    call_.reset(CreateCall(time_controller_, event_log_.get(), config,
                            &network_controller_factory_,
                            fake_audio_setup_.audio_state));
     transport_ = absl::make_unique<NetworkNodeTransport>(clock_, call_.get());
@@ -175,6 +156,7 @@ CallClient::~CallClient() {
   SendTask([&] {
     call_.reset();
     fake_audio_setup_ = {};
+    event_log_.reset();
   });
 }
 

test/scenario/call_client.h

@@ -36,8 +36,7 @@ namespace test {
 class LoggingNetworkControllerFactory
     : public NetworkControllerFactoryInterface {
  public:
-  LoggingNetworkControllerFactory(TimeController* time_controller,
+  LoggingNetworkControllerFactory(LogWriterFactoryInterface* log_writer_factory,
-                                  LogWriterFactoryInterface* log_writer_factory,
                                   TransportControllerConfig config);
   RTC_DISALLOW_COPY_AND_ASSIGN(LoggingNetworkControllerFactory);
   ~LoggingNetworkControllerFactory();
@@ -46,11 +45,8 @@ class LoggingNetworkControllerFactory
   TimeDelta GetProcessInterval() const override;
   // TODO(srte): Consider using the Columnprinter interface for this.
   void LogCongestionControllerStats(Timestamp at_time);
-  RtcEventLog* GetEventLog() const;
 
  private:
-  TimeController* time_controller_;
-  std::unique_ptr<RtcEventLog> event_log_;
   std::unique_ptr<NetworkControllerFactoryInterface> owned_cc_factory_;
   NetworkControllerFactoryInterface* cc_factory_ = nullptr;
   std::unique_ptr<ControlStatePrinter> cc_printer_;
@@ -103,6 +99,7 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   TimeController* const time_controller_;
   Clock* clock_;
   const std::unique_ptr<LogWriterFactoryInterface> log_writer_factory_;
+  std::unique_ptr<RtcEventLog> event_log_;
   LoggingNetworkControllerFactory network_controller_factory_;
   CallClientFakeAudio fake_audio_setup_;
   std::unique_ptr<Call> call_;

test/scenario/scenario_config.h

@@ -49,11 +49,6 @@ struct TransportControllerConfig {
     DataRate start_rate = DataRate::kbps(300);
     DataRate max_padding_rate = DataRate::Zero();
   } rates;
-  enum CongestionController {
-    kGoogCc,
-    kGoogCcFeedback,
-    kInjected
-  } cc = kGoogCc;
   NetworkControllerFactoryInterface* cc_factory = nullptr;
   TimeDelta state_log_interval = TimeDelta::ms(100);
 };

test/scenario/scenario_tests/bbr_performance.cc

@@ -148,8 +148,6 @@ TEST_P(BbrScenarioTest, ReceivesVideo) {
   Scenario s("bbr_test_gen/bbr__" + conf_.Name());
   CallClientConfig call_config;
   if (conf_.tuning.use_bbr) {
-    call_config.transport.cc =
-        TransportControllerConfig::CongestionController::kInjected;
     call_config.transport.cc_factory = &bbr_factory;
   }
   call_config.transport.rates.min_rate = DataRate::kbps(30);

test/scenario/simulated_time.cc

@@ -22,6 +22,7 @@
 namespace webrtc {
 namespace test {
 namespace {
+constexpr int kEventLogOutputIntervalMs = 5000;
 struct RawFeedbackReportPacket {
   static constexpr int MAX_FEEDBACKS = 10;
   struct Feedback {
@@ -33,6 +34,20 @@ struct RawFeedbackReportPacket {
   int64_t first_recv_time_ms;
   Feedback feedbacks[MAX_FEEDBACKS - 1];
 };
+
+std::unique_ptr<RtcEventLog> CreateEventLog(
+    TaskQueueFactory* task_queue_factory,
+    LogWriterFactoryInterface* log_writer_factory) {
+  if (!log_writer_factory) {
+    return RtcEventLog::CreateNull();
+  }
+  auto event_log = RtcEventLog::Create(RtcEventLog::EncodingType::NewFormat,
+                                       task_queue_factory);
+  bool success = event_log->StartLogging(log_writer_factory->Create(".rtc.dat"),
+                                         kEventLogOutputIntervalMs);
+  RTC_CHECK(success);
+  return event_log;
+}
 }  // namespace
 
 PacketStream::PacketStream(PacketStreamConfig config) : config_(config) {}
@@ -255,9 +270,9 @@ SimulatedTimeClient::SimulatedTimeClient(
     rtc::IPAddress return_receiver_ip,
     Timestamp at_time)
     : log_writer_factory_(std::move(log_writer_factory)),
-      network_controller_factory_(time_controller,
+      event_log_(CreateEventLog(time_controller->GetTaskQueueFactory(),
-                                  log_writer_factory_.get(),
+                                log_writer_factory_.get())),
-                                  config.transport),
+      network_controller_factory_(log_writer_factory_.get(), config.transport),
       send_link_(send_link),
       return_link_(return_link),
       sender_(send_link.front(), send_receiver_ip),
@@ -270,6 +285,7 @@ SimulatedTimeClient::SimulatedTimeClient(
   initial_config.constraints = current_contraints_;
   initial_config.stream_based_config.max_padding_rate =
       config.transport.rates.max_padding_rate;
+  initial_config.event_log = event_log_.get();
   congestion_controller_ = network_controller_factory_.Create(initial_config);
   for (auto& stream_config : stream_configs)
     packet_streams_.emplace_back(new PacketStream(stream_config));

test/scenario/simulated_time.h

@@ -148,6 +148,7 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface {
  private:
   friend class Scenario;
   std::unique_ptr<LogWriterFactoryInterface> log_writer_factory_;
+  std::unique_ptr<RtcEventLog> event_log_;
   LoggingNetworkControllerFactory network_controller_factory_;
   std::unique_ptr<NetworkControllerInterface> congestion_controller_;
   std::vector<EmulatedNetworkNode*> send_link_;