d1c0998730
The factory follows the same principles as PeerConnectionFactory; various modules can be passed into its constructor but default implementations are provided. Currently the only object the factory can create is a UdpTransport (need to start somewhere). UdpTransportChannel (renamed to UdpTransport) will now accept a socket passed into its constructor, relying on the factory to create the socket. This allows some simplifications to be made, such as getting rid of "State" since the only states are now "has destination set or doesn't". BUG=webrtc:7013 Review-Url: https://codereview.webrtc.org/2632613002 Cr-Commit-Position: refs/heads/master@{#16154}
120 lines
4.4 KiB
C++
120 lines
4.4 KiB
C++
/*
|
|
* Copyright 2017 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 "webrtc/api/ortcfactory.h"
|
|
|
|
#include <string>
|
|
#include <utility> // For std::move.
|
|
|
|
#include "webrtc/base/bind.h"
|
|
#include "webrtc/base/asyncpacketsocket.h"
|
|
#include "webrtc/p2p/base/basicpacketsocketfactory.h"
|
|
#include "webrtc/p2p/base/udptransport.h"
|
|
|
|
namespace webrtc {
|
|
|
|
// static
|
|
std::unique_ptr<OrtcFactoryInterface> OrtcFactoryInterface::Create(
|
|
rtc::Thread* network_thread,
|
|
rtc::Thread* signaling_thread,
|
|
rtc::NetworkManager* network_manager,
|
|
rtc::PacketSocketFactory* socket_factory) {
|
|
// Hop to signaling thread if needed.
|
|
if (signaling_thread && !signaling_thread->IsCurrent()) {
|
|
return signaling_thread->Invoke<std::unique_ptr<OrtcFactoryInterface>>(
|
|
RTC_FROM_HERE,
|
|
rtc::Bind(&OrtcFactoryInterface::Create, network_thread,
|
|
signaling_thread, network_manager, socket_factory));
|
|
}
|
|
OrtcFactory* new_factory =
|
|
new OrtcFactory(network_thread, signaling_thread,
|
|
network_manager, socket_factory);
|
|
// Return a proxy so that any calls on the returned object (including
|
|
// destructor) happen on the signaling thread.
|
|
return OrtcFactoryProxy::Create(new_factory->signaling_thread(),
|
|
new_factory->network_thread(), new_factory);
|
|
}
|
|
|
|
OrtcFactory::OrtcFactory(rtc::Thread* network_thread,
|
|
rtc::Thread* signaling_thread,
|
|
rtc::NetworkManager* network_manager,
|
|
rtc::PacketSocketFactory* socket_factory)
|
|
: network_thread_(network_thread),
|
|
signaling_thread_(signaling_thread),
|
|
network_manager_(network_manager),
|
|
socket_factory_(socket_factory) {
|
|
if (!network_thread_) {
|
|
owned_network_thread_ = rtc::Thread::CreateWithSocketServer();
|
|
owned_network_thread_->Start();
|
|
network_thread_ = owned_network_thread_.get();
|
|
}
|
|
|
|
// The worker thread is created internally because it's an implementation
|
|
// detail, and consumers of the API don't need to really know about it.
|
|
owned_worker_thread_ = rtc::Thread::Create();
|
|
owned_worker_thread_->Start();
|
|
|
|
if (signaling_thread_) {
|
|
RTC_DCHECK_RUN_ON(signaling_thread_);
|
|
} else {
|
|
signaling_thread_ = rtc::Thread::Current();
|
|
if (!signaling_thread_) {
|
|
// If this thread isn't already wrapped by an rtc::Thread, create a
|
|
// wrapper and own it in this class.
|
|
signaling_thread_ = rtc::ThreadManager::Instance()->WrapCurrentThread();
|
|
wraps_signaling_thread_ = true;
|
|
}
|
|
}
|
|
if (!network_manager_) {
|
|
owned_network_manager_.reset(new rtc::BasicNetworkManager());
|
|
network_manager_ = owned_network_manager_.get();
|
|
}
|
|
if (!socket_factory_) {
|
|
owned_socket_factory_.reset(
|
|
new rtc::BasicPacketSocketFactory(network_thread_));
|
|
socket_factory_ = owned_socket_factory_.get();
|
|
}
|
|
}
|
|
|
|
OrtcFactory::~OrtcFactory() {
|
|
RTC_DCHECK_RUN_ON(signaling_thread_);
|
|
if (wraps_signaling_thread_) {
|
|
rtc::ThreadManager::Instance()->UnwrapCurrentThread();
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<UdpTransportInterface> OrtcFactory::CreateUdpTransport(
|
|
int family,
|
|
uint16_t min_port,
|
|
uint16_t max_port) {
|
|
if (!network_thread_->IsCurrent()) {
|
|
RTC_DCHECK_RUN_ON(signaling_thread_);
|
|
return network_thread_->Invoke<std::unique_ptr<UdpTransportInterface>>(
|
|
RTC_FROM_HERE, rtc::Bind(&OrtcFactory::CreateUdpTransport, this, family,
|
|
min_port, max_port));
|
|
}
|
|
std::unique_ptr<rtc::AsyncPacketSocket> socket(
|
|
socket_factory_->CreateUdpSocket(
|
|
rtc::SocketAddress(rtc::GetAnyIP(family), 0), min_port, max_port));
|
|
if (!socket) {
|
|
LOG(LS_WARNING) << "Local socket allocation failure.";
|
|
return nullptr;
|
|
}
|
|
LOG(LS_INFO) << "Created UDP socket with address "
|
|
<< socket->GetLocalAddress().ToSensitiveString() << ".";
|
|
// Use proxy so that calls to the returned object are invoked on the network
|
|
// thread.
|
|
return UdpTransportProxy::Create(
|
|
signaling_thread_, network_thread_,
|
|
new cricket::UdpTransport(std::string(), std::move(socket)));
|
|
}
|
|
|
|
} // namespace webrtc
|