7bb87ee4e8
Create a new target //webrtc/api:libjingle_peerconnection_api and start moving things into it. Move remaining parts of //webrtc/api:libjingle_peerconnection to //webrtc/pc:libjingle_peerconnection. Moved the RTCStatsCollectorCallback into its own header file, so that PeerConnectionInterface can include that instead of pulling in RTCStatsCollector and PeerConnection and everything. Separated cricket::MediaType into its own header/source set, so that it can be used in the api. BUG=webrtc:5883 Review-Url: https://codereview.webrtc.org/2514883002 Cr-Commit-Position: refs/heads/master@{#16210}
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
|