in test/pc/e2e pass TaskQueueFactory explicitly

instead of relying on factories that use GlobalTaskQueueFactory

Bug: webrtc:10284
Change-Id: Icc32ae1c159c39a6594d2aaec79c68dcc826fea8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/139894
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28220}

api/BUILD.gn

@@ -295,6 +295,7 @@ rtc_source_set("peer_connection_quality_test_fixture_api") {
     "../logging:rtc_event_log_api",
     "../media:rtc_media_base",
     "../rtc_base:rtc_base",
+    "task_queue",
     "transport:network_control",
     "units:time_delta",
     "video_codecs:video_codecs_api",

api/test/peerconnection_quality_test_fixture.h

@@ -23,6 +23,7 @@
 #include "api/function_view.h"
 #include "api/media_transport_interface.h"
 #include "api/peer_connection_interface.h"
+#include "api/task_queue/task_queue_factory.h"
 #include "api/test/audio_quality_analyzer_interface.h"
 #include "api/test/simulated_network.h"
 #include "api/test/video_quality_analyzer_interface.h"
@@ -185,9 +186,11 @@ class PeerConnectionE2EQualityTestFixture {
    public:
     virtual ~PeerConfigurer() = default;
 
-    // The parameters of the following 7 methods will be passed to the
+    // The parameters of the following 8 methods will be passed to the
     // PeerConnectionFactoryInterface implementation that will be created for
     // this peer.
+    virtual PeerConfigurer* SetTaskQueueFactory(
+        std::unique_ptr<TaskQueueFactory> task_queue_factory) = 0;
     virtual PeerConfigurer* SetCallFactory(
         std::unique_ptr<CallFactoryInterface> call_factory) = 0;
     virtual PeerConfigurer* SetEventLogFactory(

test/pc/e2e/BUILD.gn

@@ -53,9 +53,10 @@ rtc_source_set("peer_connection_quality_test_params") {
     "../../../api:fec_controller_api",
     "../../../api:libjingle_peerconnection_api",
     "../../../api:peer_connection_quality_test_fixture_api",
+    "../../../api/rtc_event_log",
+    "../../../api/task_queue",
     "../../../api/transport:network_control",
     "../../../api/video_codecs:video_codecs_api",
-    "../../../logging:rtc_event_log_api",
     "../../../rtc_base",
     "//third_party/abseil-cpp/absl/memory",
   ]
@@ -200,13 +201,14 @@ if (rtc_include_tests) {
       "../../../api:array_view",
       "../../../api:peer_connection_quality_test_fixture_api",
       "../../../api:scoped_refptr",
-      "../../../api/audio_codecs:builtin_audio_decoder_factory",
-      "../../../api/audio_codecs:builtin_audio_encoder_factory",
+      "../../../api/rtc_event_log:rtc_event_log_factory",
+      "../../../api/task_queue",
+      "../../../api/task_queue:default_task_queue_factory",
       "../../../api/video_codecs:builtin_video_decoder_factory",
       "../../../api/video_codecs:builtin_video_encoder_factory",
-      "../../../logging:rtc_event_log_impl_base",
       "../../../media:rtc_audio_video",
       "../../../media:rtc_media_base",
+      "../../../media:rtc_media_engine_defaults",
       "../../../modules/audio_device:audio_device_api",
       "../../../modules/audio_device:audio_device_impl",
       "../../../modules/audio_processing:api",

test/pc/e2e/peer_connection_quality_test.h

@@ -47,6 +47,12 @@ class PeerConfigurerImpl final
                                                             network_manager)),
         params_(absl::make_unique<Params>()) {}
 
+  PeerConfigurer* SetTaskQueueFactory(
+      std::unique_ptr<TaskQueueFactory> task_queue_factory) override {
+    components_->pcf_dependencies->task_queue_factory =
+        std::move(task_queue_factory);
+    return this;
+  }
   PeerConfigurer* SetCallFactory(
       std::unique_ptr<CallFactoryInterface> call_factory) override {
     components_->pcf_dependencies->call_factory = std::move(call_factory);

test/pc/e2e/peer_connection_quality_test_params.h

@@ -19,11 +19,12 @@
 #include "api/call/call_factory_interface.h"
 #include "api/fec_controller.h"
 #include "api/media_transport_interface.h"
+#include "api/rtc_event_log/rtc_event_log_factory_interface.h"
+#include "api/task_queue/task_queue_factory.h"
 #include "api/test/peerconnection_quality_test_fixture.h"
 #include "api/transport/network_control.h"
 #include "api/video_codecs/video_decoder_factory.h"
 #include "api/video_codecs/video_encoder_factory.h"
-#include "logging/rtc_event_log/rtc_event_log_factory_interface.h"
 #include "rtc_base/network.h"
 #include "rtc_base/rtc_certificate_generator.h"
 #include "rtc_base/ssl_certificate.h"
@@ -42,6 +43,7 @@ namespace webrtc_pc_e2e {
 // can override only some parts of media engine like video encoder/decoder
 // factories.
 struct PeerConnectionFactoryComponents {
+  std::unique_ptr<TaskQueueFactory> task_queue_factory;
   std::unique_ptr<CallFactoryInterface> call_factory;
   std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
   std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;

test/pc/e2e/test_peer.cc

@@ -13,13 +13,14 @@
 
 #include "absl/memory/memory.h"
 #include "absl/types/optional.h"
-#include "api/audio_codecs/builtin_audio_decoder_factory.h"
-#include "api/audio_codecs/builtin_audio_encoder_factory.h"
+#include "api/rtc_event_log/rtc_event_log_factory.h"
 #include "api/scoped_refptr.h"
+#include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_factory.h"
 #include "api/video_codecs/builtin_video_decoder_factory.h"
 #include "api/video_codecs/builtin_video_encoder_factory.h"
-#include "logging/rtc_event_log/rtc_event_log_factory.h"
 #include "media/engine/webrtc_media_engine.h"
+#include "media/engine/webrtc_media_engine_defaults.h"
 #include "modules/audio_device/include/audio_device.h"
 #include "modules/audio_processing/aec_dump/aec_dump_factory.h"
 #include "modules/audio_processing/include/audio_processing.h"
@@ -43,12 +44,17 @@ void SetMandatoryEntities(InjectableComponents* components) {
   RTC_DCHECK(components->pc_dependencies);
 
   // Setup required peer connection factory dependencies.
+  if (components->pcf_dependencies->task_queue_factory == nullptr) {
+    components->pcf_dependencies->task_queue_factory =
+        CreateDefaultTaskQueueFactory();
+  }
   if (components->pcf_dependencies->call_factory == nullptr) {
     components->pcf_dependencies->call_factory = webrtc::CreateCallFactory();
   }
   if (components->pcf_dependencies->event_log_factory == nullptr) {
     components->pcf_dependencies->event_log_factory =
-        webrtc::CreateRtcEventLogFactory();
+        absl::make_unique<RtcEventLogFactory>(
+            components->pcf_dependencies->task_queue_factory.get());
   }
 }
 
@@ -120,6 +126,7 @@ struct TestPeerComponents {
   }
 
   rtc::scoped_refptr<AudioDeviceModule> CreateAudioDeviceModule(
+      TaskQueueFactory* task_queue_factory,
       absl::optional<AudioConfig> audio_config,
       absl::optional<std::string> audio_output_file_name) {
     std::unique_ptr<TestAudioDeviceModule::Capturer> capturer;
@@ -148,8 +155,9 @@ struct TestPeerComponents {
           TestAudioDeviceModule::CreateDiscardRenderer(kSamplingFrequencyInHz);
     }
 
-    return TestAudioDeviceModule::CreateTestAudioDeviceModule(
-        std::move(capturer), std::move(renderer), /*speed=*/1.f);
+    return TestAudioDeviceModule::Create(task_queue_factory,
+                                         std::move(capturer),
+                                         std::move(renderer), /*speed=*/1.f);
   }
 
   std::unique_ptr<VideoEncoderFactory> CreateVideoEncoderFactory(
@@ -190,23 +198,20 @@ struct TestPeerComponents {
       double bitrate_multiplier,
       std::map<std::string, absl::optional<int>> stream_required_spatial_index,
       VideoQualityAnalyzerInjectionHelper* video_analyzer_helper,
-      absl::optional<std::string> audio_output_file_name,
-      rtc::TaskQueue* task_queue) {
-    rtc::scoped_refptr<AudioDeviceModule> adm = CreateAudioDeviceModule(
-        std::move(audio_config), std::move(audio_output_file_name));
-
-    std::unique_ptr<VideoEncoderFactory> video_encoder_factory =
-        CreateVideoEncoderFactory(pcf_dependencies, video_analyzer_helper,
-                                  bitrate_multiplier,
-                                  std::move(stream_required_spatial_index));
-    std::unique_ptr<VideoDecoderFactory> video_decoder_factory =
+      absl::optional<std::string> audio_output_file_name) {
+    cricket::MediaEngineDependencies media_deps;
+    media_deps.task_queue_factory = pcf_dependencies->task_queue_factory.get();
+    media_deps.adm = CreateAudioDeviceModule(media_deps.task_queue_factory,
+                                             std::move(audio_config),
+                                             std::move(audio_output_file_name));
+    media_deps.audio_processing = audio_processing;
+    media_deps.video_encoder_factory = CreateVideoEncoderFactory(
+        pcf_dependencies, video_analyzer_helper, bitrate_multiplier,
+        std::move(stream_required_spatial_index));
+    media_deps.video_decoder_factory =
         CreateVideoDecoderFactory(pcf_dependencies, video_analyzer_helper);
-
-    return cricket::WebRtcMediaEngineFactory::Create(
-        adm, webrtc::CreateBuiltinAudioEncoderFactory(),
-        webrtc::CreateBuiltinAudioDecoderFactory(),
-        std::move(video_encoder_factory), std::move(video_decoder_factory),
-        /*audio_mixer=*/nullptr, audio_processing);
+    webrtc::SetMediaEngineDefaults(&media_deps);
+    return cricket::CreateMediaEngine(std::move(media_deps));
   }
 
   // Creates PeerConnectionFactoryDependencies objects, providing entities
@@ -229,10 +234,12 @@ struct TestPeerComponents {
     pcf_deps.media_engine = CreateMediaEngine(
         pcf_dependencies.get(), std::move(audio_config), bitrate_multiplier,
         std::move(stream_required_spatial_index), video_analyzer_helper,
-        std::move(audio_output_file_name), task_queue);
+        std::move(audio_output_file_name));
 
     pcf_deps.call_factory = std::move(pcf_dependencies->call_factory);
     pcf_deps.event_log_factory = std::move(pcf_dependencies->event_log_factory);
+    pcf_deps.task_queue_factory =
+        std::move(pcf_dependencies->task_queue_factory);
 
     if (pcf_dependencies->fec_controller_factory != nullptr) {
       pcf_deps.fec_controller_factory =