zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup of network controller handling in Scenario tests.

Browse Source 
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}
This commit is contained in:
Sebastian Jansson
2019-04-24 15:13:26 +02:00
committed by Commit Bot
parent 5e3d0f88c8
commit 7ccaf8969d
12 changed files with 87 additions and 137 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
api/transport/goog_cc_factory.h
View File

@ -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);

2
modules/congestion_controller/bbr/bbr_network_controller_unittest.cc
View File

@ -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);

44
modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
View File

@ -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 =
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(

20
modules/congestion_controller/goog_cc/test/goog_cc_printer.cc
View File

@ -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<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

14
modules/congestion_controller/goog_cc/test/goog_cc_printer.h
View File

@ -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_

2
modules/congestion_controller/pcc/pcc_network_controller_unittest.cc
View File

@ -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);

96
test/scenario/call_client.cc
View File

@ -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)
: time_controller_(time_controller) {
std::unique_ptr<RtcEventLogOutput> cc_out;
if (!log_writer_factory) {
event_log_ = RtcEventLog::CreateNull();
} 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<GoogCcStatePrinter>();
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<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:
TransportControllerConfig config) {
if (config.cc_factory) {
cc_factory_ = config.cc_factory;
if (cc_out)
if (log_writer_factory)
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_);
} else {
if (log_writer_factory) {
auto goog_printer = absl::make_unique<GoogCcStatePrinter>();
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<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,
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<NetworkNodeTransport>(clock_, call_.get());
@ -175,6 +156,7 @@ CallClient::~CallClient() {
SendTask([&] {
call_.reset();
fake_audio_setup_ = {};
event_log_.reset();
});
}

7
test/scenario/call_client.h
View File

@ -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<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_;

5
test/scenario/scenario_config.h
View File

@ -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);
};

2
test/scenario/scenario_tests/bbr_performance.cc
View File

@ -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);

22
test/scenario/simulated_time.cc
View File

@ -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,
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));

1
test/scenario/simulated_time.h
View File

@ -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_;