| /* | |
| * Copyright 2020 The WebRTC project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "pc/connection_context.h" | |
| #include <type_traits> | |
| #include <utility> | |
| #include <vector> | |
| #include "api/environment/environment.h" | |
| #include "media/base/media_engine.h" | |
| #include "media/sctp/sctp_transport_factory.h" | |
| #include "pc/media_factory.h" | |
| #include "rtc_base/helpers.h" | |
| #include "rtc_base/internal/default_socket_server.h" | |
| #include "rtc_base/socket_server.h" | |
| #include "rtc_base/time_utils.h" | |
| namespace webrtc { | |
| namespace { | |
| rtc::Thread* MaybeStartNetworkThread( | |
| rtc::Thread* old_thread, | |
| std::unique_ptr<rtc::SocketFactory>& socket_factory_holder, | |
| std::unique_ptr<rtc::Thread>& thread_holder) { | |
| if (old_thread) { | |
| return old_thread; | |
| } | |
| std::unique_ptr<rtc::SocketServer> socket_server = | |
| rtc::CreateDefaultSocketServer(); | |
| thread_holder = std::make_unique<rtc::Thread>(socket_server.get()); | |
| socket_factory_holder = std::move(socket_server); | |
| thread_holder->SetName("pc_network_thread", nullptr); | |
| thread_holder->Start(); | |
| return thread_holder.get(); | |
| } | |
| rtc::Thread* MaybeWrapThread(rtc::Thread* signaling_thread, | |
| bool& wraps_current_thread) { | |
| wraps_current_thread = false; | |
| if (signaling_thread) { | |
| return signaling_thread; | |
| } | |
| auto this_thread = rtc::Thread::Current(); | |
| if (!this_thread) { | |
| // If this thread isn't already wrapped by an rtc::Thread, create a | |
| // wrapper and own it in this class. | |
| this_thread = rtc::ThreadManager::Instance()->WrapCurrentThread(); | |
| wraps_current_thread = true; | |
| } | |
| return this_thread; | |
| } | |
| std::unique_ptr<SctpTransportFactoryInterface> MaybeCreateSctpFactory( | |
| std::unique_ptr<SctpTransportFactoryInterface> factory, | |
| rtc::Thread* network_thread) { | |
| if (factory) { | |
| return factory; | |
| } | |
| #ifdef WEBRTC_HAVE_SCTP | |
| return std::make_unique<cricket::SctpTransportFactory>(network_thread); | |
| #else | |
| return nullptr; | |
| #endif | |
| } | |
| } // namespace | |
| // Static | |
| rtc::scoped_refptr<ConnectionContext> ConnectionContext::Create( | |
| const Environment& env, | |
| PeerConnectionFactoryDependencies* dependencies) { | |
| return rtc::scoped_refptr<ConnectionContext>( | |
| new ConnectionContext(env, dependencies)); | |
| } | |
| ConnectionContext::ConnectionContext( | |
| const Environment& env, | |
| PeerConnectionFactoryDependencies* dependencies) | |
| : network_thread_(MaybeStartNetworkThread(dependencies->network_thread, | |
| owned_socket_factory_, | |
| owned_network_thread_)), | |
| worker_thread_(dependencies->worker_thread, | |
| []() { | |
| auto thread_holder = rtc::Thread::Create(); | |
| thread_holder->SetName("pc_worker_thread", nullptr); | |
| thread_holder->Start(); | |
| return thread_holder; | |
| }), | |
| signaling_thread_(MaybeWrapThread(dependencies->signaling_thread, | |
| wraps_current_thread_)), | |
| env_(env), | |
| media_engine_( | |
| dependencies->media_factory != nullptr | |
| ? dependencies->media_factory->CreateMediaEngine(env_, | |
| *dependencies) | |
| : nullptr), | |
| network_monitor_factory_( | |
| std::move(dependencies->network_monitor_factory)), | |
| default_network_manager_(std::move(dependencies->network_manager)), | |
| call_factory_(std::move(dependencies->media_factory)), | |
| default_socket_factory_(std::move(dependencies->packet_socket_factory)), | |
| sctp_factory_( | |
| MaybeCreateSctpFactory(std::move(dependencies->sctp_factory), | |
| network_thread())), | |
| use_rtx_(true) { | |
| RTC_DCHECK_RUN_ON(signaling_thread_); | |
| RTC_DCHECK(!(default_network_manager_ && network_monitor_factory_)) | |
| << "You can't set both network_manager and network_monitor_factory."; | |
| signaling_thread_->AllowInvokesToThread(worker_thread()); | |
| signaling_thread_->AllowInvokesToThread(network_thread_); | |
| worker_thread_->AllowInvokesToThread(network_thread_); | |
| if (!network_thread_->IsCurrent()) { | |
| // network_thread_->IsCurrent() == true means signaling_thread_ is | |
| // network_thread_. In this case, no further action is required as | |
| // signaling_thread_ can already invoke network_thread_. | |
| network_thread_->PostTask( | |
| [thread = network_thread_, worker_thread = worker_thread_.get()] { | |
| thread->DisallowBlockingCalls(); | |
| thread->DisallowAllInvokes(); | |
| if (worker_thread == thread) { | |
| // In this case, worker_thread_ == network_thread_ | |
| thread->AllowInvokesToThread(thread); | |
| } | |
| }); | |
| } | |
| rtc::InitRandom(rtc::Time32()); | |
| rtc::SocketFactory* socket_factory = dependencies->socket_factory; | |
| if (socket_factory == nullptr) { | |
| if (owned_socket_factory_) { | |
| socket_factory = owned_socket_factory_.get(); | |
| } else { | |
| // TODO(bugs.webrtc.org/13145): This case should be deleted. Either | |
| // require that a PacketSocketFactory and NetworkManager always are | |
| // injected (with no need to construct these default objects), or require | |
| // that if a network_thread is injected, an approprite rtc::SocketServer | |
| // should be injected too. | |
| socket_factory = network_thread()->socketserver(); | |
| } | |
| } | |
| if (!default_network_manager_) { | |
| // If network_monitor_factory_ is non-null, it will be used to create a | |
| // network monitor while on the network thread. | |
| default_network_manager_ = std::make_unique<rtc::BasicNetworkManager>( | |
| network_monitor_factory_.get(), socket_factory, &env_.field_trials()); | |
| } | |
| if (!default_socket_factory_) { | |
| default_socket_factory_ = | |
| std::make_unique<rtc::BasicPacketSocketFactory>(socket_factory); | |
| } | |
| // Set warning levels on the threads, to give warnings when response | |
| // may be slower than is expected of the thread. | |
| // Since some of the threads may be the same, start with the least | |
| // restrictive limits and end with the least permissive ones. | |
| // This will give warnings for all cases. | |
| signaling_thread_->SetDispatchWarningMs(100); | |
| worker_thread_->SetDispatchWarningMs(30); | |
| network_thread_->SetDispatchWarningMs(10); | |
| if (media_engine_) { | |
| // TODO(tommi): Change VoiceEngine to do ctor time initialization so that | |
| // this isn't necessary. | |
| worker_thread_->BlockingCall([&] { media_engine_->Init(); }); | |
| } | |
| } | |
| ConnectionContext::~ConnectionContext() { | |
| RTC_DCHECK_RUN_ON(signaling_thread_); | |
| // `media_engine_` requires destruction to happen on the worker thread. | |
| worker_thread_->PostTask([media_engine = std::move(media_engine_)] {}); | |
| // Make sure `worker_thread()` and `signaling_thread()` outlive | |
| // `default_socket_factory_` and `default_network_manager_`. | |
| default_socket_factory_ = nullptr; | |
| default_network_manager_ = nullptr; | |
| if (wraps_current_thread_) | |
| rtc::ThreadManager::Instance()->UnwrapCurrentThread(); | |
| } | |
| } // namespace webrtc |