1 files changed, 43 insertions, 29 deletions

diff --git a/third_party/libwebrtc/test/call_test.cc b/third_party/libwebrtc/test/call_test.cc
index 2b71608ac6..09099cccd6 100644
--- a/third_party/libwebrtc/test/call_test.cc
+++ b/third_party/libwebrtc/test/call_test.cc
@@ -15,7 +15,8 @@
 
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
-#include "api/task_queue/default_task_queue_factory.h"
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/test/create_frame_generator.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
@@ -38,19 +39,18 @@ namespace webrtc {
 namespace test {
 
 CallTest::CallTest()
-    : clock_(Clock::GetRealTimeClock()),
-      task_queue_factory_(CreateDefaultTaskQueueFactory()),
-      send_event_log_(std::make_unique<RtcEventLogNull>()),
-      recv_event_log_(std::make_unique<RtcEventLogNull>()),
+    : env_(CreateEnvironment(&field_trials_)),
+      send_env_(env_),
+      recv_env_(env_),
       audio_send_config_(/*send_transport=*/nullptr),
       audio_send_stream_(nullptr),
       frame_generator_capturer_(nullptr),
       fake_encoder_factory_([this]() {
         std::unique_ptr<FakeEncoder> fake_encoder;
         if (video_encoder_configs_[0].codec_type == kVideoCodecVP8) {
-          fake_encoder = std::make_unique<FakeVp8Encoder>(clock_);
+          fake_encoder = std::make_unique<FakeVp8Encoder>(&env_.clock());
         } else {
-          fake_encoder = std::make_unique<FakeEncoder>(clock_);
+          fake_encoder = std::make_unique<FakeEncoder>(&env_.clock());
         }
         fake_encoder->SetMaxBitrate(fake_encoder_max_bitrate_);
         return fake_encoder;
@@ -62,12 +62,24 @@ CallTest::CallTest()
       num_flexfec_streams_(0),
       audio_decoder_factory_(CreateBuiltinAudioDecoderFactory()),
       audio_encoder_factory_(CreateBuiltinAudioEncoderFactory()),
-      task_queue_(task_queue_factory_->CreateTaskQueue(
+      task_queue_(env_.task_queue_factory().CreateTaskQueue(
           "CallTestTaskQueue",
           TaskQueueFactory::Priority::NORMAL)) {}
 
 CallTest::~CallTest() = default;
 
+void CallTest::SetSendEventLog(std::unique_ptr<RtcEventLog> event_log) {
+  EnvironmentFactory f(env_);
+  f.Set(std::move(event_log));
+  send_env_ = f.Create();
+}
+
+void CallTest::SetRecvEventLog(std::unique_ptr<RtcEventLog> event_log) {
+  EnvironmentFactory f(env_);
+  f.Set(std::move(event_log));
+  recv_env_ = f.Create();
+}
+
 void CallTest::RegisterRtpExtension(const RtpExtension& extension) {
   for (const RtpExtension& registered_extension : rtp_extensions_) {
     if (registered_extension.id == extension.id) {
@@ -97,7 +109,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
     num_audio_streams_ = test->GetNumAudioStreams();
     num_flexfec_streams_ = test->GetNumFlexfecStreams();
     RTC_DCHECK(num_video_streams_ > 0 || num_audio_streams_ > 0);
-    CallConfig send_config(send_event_log_.get());
+    CallConfig send_config = SendCallConfig();
     test->ModifySenderBitrateConfig(&send_config.bitrate_config);
     if (num_audio_streams_ > 0) {
       CreateFakeAudioDevices(test->CreateCapturer(), test->CreateRenderer());
@@ -117,7 +129,7 @@ void CallTest::RunBaseTest(BaseTest* test) {
     }
     CreateSenderCall(send_config);
     if (test->ShouldCreateReceivers()) {
-      CallConfig recv_config(recv_event_log_.get());
+      CallConfig recv_config = RecvCallConfig();
       test->ModifyReceiverBitrateConfig(&recv_config.bitrate_config);
       if (num_audio_streams_ > 0) {
         AudioState::Config audio_state_config;
@@ -206,9 +218,20 @@ void CallTest::RunBaseTest(BaseTest* test) {
   });
 }
 
+CallConfig CallTest::SendCallConfig() const {
+  CallConfig sender_config(send_env_);
+  sender_config.network_state_predictor_factory =
+      network_state_predictor_factory_.get();
+  sender_config.network_controller_factory = network_controller_factory_.get();
+  return sender_config;
+}
+
+CallConfig CallTest::RecvCallConfig() const {
+  return CallConfig(recv_env_);
+}
+
 void CallTest::CreateCalls() {
-  CreateCalls(CallConfig(send_event_log_.get()),
-              CallConfig(recv_event_log_.get()));
+  CreateCalls(SendCallConfig(), RecvCallConfig());
 }
 
 void CallTest::CreateCalls(const CallConfig& sender_config,
@@ -218,24 +241,15 @@ void CallTest::CreateCalls(const CallConfig& sender_config,
 }
 
 void CallTest::CreateSenderCall() {
-  CreateSenderCall(CallConfig(send_event_log_.get()));
+  CreateSenderCall(SendCallConfig());
 }
 
 void CallTest::CreateSenderCall(const CallConfig& config) {
-  auto sender_config = config;
-  sender_config.task_queue_factory = task_queue_factory_.get();
-  sender_config.network_state_predictor_factory =
-      network_state_predictor_factory_.get();
-  sender_config.network_controller_factory = network_controller_factory_.get();
-  sender_config.trials = &field_trials_;
-  sender_call_ = Call::Create(sender_config);
+  sender_call_ = Call::Create(config);
 }
 
 void CallTest::CreateReceiverCall(const CallConfig& config) {
-  auto receiver_config = config;
-  receiver_config.task_queue_factory = task_queue_factory_.get();
-  receiver_config.trials = &field_trials_;
-  receiver_call_ = Call::Create(receiver_config);
+  receiver_call_ = Call::Create(config);
 }
 
 void CallTest::DestroyCalls() {
@@ -489,7 +503,7 @@ void CallTest::CreateFrameGeneratorCapturerWithDrift(Clock* clock,
           clock,
           test::CreateSquareFrameGenerator(width, height, absl::nullopt,
                                            absl::nullopt),
-          framerate * speed, *task_queue_factory_);
+          framerate * speed, env_.task_queue_factory());
   frame_generator_capturer_ = frame_generator_capturer.get();
   frame_generator_capturer->Init();
   video_sources_.push_back(std::move(frame_generator_capturer));
@@ -502,10 +516,10 @@ void CallTest::CreateFrameGeneratorCapturer(int framerate,
   video_sources_.clear();
   auto frame_generator_capturer =
       std::make_unique<test::FrameGeneratorCapturer>(
-          clock_,
+          &env_.clock(),
           test::CreateSquareFrameGenerator(width, height, absl::nullopt,
                                            absl::nullopt),
-          framerate, *task_queue_factory_);
+          framerate, env_.task_queue_factory());
   frame_generator_capturer_ = frame_generator_capturer.get();
   frame_generator_capturer->Init();
   video_sources_.push_back(std::move(frame_generator_capturer));
@@ -516,9 +530,9 @@ void CallTest::CreateFakeAudioDevices(
     std::unique_ptr<TestAudioDeviceModule::Capturer> capturer,
     std::unique_ptr<TestAudioDeviceModule::Renderer> renderer) {
   fake_send_audio_device_ = TestAudioDeviceModule::Create(
-      task_queue_factory_.get(), std::move(capturer), nullptr, 1.f);
+      &env_.task_queue_factory(), std::move(capturer), nullptr, 1.f);
   fake_recv_audio_device_ = TestAudioDeviceModule::Create(
-      task_queue_factory_.get(), nullptr, std::move(renderer), 1.f);
+      &env_.task_queue_factory(), nullptr, std::move(renderer), 1.f);
 }
 
 void CallTest::CreateVideoStreams() {