Update test/scenario to use Environment

Bug: webrtc:15656
Change-Id: Ic1508d01dce449103cdf1a507636617bda3dba22
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/329200
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#41281}

test/scenario/BUILD.gn

@@ -86,10 +86,11 @@ if (rtc_include_tests && !build_with_chromium) {
       "../../api:rtp_parameters",
       "../../api:sequence_checker",
       "../../api:time_controller",
-      "../../api:time_controller",
       "../../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/rtc_event_log:rtc_event_log_factory",
       "../../api/task_queue",
@@ -146,7 +147,6 @@ if (rtc_include_tests && !build_with_chromium) {
       "../../rtc_base/synchronization:mutex",
       "../../rtc_base/task_utils:repeating_task",
       "../../system_wrappers",
-      "../../system_wrappers:field_trial",
       "../../video/config:streams_config",
       "../logging:log_writer",
       "../network:emulated_network",

test/scenario/call_client.cc

@@ -13,6 +13,8 @@
 #include <memory>
 #include <utility>
 
+#include "api/environment/environment.h"
+#include "api/environment/environment_factory.h"
 #include "api/media_types.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
@@ -60,37 +62,27 @@ CallClientFakeAudio InitAudio(TimeController* time_controller) {
 }
 
 std::unique_ptr<Call> CreateCall(
-    TimeController* time_controller,
+    const Environment& env,
-    RtcEventLog* event_log,
     CallClientConfig config,
     LoggingNetworkControllerFactory* network_controller_factory,
     rtc::scoped_refptr<AudioState> audio_state) {
-  CallConfig call_config(event_log);
+  CallConfig call_config(env);
   call_config.bitrate_config.max_bitrate_bps =
       config.transport.rates.max_rate.bps_or(-1);
   call_config.bitrate_config.min_bitrate_bps =
       config.transport.rates.min_rate.bps();
   call_config.bitrate_config.start_bitrate_bps =
       config.transport.rates.start_rate.bps();
-  call_config.task_queue_factory = time_controller->GetTaskQueueFactory();
   call_config.network_controller_factory = network_controller_factory;
   call_config.audio_state = audio_state;
-  call_config.trials = config.field_trials;
+  return Call::Create(call_config);
-  Clock* clock = time_controller->GetClock();
-  return Call::Create(call_config, clock,
-                      RtpTransportControllerSendFactory().Create(
-                          call_config.ExtractTransportConfig(), clock));
 }
 
 std::unique_ptr<RtcEventLog> CreateEventLog(
-    TaskQueueFactory* task_queue_factory,
+    const Environment& env,
-    LogWriterFactoryInterface* log_writer_factory) {
+    LogWriterFactoryInterface& log_writer_factory) {
-  if (!log_writer_factory) {
+  auto event_log = RtcEventLogFactory().Create(env);
-    return std::make_unique<RtcEventLogNull>();
+  bool success = event_log->StartLogging(log_writer_factory.Create(".rtc.dat"),
-  }
-  auto event_log = RtcEventLogFactory(task_queue_factory)
-                       .CreateRtcEventLog(RtcEventLog::EncodingType::NewFormat);
-  bool success = event_log->StartLogging(log_writer_factory->Create(".rtc.dat"),
                                          kEventLogOutputIntervalMs);
   RTC_CHECK(success);
   return event_log;
@@ -218,22 +210,25 @@ CallClient::CallClient(
     std::unique_ptr<LogWriterFactoryInterface> log_writer_factory,
     CallClientConfig config)
     : time_controller_(time_controller),
-      clock_(time_controller->GetClock()),
+      env_(CreateEnvironment(time_controller_->CreateTaskQueueFactory(),
+                             time_controller_->GetClock())),
       log_writer_factory_(std::move(log_writer_factory)),
       network_controller_factory_(log_writer_factory_.get(), config.transport),
-      task_queue_(time_controller->GetTaskQueueFactory()->CreateTaskQueue(
+      task_queue_(env_.task_queue_factory().CreateTaskQueue(
           "CallClient",
           TaskQueueFactory::Priority::NORMAL)) {
-  config.field_trials = &field_trials_;
   SendTask([this, config] {
-    event_log_ = CreateEventLog(time_controller_->GetTaskQueueFactory(),
+    if (log_writer_factory_ != nullptr) {
-                                log_writer_factory_.get());
+      EnvironmentFactory env_factory(env_);
+      env_factory.Set(CreateEventLog(env_, *log_writer_factory_));
+      env_ = env_factory.Create();
+    }
     fake_audio_setup_ = InitAudio(time_controller_);
 
-    call_ =
+    call_ = CreateCall(env_, config, &network_controller_factory_,
-        CreateCall(time_controller_, event_log_.get(), config,
+                       fake_audio_setup_.audio_state);
-                   &network_controller_factory_, fake_audio_setup_.audio_state);
+    transport_ =
-    transport_ = std::make_unique<NetworkNodeTransport>(clock_, call_.get());
+        std::make_unique<NetworkNodeTransport>(&env_.clock(), call_.get());
   });
 }
 
@@ -242,9 +237,8 @@ CallClient::~CallClient() {
     call_.reset();
     fake_audio_setup_ = {};
     rtc::Event done;
-    event_log_->StopLogging([&done] { done.Set(); });
+    env_.event_log().StopLogging([&done] { done.Set(); });
     done.Wait(rtc::Event::kForever);
-    event_log_.reset();
   });
 }
 
@@ -282,7 +276,7 @@ DataRate CallClient::padding_rate() const {
 void CallClient::SetRemoteBitrate(DataRate bitrate) {
   RemoteBitrateReport msg;
   msg.bandwidth = bitrate;
-  msg.receive_time = clock_->CurrentTime();
+  msg.receive_time = env_.clock().CurrentTime();
   network_controller_factory_.SetRemoteBitrateEstimate(msg);
 }
 

test/scenario/call_client.h

@@ -17,6 +17,7 @@
 #include <vector>
 
 #include "api/array_view.h"
+#include "api/environment/environment.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/rtp_parameters.h"
 #include "api/test/time_controller.h"
@@ -156,9 +157,8 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   void UnBind();
 
   TimeController* const time_controller_;
-  Clock* clock_;
+  Environment env_;
   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_;
@@ -175,8 +175,6 @@ class CallClient : public EmulatedNetworkReceiverInterface {
   std::map<uint32_t, MediaType> ssrc_media_types_;
   // Defined last so it's destroyed first.
   TaskQueueForTest task_queue_;
-
-  const FieldTrialBasedConfig field_trials_;
 };
 
 class CallClientPair {

test/scenario/scenario_config.h

@@ -57,7 +57,6 @@ struct CallClientConfig {
   // The number of bites that can be sent in one burst is pacer_burst_interval *
   // current bwe. 40ms is the default Chrome setting.
   TimeDelta pacer_burst_interval = TimeDelta::Millis(40);
-  const FieldTrialsView* field_trials = nullptr;
 };
 
 struct PacketStreamConfig {

test/scenario/video_stream.cc

@@ -372,9 +372,9 @@ SendVideoStream::SendVideoStream(CallClient* sender,
                                  VideoFrameMatcher* matcher)
     : sender_(sender), config_(config) {
   video_capturer_ = std::make_unique<FrameGeneratorCapturer>(
-      sender_->clock_, CreateFrameGenerator(sender_->clock_, config.source),
+      &sender_->env_.clock(),
-      config.source.framerate,
+      CreateFrameGenerator(&sender_->env_.clock(), config.source),
-      *sender->time_controller_->GetTaskQueueFactory());
+      config.source.framerate, sender_->env_.task_queue_factory());
   video_capturer_->Init();
 
   using Encoder = VideoStreamConfig::Encoder;
@@ -386,9 +386,11 @@ SendVideoStream::SendVideoStream(CallClient* sender,
             MutexLock lock(&mutex_);
             std::unique_ptr<FakeEncoder> encoder;
             if (config_.encoder.codec == Codec::kVideoCodecVP8) {
-              encoder = std::make_unique<test::FakeVp8Encoder>(sender_->clock_);
+              encoder = std::make_unique<test::FakeVp8Encoder>(
+                  &sender_->env_.clock());
             } else if (config_.encoder.codec == Codec::kVideoCodecGeneric) {
-              encoder = std::make_unique<test::FakeEncoder>(sender_->clock_);
+              encoder =
+                  std::make_unique<test::FakeEncoder>(&sender_->env_.clock());
             } else {
               RTC_DCHECK_NOTREACHED();
             }
@@ -436,7 +438,7 @@ SendVideoStream::SendVideoStream(CallClient* sender,
 
     if (matcher->Active()) {
       frame_tap_ = std::make_unique<ForwardingCapturedFrameTap>(
-          sender_->clock_, matcher, video_capturer_.get());
+          &sender_->env_.clock(), matcher, video_capturer_.get());
       send_stream_->SetSource(frame_tap_.get(),
                               config.encoder.degradation_preference);
     } else {
@@ -565,8 +567,8 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
   for (size_t i = 0; i < num_streams; ++i) {
     rtc::VideoSinkInterface<VideoFrame>* renderer = &fake_renderer_;
     if (matcher->Active()) {
-      render_taps_.emplace_back(
+      render_taps_.emplace_back(std::make_unique<DecodedFrameTap>(
-          std::make_unique<DecodedFrameTap>(receiver_->clock_, matcher, i));
+          &receiver_->env_.clock(), matcher, i));
       renderer = render_taps_.back().get();
     }
     auto recv_config = CreateVideoReceiveStreamConfig(