Update CallTests to create Call using Environment

Bug: webrtc:15656
Change-Id: Ie7dd1a4db04ab7fde466b7f0483b09e3b31850d8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/329083
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41295}

call/BUILD.gn

@@ -569,7 +569,6 @@ if (rtc_include_tests) {
         "../api/rtc_event_log",
         "../api/rtc_event_log:rtc_event_log_factory",
         "../api/task_queue",
-        "../api/task_queue:default_task_queue_factory",
         "../api/task_queue:pending_task_safety_flag",
         "../api/test/metrics:global_metrics_logger_and_exporter",
         "../api/test/metrics:metric",

call/bitrate_estimator_tests.cc

@@ -178,13 +178,13 @@ class BitrateEstimatorTest : public test::CallTest {
       RTC_DCHECK_EQ(1, test_->GetVideoEncoderConfig()->number_of_streams);
       frame_generator_capturer_ =
           std::make_unique<test::FrameGeneratorCapturer>(
-              test->clock_,
+              &test->env().clock(),
               test::CreateSquareFrameGenerator(
                   test::VideoTestConstants::kDefaultWidth,
                   test::VideoTestConstants::kDefaultHeight, absl::nullopt,
                   absl::nullopt),
               test::VideoTestConstants::kDefaultFramerate,
-              *test->task_queue_factory_);
+              test->env().task_queue_factory());
       frame_generator_capturer_->Init();
       frame_generator_capturer_->Start();
       send_stream_->SetSource(frame_generator_capturer_.get(),

call/call_perf_tests.cc

@@ -212,7 +212,7 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     metrics::Reset();
     rtc::scoped_refptr<AudioDeviceModule> fake_audio_device =
         TestAudioDeviceModule::Create(
-            task_queue_factory_.get(),
+            &env().task_queue_factory(),
             TestAudioDeviceModule::CreatePulsedNoiseCapturer(256, 48000),
             TestAudioDeviceModule::CreateDiscardRenderer(48000),
             audio_rtp_speed);
@@ -223,12 +223,12 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     send_audio_state_config.audio_processing =
         AudioProcessingBuilder().Create();
     send_audio_state_config.audio_device_module = fake_audio_device;
-    CallConfig sender_config(send_event_log_.get());
+    CallConfig sender_config = SendCallConfig();
 
     auto audio_state = AudioState::Create(send_audio_state_config);
     fake_audio_device->RegisterAudioCallback(audio_state->audio_transport());
     sender_config.audio_state = audio_state;
-    CallConfig receiver_config(recv_event_log_.get());
+    CallConfig receiver_config = RecvCallConfig();
     receiver_config.audio_state = audio_state;
     CreateCalls(sender_config, receiver_config);
 
@@ -319,7 +319,8 @@ void CallPerfTest::TestAudioVideoSync(FecMode fec,
     }
     EXPECT_EQ(1u, video_receive_streams_.size());
     observer->set_receive_stream(video_receive_streams_[0]);
-    drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed);
+    drifting_clock =
+        std::make_unique<DriftingClock>(&env().clock(), video_ntp_speed);
     CreateFrameGeneratorCapturerWithDrift(
         drifting_clock.get(), video_rtp_speed,
         test::VideoTestConstants::kDefaultFramerate,

call/rampup_tests.cc

@@ -16,9 +16,7 @@
 #include "absl/strings/string_view.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
 #include "api/rtc_event_log_output_file.h"
-#include "api/task_queue/default_task_queue_factory.h"
 #include "api/task_queue/task_queue_base.h"
-#include "api/task_queue/task_queue_factory.h"
 #include "api/test/metrics/global_metrics_logger_and_exporter.h"
 #include "api/test/metrics/metric.h"
 #include "call/fake_network_pipe.h"
@@ -565,30 +563,29 @@ void RampUpDownUpTester::EvolveTestState(int bitrate_bps, bool suspended) {
 
 class RampUpTest : public test::CallTest {
  public:
-  RampUpTest()
+  RampUpTest() {
-      : task_queue_factory_(CreateDefaultTaskQueueFactory()),
-        rtc_event_log_factory_(task_queue_factory_.get()) {
     std::string dump_name(absl::GetFlag(FLAGS_ramp_dump_name));
     if (!dump_name.empty()) {
-      send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+      std::unique_ptr<RtcEventLog> send_event_log =
-          RtcEventLog::EncodingType::Legacy);
+          rtc_event_log_factory_.Create(env());
-      recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+      std::unique_ptr<RtcEventLog> recv_event_log =
-          RtcEventLog::EncodingType::Legacy);
+          rtc_event_log_factory_.Create(env());
       bool event_log_started =
-          send_event_log_->StartLogging(
+          send_event_log->StartLogging(
               std::make_unique<RtcEventLogOutputFile>(
                   dump_name + ".send.rtc.dat", RtcEventLog::kUnlimitedOutput),
               RtcEventLog::kImmediateOutput) &&
-          recv_event_log_->StartLogging(
+          recv_event_log->StartLogging(
               std::make_unique<RtcEventLogOutputFile>(
                   dump_name + ".recv.rtc.dat", RtcEventLog::kUnlimitedOutput),
               RtcEventLog::kImmediateOutput);
       RTC_DCHECK(event_log_started);
+      SetSendEventLog(std::move(send_event_log));
+      SetRecvEventLog(std::move(recv_event_log));
     }
   }
 
  private:
-  const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
   RtcEventLogFactory rtc_event_log_factory_;
 };
 

test/BUILD.gn

@@ -1287,9 +1287,10 @@ if (!build_with_chromium) {
       "../api:transport_api",
       "../api/audio_codecs:builtin_audio_decoder_factory",
       "../api/audio_codecs:builtin_audio_encoder_factory",
+      "../api/environment",
+      "../api/environment:environment_factory",
       "../api/rtc_event_log",
       "../api/task_queue",
-      "../api/task_queue:default_task_queue_factory",
       "../api/test/video:function_video_factory",
       "../api/transport:field_trial_based_config",
       "../api/units:time_delta",

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()),
+    : env_(CreateEnvironment(&field_trials_)),
-      task_queue_factory_(CreateDefaultTaskQueueFactory()),
+      send_env_(env_),
-      send_event_log_(std::make_unique<RtcEventLogNull>()),
+      recv_env_(env_),
-      recv_event_log_(std::make_unique<RtcEventLogNull>()),
       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()),
+  CreateCalls(SendCallConfig(), RecvCallConfig());
-              CallConfig(recv_event_log_.get()));
 }
 
 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_call_ = Call::Create(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);
 }
 
 void CallTest::CreateReceiverCall(const CallConfig& config) {
-  auto receiver_config = config;
+  receiver_call_ = Call::Create(config);
-  receiver_config.task_queue_factory = task_queue_factory_.get();
-  receiver_config.trials = &field_trials_;
-  receiver_call_ = Call::Create(receiver_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() {

test/call_test.h

@@ -17,6 +17,7 @@
 
 #include "absl/types/optional.h"
 #include "api/array_view.h"
+#include "api/environment/environment.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
@@ -52,6 +53,11 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   static const std::map<uint8_t, MediaType> payload_type_map_;
 
  protected:
+  const Environment& env() const { return env_; }
+
+  void SetSendEventLog(std::unique_ptr<RtcEventLog> event_log);
+  void SetRecvEventLog(std::unique_ptr<RtcEventLog> event_log);
+
   void RegisterRtpExtension(const RtpExtension& extension);
   // Returns header extensions that can be parsed by the transport.
   rtc::ArrayView<const RtpExtension> GetRegisteredExtensions() {
@@ -62,6 +68,9 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   // to simplify test code.
   void RunBaseTest(BaseTest* test);
 
+  CallConfig SendCallConfig() const;
+  CallConfig RecvCallConfig() const;
+
   void CreateCalls();
   void CreateCalls(const CallConfig& sender_config,
                    const CallConfig& receiver_config);
@@ -185,13 +194,11 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
   void OnRtpPacket(const RtpPacketReceived& packet) override;
 
   test::RunLoop loop_;
-
-  Clock* const clock_;
   test::ScopedKeyValueConfig field_trials_;
+  Environment env_;
+  Environment send_env_;
+  Environment recv_env_;
 
-  std::unique_ptr<TaskQueueFactory> task_queue_factory_;
-  std::unique_ptr<webrtc::RtcEventLog> send_event_log_;
-  std::unique_ptr<webrtc::RtcEventLog> recv_event_log_;
   std::unique_ptr<Call> sender_call_;
   std::unique_ptr<PacketTransport> send_transport_;
   SimulatedNetworkInterface* send_simulated_network_ = nullptr;

video/end_to_end_tests/network_state_tests.cc

@@ -94,7 +94,7 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
 
   SendTask(task_queue(), [this, network_to_bring_up, &encoder_factory,
                           transport]() {
-    CreateSenderCall(CallConfig(send_event_log_.get()));
+    CreateSenderCall();
     sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
 
     CreateSendConfig(1, 0, 0, transport);

video/end_to_end_tests/stats_tests.cc

@@ -518,9 +518,9 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
 
   metrics::Reset();
 
-  CallConfig send_config(send_event_log_.get());
+  CallConfig send_config = SendCallConfig();
   test.ModifySenderBitrateConfig(&send_config.bitrate_config);
-  CallConfig recv_config(recv_event_log_.get());
+  CallConfig recv_config = RecvCallConfig();
   test.ModifyReceiverBitrateConfig(&recv_config.bitrate_config);
 
   VideoEncoderConfig encoder_config_with_screenshare;
@@ -732,13 +732,13 @@ TEST_F(StatsEndToEndTest, CallReportsRttForSender) {
     Start();
   });
 
-  int64_t start_time_ms = clock_->TimeInMilliseconds();
+  int64_t start_time_ms = env().clock().TimeInMilliseconds();
   while (true) {
     Call::Stats stats;
     SendTask(task_queue(),
              [this, &stats]() { stats = sender_call_->GetStats(); });
     ASSERT_GE(start_time_ms + test::VideoTestConstants::kDefaultTimeout.ms(),
-              clock_->TimeInMilliseconds())
+              env().clock().TimeInMilliseconds())
         << "No RTT stats before timeout!";
     if (stats.rtt_ms != -1) {
       // To avoid failures caused by rounding or minor ntp clock adjustments,

video/video_quality_test.cc

@@ -375,7 +375,6 @@ VideoQualityTest::VideoQualityTest(
     std::unique_ptr<InjectionComponents> injection_components)
     : clock_(Clock::GetRealTimeClock()),
       task_queue_factory_(CreateDefaultTaskQueueFactory()),
-      rtc_event_log_factory_(task_queue_factory_.get()),
       video_decoder_factory_([this](const SdpVideoFormat& format) {
         return this->CreateVideoDecoder(format);
       }),
@@ -1221,10 +1220,10 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
   }
 
   if (!params.logging.rtc_event_log_name.empty()) {
-    send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+    std::unique_ptr<RtcEventLog> send_event_log =
-        RtcEventLog::EncodingType::NewFormat);
+        rtc_event_log_factory_.Create(env());
-    recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+    std::unique_ptr<RtcEventLog> recv_event_log =
-        RtcEventLog::EncodingType::NewFormat);
+        rtc_event_log_factory_.Create(env());
     std::unique_ptr<RtcEventLogOutputFile> send_output(
         std::make_unique<RtcEventLogOutputFile>(
             params.logging.rtc_event_log_name + "_send",
@@ -1234,19 +1233,18 @@ void VideoQualityTest::RunWithAnalyzer(const Params& params) {
             params.logging.rtc_event_log_name + "_recv",
             RtcEventLog::kUnlimitedOutput));
     bool event_log_started =
-        send_event_log_->StartLogging(std::move(send_output),
+        send_event_log->StartLogging(std::move(send_output),
-                                      RtcEventLog::kImmediateOutput) &&
+                                     RtcEventLog::kImmediateOutput) &&
-        recv_event_log_->StartLogging(std::move(recv_output),
+        recv_event_log->StartLogging(std::move(recv_output),
-                                      RtcEventLog::kImmediateOutput);
+                                     RtcEventLog::kImmediateOutput);
     RTC_DCHECK(event_log_started);
-  } else {
+    SetSendEventLog(std::move(send_event_log));
-    send_event_log_ = std::make_unique<RtcEventLogNull>();
+    SetRecvEventLog(std::move(recv_event_log));
-    recv_event_log_ = std::make_unique<RtcEventLogNull>();
   }
 
   SendTask(task_queue(), [this, &params, &send_transport, &recv_transport]() {
-    CallConfig send_call_config(send_event_log_.get());
+    CallConfig send_call_config = SendCallConfig();
-    CallConfig recv_call_config(recv_event_log_.get());
+    CallConfig recv_call_config = RecvCallConfig();
     send_call_config.bitrate_config = params.call.call_bitrate_config;
     recv_call_config.bitrate_config = params.call.call_bitrate_config;
     if (params_.audio.enabled)
@@ -1444,10 +1442,10 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
   std::vector<std::unique_ptr<test::VideoRenderer>> loopback_renderers;
 
   if (!params.logging.rtc_event_log_name.empty()) {
-    send_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+    std::unique_ptr<RtcEventLog> send_event_log =
-        RtcEventLog::EncodingType::NewFormat);
+        rtc_event_log_factory_.Create(env());
-    recv_event_log_ = rtc_event_log_factory_.CreateRtcEventLog(
+    std::unique_ptr<RtcEventLog> recv_event_log =
-        RtcEventLog::EncodingType::NewFormat);
+        rtc_event_log_factory_.Create(env());
     std::unique_ptr<RtcEventLogOutputFile> send_output(
         std::make_unique<RtcEventLogOutputFile>(
             params.logging.rtc_event_log_name + "_send",
@@ -1457,14 +1455,13 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
             params.logging.rtc_event_log_name + "_recv",
             RtcEventLog::kUnlimitedOutput));
     bool event_log_started =
-        send_event_log_->StartLogging(std::move(send_output),
+        send_event_log->StartLogging(std::move(send_output),
-                                      /*output_period_ms=*/5000) &&
+                                     /*output_period_ms=*/5000) &&
-        recv_event_log_->StartLogging(std::move(recv_output),
+        recv_event_log->StartLogging(std::move(recv_output),
-                                      /*output_period_ms=*/5000);
+                                     /*output_period_ms=*/5000);
     RTC_DCHECK(event_log_started);
-  } else {
+    SetSendEventLog(std::move(send_event_log));
-    send_event_log_ = std::make_unique<RtcEventLogNull>();
+    SetRecvEventLog(std::move(recv_event_log));
-    recv_event_log_ = std::make_unique<RtcEventLogNull>();
   }
 
   SendTask(task_queue(), [&]() {
@@ -1473,9 +1470,9 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
 
     // TODO(ivica): Remove bitrate_config and use the default CallConfig(), to
     // match the full stack tests.
-    CallConfig send_call_config(send_event_log_.get());
+    CallConfig send_call_config = SendCallConfig();
     send_call_config.bitrate_config = params_.call.call_bitrate_config;
-    CallConfig recv_call_config(recv_event_log_.get());
+    CallConfig recv_call_config = RecvCallConfig();
 
     if (params_.audio.enabled)
       InitializeAudioDevice(&send_call_config, &recv_call_config,