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}
123 lines
4.7 KiB
C++
123 lines
4.7 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 <memory>
|
|
|
|
#include "webrtc/api/ortcfactoryinterface.h"
|
|
#include "webrtc/base/fakenetwork.h"
|
|
#include "webrtc/base/gunit.h"
|
|
#include "webrtc/base/physicalsocketserver.h"
|
|
#include "webrtc/base/virtualsocketserver.h"
|
|
#include "webrtc/p2p/base/udptransport.h"
|
|
|
|
namespace {
|
|
|
|
const int kDefaultTimeout = 10000; // 10 seconds.
|
|
static const rtc::IPAddress kIPv4LocalHostAddress =
|
|
rtc::IPAddress(0x7F000001); // 127.0.0.1
|
|
|
|
class PacketReceiver : public sigslot::has_slots<> {
|
|
public:
|
|
explicit PacketReceiver(rtc::PacketTransportInterface* transport) {
|
|
transport->SignalReadPacket.connect(this, &PacketReceiver::OnReadPacket);
|
|
}
|
|
int packets_read() const { return packets_read_; }
|
|
|
|
private:
|
|
void OnReadPacket(rtc::PacketTransportInterface*,
|
|
const char*,
|
|
size_t,
|
|
const rtc::PacketTime&,
|
|
int) {
|
|
++packets_read_;
|
|
}
|
|
|
|
int packets_read_ = 0;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
namespace webrtc {
|
|
|
|
// Used to test that things work end-to-end when using the default
|
|
// implementations of threads/etc. provided by OrtcFactory, with the exception
|
|
// of using a virtual network.
|
|
//
|
|
// By default, the virtual network manager doesn't enumerate any networks, but
|
|
// sockets can still be created in this state.
|
|
class OrtcFactoryTest : public testing::Test {
|
|
public:
|
|
OrtcFactoryTest()
|
|
: virtual_socket_server_(&physical_socket_server_),
|
|
network_thread_(&virtual_socket_server_),
|
|
ortc_factory_(OrtcFactoryInterface::Create(&network_thread_,
|
|
nullptr,
|
|
&fake_network_manager_,
|
|
nullptr)) {
|
|
// Sockets are bound to the ANY address, so this is needed to tell the
|
|
// virtual network which address to use in this case.
|
|
virtual_socket_server_.SetDefaultRoute(kIPv4LocalHostAddress);
|
|
network_thread_.Start();
|
|
}
|
|
|
|
protected:
|
|
rtc::PhysicalSocketServer physical_socket_server_;
|
|
rtc::VirtualSocketServer virtual_socket_server_;
|
|
rtc::Thread network_thread_;
|
|
rtc::FakeNetworkManager fake_network_manager_;
|
|
std::unique_ptr<OrtcFactoryInterface> ortc_factory_;
|
|
};
|
|
|
|
TEST_F(OrtcFactoryTest, EndToEndUdpTransport) {
|
|
std::unique_ptr<UdpTransportInterface> transport1 =
|
|
ortc_factory_->CreateUdpTransport(AF_INET);
|
|
std::unique_ptr<UdpTransportInterface> transport2 =
|
|
ortc_factory_->CreateUdpTransport(AF_INET);
|
|
ASSERT_NE(nullptr, transport1);
|
|
ASSERT_NE(nullptr, transport2);
|
|
// Sockets are bound to the ANY address, so we need to provide the IP address
|
|
// explicitly.
|
|
transport1->SetRemoteAddress(
|
|
rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET),
|
|
transport2->GetLocalAddress().port()));
|
|
transport2->SetRemoteAddress(
|
|
rtc::SocketAddress(virtual_socket_server_.GetDefaultRoute(AF_INET),
|
|
transport1->GetLocalAddress().port()));
|
|
|
|
// TODO(deadbeef): Once there's something (RTP senders/receivers) that can
|
|
// use UdpTransport end-to-end, use that for this end-to-end test instead of
|
|
// making assumptions about the implementation.
|
|
//
|
|
// For now, this assumes the returned object is a UdpTransportProxy that wraps
|
|
// a UdpTransport.
|
|
cricket::UdpTransport* internal_transport1 =
|
|
static_cast<UdpTransportProxyWithInternal<cricket::UdpTransport>*>(
|
|
transport1.get())
|
|
->internal();
|
|
cricket::UdpTransport* internal_transport2 =
|
|
static_cast<UdpTransportProxyWithInternal<cricket::UdpTransport>*>(
|
|
transport2.get())
|
|
->internal();
|
|
// Need to call internal "SendPacket" method on network thread.
|
|
network_thread_.Invoke<void>(
|
|
RTC_FROM_HERE, [internal_transport1, internal_transport2]() {
|
|
PacketReceiver receiver1(internal_transport1);
|
|
PacketReceiver receiver2(internal_transport2);
|
|
internal_transport1->SendPacket("foo", sizeof("foo"),
|
|
rtc::PacketOptions(), 0);
|
|
internal_transport2->SendPacket("foo", sizeof("foo"),
|
|
rtc::PacketOptions(), 0);
|
|
EXPECT_EQ_WAIT(1, receiver1.packets_read(), kDefaultTimeout);
|
|
EXPECT_EQ_WAIT(1, receiver2.packets_read(), kDefaultTimeout);
|
|
});
|
|
}
|
|
|
|
} // namespace webrtc
|