Move all files in p2p/test to webrtc namespace
This includes files,
- nat_types
- stun_server
- fake_port_allocator
- nat_socket_factory
- fake_ice_transport
- nat_server
- mock_ice_transport
- test_stun_server
- mock_ice_agent
- turn_server
- test_turn_server
- mock_dns_resolving_packet_socket_factory
- fake_packet_transport
- test_turn_customizer
- mock_active_ice_controller
- mock_ice_controller
Bug: webrtc:42232595
Change-Id: I054f8953093102b921627f4bb896eafd663dad7e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/381060
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44119}
diff --git a/examples/stunserver/stunserver_main.cc b/examples/stunserver/stunserver_main.cc
index ad5d070..ec90361 100644
--- a/examples/stunserver/stunserver_main.cc
+++ b/examples/stunserver/stunserver_main.cc
@@ -15,7 +15,7 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/thread.h"
-using cricket::StunServer;
+using ::webrtc::StunServer;
int main(int argc, char* argv[]) {
if (argc != 2) {
diff --git a/examples/turnserver/turnserver_main.cc b/examples/turnserver/turnserver_main.cc
index de8f2de..dd90ac5 100644
--- a/examples/turnserver/turnserver_main.cc
+++ b/examples/turnserver/turnserver_main.cc
@@ -28,7 +28,7 @@
namespace {
const char kSoftware[] = "libjingle TurnServer";
-class TurnFileAuth : public cricket::TurnAuthInterface {
+class TurnFileAuth : public webrtc::TurnAuthInterface {
public:
explicit TurnFileAuth(std::map<std::string, std::string> name_to_key)
: name_to_key_(std::move(name_to_key)) {}
@@ -80,7 +80,7 @@
return 1;
}
- cricket::TurnServer server(&main);
+ webrtc::TurnServer server(&main);
std::fstream auth_file(argv[4], std::fstream::in);
TurnFileAuth auth(auth_file.is_open()
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 7b94134..7d89744 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -158,12 +158,12 @@
static const SocketAddress kCascadedPrivateAddrs[2] = {
SocketAddress("192.168.10.11", 0), SocketAddress("192.168.20.22", 0)};
// The address of the public STUN server.
-static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+static const SocketAddress kStunAddr("99.99.99.1", webrtc::STUN_SERVER_PORT);
// The addresses for the public turn server.
static const SocketAddress kTurnUdpIntAddr("99.99.99.3",
- cricket::STUN_SERVER_PORT);
+ webrtc::STUN_SERVER_PORT);
static const SocketAddress kTurnTcpIntAddr("99.99.99.4",
- cricket::STUN_SERVER_PORT + 1);
+ webrtc::STUN_SERVER_PORT + 1);
static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
static const cricket::RelayCredentials kRelayCredentials("test", "test");
@@ -316,11 +316,12 @@
public:
P2PTransportChannelTestBase()
: vss_(new rtc::VirtualSocketServer()),
- nss_(new rtc::NATSocketServer(vss_.get())),
+ nss_(new webrtc::NATSocketServer(vss_.get())),
ss_(new rtc::FirewallSocketServer(nss_.get())),
socket_factory_(new rtc::BasicPacketSocketFactory(ss_.get())),
main_(ss_.get()),
- stun_server_(TestStunServer::Create(ss_.get(), kStunAddr, main_)),
+ stun_server_(
+ webrtc::TestStunServer::Create(ss_.get(), kStunAddr, main_)),
turn_server_(&main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
force_relay_(false) {
ep1_.role_ = ICEROLE_CONTROLLING;
@@ -545,7 +546,7 @@
P2PTransportChannel* ep2_ch1() { return ep2_.cd1_.ch_.get(); }
P2PTransportChannel* ep2_ch2() { return ep2_.cd2_.ch_.get(); }
- TestTurnServer* test_turn_server() { return &turn_server_; }
+ webrtc::TestTurnServer* test_turn_server() { return &turn_server_; }
rtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
// Common results.
@@ -564,7 +565,7 @@
static const Result kLocalTcpToPrflxTcp;
static const Result kPrflxTcpToLocalTcp;
- rtc::NATSocketServer* nat() { return nss_.get(); }
+ webrtc::NATSocketServer* nat() { return nss_.get(); }
rtc::FirewallSocketServer* fw() { return ss_.get(); }
Endpoint* GetEndpoint(int endpoint) {
@@ -1044,15 +1045,15 @@
private:
std::unique_ptr<rtc::VirtualSocketServer> vss_;
- std::unique_ptr<rtc::NATSocketServer> nss_;
+ std::unique_ptr<webrtc::NATSocketServer> nss_;
std::unique_ptr<rtc::FirewallSocketServer> ss_;
std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PendingTaskSafetyFlag> safety_ =
PendingTaskSafetyFlag::Create();
- TestStunServer::StunServerPtr stun_server_;
- TestTurnServer turn_server_;
+ webrtc::TestStunServer::StunServerPtr stun_server_;
+ webrtc::TestTurnServer turn_server_;
Endpoint ep1_;
Endpoint ep2_;
RemoteIceParameterSource remote_ice_parameter_source_ = FROM_CANDIDATE;
@@ -1179,8 +1180,9 @@
AddAddress(endpoint, kPrivateAddrs[endpoint]);
// Add a single NAT of the desired type
nat()
- ->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
- static_cast<rtc::NATType>(config - NAT_FULL_CONE))
+ ->AddTranslator(
+ kPublicAddrs[endpoint], kNatAddrs[endpoint],
+ static_cast<webrtc::NATType>(config - NAT_FULL_CONE))
->AddClient(kPrivateAddrs[endpoint]);
break;
case NAT_DOUBLE_CONE:
@@ -1189,10 +1191,10 @@
// Add a two cascaded NATs of the desired types
nat()
->AddTranslator(kPublicAddrs[endpoint], kNatAddrs[endpoint],
- (config == NAT_DOUBLE_CONE) ? rtc::NAT_OPEN_CONE
- : rtc::NAT_SYMMETRIC)
+ (config == NAT_DOUBLE_CONE) ? webrtc::NAT_OPEN_CONE
+ : webrtc::NAT_SYMMETRIC)
->AddTranslator(kPrivateAddrs[endpoint],
- kCascadedNatAddrs[endpoint], rtc::NAT_OPEN_CONE)
+ kCascadedNatAddrs[endpoint], webrtc::NAT_OPEN_CONE)
->AddClient(kCascadedPrivateAddrs[endpoint]);
break;
case BLOCK_UDP:
@@ -2639,14 +2641,14 @@
RTC_CHECK_GE(nat_type, NAT_FULL_CONE);
RTC_CHECK_LE(nat_type, NAT_SYMMETRIC);
CreatePortAllocators(env);
- rtc::NATSocketServer::Translator* outer_nat = nat()->AddTranslator(
+ webrtc::NATSocketServer::Translator* outer_nat = nat()->AddTranslator(
kPublicAddrs[0], kNatAddrs[0],
- static_cast<rtc::NATType>(nat_type - NAT_FULL_CONE));
+ static_cast<webrtc::NATType>(nat_type - NAT_FULL_CONE));
ConfigureEndpoint(outer_nat, 0, config1);
ConfigureEndpoint(outer_nat, 1, config2);
set_remote_ice_parameter_source(FROM_SETICEPARAMETERS);
}
- void ConfigureEndpoint(rtc::NATSocketServer::Translator* nat,
+ void ConfigureEndpoint(webrtc::NATSocketServer::Translator* nat,
int endpoint,
Config config) {
RTC_CHECK(config <= NAT_SYMMETRIC);
@@ -2656,7 +2658,7 @@
} else {
AddAddress(endpoint, kCascadedPrivateAddrs[endpoint]);
nat->AddTranslator(kPrivateAddrs[endpoint], kCascadedNatAddrs[endpoint],
- static_cast<rtc::NATType>(config - NAT_FULL_CONE))
+ static_cast<webrtc::NATType>(config - NAT_FULL_CONE))
->AddClient(kCascadedPrivateAddrs[endpoint]);
}
}
@@ -5755,7 +5757,7 @@
return *channel_;
}
- TestTurnServer* turn_server() { return &turn_server_; }
+ webrtc::TestTurnServer* turn_server() { return &turn_server_; }
// This verifies the next pingable connection has the expected candidates'
// types and, for relay local candidate, the expected relay protocol and ping
@@ -5776,7 +5778,7 @@
private:
std::unique_ptr<BasicPortAllocator> port_allocator_;
rtc::FakeNetworkManager network_manager_;
- TestTurnServer turn_server_;
+ webrtc::TestTurnServer turn_server_;
std::unique_ptr<P2PTransportChannel> channel_;
};
@@ -7172,7 +7174,7 @@
rtc::CreateDefaultSocketServer();
rtc::AutoSocketServerThread main_thread(socket_server.get());
rtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
- MockIceControllerFactory factory;
+ webrtc::MockIceControllerFactory factory;
FakePortAllocator pa(rtc::Thread::Current(), &packet_socket_factory,
&env.field_trials());
EXPECT_CALL(factory, RecordIceControllerCreated()).Times(1);
@@ -7191,7 +7193,7 @@
rtc::CreateDefaultSocketServer();
rtc::AutoSocketServerThread main_thread(socket_server.get());
rtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
- MockActiveIceControllerFactory factory;
+ webrtc::MockActiveIceControllerFactory factory;
FakePortAllocator pa(rtc::Thread::Current(), &packet_socket_factory,
&env.field_trials());
EXPECT_CALL(factory, RecordActiveIceControllerCreated()).Times(1);
diff --git a/p2p/base/packet_transport_internal_unittest.cc b/p2p/base/packet_transport_internal_unittest.cc
index d4428de..7886c74 100644
--- a/p2p/base/packet_transport_internal_unittest.cc
+++ b/p2p/base/packet_transport_internal_unittest.cc
@@ -22,7 +22,7 @@
TEST(PacketTransportInternal,
NotifyPacketReceivedPassthrougPacketToRegisteredListener) {
- rtc::FakePacketTransport packet_transport("test");
+ webrtc::FakePacketTransport packet_transport("test");
MockFunction<void(rtc::PacketTransportInternal*, const rtc::ReceivedPacket&)>
receiver;
@@ -42,7 +42,7 @@
}
TEST(PacketTransportInternal, NotifiesOnceOnClose) {
- rtc::FakePacketTransport packet_transport("test");
+ webrtc::FakePacketTransport packet_transport("test");
int call_count = 0;
packet_transport.SetOnCloseCallback([&]() { ++call_count; });
ASSERT_EQ(call_count, 0);
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index eb3a4c7..1e2bf99 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -81,11 +81,6 @@
using rtc::AsyncPacketSocket;
using rtc::ByteBufferReader;
using rtc::ByteBufferWriter;
-using rtc::NAT_ADDR_RESTRICTED;
-using rtc::NAT_OPEN_CONE;
-using rtc::NAT_PORT_RESTRICTED;
-using rtc::NAT_SYMMETRIC;
-using rtc::NATType;
using rtc::PacketSocketFactory;
using rtc::Socket;
using ::testing::Eq;
@@ -93,6 +88,11 @@
using ::testing::IsTrue;
using ::testing::NotNull;
using webrtc::IceCandidateType;
+using ::webrtc::NAT_ADDR_RESTRICTED;
+using ::webrtc::NAT_OPEN_CONE;
+using ::webrtc::NAT_PORT_RESTRICTED;
+using ::webrtc::NAT_SYMMETRIC;
+using ::webrtc::NATType;
using ::webrtc::SocketAddress;
namespace cricket {
@@ -104,10 +104,10 @@
const SocketAddress kLocalAddr1("192.168.1.2", 0);
const SocketAddress kLocalAddr2("192.168.1.3", 0);
const SocketAddress kLinkLocalIPv6Addr("fe80::aabb:ccff:fedd:eeff", 0);
-const SocketAddress kNatAddr1("77.77.77.77", rtc::NAT_SERVER_UDP_PORT);
-const SocketAddress kNatAddr2("88.88.88.88", rtc::NAT_SERVER_UDP_PORT);
-const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT);
-const SocketAddress kTurnUdpIntAddr("99.99.99.4", STUN_SERVER_PORT);
+const SocketAddress kNatAddr1("77.77.77.77", webrtc::NAT_SERVER_UDP_PORT);
+const SocketAddress kNatAddr2("88.88.88.88", webrtc::NAT_SERVER_UDP_PORT);
+const SocketAddress kStunAddr("99.99.99.1", webrtc::STUN_SERVER_PORT);
+const SocketAddress kTurnUdpIntAddr("99.99.99.4", webrtc::STUN_SERVER_PORT);
const SocketAddress kTurnTcpIntAddr("99.99.99.4", 5010);
const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
const RelayCredentials kRelayCredentials("test", "test");
@@ -434,7 +434,8 @@
nat_factory2_(ss_.get(), kNatAddr2, SocketAddress()),
nat_socket_factory1_(&nat_factory1_),
nat_socket_factory2_(&nat_factory2_),
- stun_server_(TestStunServer::Create(ss_.get(), kStunAddr, main_)),
+ stun_server_(
+ webrtc::TestStunServer::Create(ss_.get(), kStunAddr, main_)),
turn_server_(&main_, ss_.get(), kTurnUdpIntAddr, kTurnUdpExtAddr),
username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
password_(rtc::CreateRandomString(ICE_PWD_LENGTH)),
@@ -466,8 +467,8 @@
auto port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
TestConnectivity("udp", std::move(port1), StunName(ntype), std::move(port2),
- ntype == NAT_OPEN_CONE, true, ntype != NAT_SYMMETRIC,
- true);
+ ntype == webrtc::NAT_OPEN_CONE, true,
+ ntype != webrtc::NAT_SYMMETRIC, true);
}
void TestLocalToRelay(webrtc::ProtocolType proto) {
auto port1 = CreateUdpPort(kLocalAddr1);
@@ -484,7 +485,7 @@
auto port2 = CreateUdpPort(kLocalAddr2);
port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype), std::move(port1), "udp", std::move(port2),
- true, ntype != NAT_SYMMETRIC, true, true);
+ true, ntype != webrtc::NAT_SYMMETRIC, true, true);
}
void TestStunToStun(NATType ntype1, NATType ntype2) {
nat_server1_ = CreateNatServer(kNatAddr1, ntype1);
@@ -494,9 +495,11 @@
auto port2 = CreateStunPort(kLocalAddr2, &nat_socket_factory2_);
port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype1), std::move(port1), StunName(ntype2),
- std::move(port2), ntype2 == NAT_OPEN_CONE,
- ntype1 != NAT_SYMMETRIC, ntype2 != NAT_SYMMETRIC,
- ntype1 + ntype2 < (NAT_PORT_RESTRICTED + NAT_SYMMETRIC));
+ std::move(port2), ntype2 == webrtc::NAT_OPEN_CONE,
+ ntype1 != webrtc::NAT_SYMMETRIC,
+ ntype2 != webrtc::NAT_SYMMETRIC,
+ ntype1 + ntype2 <
+ (webrtc::NAT_PORT_RESTRICTED + webrtc::NAT_SYMMETRIC));
}
void TestStunToRelay(NATType ntype, webrtc::ProtocolType proto) {
nat_server1_ = CreateNatServer(kNatAddr1, ntype);
@@ -505,8 +508,8 @@
auto port2 = CreateRelayPort(kLocalAddr2, proto, webrtc::PROTO_UDP);
port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
TestConnectivity(StunName(ntype), std::move(port1), RelayName(proto),
- std::move(port2), false, ntype != NAT_SYMMETRIC, true,
- true);
+ std::move(port2), false, ntype != webrtc::NAT_SYMMETRIC,
+ true, true);
}
void TestTcpToTcp() {
auto port1 = CreateTcpPort(kLocalAddr1);
@@ -649,20 +652,20 @@
return port;
}
- std::unique_ptr<rtc::NATServer> CreateNatServer(const SocketAddress& addr,
- rtc::NATType type) {
- return std::make_unique<rtc::NATServer>(type, main_, ss_.get(), addr, addr,
- main_, ss_.get(), addr);
+ std::unique_ptr<webrtc::NATServer> CreateNatServer(const SocketAddress& addr,
+ webrtc::NATType type) {
+ return std::make_unique<webrtc::NATServer>(type, main_, ss_.get(), addr,
+ addr, main_, ss_.get(), addr);
}
static const char* StunName(NATType type) {
switch (type) {
- case NAT_OPEN_CONE:
+ case webrtc::NAT_OPEN_CONE:
return "stun(open cone)";
- case NAT_ADDR_RESTRICTED:
+ case webrtc::NAT_ADDR_RESTRICTED:
return "stun(addr restricted)";
- case NAT_PORT_RESTRICTED:
+ case webrtc::NAT_PORT_RESTRICTED:
return "stun(port restricted)";
- case NAT_SYMMETRIC:
+ case webrtc::NAT_SYMMETRIC:
return "stun(symmetric)";
default:
return "stun(?)";
@@ -944,14 +947,14 @@
std::unique_ptr<rtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
rtc::BasicPacketSocketFactory socket_factory_;
- std::unique_ptr<rtc::NATServer> nat_server1_;
- std::unique_ptr<rtc::NATServer> nat_server2_;
- rtc::NATSocketFactory nat_factory1_;
- rtc::NATSocketFactory nat_factory2_;
+ std::unique_ptr<webrtc::NATServer> nat_server1_;
+ std::unique_ptr<webrtc::NATServer> nat_server2_;
+ webrtc::NATSocketFactory nat_factory1_;
+ webrtc::NATSocketFactory nat_factory2_;
rtc::BasicPacketSocketFactory nat_socket_factory1_;
rtc::BasicPacketSocketFactory nat_socket_factory2_;
- TestStunServer::StunServerPtr stun_server_;
- TestTurnServer turn_server_;
+ webrtc::TestStunServer::StunServerPtr stun_server_;
+ webrtc::TestTurnServer turn_server_;
std::string username_;
std::string password_;
bool role_conflict_;
@@ -1263,19 +1266,19 @@
}
TEST_F(PortTest, TestLocalToConeNat) {
- TestLocalToStun(NAT_OPEN_CONE);
+ TestLocalToStun(webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestLocalToARNat) {
- TestLocalToStun(NAT_ADDR_RESTRICTED);
+ TestLocalToStun(webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestLocalToPRNat) {
- TestLocalToStun(NAT_PORT_RESTRICTED);
+ TestLocalToStun(webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestLocalToSymNat) {
- TestLocalToStun(NAT_SYMMETRIC);
+ TestLocalToStun(webrtc::NAT_SYMMETRIC);
}
// Flaky: https://code.google.com/p/webrtc/issues/detail?id=3316.
@@ -1285,105 +1288,105 @@
// Cone NAT -> XXXX
TEST_F(PortTest, TestConeNatToLocal) {
- TestStunToLocal(NAT_OPEN_CONE);
+ TestStunToLocal(webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestConeNatToConeNat) {
- TestStunToStun(NAT_OPEN_CONE, NAT_OPEN_CONE);
+ TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestConeNatToARNat) {
- TestStunToStun(NAT_OPEN_CONE, NAT_ADDR_RESTRICTED);
+ TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestConeNatToPRNat) {
- TestStunToStun(NAT_OPEN_CONE, NAT_PORT_RESTRICTED);
+ TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestConeNatToSymNat) {
- TestStunToStun(NAT_OPEN_CONE, NAT_SYMMETRIC);
+ TestStunToStun(webrtc::NAT_OPEN_CONE, webrtc::NAT_SYMMETRIC);
}
TEST_F(PortTest, TestConeNatToTurn) {
- TestStunToRelay(NAT_OPEN_CONE, webrtc::PROTO_UDP);
+ TestStunToRelay(webrtc::NAT_OPEN_CONE, webrtc::PROTO_UDP);
}
// Address-restricted NAT -> XXXX
TEST_F(PortTest, TestARNatToLocal) {
- TestStunToLocal(NAT_ADDR_RESTRICTED);
+ TestStunToLocal(webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestARNatToConeNat) {
- TestStunToStun(NAT_ADDR_RESTRICTED, NAT_OPEN_CONE);
+ TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestARNatToARNat) {
- TestStunToStun(NAT_ADDR_RESTRICTED, NAT_ADDR_RESTRICTED);
+ TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestARNatToPRNat) {
- TestStunToStun(NAT_ADDR_RESTRICTED, NAT_PORT_RESTRICTED);
+ TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestARNatToSymNat) {
- TestStunToStun(NAT_ADDR_RESTRICTED, NAT_SYMMETRIC);
+ TestStunToStun(webrtc::NAT_ADDR_RESTRICTED, webrtc::NAT_SYMMETRIC);
}
TEST_F(PortTest, TestARNatToTurn) {
- TestStunToRelay(NAT_ADDR_RESTRICTED, webrtc::PROTO_UDP);
+ TestStunToRelay(webrtc::NAT_ADDR_RESTRICTED, webrtc::PROTO_UDP);
}
// Port-restricted NAT -> XXXX
TEST_F(PortTest, TestPRNatToLocal) {
- TestStunToLocal(NAT_PORT_RESTRICTED);
+ TestStunToLocal(webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToConeNat) {
- TestStunToStun(NAT_PORT_RESTRICTED, NAT_OPEN_CONE);
+ TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestPRNatToARNat) {
- TestStunToStun(NAT_PORT_RESTRICTED, NAT_ADDR_RESTRICTED);
+ TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToPRNat) {
- TestStunToStun(NAT_PORT_RESTRICTED, NAT_PORT_RESTRICTED);
+ TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestPRNatToSymNat) {
// Will "fail"
- TestStunToStun(NAT_PORT_RESTRICTED, NAT_SYMMETRIC);
+ TestStunToStun(webrtc::NAT_PORT_RESTRICTED, webrtc::NAT_SYMMETRIC);
}
TEST_F(PortTest, TestPRNatToTurn) {
- TestStunToRelay(NAT_PORT_RESTRICTED, webrtc::PROTO_UDP);
+ TestStunToRelay(webrtc::NAT_PORT_RESTRICTED, webrtc::PROTO_UDP);
}
// Symmetric NAT -> XXXX
TEST_F(PortTest, TestSymNatToLocal) {
- TestStunToLocal(NAT_SYMMETRIC);
+ TestStunToLocal(webrtc::NAT_SYMMETRIC);
}
TEST_F(PortTest, TestSymNatToConeNat) {
- TestStunToStun(NAT_SYMMETRIC, NAT_OPEN_CONE);
+ TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_OPEN_CONE);
}
TEST_F(PortTest, TestSymNatToARNat) {
- TestStunToStun(NAT_SYMMETRIC, NAT_ADDR_RESTRICTED);
+ TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_ADDR_RESTRICTED);
}
TEST_F(PortTest, TestSymNatToPRNat) {
// Will "fail"
- TestStunToStun(NAT_SYMMETRIC, NAT_PORT_RESTRICTED);
+ TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_PORT_RESTRICTED);
}
TEST_F(PortTest, TestSymNatToSymNat) {
// Will "fail"
- TestStunToStun(NAT_SYMMETRIC, NAT_SYMMETRIC);
+ TestStunToStun(webrtc::NAT_SYMMETRIC, webrtc::NAT_SYMMETRIC);
}
TEST_F(PortTest, TestSymNatToTurn) {
- TestStunToRelay(NAT_SYMMETRIC, webrtc::PROTO_UDP);
+ TestStunToRelay(webrtc::NAT_SYMMETRIC, webrtc::PROTO_UDP);
}
// Outbound TCP -> XXXX
@@ -2920,8 +2923,8 @@
// This test verifies the foundation of different types of ICE candidates.
TEST_F(PortTest, TestCandidateFoundation) {
- std::unique_ptr<rtc::NATServer> nat_server(
- CreateNatServer(kNatAddr1, NAT_OPEN_CONE));
+ std::unique_ptr<webrtc::NATServer> nat_server(
+ CreateNatServer(kNatAddr1, webrtc::NAT_OPEN_CONE));
auto udpport1 = CreateUdpPort(kLocalAddr1);
udpport1->PrepareAddress();
auto udpport2 = CreateUdpPort(kLocalAddr1);
@@ -2973,10 +2976,10 @@
turnport2->Candidates()[0].foundation());
// Running a second turn server, to get different base IP address.
- SocketAddress kTurnUdpIntAddr2("99.99.98.4", STUN_SERVER_PORT);
+ SocketAddress kTurnUdpIntAddr2("99.99.98.4", webrtc::STUN_SERVER_PORT);
SocketAddress kTurnUdpExtAddr2("99.99.98.5", 0);
- TestTurnServer turn_server2(rtc::Thread::Current(), vss(), kTurnUdpIntAddr2,
- kTurnUdpExtAddr2);
+ webrtc::TestTurnServer turn_server2(rtc::Thread::Current(), vss(),
+ kTurnUdpIntAddr2, kTurnUdpExtAddr2);
auto turnport3 =
CreateTurnPort(kLocalAddr1, nat_socket_factory1(), webrtc::PROTO_UDP,
webrtc::PROTO_UDP, kTurnUdpIntAddr2);
@@ -2990,8 +2993,9 @@
// Start a TCP turn server, and check that two turn candidates have
// different foundations if their relay protocols are different.
- TestTurnServer turn_server3(rtc::Thread::Current(), vss(), kTurnTcpIntAddr,
- kTurnUdpExtAddr, webrtc::PROTO_TCP);
+ webrtc::TestTurnServer turn_server3(rtc::Thread::Current(), vss(),
+ kTurnTcpIntAddr, kTurnUdpExtAddr,
+ webrtc::PROTO_TCP);
auto turnport4 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
webrtc::PROTO_TCP, webrtc::PROTO_UDP);
turnport4->PrepareAddress();
@@ -3006,7 +3010,7 @@
// This test verifies the related addresses of different types of
// ICE candidates.
TEST_F(PortTest, TestCandidateRelatedAddress) {
- auto nat_server = CreateNatServer(kNatAddr1, NAT_OPEN_CONE);
+ auto nat_server = CreateNatServer(kNatAddr1, webrtc::NAT_OPEN_CONE);
auto udpport = CreateUdpPort(kLocalAddr1);
udpport->PrepareAddress();
// For UDPPort, related address will be empty.
diff --git a/p2p/base/regathering_controller_unittest.cc b/p2p/base/regathering_controller_unittest.cc
index a396712..79773e7 100644
--- a/p2p/base/regathering_controller_unittest.cc
+++ b/p2p/base/regathering_controller_unittest.cc
@@ -33,10 +33,10 @@
cricket::PORTALLOCATOR_DISABLE_RELAY |
cricket::PORTALLOCATOR_DISABLE_TCP;
// The address of the public STUN server.
-const webrtc::SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+const webrtc::SocketAddress kStunAddr("99.99.99.1", webrtc::STUN_SERVER_PORT);
// The addresses for the public TURN server.
const webrtc::SocketAddress kTurnUdpIntAddr("99.99.99.3",
- cricket::STUN_SERVER_PORT);
+ webrtc::STUN_SERVER_PORT);
const cricket::RelayCredentials kRelayCredentials("test", "test");
const char kIceUfrag[] = "UF00";
const char kIcePwd[] = "TESTICEPWD00000000000000";
@@ -51,7 +51,7 @@
RegatheringControllerTest()
: vss_(std::make_unique<rtc::VirtualSocketServer>()),
thread_(vss_.get()),
- ice_transport_(std::make_unique<cricket::MockIceTransport>()),
+ ice_transport_(std::make_unique<MockIceTransport>()),
packet_socket_factory_(
std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
allocator_(std::make_unique<cricket::FakePortAllocator>(
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 66b2725..ee1662f 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -71,14 +71,14 @@
static const SocketAddress kMsdnAddress("unittest-mdns-host-name.local", 0);
static const SocketAddress kPublicIP("212.116.91.133", 0);
static const SocketAddress kNatAddr(kPublicIP.ipaddr(),
- rtc::NAT_SERVER_UDP_PORT);
+ webrtc::NAT_SERVER_UDP_PORT);
static const SocketAddress kStunServerAddr1("34.38.54.120", 5000);
static const SocketAddress kStunServerAddr2("34.38.54.120", 4000);
static const SocketAddress kPrivateIPv6("2001:4860:4860::8844", 0);
static const SocketAddress kPublicIPv6("2002:4860:4860::8844", 5000);
static const SocketAddress kNatAddrIPv6(kPublicIPv6.ipaddr(),
- rtc::NAT_SERVER_UDP_PORT);
+ webrtc::NAT_SERVER_UDP_PORT);
static const SocketAddress kStunServerAddrIPv6Addr("2003:4860:4860::8844",
5000);
@@ -140,7 +140,7 @@
nat_factory_(ss_.get(), nat_server_address, nat_server_address),
nat_socket_factory_(&nat_factory_),
mdns_responder_provider_(new FakeMdnsResponderProvider()),
- nat_server_(CreateNatServer(nat_server_address, rtc::NAT_OPEN_CONE)),
+ nat_server_(CreateNatServer(nat_server_address, webrtc::NAT_OPEN_CONE)),
done_(false),
error_(false),
stun_keepalive_delay_(1),
@@ -150,14 +150,14 @@
for (const auto& addr : stun_server_addresses) {
RTC_CHECK(addr.family() == address.family());
stun_servers_.push_back(
- cricket::TestStunServer::Create(ss_.get(), addr, thread_));
+ webrtc::TestStunServer::Create(ss_.get(), addr, thread_));
}
}
- std::unique_ptr<rtc::NATServer> CreateNatServer(const SocketAddress& addr,
- rtc::NATType type) {
- return std::make_unique<rtc::NATServer>(type, thread_, ss_.get(), addr,
- addr, thread_, ss_.get(), addr);
+ std::unique_ptr<webrtc::NATServer> CreateNatServer(const SocketAddress& addr,
+ webrtc::NATType type) {
+ return std::make_unique<webrtc::NATServer>(type, thread_, ss_.get(), addr,
+ addr, thread_, ss_.get(), addr);
}
virtual rtc::PacketSocketFactory* socket_factory() {
@@ -291,8 +291,8 @@
return &networks_.back();
}
- cricket::TestStunServer* stun_server_1() { return stun_servers_[0].get(); }
- cricket::TestStunServer* stun_server_2() { return stun_servers_[1].get(); }
+ webrtc::TestStunServer* stun_server_1() { return stun_servers_[0].get(); }
+ webrtc::TestStunServer* stun_server_2() { return stun_servers_[1].get(); }
rtc::AutoSocketServerThread& thread() { return thread_; }
rtc::SocketFactory* nat_factory() { return &nat_factory_; }
@@ -303,13 +303,13 @@
std::unique_ptr<rtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread thread_;
- rtc::NATSocketFactory nat_factory_;
+ webrtc::NATSocketFactory nat_factory_;
rtc::BasicPacketSocketFactory nat_socket_factory_;
std::unique_ptr<cricket::UDPPort> stun_port_;
- std::vector<cricket::TestStunServer::StunServerPtr> stun_servers_;
+ std::vector<webrtc::TestStunServer::StunServerPtr> stun_servers_;
std::unique_ptr<rtc::AsyncPacketSocket> socket_;
std::unique_ptr<rtc::MdnsResponderProvider> mdns_responder_provider_;
- std::unique_ptr<rtc::NATServer> nat_server_;
+ std::unique_ptr<webrtc::NATServer> nat_server_;
bool done_;
bool error_;
int stun_keepalive_delay_;
@@ -406,12 +406,12 @@
}
void SetDnsResolverExpectations(
- rtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
+ webrtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
socket_factory_.SetExpectations(expectations);
}
private:
- rtc::MockDnsResolvingPacketSocketFactory socket_factory_;
+ webrtc::MockDnsResolvingPacketSocketFactory socket_factory_;
};
// Test that we can get an address from a STUN server specified by a hostname.
@@ -861,12 +861,12 @@
}
void SetDnsResolverExpectations(
- rtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
+ webrtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
socket_factory_.SetExpectations(expectations);
}
private:
- rtc::MockDnsResolvingPacketSocketFactory socket_factory_;
+ webrtc::MockDnsResolvingPacketSocketFactory socket_factory_;
};
// Test that we can get an address from a STUN server specified by a hostname.
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index 807e237..c9235e5 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -88,12 +88,12 @@
static const SocketAddress kLocalIPv6Addr2("2401:fa00:4:2000:be30:5bff:fee5:d4",
0);
static const SocketAddress kTurnUdpIntAddr("99.99.99.3",
- cricket::TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
static const SocketAddress kTurnTcpIntAddr("99.99.99.4",
- cricket::TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
static const SocketAddress kTurnAlternateIntAddr("99.99.99.6",
- cricket::TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
// Port for redirecting to a TCP Web server. Should not work.
static const SocketAddress kTurnDangerousAddr("99.99.99.7", 81);
// Port 53 (the DNS port); should work.
@@ -103,14 +103,13 @@
// Port 443 (the HTTPS port); should work.
static const SocketAddress kTurnPort443Addr("99.99.99.7", 443);
// The default TURN server port.
-static const SocketAddress kTurnIntAddr("99.99.99.7",
- cricket::TURN_SERVER_PORT);
+static const SocketAddress kTurnIntAddr("99.99.99.7", webrtc::TURN_SERVER_PORT);
static const SocketAddress kTurnIPv6IntAddr(
"2400:4030:2:2c00:be30:abcd:efab:cdef",
- cricket::TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
static const SocketAddress kTurnUdpIPv6IntAddr(
"2400:4030:1:2c00:be30:abcd:efab:cdef",
- cricket::TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
static const SocketAddress kTurnInvalidAddr("www.google.invalid.", 3478);
static const SocketAddress kTurnValidAddr("www.google.valid.", 3478);
@@ -512,7 +511,7 @@
std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnAlternateIntAddr);
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
@@ -544,7 +543,7 @@
std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnIPv6IntAddr);
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
turn_server_.set_redirect_hook(&redirector);
CreateTurnPort(kTurnUsername, kTurnPassword,
@@ -565,7 +564,7 @@
redirect_addresses.push_back(kTurnAlternateIntAddr);
redirect_addresses.push_back(kTurnIntAddr);
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
@@ -593,7 +592,7 @@
redirect_addresses.push_back(kTurnAlternateIntAddr);
redirect_addresses.push_back(kTurnAlternateIntAddr);
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
turn_server_.AddInternalSocket(kTurnAlternateIntAddr, protocol_type);
@@ -625,7 +624,7 @@
// Pick an unusual address in the 127.0.0.0/8 range to make sure more than
// 127.0.0.1 is covered.
SocketAddress loopback_address(ipv6 ? "::1" : "127.1.2.3",
- TURN_SERVER_PORT);
+ webrtc::TURN_SERVER_PORT);
redirect_addresses.push_back(loopback_address);
// Make a socket and bind it to the local port, to make extra sure no
@@ -639,7 +638,7 @@
ASSERT_EQ(0, loopback_socket->Listen(1));
}
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(server_address, protocol_type);
turn_server_.set_redirect_hook(&redirector);
@@ -954,7 +953,7 @@
std::unique_ptr<TurnPortTestVirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
std::unique_ptr<rtc::AsyncPacketSocket> socket_;
- TestTurnServer turn_server_;
+ webrtc::TestTurnServer turn_server_;
std::unique_ptr<TurnPort> turn_port_;
std::unique_ptr<UDPPort> udp_port_;
bool turn_ready_ = false;
@@ -1036,7 +1035,7 @@
TestTurnAllocateSucceeds(kSimulatedRtt * 2);
}
-class TurnLoggingIdValidator : public StunMessageObserver {
+class TurnLoggingIdValidator : public webrtc::StunMessageObserver {
public:
explicit TurnLoggingIdValidator(const char* expect_val)
: expect_val_(expect_val) {}
@@ -1999,7 +1998,7 @@
}
#endif
-class MessageObserver : public StunMessageObserver {
+class MessageObserver : public webrtc::StunMessageObserver {
public:
MessageObserver(unsigned int* message_counter,
unsigned int* channel_data_counter,
@@ -2014,7 +2013,7 @@
}
// Implementation defined attributes are returned as ByteString
const StunByteStringAttribute* attr =
- msg->GetByteString(TestTurnCustomizer::STUN_ATTR_COUNTER);
+ msg->GetByteString(webrtc::TestTurnCustomizer::STUN_ATTR_COUNTER);
if (attr != nullptr && attr_counter_ != nullptr) {
rtc::ByteBufferReader buf(attr->array_view());
unsigned int val = ~0u;
@@ -2045,7 +2044,7 @@
unsigned int observer_message_counter = 0;
unsigned int observer_channel_data_counter = 0;
unsigned int observer_attr_counter = 0;
- TestTurnCustomizer* customizer = new TestTurnCustomizer();
+ webrtc::TestTurnCustomizer* customizer = new webrtc::TestTurnCustomizer();
std::unique_ptr<MessageObserver> validator(new MessageObserver(
&observer_message_counter, &observer_channel_data_counter,
&observer_attr_counter));
@@ -2075,7 +2074,7 @@
unsigned int observer_message_counter = 0;
unsigned int observer_channel_data_counter = 0;
unsigned int observer_attr_counter = 0;
- TestTurnCustomizer* customizer = new TestTurnCustomizer();
+ webrtc::TestTurnCustomizer* customizer = new webrtc::TestTurnCustomizer();
std::unique_ptr<MessageObserver> validator(new MessageObserver(
&observer_message_counter, &observer_channel_data_counter,
&observer_attr_counter));
@@ -2104,7 +2103,7 @@
unsigned int observer_message_counter = 0;
unsigned int observer_channel_data_counter = 0;
unsigned int observer_attr_counter = 0;
- TestTurnCustomizer* customizer = new TestTurnCustomizer();
+ webrtc::TestTurnCustomizer* customizer = new webrtc::TestTurnCustomizer();
std::unique_ptr<MessageObserver> validator(new MessageObserver(
&observer_message_counter, &observer_channel_data_counter,
&observer_attr_counter));
@@ -2170,7 +2169,7 @@
std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnDangerousAddr);
- TestTurnRedirector redirector(redirect_addresses);
+ webrtc::TestTurnRedirector redirector(redirect_addresses);
turn_server_.AddInternalSocket(kTurnIntAddr, protocol_type);
turn_server_.AddInternalSocket(kTurnDangerousAddr, protocol_type);
@@ -2205,12 +2204,12 @@
}
void SetDnsResolverExpectations(
- rtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
+ webrtc::MockDnsResolvingPacketSocketFactory::Expectations expectations) {
socket_factory_.SetExpectations(expectations);
}
private:
- rtc::MockDnsResolvingPacketSocketFactory socket_factory_;
+ webrtc::MockDnsResolvingPacketSocketFactory socket_factory_;
};
// Test an allocation from a TURN server specified by a hostname.
diff --git a/p2p/base/wrapping_active_ice_controller_unittest.cc b/p2p/base/wrapping_active_ice_controller_unittest.cc
index 1f2f399..433e4c3 100644
--- a/p2p/base/wrapping_active_ice_controller_unittest.cc
+++ b/p2p/base/wrapping_active_ice_controller_unittest.cc
@@ -30,11 +30,11 @@
using ::cricket::IceMode;
using ::cricket::IceRecheckEvent;
using ::cricket::IceSwitchReason;
-using ::cricket::MockIceAgent;
-using ::cricket::MockIceController;
-using ::cricket::MockIceControllerFactory;
using ::cricket::NominationMode;
using ::cricket::WrappingActiveIceController;
+using ::webrtc::MockIceAgent;
+using ::webrtc::MockIceController;
+using ::webrtc::MockIceControllerFactory;
using ::testing::_;
using ::testing::ElementsAreArray;
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index 31355d3..1a08137 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -93,10 +93,12 @@
static const SocketAddress kClientIPv6Addr5(
"2401:fa00:4:5000:be30:5bff:fee5:c3",
0);
-static const SocketAddress kNatUdpAddr("77.77.77.77", rtc::NAT_SERVER_UDP_PORT);
-static const SocketAddress kNatTcpAddr("77.77.77.77", rtc::NAT_SERVER_TCP_PORT);
+static const SocketAddress kNatUdpAddr("77.77.77.77",
+ webrtc::NAT_SERVER_UDP_PORT);
+static const SocketAddress kNatTcpAddr("77.77.77.77",
+ webrtc::NAT_SERVER_TCP_PORT);
static const SocketAddress kRemoteClientAddr("22.22.22.22", 0);
-static const SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+static const SocketAddress kStunAddr("99.99.99.1", webrtc::STUN_SERVER_PORT);
static const SocketAddress kTurnUdpIntAddr("99.99.99.4", 3478);
static const SocketAddress kTurnUdpIntIPv6Addr(
"2402:fb00:4:1000:be30:5bff:fee5:c3",
@@ -159,7 +161,8 @@
// must be called.
nat_factory_(vss_.get(), kNatUdpAddr, kNatTcpAddr),
nat_socket_factory_(new rtc::BasicPacketSocketFactory(&nat_factory_)),
- stun_server_(TestStunServer::Create(fss_.get(), kStunAddr, thread_)),
+ stun_server_(
+ webrtc::TestStunServer::Create(fss_.get(), kStunAddr, thread_)),
turn_server_(rtc::Thread::Current(),
fss_.get(),
kTurnUdpIntAddr,
@@ -477,7 +480,7 @@
void ResetWithStunServer(const webrtc::SocketAddress& stun_server,
bool with_nat) {
if (with_nat) {
- nat_server_.reset(new rtc::NATServer(
+ nat_server_.reset(new webrtc::NATServer(
rtc::NAT_OPEN_CONE, thread_, vss_.get(), kNatUdpAddr, kNatTcpAddr,
thread_, vss_.get(), webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
} else {
@@ -504,11 +507,11 @@
std::unique_ptr<rtc::FirewallSocketServer> fss_;
rtc::BasicPacketSocketFactory socket_factory_;
rtc::AutoSocketServerThread thread_;
- std::unique_ptr<rtc::NATServer> nat_server_;
- rtc::NATSocketFactory nat_factory_;
+ std::unique_ptr<webrtc::NATServer> nat_server_;
+ webrtc::NATSocketFactory nat_factory_;
std::unique_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
- TestStunServer::StunServerPtr stun_server_;
- TestTurnServer turn_server_;
+ webrtc::TestStunServer::StunServerPtr stun_server_;
+ webrtc::TestTurnServer turn_server_;
rtc::FakeNetworkManager network_manager_;
std::unique_ptr<BasicPortAllocator> allocator_;
std::unique_ptr<PortAllocatorSession> session_;
diff --git a/p2p/stunprober/stun_prober_unittest.cc b/p2p/stunprober/stun_prober_unittest.cc
index 2d778e8..eff4e22 100644
--- a/p2p/stunprober/stun_prober_unittest.cc
+++ b/p2p/stunprober/stun_prober_unittest.cc
@@ -51,9 +51,9 @@
main_(ss_.get()),
result_(StunProber::SUCCESS),
stun_server_1_(
- cricket::TestStunServer::Create(ss_.get(), kStunAddr1, main_)),
+ webrtc::TestStunServer::Create(ss_.get(), kStunAddr1, main_)),
stun_server_2_(
- cricket::TestStunServer::Create(ss_.get(), kStunAddr2, main_)) {
+ webrtc::TestStunServer::Create(ss_.get(), kStunAddr2, main_)) {
stun_server_1_->set_fake_stun_addr(kStunMappedAddr);
stun_server_2_->set_fake_stun_addr(kStunMappedAddr);
rtc::InitializeSSL();
@@ -145,8 +145,8 @@
std::unique_ptr<StunProber> prober_;
int result_ = 0;
bool stopped_ = false;
- cricket::TestStunServer::StunServerPtr stun_server_1_;
- cricket::TestStunServer::StunServerPtr stun_server_2_;
+ webrtc::TestStunServer::StunServerPtr stun_server_1_;
+ webrtc::TestStunServer::StunServerPtr stun_server_2_;
StunProber::Stats stats_;
};
diff --git a/p2p/test/fake_packet_transport.h b/p2p/test/fake_packet_transport.h
index b9162ee..86640b8 100644
--- a/p2p/test/fake_packet_transport.h
+++ b/p2p/test/fake_packet_transport.h
@@ -18,10 +18,10 @@
#include "rtc_base/copy_on_write_buffer.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
// Used to simulate a packet-based transport.
-class FakePacketTransport : public PacketTransportInternal {
+class FakePacketTransport : public rtc::PacketTransportInternal {
public:
explicit FakePacketTransport(const std::string& transport_name)
: transport_name_(transport_name) {}
@@ -59,7 +59,7 @@
bool receiving() const override { return receiving_; }
int SendPacket(const char* data,
size_t len,
- const PacketOptions& options,
+ const rtc::PacketOptions& options,
int /* flags */) override {
if (!dest_ || error_ != 0) {
return -1;
@@ -67,17 +67,17 @@
CopyOnWriteBuffer packet(data, len);
SendPacketInternal(packet, options);
- SentPacket sent_packet(options.packet_id, TimeMillis());
+ rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis());
SignalSentPacket(this, sent_packet);
return static_cast<int>(len);
}
- int SetOption(Socket::Option opt, int value) override {
+ int SetOption(rtc::Socket::Option opt, int value) override {
options_[opt] = value;
return 0;
}
- bool GetOption(Socket::Option opt, int* value) override {
+ bool GetOption(rtc::Socket::Option opt, int* value) override {
auto it = options_.find(opt);
if (it == options_.end()) {
return false;
@@ -91,16 +91,16 @@
const CopyOnWriteBuffer* last_sent_packet() { return &last_sent_packet_; }
- std::optional<NetworkRoute> network_route() const override {
+ std::optional<rtc::NetworkRoute> network_route() const override {
return network_route_;
}
- void SetNetworkRoute(std::optional<NetworkRoute> network_route) {
+ void SetNetworkRoute(std::optional<rtc::NetworkRoute> network_route) {
network_route_ = network_route;
SignalNetworkRouteChanged(network_route);
}
- using PacketTransportInternal::NotifyOnClose;
- using PacketTransportInternal::NotifyPacketReceived;
+ using rtc::PacketTransportInternal::NotifyOnClose;
+ using rtc::PacketTransportInternal::NotifyPacketReceived;
private:
void set_writable(bool writable) {
@@ -127,8 +127,7 @@
last_sent_packet_ = packet;
if (dest_) {
dest_->NotifyPacketReceived(rtc::ReceivedPacket(
- packet, webrtc::SocketAddress(),
- webrtc::Timestamp::Micros(rtc::TimeMicros()),
+ packet, SocketAddress(), Timestamp::Micros(rtc::TimeMicros()),
options.ecn_1 ? EcnMarking::kEct1 : EcnMarking::kNotEct));
}
}
@@ -139,12 +138,18 @@
bool writable_ = false;
bool receiving_ = false;
- std::map<Socket::Option, int> options_;
+ std::map<rtc::Socket::Option, int> options_;
int error_ = 0;
- std::optional<NetworkRoute> network_route_;
+ std::optional<rtc::NetworkRoute> network_route_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::FakePacketTransport;
} // namespace rtc
#endif // P2P_TEST_FAKE_PACKET_TRANSPORT_H_
diff --git a/p2p/test/mock_active_ice_controller.h b/p2p/test/mock_active_ice_controller.h
index 010bb9c..794c451 100644
--- a/p2p/test/mock_active_ice_controller.h
+++ b/p2p/test/mock_active_ice_controller.h
@@ -17,7 +17,7 @@
#include "p2p/base/active_ice_controller_interface.h"
#include "test/gmock.h"
-namespace cricket {
+namespace webrtc {
class MockActiveIceController : public cricket::ActiveIceControllerInterface {
public:
@@ -84,6 +84,13 @@
MOCK_METHOD(void, RecordActiveIceControllerCreated, ());
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::MockActiveIceController;
+using ::webrtc::MockActiveIceControllerFactory;
} // namespace cricket
#endif // P2P_TEST_MOCK_ACTIVE_ICE_CONTROLLER_H_
diff --git a/p2p/test/mock_dns_resolving_packet_socket_factory.h b/p2p/test/mock_dns_resolving_packet_socket_factory.h
index ae3943b..f87f4cb 100644
--- a/p2p/test/mock_dns_resolving_packet_socket_factory.h
+++ b/p2p/test/mock_dns_resolving_packet_socket_factory.h
@@ -17,22 +17,23 @@
#include "api/test/mock_async_dns_resolver.h"
#include "p2p/base/basic_packet_socket_factory.h"
-namespace rtc {
+namespace webrtc {
// A PacketSocketFactory implementation for tests that uses a mock DnsResolver
// and allows setting expectations on the resolver and results.
-class MockDnsResolvingPacketSocketFactory : public BasicPacketSocketFactory {
+class MockDnsResolvingPacketSocketFactory
+ : public rtc::BasicPacketSocketFactory {
public:
- using Expectations = std::function<void(webrtc::MockAsyncDnsResolver*,
- webrtc::MockAsyncDnsResolverResult*)>;
+ using Expectations =
+ std::function<void(MockAsyncDnsResolver*, MockAsyncDnsResolverResult*)>;
- explicit MockDnsResolvingPacketSocketFactory(SocketFactory* socket_factory)
- : BasicPacketSocketFactory(socket_factory) {}
+ explicit MockDnsResolvingPacketSocketFactory(
+ rtc::SocketFactory* socket_factory)
+ : rtc::BasicPacketSocketFactory(socket_factory) {}
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAsyncDnsResolver()
- override {
- std::unique_ptr<webrtc::MockAsyncDnsResolver> resolver =
- std::make_unique<webrtc::MockAsyncDnsResolver>();
+ std::unique_ptr<AsyncDnsResolverInterface> CreateAsyncDnsResolver() override {
+ std::unique_ptr<MockAsyncDnsResolver> resolver =
+ std::make_unique<MockAsyncDnsResolver>();
if (expectations_) {
expectations_(resolver.get(), &resolver_result_);
}
@@ -44,10 +45,16 @@
}
private:
- webrtc::MockAsyncDnsResolverResult resolver_result_;
+ MockAsyncDnsResolverResult resolver_result_;
Expectations expectations_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::MockDnsResolvingPacketSocketFactory;
} // namespace rtc
#endif // P2P_TEST_MOCK_DNS_RESOLVING_PACKET_SOCKET_FACTORY_H_
diff --git a/p2p/test/mock_ice_agent.h b/p2p/test/mock_ice_agent.h
index 7d25756..cd0fa93 100644
--- a/p2p/test/mock_ice_agent.h
+++ b/p2p/test/mock_ice_agent.h
@@ -19,32 +19,38 @@
#include "p2p/base/transport_description.h"
#include "test/gmock.h"
-namespace cricket {
+namespace webrtc {
-class MockIceAgent : public IceAgentInterface {
+class MockIceAgent : public cricket::IceAgentInterface {
public:
~MockIceAgent() override = default;
MOCK_METHOD(int64_t, GetLastPingSentMs, (), (override, const));
- MOCK_METHOD(IceRole, GetIceRole, (), (override, const));
+ MOCK_METHOD(cricket::IceRole, GetIceRole, (), (override, const));
MOCK_METHOD(void, OnStartedPinging, (), (override));
MOCK_METHOD(void, UpdateConnectionStates, (), (override));
MOCK_METHOD(void, UpdateState, (), (override));
MOCK_METHOD(void,
ForgetLearnedStateForConnections,
- (rtc::ArrayView<const Connection* const>),
+ (rtc::ArrayView<const cricket::Connection* const>),
(override));
- MOCK_METHOD(void, SendPingRequest, (const Connection*), (override));
+ MOCK_METHOD(void, SendPingRequest, (const cricket::Connection*), (override));
MOCK_METHOD(void,
SwitchSelectedConnection,
- (const Connection*, IceSwitchReason),
+ (const cricket::Connection*, cricket::IceSwitchReason),
(override));
MOCK_METHOD(bool,
PruneConnections,
- (rtc::ArrayView<const Connection* const>),
+ (rtc::ArrayView<const cricket::Connection* const>),
(override));
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::MockIceAgent;
} // namespace cricket
#endif // P2P_TEST_MOCK_ICE_AGENT_H_
diff --git a/p2p/test/mock_ice_controller.h b/p2p/test/mock_ice_controller.h
index d437786..ee812cd 100644
--- a/p2p/test/mock_ice_controller.h
+++ b/p2p/test/mock_ice_controller.h
@@ -18,7 +18,7 @@
#include "p2p/base/ice_controller_interface.h"
#include "test/gmock.h"
-namespace cricket {
+namespace webrtc {
class MockIceController : public cricket::IceControllerInterface {
public:
@@ -90,6 +90,13 @@
MOCK_METHOD(void, RecordIceControllerCreated, ());
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::MockIceController;
+using ::webrtc::MockIceControllerFactory;
} // namespace cricket
#endif // P2P_TEST_MOCK_ICE_CONTROLLER_H_
diff --git a/p2p/test/mock_ice_transport.h b/p2p/test/mock_ice_transport.h
index 547f2c2..c3e32e5 100644
--- a/p2p/test/mock_ice_transport.h
+++ b/p2p/test/mock_ice_transport.h
@@ -18,10 +18,10 @@
#include "p2p/base/ice_transport_internal.h"
#include "test/gmock.h"
-namespace cricket {
+namespace webrtc {
// Used in Chromium/remoting/protocol/channel_socket_adapter_unittest.cc
-class MockIceTransport : public IceTransportInternal {
+class MockIceTransport : public cricket::IceTransportInternal {
public:
MockIceTransport() {
SignalReadyToSend(this);
@@ -43,34 +43,42 @@
(cricket::IceTransportStats * ice_transport_stats),
(override));
- IceTransportState GetState() const override {
- return IceTransportState::STATE_INIT;
+ cricket::IceTransportState GetState() const override {
+ return cricket::IceTransportState::STATE_INIT;
}
- webrtc::IceTransportState GetIceTransportState() const override {
- return webrtc::IceTransportState::kNew;
+ IceTransportState GetIceTransportState() const override {
+ return IceTransportState::kNew;
}
const std::string& transport_name() const override { return transport_name_; }
int component() const override { return 0; }
- void SetIceRole(IceRole /* role */) override {}
+ void SetIceRole(cricket::IceRole /* role */) override {}
// The ufrag and pwd in `ice_params` must be set
// before candidate gathering can start.
- void SetIceParameters(const IceParameters& /* ice_params */) override {}
- void SetRemoteIceParameters(const IceParameters& /* ice_params */) override {}
- void SetRemoteIceMode(IceMode /* mode */) override {}
- void SetIceConfig(const IceConfig& config) override { ice_config_ = config; }
- const IceConfig& config() const override { return ice_config_; }
+ void SetIceParameters(
+ const cricket::IceParameters& /* ice_params */) override {}
+ void SetRemoteIceParameters(
+ const cricket::IceParameters& /* ice_params */) override {}
+ void SetRemoteIceMode(cricket::IceMode /* mode */) override {}
+ void SetIceConfig(const cricket::IceConfig& config) override {
+ ice_config_ = config;
+ }
+ const cricket::IceConfig& config() const override { return ice_config_; }
std::optional<int> GetRttEstimate() override { return std::nullopt; }
- const Connection* selected_connection() const override { return nullptr; }
- std::optional<const CandidatePair> GetSelectedCandidatePair() const override {
+ const cricket::Connection* selected_connection() const override {
+ return nullptr;
+ }
+ std::optional<const cricket::CandidatePair> GetSelectedCandidatePair()
+ const override {
return std::nullopt;
}
void MaybeStartGathering() override {}
- void AddRemoteCandidate(const Candidate& /* candidate */) override {}
- void RemoveRemoteCandidate(const Candidate& /* candidate */) override {}
+ void AddRemoteCandidate(const cricket::Candidate& /* candidate */) override {}
+ void RemoveRemoteCandidate(
+ const cricket::Candidate& /* candidate */) override {}
void RemoveAllRemoteCandidates() override {}
- IceGatheringState gathering_state() const override {
- return IceGatheringState::kIceGatheringComplete;
+ cricket::IceGatheringState gathering_state() const override {
+ return cricket::IceGatheringState::kIceGatheringComplete;
}
bool receiving() const override { return true; }
@@ -78,9 +86,15 @@
private:
std::string transport_name_;
- IceConfig ice_config_;
+ cricket::IceConfig ice_config_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::MockIceTransport;
} // namespace cricket
#endif // P2P_TEST_MOCK_ICE_TRANSPORT_H_
diff --git a/p2p/test/nat_server.cc b/p2p/test/nat_server.cc
index c9e6f87..5513a5d 100644
--- a/p2p/test/nat_server.cc
+++ b/p2p/test/nat_server.cc
@@ -22,19 +22,19 @@
#include "rtc_base/socket_adapters.h"
#include "rtc_base/socket_address.h"
-namespace rtc {
+namespace webrtc {
RouteCmp::RouteCmp(NAT* nat) : symmetric(nat->IsSymmetric()) {}
-size_t RouteCmp::operator()(const webrtc::SocketAddressPair& r) const {
+size_t RouteCmp::operator()(const SocketAddressPair& r) const {
size_t h = r.source().Hash();
if (symmetric)
h ^= r.destination().Hash();
return h;
}
-bool RouteCmp::operator()(const webrtc::SocketAddressPair& r1,
- const webrtc::SocketAddressPair& r2) const {
+bool RouteCmp::operator()(const SocketAddressPair& r1,
+ const SocketAddressPair& r2) const {
if (r1.source() < r2.source())
return true;
if (r2.source() < r1.source())
@@ -49,7 +49,7 @@
AddrCmp::AddrCmp(NAT* nat)
: use_ip(nat->FiltersIP()), use_port(nat->FiltersPort()) {}
-size_t AddrCmp::operator()(const webrtc::SocketAddress& a) const {
+size_t AddrCmp::operator()(const SocketAddress& a) const {
size_t h = 0;
if (use_ip)
h ^= webrtc::HashIP(a.ipaddr());
@@ -58,8 +58,8 @@
return h;
}
-bool AddrCmp::operator()(const webrtc::SocketAddress& a1,
- const webrtc::SocketAddress& a2) const {
+bool AddrCmp::operator()(const SocketAddress& a1,
+ const SocketAddress& a2) const {
if (use_ip && (a1.ipaddr() < a2.ipaddr()))
return true;
if (use_ip && (a2.ipaddr() < a1.ipaddr()))
@@ -73,16 +73,17 @@
// Proxy socket that will capture the external destination address intended for
// a TCP connection to the NAT server.
-class NATProxyServerSocket : public AsyncProxyServerSocket {
+class NATProxyServerSocket : public rtc::AsyncProxyServerSocket {
public:
- explicit NATProxyServerSocket(Socket* socket)
- : AsyncProxyServerSocket(socket, kNATEncodedIPv6AddressSize) {
+ explicit NATProxyServerSocket(rtc::Socket* socket)
+ : rtc::AsyncProxyServerSocket(socket,
+ webrtc::kNATEncodedIPv6AddressSize) {
BufferInput(true);
}
- void SendConnectResult(int err, const webrtc::SocketAddress& addr) override {
+ void SendConnectResult(int err, const SocketAddress& addr) override {
char code = err ? 1 : 0;
- BufferedReadAdapter::DirectSend(&code, sizeof(char));
+ rtc::BufferedReadAdapter::DirectSend(&code, sizeof(char));
}
protected:
@@ -93,13 +94,13 @@
int family = data[1];
RTC_DCHECK(family == AF_INET || family == AF_INET6);
- if ((family == AF_INET && *len < kNATEncodedIPv4AddressSize) ||
- (family == AF_INET6 && *len < kNATEncodedIPv6AddressSize)) {
+ if ((family == AF_INET && *len < webrtc::kNATEncodedIPv4AddressSize) ||
+ (family == AF_INET6 && *len < webrtc::kNATEncodedIPv6AddressSize)) {
return;
}
- webrtc::SocketAddress dest_addr;
- size_t address_length = UnpackAddressFromNAT(
+ SocketAddress dest_addr;
+ size_t address_length = webrtc::UnpackAddressFromNAT(
MakeArrayView(reinterpret_cast<const uint8_t*>(data), *len),
&dest_addr);
*len -= address_length;
@@ -116,28 +117,28 @@
}
};
-class NATProxyServer : public ProxyServer {
+class NATProxyServer : public rtc::ProxyServer {
public:
- NATProxyServer(SocketFactory* int_factory,
- const webrtc::SocketAddress& int_addr,
- SocketFactory* ext_factory,
- const webrtc::SocketAddress& ext_ip)
- : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
+ NATProxyServer(rtc::SocketFactory* int_factory,
+ const SocketAddress& int_addr,
+ rtc::SocketFactory* ext_factory,
+ const SocketAddress& ext_ip)
+ : rtc::ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected:
- AsyncProxyServerSocket* WrapSocket(Socket* socket) override {
+ rtc::AsyncProxyServerSocket* WrapSocket(rtc::Socket* socket) override {
return new NATProxyServerSocket(socket);
}
};
NATServer::NATServer(NATType type,
rtc::Thread& internal_socket_thread,
- SocketFactory* internal,
- const webrtc::SocketAddress& internal_udp_addr,
- const webrtc::SocketAddress& internal_tcp_addr,
+ rtc::SocketFactory* internal,
+ const SocketAddress& internal_udp_addr,
+ const SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
- SocketFactory* external,
- const webrtc::SocketAddress& external_ip)
+ rtc::SocketFactory* external,
+ const SocketAddress& external_ip)
: internal_socket_thread_(internal_socket_thread),
external_socket_thread_(external_socket_thread),
external_(external),
@@ -145,7 +146,8 @@
nat_ = NAT::Create(type);
internal_socket_thread_.BlockingCall([&] {
- udp_server_socket_ = AsyncUDPSocket::Create(internal, internal_udp_addr);
+ udp_server_socket_ =
+ rtc::AsyncUDPSocket::Create(internal, internal_udp_addr);
udp_server_socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
OnInternalUDPPacket(socket, packet);
@@ -171,15 +173,15 @@
delete ext_map_;
}
-void NATServer::OnInternalUDPPacket(AsyncPacketSocket* socket,
+void NATServer::OnInternalUDPPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(internal_socket_thread_.IsCurrent());
// Read the intended destination from the wire.
- webrtc::SocketAddress dest_addr;
- size_t length = UnpackAddressFromNAT(packet.payload(), &dest_addr);
+ SocketAddress dest_addr;
+ size_t length = webrtc::UnpackAddressFromNAT(packet.payload(), &dest_addr);
// Find the translation for these addresses (allocating one if necessary).
- webrtc::SocketAddressPair route(packet.source_address(), dest_addr);
+ SocketAddressPair route(packet.source_address(), dest_addr);
InternalMap::iterator iter = int_map_->find(route);
if (iter == int_map_->end()) {
Translate(route);
@@ -197,10 +199,10 @@
iter->second->socket->SendTo(buf + length, size - length, dest_addr, options);
}
-void NATServer::OnExternalUDPPacket(AsyncPacketSocket* socket,
+void NATServer::OnExternalUDPPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(external_socket_thread_.IsCurrent());
- webrtc::SocketAddress local_addr = socket->GetLocalAddress();
+ SocketAddress local_addr = socket->GetLocalAddress();
// Find the translation for this addresses.
ExternalMap::iterator iter = ext_map_->find(local_addr);
@@ -217,9 +219,10 @@
// Forward this packet to the internal address.
// First prepend the address in a quasi-STUN format.
std::unique_ptr<char[]> real_buf(
- new char[packet.payload().size() + kNATEncodedIPv6AddressSize]);
- size_t addrlength = PackAddressForNAT(
- real_buf.get(), packet.payload().size() + kNATEncodedIPv6AddressSize,
+ new char[packet.payload().size() + webrtc::kNATEncodedIPv6AddressSize]);
+ size_t addrlength = webrtc::PackAddressForNAT(
+ real_buf.get(),
+ packet.payload().size() + webrtc::kNATEncodedIPv6AddressSize,
packet.source_address());
// Copy the data part after the address.
rtc::PacketOptions options;
@@ -230,9 +233,10 @@
iter->second->route.source(), options);
}
-void NATServer::Translate(const webrtc::SocketAddressPair& route) {
+void NATServer::Translate(const SocketAddressPair& route) {
external_socket_thread_.BlockingCall([&] {
- AsyncUDPSocket* socket = AsyncUDPSocket::Create(external_, external_ip_);
+ rtc::AsyncUDPSocket* socket =
+ rtc::AsyncUDPSocket::Create(external_, external_ip_);
if (!socket) {
RTC_LOG(LS_ERROR) << "Couldn't find a free port!";
@@ -250,12 +254,12 @@
}
bool NATServer::ShouldFilterOut(TransEntry* entry,
- const webrtc::SocketAddress& ext_addr) {
+ const SocketAddress& ext_addr) {
return entry->AllowlistContains(ext_addr);
}
-NATServer::TransEntry::TransEntry(const webrtc::SocketAddressPair& r,
- AsyncUDPSocket* s,
+NATServer::TransEntry::TransEntry(const SocketAddressPair& r,
+ rtc::AsyncUDPSocket* s,
NAT* nat)
: route(r), socket(s) {
allowlist = new AddressSet(AddrCmp(nat));
@@ -266,15 +270,14 @@
delete socket;
}
-void NATServer::TransEntry::AllowlistInsert(const webrtc::SocketAddress& addr) {
- webrtc::MutexLock lock(&mutex_);
+void NATServer::TransEntry::AllowlistInsert(const SocketAddress& addr) {
+ MutexLock lock(&mutex_);
allowlist->insert(addr);
}
-bool NATServer::TransEntry::AllowlistContains(
- const webrtc::SocketAddress& ext_addr) {
- webrtc::MutexLock lock(&mutex_);
+bool NATServer::TransEntry::AllowlistContains(const SocketAddress& ext_addr) {
+ MutexLock lock(&mutex_);
return allowlist->find(ext_addr) == allowlist->end();
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/p2p/test/nat_server.h b/p2p/test/nat_server.h
index ecdd70a..7ae038c 100644
--- a/p2p/test/nat_server.h
+++ b/p2p/test/nat_server.h
@@ -22,16 +22,16 @@
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/thread.h"
-namespace rtc {
+namespace webrtc {
// Change how routes (socketaddress pairs) are compared based on the type of
// NAT. The NAT server maintains a hashtable of the routes that it knows
// about. So these affect which routes are treated the same.
struct RouteCmp {
explicit RouteCmp(NAT* nat);
- size_t operator()(const webrtc::SocketAddressPair& r) const;
- bool operator()(const webrtc::SocketAddressPair& r1,
- const webrtc::SocketAddressPair& r2) const;
+ size_t operator()(const SocketAddressPair& r) const;
+ bool operator()(const SocketAddressPair& r1,
+ const SocketAddressPair& r2) const;
bool symmetric;
};
@@ -39,9 +39,8 @@
// Changes how addresses are compared based on the filtering rules of the NAT.
struct AddrCmp {
explicit AddrCmp(NAT* nat);
- size_t operator()(const webrtc::SocketAddress& r) const;
- bool operator()(const webrtc::SocketAddress& r1,
- const webrtc::SocketAddress& r2) const;
+ size_t operator()(const SocketAddress& r) const;
+ bool operator()(const SocketAddress& r1, const SocketAddress& r2) const;
bool use_ip;
bool use_port;
@@ -63,70 +62,78 @@
public:
NATServer(NATType type,
rtc::Thread& internal_socket_thread,
- SocketFactory* internal,
- const webrtc::SocketAddress& internal_udp_addr,
- const webrtc::SocketAddress& internal_tcp_addr,
+ rtc::SocketFactory* internal,
+ const SocketAddress& internal_udp_addr,
+ const SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
- SocketFactory* external,
- const webrtc::SocketAddress& external_ip);
+ rtc::SocketFactory* external,
+ const SocketAddress& external_ip);
~NATServer();
NATServer(const NATServer&) = delete;
NATServer& operator=(const NATServer&) = delete;
- webrtc::SocketAddress internal_udp_address() const {
+ SocketAddress internal_udp_address() const {
return udp_server_socket_->GetLocalAddress();
}
- webrtc::SocketAddress internal_tcp_address() const {
+ SocketAddress internal_tcp_address() const {
return tcp_proxy_server_->GetServerAddress();
}
// Packets received on one of the networks.
- void OnInternalUDPPacket(AsyncPacketSocket* socket,
+ void OnInternalUDPPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnExternalUDPPacket(AsyncPacketSocket* socket,
+ void OnExternalUDPPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
private:
- typedef std::set<webrtc::SocketAddress, AddrCmp> AddressSet;
+ typedef std::set<SocketAddress, AddrCmp> AddressSet;
/* Records a translation and the associated external socket. */
struct TransEntry {
- TransEntry(const webrtc::SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat);
+ TransEntry(const SocketAddressPair& r, rtc::AsyncUDPSocket* s, NAT* nat);
~TransEntry();
- void AllowlistInsert(const webrtc::SocketAddress& addr);
- bool AllowlistContains(const webrtc::SocketAddress& ext_addr);
+ void AllowlistInsert(const SocketAddress& addr);
+ bool AllowlistContains(const SocketAddress& ext_addr);
- webrtc::SocketAddressPair route;
- AsyncUDPSocket* socket;
+ SocketAddressPair route;
+ rtc::AsyncUDPSocket* socket;
AddressSet* allowlist;
- webrtc::Mutex mutex_;
+ Mutex mutex_;
};
- typedef std::map<webrtc::SocketAddressPair, TransEntry*, RouteCmp>
- InternalMap;
- typedef std::map<webrtc::SocketAddress, TransEntry*> ExternalMap;
+ typedef std::map<SocketAddressPair, TransEntry*, RouteCmp> InternalMap;
+ typedef std::map<SocketAddress, TransEntry*> ExternalMap;
/* Creates a new entry that translates the given route. */
- void Translate(const webrtc::SocketAddressPair& route);
+ void Translate(const SocketAddressPair& route);
/* Determines whether the NAT would filter out a packet from this address. */
- bool ShouldFilterOut(TransEntry* entry,
- const webrtc::SocketAddress& ext_addr);
+ bool ShouldFilterOut(TransEntry* entry, const SocketAddress& ext_addr);
NAT* nat_;
rtc::Thread& internal_socket_thread_;
rtc::Thread& external_socket_thread_;
- SocketFactory* external_;
- webrtc::SocketAddress external_ip_;
- AsyncUDPSocket* udp_server_socket_;
- ProxyServer* tcp_proxy_server_;
+ rtc::SocketFactory* external_;
+ SocketAddress external_ip_;
+ rtc::AsyncUDPSocket* udp_server_socket_;
+ rtc::ProxyServer* tcp_proxy_server_;
InternalMap* int_map_;
ExternalMap* ext_map_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AddrCmp;
+using ::webrtc::NAT_SERVER_TCP_PORT;
+using ::webrtc::NAT_SERVER_UDP_PORT;
+using ::webrtc::NATServer;
+using ::webrtc::RouteCmp;
} // namespace rtc
#endif // P2P_TEST_NAT_SERVER_H_
diff --git a/p2p/test/nat_socket_factory.cc b/p2p/test/nat_socket_factory.cc
index 21f55ae..04bd045 100644
--- a/p2p/test/nat_socket_factory.cc
+++ b/p2p/test/nat_socket_factory.cc
@@ -18,15 +18,15 @@
#include "rtc_base/logging.h"
#include "rtc_base/virtual_socket_server.h"
-namespace rtc {
+namespace webrtc {
// Packs the given socketaddress into the buffer in buf, in the quasi-STUN
// format that the natserver uses.
// Returns 0 if an invalid address is passed.
size_t PackAddressForNAT(char* buf,
size_t buf_size,
- const webrtc::SocketAddress& remote_addr) {
- const webrtc::IPAddress& ip = remote_addr.ipaddr();
+ const SocketAddress& remote_addr) {
+ const IPAddress& ip = remote_addr.ipaddr();
int family = ip.family();
buf[0] = 0;
buf[1] = family;
@@ -51,7 +51,7 @@
// quasi-STUN format. Returns the length of the address (i.e., the offset into
// data where the original packet starts).
size_t UnpackAddressFromNAT(rtc::ArrayView<const uint8_t> buf,
- webrtc::SocketAddress* remote_addr) {
+ SocketAddress* remote_addr) {
RTC_CHECK(buf.size() >= 8);
RTC_DCHECK(buf.data()[0] == 0);
int family = buf[1];
@@ -59,19 +59,19 @@
*(reinterpret_cast<const uint16_t*>(&buf.data()[2])));
if (family == AF_INET) {
const in_addr* v4addr = reinterpret_cast<const in_addr*>(&buf.data()[4]);
- *remote_addr = webrtc::SocketAddress(webrtc::IPAddress(*v4addr), port);
+ *remote_addr = SocketAddress(IPAddress(*v4addr), port);
return kNATEncodedIPv4AddressSize;
} else if (family == AF_INET6) {
RTC_DCHECK(buf.size() >= 20);
const in6_addr* v6addr = reinterpret_cast<const in6_addr*>(&buf.data()[4]);
- *remote_addr = webrtc::SocketAddress(webrtc::IPAddress(*v6addr), port);
+ *remote_addr = SocketAddress(IPAddress(*v6addr), port);
return kNATEncodedIPv6AddressSize;
}
return 0U;
}
// NATSocket
-class NATSocket : public Socket, public sigslot::has_slots<> {
+class NATSocket : public rtc::Socket, public sigslot::has_slots<> {
public:
explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
: sf_(sf),
@@ -82,15 +82,15 @@
~NATSocket() override { delete socket_; }
- webrtc::SocketAddress GetLocalAddress() const override {
- return (socket_) ? socket_->GetLocalAddress() : webrtc::SocketAddress();
+ SocketAddress GetLocalAddress() const override {
+ return (socket_) ? socket_->GetLocalAddress() : SocketAddress();
}
- webrtc::SocketAddress GetRemoteAddress() const override {
+ SocketAddress GetRemoteAddress() const override {
return remote_addr_; // will be NIL if not connected
}
- int Bind(const webrtc::SocketAddress& addr) override {
+ int Bind(const SocketAddress& addr) override {
if (socket_) { // already bound, bubble up error
return -1;
}
@@ -98,13 +98,12 @@
return BindInternal(addr);
}
- int Connect(const webrtc::SocketAddress& addr) override {
+ int Connect(const SocketAddress& addr) override {
int result = 0;
// If we're not already bound (meaning `socket_` is null), bind to ANY
// address.
if (!socket_) {
- result =
- BindInternal(webrtc::SocketAddress(webrtc::GetAnyIP(family_), 0));
+ result = BindInternal(SocketAddress(webrtc::GetAnyIP(family_), 0));
if (result < 0) {
return result;
}
@@ -130,7 +129,7 @@
int SendTo(const void* data,
size_t size,
- const webrtc::SocketAddress& addr) override {
+ const SocketAddress& addr) override {
RTC_DCHECK(!connected_ || addr == remote_addr_);
if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
return socket_->SendTo(data, size, addr);
@@ -150,13 +149,13 @@
}
int Recv(void* data, size_t size, int64_t* timestamp) override {
- webrtc::SocketAddress addr;
+ SocketAddress addr;
return RecvFrom(data, size, &addr, timestamp);
}
int RecvFrom(void* data,
size_t size,
- webrtc::SocketAddress* out_addr,
+ SocketAddress* out_addr,
int64_t* timestamp) override {
if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
return socket_->RecvFrom(data, size, out_addr, timestamp);
@@ -166,16 +165,15 @@
buf_.EnsureCapacity(size + kNATEncodedIPv6AddressSize);
// Read the packet from the socket.
- Socket::ReceiveBuffer receive_buffer(buf_);
+ rtc::Socket::ReceiveBuffer receive_buffer(buf_);
int result = socket_->RecvFrom(receive_buffer);
if (result >= 0) {
RTC_DCHECK(receive_buffer.source_address == server_addr_);
*timestamp =
- receive_buffer.arrival_time.value_or(webrtc::Timestamp::Micros(0))
- .us();
+ receive_buffer.arrival_time.value_or(Timestamp::Micros(0)).us();
// Decode the wire packet into the actual results.
- webrtc::SocketAddress real_remote_addr;
+ SocketAddress real_remote_addr;
size_t addrlength = UnpackAddressFromNAT(buf_, &real_remote_addr);
memcpy(data, buf_.data() + addrlength, result - addrlength);
@@ -200,7 +198,7 @@
result = socket_->Close();
if (result >= 0) {
connected_ = false;
- remote_addr_ = webrtc::SocketAddress();
+ remote_addr_ = SocketAddress();
delete socket_;
socket_ = nullptr;
}
@@ -209,7 +207,7 @@
}
int Listen(int backlog) override { return socket_->Listen(backlog); }
- Socket* Accept(webrtc::SocketAddress* paddr) override {
+ rtc::Socket* Accept(SocketAddress* paddr) override {
return socket_->Accept(paddr);
}
int GetError() const override {
@@ -232,7 +230,7 @@
return socket_ ? socket_->SetOption(opt, value) : -1;
}
- void OnConnectEvent(Socket* socket) {
+ void OnConnectEvent(rtc::Socket* socket) {
// If we're NATed, we need to send a message with the real addr to use.
RTC_DCHECK(socket == socket_);
if (server_addr_.IsNil()) {
@@ -242,7 +240,7 @@
SendConnectRequest();
}
}
- void OnReadEvent(Socket* socket) {
+ void OnReadEvent(rtc::Socket* socket) {
// If we're NATed, we need to process the connect reply.
RTC_DCHECK(socket == socket_);
if (type_ == SOCK_STREAM && !server_addr_.IsNil() && !connected_) {
@@ -251,17 +249,17 @@
SignalReadEvent(this);
}
}
- void OnWriteEvent(Socket* socket) {
+ void OnWriteEvent(rtc::Socket* socket) {
RTC_DCHECK(socket == socket_);
SignalWriteEvent(this);
}
- void OnCloseEvent(Socket* socket, int error) {
+ void OnCloseEvent(rtc::Socket* socket, int error) {
RTC_DCHECK(socket == socket_);
SignalCloseEvent(this, error);
}
private:
- int BindInternal(const webrtc::SocketAddress& addr) {
+ int BindInternal(const SocketAddress& addr) {
RTC_DCHECK(!socket_);
int result;
@@ -305,31 +303,31 @@
int family_;
int type_;
bool connected_;
- webrtc::SocketAddress remote_addr_;
- webrtc::SocketAddress server_addr_; // address of the NAT server
- Socket* socket_;
+ SocketAddress remote_addr_;
+ SocketAddress server_addr_; // address of the NAT server
+ rtc::Socket* socket_;
// Need to hold error in case it occurs before the socket is created.
int error_ = 0;
Buffer buf_;
};
// NATSocketFactory
-NATSocketFactory::NATSocketFactory(SocketFactory* factory,
- const webrtc::SocketAddress& nat_udp_addr,
- const webrtc::SocketAddress& nat_tcp_addr)
+NATSocketFactory::NATSocketFactory(rtc::SocketFactory* factory,
+ const SocketAddress& nat_udp_addr,
+ const SocketAddress& nat_tcp_addr)
: factory_(factory),
nat_udp_addr_(nat_udp_addr),
nat_tcp_addr_(nat_tcp_addr) {}
-Socket* NATSocketFactory::CreateSocket(int family, int type) {
+rtc::Socket* NATSocketFactory::CreateSocket(int family, int type) {
return new NATSocket(this, family, type);
}
-Socket* NATSocketFactory::CreateInternalSocket(
+rtc::Socket* NATSocketFactory::CreateInternalSocket(
int family,
int type,
- const webrtc::SocketAddress& local_addr,
- webrtc::SocketAddress* nat_addr) {
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) {
if (type == SOCK_STREAM) {
*nat_addr = nat_tcp_addr_;
} else {
@@ -339,17 +337,17 @@
}
// NATSocketServer
-NATSocketServer::NATSocketServer(SocketServer* server)
+NATSocketServer::NATSocketServer(rtc::SocketServer* server)
: server_(server), msg_queue_(nullptr) {}
NATSocketServer::Translator* NATSocketServer::GetTranslator(
- const webrtc::SocketAddress& ext_ip) {
+ const SocketAddress& ext_ip) {
return nats_.Get(ext_ip);
}
NATSocketServer::Translator* NATSocketServer::AddTranslator(
- const webrtc::SocketAddress& ext_ip,
- const webrtc::SocketAddress& int_ip,
+ const SocketAddress& ext_ip,
+ const SocketAddress& int_ip,
NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
@@ -359,21 +357,20 @@
ext_ip, new Translator(this, type, int_ip, *msg_queue_, server_, ext_ip));
}
-void NATSocketServer::RemoveTranslator(const webrtc::SocketAddress& ext_ip) {
+void NATSocketServer::RemoveTranslator(const SocketAddress& ext_ip) {
nats_.Remove(ext_ip);
}
-Socket* NATSocketServer::CreateSocket(int family, int type) {
+rtc::Socket* NATSocketServer::CreateSocket(int family, int type) {
return new NATSocket(this, family, type);
}
-void NATSocketServer::SetMessageQueue(Thread* queue) {
+void NATSocketServer::SetMessageQueue(rtc::Thread* queue) {
msg_queue_ = queue;
server_->SetMessageQueue(queue);
}
-bool NATSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
- bool process_io) {
+bool NATSocketServer::Wait(TimeDelta max_wait_duration, bool process_io) {
return server_->Wait(max_wait_duration, process_io);
}
@@ -381,12 +378,12 @@
server_->WakeUp();
}
-Socket* NATSocketServer::CreateInternalSocket(
+rtc::Socket* NATSocketServer::CreateInternalSocket(
int family,
int type,
- const webrtc::SocketAddress& local_addr,
- webrtc::SocketAddress* nat_addr) {
- Socket* socket = nullptr;
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) {
+ rtc::Socket* socket = nullptr;
Translator* nat = nats_.FindClient(local_addr);
if (nat) {
socket = nat->internal_factory()->CreateSocket(family, type);
@@ -401,15 +398,15 @@
// NATSocketServer::Translator
NATSocketServer::Translator::Translator(NATSocketServer* server,
NATType type,
- const webrtc::SocketAddress& int_ip,
- Thread& external_socket_thread,
- SocketFactory* ext_factory,
- const webrtc::SocketAddress& ext_ip)
+ const SocketAddress& int_ip,
+ rtc::Thread& external_socket_thread,
+ rtc::SocketFactory* ext_factory,
+ const SocketAddress& ext_ip)
: server_(server) {
// Create a new private network, and a NATServer running on the private
// network that bridges to the external network. Also tell the private
// network to use the same message queue as us.
- internal_server_ = std::make_unique<VirtualSocketServer>();
+ internal_server_ = std::make_unique<rtc::VirtualSocketServer>();
internal_server_->SetMessageQueue(server_->queue());
nat_server_ = std::make_unique<NATServer>(
type, *server->queue(), internal_server_.get(), int_ip, int_ip,
@@ -421,13 +418,13 @@
}
NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
- const webrtc::SocketAddress& ext_ip) {
+ const SocketAddress& ext_ip) {
return nats_.Get(ext_ip);
}
NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
- const webrtc::SocketAddress& ext_ip,
- const webrtc::SocketAddress& int_ip,
+ const SocketAddress& ext_ip,
+ const SocketAddress& int_ip,
NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
@@ -438,13 +435,12 @@
*server_->queue(), server_, ext_ip));
}
void NATSocketServer::Translator::RemoveTranslator(
- const webrtc::SocketAddress& ext_ip) {
+ const SocketAddress& ext_ip) {
nats_.Remove(ext_ip);
RemoveClient(ext_ip);
}
-bool NATSocketServer::Translator::AddClient(
- const webrtc::SocketAddress& int_ip) {
+bool NATSocketServer::Translator::AddClient(const SocketAddress& int_ip) {
// Fail if a client already exists with this internal address.
if (clients_.find(int_ip) != clients_.end())
return false;
@@ -453,16 +449,15 @@
return true;
}
-void NATSocketServer::Translator::RemoveClient(
- const webrtc::SocketAddress& int_ip) {
- std::set<webrtc::SocketAddress>::iterator it = clients_.find(int_ip);
+void NATSocketServer::Translator::RemoveClient(const SocketAddress& int_ip) {
+ std::set<SocketAddress>::iterator it = clients_.find(int_ip);
if (it != clients_.end()) {
clients_.erase(it);
}
}
NATSocketServer::Translator* NATSocketServer::Translator::FindClient(
- const webrtc::SocketAddress& int_ip) {
+ const SocketAddress& int_ip) {
// See if we have the requested IP, or any of our children do.
return (clients_.find(int_ip) != clients_.end()) ? this
: nats_.FindClient(int_ip);
@@ -476,20 +471,19 @@
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
- const webrtc::SocketAddress& ext_ip) {
+ const SocketAddress& ext_ip) {
TranslatorMap::iterator it = find(ext_ip);
return (it != end()) ? it->second : nullptr;
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
- const webrtc::SocketAddress& ext_ip,
+ const SocketAddress& ext_ip,
Translator* nat) {
(*this)[ext_ip] = nat;
return nat;
}
-void NATSocketServer::TranslatorMap::Remove(
- const webrtc::SocketAddress& ext_ip) {
+void NATSocketServer::TranslatorMap::Remove(const SocketAddress& ext_ip) {
TranslatorMap::iterator it = find(ext_ip);
if (it != end()) {
delete it->second;
@@ -498,7 +492,7 @@
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
- const webrtc::SocketAddress& int_ip) {
+ const SocketAddress& int_ip) {
Translator* nat = nullptr;
for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
nat = it->second->FindClient(int_ip);
@@ -506,4 +500,4 @@
return nat;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/p2p/test/nat_socket_factory.h b/p2p/test/nat_socket_factory.h
index f46c76e..4a4d712 100644
--- a/p2p/test/nat_socket_factory.h
+++ b/p2p/test/nat_socket_factory.h
@@ -28,7 +28,7 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/thread.h"
-namespace rtc {
+namespace webrtc {
const size_t kNATEncodedIPv4AddressSize = 8U;
const size_t kNATEncodedIPv6AddressSize = 20U;
@@ -37,37 +37,38 @@
class NATInternalSocketFactory {
public:
virtual ~NATInternalSocketFactory() {}
- virtual Socket* CreateInternalSocket(int family,
- int type,
- const webrtc::SocketAddress& local_addr,
- webrtc::SocketAddress* nat_addr) = 0;
+ virtual rtc::Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) = 0;
};
// Creates sockets that will send all traffic through a NAT, using an existing
// NATServer instance running at nat_addr. The actual data is sent using sockets
// from a socket factory, given to the constructor.
-class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
+class NATSocketFactory : public rtc::SocketFactory,
+ public NATInternalSocketFactory {
public:
- NATSocketFactory(SocketFactory* factory,
- const webrtc::SocketAddress& nat_udp_addr,
- const webrtc::SocketAddress& nat_tcp_addr);
+ NATSocketFactory(rtc::SocketFactory* factory,
+ const SocketAddress& nat_udp_addr,
+ const SocketAddress& nat_tcp_addr);
NATSocketFactory(const NATSocketFactory&) = delete;
NATSocketFactory& operator=(const NATSocketFactory&) = delete;
// SocketFactory implementation
- Socket* CreateSocket(int family, int type) override;
+ rtc::Socket* CreateSocket(int family, int type) override;
// NATInternalSocketFactory implementation
- Socket* CreateInternalSocket(int family,
- int type,
- const webrtc::SocketAddress& local_addr,
- webrtc::SocketAddress* nat_addr) override;
+ rtc::Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) override;
private:
- SocketFactory* factory_;
- webrtc::SocketAddress nat_udp_addr_;
- webrtc::SocketAddress nat_tcp_addr_;
+ rtc::SocketFactory* factory_;
+ SocketAddress nat_udp_addr_;
+ SocketAddress nat_tcp_addr_;
};
// Creates sockets that will send traffic through a NAT depending on what
@@ -85,18 +86,19 @@
// ss->GetTranslator("99.99.99.99")->AddClient("10.0.0.3");
// ss->GetTranslator("99.99.99.99")->GetTranslator("10.0.0.2")->
// AddClient("192.168.1.2");
-class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
+class NATSocketServer : public rtc::SocketServer,
+ public NATInternalSocketFactory {
public:
class Translator;
// holds a list of NATs
- class TranslatorMap : private std::map<webrtc::SocketAddress, Translator*> {
+ class TranslatorMap : private std::map<SocketAddress, Translator*> {
public:
~TranslatorMap();
- Translator* Get(const webrtc::SocketAddress& ext_ip);
- Translator* Add(const webrtc::SocketAddress& ext_ip, Translator*);
- void Remove(const webrtc::SocketAddress& ext_ip);
- Translator* FindClient(const webrtc::SocketAddress& int_ip);
+ Translator* Get(const SocketAddress& ext_ip);
+ Translator* Add(const SocketAddress& ext_ip, Translator*);
+ void Remove(const SocketAddress& ext_ip);
+ Translator* FindClient(const SocketAddress& int_ip);
};
// a specific NAT
@@ -104,79 +106,91 @@
public:
Translator(NATSocketServer* server,
NATType type,
- const webrtc::SocketAddress& int_addr,
- Thread& external_socket_thread,
- SocketFactory* ext_factory,
- const webrtc::SocketAddress& ext_addr);
+ const SocketAddress& int_addr,
+ rtc::Thread& external_socket_thread,
+ rtc::SocketFactory* ext_factory,
+ const SocketAddress& ext_addr);
~Translator();
- SocketFactory* internal_factory() { return internal_server_.get(); }
- webrtc::SocketAddress internal_udp_address() const {
+ rtc::SocketFactory* internal_factory() { return internal_server_.get(); }
+ SocketAddress internal_udp_address() const {
return nat_server_->internal_udp_address();
}
- webrtc::SocketAddress internal_tcp_address() const {
- return webrtc::SocketAddress(); // nat_server_->internal_tcp_address();
+ SocketAddress internal_tcp_address() const {
+ return SocketAddress(); // nat_server_->internal_tcp_address();
}
- Translator* GetTranslator(const webrtc::SocketAddress& ext_ip);
- Translator* AddTranslator(const webrtc::SocketAddress& ext_ip,
- const webrtc::SocketAddress& int_ip,
+ Translator* GetTranslator(const SocketAddress& ext_ip);
+ Translator* AddTranslator(const SocketAddress& ext_ip,
+ const SocketAddress& int_ip,
NATType type);
- void RemoveTranslator(const webrtc::SocketAddress& ext_ip);
+ void RemoveTranslator(const SocketAddress& ext_ip);
- bool AddClient(const webrtc::SocketAddress& int_ip);
- void RemoveClient(const webrtc::SocketAddress& int_ip);
+ bool AddClient(const SocketAddress& int_ip);
+ void RemoveClient(const SocketAddress& int_ip);
// Looks for the specified client in this or a child NAT.
- Translator* FindClient(const webrtc::SocketAddress& int_ip);
+ Translator* FindClient(const SocketAddress& int_ip);
private:
NATSocketServer* server_;
- std::unique_ptr<SocketServer> internal_server_;
+ std::unique_ptr<rtc::SocketServer> internal_server_;
std::unique_ptr<NATServer> nat_server_;
TranslatorMap nats_;
- std::set<webrtc::SocketAddress> clients_;
+ std::set<SocketAddress> clients_;
};
- explicit NATSocketServer(SocketServer* ss);
+ explicit NATSocketServer(rtc::SocketServer* ss);
NATSocketServer(const NATSocketServer&) = delete;
NATSocketServer& operator=(const NATSocketServer&) = delete;
- SocketServer* socketserver() { return server_; }
- Thread* queue() { return msg_queue_; }
+ rtc::SocketServer* socketserver() { return server_; }
+ rtc::Thread* queue() { return msg_queue_; }
- Translator* GetTranslator(const webrtc::SocketAddress& ext_ip);
- Translator* AddTranslator(const webrtc::SocketAddress& ext_ip,
- const webrtc::SocketAddress& int_ip,
+ Translator* GetTranslator(const SocketAddress& ext_ip);
+ Translator* AddTranslator(const SocketAddress& ext_ip,
+ const SocketAddress& int_ip,
NATType type);
- void RemoveTranslator(const webrtc::SocketAddress& ext_ip);
+ void RemoveTranslator(const SocketAddress& ext_ip);
// SocketServer implementation
- Socket* CreateSocket(int family, int type) override;
+ rtc::Socket* CreateSocket(int family, int type) override;
- void SetMessageQueue(Thread* queue) override;
- bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
+ void SetMessageQueue(rtc::Thread* queue) override;
+ bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
// NATInternalSocketFactory implementation
- Socket* CreateInternalSocket(int family,
- int type,
- const webrtc::SocketAddress& local_addr,
- webrtc::SocketAddress* nat_addr) override;
+ rtc::Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) override;
private:
- SocketServer* server_;
- Thread* msg_queue_;
+ rtc::SocketServer* server_;
+ rtc::Thread* msg_queue_;
TranslatorMap nats_;
};
// Free-standing NAT helper functions.
size_t PackAddressForNAT(char* buf,
size_t buf_size,
- const webrtc::SocketAddress& remote_addr);
+ const SocketAddress& remote_addr);
size_t UnpackAddressFromNAT(rtc::ArrayView<const uint8_t> buf,
- webrtc::SocketAddress* remote_addr);
+ SocketAddress* remote_addr);
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::kNATEncodedIPv4AddressSize;
+using ::webrtc::kNATEncodedIPv6AddressSize;
+using ::webrtc::NATInternalSocketFactory;
+using ::webrtc::NATSocketFactory;
+using ::webrtc::NATSocketServer;
+using ::webrtc::PackAddressForNAT;
+using ::webrtc::UnpackAddressFromNAT;
} // namespace rtc
#endif // P2P_TEST_NAT_SOCKET_FACTORY_H_
diff --git a/p2p/test/nat_types.cc b/p2p/test/nat_types.cc
index 250ea22..6fbc973 100644
--- a/p2p/test/nat_types.cc
+++ b/p2p/test/nat_types.cc
@@ -12,7 +12,7 @@
#include "rtc_base/checks.h"
-namespace rtc {
+namespace webrtc {
class SymmetricNAT : public NAT {
public:
@@ -58,4 +58,4 @@
}
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/p2p/test/nat_types.h b/p2p/test/nat_types.h
index 7f32566..7ed5c40 100644
--- a/p2p/test/nat_types.h
+++ b/p2p/test/nat_types.h
@@ -11,7 +11,7 @@
#ifndef P2P_TEST_NAT_TYPES_H_
#define P2P_TEST_NAT_TYPES_H_
-namespace rtc {
+namespace webrtc {
/* Identifies each type of NAT that can be simulated. */
enum NATType {
@@ -42,6 +42,17 @@
static NAT* Create(NATType type);
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::NAT;
+using ::webrtc::NAT_ADDR_RESTRICTED;
+using ::webrtc::NAT_OPEN_CONE;
+using ::webrtc::NAT_PORT_RESTRICTED;
+using ::webrtc::NAT_SYMMETRIC;
+using ::webrtc::NATType;
} // namespace rtc
#endif // P2P_TEST_NAT_TYPES_H_
diff --git a/p2p/test/nat_unittest.cc b/p2p/test/nat_unittest.cc
index e39620f..e49cbef 100644
--- a/p2p/test/nat_unittest.cc
+++ b/p2p/test/nat_unittest.cc
@@ -70,7 +70,7 @@
const webrtc::SocketAddress& internal_addr,
SocketServer* external,
const webrtc::SocketAddress external_addrs[4],
- NATType nat_type,
+ webrtc::NATType nat_type,
bool exp_same) {
Thread th_int(internal);
Thread th_ext(external);
@@ -80,10 +80,10 @@
webrtc::SocketAddress server_addr = internal_addr;
server_addr.SetPort(0); // Auto-select a port
- NATServer* nat =
- new NATServer(nat_type, th_int, internal, server_addr, server_addr,
- th_ext, external, external_addrs[0]);
- NATSocketFactory* natsf = new NATSocketFactory(
+ webrtc::NATServer* nat =
+ new webrtc::NATServer(nat_type, th_int, internal, server_addr,
+ server_addr, th_ext, external, external_addrs[0]);
+ webrtc::NATSocketFactory* natsf = new webrtc::NATSocketFactory(
internal, nat->internal_udp_address(), nat->internal_tcp_address());
webrtc::TestClient* in;
@@ -131,7 +131,7 @@
const webrtc::SocketAddress& internal_addr,
SocketServer* external,
const webrtc::SocketAddress external_addrs[4],
- NATType nat_type,
+ webrtc::NATType nat_type,
bool filter_ip,
bool filter_port) {
Thread th_int(internal);
@@ -141,10 +141,10 @@
server_addr.SetPort(0); // Auto-select a port
th_int.Start();
th_ext.Start();
- NATServer* nat =
- new NATServer(nat_type, th_int, internal, server_addr, server_addr,
- th_ext, external, external_addrs[0]);
- NATSocketFactory* natsf = new NATSocketFactory(
+ webrtc::NATServer* nat =
+ new webrtc::NATServer(nat_type, th_int, internal, server_addr,
+ server_addr, th_ext, external, external_addrs[0]);
+ webrtc::NATSocketFactory* natsf = new webrtc::NATSocketFactory(
internal, nat->internal_udp_address(), nat->internal_tcp_address());
webrtc::TestClient* in = nullptr;
@@ -193,14 +193,14 @@
const webrtc::SocketAddress& internal_addr,
SocketServer* external,
const webrtc::SocketAddress external_addrs[4]) {
- TestSend(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
- true);
TestSend(internal, internal_addr, external, external_addrs,
- NAT_ADDR_RESTRICTED, true);
+ webrtc::NAT_OPEN_CONE, true);
TestSend(internal, internal_addr, external, external_addrs,
- NAT_PORT_RESTRICTED, true);
- TestSend(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
- false);
+ webrtc::NAT_ADDR_RESTRICTED, true);
+ TestSend(internal, internal_addr, external, external_addrs,
+ webrtc::NAT_PORT_RESTRICTED, true);
+ TestSend(internal, internal_addr, external, external_addrs,
+ webrtc::NAT_SYMMETRIC, false);
}
// Tests that NATServer filters packets properly.
@@ -208,14 +208,14 @@
const webrtc::SocketAddress& internal_addr,
SocketServer* external,
const webrtc::SocketAddress external_addrs[4]) {
- TestRecv(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
- false, false);
TestRecv(internal, internal_addr, external, external_addrs,
- NAT_ADDR_RESTRICTED, true, false);
+ webrtc::NAT_OPEN_CONE, false, false);
TestRecv(internal, internal_addr, external, external_addrs,
- NAT_PORT_RESTRICTED, true, true);
- TestRecv(internal, internal_addr, external, external_addrs, NAT_SYMMETRIC,
- true, true);
+ webrtc::NAT_ADDR_RESTRICTED, true, false);
+ TestRecv(internal, internal_addr, external, external_addrs,
+ webrtc::NAT_PORT_RESTRICTED, true, true);
+ TestRecv(internal, internal_addr, external, external_addrs,
+ webrtc::NAT_SYMMETRIC, true, true);
}
bool TestConnectivity(const webrtc::SocketAddress& src,
@@ -357,17 +357,17 @@
ext_vss_(new TestVirtualSocketServer()),
int_thread_(new Thread(int_vss_.get())),
ext_thread_(new Thread(ext_vss_.get())),
- nat_(new NATServer(NAT_OPEN_CONE,
- *int_thread_,
- int_vss_.get(),
- int_addr_,
- int_addr_,
- *ext_thread_,
- ext_vss_.get(),
- ext_addr_)),
- natsf_(new NATSocketFactory(int_vss_.get(),
- nat_->internal_udp_address(),
- nat_->internal_tcp_address())) {
+ nat_(new webrtc::NATServer(webrtc::NAT_OPEN_CONE,
+ *int_thread_,
+ int_vss_.get(),
+ int_addr_,
+ int_addr_,
+ *ext_thread_,
+ ext_vss_.get(),
+ ext_addr_)),
+ natsf_(new webrtc::NATSocketFactory(int_vss_.get(),
+ nat_->internal_udp_address(),
+ nat_->internal_tcp_address())) {
int_thread_->Start();
ext_thread_->Start();
}
@@ -392,8 +392,8 @@
std::unique_ptr<TestVirtualSocketServer> ext_vss_;
std::unique_ptr<Thread> int_thread_;
std::unique_ptr<Thread> ext_thread_;
- std::unique_ptr<NATServer> nat_;
- std::unique_ptr<NATSocketFactory> natsf_;
+ std::unique_ptr<webrtc::NATServer> nat_;
+ std::unique_ptr<webrtc::NATSocketFactory> natsf_;
std::unique_ptr<Socket> client_;
std::unique_ptr<Socket> server_;
std::unique_ptr<Socket> accepted_;
diff --git a/p2p/test/stun_server.cc b/p2p/test/stun_server.cc
index 60ec70f..4299a3d 100644
--- a/p2p/test/stun_server.cc
+++ b/p2p/test/stun_server.cc
@@ -20,7 +20,7 @@
#include "rtc_base/logging.h"
#include "rtc_base/network/received_packet.h"
-namespace cricket {
+namespace webrtc {
StunServer::StunServer(rtc::AsyncUDPSocket* socket) : socket_(socket) {
socket_->RegisterReceivedPacketCallback(
@@ -39,7 +39,7 @@
RTC_DCHECK_RUN_ON(&sequence_checker_);
// Parse the STUN message; eat any messages that fail to parse.
rtc::ByteBufferReader bbuf(packet.payload());
- StunMessage msg;
+ cricket::StunMessage msg;
if (!msg.Read(&bbuf)) {
return;
}
@@ -50,7 +50,7 @@
// Send the message to the appropriate handler function.
switch (msg.type()) {
- case STUN_BINDING_REQUEST:
+ case cricket::STUN_BINDING_REQUEST:
OnBindingRequest(&msg, packet.source_address());
break;
@@ -60,21 +60,22 @@
}
}
-void StunServer::OnBindingRequest(StunMessage* msg,
- const webrtc::SocketAddress& remote_addr) {
- StunMessage response(STUN_BINDING_RESPONSE, msg->transaction_id());
+void StunServer::OnBindingRequest(cricket::StunMessage* msg,
+ const SocketAddress& remote_addr) {
+ cricket::StunMessage response(cricket::STUN_BINDING_RESPONSE,
+ msg->transaction_id());
GetStunBindResponse(msg, remote_addr, &response);
SendResponse(response, remote_addr);
}
-void StunServer::SendErrorResponse(const StunMessage& msg,
- const webrtc::SocketAddress& addr,
+void StunServer::SendErrorResponse(const cricket::StunMessage& msg,
+ const SocketAddress& addr,
int error_code,
absl::string_view error_desc) {
- StunMessage err_msg(GetStunErrorResponseType(msg.type()),
- msg.transaction_id());
+ cricket::StunMessage err_msg(cricket::GetStunErrorResponseType(msg.type()),
+ msg.transaction_id());
- auto err_code = StunAttribute::CreateErrorCode();
+ auto err_code = cricket::StunAttribute::CreateErrorCode();
err_code->SetCode(error_code);
err_code->SetReason(std::string(error_desc));
err_msg.AddAttribute(std::move(err_code));
@@ -82,8 +83,8 @@
SendResponse(err_msg, addr);
}
-void StunServer::SendResponse(const StunMessage& msg,
- const webrtc::SocketAddress& addr) {
+void StunServer::SendResponse(const cricket::StunMessage& msg,
+ const SocketAddress& addr) {
rtc::ByteBufferWriter buf;
msg.Write(&buf);
rtc::PacketOptions options;
@@ -91,21 +92,23 @@
RTC_LOG_ERR(LS_ERROR) << "sendto";
}
-void StunServer::GetStunBindResponse(StunMessage* message,
- const webrtc::SocketAddress& remote_addr,
- StunMessage* response) const {
- RTC_DCHECK_EQ(response->type(), STUN_BINDING_RESPONSE);
+void StunServer::GetStunBindResponse(cricket::StunMessage* message,
+ const SocketAddress& remote_addr,
+ cricket::StunMessage* response) const {
+ RTC_DCHECK_EQ(response->type(), cricket::STUN_BINDING_RESPONSE);
RTC_DCHECK_EQ(response->transaction_id(), message->transaction_id());
// Tell the user the address that we received their message from.
- std::unique_ptr<StunAddressAttribute> mapped_addr;
+ std::unique_ptr<cricket::StunAddressAttribute> mapped_addr;
if (message->IsLegacy()) {
- mapped_addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
+ mapped_addr = cricket::StunAttribute::CreateAddress(
+ cricket::STUN_ATTR_MAPPED_ADDRESS);
} else {
- mapped_addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ mapped_addr = cricket::StunAttribute::CreateXorAddress(
+ cricket::STUN_ATTR_XOR_MAPPED_ADDRESS);
}
mapped_addr->SetAddress(remote_addr);
response->AddAttribute(std::move(mapped_addr));
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/test/stun_server.h b/p2p/test/stun_server.h
index 4e63388..06346ad 100644
--- a/p2p/test/stun_server.h
+++ b/p2p/test/stun_server.h
@@ -21,7 +21,7 @@
#include "rtc_base/async_udp_socket.h"
#include "rtc_base/socket_address.h"
-namespace cricket {
+namespace webrtc {
const int STUN_SERVER_PORT = 3478;
@@ -38,32 +38,39 @@
const rtc::ReceivedPacket& packet);
// Handlers for the different types of STUN/TURN requests:
- virtual void OnBindingRequest(StunMessage* msg,
- const webrtc::SocketAddress& addr);
- void OnAllocateRequest(StunMessage* msg, const webrtc::SocketAddress& addr);
- void OnSharedSecretRequest(StunMessage* msg,
- const webrtc::SocketAddress& addr);
- void OnSendRequest(StunMessage* msg, const webrtc::SocketAddress& addr);
+ virtual void OnBindingRequest(cricket::StunMessage* msg,
+ const SocketAddress& addr);
+ void OnAllocateRequest(cricket::StunMessage* msg, const SocketAddress& addr);
+ void OnSharedSecretRequest(cricket::StunMessage* msg,
+ const SocketAddress& addr);
+ void OnSendRequest(cricket::StunMessage* msg, const SocketAddress& addr);
// Sends an error response to the given message back to the user.
- void SendErrorResponse(const StunMessage& msg,
- const webrtc::SocketAddress& addr,
+ void SendErrorResponse(const cricket::StunMessage& msg,
+ const SocketAddress& addr,
int error_code,
absl::string_view error_desc);
// Sends the given message to the appropriate destination.
- void SendResponse(const StunMessage& msg, const webrtc::SocketAddress& addr);
+ void SendResponse(const cricket::StunMessage& msg, const SocketAddress& addr);
// A helper method to compose a STUN binding response.
- void GetStunBindResponse(StunMessage* message,
- const webrtc::SocketAddress& remote_addr,
- StunMessage* response) const;
+ void GetStunBindResponse(cricket::StunMessage* message,
+ const SocketAddress& remote_addr,
+ cricket::StunMessage* response) const;
private:
- webrtc::SequenceChecker sequence_checker_;
+ SequenceChecker sequence_checker_;
std::unique_ptr<rtc::AsyncUDPSocket> socket_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::STUN_SERVER_PORT;
+using ::webrtc::StunServer;
} // namespace cricket
#endif // P2P_TEST_STUN_SERVER_H_
diff --git a/p2p/test/stun_server_unittest.cc b/p2p/test/stun_server_unittest.cc
index 74bdd35..a53c803 100644
--- a/p2p/test/stun_server_unittest.cc
+++ b/p2p/test/stun_server_unittest.cc
@@ -24,11 +24,11 @@
#include "rtc_base/virtual_socket_server.h"
#include "test/gtest.h"
-namespace cricket {
+namespace webrtc {
namespace {
-const webrtc::SocketAddress server_addr("99.99.99.1", 3478);
-const webrtc::SocketAddress client_addr("1.2.3.4", 1234);
+const SocketAddress server_addr("99.99.99.1", 3478);
+const SocketAddress client_addr("1.2.3.4", 1234);
} // namespace
class StunServerTest : public ::testing::Test {
@@ -37,11 +37,11 @@
ss_->SetMessageQueue(&main_thread);
server_.reset(
new StunServer(rtc::AsyncUDPSocket::Create(ss_.get(), server_addr)));
- client_.reset(new rtc::TestClient(
+ client_.reset(new TestClient(
absl::WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client_addr))));
}
- void Send(const StunMessage& msg) {
+ void Send(const cricket::StunMessage& msg) {
rtc::ByteBufferWriter buf;
msg.Write(&buf);
Send(reinterpret_cast<const char*>(buf.Data()),
@@ -51,13 +51,13 @@
client_->SendTo(buf, len, server_addr);
}
bool ReceiveFails() { return (client_->CheckNoPacket()); }
- StunMessage* Receive() {
- StunMessage* msg = NULL;
- std::unique_ptr<rtc::TestClient::Packet> packet =
- client_->NextPacket(rtc::TestClient::kTimeoutMs);
+ cricket::StunMessage* Receive() {
+ cricket::StunMessage* msg = NULL;
+ std::unique_ptr<TestClient::Packet> packet =
+ client_->NextPacket(TestClient::kTimeoutMs);
if (packet) {
rtc::ByteBufferReader buf(packet->buf);
- msg = new StunMessage();
+ msg = new cricket::StunMessage();
msg->Read(&buf);
}
return msg;
@@ -67,22 +67,22 @@
rtc::AutoThread main_thread;
std::unique_ptr<rtc::VirtualSocketServer> ss_;
std::unique_ptr<StunServer> server_;
- std::unique_ptr<rtc::TestClient> client_;
+ std::unique_ptr<TestClient> client_;
};
TEST_F(StunServerTest, TestGood) {
// kStunLegacyTransactionIdLength = 16 for legacy RFC 3489 request
std::string transaction_id = "0123456789abcdef";
- StunMessage req(STUN_BINDING_REQUEST, transaction_id);
+ cricket::StunMessage req(cricket::STUN_BINDING_REQUEST, transaction_id);
Send(req);
- StunMessage* msg = Receive();
+ cricket::StunMessage* msg = Receive();
ASSERT_TRUE(msg != NULL);
- EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
+ EXPECT_EQ(cricket::STUN_BINDING_RESPONSE, msg->type());
EXPECT_EQ(req.transaction_id(), msg->transaction_id());
- const StunAddressAttribute* mapped_addr =
- msg->GetAddress(STUN_ATTR_MAPPED_ADDRESS);
+ const cricket::StunAddressAttribute* mapped_addr =
+ msg->GetAddress(cricket::STUN_ATTR_MAPPED_ADDRESS);
EXPECT_TRUE(mapped_addr != NULL);
EXPECT_EQ(1, mapped_addr->family());
EXPECT_EQ(client_addr.port(), mapped_addr->port());
@@ -94,16 +94,16 @@
// kStunTransactionIdLength = 12 for RFC 5389 request
// StunMessage::Write will automatically insert magic cookie (0x2112A442)
std::string transaction_id = "0123456789ab";
- StunMessage req(STUN_BINDING_REQUEST, transaction_id);
+ cricket::StunMessage req(cricket::STUN_BINDING_REQUEST, transaction_id);
Send(req);
- StunMessage* msg = Receive();
+ cricket::StunMessage* msg = Receive();
ASSERT_TRUE(msg != NULL);
- EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
+ EXPECT_EQ(cricket::STUN_BINDING_RESPONSE, msg->type());
EXPECT_EQ(req.transaction_id(), msg->transaction_id());
- const StunAddressAttribute* mapped_addr =
- msg->GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ const cricket::StunAddressAttribute* mapped_addr =
+ msg->GetAddress(cricket::STUN_ATTR_XOR_MAPPED_ADDRESS);
EXPECT_TRUE(mapped_addr != NULL);
EXPECT_EQ(1, mapped_addr->family());
EXPECT_EQ(client_addr.port(), mapped_addr->port());
@@ -115,16 +115,16 @@
TEST_F(StunServerTest, TestNoXorMappedAddr) {
// kStunLegacyTransactionIdLength = 16 for legacy RFC 3489 request
std::string transaction_id = "0123456789abcdef";
- StunMessage req(STUN_BINDING_REQUEST, transaction_id);
+ cricket::StunMessage req(cricket::STUN_BINDING_REQUEST, transaction_id);
Send(req);
- StunMessage* msg = Receive();
+ cricket::StunMessage* msg = Receive();
ASSERT_TRUE(msg != NULL);
- EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
+ EXPECT_EQ(cricket::STUN_BINDING_RESPONSE, msg->type());
EXPECT_EQ(req.transaction_id(), msg->transaction_id());
- const StunAddressAttribute* mapped_addr =
- msg->GetAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
+ const cricket::StunAddressAttribute* mapped_addr =
+ msg->GetAddress(cricket::STUN_ATTR_XOR_MAPPED_ADDRESS);
EXPECT_TRUE(mapped_addr == NULL);
delete msg;
@@ -140,4 +140,4 @@
ASSERT_TRUE(ReceiveFails());
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/test/test_stun_server.cc b/p2p/test/test_stun_server.cc
index 2a835e3..38ca094 100644
--- a/p2p/test/test_stun_server.cc
+++ b/p2p/test/test_stun_server.cc
@@ -15,11 +15,11 @@
#include "rtc_base/socket.h"
#include "rtc_base/socket_server.h"
-namespace cricket {
+namespace webrtc {
-std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>>
+std::unique_ptr<TestStunServer, std::function<void(webrtc::TestStunServer*)>>
TestStunServer::Create(rtc::SocketServer* ss,
- const webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
rtc::Thread& network_thread) {
rtc::Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM);
RTC_CHECK(socket != nullptr) << "Failed to create socket";
@@ -28,24 +28,24 @@
TestStunServer* server = nullptr;
network_thread.BlockingCall(
[&]() { server = new TestStunServer(udp_socket, network_thread); });
- std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>> result(
- server, [&](TestStunServer* server) {
+ std::unique_ptr<TestStunServer, std::function<void(webrtc::TestStunServer*)>>
+ result(server, [&](TestStunServer* server) {
network_thread.BlockingCall([server]() { delete server; });
});
return result;
}
-void TestStunServer::OnBindingRequest(
- StunMessage* msg,
- const webrtc::SocketAddress& remote_addr) {
+void TestStunServer::OnBindingRequest(cricket::StunMessage* msg,
+ const SocketAddress& remote_addr) {
RTC_DCHECK_RUN_ON(&network_thread_);
if (fake_stun_addr_.IsNil()) {
StunServer::OnBindingRequest(msg, remote_addr);
} else {
- StunMessage response(STUN_BINDING_RESPONSE, msg->transaction_id());
+ cricket::StunMessage response(cricket::STUN_BINDING_RESPONSE,
+ msg->transaction_id());
GetStunBindResponse(msg, fake_stun_addr_, &response);
SendResponse(response, remote_addr);
}
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/test/test_stun_server.h b/p2p/test/test_stun_server.h
index f90958a..cef3ea2 100644
--- a/p2p/test/test_stun_server.h
+++ b/p2p/test/test_stun_server.h
@@ -20,21 +20,20 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/thread.h"
-namespace cricket {
+namespace webrtc {
// A test STUN server. Useful for unit tests.
class TestStunServer : StunServer {
public:
using StunServerPtr =
- std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>>;
+ std::unique_ptr<TestStunServer,
+ std::function<void(webrtc::TestStunServer*)>>;
static StunServerPtr Create(rtc::SocketServer* ss,
- const webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
rtc::Thread& network_thread);
// Set a fake STUN address to return to the client.
- void set_fake_stun_addr(const webrtc::SocketAddress& addr) {
- fake_stun_addr_ = addr;
- }
+ void set_fake_stun_addr(const SocketAddress& addr) { fake_stun_addr_ = addr; }
private:
static void DeleteOnNetworkThread(TestStunServer* server);
@@ -42,14 +41,20 @@
TestStunServer(rtc::AsyncUDPSocket* socket, rtc::Thread& network_thread)
: StunServer(socket), network_thread_(network_thread) {}
- void OnBindingRequest(StunMessage* msg,
- const webrtc::SocketAddress& remote_addr) override;
+ void OnBindingRequest(cricket::StunMessage* msg,
+ const SocketAddress& remote_addr) override;
private:
- webrtc::SocketAddress fake_stun_addr_;
+ SocketAddress fake_stun_addr_;
rtc::Thread& network_thread_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::TestStunServer;
} // namespace cricket
#endif // P2P_TEST_TEST_STUN_SERVER_H_
diff --git a/p2p/test/test_turn_customizer.h b/p2p/test/test_turn_customizer.h
index 4ab2420..0ec8764 100644
--- a/p2p/test/test_turn_customizer.h
+++ b/p2p/test/test_turn_customizer.h
@@ -16,9 +16,9 @@
#include "api/turn_customizer.h"
#include "rtc_base/gunit.h"
-namespace cricket {
+namespace webrtc {
-class TestTurnCustomizer : public webrtc::TurnCustomizer {
+class TestTurnCustomizer : public TurnCustomizer {
public:
TestTurnCustomizer() {}
virtual ~TestTurnCustomizer() {}
@@ -28,7 +28,7 @@
STUN_ATTR_COUNTER = 0xFF02 // Number
};
- void MaybeModifyOutgoingStunMessage(webrtc::PortInterface* port,
+ void MaybeModifyOutgoingStunMessage(PortInterface* port,
cricket::StunMessage* message) override {
modify_cnt_++;
@@ -40,7 +40,7 @@
return;
}
- bool AllowChannelData(webrtc::PortInterface* port,
+ bool AllowChannelData(PortInterface* port,
const void* data,
size_t size,
bool payload) override {
@@ -54,6 +54,12 @@
unsigned int allow_channel_data_cnt_ = 0;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::TestTurnCustomizer;
} // namespace cricket
#endif // P2P_TEST_TEST_TURN_CUSTOMIZER_H_
diff --git a/p2p/test/test_turn_server.h b/p2p/test/test_turn_server.h
index 91dc926..6e4821b 100644
--- a/p2p/test/test_turn_server.h
+++ b/p2p/test/test_turn_server.h
@@ -26,20 +26,18 @@
#include "rtc_base/ssl_identity.h"
#include "rtc_base/thread.h"
-namespace cricket {
+namespace webrtc {
static const char kTestRealm[] = "example.org";
static const char kTestSoftware[] = "TestTurnServer";
class TestTurnRedirector : public TurnRedirectInterface {
public:
- explicit TestTurnRedirector(
- const std::vector<webrtc::SocketAddress>& addresses)
+ explicit TestTurnRedirector(const std::vector<SocketAddress>& addresses)
: alternate_server_addresses_(addresses),
iter_(alternate_server_addresses_.begin()) {}
- virtual bool ShouldRedirect(const webrtc::SocketAddress&,
- webrtc::SocketAddress* out) {
+ virtual bool ShouldRedirect(const SocketAddress&, SocketAddress* out) {
if (!out || iter_ == alternate_server_addresses_.end()) {
return false;
}
@@ -48,17 +46,17 @@
}
private:
- const std::vector<webrtc::SocketAddress>& alternate_server_addresses_;
- std::vector<webrtc::SocketAddress>::const_iterator iter_;
+ const std::vector<SocketAddress>& alternate_server_addresses_;
+ std::vector<SocketAddress>::const_iterator iter_;
};
class TestTurnServer : public TurnAuthInterface {
public:
TestTurnServer(rtc::Thread* thread,
rtc::SocketFactory* socket_factory,
- const webrtc::SocketAddress& int_addr,
- const webrtc::SocketAddress& udp_ext_addr,
- webrtc::ProtocolType int_protocol = webrtc::PROTO_UDP,
+ const SocketAddress& int_addr,
+ const SocketAddress& udp_ext_addr,
+ ProtocolType int_protocol = webrtc::PROTO_UDP,
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server")
: server_(thread), socket_factory_(socket_factory) {
@@ -92,8 +90,8 @@
server_.set_enable_permission_checks(enable);
}
- void AddInternalSocket(const webrtc::SocketAddress& int_addr,
- webrtc::ProtocolType proto,
+ void AddInternalSocket(const SocketAddress& int_addr,
+ ProtocolType proto,
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server") {
RTC_DCHECK(thread_checker_.IsCurrent());
@@ -129,7 +127,7 @@
// Finds the first allocation in the server allocation map with a source
// ip and port matching the socket address provided.
- TurnServerAllocation* FindAllocation(const webrtc::SocketAddress& src) {
+ TurnServerAllocation* FindAllocation(const SocketAddress& src) {
RTC_DCHECK(thread_checker_.IsCurrent());
const TurnServer::AllocationMap& map = server_.allocations();
for (TurnServer::AllocationMap::const_iterator it = map.begin();
@@ -148,15 +146,24 @@
absl::string_view realm,
std::string* key) {
RTC_DCHECK(thread_checker_.IsCurrent());
- return ComputeStunCredentialHash(std::string(username), std::string(realm),
- std::string(username), key);
+ return cricket::ComputeStunCredentialHash(
+ std::string(username), std::string(realm), std::string(username), key);
}
TurnServer server_;
rtc::SocketFactory* socket_factory_;
- webrtc::SequenceChecker thread_checker_;
+ SequenceChecker thread_checker_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::kTestRealm;
+using ::webrtc::kTestSoftware;
+using ::webrtc::TestTurnRedirector;
+using ::webrtc::TestTurnServer;
} // namespace cricket
#endif // P2P_TEST_TEST_TURN_SERVER_H_
diff --git a/p2p/test/turn_server.cc b/p2p/test/turn_server.cc
index baff123..c560460 100644
--- a/p2p/test/turn_server.cc
+++ b/p2p/test/turn_server.cc
@@ -32,7 +32,7 @@
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
namespace {
using ::webrtc::TimeDelta;
@@ -56,24 +56,24 @@
} // namespace
-int GetStunSuccessResponseTypeOrZero(const StunMessage& req) {
- const int resp_type = GetStunSuccessResponseType(req.type());
+int GetStunSuccessResponseTypeOrZero(const cricket::StunMessage& req) {
+ const int resp_type = cricket::GetStunSuccessResponseType(req.type());
return resp_type == -1 ? 0 : resp_type;
}
-int GetStunErrorResponseTypeOrZero(const StunMessage& req) {
- const int resp_type = GetStunErrorResponseType(req.type());
+int GetStunErrorResponseTypeOrZero(const cricket::StunMessage& req) {
+ const int resp_type = cricket::GetStunErrorResponseType(req.type());
return resp_type == -1 ? 0 : resp_type;
}
static void InitErrorResponse(int code,
absl::string_view reason,
- StunMessage* resp) {
+ cricket::StunMessage* resp) {
resp->AddAttribute(std::make_unique<cricket::StunErrorCodeAttribute>(
- STUN_ATTR_ERROR_CODE, code, std::string(reason)));
+ cricket::STUN_ATTR_ERROR_CODE, code, std::string(reason)));
}
-TurnServer::TurnServer(webrtc::TaskQueueBase* thread)
+TurnServer::TurnServer(TaskQueueBase* thread)
: thread_(thread),
nonce_key_(rtc::CreateRandomString(kNonceKeySize)),
auth_hook_(NULL),
@@ -96,7 +96,7 @@
}
void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
- webrtc::ProtocolType proto) {
+ ProtocolType proto) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(server_sockets_.end() == server_sockets_.find(socket));
server_sockets_[socket] = proto;
@@ -109,7 +109,7 @@
void TurnServer::AddInternalServerSocket(
rtc::Socket* socket,
- webrtc::ProtocolType proto,
+ ProtocolType proto,
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory) {
RTC_DCHECK_RUN_ON(thread_);
@@ -119,9 +119,8 @@
socket->SignalReadEvent.connect(this, &TurnServer::OnNewInternalConnection);
}
-void TurnServer::SetExternalSocketFactory(
- rtc::PacketSocketFactory* factory,
- const webrtc::SocketAddress& external_addr) {
+void TurnServer::SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
+ const SocketAddress& external_addr) {
RTC_DCHECK_RUN_ON(thread_);
external_socket_factory_.reset(factory);
external_addr_ = external_addr;
@@ -138,7 +137,7 @@
RTC_DCHECK_RUN_ON(thread_);
// Check if someone is trying to connect to us.
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
rtc::Socket* accepted_socket = server_socket->Accept(&accept_addr);
if (accepted_socket != NULL) {
const ServerSocketInfo& info = server_listen_sockets_[server_socket];
@@ -195,7 +194,7 @@
void TurnServer::HandleStunMessage(TurnServerConnection* conn,
rtc::ArrayView<const uint8_t> payload) {
RTC_DCHECK_RUN_ON(thread_);
- TurnMessage msg;
+ cricket::TurnMessage msg;
rtc::ByteBufferReader buf(payload);
if (!msg.Read(&buf) || (buf.Length() > 0)) {
RTC_LOG(LS_WARNING) << "Received invalid STUN message";
@@ -207,13 +206,13 @@
}
// If it's a STUN binding request, handle that specially.
- if (msg.type() == STUN_BINDING_REQUEST) {
+ if (msg.type() == cricket::STUN_BINDING_REQUEST) {
HandleBindingRequest(conn, &msg);
return;
}
- if (redirect_hook_ != NULL && msg.type() == STUN_ALLOCATE_REQUEST) {
- webrtc::SocketAddress address;
+ if (redirect_hook_ != NULL && msg.type() == cricket::STUN_ALLOCATE_REQUEST) {
+ SocketAddress address;
if (redirect_hook_->ShouldRedirect(conn->src(), &address)) {
SendErrorResponseWithAlternateServer(conn, &msg, address);
return;
@@ -231,37 +230,37 @@
}
// Ensure the message is authorized; only needed for requests.
- if (IsStunRequestType(msg.type())) {
+ if (cricket::IsStunRequestType(msg.type())) {
if (!CheckAuthorization(conn, &msg, key)) {
return;
}
}
- if (!allocation && msg.type() == STUN_ALLOCATE_REQUEST) {
+ if (!allocation && msg.type() == cricket::STUN_ALLOCATE_REQUEST) {
HandleAllocateRequest(conn, &msg, key);
} else if (allocation &&
- (msg.type() != STUN_ALLOCATE_REQUEST ||
+ (msg.type() != cricket::STUN_ALLOCATE_REQUEST ||
msg.transaction_id() == allocation->transaction_id())) {
// This is a non-allocate request, or a retransmit of an allocate.
// Check that the username matches the previous username used.
- if (IsStunRequestType(msg.type()) &&
- msg.GetByteString(STUN_ATTR_USERNAME)->string_view() !=
+ if (cricket::IsStunRequestType(msg.type()) &&
+ msg.GetByteString(cricket::STUN_ATTR_USERNAME)->string_view() !=
allocation->username()) {
- SendErrorResponse(conn, &msg, STUN_ERROR_WRONG_CREDENTIALS,
- STUN_ERROR_REASON_WRONG_CREDENTIALS);
+ SendErrorResponse(conn, &msg, cricket::STUN_ERROR_WRONG_CREDENTIALS,
+ cricket::STUN_ERROR_REASON_WRONG_CREDENTIALS);
return;
}
allocation->HandleTurnMessage(&msg);
} else {
// Allocation mismatch.
- SendErrorResponse(conn, &msg, STUN_ERROR_ALLOCATION_MISMATCH,
- STUN_ERROR_REASON_ALLOCATION_MISMATCH);
+ SendErrorResponse(conn, &msg, cricket::STUN_ERROR_ALLOCATION_MISMATCH,
+ cricket::STUN_ERROR_REASON_ALLOCATION_MISMATCH);
}
}
-bool TurnServer::GetKey(const StunMessage* msg, std::string* key) {
- const StunByteStringAttribute* username_attr =
- msg->GetByteString(STUN_ATTR_USERNAME);
+bool TurnServer::GetKey(const cricket::StunMessage* msg, std::string* key) {
+ const cricket::StunByteStringAttribute* username_attr =
+ msg->GetByteString(cricket::STUN_ATTR_USERNAME);
if (!username_attr) {
return false;
}
@@ -272,45 +271,48 @@
}
bool TurnServer::CheckAuthorization(TurnServerConnection* conn,
- StunMessage* msg,
+ cricket::StunMessage* msg,
absl::string_view key) {
// RFC 5389, 10.2.2.
- RTC_DCHECK(IsStunRequestType(msg->type()));
- const StunByteStringAttribute* mi_attr =
- msg->GetByteString(STUN_ATTR_MESSAGE_INTEGRITY);
- const StunByteStringAttribute* username_attr =
- msg->GetByteString(STUN_ATTR_USERNAME);
- const StunByteStringAttribute* realm_attr =
- msg->GetByteString(STUN_ATTR_REALM);
- const StunByteStringAttribute* nonce_attr =
- msg->GetByteString(STUN_ATTR_NONCE);
+ RTC_DCHECK(cricket::IsStunRequestType(msg->type()));
+ const cricket::StunByteStringAttribute* mi_attr =
+ msg->GetByteString(cricket::STUN_ATTR_MESSAGE_INTEGRITY);
+ const cricket::StunByteStringAttribute* username_attr =
+ msg->GetByteString(cricket::STUN_ATTR_USERNAME);
+ const cricket::StunByteStringAttribute* realm_attr =
+ msg->GetByteString(cricket::STUN_ATTR_REALM);
+ const cricket::StunByteStringAttribute* nonce_attr =
+ msg->GetByteString(cricket::STUN_ATTR_NONCE);
// Fail if no MESSAGE_INTEGRITY.
if (!mi_attr) {
- SendErrorResponseWithRealmAndNonce(conn, msg, STUN_ERROR_UNAUTHORIZED,
- STUN_ERROR_REASON_UNAUTHORIZED);
+ SendErrorResponseWithRealmAndNonce(conn, msg,
+ cricket::STUN_ERROR_UNAUTHORIZED,
+ cricket::STUN_ERROR_REASON_UNAUTHORIZED);
return false;
}
// Fail if there is MESSAGE_INTEGRITY but no username, nonce, or realm.
if (!username_attr || !realm_attr || !nonce_attr) {
- SendErrorResponse(conn, msg, STUN_ERROR_BAD_REQUEST,
- STUN_ERROR_REASON_BAD_REQUEST);
+ SendErrorResponse(conn, msg, cricket::STUN_ERROR_BAD_REQUEST,
+ cricket::STUN_ERROR_REASON_BAD_REQUEST);
return false;
}
// Fail if bad nonce.
if (!ValidateNonce(nonce_attr->string_view())) {
- SendErrorResponseWithRealmAndNonce(conn, msg, STUN_ERROR_STALE_NONCE,
- STUN_ERROR_REASON_STALE_NONCE);
+ SendErrorResponseWithRealmAndNonce(conn, msg,
+ cricket::STUN_ERROR_STALE_NONCE,
+ cricket::STUN_ERROR_REASON_STALE_NONCE);
return false;
}
// Fail if bad MESSAGE_INTEGRITY.
if (key.empty() || msg->ValidateMessageIntegrity(std::string(key)) !=
- StunMessage::IntegrityStatus::kIntegrityOk) {
- SendErrorResponseWithRealmAndNonce(conn, msg, STUN_ERROR_UNAUTHORIZED,
- STUN_ERROR_REASON_UNAUTHORIZED);
+ cricket::StunMessage::IntegrityStatus::kIntegrityOk) {
+ SendErrorResponseWithRealmAndNonce(conn, msg,
+ cricket::STUN_ERROR_UNAUTHORIZED,
+ cricket::STUN_ERROR_REASON_UNAUTHORIZED);
return false;
}
@@ -318,8 +320,9 @@
TurnServerAllocation* allocation = FindAllocation(conn);
if (enable_otu_nonce_ && allocation &&
allocation->last_nonce() == nonce_attr->string_view()) {
- SendErrorResponseWithRealmAndNonce(conn, msg, STUN_ERROR_STALE_NONCE,
- STUN_ERROR_REASON_STALE_NONCE);
+ SendErrorResponseWithRealmAndNonce(conn, msg,
+ cricket::STUN_ERROR_STALE_NONCE,
+ cricket::STUN_ERROR_REASON_STALE_NONCE);
return false;
}
@@ -331,34 +334,34 @@
}
void TurnServer::HandleBindingRequest(TurnServerConnection* conn,
- const StunMessage* req) {
- StunMessage response(GetStunSuccessResponseTypeOrZero(*req),
- req->transaction_id());
+ const cricket::StunMessage* req) {
+ cricket::StunMessage response(GetStunSuccessResponseTypeOrZero(*req),
+ req->transaction_id());
// Tell the user the address that we received their request from.
- auto mapped_addr_attr = std::make_unique<StunXorAddressAttribute>(
- STUN_ATTR_XOR_MAPPED_ADDRESS, conn->src());
+ auto mapped_addr_attr = std::make_unique<cricket::StunXorAddressAttribute>(
+ cricket::STUN_ATTR_XOR_MAPPED_ADDRESS, conn->src());
response.AddAttribute(std::move(mapped_addr_attr));
SendStun(conn, &response);
}
void TurnServer::HandleAllocateRequest(TurnServerConnection* conn,
- const TurnMessage* msg,
+ const cricket::TurnMessage* msg,
absl::string_view key) {
// Check the parameters in the request.
- const StunUInt32Attribute* transport_attr =
- msg->GetUInt32(STUN_ATTR_REQUESTED_TRANSPORT);
+ const cricket::StunUInt32Attribute* transport_attr =
+ msg->GetUInt32(cricket::STUN_ATTR_REQUESTED_TRANSPORT);
if (!transport_attr) {
- SendErrorResponse(conn, msg, STUN_ERROR_BAD_REQUEST,
- STUN_ERROR_REASON_BAD_REQUEST);
+ SendErrorResponse(conn, msg, cricket::STUN_ERROR_BAD_REQUEST,
+ cricket::STUN_ERROR_REASON_BAD_REQUEST);
return;
}
// Only UDP is supported right now.
int proto = transport_attr->value() >> 24;
if (proto != IPPROTO_UDP) {
- SendErrorResponse(conn, msg, STUN_ERROR_UNSUPPORTED_PROTOCOL,
- STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL);
+ SendErrorResponse(conn, msg, cricket::STUN_ERROR_UNSUPPORTED_PROTOCOL,
+ cricket::STUN_ERROR_REASON_UNSUPPORTED_PROTOCOL);
return;
}
@@ -368,7 +371,7 @@
if (alloc) {
alloc->HandleTurnMessage(msg);
} else {
- SendErrorResponse(conn, msg, STUN_ERROR_SERVER_ERROR,
+ SendErrorResponse(conn, msg, cricket::STUN_ERROR_SERVER_ERROR,
"Failed to allocate socket");
}
}
@@ -433,11 +436,12 @@
}
void TurnServer::SendErrorResponse(TurnServerConnection* conn,
- const StunMessage* req,
+ const cricket::StunMessage* req,
int code,
absl::string_view reason) {
RTC_DCHECK_RUN_ON(thread_);
- TurnMessage resp(GetStunErrorResponseTypeOrZero(*req), req->transaction_id());
+ cricket::TurnMessage resp(GetStunErrorResponseTypeOrZero(*req),
+ req->transaction_id());
InitErrorResponse(code, reason, &resp);
RTC_LOG(LS_INFO) << "Sending error response, type=" << resp.type()
@@ -445,11 +449,13 @@
SendStun(conn, &resp);
}
-void TurnServer::SendErrorResponseWithRealmAndNonce(TurnServerConnection* conn,
- const StunMessage* msg,
- int code,
- absl::string_view reason) {
- TurnMessage resp(GetStunErrorResponseTypeOrZero(*msg), msg->transaction_id());
+void TurnServer::SendErrorResponseWithRealmAndNonce(
+ TurnServerConnection* conn,
+ const cricket::StunMessage* msg,
+ int code,
+ absl::string_view reason) {
+ cricket::TurnMessage resp(GetStunErrorResponseTypeOrZero(*msg),
+ msg->transaction_id());
InitErrorResponse(code, reason, &resp);
int64_t timestamp = rtc::TimeMillis();
@@ -457,32 +463,34 @@
timestamp = ts_for_next_nonce_;
ts_for_next_nonce_ = 0;
}
- resp.AddAttribute(std::make_unique<StunByteStringAttribute>(
- STUN_ATTR_NONCE, GenerateNonce(timestamp)));
- resp.AddAttribute(
- std::make_unique<StunByteStringAttribute>(STUN_ATTR_REALM, realm_));
+ resp.AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
+ cricket::STUN_ATTR_NONCE, GenerateNonce(timestamp)));
+ resp.AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
+ cricket::STUN_ATTR_REALM, realm_));
SendStun(conn, &resp);
}
void TurnServer::SendErrorResponseWithAlternateServer(
TurnServerConnection* conn,
- const StunMessage* msg,
- const webrtc::SocketAddress& addr) {
- TurnMessage resp(GetStunErrorResponseTypeOrZero(*msg), msg->transaction_id());
- InitErrorResponse(STUN_ERROR_TRY_ALTERNATE,
- STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
- resp.AddAttribute(
- std::make_unique<StunAddressAttribute>(STUN_ATTR_ALTERNATE_SERVER, addr));
+ const cricket::StunMessage* msg,
+ const SocketAddress& addr) {
+ cricket::TurnMessage resp(GetStunErrorResponseTypeOrZero(*msg),
+ msg->transaction_id());
+ InitErrorResponse(cricket::STUN_ERROR_TRY_ALTERNATE,
+ cricket::STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
+ resp.AddAttribute(std::make_unique<cricket::StunAddressAttribute>(
+ cricket::STUN_ATTR_ALTERNATE_SERVER, addr));
SendStun(conn, &resp);
}
-void TurnServer::SendStun(TurnServerConnection* conn, StunMessage* msg) {
+void TurnServer::SendStun(TurnServerConnection* conn,
+ cricket::StunMessage* msg) {
RTC_DCHECK_RUN_ON(thread_);
rtc::ByteBufferWriter buf;
// Add a SOFTWARE attribute if one is set.
if (!software_.empty()) {
- msg->AddAttribute(std::make_unique<StunByteStringAttribute>(
- STUN_ATTR_SOFTWARE, software_));
+ msg->AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
+ cricket::STUN_ATTR_SOFTWARE, software_));
}
msg->Write(&buf);
Send(conn, buf);
@@ -526,8 +534,8 @@
}
}
-TurnServerConnection::TurnServerConnection(const webrtc::SocketAddress& src,
- webrtc::ProtocolType proto,
+TurnServerConnection::TurnServerConnection(const SocketAddress& src,
+ ProtocolType proto,
rtc::AsyncPacketSocket* socket)
: src_(src),
dst_(socket->GetRemoteAddress()),
@@ -544,14 +552,14 @@
std::string TurnServerConnection::ToString() const {
const char* const kProtos[] = {"unknown", "udp", "tcp", "ssltcp"};
- rtc::StringBuilder ost;
+ StringBuilder ost;
ost << src_.ToSensitiveString() << "-" << dst_.ToSensitiveString() << ":"
<< kProtos[proto_];
return ost.Release();
}
TurnServerAllocation::TurnServerAllocation(TurnServer* server,
- webrtc::TaskQueueBase* thread,
+ TaskQueueBase* thread,
const TurnServerConnection& conn,
rtc::AsyncPacketSocket* socket,
absl::string_view key)
@@ -574,28 +582,28 @@
}
std::string TurnServerAllocation::ToString() const {
- rtc::StringBuilder ost;
+ StringBuilder ost;
ost << "Alloc[" << conn_.ToString() << "]";
return ost.Release();
}
-void TurnServerAllocation::HandleTurnMessage(const TurnMessage* msg) {
+void TurnServerAllocation::HandleTurnMessage(const cricket::TurnMessage* msg) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(msg != NULL);
switch (msg->type()) {
- case STUN_ALLOCATE_REQUEST:
+ case cricket::STUN_ALLOCATE_REQUEST:
HandleAllocateRequest(msg);
break;
- case TURN_REFRESH_REQUEST:
+ case cricket::TURN_REFRESH_REQUEST:
HandleRefreshRequest(msg);
break;
- case TURN_SEND_INDICATION:
+ case cricket::TURN_SEND_INDICATION:
HandleSendIndication(msg);
break;
- case TURN_CREATE_PERMISSION_REQUEST:
+ case cricket::TURN_CREATE_PERMISSION_REQUEST:
HandleCreatePermissionRequest(msg);
break;
- case TURN_CHANNEL_BIND_REQUEST:
+ case cricket::TURN_CHANNEL_BIND_REQUEST:
HandleChannelBindRequest(msg);
break;
default:
@@ -606,11 +614,12 @@
}
}
-void TurnServerAllocation::HandleAllocateRequest(const TurnMessage* msg) {
+void TurnServerAllocation::HandleAllocateRequest(
+ const cricket::TurnMessage* msg) {
// Copy the important info from the allocate request.
transaction_id_ = msg->transaction_id();
- const StunByteStringAttribute* username_attr =
- msg->GetByteString(STUN_ATTR_USERNAME);
+ const cricket::StunByteStringAttribute* username_attr =
+ msg->GetByteString(cricket::STUN_ATTR_USERNAME);
RTC_DCHECK(username_attr != NULL);
username_ = std::string(username_attr->string_view());
@@ -622,15 +631,16 @@
<< lifetime.seconds();
// We've already validated all the important bits; just send a response here.
- TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
- msg->transaction_id());
+ cricket::TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
+ msg->transaction_id());
- auto mapped_addr_attr = std::make_unique<StunXorAddressAttribute>(
- STUN_ATTR_XOR_MAPPED_ADDRESS, conn_.src());
- auto relayed_addr_attr = std::make_unique<StunXorAddressAttribute>(
- STUN_ATTR_XOR_RELAYED_ADDRESS, external_socket_->GetLocalAddress());
- auto lifetime_attr = std::make_unique<StunUInt32Attribute>(
- STUN_ATTR_LIFETIME, lifetime.seconds());
+ auto mapped_addr_attr = std::make_unique<cricket::StunXorAddressAttribute>(
+ cricket::STUN_ATTR_XOR_MAPPED_ADDRESS, conn_.src());
+ auto relayed_addr_attr = std::make_unique<cricket::StunXorAddressAttribute>(
+ cricket::STUN_ATTR_XOR_RELAYED_ADDRESS,
+ external_socket_->GetLocalAddress());
+ auto lifetime_attr = std::make_unique<cricket::StunUInt32Attribute>(
+ cricket::STUN_ATTR_LIFETIME, lifetime.seconds());
response.AddAttribute(std::move(mapped_addr_attr));
response.AddAttribute(std::move(relayed_addr_attr));
response.AddAttribute(std::move(lifetime_attr));
@@ -638,7 +648,8 @@
SendResponse(&response);
}
-void TurnServerAllocation::HandleRefreshRequest(const TurnMessage* msg) {
+void TurnServerAllocation::HandleRefreshRequest(
+ const cricket::TurnMessage* msg) {
// Figure out the new lifetime.
TimeDelta lifetime = ComputeLifetime(*msg);
@@ -650,21 +661,23 @@
<< ": Refreshed allocation, lifetime=" << lifetime.seconds();
// Send a success response with a LIFETIME attribute.
- TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
- msg->transaction_id());
+ cricket::TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
+ msg->transaction_id());
- auto lifetime_attr = std::make_unique<StunUInt32Attribute>(
- STUN_ATTR_LIFETIME, lifetime.seconds());
+ auto lifetime_attr = std::make_unique<cricket::StunUInt32Attribute>(
+ cricket::STUN_ATTR_LIFETIME, lifetime.seconds());
response.AddAttribute(std::move(lifetime_attr));
SendResponse(&response);
}
-void TurnServerAllocation::HandleSendIndication(const TurnMessage* msg) {
+void TurnServerAllocation::HandleSendIndication(
+ const cricket::TurnMessage* msg) {
// Check mandatory attributes.
- const StunByteStringAttribute* data_attr = msg->GetByteString(STUN_ATTR_DATA);
- const StunAddressAttribute* peer_attr =
- msg->GetAddress(STUN_ATTR_XOR_PEER_ADDRESS);
+ const cricket::StunByteStringAttribute* data_attr =
+ msg->GetByteString(cricket::STUN_ATTR_DATA);
+ const cricket::StunAddressAttribute* peer_attr =
+ msg->GetAddress(cricket::STUN_ATTR_XOR_PEER_ADDRESS);
if (!data_attr || !peer_attr) {
RTC_LOG(LS_WARNING) << ToString() << ": Received invalid send indication";
return;
@@ -683,11 +696,11 @@
}
void TurnServerAllocation::HandleCreatePermissionRequest(
- const TurnMessage* msg) {
+ const cricket::TurnMessage* msg) {
RTC_DCHECK_RUN_ON(server_->thread_);
// Check mandatory attributes.
- const StunAddressAttribute* peer_attr =
- msg->GetAddress(STUN_ATTR_XOR_PEER_ADDRESS);
+ const cricket::StunAddressAttribute* peer_attr =
+ msg->GetAddress(cricket::STUN_ATTR_XOR_PEER_ADDRESS);
if (!peer_attr) {
SendBadRequestResponse(msg);
return;
@@ -695,7 +708,8 @@
if (server_->reject_private_addresses_ &&
webrtc::IPIsPrivate(peer_attr->GetAddress().ipaddr())) {
- SendErrorResponse(msg, STUN_ERROR_FORBIDDEN, STUN_ERROR_REASON_FORBIDDEN);
+ SendErrorResponse(msg, cricket::STUN_ERROR_FORBIDDEN,
+ cricket::STUN_ERROR_REASON_FORBIDDEN);
return;
}
@@ -706,12 +720,13 @@
<< peer_attr->GetAddress().ToSensitiveString();
// Send a success response.
- TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
- msg->transaction_id());
+ cricket::TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
+ msg->transaction_id());
SendResponse(&response);
}
-void TurnServerAllocation::HandleChannelBindRequest(const TurnMessage* msg) {
+void TurnServerAllocation::HandleChannelBindRequest(
+ const cricket::TurnMessage* msg) {
RTC_DCHECK_RUN_ON(server_->thread_);
if (server_->reject_bind_requests_) {
RTC_LOG(LS_ERROR) << "HandleChannelBindRequest: Rejecting bind requests";
@@ -720,10 +735,10 @@
}
// Check mandatory attributes.
- const StunUInt32Attribute* channel_attr =
- msg->GetUInt32(STUN_ATTR_CHANNEL_NUMBER);
- const StunAddressAttribute* peer_attr =
- msg->GetAddress(STUN_ATTR_XOR_PEER_ADDRESS);
+ const cricket::StunUInt32Attribute* channel_attr =
+ msg->GetUInt32(cricket::STUN_ATTR_CHANNEL_NUMBER);
+ const cricket::StunAddressAttribute* peer_attr =
+ msg->GetAddress(cricket::STUN_ATTR_XOR_PEER_ADDRESS);
if (!channel_attr || !peer_attr) {
SendBadRequestResponse(msg);
return;
@@ -765,8 +780,8 @@
<< ", peer=" << peer_attr->GetAddress().ToSensitiveString();
// Send a success response.
- TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
- msg->transaction_id());
+ cricket::TurnMessage response(GetStunSuccessResponseTypeOrZero(*msg),
+ msg->transaction_id());
SendResponse(&response);
}
@@ -795,16 +810,17 @@
rtc::ByteBufferWriter buf;
buf.WriteUInt16(channel->id);
buf.WriteUInt16(static_cast<uint16_t>(packet.payload().size()));
- buf.Write(webrtc::ArrayView<const uint8_t>(packet.payload()));
+ buf.Write(ArrayView<const uint8_t>(packet.payload()));
server_->Send(&conn_, buf);
} else if (!server_->enable_permission_checks_ ||
HasPermission(packet.source_address().ipaddr())) {
// No channel, but a permission exists. Send as a data indication.
- TurnMessage msg(TURN_DATA_INDICATION);
- msg.AddAttribute(std::make_unique<StunXorAddressAttribute>(
- STUN_ATTR_XOR_PEER_ADDRESS, packet.source_address()));
- msg.AddAttribute(std::make_unique<StunByteStringAttribute>(
- STUN_ATTR_DATA, packet.payload().data(), packet.payload().size()));
+ cricket::TurnMessage msg(cricket::TURN_DATA_INDICATION);
+ msg.AddAttribute(std::make_unique<cricket::StunXorAddressAttribute>(
+ cricket::STUN_ATTR_XOR_PEER_ADDRESS, packet.source_address()));
+ msg.AddAttribute(std::make_unique<cricket::StunByteStringAttribute>(
+ cricket::STUN_ATTR_DATA, packet.payload().data(),
+ packet.payload().size()));
server_->SendStun(&conn_, &msg);
} else {
RTC_LOG(LS_WARNING)
@@ -813,19 +829,21 @@
}
}
-TimeDelta TurnServerAllocation::ComputeLifetime(const TurnMessage& msg) {
- if (const StunUInt32Attribute* attr = msg.GetUInt32(STUN_ATTR_LIFETIME)) {
+TimeDelta TurnServerAllocation::ComputeLifetime(
+ const cricket::TurnMessage& msg) {
+ if (const cricket::StunUInt32Attribute* attr =
+ msg.GetUInt32(cricket::STUN_ATTR_LIFETIME)) {
return std::min(TimeDelta::Seconds(static_cast<int>(attr->value())),
kDefaultAllocationTimeout);
}
return kDefaultAllocationTimeout;
}
-bool TurnServerAllocation::HasPermission(const webrtc::IPAddress& addr) {
+bool TurnServerAllocation::HasPermission(const IPAddress& addr) {
return FindPermission(addr) != perms_.end();
}
-void TurnServerAllocation::AddPermission(const webrtc::IPAddress& addr) {
+void TurnServerAllocation::AddPermission(const IPAddress& addr) {
auto perm = FindPermission(addr);
if (perm == perms_.end()) {
perm = perms_.insert(perms_.end(), {.peer = addr});
@@ -838,7 +856,7 @@
}
TurnServerAllocation::PermissionList::iterator
-TurnServerAllocation::FindPermission(const webrtc::IPAddress& addr) {
+TurnServerAllocation::FindPermission(const IPAddress& addr) {
return absl::c_find_if(perms_,
[&](const Permission& p) { return p.peer == addr; });
}
@@ -850,22 +868,24 @@
}
TurnServerAllocation::ChannelList::iterator TurnServerAllocation::FindChannel(
- const webrtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
return absl::c_find_if(channels_,
[&](const Channel& c) { return c.peer == addr; });
}
-void TurnServerAllocation::SendResponse(TurnMessage* msg) {
+void TurnServerAllocation::SendResponse(cricket::TurnMessage* msg) {
// Success responses always have M-I.
msg->AddMessageIntegrity(key_);
server_->SendStun(&conn_, msg);
}
-void TurnServerAllocation::SendBadRequestResponse(const TurnMessage* req) {
- SendErrorResponse(req, STUN_ERROR_BAD_REQUEST, STUN_ERROR_REASON_BAD_REQUEST);
+void TurnServerAllocation::SendBadRequestResponse(
+ const cricket::TurnMessage* req) {
+ SendErrorResponse(req, cricket::STUN_ERROR_BAD_REQUEST,
+ cricket::STUN_ERROR_REASON_BAD_REQUEST);
}
-void TurnServerAllocation::SendErrorResponse(const TurnMessage* req,
+void TurnServerAllocation::SendErrorResponse(const cricket::TurnMessage* req,
int code,
absl::string_view reason) {
server_->SendErrorResponse(&conn_, req, code, reason);
@@ -873,7 +893,7 @@
void TurnServerAllocation::SendExternal(const void* data,
size_t size,
- const webrtc::SocketAddress& peer) {
+ const SocketAddress& peer) {
rtc::PacketOptions options;
external_socket_->SendTo(data, size, peer, options);
}
@@ -887,4 +907,4 @@
delay);
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/test/turn_server.h b/p2p/test/turn_server.h
index 6431bef..26d7d00 100644
--- a/p2p/test/turn_server.h
+++ b/p2p/test/turn_server.h
@@ -35,14 +35,16 @@
class ByteBufferWriter;
class PacketSocketFactory;
} // namespace rtc
-
namespace cricket {
+class StunMessage;
+class TurnMessage;
+} // namespace cricket
+
+namespace webrtc {
constexpr int kMinTurnChannelNumber = 0x4000;
constexpr int kMaxTurnChannelNumber = 0x7FFF;
-class StunMessage;
-class TurnMessage;
class TurnServer;
// The default server port for TURN, as specified in RFC5766.
@@ -52,19 +54,19 @@
class TurnServerConnection {
public:
TurnServerConnection() : proto_(webrtc::PROTO_UDP), socket_(NULL) {}
- TurnServerConnection(const webrtc::SocketAddress& src,
- webrtc::ProtocolType proto,
+ TurnServerConnection(const SocketAddress& src,
+ ProtocolType proto,
rtc::AsyncPacketSocket* socket);
- const webrtc::SocketAddress& src() const { return src_; }
+ const SocketAddress& src() const { return src_; }
rtc::AsyncPacketSocket* socket() { return socket_; }
bool operator==(const TurnServerConnection& t) const;
bool operator<(const TurnServerConnection& t) const;
std::string ToString() const;
private:
- webrtc::SocketAddress src_;
- webrtc::SocketAddress dst_;
- webrtc::ProtocolType proto_;
+ SocketAddress src_;
+ SocketAddress dst_;
+ ProtocolType proto_;
rtc::AsyncPacketSocket* socket_;
};
@@ -76,7 +78,7 @@
class TurnServerAllocation final {
public:
TurnServerAllocation(TurnServer* server_,
- webrtc::TaskQueueBase* thread,
+ TaskQueueBase* thread,
const TurnServerConnection& conn,
rtc::AsyncPacketSocket* server_socket,
absl::string_view key);
@@ -93,51 +95,49 @@
std::string ToString() const;
- void HandleTurnMessage(const TurnMessage* msg);
+ void HandleTurnMessage(const cricket::TurnMessage* msg);
void HandleChannelData(rtc::ArrayView<const uint8_t> payload);
private:
struct Channel {
- webrtc::ScopedTaskSafety pending_delete;
+ ScopedTaskSafety pending_delete;
const uint16_t id;
- const webrtc::SocketAddress peer;
+ const SocketAddress peer;
};
struct Permission {
- webrtc::ScopedTaskSafety pending_delete;
- webrtc::IPAddress peer;
+ ScopedTaskSafety pending_delete;
+ IPAddress peer;
};
using PermissionList = std::list<Permission>;
using ChannelList = std::list<Channel>;
- void PostDeleteSelf(webrtc::TimeDelta delay);
+ void PostDeleteSelf(TimeDelta delay);
- void HandleAllocateRequest(const TurnMessage* msg);
- void HandleRefreshRequest(const TurnMessage* msg);
- void HandleSendIndication(const TurnMessage* msg);
- void HandleCreatePermissionRequest(const TurnMessage* msg);
- void HandleChannelBindRequest(const TurnMessage* msg);
+ void HandleAllocateRequest(const cricket::TurnMessage* msg);
+ void HandleRefreshRequest(const cricket::TurnMessage* msg);
+ void HandleSendIndication(const cricket::TurnMessage* msg);
+ void HandleCreatePermissionRequest(const cricket::TurnMessage* msg);
+ void HandleChannelBindRequest(const cricket::TurnMessage* msg);
void OnExternalPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- static webrtc::TimeDelta ComputeLifetime(const TurnMessage& msg);
- bool HasPermission(const webrtc::IPAddress& addr);
- void AddPermission(const webrtc::IPAddress& addr);
- PermissionList::iterator FindPermission(const webrtc::IPAddress& addr);
+ static TimeDelta ComputeLifetime(const cricket::TurnMessage& msg);
+ bool HasPermission(const IPAddress& addr);
+ void AddPermission(const IPAddress& addr);
+ PermissionList::iterator FindPermission(const IPAddress& addr);
ChannelList::iterator FindChannel(int channel_id);
- ChannelList::iterator FindChannel(const webrtc::SocketAddress& addr);
+ ChannelList::iterator FindChannel(const SocketAddress& addr);
- void SendResponse(TurnMessage* msg);
- void SendBadRequestResponse(const TurnMessage* req);
- void SendErrorResponse(const TurnMessage* req,
+ void SendResponse(cricket::TurnMessage* msg);
+ void SendBadRequestResponse(const cricket::TurnMessage* req);
+ void SendErrorResponse(const cricket::TurnMessage* req,
int code,
absl::string_view reason);
- void SendExternal(const void* data,
- size_t size,
- const webrtc::SocketAddress& peer);
+ void SendExternal(const void* data, size_t size, const SocketAddress& peer);
TurnServer* const server_;
- webrtc::TaskQueueBase* const thread_;
+ TaskQueueBase* const thread_;
TurnServerConnection conn_;
std::unique_ptr<rtc::AsyncPacketSocket> external_socket_;
std::string key_;
@@ -146,7 +146,7 @@
std::string last_nonce_;
PermissionList perms_;
ChannelList channels_;
- webrtc::ScopedTaskSafety safety_;
+ ScopedTaskSafety safety_;
};
// An interface through which the MD5 credential hash can be retrieved.
@@ -164,14 +164,14 @@
// An interface enables Turn Server to control redirection behavior.
class TurnRedirectInterface {
public:
- virtual bool ShouldRedirect(const webrtc::SocketAddress& address,
- webrtc::SocketAddress* out) = 0;
+ virtual bool ShouldRedirect(const SocketAddress& address,
+ SocketAddress* out) = 0;
virtual ~TurnRedirectInterface() {}
};
class StunMessageObserver {
public:
- virtual void ReceivedMessage(const TurnMessage* msg) = 0;
+ virtual void ReceivedMessage(const cricket::TurnMessage* msg) = 0;
virtual void ReceivedChannelData(rtc::ArrayView<const uint8_t> payload) = 0;
virtual ~StunMessageObserver() {}
};
@@ -185,7 +185,7 @@
typedef std::map<TurnServerConnection, std::unique_ptr<TurnServerAllocation>>
AllocationMap;
- explicit TurnServer(webrtc::TaskQueueBase* thread);
+ explicit TurnServer(TaskQueueBase* thread);
~TurnServer() override;
// Gets/sets the realm value to use for the server.
@@ -246,18 +246,17 @@
}
// Starts listening for packets from internal clients.
- void AddInternalSocket(rtc::AsyncPacketSocket* socket,
- webrtc::ProtocolType proto);
+ void AddInternalSocket(rtc::AsyncPacketSocket* socket, ProtocolType proto);
// Starts listening for the connections on this socket. When someone tries
// to connect, the connection will be accepted and a new internal socket
// will be added.
void AddInternalServerSocket(
rtc::Socket* socket,
- webrtc::ProtocolType proto,
+ ProtocolType proto,
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory = nullptr);
// Specifies the factory to use for creating external sockets.
void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
- const webrtc::SocketAddress& address);
+ const SocketAddress& address);
// For testing only.
std::string SetTimestampForNextNonce(int64_t timestamp) {
RTC_DCHECK_RUN_ON(thread_);
@@ -288,15 +287,17 @@
void HandleStunMessage(TurnServerConnection* conn,
rtc::ArrayView<const uint8_t> payload)
RTC_RUN_ON(thread_);
- void HandleBindingRequest(TurnServerConnection* conn, const StunMessage* msg)
+ void HandleBindingRequest(TurnServerConnection* conn,
+ const cricket::StunMessage* msg)
RTC_RUN_ON(thread_);
void HandleAllocateRequest(TurnServerConnection* conn,
- const TurnMessage* msg,
+ const cricket::TurnMessage* msg,
absl::string_view key) RTC_RUN_ON(thread_);
- bool GetKey(const StunMessage* msg, std::string* key) RTC_RUN_ON(thread_);
+ bool GetKey(const cricket::StunMessage* msg, std::string* key)
+ RTC_RUN_ON(thread_);
bool CheckAuthorization(TurnServerConnection* conn,
- StunMessage* msg,
+ cricket::StunMessage* msg,
absl::string_view key) RTC_RUN_ON(thread_);
bool ValidateNonce(absl::string_view nonce) const RTC_RUN_ON(thread_);
@@ -308,38 +309,37 @@
RTC_RUN_ON(thread_);
void SendErrorResponse(TurnServerConnection* conn,
- const StunMessage* req,
+ const cricket::StunMessage* req,
int code,
absl::string_view reason);
void SendErrorResponseWithRealmAndNonce(TurnServerConnection* conn,
- const StunMessage* req,
+ const cricket::StunMessage* req,
int code,
absl::string_view reason)
RTC_RUN_ON(thread_);
void SendErrorResponseWithAlternateServer(TurnServerConnection* conn,
- const StunMessage* req,
- const webrtc::SocketAddress& addr)
+ const cricket::StunMessage* req,
+ const SocketAddress& addr)
RTC_RUN_ON(thread_);
- void SendStun(TurnServerConnection* conn, StunMessage* msg);
+ void SendStun(TurnServerConnection* conn, cricket::StunMessage* msg);
void Send(TurnServerConnection* conn, const rtc::ByteBufferWriter& buf);
void DestroyAllocation(TurnServerAllocation* allocation) RTC_RUN_ON(thread_);
void DestroyInternalSocket(rtc::AsyncPacketSocket* socket)
RTC_RUN_ON(thread_);
- typedef std::map<rtc::AsyncPacketSocket*, webrtc::ProtocolType>
- InternalSocketMap;
+ typedef std::map<rtc::AsyncPacketSocket*, ProtocolType> InternalSocketMap;
struct ServerSocketInfo {
- webrtc::ProtocolType proto;
+ ProtocolType proto;
// If non-null, used to wrap accepted sockets.
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory;
};
typedef std::map<rtc::Socket*, ServerSocketInfo> ServerSocketMap;
- webrtc::TaskQueueBase* const thread_;
+ TaskQueueBase* const thread_;
const std::string nonce_key_;
std::string realm_ RTC_GUARDED_BY(thread_);
std::string software_ RTC_GUARDED_BY(thread_);
@@ -357,7 +357,7 @@
ServerSocketMap server_listen_sockets_ RTC_GUARDED_BY(thread_);
std::unique_ptr<rtc::PacketSocketFactory> external_socket_factory_
RTC_GUARDED_BY(thread_);
- webrtc::SocketAddress external_addr_ RTC_GUARDED_BY(thread_);
+ SocketAddress external_addr_ RTC_GUARDED_BY(thread_);
AllocationMap allocations_ RTC_GUARDED_BY(thread_);
@@ -372,6 +372,20 @@
friend class TurnServerAllocation;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::kMaxTurnChannelNumber;
+using ::webrtc::kMinTurnChannelNumber;
+using ::webrtc::StunMessageObserver;
+using ::webrtc::TURN_SERVER_PORT;
+using ::webrtc::TurnAuthInterface;
+using ::webrtc::TurnRedirectInterface;
+using ::webrtc::TurnServer;
+using ::webrtc::TurnServerAllocation;
+using ::webrtc::TurnServerConnection;
} // namespace cricket
#endif // P2P_TEST_TURN_SERVER_H_
diff --git a/p2p/test/turn_server_unittest.cc b/p2p/test/turn_server_unittest.cc
index 38d1371..a90b9fd 100644
--- a/p2p/test/turn_server_unittest.cc
+++ b/p2p/test/turn_server_unittest.cc
@@ -23,7 +23,7 @@
// NOTE: This is a work in progress. Currently this file only has tests for
// TurnServerConnection, a primitive class used by TurnServer.
-namespace cricket {
+namespace webrtc {
class TurnServerConnectionTest : public ::testing::Test {
public:
@@ -52,11 +52,9 @@
TEST_F(TurnServerConnectionTest, ComparisonOperators) {
std::unique_ptr<rtc::AsyncPacketSocket> socket1(
- socket_factory_.CreateUdpSocket(webrtc::SocketAddress("1.1.1.1", 1), 0,
- 0));
+ socket_factory_.CreateUdpSocket(SocketAddress("1.1.1.1", 1), 0, 0));
std::unique_ptr<rtc::AsyncPacketSocket> socket2(
- socket_factory_.CreateUdpSocket(webrtc::SocketAddress("2.2.2.2", 2), 0,
- 0));
+ socket_factory_.CreateUdpSocket(SocketAddress("2.2.2.2", 2), 0, 0));
TurnServerConnection connection1(socket2->GetLocalAddress(), PROTO_UDP,
socket1.get());
TurnServerConnection connection2(socket2->GetLocalAddress(), PROTO_UDP,
@@ -70,4 +68,4 @@
ExpectNotEqual(connection1, connection4);
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index 0399aa3..e480a03 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -222,10 +222,10 @@
if (flags1 & RAW_PACKET_TRANSPORT) {
fake_rtp_packet_transport1_.reset(
- new rtc::FakePacketTransport("channel1_rtp"));
+ new webrtc::FakePacketTransport("channel1_rtp"));
if (!(flags1 & RTCP_MUX)) {
fake_rtcp_packet_transport1_.reset(
- new rtc::FakePacketTransport("channel1_rtcp"));
+ new webrtc::FakePacketTransport("channel1_rtcp"));
}
} else {
// Confirmed to work with KT_RSA and KT_ECDSA.
@@ -248,10 +248,10 @@
// Based on flags, create fake DTLS or raw packet transports.
if (flags2 & RAW_PACKET_TRANSPORT) {
fake_rtp_packet_transport2_.reset(
- new rtc::FakePacketTransport("channel2_rtp"));
+ new webrtc::FakePacketTransport("channel2_rtp"));
if (!(flags2 & RTCP_MUX)) {
fake_rtcp_packet_transport2_.reset(
- new rtc::FakePacketTransport("channel2_rtcp"));
+ new webrtc::FakePacketTransport("channel2_rtcp"));
}
} else {
// Confirmed to work with KT_RSA and KT_ECDSA.
@@ -1571,10 +1571,10 @@
std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport1_;
std::unique_ptr<cricket::FakeDtlsTransport> fake_rtp_dtls_transport2_;
std::unique_ptr<cricket::FakeDtlsTransport> fake_rtcp_dtls_transport2_;
- std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport1_;
- std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport1_;
- std::unique_ptr<rtc::FakePacketTransport> fake_rtp_packet_transport2_;
- std::unique_ptr<rtc::FakePacketTransport> fake_rtcp_packet_transport2_;
+ std::unique_ptr<webrtc::FakePacketTransport> fake_rtp_packet_transport1_;
+ std::unique_ptr<webrtc::FakePacketTransport> fake_rtcp_packet_transport1_;
+ std::unique_ptr<webrtc::FakePacketTransport> fake_rtp_packet_transport2_;
+ std::unique_ptr<webrtc::FakePacketTransport> fake_rtcp_packet_transport2_;
std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport1_;
std::unique_ptr<webrtc::RtpTransportInternal> rtp_transport2_;
std::unique_ptr<webrtc::RtpTransportInternal> new_rtp_transport_;
diff --git a/pc/data_channel_integrationtest.cc b/pc/data_channel_integrationtest.cc
index 50e124c..92d27b3 100644
--- a/pc/data_channel_integrationtest.cc
+++ b/pc/data_channel_integrationtest.cc
@@ -1513,7 +1513,7 @@
"192.0.2.1", 3478};
static const rtc::SocketAddress turn_server_1_external_address{
"192.0.3.1", 0};
- cricket::TestTurnServer* turn_server_1 = CreateTurnServer(
+ TestTurnServer* turn_server_1 = CreateTurnServer(
turn_server_1_internal_address, turn_server_1_external_address);
// Bypass permission check on received packets so media can be sent before
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index 863cd35..d3a945b 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -1971,8 +1971,8 @@
}
void StartStunServer(const SocketAddress& server_address) {
- stun_server_ = cricket::TestStunServer::Create(firewall(), server_address,
- *network_thread());
+ stun_server_ =
+ TestStunServer::Create(firewall(), server_address, *network_thread());
}
bool TestIPv6() {
@@ -2015,7 +2015,7 @@
private:
uint32_t port_allocator_flags_;
- cricket::TestStunServer::StunServerPtr stun_server_;
+ TestStunServer::StunServerPtr stun_server_;
};
// Ensure FakeClockForTest is constructed first (see class for rationale).
@@ -2535,10 +2535,10 @@
static const SocketAddress turn_server_1_external_address{"88.88.88.1", 0};
static const SocketAddress turn_server_2_internal_address{"99.99.99.0", 3478};
static const SocketAddress turn_server_2_external_address{"99.99.99.1", 0};
- cricket::TestTurnServer* turn_server_1 = CreateTurnServer(
+ TestTurnServer* turn_server_1 = CreateTurnServer(
turn_server_1_internal_address, turn_server_1_external_address);
- cricket::TestTurnServer* turn_server_2 = CreateTurnServer(
+ TestTurnServer* turn_server_2 = CreateTurnServer(
turn_server_2_internal_address, turn_server_2_external_address);
// Bypass permission check on received packets so media can be sent before
// the candidate is signaled.
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index 341d879..cda8dcb 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -252,13 +252,13 @@
const std::string& common_name = "test turn server") {
rtc::Thread* thread = network_thread();
rtc::SocketFactory* factory = &firewall_socket_server_;
- std::unique_ptr<cricket::TestTurnServer> turn_server;
+ std::unique_ptr<TestTurnServer> turn_server;
SendTask(network_thread(), [&] {
static const SocketAddress turn_server_internal_address{
kTurnInternalAddress, kTurnInternalPort};
static const SocketAddress turn_server_external_address{
kTurnExternalAddress, kTurnExternalPort};
- turn_server = std::make_unique<cricket::TestTurnServer>(
+ turn_server = std::make_unique<TestTurnServer>(
thread, factory, turn_server_internal_address,
turn_server_external_address, type, true /*ignore_bad_certs=*/,
common_name);
@@ -328,7 +328,7 @@
Clock* const clock_;
// The turn servers should be accessed & deleted on the network thread to
// avoid a race with the socket read/write which occurs on the network thread.
- std::vector<std::unique_ptr<cricket::TestTurnServer>> turn_servers_;
+ std::vector<std::unique_ptr<TestTurnServer>> turn_servers_;
// `virtual_socket_server_` is used by `network_thread_` so it must be
// destroyed later.
// TODO(bugs.webrtc.org/7668): We would like to update the virtual network we
diff --git a/pc/rtp_transport_unittest.cc b/pc/rtp_transport_unittest.cc
index ef616bb..6b8b9d1 100644
--- a/pc/rtp_transport_unittest.cc
+++ b/pc/rtp_transport_unittest.cc
@@ -97,9 +97,9 @@
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtcp("fake_rtcp");
+ FakePacketTransport fake_rtcp("fake_rtcp");
fake_rtcp.SetWritable(true);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready
@@ -111,9 +111,9 @@
TEST(RtpTransportTest, SettingRtpAndRtcpSignalsReady) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtcp("fake_rtcp");
+ FakePacketTransport fake_rtcp("fake_rtcp");
fake_rtcp.SetWritable(true);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
@@ -125,7 +125,7 @@
TEST(RtpTransportTest, SettingRtpWithRtcpMuxEnabledSignalsReady) {
RtpTransport transport(kMuxEnabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
@@ -135,7 +135,7 @@
TEST(RtpTransportTest, DisablingRtcpMuxSignalsNotReady) {
RtpTransport transport(kMuxEnabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
@@ -148,7 +148,7 @@
TEST(RtpTransportTest, EnablingRtcpMuxSignalsReady) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
@@ -162,7 +162,7 @@
TEST(RtpTransportTest, SetRtpTransportWithNetworkRouteChanged) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
EXPECT_FALSE(observer.network_route());
@@ -191,7 +191,7 @@
TEST(RtpTransportTest, SetRtcpTransportWithNetworkRouteChanged) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
SignalObserver observer(&transport);
- rtc::FakePacketTransport fake_rtcp("fake_rtcp");
+ FakePacketTransport fake_rtcp("fake_rtcp");
EXPECT_FALSE(observer.network_route());
@@ -223,8 +223,8 @@
// If the RTCP-mux is not enabled, RTCP packets are expected to be sent over
// the RtcpPacketTransport.
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
- rtc::FakePacketTransport fake_rtcp("fake_rtcp");
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtcp("fake_rtcp");
+ FakePacketTransport fake_rtp("fake_rtp");
transport.SetRtcpPacketTransport(&fake_rtcp); // rtcp ready
transport.SetRtpPacketTransport(&fake_rtp); // rtp ready
SignalObserver observer(&transport);
@@ -246,7 +246,7 @@
TEST(RtpTransportTest, ChangingReadyToSendStateOnlySignalsWhenChanged) {
RtpTransport transport(kMuxEnabled, ExplicitKeyValueConfig(""));
TransportObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetWritable(true);
// State changes, so we should signal.
@@ -270,7 +270,7 @@
// received.
TEST(RtpTransportTest, SignalDemuxedRtcp) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetDestination(&fake_rtp, true);
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
@@ -293,7 +293,7 @@
// handled payload type is received.
TEST(RtpTransportTest, SignalHandledRtpPayloadType) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetDestination(&fake_rtp, true);
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
@@ -317,7 +317,7 @@
TEST(RtpTransportTest, ReceivedPacketEcnMarkingPropagatedToDemuxedPacket) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
// Setup FakePacketTransport to send packets to itself.
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetDestination(&fake_rtp, true);
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
@@ -341,7 +341,7 @@
// unhandled payload type is received.
TEST(RtpTransportTest, DontSignalUnhandledRtpPayloadType) {
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetDestination(&fake_rtp, true);
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
@@ -367,7 +367,7 @@
RtpTransport transport(kMuxEnabled, ExplicitKeyValueConfig(""));
TransportObserver observer(&transport);
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
fake_rtp.SetDestination(&fake_rtp, true);
transport.SetRtpPacketTransport(&fake_rtp);
fake_rtp.SetWritable(true);
@@ -391,7 +391,7 @@
RtpTransport transport(
kMuxEnabled,
ExplicitKeyValueConfig("WebRTC-SetReadyToSendFalseIfSendFail/Enabled/"));
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
transport.SetRtpPacketTransport(&fake_rtp);
TransportObserver observer(&transport);
observer.SetActionOnReadyToSend([&](bool ready) {
@@ -418,7 +418,7 @@
const int kShortTimeout = 100;
test::RunLoop loop;
RtpTransport transport(kMuxDisabled, ExplicitKeyValueConfig(""));
- rtc::FakePacketTransport fake_rtp("fake_rtp");
+ FakePacketTransport fake_rtp("fake_rtp");
transport.SetRtpPacketTransport(&fake_rtp);
fake_rtp.SetDestination(&fake_rtp, true);
TransportObserver observer(&transport);
diff --git a/pc/slow_peer_connection_integration_test.cc b/pc/slow_peer_connection_integration_test.cc
index b6fc7a4..28a858f 100644
--- a/pc/slow_peer_connection_integration_test.cc
+++ b/pc/slow_peer_connection_integration_test.cc
@@ -280,8 +280,8 @@
}
void StartStunServer(const SocketAddress& server_address) {
- stun_server_ = cricket::TestStunServer::Create(firewall(), server_address,
- *network_thread());
+ stun_server_ =
+ TestStunServer::Create(firewall(), server_address, *network_thread());
}
bool TestIPv6() {
@@ -324,7 +324,7 @@
private:
uint32_t port_allocator_flags_;
- cricket::TestStunServer::StunServerPtr stun_server_;
+ TestStunServer::StunServerPtr stun_server_;
};
// Ensure FakeClockForTest is constructed first (see class for rationale).
@@ -341,7 +341,7 @@
// to time out.
TEST_P(PeerConnectionIntegrationIceStatesTestWithFakeClock, VerifyIceStates) {
const SocketAddress kStunServerAddress =
- SocketAddress("99.99.99.1", cricket::STUN_SERVER_PORT);
+ SocketAddress("99.99.99.1", STUN_SERVER_PORT);
StartStunServer(kStunServerAddress);
PeerConnectionInterface::RTCConfiguration config;
diff --git a/pc/srtp_transport_unittest.cc b/pc/srtp_transport_unittest.cc
index 890474c..a742fb9 100644
--- a/pc/srtp_transport_unittest.cc
+++ b/pc/srtp_transport_unittest.cc
@@ -55,9 +55,9 @@
bool rtcp_mux_enabled = true;
rtp_packet_transport1_ =
- std::make_unique<rtc::FakePacketTransport>("fake_packet_transport1");
+ std::make_unique<FakePacketTransport>("fake_packet_transport1");
rtp_packet_transport2_ =
- std::make_unique<rtc::FakePacketTransport>("fake_packet_transport2");
+ std::make_unique<FakePacketTransport>("fake_packet_transport2");
bool asymmetric = false;
rtp_packet_transport1_->SetDestination(rtp_packet_transport2_.get(),
@@ -158,7 +158,7 @@
original_rtp_data, rtp_len));
// Get the encrypted packet from underneath packet transport and verify
// the data is actually encrypted.
- auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ auto fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport1_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
original_rtp_data, rtp_len));
@@ -173,7 +173,7 @@
ASSERT_TRUE(rtp_sink1_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
- auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ auto fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
original_rtp_data, rtp_len));
@@ -202,7 +202,7 @@
rtcp_packet_data, rtcp_len));
// Get the encrypted packet from underneath packet transport and verify the
// data is actually encrypted.
- auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ auto fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport1_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
rtcp_packet_data, rtcp_len));
@@ -213,7 +213,7 @@
ASSERT_TRUE(rtp_sink1_.last_recv_rtcp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtcp_packet().data(),
rtcp_packet_data, rtcp_len));
- fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
rtcp_packet_data, rtcp_len));
@@ -280,7 +280,7 @@
original_rtp_data, rtp_len));
// Get the encrypted packet from underneath packet transport and verify the
// data and header extension are actually encrypted.
- auto fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ auto fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport1_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
original_rtp_data, rtp_len));
@@ -296,7 +296,7 @@
ASSERT_TRUE(rtp_sink1_.last_recv_rtp_packet().data());
EXPECT_EQ(0, memcmp(rtp_sink1_.last_recv_rtp_packet().data(),
original_rtp_data, rtp_len));
- fake_rtp_packet_transport = static_cast<rtc::FakePacketTransport*>(
+ fake_rtp_packet_transport = static_cast<FakePacketTransport*>(
srtp_transport2_->rtp_packet_transport());
EXPECT_NE(0, memcmp(fake_rtp_packet_transport->last_sent_packet()->data(),
original_rtp_data, rtp_len));
@@ -333,8 +333,8 @@
std::unique_ptr<SrtpTransport> srtp_transport1_;
std::unique_ptr<SrtpTransport> srtp_transport2_;
- std::unique_ptr<rtc::FakePacketTransport> rtp_packet_transport1_;
- std::unique_ptr<rtc::FakePacketTransport> rtp_packet_transport2_;
+ std::unique_ptr<FakePacketTransport> rtp_packet_transport1_;
+ std::unique_ptr<FakePacketTransport> rtp_packet_transport2_;
TransportObserver rtp_sink1_;
TransportObserver rtp_sink2_;
@@ -426,8 +426,8 @@
"WebRTC-SrtpRemoveReceiveStream/Enabled/");
auto srtp_transport =
std::make_unique<SrtpTransport>(/*rtcp_mux_enabled=*/true, field_trials);
- auto rtp_packet_transport = std::make_unique<rtc::FakePacketTransport>(
- "fake_packet_transport_loopback");
+ auto rtp_packet_transport =
+ std::make_unique<FakePacketTransport>("fake_packet_transport_loopback");
bool asymmetric = false;
rtp_packet_transport->SetDestination(rtp_packet_transport.get(), asymmetric);
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index fb2bf9a..b2d2e41 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -1635,16 +1635,16 @@
return caller_ && callee_;
}
- cricket::TestTurnServer* CreateTurnServer(
+ TestTurnServer* CreateTurnServer(
SocketAddress internal_address,
SocketAddress external_address,
ProtocolType type = ProtocolType::PROTO_UDP,
const std::string& common_name = "test turn server") {
rtc::Thread* thread = network_thread();
rtc::SocketFactory* socket_factory = fss_.get();
- std::unique_ptr<cricket::TestTurnServer> turn_server;
+ std::unique_ptr<TestTurnServer> turn_server;
SendTask(network_thread(), [&] {
- turn_server = std::make_unique<cricket::TestTurnServer>(
+ turn_server = std::make_unique<TestTurnServer>(
thread, socket_factory, internal_address, external_address, type,
/*ignore_bad_certs=*/true, common_name);
});
@@ -1653,11 +1653,10 @@
return turn_servers_.back().get();
}
- cricket::TestTurnCustomizer* CreateTurnCustomizer() {
- std::unique_ptr<cricket::TestTurnCustomizer> turn_customizer;
- SendTask(network_thread(), [&] {
- turn_customizer = std::make_unique<cricket::TestTurnCustomizer>();
- });
+ TestTurnCustomizer* CreateTurnCustomizer() {
+ std::unique_ptr<TestTurnCustomizer> turn_customizer;
+ SendTask(network_thread(),
+ [&] { turn_customizer = std::make_unique<TestTurnCustomizer>(); });
turn_customizers_.push_back(std::move(turn_customizer));
// Interactions with the turn customizer should be done on the network
// thread.
@@ -1667,7 +1666,7 @@
// Checks that the function counters for a TestTurnCustomizer are greater than
// 0.
void ExpectTurnCustomizerCountersIncremented(
- cricket::TestTurnCustomizer* turn_customizer) {
+ TestTurnCustomizer* turn_customizer) {
SendTask(network_thread(), [turn_customizer] {
EXPECT_GT(turn_customizer->allow_channel_data_cnt_, 0u);
EXPECT_GT(turn_customizer->modify_cnt_, 0u);
@@ -1922,8 +1921,8 @@
// The turn servers and turn customizers should be accessed & deleted on the
// network thread to avoid a race with the socket read/write that occurs
// on the network thread.
- std::vector<std::unique_ptr<cricket::TestTurnServer>> turn_servers_;
- std::vector<std::unique_ptr<cricket::TestTurnCustomizer>> turn_customizers_;
+ std::vector<std::unique_ptr<TestTurnServer>> turn_servers_;
+ std::vector<std::unique_ptr<TestTurnCustomizer>> turn_customizers_;
std::unique_ptr<PeerConnectionIntegrationWrapper> caller_;
std::unique_ptr<PeerConnectionIntegrationWrapper> callee_;
std::string field_trials_;
diff --git a/rtc_base/ssl_identity.h b/rtc_base/ssl_identity.h
index 46b36de..96462df 100644
--- a/rtc_base/ssl_identity.h
+++ b/rtc_base/ssl_identity.h
@@ -55,7 +55,7 @@
class RTC_EXPORT KeyParams {
public:
// Generate a KeyParams object from a simple KeyType, using default params.
- explicit KeyParams(KeyType key_type = KT_DEFAULT);
+ explicit KeyParams(KeyType key_type = rtc::KT_DEFAULT);
// Generate a a KeyParams for RSA with explicit parameters.
static KeyParams RSA(int mod_size = rtc::kRsaDefaultModSize,
diff --git a/test/network/emulated_turn_server.cc b/test/network/emulated_turn_server.cc
index 49b29e4..b4ae8f2 100644
--- a/test/network/emulated_turn_server.cc
+++ b/test/network/emulated_turn_server.cc
@@ -141,7 +141,7 @@
SendTask(thread_.get(), [this, enable_permission_checks =
config.enable_permission_checks]() {
RTC_DCHECK_RUN_ON(thread_.get());
- turn_server_ = std::make_unique<cricket::TurnServer>(thread_.get());
+ turn_server_ = std::make_unique<TurnServer>(thread_.get());
turn_server_->set_realm(kTestRealm);
turn_server_->set_realm(kTestSoftware);
turn_server_->set_auth_hook(this);
diff --git a/test/network/emulated_turn_server.h b/test/network/emulated_turn_server.h
index fed93aa..eedd86b 100644
--- a/test/network/emulated_turn_server.h
+++ b/test/network/emulated_turn_server.h
@@ -40,7 +40,7 @@
// using a wrapper around AsyncPacketSocket (no lookup required as the
// wrapper around AsyncPacketSocket keep a pointer to the EmulatedEndpoint).
class EmulatedTURNServer : public EmulatedTURNServerInterface,
- public cricket::TurnAuthInterface,
+ public TurnAuthInterface,
public webrtc::EmulatedNetworkReceiverInterface {
public:
// Create an EmulatedTURNServer.
@@ -88,7 +88,7 @@
IceServerConfig ice_config_;
EmulatedEndpoint* const client_;
EmulatedEndpoint* const peer_;
- std::unique_ptr<cricket::TurnServer> turn_server_ RTC_GUARDED_BY(&thread_);
+ std::unique_ptr<TurnServer> turn_server_ RTC_GUARDED_BY(&thread_);
class AsyncPacketSocketWrapper;
std::map<SocketAddress, AsyncPacketSocketWrapper*> sockets_
RTC_GUARDED_BY(&thread_);
