blob: 56a6e9186954ab936d55d13408794eef602a7bb3 [file] [log] [blame]
/*
* 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