Use single argument PeerConnectionFactory factory in objc code

Bug: webrtc:10284
Change-Id: If656af94636731d1caa208db78e460740edbf83c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/137422
Reviewed-by: Kári Helgason <kthelgason@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#28002}

examples/BUILD.gn

@@ -460,7 +460,7 @@ if (is_ios || (is_mac && target_cpu != "x86")) {
         "../api:scoped_refptr",
         "../api/audio_codecs:builtin_audio_decoder_factory",
         "../api/audio_codecs:builtin_audio_encoder_factory",
-        "../api/video:builtin_video_bitrate_allocator_factory",
+        "../api/task_queue:default_task_queue_factory",
         "../logging:rtc_event_log_impl_base",
         "../media:rtc_audio_video",
         "../modules/audio_processing",

examples/objcnativeapi/objc/objc_call_client.mm

@@ -21,7 +21,7 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/peer_connection_interface.h"
-#include "api/video/builtin_video_bitrate_allocator_factory.h"
+#include "api/task_queue/default_task_queue_factory.h"
 #include "logging/rtc_event_log/rtc_event_log_factory.h"
 #include "media/engine/webrtc_media_engine.h"
 #include "modules/audio_processing/include/audio_processing.h"
@@ -113,31 +113,26 @@ void ObjCCallClient::CreatePeerConnectionFactory() {
   signaling_thread_->SetName("signaling_thread", nullptr);
   RTC_CHECK(signaling_thread_->Start()) << "Failed to start thread";
 
-  std::unique_ptr<webrtc::VideoDecoderFactory> videoDecoderFactory =
+  webrtc::PeerConnectionFactoryDependencies dependencies;
-      webrtc::ObjCToNativeVideoDecoderFactory([[RTCDefaultVideoDecoderFactory alloc] init]);
+  dependencies.network_thread = network_thread_.get();
-  std::unique_ptr<webrtc::VideoEncoderFactory> videoEncoderFactory =
+  dependencies.worker_thread = worker_thread_.get();
+  dependencies.signaling_thread = signaling_thread_.get();
+  dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
+  cricket::MediaEngineDependencies media_deps;
+  media_deps.task_queue_factory = dependencies.task_queue_factory.get();
+  media_deps.audio_encoder_factory = webrtc::CreateBuiltinAudioEncoderFactory();
+  media_deps.audio_decoder_factory = webrtc::CreateBuiltinAudioDecoderFactory();
+  media_deps.video_encoder_factory =
       webrtc::ObjCToNativeVideoEncoderFactory([[RTCDefaultVideoEncoderFactory alloc] init]);
-
+  media_deps.video_decoder_factory =
-  std::unique_ptr<webrtc::VideoBitrateAllocatorFactory> videoBitrateAllocatorFactory =
+      webrtc::ObjCToNativeVideoDecoderFactory([[RTCDefaultVideoDecoderFactory alloc] init]);
-      webrtc::CreateBuiltinVideoBitrateAllocatorFactory();
+  media_deps.audio_processing = webrtc::AudioProcessingBuilder().Create();
-
+  dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
-  std::unique_ptr<cricket::MediaEngineInterface> media_engine =
+  RTC_LOG(LS_INFO) << "Media engine created: " << dependencies.media_engine.get();
-      cricket::WebRtcMediaEngineFactory::Create(nullptr /* adm */,
+  dependencies.call_factory = webrtc::CreateCallFactory();
-                                                webrtc::CreateBuiltinAudioEncoderFactory(),
+  dependencies.event_log_factory =
-                                                webrtc::CreateBuiltinAudioDecoderFactory(),
+      absl::make_unique<webrtc::RtcEventLogFactory>(dependencies.task_queue_factory.get());
-                                                std::move(videoEncoderFactory),
+  pcf_ = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
-                                                std::move(videoDecoderFactory),
-                                                std::move(videoBitrateAllocatorFactory),
-                                                nullptr /* audio_mixer */,
-                                                webrtc::AudioProcessingBuilder().Create());
-  RTC_LOG(LS_INFO) << "Media engine created: " << media_engine.get();
-
-  pcf_ = webrtc::CreateModularPeerConnectionFactory(network_thread_.get(),
-                                                    worker_thread_.get(),
-                                                    signaling_thread_.get(),
-                                                    std::move(media_engine),
-                                                    webrtc::CreateCallFactory(),
-                                                    webrtc::CreateRtcEventLogFactory());
   RTC_LOG(LS_INFO) << "PeerConnectionFactory created: " << pcf_;
 }
 
@@ -147,8 +142,8 @@ void ObjCCallClient::CreatePeerConnection() {
   config.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
   // DTLS SRTP has to be disabled for loopback to work.
   config.enable_dtls_srtp = false;
-  pc_ = pcf_->CreatePeerConnection(
+  webrtc::PeerConnectionDependencies pc_dependencies(pc_observer_.get());
-      config, nullptr /* port_allocator */, nullptr /* cert_generator */, pc_observer_.get());
+  pc_ = pcf_->CreatePeerConnection(config, std::move(pc_dependencies));
   RTC_LOG(LS_INFO) << "PeerConnection created: " << pc_;
 
   rtc::scoped_refptr<webrtc::VideoTrackInterface> local_video_track =

sdk/BUILD.gn

@@ -912,6 +912,7 @@ if (is_ios || is_mac) {
         "../api/audio_codecs:audio_codecs_api",
         "../api/audio_codecs:builtin_audio_decoder_factory",
         "../api/audio_codecs:builtin_audio_encoder_factory",
+        "../api/task_queue:default_task_queue_factory",
         "../api/video:video_frame",
         "../api/video_codecs:video_codecs_api",
         "../common_video",

sdk/objc/api/peerconnection/RTCPeerConnectionFactory.mm

@@ -28,8 +28,10 @@
 #import "components/video_codec/RTCVideoEncoderFactoryH264.h"
 // The no-media version PeerConnectionFactory doesn't depend on these files, but the gn check tool
 // is not smart enough to take the #ifdef into account.
+#include "absl/memory/memory.h"
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"     // nogncheck
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"     // nogncheck
+#include "api/task_queue/default_task_queue_factory.h"
 #include "logging/rtc_event_log/rtc_event_log_factory.h"
 #include "modules/audio_device/include/audio_device.h"          // nogncheck
 #include "modules/audio_processing/include/audio_processing.h"  // nogncheck
@@ -139,13 +141,11 @@
 
 - (instancetype)initWithNoMedia {
   if (self = [self initNative]) {
-    _nativeFactory = webrtc::CreateModularPeerConnectionFactory(
+    webrtc::PeerConnectionFactoryDependencies dependencies;
-        _networkThread.get(),
+    dependencies.network_thread = _networkThread.get();
-        _workerThread.get(),
+    dependencies.worker_thread = _workerThread.get();
-        _signalingThread.get(),
+    dependencies.signaling_thread = _signalingThread.get();
-        std::unique_ptr<cricket::MediaEngineInterface>(),
+    _nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
-        std::unique_ptr<webrtc::CallFactoryInterface>(),
-        std::unique_ptr<webrtc::RtcEventLogFactoryInterface>());
     NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
   }
   return self;
@@ -209,39 +209,36 @@
                                  networkControllerFactory
                             mediaTransportFactory:(std::unique_ptr<webrtc::MediaTransportFactory>)
                                                       mediaTransportFactory {
-#ifdef HAVE_NO_MEDIA
-  return [self initWithNoMedia];
-#else
   if (self = [self initNative]) {
-    if (!audioProcessingModule) audioProcessingModule = webrtc::AudioProcessingBuilder().Create();
-
-    std::unique_ptr<cricket::MediaEngineInterface> media_engine =
-        cricket::WebRtcMediaEngineFactory::Create(audioDeviceModule,
-                                                  audioEncoderFactory,
-                                                  audioDecoderFactory,
-                                                  std::move(videoEncoderFactory),
-                                                  std::move(videoDecoderFactory),
-                                                  nullptr,  // audio mixer
-                                                  audioProcessingModule);
-
-    std::unique_ptr<webrtc::CallFactoryInterface> call_factory = webrtc::CreateCallFactory();
-
-    std::unique_ptr<webrtc::RtcEventLogFactoryInterface> event_log_factory =
-        webrtc::CreateRtcEventLogFactory();
     webrtc::PeerConnectionFactoryDependencies dependencies;
     dependencies.network_thread = _networkThread.get();
     dependencies.worker_thread = _workerThread.get();
     dependencies.signaling_thread = _signalingThread.get();
-    dependencies.media_engine = std::move(media_engine);
+#ifndef HAVE_NO_MEDIA
-    dependencies.call_factory = std::move(call_factory);
+    dependencies.task_queue_factory = webrtc::CreateDefaultTaskQueueFactory();
-    dependencies.event_log_factory = std::move(event_log_factory);
+    cricket::MediaEngineDependencies media_deps;
+    media_deps.adm = std::move(audioDeviceModule);
+    media_deps.task_queue_factory = dependencies.task_queue_factory.get();
+    media_deps.audio_encoder_factory = std::move(audioEncoderFactory);
+    media_deps.audio_decoder_factory = std::move(audioDecoderFactory);
+    media_deps.video_encoder_factory = std::move(videoEncoderFactory);
+    media_deps.video_decoder_factory = std::move(videoDecoderFactory);
+    if (audioProcessingModule) {
+      media_deps.audio_processing = std::move(audioProcessingModule);
+    } else {
+      media_deps.audio_processing = webrtc::AudioProcessingBuilder().Create();
+    }
+    dependencies.media_engine = cricket::CreateMediaEngine(std::move(media_deps));
+    dependencies.call_factory = webrtc::CreateCallFactory();
+    dependencies.event_log_factory =
+        absl::make_unique<webrtc::RtcEventLogFactory>(dependencies.task_queue_factory.get());
     dependencies.network_controller_factory = std::move(networkControllerFactory);
     dependencies.media_transport_factory = std::move(mediaTransportFactory);
+#endif
     _nativeFactory = webrtc::CreateModularPeerConnectionFactory(std::move(dependencies));
     NSAssert(_nativeFactory, @"Failed to initialize PeerConnectionFactory!");
   }
   return self;
-#endif
 }
 
 - (RTCAudioSource *)audioSourceWithConstraints:(nullable RTCMediaConstraints *)constraints {