diff --git a/api/transport/goog_cc_factory.h b/api/transport/goog_cc_factory.h index fb85c78825..10e240c72d 100644 --- a/api/transport/goog_cc_factory.h +++ b/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); diff --git a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc b/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc index c48d33fe2e..1a2c24f54d 100644 --- a/modules/congestion_controller/bbr/bbr_network_controller_unittest.cc +++ b/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); diff --git a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc index 8f7b4f1aa2..e7eea9a2a2 100644 --- a/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc +++ b/modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc @@ -49,16 +49,21 @@ int CountBandwidthDips(std::queue 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; // 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; 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 = - TransportControllerConfig::CongestionController::kGoogCcFeedback; + config.transport.cc_factory = &factory; 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( diff --git a/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc b/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc index aba3cec62c..da39f71fd8 100644 --- a/modules/congestion_controller/goog_cc/test/goog_cc_printer.cc +++ b/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, - GoogCcStatePrinter* printer) - : GoogCcNetworkControllerFactory(event_log), printer_(printer) {} +GoogCcDebugFactory::GoogCcDebugFactory(GoogCcStatePrinter* printer) + : GoogCcNetworkControllerFactory(GoogCcFactoryConfig()), + printer_(printer) {} std::unique_ptr GoogCcDebugFactory::Create( NetworkControllerConfig config) { @@ -71,18 +71,4 @@ std::unique_ptr GoogCcDebugFactory::Create( return controller; } -GoogCcFeedbackDebugFactory::GoogCcFeedbackDebugFactory( - RtcEventLog* event_log, - GoogCcStatePrinter* printer) - : GoogCcFeedbackNetworkControllerFactory(event_log), printer_(printer) {} - -std::unique_ptr GoogCcFeedbackDebugFactory::Create( - NetworkControllerConfig config) { - RTC_CHECK(controller_ == nullptr); - auto controller = GoogCcFeedbackNetworkControllerFactory::Create(config); - controller_ = static_cast(controller.get()); - printer_->Attach(controller_); - return controller; -} - } // namespace webrtc diff --git a/modules/congestion_controller/goog_cc/test/goog_cc_printer.h b/modules/congestion_controller/goog_cc/test/goog_cc_printer.h index 173c6c3081..c09138fa3c 100644 --- a/modules/congestion_controller/goog_cc/test/goog_cc_printer.h +++ b/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 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 Create( - NetworkControllerConfig config) override; - - private: - GoogCcStatePrinter* printer_; - GoogCcNetworkController* controller_ = nullptr; -}; } // namespace webrtc #endif // MODULES_CONGESTION_CONTROLLER_GOOG_CC_TEST_GOOG_CC_PRINTER_H_ diff --git a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc b/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc index c9e5096d31..6c870c1fdd 100644 --- a/modules/congestion_controller/pcc/pcc_network_controller_unittest.cc +++ b/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); diff --git a/test/scenario/call_client.cc b/test/scenario/call_client.cc index a98c3e097a..7258bd7d33 100644 --- a/test/scenario/call_client.cc +++ b/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 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 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) - : time_controller_(time_controller) { - std::unique_ptr cc_out; - if (!log_writer_factory) { - event_log_ = RtcEventLog::CreateNull(); + TransportControllerConfig config) { + if (config.cc_factory) { + cc_factory_ = config.cc_factory; + if (log_writer_factory) + RTC_LOG(LS_WARNING) + << "Can't log controller state for injected network controllers"; } else { - event_log_ = RtcEventLog::Create(RtcEventLog::EncodingType::Legacy, - time_controller->GetTaskQueueFactory()); - bool success = event_log_->StartLogging( - log_writer_factory->Create(".rtc.dat"), RtcEventLog::kImmediateOutput); - RTC_CHECK(success); - cc_out = log_writer_factory->Create(".cc_state.txt"); - } - switch (config.cc) { - case TransportControllerConfig::CongestionController::kGoogCc: - if (cc_out) { - auto goog_printer = absl::make_unique(); - owned_cc_factory_.reset( - 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(); - 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(); + if (log_writer_factory) { + auto goog_printer = absl::make_unique(); + owned_cc_factory_.reset(new GoogCcDebugFactory(goog_printer.get())); + cc_factory_ = owned_cc_factory_.get(); + cc_printer_.reset( + new ControlStatePrinter(log_writer_factory->Create(".cc_state.txt"), + std::move(goog_printer))); + cc_printer_->PrintHeaders(); + } else { + owned_cc_factory_.reset( + new GoogCcNetworkControllerFactory(GoogCcFactoryConfig())); + 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 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, - log_writer_factory_.get(), - config.transport), + network_controller_factory_(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(clock_, call_.get()); @@ -175,6 +156,7 @@ CallClient::~CallClient() { SendTask([&] { call_.reset(); fake_audio_setup_ = {}; + event_log_.reset(); }); } diff --git a/test/scenario/call_client.h b/test/scenario/call_client.h index f080b9cdb8..13f09b8061 100644 --- a/test/scenario/call_client.h +++ b/test/scenario/call_client.h @@ -36,8 +36,7 @@ namespace test { class LoggingNetworkControllerFactory : public NetworkControllerFactoryInterface { public: - LoggingNetworkControllerFactory(TimeController* time_controller, - LogWriterFactoryInterface* log_writer_factory, + LoggingNetworkControllerFactory(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 event_log_; std::unique_ptr owned_cc_factory_; NetworkControllerFactoryInterface* cc_factory_ = nullptr; std::unique_ptr cc_printer_; @@ -103,6 +99,7 @@ class CallClient : public EmulatedNetworkReceiverInterface { TimeController* const time_controller_; Clock* clock_; const std::unique_ptr log_writer_factory_; + std::unique_ptr event_log_; LoggingNetworkControllerFactory network_controller_factory_; CallClientFakeAudio fake_audio_setup_; std::unique_ptr call_; diff --git a/test/scenario/scenario_config.h b/test/scenario/scenario_config.h index 18e34a7fb2..e82ab98d1a 100644 --- a/test/scenario/scenario_config.h +++ b/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); }; diff --git a/test/scenario/scenario_tests/bbr_performance.cc b/test/scenario/scenario_tests/bbr_performance.cc index 2e2efa2d7e..a4af2a39c5 100644 --- a/test/scenario/scenario_tests/bbr_performance.cc +++ b/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); diff --git a/test/scenario/simulated_time.cc b/test/scenario/simulated_time.cc index 0d01385f83..efee9583ef 100644 --- a/test/scenario/simulated_time.cc +++ b/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 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, - log_writer_factory_.get(), - config.transport), + event_log_(CreateEventLog(time_controller->GetTaskQueueFactory(), + log_writer_factory_.get())), + 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)); diff --git a/test/scenario/simulated_time.h b/test/scenario/simulated_time.h index 05ff887f43..7f8315717a 100644 --- a/test/scenario/simulated_time.h +++ b/test/scenario/simulated_time.h @@ -148,6 +148,7 @@ class SimulatedTimeClient : EmulatedNetworkReceiverInterface { private: friend class Scenario; std::unique_ptr log_writer_factory_; + std::unique_ptr event_log_; LoggingNetworkControllerFactory network_controller_factory_; std::unique_ptr congestion_controller_; std::vector send_link_;