Move socket_address.h to webrtc namespace
Bug: webrtc:42232595
Change-Id: I58a5a286887e66fad95c6acf146808623a76dd0d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/380842
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Auto-Submit: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44111}
diff --git a/api/async_dns_resolver.h b/api/async_dns_resolver.h
index d055a5b..11fdf67 100644
--- a/api/async_dns_resolver.h
+++ b/api/async_dns_resolver.h
@@ -45,8 +45,7 @@
// If the address was successfully resolved, sets `addr` to a copy of the
// address from `Start` with the IP address set to the top most resolved
// address of `family` (`addr` will have both hostname and the resolved ip).
- virtual bool GetResolvedAddress(int family,
- rtc::SocketAddress* addr) const = 0;
+ virtual bool GetResolvedAddress(int family, SocketAddress* addr) const = 0;
// Returns error from resolver.
virtual int GetError() const = 0;
};
@@ -61,10 +60,10 @@
virtual ~AsyncDnsResolverInterface() = default;
// Start address resolution of the hostname in `addr`.
- virtual void Start(const rtc::SocketAddress& addr,
+ virtual void Start(const SocketAddress& addr,
absl::AnyInvocable<void()> callback) = 0;
// Start address resolution of the hostname in `addr` matching `family`.
- virtual void Start(const rtc::SocketAddress& addr,
+ virtual void Start(const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) = 0;
virtual const AsyncDnsResolverResult& result() const = 0;
@@ -81,14 +80,14 @@
// will be called when resolution is finished.
// The callback will be called on the sequence that the caller runs on.
virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
absl::AnyInvocable<void()> callback) = 0;
// Creates an AsyncDnsResolver and starts resolving the name to an address
// matching the specified family. The callback will be called when resolution
// is finished. The callback will be called on the sequence that the caller
// runs on.
virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) = 0;
// Creates an AsyncDnsResolver and does not start it.
diff --git a/api/candidate.cc b/api/candidate.cc
index ace912e..dd92774 100644
--- a/api/candidate.cc
+++ b/api/candidate.cc
@@ -56,7 +56,7 @@
Candidate::Candidate(int component,
absl::string_view protocol,
- const rtc::SocketAddress& address,
+ const webrtc::SocketAddress& address,
uint32_t priority,
absl::string_view username,
absl::string_view password,
@@ -203,22 +203,23 @@
webrtc::IPAddress ip;
if (address().hostname().empty()) {
// IP needs to be redacted, but no hostname available.
- rtc::SocketAddress redacted_addr("redacted-ip.invalid", address().port());
+ webrtc::SocketAddress redacted_addr("redacted-ip.invalid",
+ address().port());
copy.set_address(redacted_addr);
} else if (webrtc::IPFromString(address().hostname(), &ip)) {
// The hostname is an IP literal, and needs to be redacted too.
- rtc::SocketAddress redacted_addr("redacted-literal.invalid",
- address().port());
+ webrtc::SocketAddress redacted_addr("redacted-literal.invalid",
+ address().port());
copy.set_address(redacted_addr);
} else {
- rtc::SocketAddress hostname_only_addr(address().hostname(),
- address().port());
+ webrtc::SocketAddress hostname_only_addr(address().hostname(),
+ address().port());
copy.set_address(hostname_only_addr);
}
}
if (filter_related_address) {
copy.set_related_address(
- rtc::EmptySocketAddressWithFamily(copy.address().family()));
+ webrtc::EmptySocketAddressWithFamily(copy.address().family()));
}
if (filter_ufrag) {
copy.set_username("");
@@ -227,7 +228,7 @@
return copy;
}
-void Candidate::ComputeFoundation(const rtc::SocketAddress& base_address,
+void Candidate::ComputeFoundation(const webrtc::SocketAddress& base_address,
uint64_t tie_breaker) {
// https://www.rfc-editor.org/rfc/rfc5245#section-4.1.1.3
// The foundation is an identifier, scoped within a session. Two candidates
diff --git a/api/candidate.h b/api/candidate.h
index ae54d74..0b56681 100644
--- a/api/candidate.h
+++ b/api/candidate.h
@@ -50,7 +50,7 @@
Candidate();
Candidate(int component,
absl::string_view protocol,
- const rtc::SocketAddress& address,
+ const webrtc::SocketAddress& address,
uint32_t priority,
absl::string_view username,
absl::string_view password,
@@ -87,8 +87,8 @@
Assign(relay_protocol_, protocol);
}
- const rtc::SocketAddress& address() const { return address_; }
- void set_address(const rtc::SocketAddress& address) { address_ = address; }
+ const webrtc::SocketAddress& address() const { return address_; }
+ void set_address(const webrtc::SocketAddress& address) { address_ = address; }
uint32_t priority() const { return priority_; }
void set_priority(const uint32_t priority) { priority_ = priority; }
@@ -185,8 +185,10 @@
Assign(foundation_, foundation);
}
- const rtc::SocketAddress& related_address() const { return related_address_; }
- void set_related_address(const rtc::SocketAddress& related_address) {
+ const webrtc::SocketAddress& related_address() const {
+ return related_address_;
+ }
+ void set_related_address(const webrtc::SocketAddress& related_address) {
related_address_ = related_address;
}
const std::string& tcptype() const { return tcptype_; }
@@ -249,7 +251,7 @@
// characteristics. Foundations are used in the frozen algorithm.
// A session wide (peerconnection) tie-breaker is applied to the foundation,
// adds additional randomness and must be the same for all candidates.
- void ComputeFoundation(const rtc::SocketAddress& base_address,
+ void ComputeFoundation(const webrtc::SocketAddress& base_address,
uint64_t tie_breaker);
// https://www.rfc-editor.org/rfc/rfc5245#section-7.2.1.3
@@ -270,7 +272,7 @@
int component_;
std::string protocol_;
std::string relay_protocol_;
- rtc::SocketAddress address_;
+ webrtc::SocketAddress address_;
uint32_t priority_;
std::string username_;
std::string password_;
@@ -280,7 +282,7 @@
rtc::AdapterType underlying_type_for_vpn_;
uint32_t generation_;
std::string foundation_;
- rtc::SocketAddress related_address_;
+ webrtc::SocketAddress related_address_;
std::string tcptype_;
std::string transport_name_;
uint16_t network_id_;
diff --git a/api/candidate_unittest.cc b/api/candidate_unittest.cc
index 3091629..91b89c9 100644
--- a/api/candidate_unittest.cc
+++ b/api/candidate_unittest.cc
@@ -62,7 +62,7 @@
c.set_protocol("udp");
c.set_relay_protocol("udp");
- rtc::SocketAddress address("99.99.98.1", 1024);
+ webrtc::SocketAddress address("99.99.98.1", 1024);
c.set_address(address);
c.ComputeFoundation(c.address(), 1);
std::string foundation1 = c.foundation();
diff --git a/api/packet_socket_factory.h b/api/packet_socket_factory.h
index a73d3de..8c5ea6f 100644
--- a/api/packet_socket_factory.h
+++ b/api/packet_socket_factory.h
@@ -56,18 +56,19 @@
PacketSocketFactory() = default;
virtual ~PacketSocketFactory() = default;
- virtual AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
- uint16_t min_port,
- uint16_t max_port) = 0;
+ virtual AsyncPacketSocket* CreateUdpSocket(
+ const webrtc::SocketAddress& address,
+ uint16_t min_port,
+ uint16_t max_port) = 0;
virtual AsyncListenSocket* CreateServerTcpSocket(
- const SocketAddress& local_address,
+ const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) = 0;
virtual AsyncPacketSocket* CreateClientTcpSocket(
- const SocketAddress& local_address,
- const SocketAddress& remote_address,
+ const webrtc::SocketAddress& local_address,
+ const webrtc::SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) = 0;
virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface>
diff --git a/api/test/mock_async_dns_resolver.h b/api/test/mock_async_dns_resolver.h
index d6a7148..5848972 100644
--- a/api/test/mock_async_dns_resolver.h
+++ b/api/test/mock_async_dns_resolver.h
@@ -24,7 +24,7 @@
public:
MOCK_METHOD(bool,
GetResolvedAddress,
- (int, rtc::SocketAddress*),
+ (int, webrtc::SocketAddress*),
(const, override));
MOCK_METHOD(int, GetError, (), (const, override));
};
@@ -33,11 +33,11 @@
public:
MOCK_METHOD(void,
Start,
- (const rtc::SocketAddress&, absl::AnyInvocable<void()>),
+ (const webrtc::SocketAddress&, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(void,
Start,
- (const rtc::SocketAddress&,
+ (const webrtc::SocketAddress&,
int family,
absl::AnyInvocable<void()>),
(override));
@@ -48,11 +48,11 @@
public:
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
CreateAndResolve,
- (const rtc::SocketAddress&, absl::AnyInvocable<void()>),
+ (const webrtc::SocketAddress&, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
CreateAndResolve,
- (const rtc::SocketAddress&, int, absl::AnyInvocable<void()>),
+ (const webrtc::SocketAddress&, int, absl::AnyInvocable<void()>),
(override));
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
Create,
diff --git a/api/test/mock_packet_socket_factory.h b/api/test/mock_packet_socket_factory.h
index d54be78..0e4a42c 100644
--- a/api/test/mock_packet_socket_factory.h
+++ b/api/test/mock_packet_socket_factory.h
@@ -26,16 +26,16 @@
public:
MOCK_METHOD(AsyncPacketSocket*,
CreateUdpSocket,
- (const SocketAddress&, uint16_t, uint16_t),
+ (const webrtc::SocketAddress&, uint16_t, uint16_t),
(override));
MOCK_METHOD(AsyncListenSocket*,
CreateServerTcpSocket,
- (const SocketAddress&, uint16_t, uint16_t, int opts),
+ (const webrtc::SocketAddress&, uint16_t, uint16_t, int opts),
(override));
MOCK_METHOD(AsyncPacketSocket*,
CreateClientTcpSocket,
- (const SocketAddress& local_address,
- const SocketAddress&,
+ (const webrtc::SocketAddress& local_address,
+ const webrtc::SocketAddress&,
const PacketSocketTcpOptions&),
(override));
MOCK_METHOD(std::unique_ptr<webrtc::AsyncDnsResolverInterface>,
diff --git a/api/test/network_emulation/network_emulation_interfaces.cc b/api/test/network_emulation/network_emulation_interfaces.cc
index 3986f82..79dc4bd 100644
--- a/api/test/network_emulation/network_emulation_interfaces.cc
+++ b/api/test/network_emulation/network_emulation_interfaces.cc
@@ -21,8 +21,8 @@
namespace webrtc {
-EmulatedIpPacket::EmulatedIpPacket(const rtc::SocketAddress& from,
- const rtc::SocketAddress& to,
+EmulatedIpPacket::EmulatedIpPacket(const SocketAddress& from,
+ const SocketAddress& to,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time,
uint16_t application_overhead,
diff --git a/api/test/network_emulation/network_emulation_interfaces.h b/api/test/network_emulation/network_emulation_interfaces.h
index 346cc80..11d19c0 100644
--- a/api/test/network_emulation/network_emulation_interfaces.h
+++ b/api/test/network_emulation/network_emulation_interfaces.h
@@ -31,8 +31,8 @@
struct EmulatedIpPacket {
public:
- EmulatedIpPacket(const rtc::SocketAddress& from,
- const rtc::SocketAddress& to,
+ EmulatedIpPacket(const SocketAddress& from,
+ const SocketAddress& to,
rtc::CopyOnWriteBuffer data,
Timestamp arrival_time,
uint16_t application_overhead = 0,
@@ -49,8 +49,8 @@
const uint8_t* cdata() const { return data.cdata(); }
size_t ip_packet_size() const { return size() + headers_size; }
- rtc::SocketAddress from;
- rtc::SocketAddress to;
+ SocketAddress from;
+ SocketAddress to;
// Holds the UDP payload.
rtc::CopyOnWriteBuffer data;
uint16_t headers_size;
@@ -258,8 +258,8 @@
// socket.
// `to` will be used for routing verification and picking right socket by port
// on destination endpoint.
- virtual void SendPacket(const rtc::SocketAddress& from,
- const rtc::SocketAddress& to,
+ virtual void SendPacket(const SocketAddress& from,
+ const SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead = 0,
EcnMarking ecn = EcnMarking::kNotEct) = 0;
diff --git a/api/test/network_emulation_manager.h b/api/test/network_emulation_manager.h
index b2773de..ce1173d 100644
--- a/api/test/network_emulation_manager.h
+++ b/api/test/network_emulation_manager.h
@@ -115,7 +115,7 @@
// Returns socket address, which client should use to connect to TURN server
// and do TURN allocation.
- virtual rtc::SocketAddress GetClientEndpointAddress() const = 0;
+ virtual SocketAddress GetClientEndpointAddress() const = 0;
// Get non-null peer endpoint, that is "connected to the internet".
// This shall typically be connected to another TURN server.
diff --git a/api/transport/stun.cc b/api/transport/stun.cc
index 77bc79f..78552d66e 100644
--- a/api/transport/stun.cc
+++ b/api/transport/stun.cc
@@ -877,7 +877,7 @@
}
StunAddressAttribute::StunAddressAttribute(uint16_t type,
- const rtc::SocketAddress& addr)
+ const webrtc::SocketAddress& addr)
: StunAttribute(type, 0) {
SetAddress(addr);
}
@@ -911,7 +911,7 @@
return false;
}
webrtc::IPAddress ipaddr(v4addr);
- SetAddress(rtc::SocketAddress(ipaddr, port));
+ SetAddress(webrtc::SocketAddress(ipaddr, port));
} else if (stun_family == STUN_ADDRESS_IPV6) {
in6_addr v6addr;
if (length() != SIZE_IP6) {
@@ -922,7 +922,7 @@
return false;
}
webrtc::IPAddress ipaddr(v6addr);
- SetAddress(rtc::SocketAddress(ipaddr, port));
+ SetAddress(webrtc::SocketAddress(ipaddr, port));
} else {
return false;
}
@@ -955,8 +955,9 @@
return true;
}
-StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
- const rtc::SocketAddress& addr)
+StunXorAddressAttribute::StunXorAddressAttribute(
+ uint16_t type,
+ const webrtc::SocketAddress& addr)
: StunAddressAttribute(type, addr), owner_(NULL) {}
StunXorAddressAttribute::StunXorAddressAttribute(uint16_t type,
@@ -1013,7 +1014,7 @@
return false;
uint16_t xoredport = port() ^ (kStunMagicCookie >> 16);
webrtc::IPAddress xored_ip = GetXoredIP();
- SetAddress(rtc::SocketAddress(xored_ip, xoredport));
+ SetAddress(webrtc::SocketAddress(xored_ip, xoredport));
return true;
}
diff --git a/api/transport/stun.h b/api/transport/stun.h
index 30898f0..fd5d45f 100644
--- a/api/transport/stun.h
+++ b/api/transport/stun.h
@@ -391,7 +391,7 @@
static const uint16_t SIZE_UNDEF = 0;
static const uint16_t SIZE_IP4 = 8;
static const uint16_t SIZE_IP6 = 20;
- StunAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+ StunAddressAttribute(uint16_t type, const webrtc::SocketAddress& addr);
StunAddressAttribute(uint16_t type, uint16_t length);
StunAttributeValueType value_type() const override;
@@ -406,11 +406,11 @@
return STUN_ADDRESS_UNDEF;
}
- const rtc::SocketAddress& GetAddress() const { return address_; }
+ const webrtc::SocketAddress& GetAddress() const { return address_; }
const webrtc::IPAddress& ipaddr() const { return address_.ipaddr(); }
uint16_t port() const { return address_.port(); }
- void SetAddress(const rtc::SocketAddress& addr) {
+ void SetAddress(const webrtc::SocketAddress& addr) {
address_ = addr;
EnsureAddressLength();
}
@@ -440,7 +440,7 @@
}
}
}
- rtc::SocketAddress address_;
+ webrtc::SocketAddress address_;
};
// Implements STUN attributes that record an Internet address. When encoded
@@ -448,7 +448,7 @@
// transaction ID of the message.
class StunXorAddressAttribute : public StunAddressAttribute {
public:
- StunXorAddressAttribute(uint16_t type, const rtc::SocketAddress& addr);
+ StunXorAddressAttribute(uint16_t type, const webrtc::SocketAddress& addr);
StunXorAddressAttribute(uint16_t type, uint16_t length, StunMessage* owner);
StunAttributeValueType value_type() const override;
diff --git a/api/transport/stun_unittest.cc b/api/transport/stun_unittest.cc
index c8788ff..df50c93 100644
--- a/api/transport/stun_unittest.cc
+++ b/api/transport/stun_unittest.cc
@@ -275,9 +275,9 @@
static const char kRfc5769SampleMsgServerSoftware[] = "test vector";
static const char kRfc5769SampleMsgUsername[] = "evtj:h6vY";
static const char kRfc5769SampleMsgPassword[] = "VOkJxbRl1RmTxUk/WvJxBt";
-static const rtc::SocketAddress kRfc5769SampleMsgMappedAddress(
+static const webrtc::SocketAddress kRfc5769SampleMsgMappedAddress(
"192.0.2.1", 32853);
-static const rtc::SocketAddress kRfc5769SampleMsgIPv6MappedAddress(
+static const webrtc::SocketAddress kRfc5769SampleMsgIPv6MappedAddress(
"2001:db8:1234:5678:11:2233:4455:6677", 32853);
static const uint8_t kRfc5769SampleMsgWithAuthTransactionId[] = {
@@ -856,7 +856,7 @@
webrtc::IPAddress test_ip(kIPv6TestAddress2);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV6, kTestMessagePort2,
@@ -869,7 +869,7 @@
webrtc::IPAddress test_ip(test_in_addr);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV4, kTestMessagePort2,
@@ -905,7 +905,7 @@
CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
msg.AddAttribute(std::move(addr));
@@ -933,7 +933,7 @@
CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort4);
addr->SetAddress(test_addr);
msg.AddAttribute(std::move(addr));
@@ -961,7 +961,7 @@
CheckStunTransactionID(msg, kTestTransactionId2, kStunTransactionIdLength);
auto addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort1);
addr->SetAddress(test_addr);
msg.AddAttribute(std::move(addr));
@@ -990,7 +990,7 @@
CheckStunTransactionID(msg, kTestTransactionId1, kStunTransactionIdLength);
auto addr = StunAttribute::CreateXorAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort3);
addr->SetAddress(test_addr);
msg.AddAttribute(std::move(addr));
@@ -1518,7 +1518,7 @@
{ // Test StunAddressAttribute.
webrtc::IPAddress test_ip(kIPv6TestAddress2);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV6,
kTestMessagePort2, test_ip);
@@ -1532,7 +1532,7 @@
{ // Test StunAddressAttribute.
webrtc::IPAddress test_ip(kIPv6TestAddress2);
auto addr = StunAttribute::CreateAddress(STUN_ATTR_XOR_MAPPED_ADDRESS);
- rtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
+ webrtc::SocketAddress test_addr(test_ip, kTestMessagePort2);
addr->SetAddress(test_addr);
CheckStunAddressAttribute(addr.get(), STUN_ADDRESS_IPV6,
kTestMessagePort2, test_ip);
diff --git a/examples/stunprober/main.cc b/examples/stunprober/main.cc
index 023c52f..8728d94 100644
--- a/examples/stunprober/main.cc
+++ b/examples/stunprober/main.cc
@@ -117,11 +117,11 @@
#endif // WEBRTC_WIN
absl::ParseCommandLine(argc, argv);
- std::vector<rtc::SocketAddress> server_addresses;
+ std::vector<webrtc::SocketAddress> server_addresses;
std::istringstream servers(absl::GetFlag(FLAGS_servers));
std::string server;
while (getline(servers, server, ',')) {
- rtc::SocketAddress addr;
+ webrtc::SocketAddress addr;
if (!addr.FromString(server)) {
RTC_LOG(LS_ERROR) << "Parsing " << server << " failed.";
return -1;
diff --git a/examples/stunserver/stunserver_main.cc b/examples/stunserver/stunserver_main.cc
index 71b4113..ad5d070 100644
--- a/examples/stunserver/stunserver_main.cc
+++ b/examples/stunserver/stunserver_main.cc
@@ -23,7 +23,7 @@
return 1;
}
- rtc::SocketAddress server_addr;
+ webrtc::SocketAddress server_addr;
if (!server_addr.FromString(argv[1])) {
std::cerr << "Unable to parse IP address: " << argv[1];
return 1;
diff --git a/examples/turnserver/turnserver_main.cc b/examples/turnserver/turnserver_main.cc
index 85af95e..de8f2de 100644
--- a/examples/turnserver/turnserver_main.cc
+++ b/examples/turnserver/turnserver_main.cc
@@ -58,7 +58,7 @@
return 1;
}
- rtc::SocketAddress int_addr;
+ webrtc::SocketAddress int_addr;
if (!int_addr.FromString(argv[1])) {
std::cerr << "Unable to parse IP address: " << argv[1] << std::endl;
return 1;
@@ -92,7 +92,7 @@
server.AddInternalSocket(int_socket, cricket::PROTO_UDP);
server.SetExternalSocketFactory(
new rtc::BasicPacketSocketFactory(&socket_server),
- rtc::SocketAddress(ext_addr, 0));
+ webrtc::SocketAddress(ext_addr, 0));
std::cout << "Listening internally at " << int_addr.ToString() << std::endl;
diff --git a/net/dcsctp/socket/dcsctp_socket_network_test.cc b/net/dcsctp/socket/dcsctp_socket_network_test.cc
index c22a938..36f0565 100644
--- a/net/dcsctp/socket/dcsctp_socket_network_test.cc
+++ b/net/dcsctp/socket/dcsctp_socket_network_test.cc
@@ -107,7 +107,7 @@
endpoint_ = endpoint;
uint16_t port = endpoint->BindReceiver(0, this).value();
source_address_ =
- rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), port);
+ webrtc::SocketAddress(endpoint_->GetPeerLocalAddress(), port);
}
void SetDestination(const BoundSocket& socket) {
@@ -131,8 +131,8 @@
std::function<void(rtc::CopyOnWriteBuffer)> receiver_;
webrtc::EmulatedEndpoint* endpoint_ = nullptr;
- rtc::SocketAddress source_address_;
- rtc::SocketAddress dest_address_;
+ webrtc::SocketAddress source_address_;
+ webrtc::SocketAddress dest_address_;
};
// Sends at a constant rate but with random packet sizes.
diff --git a/p2p/base/async_stun_tcp_socket.cc b/p2p/base/async_stun_tcp_socket.cc
index 517902a..d7228d8 100644
--- a/p2p/base/async_stun_tcp_socket.cc
+++ b/p2p/base/async_stun_tcp_socket.cc
@@ -47,8 +47,8 @@
// connect() fail (`socket` is destroyed in that case).
AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
rtc::Socket* socket,
- const rtc::SocketAddress& bind_address,
- const rtc::SocketAddress& remote_address) {
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address) {
return new AsyncStunTCPSocket(
AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
}
@@ -96,7 +96,7 @@
}
size_t AsyncStunTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
- rtc::SocketAddress remote_addr(GetRemoteAddress());
+ webrtc::SocketAddress remote_addr(GetRemoteAddress());
// STUN packet - First 4 bytes. Total header size is 20 bytes.
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |0 0| STUN Message Type | Message Length |
diff --git a/p2p/base/async_stun_tcp_socket.h b/p2p/base/async_stun_tcp_socket.h
index 2c43d55..e4110d2 100644
--- a/p2p/base/async_stun_tcp_socket.h
+++ b/p2p/base/async_stun_tcp_socket.h
@@ -25,9 +25,10 @@
// Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns NULL if bind() or
// connect() fail (`socket` is destroyed in that case).
- static AsyncStunTCPSocket* Create(rtc::Socket* socket,
- const rtc::SocketAddress& bind_address,
- const rtc::SocketAddress& remote_address);
+ static AsyncStunTCPSocket* Create(
+ rtc::Socket* socket,
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address);
explicit AsyncStunTCPSocket(rtc::Socket* socket);
diff --git a/p2p/base/async_stun_tcp_socket_unittest.cc b/p2p/base/async_stun_tcp_socket_unittest.cc
index e28a172..c38bb30 100644
--- a/p2p/base/async_stun_tcp_socket_unittest.cc
+++ b/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -62,8 +62,8 @@
0x40, 0x00, 0x00, 0x05, 0x21, 0x12, 0xA4, 0x42, '0',
};
-static const rtc::SocketAddress kClientAddr("11.11.11.11", 0);
-static const rtc::SocketAddress kServerAddr("22.22.22.22", 0);
+static const webrtc::SocketAddress kClientAddr("11.11.11.11", 0);
+static const webrtc::SocketAddress kServerAddr("22.22.22.22", 0);
class AsyncStunServerTCPSocket : public rtc::AsyncTcpListenSocket {
public:
diff --git a/p2p/base/basic_async_resolver_factory.cc b/p2p/base/basic_async_resolver_factory.cc
index b69e066..cf2f14e 100644
--- a/p2p/base/basic_async_resolver_factory.cc
+++ b/p2p/base/basic_async_resolver_factory.cc
@@ -27,7 +27,7 @@
std::unique_ptr<webrtc::AsyncDnsResolverInterface>
BasicAsyncDnsResolverFactory::CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
resolver->Start(addr, std::move(callback));
@@ -36,7 +36,7 @@
std::unique_ptr<webrtc::AsyncDnsResolverInterface>
BasicAsyncDnsResolverFactory::CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) {
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create();
diff --git a/p2p/base/basic_async_resolver_factory.h b/p2p/base/basic_async_resolver_factory.h
index f99fb3e..a30a737 100644
--- a/p2p/base/basic_async_resolver_factory.h
+++ b/p2p/base/basic_async_resolver_factory.h
@@ -26,11 +26,11 @@
BasicAsyncDnsResolverFactory() = default;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
absl::AnyInvocable<void()> callback) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAndResolve(
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) override;
diff --git a/p2p/base/basic_packet_socket_factory.cc b/p2p/base/basic_packet_socket_factory.cc
index 294dbdd..f401f3f 100644
--- a/p2p/base/basic_packet_socket_factory.cc
+++ b/p2p/base/basic_packet_socket_factory.cc
@@ -35,7 +35,7 @@
BasicPacketSocketFactory::~BasicPacketSocketFactory() {}
AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
- const SocketAddress& address,
+ const webrtc::SocketAddress& address,
uint16_t min_port,
uint16_t max_port) {
// UDP sockets are simple.
@@ -52,7 +52,7 @@
}
AsyncListenSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
- const SocketAddress& local_address,
+ const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) {
@@ -84,8 +84,8 @@
}
AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
- const SocketAddress& local_address,
- const SocketAddress& remote_address,
+ const webrtc::SocketAddress& local_address,
+ const webrtc::SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) {
Socket* socket =
socket_factory_->CreateSocket(local_address.family(), SOCK_STREAM);
@@ -173,10 +173,11 @@
return std::make_unique<webrtc::AsyncDnsResolver>();
}
-int BasicPacketSocketFactory::BindSocket(Socket* socket,
- const SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port) {
+int BasicPacketSocketFactory::BindSocket(
+ Socket* socket,
+ const webrtc::SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port) {
int ret = -1;
if (min_port == 0 && max_port == 0) {
// If there's no port range, let the OS pick a port for us.
@@ -184,7 +185,7 @@
} else {
// Otherwise, try to find a port in the provided range.
for (int port = min_port; ret < 0 && port <= max_port; ++port) {
- ret = socket->Bind(SocketAddress(local_address.ipaddr(), port));
+ ret = socket->Bind(webrtc::SocketAddress(local_address.ipaddr(), port));
}
}
return ret;
diff --git a/p2p/base/basic_packet_socket_factory.h b/p2p/base/basic_packet_socket_factory.h
index b172d34..26d78e8 100644
--- a/p2p/base/basic_packet_socket_factory.h
+++ b/p2p/base/basic_packet_socket_factory.h
@@ -33,16 +33,17 @@
explicit BasicPacketSocketFactory(SocketFactory* socket_factory);
~BasicPacketSocketFactory() override;
- AsyncPacketSocket* CreateUdpSocket(const SocketAddress& local_address,
+ AsyncPacketSocket* CreateUdpSocket(const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port) override;
- AsyncListenSocket* CreateServerTcpSocket(const SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port,
- int opts) override;
+ AsyncListenSocket* CreateServerTcpSocket(
+ const webrtc::SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port,
+ int opts) override;
AsyncPacketSocket* CreateClientTcpSocket(
- const SocketAddress& local_address,
- const SocketAddress& remote_address,
+ const webrtc::SocketAddress& local_address,
+ const webrtc::SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) override;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAsyncDnsResolver()
@@ -50,7 +51,7 @@
private:
int BindSocket(Socket* socket,
- const SocketAddress& local_address,
+ const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port);
diff --git a/p2p/base/connection.cc b/p2p/base/connection.cc
index e05b017..0f211fd 100644
--- a/p2p/base/connection.cc
+++ b/p2p/base/connection.cc
@@ -491,7 +491,7 @@
RTC_DCHECK_RUN_ON(network_thread_);
std::unique_ptr<IceMessage> msg;
std::string remote_ufrag;
- const rtc::SocketAddress& addr(remote_candidate_.address());
+ const webrtc::SocketAddress& addr(remote_candidate_.address());
if (!port_->GetStunMessage(
reinterpret_cast<const char*>(packet.payload().data()),
packet.payload().size(), addr, &msg, &remote_ufrag)) {
@@ -660,7 +660,7 @@
}
}
- const rtc::SocketAddress& remote_addr = remote_candidate_.address();
+ const webrtc::SocketAddress& remote_addr = remote_candidate_.address();
if (msg->type() == STUN_BINDING_REQUEST) {
// Check for role conflicts.
const std::string& remote_ufrag = remote_candidate_.username();
@@ -830,7 +830,7 @@
void Connection::SendResponseMessage(const StunMessage& response) {
RTC_DCHECK_RUN_ON(network_thread_);
// Where I send the response.
- const rtc::SocketAddress& addr = remote_candidate_.address();
+ const webrtc::SocketAddress& addr = remote_candidate_.address();
// Send the response.
rtc::ByteBufferWriter buf;
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 5dbab6c..5421705 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -981,7 +981,7 @@
// Handle stun packets
void P2PTransportChannel::OnUnknownAddress(webrtc::PortInterface* port,
- const rtc::SocketAddress& address,
+ const webrtc::SocketAddress& address,
webrtc::ProtocolType proto,
IceMessage* stun_msg,
const std::string& remote_username,
@@ -1293,7 +1293,7 @@
return;
}
- rtc::SocketAddress resolved_address;
+ webrtc::SocketAddress resolved_address;
// Prefer IPv6 to IPv4 if we have it (see RFC 5245 Section 15.1).
// TODO(zstein): This won't work if we only have IPv4 locally but receive an
// AAAA DNS record.
diff --git a/p2p/base/p2p_transport_channel.h b/p2p/base/p2p_transport_channel.h
index f1b3c0a..20c306a 100644
--- a/p2p/base/p2p_transport_channel.h
+++ b/p2p/base/p2p_transport_channel.h
@@ -323,7 +323,7 @@
const std::vector<Candidate>& candidates);
void OnCandidatesAllocationDone(PortAllocatorSession* session);
void OnUnknownAddress(webrtc::PortInterface* port,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
webrtc::ProtocolType proto,
IceMessage* stun_msg,
const std::string& remote_username,
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index 3e23099..7b94134 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -98,7 +98,6 @@
namespace {
-using rtc::SocketAddress;
using ::testing::_;
using ::testing::Assign;
using ::testing::Contains;
@@ -121,6 +120,7 @@
using ::webrtc::IceCandidateType;
using ::webrtc::PendingTaskSafetyFlag;
using ::webrtc::SafeTask;
+using ::webrtc::SocketAddress;
// Default timeout for tests in this file.
// Should be large enough for slow buildbots to run the tests reliably.
@@ -196,7 +196,7 @@
int priority,
absl::string_view ufrag = "") {
cricket::Candidate c;
- c.set_address(rtc::SocketAddress(ip, port));
+ c.set_address(webrtc::SocketAddress(ip, port));
c.set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
c.set_protocol(cricket::UDP_PROTOCOL_NAME);
c.set_priority(priority);
@@ -210,8 +210,8 @@
rtc::NetworkManager* network_manager,
rtc::PacketSocketFactory* socket_factory,
const cricket::ServerAddresses& stun_servers,
- const rtc::SocketAddress& turn_server_udp,
- const rtc::SocketAddress& turn_server_tcp) {
+ const webrtc::SocketAddress& turn_server_udp,
+ const webrtc::SocketAddress& turn_server_tcp) {
cricket::RelayServerConfig turn_server;
turn_server.credentials = kRelayCredentials;
if (!turn_server_udp.IsNil()) {
@@ -239,7 +239,7 @@
mock_async_dns_resolver_ = std::make_unique<webrtc::MockAsyncDnsResolver>();
EXPECT_CALL(*mock_async_dns_resolver_, Start(_, _))
.WillRepeatedly(
- [](const rtc::SocketAddress& /* addr */,
+ [](const webrtc::SocketAddress& /* addr */,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*mock_async_dns_resolver_, result())
.WillOnce(ReturnRef(mock_async_dns_resolver_result_));
@@ -256,7 +256,7 @@
});
}
- void SetAddressToReturn(rtc::SocketAddress address_to_return) {
+ void SetAddressToReturn(webrtc::SocketAddress address_to_return) {
EXPECT_CALL(mock_async_dns_resolver_result_, GetResolvedAddress(_, _))
.WillOnce(DoAll(SetArgPointee<1>(address_to_return), Return(true)));
}
@@ -333,10 +333,10 @@
ServerAddresses stun_servers = {kStunAddr};
ep1_.allocator_ = CreateBasicPortAllocator(
env, &ep1_.network_manager_, socket_factory_.get(), stun_servers,
- kTurnUdpIntAddr, rtc::SocketAddress());
+ kTurnUdpIntAddr, webrtc::SocketAddress());
ep2_.allocator_ = CreateBasicPortAllocator(
env, &ep2_.network_manager_, socket_factory_.get(), stun_servers,
- kTurnUdpIntAddr, rtc::SocketAddress());
+ kTurnUdpIntAddr, webrtc::SocketAddress());
}
protected:
@@ -3972,7 +3972,7 @@
if (!port) {
return nullptr;
}
- return port->GetConnection(rtc::SocketAddress(ip, port_num));
+ return port->GetConnection(webrtc::SocketAddress(ip, port_num));
}
Connection* FindNextPingableConnectionAndPingIt(P2PTransportChannel* ch) {
@@ -4321,7 +4321,7 @@
prflx_priority));
Port* port = GetPort(&ch);
ASSERT_NE(nullptr, port);
- port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("1.1.1.1", 1),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn = GetConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_NE(nullptr, conn);
@@ -4523,14 +4523,14 @@
Port* port = GetPort(&ch);
// conn1 should be resurrected with original priority.
- port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("1.1.1.1", 1),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
EXPECT_EQ(conn1->remote_candidate().priority(), remote_priority);
// conn3, a real prflx connection, should have prflx priority.
- port->SignalUnknownAddress(port, rtc::SocketAddress("3.3.3.3", 1),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("3.3.3.3", 1),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 1);
ASSERT_TRUE(conn3 != nullptr);
@@ -4828,7 +4828,7 @@
request.AddAttribute(std::make_unique<StunUInt32Attribute>(STUN_ATTR_PRIORITY,
prflx_priority));
TestUDPPort* port = static_cast<TestUDPPort*>(GetPort(&ch));
- port->SignalUnknownAddress(port, rtc::SocketAddress("1.1.1.1", 1),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("1.1.1.1", 1),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn1 = WaitForConnectionTo(&ch, "1.1.1.1", 1);
ASSERT_TRUE(conn1 != nullptr);
@@ -4856,7 +4856,7 @@
// Another request with unknown address, it will not be set as the selected
// connection because the selected connection was nominated by the controlling
// side.
- port->SignalUnknownAddress(port, rtc::SocketAddress("3.3.3.3", 3),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("3.3.3.3", 3),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 3);
ASSERT_TRUE(conn3 != nullptr);
@@ -4868,7 +4868,7 @@
// selected as the selected connection.
request.AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
- port->SignalUnknownAddress(port, rtc::SocketAddress("4.4.4.4", 4),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("4.4.4.4", 4),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn4 = WaitForConnectionTo(&ch, "4.4.4.4", 4);
ASSERT_TRUE(conn4 != nullptr);
@@ -4886,7 +4886,7 @@
// port->set_sent_binding_response(false);
ch.SetRemoteIceParameters(kIceParams[2]);
ch.SetRemoteIceParameters(kIceParams[3]);
- port->SignalUnknownAddress(port, rtc::SocketAddress("5.5.5.5", 5),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("5.5.5.5", 5),
webrtc::PROTO_UDP, &request, kIceUfrag[2], false);
Connection* conn5 = WaitForConnectionTo(&ch, "5.5.5.5", 5);
ASSERT_TRUE(conn5 != nullptr);
@@ -4940,7 +4940,7 @@
request.AddAttribute(
std::make_unique<StunByteStringAttribute>(STUN_ATTR_USE_CANDIDATE));
Port* port = GetPort(&ch);
- port->SignalUnknownAddress(port, rtc::SocketAddress("3.3.3.3", 3),
+ port->SignalUnknownAddress(port, webrtc::SocketAddress("3.3.3.3", 3),
webrtc::PROTO_UDP, &request, kIceUfrag[1], false);
Connection* conn3 = WaitForConnectionTo(&ch, "3.3.3.3", 3);
ASSERT_TRUE(conn3 != nullptr);
@@ -5730,7 +5730,7 @@
BasicPortAllocator& CreatePortAllocator(const Environment& env) {
port_allocator_ = CreateBasicPortAllocator(
env, &network_manager_, packet_socket_factory(), ServerAddresses(),
- kTurnUdpIntAddr, rtc::SocketAddress());
+ kTurnUdpIntAddr, webrtc::SocketAddress());
port_allocator_->set_flags(port_allocator_->flags() |
PORTALLOCATOR_DISABLE_STUN |
PORTALLOCATOR_DISABLE_TCP);
@@ -6086,7 +6086,7 @@
// The IP address of ep1's host candidate should be obfuscated.
EXPECT_TRUE(local_candidate.address().IsUnresolvedIP());
// This is the underlying private IP address of the same candidate at ep1.
- const auto local_address = rtc::SocketAddress(
+ const auto local_address = webrtc::SocketAddress(
kPublicAddrs[0].ipaddr(), local_candidate.address().port());
// Let ep2 signal its candidate to ep1. ep1 should form a candidate
@@ -6163,7 +6163,7 @@
// The IP address of ep1's host candidate should be obfuscated.
ASSERT_TRUE(local_candidate.address().IsUnresolvedIP());
// This is the underlying private IP address of the same candidate at ep1.
- const auto local_address = rtc::SocketAddress(
+ const auto local_address = webrtc::SocketAddress(
kPublicAddrs[0].ipaddr(), local_candidate.address().port());
// Let ep1 signal its hostname candidate to ep2.
ResumeCandidates(0);
@@ -6239,7 +6239,7 @@
EXPECT_TRUE(local_candidate_ep1.address().IsUnresolvedIP());
// This is the underlying private IP address of the same candidate at ep1,
// and let the mock resolver of ep2 receive the correct resolution.
- rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
+ webrtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
resolver_fixture.SetAddressToReturn(resolved_address_ep1);
@@ -6302,7 +6302,7 @@
if (local_candidate_ep1.is_local()) {
// This is the underlying private IP address of the same candidate at ep1,
// and let the mock resolver of ep2 receive the correct resolution.
- rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
+ webrtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
resolver_fixture.SetAddressToReturn(resolved_address_ep1);
break;
@@ -6509,7 +6509,7 @@
ASSERT_TRUE(local_candidate_ep1.is_local());
// This is the underlying private IP address of the same candidate at ep1,
// and let the mock resolver of ep2 receive the correct resolution.
- rtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
+ webrtc::SocketAddress resolved_address_ep1(local_candidate_ep1.address());
resolved_address_ep1.SetResolvedIP(kPublicAddrs[0].ipaddr());
resolver_fixture.SetAddressToReturn(resolved_address_ep1);
@@ -6581,7 +6581,7 @@
// address directly to simulate the process of adding remote candidates with
// the name resolution.
for (auto& mdns_candidate : mdns_candidates) {
- rtc::SocketAddress resolved_address(mdns_candidate.address());
+ webrtc::SocketAddress resolved_address(mdns_candidate.address());
resolved_address.SetResolvedIP(0x1111); // 1.1.1.1
mdns_candidate.set_address(resolved_address);
EXPECT_FALSE(mdns_candidate.address().IsUnresolvedIP());
diff --git a/p2p/base/packet_transport_internal_unittest.cc b/p2p/base/packet_transport_internal_unittest.cc
index d0dba3b..d4428de 100644
--- a/p2p/base/packet_transport_internal_unittest.cc
+++ b/p2p/base/packet_transport_internal_unittest.cc
@@ -35,7 +35,7 @@
rtc::ReceivedPacket::kDtlsDecrypted);
});
packet_transport.NotifyPacketReceived(rtc::ReceivedPacket(
- {}, rtc::SocketAddress(), std::nullopt, rtc::EcnMarking::kNotEct,
+ {}, webrtc::SocketAddress(), std::nullopt, rtc::EcnMarking::kNotEct,
rtc::ReceivedPacket::kDtlsDecrypted));
packet_transport.DeregisterReceivedPacketCallback(&receiver);
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index 9866226..71c903e 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -197,7 +197,7 @@
return candidates_;
}
-Connection* Port::GetConnection(const rtc::SocketAddress& remote_addr) {
+Connection* Port::GetConnection(const webrtc::SocketAddress& remote_addr) {
AddressMap::const_iterator iter = connections_.find(remote_addr);
if (iter != connections_.end())
return iter->second;
@@ -205,9 +205,9 @@
return NULL;
}
-void Port::AddAddress(const rtc::SocketAddress& address,
- const rtc::SocketAddress& base_address,
- const rtc::SocketAddress& related_address,
+void Port::AddAddress(const webrtc::SocketAddress& address,
+ const webrtc::SocketAddress& base_address,
+ const webrtc::SocketAddress& related_address,
absl::string_view protocol,
absl::string_view relay_protocol,
absl::string_view tcptype,
@@ -266,14 +266,14 @@
auto callback = [weak_ptr, copy, is_final](const rtc::IPAddress& addr,
absl::string_view name) mutable {
RTC_DCHECK(copy.address().ipaddr() == addr);
- rtc::SocketAddress hostname_address(name, copy.address().port());
+ webrtc::SocketAddress hostname_address(name, copy.address().port());
// In Port and Connection, we need the IP address information to
// correctly handle the update of candidate type to prflx. The removal
// of IP address when signaling this candidate will take place in
// BasicPortAllocatorSession::OnCandidateReady, via SanitizeCandidate.
hostname_address.SetResolvedIP(addr);
copy.set_address(hostname_address);
- copy.set_related_address(rtc::SocketAddress());
+ copy.set_related_address(webrtc::SocketAddress());
if (weak_ptr != nullptr) {
RTC_DCHECK_RUN_ON(weak_ptr->thread_);
weak_ptr->set_mdns_name_registration_status(
@@ -322,7 +322,7 @@
webrtc::ProtocolType proto) {
const char* data = reinterpret_cast<const char*>(packet.payload().data());
size_t size = packet.payload().size();
- const rtc::SocketAddress& addr = packet.source_address();
+ const webrtc::SocketAddress& addr = packet.source_address();
// If the user has enabled port packets, just hand this over.
if (enable_port_packets_) {
SignalReadPacket(this, data, size, addr);
@@ -388,7 +388,7 @@
bool Port::GetStunMessage(const char* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
std::unique_ptr<IceMessage>* out_msg,
std::string* out_username) {
RTC_DCHECK_RUN_ON(thread_);
@@ -554,7 +554,7 @@
return true;
}
-bool Port::IsCompatibleAddress(const rtc::SocketAddress& addr) {
+bool Port::IsCompatibleAddress(const webrtc::SocketAddress& addr) {
// Get a representative IP for the Network this port is configured to use.
webrtc::IPAddress ip = network_->GetBestIP();
// We use single-stack sockets, so families must match.
@@ -618,7 +618,7 @@
return true;
}
-bool Port::MaybeIceRoleConflict(const rtc::SocketAddress& addr,
+bool Port::MaybeIceRoleConflict(const webrtc::SocketAddress& addr,
IceMessage* stun_msg,
absl::string_view remote_ufrag) {
RTC_DCHECK_RUN_ON(thread_);
@@ -691,12 +691,12 @@
return false;
}
-bool Port::CanHandleIncomingPacketsFrom(const rtc::SocketAddress&) const {
+bool Port::CanHandleIncomingPacketsFrom(const webrtc::SocketAddress&) const {
return false;
}
void Port::SendBindingErrorResponse(StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view reason) {
RTC_DCHECK_RUN_ON(thread_);
@@ -747,7 +747,7 @@
void Port::SendUnknownAttributesErrorResponse(
StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const std::vector<uint16_t>& unknown_types) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(message->type() == STUN_BINDING_REQUEST);
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 528a1eb..83bd46f 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -124,10 +124,10 @@
std::optional<webrtc::ProtocolType> StringToProto(absl::string_view proto_name);
struct ProtocolAddress {
- rtc::SocketAddress address;
+ webrtc::SocketAddress address;
webrtc::ProtocolType proto;
- ProtocolAddress(const rtc::SocketAddress& a, webrtc::ProtocolType p)
+ ProtocolAddress(const webrtc::SocketAddress& a, webrtc::ProtocolType p)
: address(a), proto(p) {}
bool operator==(const ProtocolAddress& o) const {
@@ -164,7 +164,7 @@
int64_t estimated_disconnected_time_ms;
};
-typedef std::set<rtc::SocketAddress> ServerAddresses;
+typedef std::set<webrtc::SocketAddress> ServerAddresses;
// Represents a local communication mechanism that can be used to create
// connections to similar mechanisms of the other client. Subclasses of this
@@ -283,11 +283,11 @@
void SendPortDestroyed(Port* port);
// Returns a map containing all of the connections of this port, keyed by the
// remote address.
- typedef std::map<rtc::SocketAddress, Connection*> AddressMap;
+ typedef std::map<webrtc::SocketAddress, Connection*> AddressMap;
const AddressMap& connections() { return connections_; }
// Returns the connection to the given address or NULL if none exists.
- Connection* GetConnection(const rtc::SocketAddress& remote_addr) override;
+ Connection* GetConnection(const webrtc::SocketAddress& remote_addr) override;
// Removes and deletes a connection object. `DestroyConnection` will
// delete the connection object directly whereas `DestroyConnectionAsync`
@@ -312,16 +312,16 @@
// Shall the port handle packet from this `remote_addr`.
// This method is overridden by TurnPort.
virtual bool CanHandleIncomingPacketsFrom(
- const rtc::SocketAddress& remote_addr) const;
+ const webrtc::SocketAddress& remote_addr) const;
// Sends a response error to the given request.
void SendBindingErrorResponse(StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view reason) override;
void SendUnknownAttributesErrorResponse(
StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const std::vector<uint16_t>& unknown_types);
void EnablePortPackets() override;
@@ -345,7 +345,7 @@
std::string CreateStunUsername(
absl::string_view remote_username) const override;
- bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
+ bool MaybeIceRoleConflict(const webrtc::SocketAddress& addr,
IceMessage* stun_msg,
absl::string_view remote_ufrag) override;
@@ -371,9 +371,9 @@
rtc::WeakPtr<Port> NewWeakPtr() { return weak_factory_.GetWeakPtr(); }
- void AddAddress(const rtc::SocketAddress& address,
- const rtc::SocketAddress& base_address,
- const rtc::SocketAddress& related_address,
+ void AddAddress(const webrtc::SocketAddress& address,
+ const webrtc::SocketAddress& base_address,
+ const webrtc::SocketAddress& related_address,
absl::string_view protocol,
absl::string_view relay_protocol,
absl::string_view tcptype,
@@ -404,7 +404,7 @@
"proto)")]] void
OnReadPacket(const char* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
webrtc::ProtocolType proto) {
OnReadPacket(rtc::ReceivedPacket::CreateFromLegacy(
data, size, /*packet_time_us = */ -1, addr),
@@ -418,12 +418,12 @@
// remote_username contains the remote fragment of the STUN username.
bool GetStunMessage(const char* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
std::unique_ptr<IceMessage>* out_msg,
std::string* out_username) override;
// Checks if the address in addr is compatible with the port's ip.
- bool IsCompatibleAddress(const rtc::SocketAddress& addr);
+ bool IsCompatibleAddress(const webrtc::SocketAddress& addr);
// Returns DSCP value packets generated by the port itself should use.
rtc::DiffServCodePoint StunDscpValue() const override;
diff --git a/p2p/base/port_allocator.cc b/p2p/base/port_allocator.cc
index fc28c7e..7c16a49 100644
--- a/p2p/base/port_allocator.cc
+++ b/p2p/base/port_allocator.cc
@@ -33,7 +33,7 @@
RelayServerConfig::RelayServerConfig() {}
-RelayServerConfig::RelayServerConfig(const rtc::SocketAddress& address,
+RelayServerConfig::RelayServerConfig(const webrtc::SocketAddress& address,
absl::string_view username,
absl::string_view password,
webrtc::ProtocolType proto)
@@ -46,7 +46,7 @@
absl::string_view username,
absl::string_view password,
webrtc::ProtocolType proto)
- : RelayServerConfig(rtc::SocketAddress(address, port),
+ : RelayServerConfig(webrtc::SocketAddress(address, port),
username,
password,
proto) {}
diff --git a/p2p/base/port_allocator.h b/p2p/base/port_allocator.h
index a09f307..9acd1ce 100644
--- a/p2p/base/port_allocator.h
+++ b/p2p/base/port_allocator.h
@@ -157,7 +157,7 @@
// TODO(deadbeef): Rename to TurnServerConfig.
struct RTC_EXPORT RelayServerConfig {
RelayServerConfig();
- RelayServerConfig(const rtc::SocketAddress& address,
+ RelayServerConfig(const webrtc::SocketAddress& address,
absl::string_view username,
absl::string_view password,
webrtc::ProtocolType proto);
diff --git a/p2p/base/port_allocator_unittest.cc b/p2p/base/port_allocator_unittest.cc
index b7524e7..2b2bdc2 100644
--- a/p2p/base/port_allocator_unittest.cc
+++ b/p2p/base/port_allocator_unittest.cc
@@ -91,8 +91,8 @@
rtc::AutoSocketServerThread main_;
std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
std::unique_ptr<cricket::FakePortAllocator> allocator_;
- rtc::SocketAddress stun_server_1{"11.11.11.11", 3478};
- rtc::SocketAddress stun_server_2{"22.22.22.22", 3478};
+ webrtc::SocketAddress stun_server_1{"11.11.11.11", 3478};
+ webrtc::SocketAddress stun_server_2{"22.22.22.22", 3478};
cricket::RelayServerConfig turn_server_1{"11.11.11.11", 3478,
kTurnUsername, kTurnPassword,
cricket::PROTO_UDP, false};
@@ -295,9 +295,9 @@
}
TEST_F(PortAllocatorTest, SanitizeIpv4CandidateDefaultConfig) {
- cricket::Candidate input(1, "udp", rtc::SocketAddress(kIpv4Address, 443), 1,
- "username", "password", IceCandidateType::kHost, 1,
- "foundation", 1, 1);
+ cricket::Candidate input(1, "udp", webrtc::SocketAddress(kIpv4Address, 443),
+ 1, "username", "password", IceCandidateType::kHost,
+ 1, "foundation", 1, 1);
cricket::Candidate output = allocator_->SanitizeCandidate(input);
EXPECT_EQ(kIpv4AddressWithPort, output.address().ToString());
EXPECT_EQ(kIpv4Address, output.address().ipaddr().ToString());
@@ -305,9 +305,9 @@
TEST_F(PortAllocatorTest, SanitizeIpv4CandidateMdnsObfuscationEnabled) {
allocator_->SetMdnsObfuscationEnabledForTesting(true);
- cricket::Candidate input(1, "udp", rtc::SocketAddress(kIpv4Address, 443), 1,
- "username", "password", IceCandidateType::kHost, 1,
- "foundation", 1, 1);
+ cricket::Candidate input(1, "udp", webrtc::SocketAddress(kIpv4Address, 443),
+ 1, "username", "password", IceCandidateType::kHost,
+ 1, "foundation", 1, 1);
cricket::Candidate output = allocator_->SanitizeCandidate(input);
EXPECT_NE(kIpv4AddressWithPort, output.address().ToString());
EXPECT_EQ("", output.address().ipaddr().ToString());
@@ -316,9 +316,9 @@
TEST_F(PortAllocatorTest, SanitizePrflxCandidateMdnsObfuscationEnabled) {
allocator_->SetMdnsObfuscationEnabledForTesting(true);
// Create the candidate from an IP literal. This populates the hostname.
- cricket::Candidate input(1, "udp", rtc::SocketAddress(kIpv4Address, 443), 1,
- "username", "password", IceCandidateType::kPrflx, 1,
- "foundation", 1, 1);
+ cricket::Candidate input(1, "udp", webrtc::SocketAddress(kIpv4Address, 443),
+ 1, "username", "password", IceCandidateType::kPrflx,
+ 1, "foundation", 1, 1);
cricket::Candidate output = allocator_->SanitizeCandidate(input);
EXPECT_NE(kIpv4AddressWithPort, output.address().ToString());
EXPECT_EQ("", output.address().ipaddr().ToString());
@@ -328,9 +328,9 @@
SanitizePrflxCandidateMdnsObfuscationEnabledRelatedAddress) {
allocator_->SetMdnsObfuscationEnabledForTesting(true);
// Create the candidate from an IP literal. This populates the hostname.
- cricket::Candidate input(1, "udp", rtc::SocketAddress(kIpv4Address, 443), 1,
- "username", "password", IceCandidateType::kPrflx, 1,
- "foundation", 1, 1);
+ cricket::Candidate input(1, "udp", webrtc::SocketAddress(kIpv4Address, 443),
+ 1, "username", "password", IceCandidateType::kPrflx,
+ 1, "foundation", 1, 1);
cricket::Candidate output = allocator_->SanitizeCandidate(input);
EXPECT_NE(kIpv4AddressWithPort, output.address().ToString());
@@ -344,9 +344,9 @@
allocator_->SetMdnsObfuscationEnabledForTesting(true);
webrtc::IPAddress ip;
EXPECT_TRUE(webrtc::IPFromString(kIpv4Address, &ip));
- cricket::Candidate input(1, "udp", rtc::SocketAddress(ip, 443), 1, "username",
- "password", IceCandidateType::kHost, 1, "foundation",
- 1, 1);
+ cricket::Candidate input(1, "udp", webrtc::SocketAddress(ip, 443), 1,
+ "username", "password", IceCandidateType::kHost, 1,
+ "foundation", 1, 1);
cricket::Candidate output = allocator_->SanitizeCandidate(input);
EXPECT_NE(kIpv4AddressWithPort, output.address().ToString());
EXPECT_EQ("", output.address().ipaddr().ToString());
diff --git a/p2p/base/port_interface.h b/p2p/base/port_interface.h
index 1090672..d1ca138 100644
--- a/p2p/base/port_interface.h
+++ b/p2p/base/port_interface.h
@@ -78,7 +78,7 @@
// Returns the connection to the given address or NULL if none exists.
virtual cricket::Connection* GetConnection(
- const rtc::SocketAddress& remote_addr) = 0;
+ const SocketAddress& remote_addr) = 0;
// Creates a new connection to the given address.
enum CandidateOrigin { ORIGIN_THIS_PORT, ORIGIN_OTHER_PORT, ORIGIN_MESSAGE };
@@ -99,7 +99,7 @@
// that of a connection or an address that has sent to us already.
virtual int SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) = 0;
@@ -107,7 +107,7 @@
// address that doesn't correspond to any current connection. To turn this
// into a real connection, call CreateConnection.
sigslot::signal6<PortInterface*,
- const rtc::SocketAddress&,
+ const SocketAddress&,
ProtocolType,
cricket::IceMessage*,
const std::string&,
@@ -117,7 +117,7 @@
// Sends a response message (normal or error) to the given request. One of
// these methods should be called as a response to SignalUnknownAddress.
virtual void SendBindingErrorResponse(cricket::StunMessage* message,
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
int error_code,
absl::string_view reason) = 0;
@@ -134,9 +134,8 @@
// through their respective connection and instead delivers every packet
// through this port.
virtual void EnablePortPackets() = 0;
- sigslot::
- signal4<PortInterface*, const char*, size_t, const rtc::SocketAddress&>
- SignalReadPacket;
+ sigslot::signal4<PortInterface*, const char*, size_t, const SocketAddress&>
+ SignalReadPacket;
// Emitted each time a packet is sent on this port.
sigslot::signal1<const rtc::SentPacket&> SignalSentPacket;
@@ -184,7 +183,7 @@
// remote_username contains the remote fragment of the STUN username.
virtual bool GetStunMessage(const char* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
std::unique_ptr<cricket::IceMessage>* out_msg,
std::string* out_username) = 0;
@@ -196,7 +195,7 @@
virtual std::string CreateStunUsername(
absl::string_view remote_username) const = 0;
- virtual bool MaybeIceRoleConflict(const rtc::SocketAddress& addr,
+ virtual bool MaybeIceRoleConflict(const SocketAddress& addr,
cricket::IceMessage* stun_msg,
absl::string_view remote_ufrag) = 0;
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 2456316..eb3a4c7 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -88,12 +88,12 @@
using rtc::NATType;
using rtc::PacketSocketFactory;
using rtc::Socket;
-using rtc::SocketAddress;
using ::testing::Eq;
using ::testing::IsNull;
using ::testing::IsTrue;
using ::testing::NotNull;
using webrtc::IceCandidateType;
+using ::webrtc::SocketAddress;
namespace cricket {
namespace {
@@ -180,8 +180,8 @@
virtual void PrepareAddress() {
// Act as if the socket was bound to the best IP on the network, to the
// first port in the allowed range.
- rtc::SocketAddress addr(Network()->GetBestIP(), min_port());
- AddAddress(addr, addr, rtc::SocketAddress(), "udp", "", "", type(),
+ webrtc::SocketAddress addr(Network()->GetBestIP(), min_port());
+ AddAddress(addr, addr, webrtc::SocketAddress(), "udp", "", "", type(),
ICE_TYPE_PREFERENCE_HOST, 0, "", true);
}
@@ -192,16 +192,16 @@
virtual webrtc::ProtocolType GetProtocol() const { return webrtc::PROTO_UDP; }
// Exposed for testing candidate building.
- void AddCandidateAddress(const rtc::SocketAddress& addr) {
- AddAddress(addr, addr, rtc::SocketAddress(), "udp", "", "", type(),
+ void AddCandidateAddress(const webrtc::SocketAddress& addr) {
+ AddAddress(addr, addr, webrtc::SocketAddress(), "udp", "", "", type(),
type_preference_, 0, "", false);
}
- void AddCandidateAddress(const rtc::SocketAddress& addr,
- const rtc::SocketAddress& base_address,
+ void AddCandidateAddress(const webrtc::SocketAddress& addr,
+ const webrtc::SocketAddress& base_address,
IceCandidateType type,
int type_preference,
bool final) {
- AddAddress(addr, base_address, rtc::SocketAddress(), "udp", "", "", type,
+ AddAddress(addr, base_address, webrtc::SocketAddress(), "udp", "", "", type,
type_preference, 0, "", final);
}
@@ -216,7 +216,7 @@
}
virtual int SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& /* addr */,
+ const webrtc::SocketAddress& /* addr */,
const rtc::PacketOptions& /* options */,
bool payload) {
if (!payload) {
@@ -257,7 +257,7 @@
bool GetStunMessageFromBufferWriter(TestPort* port,
ByteBufferWriter* buf,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
std::unique_ptr<IceMessage>* out_msg,
std::string* out_username) {
return port->GetStunMessage(reinterpret_cast<const char*>(buf->Data()),
@@ -276,8 +276,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
clock->AdvanceTime(webrtc::TimeDelta::Millis(ms));
ASSERT_THAT(webrtc::WaitUntil(
@@ -285,8 +285,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
}
class TestChannel : public sigslot::has_slots<> {
@@ -630,7 +630,7 @@
PacketSocketFactory* socket_factory,
webrtc::ProtocolType int_proto,
webrtc::ProtocolType ext_proto,
- const rtc::SocketAddress& server_addr) {
+ const webrtc::SocketAddress& server_addr) {
RelayServerConfig config;
config.credentials = kRelayCredentials;
ProtocolAddress server_address(server_addr, int_proto);
@@ -880,7 +880,7 @@
return msg;
}
std::unique_ptr<TestPort> CreateTestPort(
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
absl::string_view username,
absl::string_view password,
const webrtc::FieldTrialsView* field_trials = nullptr) {
@@ -894,7 +894,7 @@
port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
return port;
}
- std::unique_ptr<TestPort> CreateTestPort(const rtc::SocketAddress& addr,
+ std::unique_ptr<TestPort> CreateTestPort(const webrtc::SocketAddress& addr,
absl::string_view username,
absl::string_view password,
cricket::IceRole role,
@@ -1643,8 +1643,8 @@
webrtc::IsRtcOk());
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
- conn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ conn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
ASSERT_THAT(webrtc::WaitUntil(
[&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
@@ -1724,8 +1724,8 @@
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
ASSERT_THAT(webrtc::WaitUntil(
[&] { return lport->last_stun_msg(); }, NotNull(),
@@ -2074,14 +2074,14 @@
std::unique_ptr<IceMessage> request = CopyStunMessage(*msg);
// Receive the BINDING-REQUEST and respond with BINDING-RESPONSE.
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
msg = rport->last_stun_msg();
ASSERT_TRUE(msg != NULL);
EXPECT_EQ(STUN_BINDING_RESPONSE, msg->type());
// Received a BINDING-RESPONSE.
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
// Verify the STUN Stats.
EXPECT_EQ(1U, lconn->stats().sent_ping_requests_total);
@@ -2164,12 +2164,12 @@
// Respond with a BINDING-RESPONSE.
request = CopyStunMessage(*msg);
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
msg = lport->last_stun_msg();
// Receive the BINDING-RESPONSE.
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
// Verify the Stun ping stats.
EXPECT_EQ(3U, rconn->stats().sent_ping_requests_total);
@@ -2223,8 +2223,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
EXPECT_EQ(nomination, rconn->remote_nomination());
EXPECT_FALSE(lconn->nominated());
@@ -2239,8 +2239,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(rport->last_stun_buf().size(), 0u);
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
EXPECT_EQ(nomination, lconn->acked_nomination());
EXPECT_TRUE(lconn->nominated());
@@ -2373,8 +2373,8 @@
IceMessage* msg = lport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Pass the binding request to rport.
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
// Wait until rport sends the response and then check the remote network cost.
ASSERT_THAT(webrtc::WaitUntil(
@@ -2441,7 +2441,7 @@
std::unique_ptr<IceMessage> in_msg, out_msg;
auto buf = std::make_unique<ByteBufferWriter>();
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
// BINDING-REQUEST from local to remote with valid ICE username,
@@ -2490,7 +2490,7 @@
std::unique_ptr<IceMessage> in_msg, out_msg;
auto buf = std::make_unique<ByteBufferWriter>();
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
// BINDING-REQUEST with no username.
@@ -2556,7 +2556,7 @@
std::unique_ptr<IceMessage> in_msg, out_msg;
auto buf = std::make_unique<ByteBufferWriter>();
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
// BINDING-REQUEST from local to remote with valid ICE username and
@@ -2594,7 +2594,7 @@
std::unique_ptr<IceMessage> in_msg, out_msg;
auto buf = std::make_unique<ByteBufferWriter>();
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
// BINDING-REQUEST from local to remote with valid ICE username and
@@ -2662,7 +2662,7 @@
std::unique_ptr<IceMessage> in_msg, out_msg;
auto buf = std::make_unique<ByteBufferWriter>();
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
// Build ordinary message with valid ufrag/pass.
@@ -2716,8 +2716,8 @@
[&] { return lport->last_stun_msg(); }, NotNull(),
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
- rconn->OnReadPacket(rtc::ReceivedPacket(lport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
// Intercept request and add comprehension required attribute.
ASSERT_THAT(webrtc::WaitUntil(
@@ -2774,7 +2774,7 @@
// Verifying encoding and decoding STUN indication message.
std::unique_ptr<IceMessage> in_msg, out_msg;
std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
- rtc::SocketAddress addr(kLocalAddr1);
+ webrtc::SocketAddress addr(kLocalAddr1);
std::string username;
in_msg = CreateStunMessage(STUN_BINDING_INDICATION);
@@ -2810,8 +2810,8 @@
IceMessage* msg = rport->last_stun_msg();
EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
// Send rport binding request to lport.
- lconn->OnReadPacket(rtc::ReceivedPacket(rport->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
ASSERT_THAT(webrtc::WaitUntil(
[&] { return lport->last_stun_msg(); }, NotNull(),
@@ -3384,7 +3384,7 @@
// Feeding the respone message from litemode to the full mode connection.
ch1.conn()->OnReadPacket(rtc::ReceivedPacket(
- ice_lite_port->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
+ ice_lite_port->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
// Verifying full mode connection becomes writable from the response.
EXPECT_THAT(webrtc::WaitUntil(
@@ -3517,7 +3517,7 @@
// Feeding the respone message back.
ch1.conn()->OnReadPacket(rtc::ReceivedPacket(
- port2->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
+ port2->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
port1->Reset();
port2->Reset();
@@ -3798,7 +3798,7 @@
// Feeding the respone message back.
ch1.conn()->OnReadPacket(rtc::ReceivedPacket(
- port2->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
+ port2->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
port1->Reset();
port2->Reset();
@@ -3895,7 +3895,7 @@
// Feeding the respone message back.
ch1.conn()->OnReadPacket(rtc::ReceivedPacket(
- port2->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
+ port2->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
port1->Reset();
port2->Reset();
@@ -4103,7 +4103,7 @@
port->SetIceTiebreaker(kTiebreakerDefault);
port->PrepareAddress();
EXPECT_EQ(1u, port->Candidates().size());
- rtc::SocketAddress address("1.1.1.1", 5000);
+ webrtc::SocketAddress address("1.1.1.1", 5000);
cricket::Candidate candidate(1, "udp", address, 0, "", "",
IceCandidateType::kRelay, 0, "");
cricket::Connection* conn1 =
@@ -4176,7 +4176,7 @@
webrtc::IsRtcOk());
ASSERT_GT(lport->last_stun_buf().size(), 0u);
rconn->OnReadPacket(rtc::ReceivedPacket(
- lport->last_stun_buf(), rtc::SocketAddress(), std::nullopt));
+ lport->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
ASSERT_THAT(webrtc::WaitUntil(
@@ -4194,7 +4194,7 @@
SendPingAndCaptureReply(lconn, rconn, ms, &reply);
lconn->OnReadPacket(
- rtc::ReceivedPacket(reply, rtc::SocketAddress(), std::nullopt));
+ rtc::ReceivedPacket(reply, webrtc::SocketAddress(), std::nullopt));
}
void OnConnectionStateChange(Connection* connection) { num_state_changes_++; }
@@ -4256,7 +4256,7 @@
EXPECT_FALSE(lconn->receiving());
lconn->OnReadPacket(
- rtc::ReceivedPacket(reply, rtc::SocketAddress(), std::nullopt));
+ rtc::ReceivedPacket(reply, webrtc::SocketAddress(), std::nullopt));
// That reply was discarded due to the ForgetLearnedState() while it was
// outstanding.
@@ -4331,8 +4331,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
- rconn->OnReadPacket(rtc::ReceivedPacket(lport_->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport_->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
EXPECT_TRUE(received_goog_delta);
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
@@ -4341,8 +4341,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
- lconn->OnReadPacket(rtc::ReceivedPacket(rport_->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport_->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
EXPECT_TRUE(received_goog_delta_ack);
}
@@ -4375,8 +4375,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(lport_->last_stun_buf().size(), 0u);
- rconn->OnReadPacket(rtc::ReceivedPacket(lport_->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ rconn->OnReadPacket(rtc::ReceivedPacket(
+ lport_->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
clock_.AdvanceTime(webrtc::TimeDelta::Millis(ms));
ASSERT_THAT(webrtc::WaitUntil(
@@ -4384,8 +4384,8 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
ASSERT_GT(rport_->last_stun_buf().size(), 0u);
- lconn->OnReadPacket(rtc::ReceivedPacket(rport_->last_stun_buf(),
- rtc::SocketAddress(), std::nullopt));
+ lconn->OnReadPacket(rtc::ReceivedPacket(
+ rport_->last_stun_buf(), webrtc::SocketAddress(), std::nullopt));
EXPECT_TRUE(received_goog_delta_ack_error);
}
diff --git a/p2p/base/regathering_controller_unittest.cc b/p2p/base/regathering_controller_unittest.cc
index 78cacc8..a396712 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 rtc::SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
+const webrtc::SocketAddress kStunAddr("99.99.99.1", cricket::STUN_SERVER_PORT);
// The addresses for the public TURN server.
-const rtc::SocketAddress kTurnUdpIntAddr("99.99.99.3",
- cricket::STUN_SERVER_PORT);
+const webrtc::SocketAddress kTurnUdpIntAddr("99.99.99.3",
+ cricket::STUN_SERVER_PORT);
const cricket::RelayCredentials kRelayCredentials("test", "test");
const char kIceUfrag[] = "UF00";
const char kIcePwd[] = "TESTICEPWD00000000000000";
diff --git a/p2p/base/stun_dictionary_unittest.cc b/p2p/base/stun_dictionary_unittest.cc
index b6af420..17d68d5 100644
--- a/p2p/base/stun_dictionary_unittest.cc
+++ b/p2p/base/stun_dictionary_unittest.cc
@@ -279,7 +279,7 @@
StunDictionaryWriter writer;
StunDictionaryView dictionary;
- rtc::SocketAddress addr("127.0.0.1", 8080);
+ webrtc::SocketAddress addr("127.0.0.1", 8080);
writer.SetUInt32(kKey1)->SetValue(27);
writer.SetUInt64(kKey1 + 1)->SetValue(28);
@@ -299,7 +299,7 @@
StunDictionaryWriter writer;
StunDictionaryView dictionary;
- rtc::SocketAddress addr("127.0.0.1", 8080);
+ webrtc::SocketAddress addr("127.0.0.1", 8080);
writer.SetUInt32(kKey1)->SetValue(27);
writer.SetUInt64(kKey1 + 1)->SetValue(28);
diff --git a/p2p/base/stun_port.cc b/p2p/base/stun_port.cc
index 1de9ffd..9c8f712 100644
--- a/p2p/base/stun_port.cc
+++ b/p2p/base/stun_port.cc
@@ -41,7 +41,7 @@
class StunBindingRequest : public StunRequest {
public:
StunBindingRequest(UDPPort* port,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int64_t start_time)
: StunRequest(port->request_manager(),
std::make_unique<StunMessage>(STUN_BINDING_REQUEST)),
@@ -51,7 +51,7 @@
SetAuthenticationRequired(false);
}
- const rtc::SocketAddress& server_addr() const { return server_addr_; }
+ const webrtc::SocketAddress& server_addr() const { return server_addr_; }
void OnResponse(StunMessage* response) override {
const StunAddressAttribute* addr_attr =
@@ -62,7 +62,7 @@
addr_attr->family() != STUN_ADDRESS_IPV6) {
RTC_LOG(LS_ERROR) << "Binding address has bad family";
} else {
- rtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
+ webrtc::SocketAddress addr(addr_attr->ipaddr(), addr_attr->port());
port_->OnStunBindingRequestSucceeded(this->Elapsed(), server_addr_, addr);
}
@@ -116,18 +116,18 @@
}
UDPPort* port_;
- const rtc::SocketAddress server_addr_;
+ const webrtc::SocketAddress server_addr_;
int64_t start_time_;
};
UDPPort::AddressResolver::AddressResolver(
rtc::PacketSocketFactory* factory,
- std::function<void(const rtc::SocketAddress&, int)> done_callback)
+ std::function<void(const webrtc::SocketAddress&, int)> done_callback)
: socket_factory_(factory), done_(std::move(done_callback)) {}
void UDPPort::AddressResolver::Resolve(
- const rtc::SocketAddress& address,
+ const webrtc::SocketAddress& address,
int family,
const webrtc::FieldTrialsView& /* field_trials */) {
if (resolvers_.find(address) != resolvers_.end())
@@ -135,7 +135,7 @@
auto resolver = socket_factory_->CreateAsyncDnsResolver();
auto resolver_ptr = resolver.get();
- std::pair<rtc::SocketAddress,
+ std::pair<webrtc::SocketAddress,
std::unique_ptr<webrtc::AsyncDnsResolverInterface>>
pair = std::make_pair(address, std::move(resolver));
@@ -150,9 +150,9 @@
}
bool UDPPort::AddressResolver::GetResolvedAddress(
- const rtc::SocketAddress& input,
+ const webrtc::SocketAddress& input,
int family,
- rtc::SocketAddress* output) const {
+ webrtc::SocketAddress* output) const {
ResolverMap::const_iterator it = resolvers_.find(input);
if (it == resolvers_.end())
return false;
@@ -200,7 +200,8 @@
if (!SharedSocket()) {
RTC_DCHECK(socket_ == nullptr);
socket_ = socket_factory()->CreateUdpSocket(
- rtc::SocketAddress(Network()->GetBestIP(), 0), min_port(), max_port());
+ webrtc::SocketAddress(Network()->GetBestIP(), 0), min_port(),
+ max_port());
if (!socket_) {
RTC_LOG(LS_WARNING) << ToString() << ": UDP socket creation failed";
return false;
@@ -279,7 +280,7 @@
int UDPPort::SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool /* payload */) {
rtc::PacketOptions modified_options(options);
@@ -351,18 +352,18 @@
}
void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* /* socket */,
- const rtc::SocketAddress& address) {
+ const webrtc::SocketAddress& address) {
// When adapter enumeration is disabled and binding to the any address, the
// default local address will be issued as a candidate instead if
// `emit_local_for_anyaddress` is true. This is to allow connectivity for
// applications which absolutely requires a HOST candidate.
- rtc::SocketAddress addr = address;
+ webrtc::SocketAddress addr = address;
// If MaybeSetDefaultLocalAddress fails, we keep the "any" IP so that at
// least the port is listening.
MaybeSetDefaultLocalAddress(&addr);
- AddAddress(addr, addr, rtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
+ AddAddress(addr, addr, webrtc::SocketAddress(), UDP_PROTOCOL_NAME, "", "",
webrtc::IceCandidateType::kHost, ICE_TYPE_PREFERENCE_HOST, 0, "",
false);
MaybePrepareStunCandidate();
@@ -421,7 +422,7 @@
}
}
-void UDPPort::ResolveStunAddress(const rtc::SocketAddress& stun_addr) {
+void UDPPort::ResolveStunAddress(const webrtc::SocketAddress& stun_addr) {
if (!resolver_) {
resolver_.reset(new AddressResolver(
socket_factory(), [&](const rtc::SocketAddress& input, int error) {
@@ -434,10 +435,10 @@
resolver_->Resolve(stun_addr, Network()->family(), field_trials());
}
-void UDPPort::OnResolveResult(const rtc::SocketAddress& input, int error) {
+void UDPPort::OnResolveResult(const webrtc::SocketAddress& input, int error) {
RTC_DCHECK(resolver_.get() != nullptr);
- rtc::SocketAddress resolved;
+ webrtc::SocketAddress resolved;
if (error != 0 || !resolver_->GetResolvedAddress(
input, Network()->GetBestIP().family(), &resolved)) {
RTC_LOG(LS_WARNING) << ToString()
@@ -456,7 +457,7 @@
}
}
-void UDPPort::SendStunBindingRequest(const rtc::SocketAddress& stun_addr) {
+void UDPPort::SendStunBindingRequest(const webrtc::SocketAddress& stun_addr) {
if (stun_addr.IsUnresolvedIP()) {
ResolveStunAddress(stun_addr);
@@ -478,7 +479,7 @@
}
}
-bool UDPPort::MaybeSetDefaultLocalAddress(rtc::SocketAddress* addr) const {
+bool UDPPort::MaybeSetDefaultLocalAddress(webrtc::SocketAddress* addr) const {
if (!addr->IsAnyIP() || !emit_local_for_anyaddress_ ||
!Network()->default_local_address_provider()) {
return true;
@@ -497,8 +498,8 @@
void UDPPort::OnStunBindingRequestSucceeded(
int rtt_ms,
- const rtc::SocketAddress& stun_server_addr,
- const rtc::SocketAddress& stun_reflected_addr) {
+ const webrtc::SocketAddress& stun_server_addr,
+ const webrtc::SocketAddress& stun_reflected_addr) {
RTC_DCHECK(stats_.stun_binding_responses_received <
stats_.stun_binding_requests_sent);
stats_.stun_binding_responses_received++;
@@ -516,11 +517,11 @@
if ((!SharedSocket() || stun_reflected_addr != socket_->GetLocalAddress() ||
Network()->GetMdnsResponder() != nullptr) &&
!HasStunCandidateWithAddress(stun_reflected_addr)) {
- rtc::SocketAddress related_address = socket_->GetLocalAddress();
+ webrtc::SocketAddress related_address = socket_->GetLocalAddress();
// If we can't stamp the related address correctly, empty it to avoid leak.
if (!MaybeSetDefaultLocalAddress(&related_address)) {
related_address =
- rtc::EmptySocketAddressWithFamily(related_address.family());
+ webrtc::EmptySocketAddressWithFamily(related_address.family());
}
rtc::StringBuilder url;
@@ -534,7 +535,7 @@
}
void UDPPort::OnStunBindingOrResolveRequestFailed(
- const rtc::SocketAddress& stun_server_addr,
+ const webrtc::SocketAddress& stun_server_addr,
int error_code,
absl::string_view reason) {
if (error_code != STUN_ERROR_NOT_AN_ERROR) {
@@ -600,7 +601,7 @@
}
bool UDPPort::HasStunCandidateWithAddress(
- const rtc::SocketAddress& addr) const {
+ const webrtc::SocketAddress& addr) const {
const std::vector<Candidate>& existing_candidates = Candidates();
std::vector<Candidate>::const_iterator it = existing_candidates.begin();
for (; it != existing_candidates.end(); ++it) {
diff --git a/p2p/base/stun_port.h b/p2p/base/stun_port.h
index 3c7dbaf..69363f6 100644
--- a/p2p/base/stun_port.h
+++ b/p2p/base/stun_port.h
@@ -110,7 +110,7 @@
~UDPPort() override;
- rtc::SocketAddress GetLocalAddress() const {
+ webrtc::SocketAddress GetLocalAddress() const {
return socket_->GetLocalAddress();
}
@@ -160,7 +160,7 @@
int SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) override;
@@ -169,7 +169,7 @@
rtc::DiffServCodePoint StunDscpValue() const override;
void OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
- const rtc::SocketAddress& address);
+ const webrtc::SocketAddress& address);
void PostAddAddress(bool is_final) override;
@@ -190,7 +190,7 @@
// `addr` is the "any" address and `emit_local_for_anyaddress_` is true. When
// returning false, it indicates that the operation has failed and the
// address shouldn't be used by any candidate.
- bool MaybeSetDefaultLocalAddress(rtc::SocketAddress* addr) const;
+ bool MaybeSetDefaultLocalAddress(webrtc::SocketAddress* addr) const;
private:
// A helper class which can be called repeatedly to resolve multiple
@@ -200,17 +200,17 @@
public:
explicit AddressResolver(
rtc::PacketSocketFactory* factory,
- std::function<void(const rtc::SocketAddress&, int)> done_callback);
+ std::function<void(const webrtc::SocketAddress&, int)> done_callback);
- void Resolve(const rtc::SocketAddress& address,
+ void Resolve(const webrtc::SocketAddress& address,
int family,
const webrtc::FieldTrialsView& field_trials);
- bool GetResolvedAddress(const rtc::SocketAddress& input,
+ bool GetResolvedAddress(const webrtc::SocketAddress& input,
int family,
- rtc::SocketAddress* output) const;
+ webrtc::SocketAddress* output) const;
private:
- typedef std::map<rtc::SocketAddress,
+ typedef std::map<webrtc::SocketAddress,
std::unique_ptr<webrtc::AsyncDnsResolverInterface>>
ResolverMap;
@@ -218,28 +218,28 @@
// The function is called when resolving the specified address is finished.
// The first argument is the input address, the second argument is the error
// or 0 if it succeeded.
- std::function<void(const rtc::SocketAddress&, int)> done_;
+ std::function<void(const webrtc::SocketAddress&, int)> done_;
// Resolver may fire callbacks that refer to done_, so ensure
// that all resolvers are destroyed first.
ResolverMap resolvers_;
};
// DNS resolution of the STUN server.
- void ResolveStunAddress(const rtc::SocketAddress& stun_addr);
- void OnResolveResult(const rtc::SocketAddress& input, int error);
+ void ResolveStunAddress(const webrtc::SocketAddress& stun_addr);
+ void OnResolveResult(const webrtc::SocketAddress& input, int error);
// Send a STUN binding request to the given address. Calling this method may
// cause the set of known server addresses to be modified, eg. by replacing an
// unresolved server address with a resolved address.
- void SendStunBindingRequest(const rtc::SocketAddress& stun_addr);
+ void SendStunBindingRequest(const webrtc::SocketAddress& stun_addr);
// Below methods handles binding request responses.
void OnStunBindingRequestSucceeded(
int rtt_ms,
- const rtc::SocketAddress& stun_server_addr,
- const rtc::SocketAddress& stun_reflected_addr);
+ const webrtc::SocketAddress& stun_server_addr,
+ const webrtc::SocketAddress& stun_reflected_addr);
void OnStunBindingOrResolveRequestFailed(
- const rtc::SocketAddress& stun_server_addr,
+ const webrtc::SocketAddress& stun_server_addr,
int error_code,
absl::string_view reason);
@@ -250,7 +250,7 @@
// changed to SignalPortReady.
void MaybeSetPortCompleteOrError();
- bool HasStunCandidateWithAddress(const rtc::SocketAddress& addr) const;
+ bool HasStunCandidateWithAddress(const webrtc::SocketAddress& addr) const;
// If this is a low-cost network, it will keep on sending STUN binding
// requests indefinitely to keep the NAT binding alive. Otherwise, stop
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 3395d60..66b2725 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -57,7 +57,6 @@
namespace {
using cricket::ServerAddresses;
-using rtc::SocketAddress;
using ::testing::_;
using ::testing::DoAll;
using ::testing::Eq;
@@ -66,6 +65,7 @@
using ::testing::ReturnPointee;
using ::testing::SetArgPointee;
using webrtc::IceCandidateType;
+using ::webrtc::SocketAddress;
static const SocketAddress kPrivateIP("192.168.1.12", 0);
static const SocketAddress kMsdnAddress("unittest-mdns-host-name.local", 0);
@@ -133,8 +133,8 @@
kNatAddr) {}
StunPortTestBase(const webrtc::IPAddress address,
- const std::set<rtc::SocketAddress>& stun_server_addresses,
- const rtc::SocketAddress& nat_server_address)
+ const std::set<webrtc::SocketAddress>& stun_server_addresses,
+ const webrtc::SocketAddress& nat_server_address)
: ss_(new rtc::VirtualSocketServer()),
thread_(ss_.get()),
nat_factory_(ss_.get(), nat_server_address, nat_server_address),
@@ -178,7 +178,7 @@
network_->set_type(adapter_type);
}
- void CreateStunPort(const rtc::SocketAddress& server_addr,
+ void CreateStunPort(const webrtc::SocketAddress& server_addr,
const webrtc::FieldTrialsView* field_trials = nullptr) {
ServerAddresses stun_servers;
stun_servers.insert(server_addr);
@@ -210,14 +210,14 @@
}
void CreateSharedUdpPort(
- const rtc::SocketAddress& server_addr,
+ const webrtc::SocketAddress& server_addr,
rtc::AsyncPacketSocket* socket,
const webrtc::FieldTrialsView* field_trials = nullptr) {
if (socket) {
socket_.reset(socket);
} else {
socket_.reset(socket_factory()->CreateUdpSocket(
- rtc::SocketAddress(kPrivateIP.ipaddr(), 0), 0, 0));
+ webrtc::SocketAddress(kPrivateIP.ipaddr(), 0), 0, 0));
}
ASSERT_TRUE(socket_ != NULL);
socket_->RegisterReceivedPacketCallback(
@@ -250,10 +250,10 @@
}
void SendData(const char* data, size_t len) {
- stun_port_->HandleIncomingPacket(socket_.get(),
- rtc::ReceivedPacket::CreateFromLegacy(
- data, len, /* packet_time_us */ -1,
- rtc::SocketAddress("22.22.22.22", 0)));
+ stun_port_->HandleIncomingPacket(
+ socket_.get(), rtc::ReceivedPacket::CreateFromLegacy(
+ data, len, /* packet_time_us */ -1,
+ webrtc::SocketAddress("22.22.22.22", 0)));
}
void EnableMdnsObfuscation() {
@@ -420,7 +420,8 @@
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
- .WillOnce([](const rtc::SocketAddress& /* addr */, int /* family */,
+ .WillOnce([](const webrtc::SocketAddress& /* addr */,
+ int /* family */,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
@@ -449,7 +450,8 @@
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kValidHostnameAddr, /*family=*/AF_INET, _))
- .WillOnce([](const rtc::SocketAddress& /* addr */, int /* family */,
+ .WillOnce([](const webrtc::SocketAddress& /* addr */,
+ int /* family */,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
@@ -874,7 +876,7 @@
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
- .WillOnce([](const rtc::SocketAddress& addr, int family,
+ .WillOnce([](const webrtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
@@ -906,7 +908,7 @@
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver,
Start(kValidHostnameAddr, /*family=*/AF_INET6, _))
- .WillOnce([](const rtc::SocketAddress& addr, int family,
+ .WillOnce([](const webrtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
diff --git a/p2p/base/tcp_port.cc b/p2p/base/tcp_port.cc
index c7281b0..5ebecc6 100644
--- a/p2p/base/tcp_port.cc
+++ b/p2p/base/tcp_port.cc
@@ -167,7 +167,7 @@
<< static_cast<int>(listen_socket_->GetState());
AddAddress(
listen_socket_->GetLocalAddress(), listen_socket_->GetLocalAddress(),
- rtc::SocketAddress(), TCP_PROTOCOL_NAME, "", TCPTYPE_PASSIVE_STR,
+ webrtc::SocketAddress(), TCP_PROTOCOL_NAME, "", TCPTYPE_PASSIVE_STR,
IceCandidateType::kHost, ICE_TYPE_PREFERENCE_HOST_TCP, 0, "", true);
} else {
RTC_LOG(LS_INFO) << ToString()
@@ -180,17 +180,17 @@
// can do.
// TODO(deadbeef): We could do something like create a dummy socket just to
// see what IP we get. But that may be overkill.
- AddAddress(rtc::SocketAddress(Network()->GetBestIP(), DISCARD_PORT),
- rtc::SocketAddress(Network()->GetBestIP(), 0),
- rtc::SocketAddress(), TCP_PROTOCOL_NAME, "", TCPTYPE_ACTIVE_STR,
- IceCandidateType::kHost, ICE_TYPE_PREFERENCE_HOST_TCP, 0, "",
- true);
+ AddAddress(webrtc::SocketAddress(Network()->GetBestIP(), DISCARD_PORT),
+ webrtc::SocketAddress(Network()->GetBestIP(), 0),
+ webrtc::SocketAddress(), TCP_PROTOCOL_NAME, "",
+ TCPTYPE_ACTIVE_STR, IceCandidateType::kHost,
+ ICE_TYPE_PREFERENCE_HOST_TCP, 0, "", true);
}
}
int TCPPort::SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) {
rtc::AsyncPacketSocket* socket = NULL;
@@ -288,7 +288,7 @@
void TCPPort::TryCreateServerSocket() {
listen_socket_ = absl::WrapUnique(socket_factory()->CreateServerTcpSocket(
- rtc::SocketAddress(Network()->GetBestIP(), 0), min_port(), max_port(),
+ webrtc::SocketAddress(Network()->GetBestIP(), 0), min_port(), max_port(),
false /* ssl */));
if (!listen_socket_) {
RTC_LOG(LS_WARNING)
@@ -299,7 +299,7 @@
listen_socket_->SignalNewConnection.connect(this, &TCPPort::OnNewConnection);
}
-rtc::AsyncPacketSocket* TCPPort::GetIncoming(const rtc::SocketAddress& addr,
+rtc::AsyncPacketSocket* TCPPort::GetIncoming(const webrtc::SocketAddress& addr,
bool remove) {
rtc::AsyncPacketSocket* socket = NULL;
for (std::list<Incoming>::iterator it = incoming_.begin();
@@ -457,7 +457,7 @@
//
// Note that, aside from minor differences in log statements, this logic is
// identical to that in TurnPort.
- const rtc::SocketAddress& socket_address = socket->GetLocalAddress();
+ const webrtc::SocketAddress& socket_address = socket->GetLocalAddress();
if (absl::c_any_of(port_->Network()->GetIPs(),
[socket_address](const rtc::InterfaceAddress& addr) {
return socket_address.ipaddr() == addr;
@@ -587,7 +587,7 @@
rtc::PacketSocketTcpOptions tcp_opts;
tcp_opts.opts = opts;
socket_.reset(port()->socket_factory()->CreateClientTcpSocket(
- rtc::SocketAddress(port()->Network()->GetBestIP(), 0),
+ webrtc::SocketAddress(port()->Network()->GetBestIP(), 0),
remote_candidate().address(), tcp_opts));
if (socket_) {
RTC_LOG(LS_VERBOSE) << ToString() << ": Connecting from "
diff --git a/p2p/base/tcp_port.h b/p2p/base/tcp_port.h
index 13551b5..aa812ad 100644
--- a/p2p/base/tcp_port.h
+++ b/p2p/base/tcp_port.h
@@ -88,7 +88,7 @@
// Handles sending using the local TCP socket.
int SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) override;
@@ -98,13 +98,13 @@
private:
struct Incoming {
- rtc::SocketAddress addr;
+ webrtc::SocketAddress addr;
rtc::AsyncPacketSocket* socket;
};
void TryCreateServerSocket();
- rtc::AsyncPacketSocket* GetIncoming(const rtc::SocketAddress& addr,
+ rtc::AsyncPacketSocket* GetIncoming(const webrtc::SocketAddress& addr,
bool remove = false);
// Receives packet signal from the local TCP Socket.
diff --git a/p2p/base/tcp_port_unittest.cc b/p2p/base/tcp_port_unittest.cc
index 3fbea87..efcdfcb 100644
--- a/p2p/base/tcp_port_unittest.cc
+++ b/p2p/base/tcp_port_unittest.cc
@@ -46,9 +46,9 @@
using cricket::ICE_UFRAG_LENGTH;
using cricket::Port;
using cricket::TCPPort;
-using rtc::SocketAddress;
using ::testing::Eq;
using ::testing::IsTrue;
+using ::webrtc::SocketAddress;
static int kTimeout = 1000;
static const SocketAddress kLocalAddr("11.11.11.11", 0);
diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc
index 0dc26a5..41d2d00 100644
--- a/p2p/base/turn_port.cc
+++ b/p2p/base/turn_port.cc
@@ -113,7 +113,7 @@
public:
TurnCreatePermissionRequest(TurnPort* port,
TurnEntry* entry,
- const rtc::SocketAddress& ext_addr);
+ const webrtc::SocketAddress& ext_addr);
~TurnCreatePermissionRequest() override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
@@ -123,7 +123,7 @@
private:
TurnPort* port_;
TurnEntry* entry_;
- rtc::SocketAddress ext_addr_;
+ webrtc::SocketAddress ext_addr_;
};
class TurnChannelBindRequest : public StunRequest {
@@ -131,7 +131,7 @@
TurnChannelBindRequest(TurnPort* port,
TurnEntry* entry,
uint16_t channel_id,
- const rtc::SocketAddress& ext_addr);
+ const webrtc::SocketAddress& ext_addr);
~TurnChannelBindRequest() override;
void OnSent() override;
void OnResponse(StunMessage* response) override;
@@ -142,7 +142,7 @@
TurnPort* const port_;
TurnEntry* entry_; // Could be WeakPtr.
const uint16_t channel_id_;
- const rtc::SocketAddress ext_addr_;
+ const webrtc::SocketAddress ext_addr_;
};
// Manages a "connection" to a remote destination. We will attempt to bring up
@@ -157,7 +157,7 @@
uint16_t channel_id() const { return channel_id_; }
- const rtc::SocketAddress& address() const { return ext_addr_; }
+ const webrtc::SocketAddress& address() const { return ext_addr_; }
BindState state() const { return state_; }
// Adds a new connection object to the list of connections that are associated
@@ -197,7 +197,7 @@
private:
TurnPort* const port_;
const uint16_t channel_id_;
- const rtc::SocketAddress ext_addr_;
+ const webrtc::SocketAddress ext_addr_;
BindState state_;
// List of associated connection instances to keep track of how many and
// which connections are associated with this entry. Once this is empty,
@@ -359,8 +359,8 @@
}
}
-rtc::SocketAddress TurnPort::GetLocalAddress() const {
- return socket_ ? socket_->GetLocalAddress() : rtc::SocketAddress();
+webrtc::SocketAddress TurnPort::GetLocalAddress() const {
+ return socket_ ? socket_->GetLocalAddress() : webrtc::SocketAddress();
}
webrtc::ProtocolType TurnPort::GetProtocol() const {
@@ -453,7 +453,8 @@
if (server_address_.proto == webrtc::PROTO_UDP && !SharedSocket()) {
socket_ = socket_factory()->CreateUdpSocket(
- rtc::SocketAddress(Network()->GetBestIP(), 0), min_port(), max_port());
+ webrtc::SocketAddress(Network()->GetBestIP(), 0), min_port(),
+ max_port());
} else if (server_address_.proto == webrtc::PROTO_TCP ||
server_address_.proto == webrtc::PROTO_TLS) {
RTC_DCHECK(!SharedSocket());
@@ -475,8 +476,8 @@
tcp_options.tls_elliptic_curves = tls_elliptic_curves_;
tcp_options.tls_cert_verifier = tls_cert_verifier_;
socket_ = socket_factory()->CreateClientTcpSocket(
- rtc::SocketAddress(Network()->GetBestIP(), 0), server_address_.address,
- tcp_options);
+ webrtc::SocketAddress(Network()->GetBestIP(), 0),
+ server_address_.address, tcp_options);
}
if (!socket_) {
@@ -536,7 +537,7 @@
//
// Note that, aside from minor differences in log statements, this logic is
// identical to that in TcpPort.
- const rtc::SocketAddress& socket_address = socket->GetLocalAddress();
+ const webrtc::SocketAddress& socket_address = socket->GetLocalAddress();
if (absl::c_none_of(Network()->GetIPs(),
[socket_address](const rtc::InterfaceAddress& addr) {
return socket_address.ipaddr() == addr;
@@ -654,7 +655,7 @@
return nullptr;
}
-bool TurnPort::FailAndPruneConnection(const rtc::SocketAddress& address) {
+bool TurnPort::FailAndPruneConnection(const webrtc::SocketAddress& address) {
Connection* conn = GetConnection(address);
if (conn != nullptr) {
conn->FailAndPrune();
@@ -696,7 +697,7 @@
int TurnPort::SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) {
// Try to find an entry for this specific address; we should have one.
@@ -723,12 +724,12 @@
}
bool TurnPort::CanHandleIncomingPacketsFrom(
- const rtc::SocketAddress& addr) const {
+ const webrtc::SocketAddress& addr) const {
return server_address_.address == addr;
}
void TurnPort::SendBindingErrorResponse(StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view reason) {
if (!GetConnection(addr))
@@ -825,7 +826,7 @@
}
// Update current server address port with the alternate server address port.
-bool TurnPort::SetAlternateServer(const rtc::SocketAddress& address) {
+bool TurnPort::SetAlternateServer(const webrtc::SocketAddress& address) {
// Check if we have seen this address before and reject if we did.
AttemptedServerSet::iterator iter = attempted_server_addresses_.find(address);
if (iter != attempted_server_addresses_.end()) {
@@ -862,7 +863,7 @@
return true;
}
-void TurnPort::ResolveTurnAddress(const rtc::SocketAddress& address) {
+void TurnPort::ResolveTurnAddress(const webrtc::SocketAddress& address) {
if (resolver_)
return;
@@ -888,7 +889,7 @@
// Copy the original server address in `resolved_address`. For TLS based
// sockets we need hostname along with resolved address.
- rtc::SocketAddress resolved_address = server_address_.address;
+ webrtc::SocketAddress resolved_address = server_address_.address;
if (result.GetError() != 0 ||
!result.GetResolvedAddress(Network()->GetBestIP().family(),
&resolved_address)) {
@@ -918,7 +919,7 @@
}
}
-void TurnPort::OnStunAddress(const rtc::SocketAddress& address) {
+void TurnPort::OnStunAddress(const webrtc::SocketAddress& address) {
// STUN Port will discover STUN candidate, as it's supplied with first TURN
// server address.
// Why not using this address? - P2PTransportChannel will start creating
@@ -928,11 +929,11 @@
// handle to UDPPort to pass back the address.
}
-void TurnPort::OnAllocateSuccess(const rtc::SocketAddress& address,
- const rtc::SocketAddress& stun_address) {
+void TurnPort::OnAllocateSuccess(const webrtc::SocketAddress& address,
+ const webrtc::SocketAddress& stun_address) {
state_ = STATE_READY;
- rtc::SocketAddress related_address = stun_address;
+ webrtc::SocketAddress related_address = stun_address;
// For relayed candidate, Base is the candidate itself.
AddAddress(address, // Candidate address.
@@ -1082,7 +1083,7 @@
// Log a warning if the data didn't come from an address that we think we have
// a permission for.
- rtc::SocketAddress ext_addr(addr_attr->GetAddress());
+ webrtc::SocketAddress ext_addr(addr_attr->GetAddress());
if (!HasPermission(ext_addr.ipaddr())) {
RTC_LOG(LS_WARNING) << ToString()
<< ": Received TURN data indication with unknown "
@@ -1140,7 +1141,7 @@
void TurnPort::DispatchPacket(const char* data,
size_t size,
- const rtc::SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
webrtc::ProtocolType proto,
int64_t packet_time_us) {
rtc::ReceivedPacket packet = rtc::ReceivedPacket::CreateFromLegacy(
@@ -1252,7 +1253,7 @@
});
}
-TurnEntry* TurnPort::FindEntry(const rtc::SocketAddress& addr) const {
+TurnEntry* TurnPort::FindEntry(const webrtc::SocketAddress& addr) const {
auto it = absl::c_find_if(
entries_, [&addr](const auto& e) { return e->address() == addr; });
return (it != entries_.end()) ? it->get() : nullptr;
@@ -1283,7 +1284,8 @@
void TurnPort::HandleConnectionDestroyed(Connection* conn) {
// Schedule an event to destroy TurnEntry for the connection, which is
// being destroyed.
- const rtc::SocketAddress& remote_address = conn->remote_candidate().address();
+ const webrtc::SocketAddress& remote_address =
+ conn->remote_candidate().address();
// We should always have an entry for this connection.
TurnEntry* entry = FindEntry(remote_address);
rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> flag =
@@ -1641,7 +1643,7 @@
TurnCreatePermissionRequest::TurnCreatePermissionRequest(
TurnPort* port,
TurnEntry* entry,
- const rtc::SocketAddress& ext_addr)
+ const webrtc::SocketAddress& ext_addr)
: StunRequest(
port->request_manager(),
std::make_unique<TurnMessage>(TURN_CREATE_PERMISSION_REQUEST)),
@@ -1712,7 +1714,7 @@
TurnPort* port,
TurnEntry* entry,
uint16_t channel_id,
- const rtc::SocketAddress& ext_addr)
+ const webrtc::SocketAddress& ext_addr)
: StunRequest(port->request_manager(),
std::make_unique<TurnMessage>(TURN_CHANNEL_BIND_REQUEST)),
port_(port),
diff --git a/p2p/base/turn_port.h b/p2p/base/turn_port.h
index 32d0b0e..9878424 100644
--- a/p2p/base/turn_port.h
+++ b/p2p/base/turn_port.h
@@ -119,7 +119,7 @@
const ProtocolAddress& server_address() const { return server_address_; }
// Returns an empty address if the local address has not been assigned.
- rtc::SocketAddress GetLocalAddress() const;
+ webrtc::SocketAddress GetLocalAddress() const;
bool ready() const { return state_ == STATE_READY; }
bool connected() const {
@@ -147,7 +147,7 @@
webrtc::PortInterface::CandidateOrigin origin) override;
int SendTo(const void* data,
size_t size,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) override;
int SetOption(rtc::Socket::Option opt, int value) override;
@@ -157,12 +157,12 @@
bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) override;
bool CanHandleIncomingPacketsFrom(
- const rtc::SocketAddress& addr) const override;
+ const webrtc::SocketAddress& addr) const override;
// Checks if a connection exists for `addr` before forwarding the call to
// the base class.
void SendBindingErrorResponse(StunMessage* message,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view reason) override;
@@ -272,7 +272,7 @@
private:
typedef std::map<rtc::Socket::Option, int> SocketOptionsMap;
- typedef std::set<rtc::SocketAddress> AttemptedServerSet;
+ typedef std::set<webrtc::SocketAddress> AttemptedServerSet;
static bool AllowedTurnPort(int port,
const webrtc::FieldTrialsView* field_trials);
@@ -285,17 +285,17 @@
void OnRefreshError();
void HandleRefreshError();
- bool SetAlternateServer(const rtc::SocketAddress& address);
- void ResolveTurnAddress(const rtc::SocketAddress& address);
+ bool SetAlternateServer(const webrtc::SocketAddress& address);
+ void ResolveTurnAddress(const webrtc::SocketAddress& address);
void OnResolveResult(const webrtc::AsyncDnsResolverResult& result);
void AddRequestAuthInfo(StunMessage* msg);
void OnSendStunPacket(const void* data, size_t size, StunRequest* request);
// Stun address from allocate success response.
// Currently used only for testing.
- void OnStunAddress(const rtc::SocketAddress& address);
- void OnAllocateSuccess(const rtc::SocketAddress& address,
- const rtc::SocketAddress& stun_address);
+ void OnStunAddress(const webrtc::SocketAddress& address);
+ void OnAllocateSuccess(const webrtc::SocketAddress& address,
+ const webrtc::SocketAddress& stun_address);
void OnAllocateError(int error_code, absl::string_view reason);
void OnAllocateRequestTimeout();
@@ -308,7 +308,7 @@
int64_t packet_time_us);
void DispatchPacket(const char* data,
size_t size,
- const rtc::SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
webrtc::ProtocolType proto,
int64_t packet_time_us);
@@ -320,12 +320,12 @@
void ResetNonce();
bool HasPermission(const webrtc::IPAddress& ipaddr) const;
- TurnEntry* FindEntry(const rtc::SocketAddress& address) const;
+ TurnEntry* FindEntry(const webrtc::SocketAddress& address) const;
TurnEntry* FindEntry(uint16_t channel_id) const;
// Marks the connection with remote address `address` failed and
// pruned (a.k.a. write-timed-out). Returns true if a connection is found.
- bool FailAndPruneConnection(const rtc::SocketAddress& address);
+ bool FailAndPruneConnection(const webrtc::SocketAddress& address);
void MaybeAddTurnLoggingId(StunMessage* message);
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index 88711cf..807e237 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -69,7 +69,7 @@
#include "test/scoped_key_value_config.h"
namespace {
-using rtc::SocketAddress;
+using ::webrtc::SocketAddress;
using ::testing::_;
using ::testing::DoAll;
@@ -284,7 +284,7 @@
return CreateTurnPortWithAllParams(MakeNetwork(kLocalAddr1), username,
password, server_address);
}
- bool CreateTurnPort(const rtc::SocketAddress& local_address,
+ bool CreateTurnPort(const webrtc::SocketAddress& local_address,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address) {
@@ -346,7 +346,7 @@
if (!socket_) {
socket_.reset(socket_factory()->CreateUdpSocket(
- rtc::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
+ webrtc::SocketAddress(kLocalAddr1.ipaddr(), 0), 0, 0));
ASSERT_TRUE(socket_ != NULL);
socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket,
@@ -509,7 +509,7 @@
}
void TestTurnAlternateServer(webrtc::ProtocolType protocol_type) {
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnAlternateIntAddr);
TestTurnRedirector redirector(redirect_addresses);
@@ -541,7 +541,7 @@
}
void TestTurnAlternateServerV4toV6(webrtc::ProtocolType protocol_type) {
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnIPv6IntAddr);
TestTurnRedirector redirector(redirect_addresses);
@@ -561,7 +561,7 @@
}
void TestTurnAlternateServerPingPong(webrtc::ProtocolType protocol_type) {
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnAlternateIntAddr);
redirect_addresses.push_back(kTurnIntAddr);
@@ -581,7 +581,7 @@
.clock = &fake_clock_}),
webrtc::IsRtcOk());
ASSERT_EQ(0U, turn_port_->Candidates().size());
- rtc::SocketAddress address;
+ webrtc::SocketAddress address;
// Verify that we have exhausted all alternate servers instead of
// failure caused by other errors.
EXPECT_FALSE(redirector.ShouldRedirect(address, &address));
@@ -589,7 +589,7 @@
void TestTurnAlternateServerDetectRepetition(
webrtc::ProtocolType protocol_type) {
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnAlternateIntAddr);
redirect_addresses.push_back(kTurnAlternateIntAddr);
@@ -621,7 +621,7 @@
const SocketAddress& server_address =
ipv6 ? kTurnIPv6IntAddr : kTurnIntAddr;
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
// 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",
@@ -1328,7 +1328,7 @@
{.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
.clock = &fake_clock_}),
webrtc::IsRtcOk());
- rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
+ webrtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Destroy the turnport while keeping the drop probability to 1 to
// suppress the release of the allocation at the server.
ss_->set_drop_probability(1.0);
@@ -1372,7 +1372,7 @@
{.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
.clock = &fake_clock_}),
webrtc::IsRtcOk());
- rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
+ webrtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
// the allocation.
@@ -1406,7 +1406,7 @@
socket_.get(),
rtc::ReceivedPacket::CreateFromLegacy(
test_packet.data(), test_packet.size(), rtc::TimeMicros(),
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0))));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0))));
}
// Tests that a shared-socket-TurnPort creates its own socket after
@@ -1420,7 +1420,7 @@
{.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 2),
.clock = &fake_clock_}),
webrtc::IsRtcOk());
- rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
+ webrtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
// the allocation.
@@ -1457,7 +1457,7 @@
{.timeout = webrtc::TimeDelta::Millis(kSimulatedRtt * 3),
.clock = &fake_clock_}),
webrtc::IsRtcOk());
- rtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
+ webrtc::SocketAddress first_addr(turn_port_->socket()->GetLocalAddress());
// Clear connected_ flag on turnport to suppress the release of
// the allocation.
@@ -2167,7 +2167,7 @@
TEST_F(TurnPortTest, TestTurnDangerousAlternateServer) {
const webrtc::ProtocolType protocol_type = webrtc::PROTO_TCP;
- std::vector<rtc::SocketAddress> redirect_addresses;
+ std::vector<webrtc::SocketAddress> redirect_addresses;
redirect_addresses.push_back(kTurnDangerousAddr);
TestTurnRedirector redirector(redirect_addresses);
@@ -2220,7 +2220,7 @@
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET, _))
- .WillOnce([](const rtc::SocketAddress& addr, int family,
+ .WillOnce([](const webrtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
@@ -2241,7 +2241,7 @@
[](webrtc::MockAsyncDnsResolver* resolver,
webrtc::MockAsyncDnsResolverResult* resolver_result) {
EXPECT_CALL(*resolver, Start(kTurnValidAddr, /*family=*/AF_INET6, _))
- .WillOnce([](const rtc::SocketAddress& addr, int family,
+ .WillOnce([](const webrtc::SocketAddress& addr, int family,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*resolver, result)
.WillRepeatedly(ReturnPointee(resolver_result));
diff --git a/p2p/client/basic_port_allocator.cc b/p2p/client/basic_port_allocator.cc
index 5a8a81b..94c80d7 100644
--- a/p2p/client/basic_port_allocator.cc
+++ b/p2p/client/basic_port_allocator.cc
@@ -1292,7 +1292,7 @@
void AllocationSequence::Init() {
if (IsFlagSet(PORTALLOCATOR_ENABLE_SHARED_SOCKET)) {
udp_socket_.reset(session_->socket_factory()->CreateUdpSocket(
- rtc::SocketAddress(network_->GetBestIP(), 0),
+ webrtc::SocketAddress(network_->GetBestIP(), 0),
session_->allocator()->min_port(), session_->allocator()->max_port()));
if (udp_socket_) {
udp_socket_->RegisterReceivedPacketCallback(
diff --git a/p2p/client/basic_port_allocator.h b/p2p/client/basic_port_allocator.h
index 6dc0ffb..bcc3db0 100644
--- a/p2p/client/basic_port_allocator.h
+++ b/p2p/client/basic_port_allocator.h
@@ -302,7 +302,7 @@
// TODO(deadbeef): Rename "relay" to "turn_server" in this struct.
struct RTC_EXPORT PortConfiguration {
// TODO(jiayl): remove `stun_address` when Chrome is updated.
- rtc::SocketAddress stun_address;
+ webrtc::SocketAddress stun_address;
ServerAddresses stun_servers;
std::string username;
std::string password;
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index bfb4f68..31355d3 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -60,12 +60,12 @@
#include "test/wait_until.h"
using rtc::IPAddress;
-using rtc::SocketAddress;
using testing::Contains;
using ::testing::Eq;
using ::testing::IsTrue;
using testing::Not;
using webrtc::IceCandidateType;
+using ::webrtc::SocketAddress;
#define MAYBE_SKIP_IPV4 \
if (!rtc::HasIPv4Enabled()) { \
@@ -212,22 +212,22 @@
allocator_->set_step_delay(kMinimumStepDelay);
}
// Endpoint is behind a NAT, with STUN specified.
- void ResetWithStunServerAndNat(const rtc::SocketAddress& stun_server) {
+ void ResetWithStunServerAndNat(const webrtc::SocketAddress& stun_server) {
ResetWithStunServer(stun_server, true);
}
// Endpoint is on the public network, with STUN specified.
- void ResetWithStunServerNoNat(const rtc::SocketAddress& stun_server) {
+ void ResetWithStunServerNoNat(const webrtc::SocketAddress& stun_server) {
ResetWithStunServer(stun_server, false);
}
// Endpoint is on the public network, with TURN specified.
- void ResetWithTurnServersNoNat(const rtc::SocketAddress& udp_turn,
- const rtc::SocketAddress& tcp_turn) {
+ void ResetWithTurnServersNoNat(const webrtc::SocketAddress& udp_turn,
+ const webrtc::SocketAddress& tcp_turn) {
ResetWithNoServersOrNat();
AddTurnServers(udp_turn, tcp_turn);
}
- RelayServerConfig CreateTurnServers(const rtc::SocketAddress& udp_turn,
- const rtc::SocketAddress& tcp_turn) {
+ RelayServerConfig CreateTurnServers(const webrtc::SocketAddress& udp_turn,
+ const webrtc::SocketAddress& tcp_turn) {
RelayServerConfig turn_server;
RelayCredentials credentials(kTurnUsername, kTurnPassword);
turn_server.credentials = credentials;
@@ -241,8 +241,8 @@
return turn_server;
}
- void AddTurnServers(const rtc::SocketAddress& udp_turn,
- const rtc::SocketAddress& tcp_turn) {
+ void AddTurnServers(const webrtc::SocketAddress& udp_turn,
+ const webrtc::SocketAddress& tcp_turn) {
RelayServerConfig turn_server = CreateTurnServers(udp_turn, tcp_turn);
allocator_->AddTurnServerForTesting(turn_server);
}
@@ -361,7 +361,7 @@
});
}
- static bool CheckPort(const rtc::SocketAddress& addr,
+ static bool CheckPort(const webrtc::SocketAddress& addr,
int min_port,
int max_port) {
return (addr.port() >= min_port && addr.port() <= max_port);
@@ -474,12 +474,12 @@
return false;
}
- void ResetWithStunServer(const rtc::SocketAddress& stun_server,
+ void ResetWithStunServer(const webrtc::SocketAddress& stun_server,
bool with_nat) {
if (with_nat) {
nat_server_.reset(new rtc::NATServer(
rtc::NAT_OPEN_CONE, thread_, vss_.get(), kNatUdpAddr, kNatTcpAddr,
- thread_, vss_.get(), rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+ thread_, vss_.get(), webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
} else {
nat_socket_factory_ =
std::make_unique<rtc::BasicPacketSocketFactory>(fss_.get());
@@ -559,32 +559,33 @@
uint32_t total_candidates = 0;
if (!host_candidate_addr.IsNil()) {
- EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kHost, "udp",
- rtc::SocketAddress(kPrivateAddr.ipaddr(), 0)));
+ EXPECT_TRUE(
+ HasCandidate(candidates_, IceCandidateType::kHost, "udp",
+ webrtc::SocketAddress(kPrivateAddr.ipaddr(), 0)));
++total_candidates;
}
if (!stun_candidate_addr.IsNil()) {
- rtc::SocketAddress related_address(host_candidate_addr, 0);
+ webrtc::SocketAddress related_address(host_candidate_addr, 0);
if (host_candidate_addr.IsNil()) {
related_address.SetIP(webrtc::GetAnyIP(stun_candidate_addr.family()));
}
EXPECT_TRUE(HasCandidateWithRelatedAddr(
candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(stun_candidate_addr, 0), related_address));
+ webrtc::SocketAddress(stun_candidate_addr, 0), related_address));
++total_candidates;
}
if (!relay_candidate_udp_transport_addr.IsNil()) {
EXPECT_TRUE(HasCandidateWithRelatedAddr(
candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(relay_candidate_udp_transport_addr, 0),
- rtc::SocketAddress(stun_candidate_addr, 0)));
+ webrtc::SocketAddress(relay_candidate_udp_transport_addr, 0),
+ webrtc::SocketAddress(stun_candidate_addr, 0)));
++total_candidates;
}
if (!relay_candidate_tcp_transport_addr.IsNil()) {
EXPECT_TRUE(HasCandidateWithRelatedAddr(
candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(relay_candidate_tcp_transport_addr, 0),
- rtc::SocketAddress(stun_candidate_addr, 0)));
+ webrtc::SocketAddress(relay_candidate_tcp_transport_addr, 0),
+ webrtc::SocketAddress(stun_candidate_addr, 0)));
++total_candidates;
}
@@ -603,8 +604,8 @@
allocator_->SetConfiguration(allocator_->stun_servers(),
allocator_->turn_servers(), 0,
webrtc::PRUNE_BASED_ON_PRIORITY);
- AddTurnServers(kTurnUdpIntIPv6Addr, rtc::SocketAddress());
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntIPv6Addr, webrtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_step_delay(kMinimumStepDelay);
allocator_->set_flags(
@@ -639,8 +640,9 @@
EXPECT_EQ(3U, ready_candidates.size());
EXPECT_TRUE(HasCandidate(ready_candidates, IceCandidateType::kHost, "udp",
kClientAddr));
- EXPECT_TRUE(HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ EXPECT_TRUE(
+ HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
}
void TestTurnPortPrunesWithUdpAndTcpPorts(
@@ -694,8 +696,9 @@
kClientAddr));
// The external candidate is always udp.
- EXPECT_TRUE(HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ EXPECT_TRUE(
+ HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
}
void TestEachInterfaceHasItsOwnTurnPorts() {
@@ -776,8 +779,9 @@
kClientIPv6Addr));
EXPECT_TRUE(HasCandidate(ready_candidates, IceCandidateType::kHost, "tcp",
kClientIPv6Addr2));
- EXPECT_TRUE(HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ EXPECT_TRUE(
+ HasCandidate(ready_candidates, IceCandidateType::kRelay, "udp",
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
}
};
@@ -1412,10 +1416,10 @@
// STUN/TURN candidates.
EXPECT_EQ(3U, candidates_.size());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
// Again, two TURN candidates, using UDP/TCP for the first hop to the TURN
// server.
- rtc::SocketAddress addr(kTurnUdpExtAddr.ipaddr(), 0);
+ webrtc::SocketAddress addr(kTurnUdpExtAddr.ipaddr(), 0);
EXPECT_EQ(2, absl::c_count_if(candidates_, [&](const Candidate& c) {
return c.is_relay() && c.protocol() == "udp" &&
AddressMatch(c.address(), addr);
@@ -1441,7 +1445,7 @@
AddInterface(kPrivateAddr);
AddInterface(kPrivateAddr2);
ResetWithStunServerAndNat(kStunAddr);
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
// Enable IPv6 here. Since the network_manager doesn't have IPv6 default
// address set and we have no IPv6 STUN server, there should be no IPv6
@@ -1721,7 +1725,7 @@
TEST_F(BasicPortAllocatorTest, TestCandidateFilterWithRelayOnly) {
AddInterface(kClientAddr);
// GTURN is not configured here.
- ResetWithTurnServersNoNat(kTurnUdpIntAddr, rtc::SocketAddress());
+ ResetWithTurnServersNoNat(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator().SetCandidateFilter(CF_RELAY);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
@@ -1732,14 +1736,14 @@
.clock = &fake_clock}),
webrtc::IsRtcOk());
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
EXPECT_EQ(1U, candidates_.size());
EXPECT_EQ(1U, ports_.size()); // Only Relay port will be in ready state.
EXPECT_TRUE(candidates_[0].is_relay());
EXPECT_EQ(
candidates_[0].related_address(),
- rtc::EmptySocketAddressWithFamily(candidates_[0].address().family()));
+ webrtc::EmptySocketAddressWithFamily(candidates_[0].address().family()));
}
TEST_F(BasicPortAllocatorTest, TestCandidateFilterWithHostOnly) {
@@ -1783,7 +1787,7 @@
EXPECT_TRUE(candidates_[0].is_stun());
EXPECT_EQ(
candidates_[0].related_address(),
- rtc::EmptySocketAddressWithFamily(candidates_[0].address().family()));
+ webrtc::EmptySocketAddressWithFamily(candidates_[0].address().family()));
}
// Host is not behind the NAT.
@@ -1880,7 +1884,7 @@
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
EXPECT_THAT(
webrtc::WaitUntil(
[&] { return candidate_allocation_done_; }, IsTrue(),
@@ -1918,9 +1922,9 @@
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
}
// Test that if the turn port prune policy is PRUNE_BASED_ON_PRIORITY, TCP TURN
@@ -2031,7 +2035,7 @@
// This test relies on a real query for "localhost", so it won't work on an
// IPv6-only machine.
MAYBE_SKIP_IPV4;
- turn_server_.AddInternalSocket(rtc::SocketAddress("127.0.0.1", 3478),
+ turn_server_.AddInternalSocket(webrtc::SocketAddress("127.0.0.1", 3478),
webrtc::PROTO_UDP);
AddInterface(kClientAddr);
allocator_.reset(new BasicPortAllocator(&network_manager_, &socket_factory_));
@@ -2040,7 +2044,7 @@
RelayCredentials credentials(kTurnUsername, kTurnPassword);
turn_server.credentials = credentials;
turn_server.ports.push_back(ProtocolAddress(
- rtc::SocketAddress("localhost", 3478), webrtc::PROTO_UDP));
+ webrtc::SocketAddress("localhost", 3478), webrtc::PROTO_UDP));
allocator_->AddTurnServerForTesting(turn_server);
allocator_->set_step_delay(kMinimumStepDelay);
@@ -2065,7 +2069,7 @@
AddInterface(kClientAddr);
ResetWithStunServerAndNat(kStunAddr);
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ -2085,9 +2089,9 @@
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
EXPECT_THAT(
webrtc::WaitUntil(
[&] { return candidate_allocation_done_; }, IsTrue(),
@@ -2108,7 +2112,7 @@
AddInterface(kClientAddr);
// Use an empty SocketAddress to add a NAT without STUN server.
ResetWithStunServerAndNat(SocketAddress());
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
// Must set the step delay to 0 to make sure the relay allocation phase is
// started before the STUN candidates are obtained, so that the STUN binding
@@ -2133,11 +2137,11 @@
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
Candidate stun_candidate;
EXPECT_TRUE(FindCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
&stun_candidate));
EXPECT_TRUE(HasCandidateWithRelatedAddr(
candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
stun_candidate.address()));
// Local port will be created first and then TURN port.
@@ -2153,8 +2157,8 @@
TEST_F(BasicPortAllocatorTest, TestSharedSocketWithNatUsingTurnTcpOnly) {
turn_server_.AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
AddInterface(kClientAddr);
- ResetWithStunServerAndNat(rtc::SocketAddress());
- AddTurnServers(rtc::SocketAddress(), kTurnTcpIntAddr);
+ ResetWithStunServerAndNat(webrtc::SocketAddress());
+ AddTurnServers(webrtc::SocketAddress(), kTurnTcpIntAddr);
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ -2174,7 +2178,7 @@
EXPECT_TRUE(
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
EXPECT_TRUE(HasCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0)));
EXPECT_EQ(1U, ports_[0]->Candidates().size());
EXPECT_EQ(1U, ports_[1]->Candidates().size());
}
@@ -2188,7 +2192,7 @@
AddInterface(kClientAddr);
// Use an empty SocketAddress to add a NAT without STUN server.
ResetWithStunServerAndNat(SocketAddress());
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() | PORTALLOCATOR_DISABLE_TCP);
@@ -2207,11 +2211,11 @@
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
Candidate stun_candidate;
EXPECT_TRUE(FindCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
&stun_candidate));
Candidate turn_candidate;
EXPECT_TRUE(FindCandidate(candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
&turn_candidate));
// Not using shared socket, so the STUN request's server reflexive address
// should be different than the TURN request's server reflexive address.
@@ -2230,7 +2234,7 @@
// the TURN server actually being used as a STUN server.
ResetWithStunServerAndNat(kStunAddr);
stun_server_.reset();
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ -2249,11 +2253,11 @@
HasCandidate(candidates_, IceCandidateType::kHost, "udp", kClientAddr));
Candidate stun_candidate;
EXPECT_TRUE(FindCandidate(candidates_, IceCandidateType::kSrflx, "udp",
- rtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0),
&stun_candidate));
EXPECT_TRUE(HasCandidateWithRelatedAddr(
candidates_, IceCandidateType::kRelay, "udp",
- rtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
+ webrtc::SocketAddress(kTurnUdpExtAddr.ipaddr(), 0),
stun_candidate.address()));
// Don't bother waiting for STUN timeout, since we already verified
@@ -2482,8 +2486,8 @@
// Expect only relay candidates now that the filter is applied.
EXPECT_TRUE(candidate.is_relay());
// Expect that the raddr is emptied due to the CF_RELAY filter.
- EXPECT_EQ(candidate.related_address(),
- rtc::EmptySocketAddressWithFamily(candidate.address().family()));
+ EXPECT_EQ(candidate.related_address(), webrtc::EmptySocketAddressWithFamily(
+ candidate.address().family()));
}
}
@@ -2498,7 +2502,7 @@
AddInterface(kPrivateAddr);
ResetWithStunServerAndNat(kStunAddr);
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ -2564,7 +2568,7 @@
AddInterface(kPrivateAddr);
ResetWithStunServerAndNat(kStunAddr);
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
@@ -2625,7 +2629,7 @@
AddInterface(kPrivateAddr);
ResetWithStunServerAndNat(kStunAddr);
- AddTurnServers(kTurnUdpIntAddr, rtc::SocketAddress());
+ AddTurnServers(kTurnUdpIntAddr, webrtc::SocketAddress());
allocator_->set_flags(allocator().flags() |
PORTALLOCATOR_ENABLE_SHARED_SOCKET |
diff --git a/p2p/dtls/dtls_ice_integrationtest.cc b/p2p/dtls/dtls_ice_integrationtest.cc
index 78844e0..658ab18 100644
--- a/p2p/dtls/dtls_ice_integrationtest.cc
+++ b/p2p/dtls/dtls_ice_integrationtest.cc
@@ -218,7 +218,7 @@
// Setup the network.
if (network_emulation_manager_ == nullptr) {
- network_manager_.AddInterface(rtc::SocketAddress("192.168.1.1", 0));
+ network_manager_.AddInterface(webrtc::SocketAddress("192.168.1.1", 0));
}
client_thread()->BlockingCall([&]() { client_.allocator->Initialize(); });
@@ -313,7 +313,7 @@
client_dtls_stun_piggyback_ && server_dtls_stun_piggyback_);
// Validate that we can add new Connections (that become writable).
- network_manager_.AddInterface(rtc::SocketAddress("192.168.2.1", 0));
+ network_manager_.AddInterface(webrtc::SocketAddress("192.168.2.1", 0));
EXPECT_THAT(webrtc::WaitUntil(
[&] {
return CountWritableConnections(client_.ice.get()) > 1 &&
diff --git a/p2p/dtls/dtls_transport.cc b/p2p/dtls/dtls_transport.cc
index 87e6a7c..28f3485 100644
--- a/p2p/dtls/dtls_transport.cc
+++ b/p2p/dtls/dtls_transport.cc
@@ -166,7 +166,7 @@
}
piggybacked_dtls_callback_(
this, rtc::ReceivedPacket(piggybacked_dtls_packet,
- rtc::SocketAddress()));
+ webrtc::SocketAddress()));
},
[this]() {
if (!dtls_) {
@@ -820,7 +820,7 @@
// from the original packet here to populate socket address and
// timestamp.
NotifyPacketReceived(rtc::ReceivedPacket(
- rtc::MakeArrayView(buf, read), rtc::SocketAddress(),
+ rtc::MakeArrayView(buf, read), webrtc::SocketAddress(),
webrtc::Timestamp::Micros(rtc::TimeMicros()),
rtc::EcnMarking::kNotEct, rtc::ReceivedPacket::kDtlsDecrypted));
} else if (ret == webrtc::SR_EOS) {
diff --git a/p2p/stunprober/stun_prober.cc b/p2p/stunprober/stun_prober.cc
index 20b55c7..9779990 100644
--- a/p2p/stunprober/stun_prober.cc
+++ b/p2p/stunprober/stun_prober.cc
@@ -65,7 +65,7 @@
int64_t received_time_ms = 0;
// Server reflexive address from STUN response for this given request.
- rtc::SocketAddress srflx_addr;
+ webrtc::SocketAddress srflx_addr;
webrtc::IPAddress server_addr;
@@ -78,7 +78,7 @@
// it'll just be a single address.
Requester(StunProber* prober,
rtc::AsyncPacketSocket* socket,
- const std::vector<rtc::SocketAddress>& server_ips);
+ const std::vector<webrtc::SocketAddress>& server_ips);
~Requester() override;
Requester(const Requester&) = delete;
@@ -108,11 +108,11 @@
std::unique_ptr<rtc::AsyncPacketSocket> socket_;
// Temporary SocketAddress and buffer for RecvFrom.
- rtc::SocketAddress addr_;
+ webrtc::SocketAddress addr_;
std::unique_ptr<rtc::ByteBufferWriter> response_packet_;
std::vector<Request*> requests_;
- std::vector<rtc::SocketAddress> server_ips_;
+ std::vector<webrtc::SocketAddress> server_ips_;
int16_t num_request_sent_ = 0;
int16_t num_response_received_ = 0;
@@ -122,7 +122,7 @@
StunProber::Requester::Requester(
StunProber* prober,
rtc::AsyncPacketSocket* socket,
- const std::vector<rtc::SocketAddress>& server_ips)
+ const std::vector<webrtc::SocketAddress>& server_ips)
: prober_(prober),
socket_(socket),
response_packet_(new rtc::ByteBufferWriter(nullptr, kMaxUdpBufferSize)),
@@ -280,7 +280,7 @@
}
}
-bool StunProber::Start(const std::vector<rtc::SocketAddress>& servers,
+bool StunProber::Start(const std::vector<webrtc::SocketAddress>& servers,
bool shared_socket_mode,
int interval_ms,
int num_request_per_ip,
@@ -291,7 +291,7 @@
timeout_ms, &observer_adapter_);
}
-bool StunProber::Prepare(const std::vector<rtc::SocketAddress>& servers,
+bool StunProber::Prepare(const std::vector<webrtc::SocketAddress>& servers,
bool shared_socket_mode,
int interval_ms,
int num_request_per_ip,
@@ -334,7 +334,7 @@
return true;
}
-bool StunProber::ResolveServerName(const rtc::SocketAddress& addr) {
+bool StunProber::ResolveServerName(const webrtc::SocketAddress& addr) {
RTC_DCHECK(!resolver_);
resolver_ = socket_factory_->CreateAsyncDnsResolver();
if (!resolver_) {
@@ -345,7 +345,7 @@
}
void StunProber::OnSocketReady(rtc::AsyncPacketSocket* socket,
- const rtc::SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
total_ready_sockets_++;
if (total_ready_sockets_ == total_socket_required()) {
ReportOnPrepared(SUCCESS);
@@ -355,10 +355,11 @@
void StunProber::OnServerResolved(
const webrtc::AsyncDnsResolverResult& result) {
RTC_DCHECK(thread_checker_.IsCurrent());
- rtc::SocketAddress received_address;
+ webrtc::SocketAddress received_address;
if (result.GetResolvedAddress(AF_INET, &received_address)) {
// Construct an address without the name in it.
- rtc::SocketAddress addr(received_address.ipaddr(), received_address.port());
+ webrtc::SocketAddress addr(received_address.ipaddr(),
+ received_address.port());
all_servers_addrs_.push_back(addr);
}
resolver_.reset();
@@ -380,15 +381,15 @@
void StunProber::CreateSockets() {
// Dedupe.
- std::set<rtc::SocketAddress> addrs(all_servers_addrs_.begin(),
- all_servers_addrs_.end());
+ std::set<webrtc::SocketAddress> addrs(all_servers_addrs_.begin(),
+ all_servers_addrs_.end());
all_servers_addrs_.assign(addrs.begin(), addrs.end());
// Prepare all the sockets beforehand. All of them will bind to "any" address.
while (sockets_.size() < total_socket_required()) {
std::unique_ptr<rtc::AsyncPacketSocket> socket(
- socket_factory_->CreateUdpSocket(rtc::SocketAddress(INADDR_ANY, 0), 0,
- 0));
+ socket_factory_->CreateUdpSocket(webrtc::SocketAddress(INADDR_ANY, 0),
+ 0, 0));
if (!socket) {
ReportOnPrepared(GENERIC_FAILURE);
return;
@@ -398,7 +399,7 @@
if (socket->GetState() == rtc::AsyncPacketSocket::STATE_BINDING) {
socket->SignalAddressReady.connect(this, &StunProber::OnSocketReady);
} else {
- OnSocketReady(socket.get(), rtc::SocketAddress(INADDR_ANY, 0));
+ OnSocketReady(socket.get(), webrtc::SocketAddress(INADDR_ANY, 0));
}
sockets_.push_back(socket.release());
}
@@ -413,7 +414,7 @@
if (shared_socket_mode_) {
requester = new Requester(this, sockets_.back(), all_servers_addrs_);
} else {
- std::vector<rtc::SocketAddress> server_ip;
+ std::vector<webrtc::SocketAddress> server_ip;
server_ip.push_back(
all_servers_addrs_[(num_request_sent_ % all_servers_addrs_.size())]);
requester = new Requester(this, sockets_.back(), server_ip);
@@ -496,7 +497,7 @@
std::map<webrtc::IPAddress, int> num_request_per_server;
for (auto* requester : requesters_) {
- std::map<rtc::SocketAddress, int> num_response_per_srflx_addr;
+ std::map<webrtc::SocketAddress, int> num_response_per_srflx_addr;
for (auto* request : requester->requests()) {
if (request->sent_time_ms <= 0) {
continue;
@@ -556,7 +557,7 @@
}
// If we could find a local IP matching srflx, we're not behind a NAT.
- rtc::SocketAddress srflx_addr;
+ webrtc::SocketAddress srflx_addr;
if (stats.srflx_addrs.size() &&
!srflx_addr.FromString(*(stats.srflx_addrs.begin()))) {
return false;
diff --git a/p2p/stunprober/stun_prober.h b/p2p/stunprober/stun_prober.h
index e368c31..8f3c96a 100644
--- a/p2p/stunprober/stun_prober.h
+++ b/p2p/stunprober/stun_prober.h
@@ -120,7 +120,7 @@
// non-shared mode, (the number of sockets) equals to requests_per_ip * (the
// number of resolved IP addresses). TODO(guoweis): Remove this once
// everything moved to Prepare() and Run().
- bool Start(const std::vector<rtc::SocketAddress>& servers,
+ bool Start(const std::vector<webrtc::SocketAddress>& servers,
bool shared_socket_mode,
int stun_ta_interval_ms,
int requests_per_ip,
@@ -129,7 +129,7 @@
// TODO(guoweis): The combination of Prepare() and Run() are equivalent to the
// Start() above. Remove Start() once everything is migrated.
- bool Prepare(const std::vector<rtc::SocketAddress>& servers,
+ bool Prepare(const std::vector<webrtc::SocketAddress>& servers,
bool shared_socket_mode,
int stun_ta_interval_ms,
int requests_per_ip,
@@ -169,11 +169,11 @@
AsyncCallback callback_;
};
- bool ResolveServerName(const rtc::SocketAddress& addr);
+ bool ResolveServerName(const webrtc::SocketAddress& addr);
void OnServerResolved(const webrtc::AsyncDnsResolverResult& resolver);
void OnSocketReady(rtc::AsyncPacketSocket* socket,
- const rtc::SocketAddress& addr);
+ const webrtc::SocketAddress& addr);
void CreateSockets();
@@ -220,14 +220,14 @@
int timeout_ms_;
// STUN server name to be resolved.
- std::vector<rtc::SocketAddress> servers_;
+ std::vector<webrtc::SocketAddress> servers_;
// Weak references.
rtc::PacketSocketFactory* socket_factory_;
rtc::Thread* thread_;
// Accumulate all resolved addresses.
- std::vector<rtc::SocketAddress> all_servers_addrs_;
+ std::vector<webrtc::SocketAddress> all_servers_addrs_;
// The set of STUN probe sockets and their state.
std::vector<Requester*> requesters_;
diff --git a/p2p/stunprober/stun_prober_unittest.cc b/p2p/stunprober/stun_prober_unittest.cc
index 0e329d5..2d778e8 100644
--- a/p2p/stunprober/stun_prober_unittest.cc
+++ b/p2p/stunprober/stun_prober_unittest.cc
@@ -36,11 +36,11 @@
namespace {
-const rtc::SocketAddress kLocalAddr("192.168.0.1", 0);
-const rtc::SocketAddress kStunAddr1("1.1.1.1", 3478);
-const rtc::SocketAddress kStunAddr2("1.1.1.2", 3478);
-const rtc::SocketAddress kFailedStunAddr("1.1.1.3", 3478);
-const rtc::SocketAddress kStunMappedAddr("77.77.77.77", 0);
+const webrtc::SocketAddress kLocalAddr("192.168.0.1", 0);
+const webrtc::SocketAddress kStunAddr1("1.1.1.1", 3478);
+const webrtc::SocketAddress kStunAddr2("1.1.1.2", 3478);
+const webrtc::SocketAddress kFailedStunAddr("1.1.1.3", 3478);
+const webrtc::SocketAddress kStunMappedAddr("77.77.77.77", 0);
} // namespace
@@ -70,7 +70,7 @@
}
void StartProbing(rtc::PacketSocketFactory* socket_factory,
- const std::vector<rtc::SocketAddress>& addrs,
+ const std::vector<webrtc::SocketAddress>& addrs,
std::vector<const rtc::Network*> networks,
bool shared_socket,
uint16_t interval,
@@ -84,7 +84,7 @@
}
void RunProber(bool shared_mode) {
- std::vector<rtc::SocketAddress> addrs;
+ std::vector<webrtc::SocketAddress> addrs;
addrs.push_back(kStunAddr1);
addrs.push_back(kStunAddr2);
// Add a non-existing server. This shouldn't pollute the result.
@@ -93,7 +93,7 @@
}
void RunProber(bool shared_mode,
- const std::vector<rtc::SocketAddress>& addrs,
+ const std::vector<webrtc::SocketAddress>& addrs,
bool check_results) {
rtc::Network ipv4_network1("test_eth0", "Test Network Adapter 1",
webrtc::IPAddress(0x12345600U), 24);
@@ -159,20 +159,20 @@
}
TEST_F(StunProberTest, ResolveNonexistentHostname) {
- std::vector<rtc::SocketAddress> addrs;
+ std::vector<webrtc::SocketAddress> addrs;
addrs.push_back(kStunAddr1);
// Add a non-existing server by name. This should cause a failed lookup.
- addrs.push_back(rtc::SocketAddress("nonexistent.test", 3478));
+ addrs.push_back(webrtc::SocketAddress("nonexistent.test", 3478));
RunProber(false, addrs, false);
// One server is pinged
EXPECT_EQ(stats().raw_num_request_sent, pings_per_ip);
}
TEST_F(StunProberTest, ResolveExistingHostname) {
- std::vector<rtc::SocketAddress> addrs;
+ std::vector<webrtc::SocketAddress> addrs;
addrs.push_back(kStunAddr1);
// Add a non-existing server by name. This should cause a failed lookup.
- addrs.push_back(rtc::SocketAddress("localhost", 3478));
+ addrs.push_back(webrtc::SocketAddress("localhost", 3478));
RunProber(false, addrs, false);
// Two servers are pinged, only one responds.
// TODO(bugs.webrtc.org/15559): Figure out why this doesn't always work
diff --git a/p2p/test/fake_packet_transport.h b/p2p/test/fake_packet_transport.h
index c6f7bc0..b9162ee 100644
--- a/p2p/test/fake_packet_transport.h
+++ b/p2p/test/fake_packet_transport.h
@@ -127,7 +127,8 @@
last_sent_packet_ = packet;
if (dest_) {
dest_->NotifyPacketReceived(rtc::ReceivedPacket(
- packet, SocketAddress(), webrtc::Timestamp::Micros(rtc::TimeMicros()),
+ packet, webrtc::SocketAddress(),
+ webrtc::Timestamp::Micros(rtc::TimeMicros()),
options.ecn_1 ? EcnMarking::kEct1 : EcnMarking::kNotEct));
}
}
diff --git a/p2p/test/nat_server.cc b/p2p/test/nat_server.cc
index 7413446..c9e6f87 100644
--- a/p2p/test/nat_server.cc
+++ b/p2p/test/nat_server.cc
@@ -49,7 +49,7 @@
AddrCmp::AddrCmp(NAT* nat)
: use_ip(nat->FiltersIP()), use_port(nat->FiltersPort()) {}
-size_t AddrCmp::operator()(const SocketAddress& a) const {
+size_t AddrCmp::operator()(const webrtc::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 SocketAddress& a1,
- const SocketAddress& a2) const {
+bool AddrCmp::operator()(const webrtc::SocketAddress& a1,
+ const webrtc::SocketAddress& a2) const {
if (use_ip && (a1.ipaddr() < a2.ipaddr()))
return true;
if (use_ip && (a2.ipaddr() < a1.ipaddr()))
@@ -80,7 +80,7 @@
BufferInput(true);
}
- void SendConnectResult(int err, const SocketAddress& addr) override {
+ void SendConnectResult(int err, const webrtc::SocketAddress& addr) override {
char code = err ? 1 : 0;
BufferedReadAdapter::DirectSend(&code, sizeof(char));
}
@@ -98,7 +98,7 @@
return;
}
- SocketAddress dest_addr;
+ webrtc::SocketAddress dest_addr;
size_t address_length = UnpackAddressFromNAT(
MakeArrayView(reinterpret_cast<const uint8_t*>(data), *len),
&dest_addr);
@@ -119,9 +119,9 @@
class NATProxyServer : public ProxyServer {
public:
NATProxyServer(SocketFactory* int_factory,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip)
+ const webrtc::SocketAddress& ext_ip)
: ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected:
@@ -133,11 +133,11 @@
NATServer::NATServer(NATType type,
rtc::Thread& internal_socket_thread,
SocketFactory* internal,
- const SocketAddress& internal_udp_addr,
- const SocketAddress& internal_tcp_addr,
+ const webrtc::SocketAddress& internal_udp_addr,
+ const webrtc::SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
SocketFactory* external,
- const SocketAddress& external_ip)
+ const webrtc::SocketAddress& external_ip)
: internal_socket_thread_(internal_socket_thread),
external_socket_thread_(external_socket_thread),
external_(external),
@@ -175,7 +175,7 @@
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(internal_socket_thread_.IsCurrent());
// Read the intended destination from the wire.
- SocketAddress dest_addr;
+ webrtc::SocketAddress dest_addr;
size_t length = UnpackAddressFromNAT(packet.payload(), &dest_addr);
// Find the translation for these addresses (allocating one if necessary).
@@ -200,7 +200,7 @@
void NATServer::OnExternalUDPPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(external_socket_thread_.IsCurrent());
- SocketAddress local_addr = socket->GetLocalAddress();
+ webrtc::SocketAddress local_addr = socket->GetLocalAddress();
// Find the translation for this addresses.
ExternalMap::iterator iter = ext_map_->find(local_addr);
@@ -250,7 +250,7 @@
}
bool NATServer::ShouldFilterOut(TransEntry* entry,
- const SocketAddress& ext_addr) {
+ const webrtc::SocketAddress& ext_addr) {
return entry->AllowlistContains(ext_addr);
}
@@ -266,12 +266,13 @@
delete socket;
}
-void NATServer::TransEntry::AllowlistInsert(const SocketAddress& addr) {
+void NATServer::TransEntry::AllowlistInsert(const webrtc::SocketAddress& addr) {
webrtc::MutexLock lock(&mutex_);
allowlist->insert(addr);
}
-bool NATServer::TransEntry::AllowlistContains(const SocketAddress& ext_addr) {
+bool NATServer::TransEntry::AllowlistContains(
+ const webrtc::SocketAddress& ext_addr) {
webrtc::MutexLock lock(&mutex_);
return allowlist->find(ext_addr) == allowlist->end();
}
diff --git a/p2p/test/nat_server.h b/p2p/test/nat_server.h
index fa620cb..ecdd70a 100644
--- a/p2p/test/nat_server.h
+++ b/p2p/test/nat_server.h
@@ -39,8 +39,9 @@
// Changes how addresses are compared based on the filtering rules of the NAT.
struct AddrCmp {
explicit AddrCmp(NAT* nat);
- size_t operator()(const SocketAddress& r) const;
- bool operator()(const SocketAddress& r1, const SocketAddress& r2) const;
+ size_t operator()(const webrtc::SocketAddress& r) const;
+ bool operator()(const webrtc::SocketAddress& r1,
+ const webrtc::SocketAddress& r2) const;
bool use_ip;
bool use_port;
@@ -63,21 +64,21 @@
NATServer(NATType type,
rtc::Thread& internal_socket_thread,
SocketFactory* internal,
- const SocketAddress& internal_udp_addr,
- const SocketAddress& internal_tcp_addr,
+ const webrtc::SocketAddress& internal_udp_addr,
+ const webrtc::SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
SocketFactory* external,
- const SocketAddress& external_ip);
+ const webrtc::SocketAddress& external_ip);
~NATServer();
NATServer(const NATServer&) = delete;
NATServer& operator=(const NATServer&) = delete;
- SocketAddress internal_udp_address() const {
+ webrtc::SocketAddress internal_udp_address() const {
return udp_server_socket_->GetLocalAddress();
}
- SocketAddress internal_tcp_address() const {
+ webrtc::SocketAddress internal_tcp_address() const {
return tcp_proxy_server_->GetServerAddress();
}
@@ -88,15 +89,15 @@
const rtc::ReceivedPacket& packet);
private:
- typedef std::set<SocketAddress, AddrCmp> AddressSet;
+ typedef std::set<webrtc::SocketAddress, AddrCmp> AddressSet;
/* Records a translation and the associated external socket. */
struct TransEntry {
TransEntry(const webrtc::SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat);
~TransEntry();
- void AllowlistInsert(const SocketAddress& addr);
- bool AllowlistContains(const SocketAddress& ext_addr);
+ void AllowlistInsert(const webrtc::SocketAddress& addr);
+ bool AllowlistContains(const webrtc::SocketAddress& ext_addr);
webrtc::SocketAddressPair route;
AsyncUDPSocket* socket;
@@ -106,19 +107,20 @@
typedef std::map<webrtc::SocketAddressPair, TransEntry*, RouteCmp>
InternalMap;
- typedef std::map<SocketAddress, TransEntry*> ExternalMap;
+ typedef std::map<webrtc::SocketAddress, TransEntry*> ExternalMap;
/* Creates a new entry that translates the given route. */
void Translate(const webrtc::SocketAddressPair& route);
/* Determines whether the NAT would filter out a packet from this address. */
- bool ShouldFilterOut(TransEntry* entry, const SocketAddress& ext_addr);
+ bool ShouldFilterOut(TransEntry* entry,
+ const webrtc::SocketAddress& ext_addr);
NAT* nat_;
rtc::Thread& internal_socket_thread_;
rtc::Thread& external_socket_thread_;
SocketFactory* external_;
- SocketAddress external_ip_;
+ webrtc::SocketAddress external_ip_;
AsyncUDPSocket* udp_server_socket_;
ProxyServer* tcp_proxy_server_;
InternalMap* int_map_;
diff --git a/p2p/test/nat_socket_factory.cc b/p2p/test/nat_socket_factory.cc
index 879f0eb..21f55ae 100644
--- a/p2p/test/nat_socket_factory.cc
+++ b/p2p/test/nat_socket_factory.cc
@@ -25,7 +25,7 @@
// Returns 0 if an invalid address is passed.
size_t PackAddressForNAT(char* buf,
size_t buf_size,
- const SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
const webrtc::IPAddress& ip = remote_addr.ipaddr();
int family = ip.family();
buf[0] = 0;
@@ -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,
- SocketAddress* remote_addr) {
+ webrtc::SocketAddress* remote_addr) {
RTC_CHECK(buf.size() >= 8);
RTC_DCHECK(buf.data()[0] == 0);
int family = buf[1];
@@ -59,12 +59,12 @@
*(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 = SocketAddress(webrtc::IPAddress(*v4addr), port);
+ *remote_addr = webrtc::SocketAddress(webrtc::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 = SocketAddress(webrtc::IPAddress(*v6addr), port);
+ *remote_addr = webrtc::SocketAddress(webrtc::IPAddress(*v6addr), port);
return kNATEncodedIPv6AddressSize;
}
return 0U;
@@ -82,15 +82,15 @@
~NATSocket() override { delete socket_; }
- SocketAddress GetLocalAddress() const override {
- return (socket_) ? socket_->GetLocalAddress() : SocketAddress();
+ webrtc::SocketAddress GetLocalAddress() const override {
+ return (socket_) ? socket_->GetLocalAddress() : webrtc::SocketAddress();
}
- SocketAddress GetRemoteAddress() const override {
+ webrtc::SocketAddress GetRemoteAddress() const override {
return remote_addr_; // will be NIL if not connected
}
- int Bind(const SocketAddress& addr) override {
+ int Bind(const webrtc::SocketAddress& addr) override {
if (socket_) { // already bound, bubble up error
return -1;
}
@@ -98,12 +98,13 @@
return BindInternal(addr);
}
- int Connect(const SocketAddress& addr) override {
+ int Connect(const webrtc::SocketAddress& addr) override {
int result = 0;
// If we're not already bound (meaning `socket_` is null), bind to ANY
// address.
if (!socket_) {
- result = BindInternal(SocketAddress(webrtc::GetAnyIP(family_), 0));
+ result =
+ BindInternal(webrtc::SocketAddress(webrtc::GetAnyIP(family_), 0));
if (result < 0) {
return result;
}
@@ -129,7 +130,7 @@
int SendTo(const void* data,
size_t size,
- const SocketAddress& addr) override {
+ const webrtc::SocketAddress& addr) override {
RTC_DCHECK(!connected_ || addr == remote_addr_);
if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
return socket_->SendTo(data, size, addr);
@@ -149,13 +150,13 @@
}
int Recv(void* data, size_t size, int64_t* timestamp) override {
- SocketAddress addr;
+ webrtc::SocketAddress addr;
return RecvFrom(data, size, &addr, timestamp);
}
int RecvFrom(void* data,
size_t size,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp) override {
if (server_addr_.IsNil() || type_ == SOCK_STREAM) {
return socket_->RecvFrom(data, size, out_addr, timestamp);
@@ -174,7 +175,7 @@
.us();
// Decode the wire packet into the actual results.
- SocketAddress real_remote_addr;
+ webrtc::SocketAddress real_remote_addr;
size_t addrlength = UnpackAddressFromNAT(buf_, &real_remote_addr);
memcpy(data, buf_.data() + addrlength, result - addrlength);
@@ -199,7 +200,7 @@
result = socket_->Close();
if (result >= 0) {
connected_ = false;
- remote_addr_ = SocketAddress();
+ remote_addr_ = webrtc::SocketAddress();
delete socket_;
socket_ = nullptr;
}
@@ -208,7 +209,7 @@
}
int Listen(int backlog) override { return socket_->Listen(backlog); }
- Socket* Accept(SocketAddress* paddr) override {
+ Socket* Accept(webrtc::SocketAddress* paddr) override {
return socket_->Accept(paddr);
}
int GetError() const override {
@@ -260,7 +261,7 @@
}
private:
- int BindInternal(const SocketAddress& addr) {
+ int BindInternal(const webrtc::SocketAddress& addr) {
RTC_DCHECK(!socket_);
int result;
@@ -304,8 +305,8 @@
int family_;
int type_;
bool connected_;
- SocketAddress remote_addr_;
- SocketAddress server_addr_; // address of the NAT server
+ webrtc::SocketAddress remote_addr_;
+ webrtc::SocketAddress server_addr_; // address of the NAT server
Socket* socket_;
// Need to hold error in case it occurs before the socket is created.
int error_ = 0;
@@ -314,8 +315,8 @@
// NATSocketFactory
NATSocketFactory::NATSocketFactory(SocketFactory* factory,
- const SocketAddress& nat_udp_addr,
- const SocketAddress& nat_tcp_addr)
+ const webrtc::SocketAddress& nat_udp_addr,
+ const webrtc::SocketAddress& nat_tcp_addr)
: factory_(factory),
nat_udp_addr_(nat_udp_addr),
nat_tcp_addr_(nat_tcp_addr) {}
@@ -324,10 +325,11 @@
return new NATSocket(this, family, type);
}
-Socket* NATSocketFactory::CreateInternalSocket(int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) {
+Socket* NATSocketFactory::CreateInternalSocket(
+ int family,
+ int type,
+ const webrtc::SocketAddress& local_addr,
+ webrtc::SocketAddress* nat_addr) {
if (type == SOCK_STREAM) {
*nat_addr = nat_tcp_addr_;
} else {
@@ -341,13 +343,13 @@
: server_(server), msg_queue_(nullptr) {}
NATSocketServer::Translator* NATSocketServer::GetTranslator(
- const SocketAddress& ext_ip) {
+ const webrtc::SocketAddress& ext_ip) {
return nats_.Get(ext_ip);
}
NATSocketServer::Translator* NATSocketServer::AddTranslator(
- const SocketAddress& ext_ip,
- const SocketAddress& int_ip,
+ const webrtc::SocketAddress& ext_ip,
+ const webrtc::SocketAddress& int_ip,
NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
@@ -357,7 +359,7 @@
ext_ip, new Translator(this, type, int_ip, *msg_queue_, server_, ext_ip));
}
-void NATSocketServer::RemoveTranslator(const SocketAddress& ext_ip) {
+void NATSocketServer::RemoveTranslator(const webrtc::SocketAddress& ext_ip) {
nats_.Remove(ext_ip);
}
@@ -379,10 +381,11 @@
server_->WakeUp();
}
-Socket* NATSocketServer::CreateInternalSocket(int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) {
+Socket* NATSocketServer::CreateInternalSocket(
+ int family,
+ int type,
+ const webrtc::SocketAddress& local_addr,
+ webrtc::SocketAddress* nat_addr) {
Socket* socket = nullptr;
Translator* nat = nats_.FindClient(local_addr);
if (nat) {
@@ -398,10 +401,10 @@
// NATSocketServer::Translator
NATSocketServer::Translator::Translator(NATSocketServer* server,
NATType type,
- const SocketAddress& int_ip,
+ const webrtc::SocketAddress& int_ip,
Thread& external_socket_thread,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip)
+ const webrtc::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
@@ -418,13 +421,13 @@
}
NATSocketServer::Translator* NATSocketServer::Translator::GetTranslator(
- const SocketAddress& ext_ip) {
+ const webrtc::SocketAddress& ext_ip) {
return nats_.Get(ext_ip);
}
NATSocketServer::Translator* NATSocketServer::Translator::AddTranslator(
- const SocketAddress& ext_ip,
- const SocketAddress& int_ip,
+ const webrtc::SocketAddress& ext_ip,
+ const webrtc::SocketAddress& int_ip,
NATType type) {
// Fail if a translator already exists with this extternal address.
if (nats_.Get(ext_ip))
@@ -435,12 +438,13 @@
*server_->queue(), server_, ext_ip));
}
void NATSocketServer::Translator::RemoveTranslator(
- const SocketAddress& ext_ip) {
+ const webrtc::SocketAddress& ext_ip) {
nats_.Remove(ext_ip);
RemoveClient(ext_ip);
}
-bool NATSocketServer::Translator::AddClient(const SocketAddress& int_ip) {
+bool NATSocketServer::Translator::AddClient(
+ const webrtc::SocketAddress& int_ip) {
// Fail if a client already exists with this internal address.
if (clients_.find(int_ip) != clients_.end())
return false;
@@ -449,15 +453,16 @@
return true;
}
-void NATSocketServer::Translator::RemoveClient(const SocketAddress& int_ip) {
- std::set<SocketAddress>::iterator it = clients_.find(int_ip);
+void NATSocketServer::Translator::RemoveClient(
+ const webrtc::SocketAddress& int_ip) {
+ std::set<webrtc::SocketAddress>::iterator it = clients_.find(int_ip);
if (it != clients_.end()) {
clients_.erase(it);
}
}
NATSocketServer::Translator* NATSocketServer::Translator::FindClient(
- const SocketAddress& int_ip) {
+ const webrtc::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);
@@ -471,19 +476,20 @@
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Get(
- const SocketAddress& ext_ip) {
+ const webrtc::SocketAddress& ext_ip) {
TranslatorMap::iterator it = find(ext_ip);
return (it != end()) ? it->second : nullptr;
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::Add(
- const SocketAddress& ext_ip,
+ const webrtc::SocketAddress& ext_ip,
Translator* nat) {
(*this)[ext_ip] = nat;
return nat;
}
-void NATSocketServer::TranslatorMap::Remove(const SocketAddress& ext_ip) {
+void NATSocketServer::TranslatorMap::Remove(
+ const webrtc::SocketAddress& ext_ip) {
TranslatorMap::iterator it = find(ext_ip);
if (it != end()) {
delete it->second;
@@ -492,7 +498,7 @@
}
NATSocketServer::Translator* NATSocketServer::TranslatorMap::FindClient(
- const SocketAddress& int_ip) {
+ const webrtc::SocketAddress& int_ip) {
Translator* nat = nullptr;
for (TranslatorMap::iterator it = begin(); it != end() && !nat; ++it) {
nat = it->second->FindClient(int_ip);
diff --git a/p2p/test/nat_socket_factory.h b/p2p/test/nat_socket_factory.h
index 9425dc3..f46c76e 100644
--- a/p2p/test/nat_socket_factory.h
+++ b/p2p/test/nat_socket_factory.h
@@ -39,8 +39,8 @@
virtual ~NATInternalSocketFactory() {}
virtual Socket* CreateInternalSocket(int family,
int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) = 0;
+ const webrtc::SocketAddress& local_addr,
+ webrtc::SocketAddress* nat_addr) = 0;
};
// Creates sockets that will send all traffic through a NAT, using an existing
@@ -49,8 +49,8 @@
class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
public:
NATSocketFactory(SocketFactory* factory,
- const SocketAddress& nat_udp_addr,
- const SocketAddress& nat_tcp_addr);
+ const webrtc::SocketAddress& nat_udp_addr,
+ const webrtc::SocketAddress& nat_tcp_addr);
NATSocketFactory(const NATSocketFactory&) = delete;
NATSocketFactory& operator=(const NATSocketFactory&) = delete;
@@ -61,13 +61,13 @@
// NATInternalSocketFactory implementation
Socket* CreateInternalSocket(int family,
int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) override;
+ const webrtc::SocketAddress& local_addr,
+ webrtc::SocketAddress* nat_addr) override;
private:
SocketFactory* factory_;
- SocketAddress nat_udp_addr_;
- SocketAddress nat_tcp_addr_;
+ webrtc::SocketAddress nat_udp_addr_;
+ webrtc::SocketAddress nat_tcp_addr_;
};
// Creates sockets that will send traffic through a NAT depending on what
@@ -90,13 +90,13 @@
class Translator;
// holds a list of NATs
- class TranslatorMap : private std::map<SocketAddress, Translator*> {
+ class TranslatorMap : private std::map<webrtc::SocketAddress, Translator*> {
public:
~TranslatorMap();
- 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);
+ 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);
};
// a specific NAT
@@ -104,38 +104,38 @@
public:
Translator(NATSocketServer* server,
NATType type,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
Thread& external_socket_thread,
SocketFactory* ext_factory,
- const SocketAddress& ext_addr);
+ const webrtc::SocketAddress& ext_addr);
~Translator();
SocketFactory* internal_factory() { return internal_server_.get(); }
- SocketAddress internal_udp_address() const {
+ webrtc::SocketAddress internal_udp_address() const {
return nat_server_->internal_udp_address();
}
- SocketAddress internal_tcp_address() const {
- return SocketAddress(); // nat_server_->internal_tcp_address();
+ webrtc::SocketAddress internal_tcp_address() const {
+ return webrtc::SocketAddress(); // nat_server_->internal_tcp_address();
}
- Translator* GetTranslator(const SocketAddress& ext_ip);
- Translator* AddTranslator(const SocketAddress& ext_ip,
- const SocketAddress& int_ip,
+ Translator* GetTranslator(const webrtc::SocketAddress& ext_ip);
+ Translator* AddTranslator(const webrtc::SocketAddress& ext_ip,
+ const webrtc::SocketAddress& int_ip,
NATType type);
- void RemoveTranslator(const SocketAddress& ext_ip);
+ void RemoveTranslator(const webrtc::SocketAddress& ext_ip);
- bool AddClient(const SocketAddress& int_ip);
- void RemoveClient(const SocketAddress& int_ip);
+ bool AddClient(const webrtc::SocketAddress& int_ip);
+ void RemoveClient(const webrtc::SocketAddress& int_ip);
// Looks for the specified client in this or a child NAT.
- Translator* FindClient(const SocketAddress& int_ip);
+ Translator* FindClient(const webrtc::SocketAddress& int_ip);
private:
NATSocketServer* server_;
std::unique_ptr<SocketServer> internal_server_;
std::unique_ptr<NATServer> nat_server_;
TranslatorMap nats_;
- std::set<SocketAddress> clients_;
+ std::set<webrtc::SocketAddress> clients_;
};
explicit NATSocketServer(SocketServer* ss);
@@ -146,11 +146,11 @@
SocketServer* socketserver() { return server_; }
Thread* queue() { return msg_queue_; }
- Translator* GetTranslator(const SocketAddress& ext_ip);
- Translator* AddTranslator(const SocketAddress& ext_ip,
- const SocketAddress& int_ip,
+ Translator* GetTranslator(const webrtc::SocketAddress& ext_ip);
+ Translator* AddTranslator(const webrtc::SocketAddress& ext_ip,
+ const webrtc::SocketAddress& int_ip,
NATType type);
- void RemoveTranslator(const SocketAddress& ext_ip);
+ void RemoveTranslator(const webrtc::SocketAddress& ext_ip);
// SocketServer implementation
Socket* CreateSocket(int family, int type) override;
@@ -162,8 +162,8 @@
// NATInternalSocketFactory implementation
Socket* CreateInternalSocket(int family,
int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) override;
+ const webrtc::SocketAddress& local_addr,
+ webrtc::SocketAddress* nat_addr) override;
private:
SocketServer* server_;
@@ -174,9 +174,9 @@
// Free-standing NAT helper functions.
size_t PackAddressForNAT(char* buf,
size_t buf_size,
- const SocketAddress& remote_addr);
+ const webrtc::SocketAddress& remote_addr);
size_t UnpackAddressFromNAT(rtc::ArrayView<const uint8_t> buf,
- SocketAddress* remote_addr);
+ webrtc::SocketAddress* remote_addr);
} // namespace rtc
#endif // P2P_TEST_NAT_SOCKET_FACTORY_H_
diff --git a/p2p/test/nat_unittest.cc b/p2p/test/nat_unittest.cc
index ce24577..e39620f 100644
--- a/p2p/test/nat_unittest.cc
+++ b/p2p/test/nat_unittest.cc
@@ -54,7 +54,7 @@
}
webrtc::TestClient* CreateTestClient(SocketFactory* factory,
- const SocketAddress& local_addr) {
+ const webrtc::SocketAddress& local_addr) {
return new webrtc::TestClient(
absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
}
@@ -67,9 +67,9 @@
// NAT type specified by nat_type, all external addrs receive the sent packet
// and, if exp_same is true, all use the same mapped-address on the NAT.
void TestSend(SocketServer* internal,
- const SocketAddress& internal_addr,
+ const webrtc::SocketAddress& internal_addr,
SocketServer* external,
- const SocketAddress external_addrs[4],
+ const webrtc::SocketAddress external_addrs[4],
NATType nat_type,
bool exp_same) {
Thread th_int(internal);
@@ -78,7 +78,7 @@
th_int.Start();
th_ext.Start();
- SocketAddress server_addr = internal_addr;
+ 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,
@@ -99,13 +99,13 @@
size_t len = strlen(buf);
th_int.BlockingCall([&] { in->SendTo(buf, len, out[0]->address()); });
- SocketAddress trans_addr;
+ webrtc::SocketAddress trans_addr;
th_ext.BlockingCall(
[&] { EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr)); });
for (int i = 1; i < 4; i++) {
th_int.BlockingCall([&] { in->SendTo(buf, len, out[i]->address()); });
- SocketAddress trans_addr2;
+ webrtc::SocketAddress trans_addr2;
th_ext.BlockingCall([&] {
EXPECT_TRUE(out[i]->CheckNextPacket(buf, len, &trans_addr2));
bool are_same = (trans_addr == trans_addr2);
@@ -128,16 +128,16 @@
// Tests that when sending from external_addrs to internal_addr, the packet
// is delivered according to the specified filter_ip and filter_port rules.
void TestRecv(SocketServer* internal,
- const SocketAddress& internal_addr,
+ const webrtc::SocketAddress& internal_addr,
SocketServer* external,
- const SocketAddress external_addrs[4],
+ const webrtc::SocketAddress external_addrs[4],
NATType nat_type,
bool filter_ip,
bool filter_port) {
Thread th_int(internal);
Thread th_ext(external);
- SocketAddress server_addr = internal_addr;
+ webrtc::SocketAddress server_addr = internal_addr;
server_addr.SetPort(0); // Auto-select a port
th_int.Start();
th_ext.Start();
@@ -160,7 +160,7 @@
size_t len = strlen(buf);
th_int.BlockingCall([&] { in->SendTo(buf, len, out[0]->address()); });
- SocketAddress trans_addr;
+ webrtc::SocketAddress trans_addr;
th_ext.BlockingCall(
[&] { EXPECT_TRUE(out[0]->CheckNextPacket(buf, len, &trans_addr)); });
@@ -190,9 +190,9 @@
// Tests that NATServer allocates bindings properly.
void TestBindings(SocketServer* internal,
- const SocketAddress& internal_addr,
+ const webrtc::SocketAddress& internal_addr,
SocketServer* external,
- const SocketAddress external_addrs[4]) {
+ const webrtc::SocketAddress external_addrs[4]) {
TestSend(internal, internal_addr, external, external_addrs, NAT_OPEN_CONE,
true);
TestSend(internal, internal_addr, external, external_addrs,
@@ -205,9 +205,9 @@
// Tests that NATServer filters packets properly.
void TestFilters(SocketServer* internal,
- const SocketAddress& internal_addr,
+ const webrtc::SocketAddress& internal_addr,
SocketServer* external,
- const SocketAddress external_addrs[4]) {
+ 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,
@@ -218,15 +218,16 @@
true, true);
}
-bool TestConnectivity(const SocketAddress& src, const webrtc::IPAddress& dst) {
+bool TestConnectivity(const webrtc::SocketAddress& src,
+ const webrtc::IPAddress& dst) {
// The physical NAT tests require connectivity to the selected ip from the
// internal address used for the NAT. Things like firewalls can break that, so
// check to see if it's worth even trying with this ip.
std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
std::unique_ptr<Socket> client(pss->CreateSocket(src.family(), SOCK_DGRAM));
std::unique_ptr<Socket> server(pss->CreateSocket(src.family(), SOCK_DGRAM));
- if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
- server->Bind(SocketAddress(dst, 0)) != 0) {
+ if (client->Bind(webrtc::SocketAddress(src.ipaddr(), 0)) != 0 ||
+ server->Bind(webrtc::SocketAddress(dst, 0)) != 0) {
return false;
}
const char* buf = "hello other socket";
@@ -240,7 +241,7 @@
return received == sent && ::memcmp(buf, payload.data(), len) == 0;
}
-void TestPhysicalInternal(const SocketAddress& int_addr) {
+void TestPhysicalInternal(const webrtc::SocketAddress& int_addr) {
webrtc::test::ScopedKeyValueConfig field_trials;
rtc::AutoThread main_thread;
PhysicalSocketServer socket_server;
@@ -261,8 +262,8 @@
return;
}
- SocketAddress ext_addr1(int_addr);
- SocketAddress ext_addr2;
+ webrtc::SocketAddress ext_addr1(int_addr);
+ webrtc::SocketAddress ext_addr2;
// Find an available IP with matching family. The test breaks if int_addr
// can't talk to ip, so check for connectivity as well.
for (const Network* const network : networks) {
@@ -280,9 +281,9 @@
RTC_LOG(LS_INFO) << "selected ip " << ext_addr2.ipaddr().ToString();
- SocketAddress ext_addrs[4] = {
- SocketAddress(ext_addr1), SocketAddress(ext_addr2),
- SocketAddress(ext_addr1), SocketAddress(ext_addr2)};
+ webrtc::SocketAddress ext_addrs[4] = {
+ webrtc::SocketAddress(ext_addr1), webrtc::SocketAddress(ext_addr2),
+ webrtc::SocketAddress(ext_addr1), webrtc::SocketAddress(ext_addr2)};
std::unique_ptr<PhysicalSocketServer> int_pss(new PhysicalSocketServer());
std::unique_ptr<PhysicalSocketServer> ext_pss(new PhysicalSocketServer());
@@ -292,12 +293,12 @@
}
TEST(NatTest, TestPhysicalIPv4) {
- TestPhysicalInternal(SocketAddress("127.0.0.1", 0));
+ TestPhysicalInternal(webrtc::SocketAddress("127.0.0.1", 0));
}
TEST(NatTest, TestPhysicalIPv6) {
if (HasIPv6Enabled()) {
- TestPhysicalInternal(SocketAddress("::1", 0));
+ TestPhysicalInternal(webrtc::SocketAddress("::1", 0));
} else {
RTC_LOG(LS_WARNING) << "No IPv6, skipping";
}
@@ -322,8 +323,8 @@
std::unique_ptr<TestVirtualSocketServer> ext_vss(
new TestVirtualSocketServer());
- SocketAddress int_addr;
- SocketAddress ext_addrs[4];
+ webrtc::SocketAddress int_addr;
+ webrtc::SocketAddress ext_addrs[4];
int_addr.SetIP(int_vss->GetNextIP(family));
ext_addrs[0].SetIP(ext_vss->GetNextIP(int_addr.family()));
ext_addrs[1].SetIP(ext_vss->GetNextIP(int_addr.family()));
@@ -384,8 +385,8 @@
client_->SignalConnectEvent.connect(this, &NatTcpTest::OnConnectEvent);
}
- SocketAddress int_addr_;
- SocketAddress ext_addr_;
+ webrtc::SocketAddress int_addr_;
+ webrtc::SocketAddress ext_addr_;
bool connected_;
std::unique_ptr<TestVirtualSocketServer> int_vss_;
std::unique_ptr<TestVirtualSocketServer> ext_vss_;
@@ -424,7 +425,7 @@
size_t len = strlen(buf);
in->Send(buf, len);
- SocketAddress trans_addr;
+ webrtc::SocketAddress trans_addr;
EXPECT_TRUE(out->CheckNextPacket(buf, len, &trans_addr));
out->Send(buf, len);
diff --git a/p2p/test/stun_server.cc b/p2p/test/stun_server.cc
index 5ef725b..60ec70f 100644
--- a/p2p/test/stun_server.cc
+++ b/p2p/test/stun_server.cc
@@ -61,14 +61,14 @@
}
void StunServer::OnBindingRequest(StunMessage* msg,
- const rtc::SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
StunMessage response(STUN_BINDING_RESPONSE, msg->transaction_id());
GetStunBindResponse(msg, remote_addr, &response);
SendResponse(response, remote_addr);
}
void StunServer::SendErrorResponse(const StunMessage& msg,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view error_desc) {
StunMessage err_msg(GetStunErrorResponseType(msg.type()),
@@ -83,7 +83,7 @@
}
void StunServer::SendResponse(const StunMessage& msg,
- const rtc::SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
rtc::ByteBufferWriter buf;
msg.Write(&buf);
rtc::PacketOptions options;
@@ -92,7 +92,7 @@
}
void StunServer::GetStunBindResponse(StunMessage* message,
- const rtc::SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
StunMessage* response) const {
RTC_DCHECK_EQ(response->type(), STUN_BINDING_RESPONSE);
RTC_DCHECK_EQ(response->transaction_id(), message->transaction_id());
diff --git a/p2p/test/stun_server.h b/p2p/test/stun_server.h
index c89c933..4e63388 100644
--- a/p2p/test/stun_server.h
+++ b/p2p/test/stun_server.h
@@ -39,23 +39,24 @@
// Handlers for the different types of STUN/TURN requests:
virtual void OnBindingRequest(StunMessage* msg,
- const rtc::SocketAddress& addr);
- void OnAllocateRequest(StunMessage* msg, const rtc::SocketAddress& addr);
- void OnSharedSecretRequest(StunMessage* msg, const rtc::SocketAddress& addr);
- void OnSendRequest(StunMessage* msg, const rtc::SocketAddress& addr);
+ 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);
// Sends an error response to the given message back to the user.
void SendErrorResponse(const StunMessage& msg,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
int error_code,
absl::string_view error_desc);
// Sends the given message to the appropriate destination.
- void SendResponse(const StunMessage& msg, const rtc::SocketAddress& addr);
+ void SendResponse(const StunMessage& msg, const webrtc::SocketAddress& addr);
// A helper method to compose a STUN binding response.
void GetStunBindResponse(StunMessage* message,
- const rtc::SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
StunMessage* response) const;
private:
diff --git a/p2p/test/stun_server_unittest.cc b/p2p/test/stun_server_unittest.cc
index db07bdf..74bdd35 100644
--- a/p2p/test/stun_server_unittest.cc
+++ b/p2p/test/stun_server_unittest.cc
@@ -27,8 +27,8 @@
namespace cricket {
namespace {
-const rtc::SocketAddress server_addr("99.99.99.1", 3478);
-const rtc::SocketAddress client_addr("1.2.3.4", 1234);
+const webrtc::SocketAddress server_addr("99.99.99.1", 3478);
+const webrtc::SocketAddress client_addr("1.2.3.4", 1234);
} // namespace
class StunServerTest : public ::testing::Test {
diff --git a/p2p/test/test_stun_server.cc b/p2p/test/test_stun_server.cc
index 3812d38..2a835e3 100644
--- a/p2p/test/test_stun_server.cc
+++ b/p2p/test/test_stun_server.cc
@@ -19,7 +19,7 @@
std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>>
TestStunServer::Create(rtc::SocketServer* ss,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
rtc::Thread& network_thread) {
rtc::Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM);
RTC_CHECK(socket != nullptr) << "Failed to create socket";
@@ -35,8 +35,9 @@
return result;
}
-void TestStunServer::OnBindingRequest(StunMessage* msg,
- const rtc::SocketAddress& remote_addr) {
+void TestStunServer::OnBindingRequest(
+ StunMessage* msg,
+ const webrtc::SocketAddress& remote_addr) {
RTC_DCHECK_RUN_ON(&network_thread_);
if (fake_stun_addr_.IsNil()) {
StunServer::OnBindingRequest(msg, remote_addr);
diff --git a/p2p/test/test_stun_server.h b/p2p/test/test_stun_server.h
index de98ed7..f90958a 100644
--- a/p2p/test/test_stun_server.h
+++ b/p2p/test/test_stun_server.h
@@ -28,11 +28,11 @@
using StunServerPtr =
std::unique_ptr<TestStunServer, std::function<void(TestStunServer*)>>;
static StunServerPtr Create(rtc::SocketServer* ss,
- const rtc::SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
rtc::Thread& network_thread);
// Set a fake STUN address to return to the client.
- void set_fake_stun_addr(const rtc::SocketAddress& addr) {
+ void set_fake_stun_addr(const webrtc::SocketAddress& addr) {
fake_stun_addr_ = addr;
}
@@ -43,10 +43,10 @@
: StunServer(socket), network_thread_(network_thread) {}
void OnBindingRequest(StunMessage* msg,
- const rtc::SocketAddress& remote_addr) override;
+ const webrtc::SocketAddress& remote_addr) override;
private:
- rtc::SocketAddress fake_stun_addr_;
+ webrtc::SocketAddress fake_stun_addr_;
rtc::Thread& network_thread_;
};
diff --git a/p2p/test/test_turn_server.h b/p2p/test/test_turn_server.h
index c3ffa8c..91dc926 100644
--- a/p2p/test/test_turn_server.h
+++ b/p2p/test/test_turn_server.h
@@ -33,12 +33,13 @@
class TestTurnRedirector : public TurnRedirectInterface {
public:
- explicit TestTurnRedirector(const std::vector<rtc::SocketAddress>& addresses)
+ explicit TestTurnRedirector(
+ const std::vector<webrtc::SocketAddress>& addresses)
: alternate_server_addresses_(addresses),
iter_(alternate_server_addresses_.begin()) {}
- virtual bool ShouldRedirect(const rtc::SocketAddress&,
- rtc::SocketAddress* out) {
+ virtual bool ShouldRedirect(const webrtc::SocketAddress&,
+ webrtc::SocketAddress* out) {
if (!out || iter_ == alternate_server_addresses_.end()) {
return false;
}
@@ -47,16 +48,16 @@
}
private:
- const std::vector<rtc::SocketAddress>& alternate_server_addresses_;
- std::vector<rtc::SocketAddress>::const_iterator iter_;
+ const std::vector<webrtc::SocketAddress>& alternate_server_addresses_;
+ std::vector<webrtc::SocketAddress>::const_iterator iter_;
};
class TestTurnServer : public TurnAuthInterface {
public:
TestTurnServer(rtc::Thread* thread,
rtc::SocketFactory* socket_factory,
- const rtc::SocketAddress& int_addr,
- const rtc::SocketAddress& udp_ext_addr,
+ const webrtc::SocketAddress& int_addr,
+ const webrtc::SocketAddress& udp_ext_addr,
webrtc::ProtocolType int_protocol = webrtc::PROTO_UDP,
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server")
@@ -91,7 +92,7 @@
server_.set_enable_permission_checks(enable);
}
- void AddInternalSocket(const rtc::SocketAddress& int_addr,
+ void AddInternalSocket(const webrtc::SocketAddress& int_addr,
webrtc::ProtocolType proto,
bool ignore_bad_cert = true,
absl::string_view common_name = "test turn server") {
@@ -128,7 +129,7 @@
// Finds the first allocation in the server allocation map with a source
// ip and port matching the socket address provided.
- TurnServerAllocation* FindAllocation(const rtc::SocketAddress& src) {
+ TurnServerAllocation* FindAllocation(const webrtc::SocketAddress& src) {
RTC_DCHECK(thread_checker_.IsCurrent());
const TurnServer::AllocationMap& map = server_.allocations();
for (TurnServer::AllocationMap::const_iterator it = map.begin();
diff --git a/p2p/test/turn_server.cc b/p2p/test/turn_server.cc
index 9c7e666..baff123 100644
--- a/p2p/test/turn_server.cc
+++ b/p2p/test/turn_server.cc
@@ -121,7 +121,7 @@
void TurnServer::SetExternalSocketFactory(
rtc::PacketSocketFactory* factory,
- const rtc::SocketAddress& external_addr) {
+ const webrtc::SocketAddress& external_addr) {
RTC_DCHECK_RUN_ON(thread_);
external_socket_factory_.reset(factory);
external_addr_ = external_addr;
@@ -138,7 +138,7 @@
RTC_DCHECK_RUN_ON(thread_);
// Check if someone is trying to connect to us.
- rtc::SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
rtc::Socket* accepted_socket = server_socket->Accept(&accept_addr);
if (accepted_socket != NULL) {
const ServerSocketInfo& info = server_listen_sockets_[server_socket];
@@ -213,7 +213,7 @@
}
if (redirect_hook_ != NULL && msg.type() == STUN_ALLOCATE_REQUEST) {
- rtc::SocketAddress address;
+ webrtc::SocketAddress address;
if (redirect_hook_->ShouldRedirect(conn->src(), &address)) {
SendErrorResponseWithAlternateServer(conn, &msg, address);
return;
@@ -467,7 +467,7 @@
void TurnServer::SendErrorResponseWithAlternateServer(
TurnServerConnection* conn,
const StunMessage* msg,
- const rtc::SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
TurnMessage resp(GetStunErrorResponseTypeOrZero(*msg), msg->transaction_id());
InitErrorResponse(STUN_ERROR_TRY_ALTERNATE,
STUN_ERROR_REASON_TRY_ALTERNATE_SERVER, &resp);
@@ -526,7 +526,7 @@
}
}
-TurnServerConnection::TurnServerConnection(const rtc::SocketAddress& src,
+TurnServerConnection::TurnServerConnection(const webrtc::SocketAddress& src,
webrtc::ProtocolType proto,
rtc::AsyncPacketSocket* socket)
: src_(src),
@@ -850,7 +850,7 @@
}
TurnServerAllocation::ChannelList::iterator TurnServerAllocation::FindChannel(
- const rtc::SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
return absl::c_find_if(channels_,
[&](const Channel& c) { return c.peer == addr; });
}
@@ -873,7 +873,7 @@
void TurnServerAllocation::SendExternal(const void* data,
size_t size,
- const rtc::SocketAddress& peer) {
+ const webrtc::SocketAddress& peer) {
rtc::PacketOptions options;
external_socket_->SendTo(data, size, peer, options);
}
diff --git a/p2p/test/turn_server.h b/p2p/test/turn_server.h
index 23474be..6431bef 100644
--- a/p2p/test/turn_server.h
+++ b/p2p/test/turn_server.h
@@ -52,18 +52,18 @@
class TurnServerConnection {
public:
TurnServerConnection() : proto_(webrtc::PROTO_UDP), socket_(NULL) {}
- TurnServerConnection(const rtc::SocketAddress& src,
+ TurnServerConnection(const webrtc::SocketAddress& src,
webrtc::ProtocolType proto,
rtc::AsyncPacketSocket* socket);
- const rtc::SocketAddress& src() const { return src_; }
+ const webrtc::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:
- rtc::SocketAddress src_;
- rtc::SocketAddress dst_;
+ webrtc::SocketAddress src_;
+ webrtc::SocketAddress dst_;
webrtc::ProtocolType proto_;
rtc::AsyncPacketSocket* socket_;
};
@@ -100,7 +100,7 @@
struct Channel {
webrtc::ScopedTaskSafety pending_delete;
const uint16_t id;
- const rtc::SocketAddress peer;
+ const webrtc::SocketAddress peer;
};
struct Permission {
webrtc::ScopedTaskSafety pending_delete;
@@ -125,7 +125,7 @@
void AddPermission(const webrtc::IPAddress& addr);
PermissionList::iterator FindPermission(const webrtc::IPAddress& addr);
ChannelList::iterator FindChannel(int channel_id);
- ChannelList::iterator FindChannel(const rtc::SocketAddress& addr);
+ ChannelList::iterator FindChannel(const webrtc::SocketAddress& addr);
void SendResponse(TurnMessage* msg);
void SendBadRequestResponse(const TurnMessage* req);
@@ -134,7 +134,7 @@
absl::string_view reason);
void SendExternal(const void* data,
size_t size,
- const rtc::SocketAddress& peer);
+ const webrtc::SocketAddress& peer);
TurnServer* const server_;
webrtc::TaskQueueBase* const thread_;
@@ -164,8 +164,8 @@
// An interface enables Turn Server to control redirection behavior.
class TurnRedirectInterface {
public:
- virtual bool ShouldRedirect(const rtc::SocketAddress& address,
- rtc::SocketAddress* out) = 0;
+ virtual bool ShouldRedirect(const webrtc::SocketAddress& address,
+ webrtc::SocketAddress* out) = 0;
virtual ~TurnRedirectInterface() {}
};
@@ -257,7 +257,7 @@
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory = nullptr);
// Specifies the factory to use for creating external sockets.
void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
- const rtc::SocketAddress& address);
+ const webrtc::SocketAddress& address);
// For testing only.
std::string SetTimestampForNextNonce(int64_t timestamp) {
RTC_DCHECK_RUN_ON(thread_);
@@ -320,7 +320,7 @@
void SendErrorResponseWithAlternateServer(TurnServerConnection* conn,
const StunMessage* req,
- const rtc::SocketAddress& addr)
+ const webrtc::SocketAddress& addr)
RTC_RUN_ON(thread_);
void SendStun(TurnServerConnection* conn, StunMessage* msg);
@@ -357,7 +357,7 @@
ServerSocketMap server_listen_sockets_ RTC_GUARDED_BY(thread_);
std::unique_ptr<rtc::PacketSocketFactory> external_socket_factory_
RTC_GUARDED_BY(thread_);
- rtc::SocketAddress external_addr_ RTC_GUARDED_BY(thread_);
+ webrtc::SocketAddress external_addr_ RTC_GUARDED_BY(thread_);
AllocationMap allocations_ RTC_GUARDED_BY(thread_);
diff --git a/p2p/test/turn_server_unittest.cc b/p2p/test/turn_server_unittest.cc
index d8194a4..38d1371 100644
--- a/p2p/test/turn_server_unittest.cc
+++ b/p2p/test/turn_server_unittest.cc
@@ -52,9 +52,11 @@
TEST_F(TurnServerConnectionTest, ComparisonOperators) {
std::unique_ptr<rtc::AsyncPacketSocket> socket1(
- socket_factory_.CreateUdpSocket(rtc::SocketAddress("1.1.1.1", 1), 0, 0));
+ socket_factory_.CreateUdpSocket(webrtc::SocketAddress("1.1.1.1", 1), 0,
+ 0));
std::unique_ptr<rtc::AsyncPacketSocket> socket2(
- socket_factory_.CreateUdpSocket(rtc::SocketAddress("2.2.2.2", 2), 0, 0));
+ socket_factory_.CreateUdpSocket(webrtc::SocketAddress("2.2.2.2", 2), 0,
+ 0));
TurnServerConnection connection1(socket2->GetLocalAddress(), PROTO_UDP,
socket1.get());
TurnServerConnection connection2(socket2->GetLocalAddress(), PROTO_UDP,
diff --git a/pc/ice_server_parsing.cc b/pc/ice_server_parsing.cc
index 07504fd..151ee70 100644
--- a/pc/ice_server_parsing.cc
+++ b/pc/ice_server_parsing.cc
@@ -259,7 +259,7 @@
switch (service_type) {
case ServiceType::STUN:
case ServiceType::STUNS:
- stun_servers->insert(rtc::SocketAddress(address, port));
+ stun_servers->insert(SocketAddress(address, port));
break;
case ServiceType::TURN:
case ServiceType::TURNS: {
@@ -276,7 +276,7 @@
// handshake (SNI and Certificate verification).
absl::string_view hostname =
server.hostname.empty() ? address : server.hostname;
- rtc::SocketAddress socket_address(hostname, port);
+ SocketAddress socket_address(hostname, port);
if (!server.hostname.empty()) {
IPAddress ip;
if (!IPFromString(address, &ip)) {
diff --git a/pc/ice_server_parsing_unittest.cc b/pc/ice_server_parsing_unittest.cc
index a38638e..8270e66 100644
--- a/pc/ice_server_parsing_unittest.cc
+++ b/pc/ice_server_parsing_unittest.cc
@@ -166,7 +166,7 @@
PeerConnectionInterface::TlsCertPolicy::kTlsCertPolicySecure,
"hostname"));
EXPECT_EQ(1U, turn_servers_.size());
- rtc::SocketAddress address = turn_servers_[0].ports[0].address;
+ SocketAddress address = turn_servers_[0].ports[0].address;
EXPECT_EQ("hostname", address.hostname());
EXPECT_EQ(1234, address.port());
EXPECT_FALSE(address.IsUnresolvedIP());
diff --git a/pc/jsep_session_description.cc b/pc/jsep_session_description.cc
index 9f39540..31486c7 100644
--- a/pc/jsep_session_description.cc
+++ b/pc/jsep_session_description.cc
@@ -67,13 +67,12 @@
}
current_preference = preference;
current_family = family;
- const rtc::SocketAddress& candidate_addr =
- jsep_candidate->candidate().address();
+ const SocketAddress& candidate_addr = jsep_candidate->candidate().address();
port = candidate_addr.port();
ip = candidate_addr.ipaddr().ToString();
hostname = candidate_addr.hostname();
}
- rtc::SocketAddress connection_addr(ip, port);
+ SocketAddress connection_addr(ip, port);
if (IPIsUnspec(connection_addr.ipaddr()) && !hostname.empty()) {
// When a hostname candidate becomes the (default) connection address,
// we use the dummy address 0.0.0.0 and port 9 in the c= and the m= lines.
@@ -91,7 +90,7 @@
// populate the c= and the m= lines. See `BuildMediaDescription` in
// webrtc_sdp.cc for the SDP generation with
// `media_desc->connection_address()`.
- connection_addr = rtc::SocketAddress(kDummyAddress, kDummyPort);
+ connection_addr = SocketAddress(kDummyAddress, kDummyPort);
}
media_desc->set_connection_address(connection_addr);
}
diff --git a/pc/jsep_session_description_unittest.cc b/pc/jsep_session_description_unittest.cc
index f1f99ee..9d3c56c 100644
--- a/pc/jsep_session_description_unittest.cc
+++ b/pc/jsep_session_description_unittest.cc
@@ -88,7 +88,7 @@
protected:
virtual void SetUp() {
int port = 1234;
- rtc::SocketAddress address("127.0.0.1", port++);
+ webrtc::SocketAddress address("127.0.0.1", port++);
cricket::Candidate candidate(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
address, 1, "", "", IceCandidateType::kHost, 0,
"1");
@@ -139,11 +139,11 @@
TEST_F(JsepSessionDescriptionTest, CloneWithCandidates) {
cricket::Candidate candidate_v4(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("192.168.1.5", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("192.168.1.5", 1234), kCandidatePriority, "", "",
IceCandidateType::kSrflx, kCandidateGeneration, kCandidateFoundation);
cricket::Candidate candidate_v6(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
JsepIceCandidate jice_v4("audio", 0, candidate_v4);
@@ -266,7 +266,7 @@
cricket::Candidate c;
c.set_component(cricket::ICE_CANDIDATE_COMPONENT_RTP);
c.set_protocol(cricket::UDP_PROTOCOL_NAME);
- c.set_address(rtc::SocketAddress("example.local", 1234));
+ c.set_address(webrtc::SocketAddress("example.local", 1234));
c.set_type(IceCandidateType::kHost);
const size_t audio_index = 0;
JsepIceCandidate hostname_candidate("audio", audio_index, c);
@@ -297,7 +297,7 @@
cricket::Candidate c;
c.set_component(cricket::ICE_CANDIDATE_COMPONENT_RTP);
c.set_protocol(cricket::UDP_PROTOCOL_NAME);
- c.set_address(rtc::SocketAddress("example.local", 1234));
+ c.set_address(webrtc::SocketAddress("example.local", 1234));
c.set_type(IceCandidateType::kHost);
const size_t audio_index = 0;
const size_t video_index = 1;
@@ -349,11 +349,11 @@
// Stun has a high preference than local host.
cricket::Candidate candidate1(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kSrflx, kCandidateGeneration, kCandidateFoundation);
cricket::Candidate candidate2(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
JsepIceCandidate jice1("audio", 0, candidate1);
@@ -379,11 +379,11 @@
SerializeSessionDescriptionWithBothIPFamilies) {
cricket::Candidate candidate_v4(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("192.168.1.5", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("192.168.1.5", 1234), kCandidatePriority, "", "",
IceCandidateType::kSrflx, kCandidateGeneration, kCandidateFoundation);
cricket::Candidate candidate_v6(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
JsepIceCandidate jice_v4("audio", 0, candidate_v4);
@@ -410,12 +410,12 @@
// Stun has a high preference than local host.
cricket::Candidate candidate1(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kSrflx, kCandidateGeneration, kCandidateFoundation);
cricket::Candidate candidate2(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("fe80::1234:5678:abcd:ef12", 1235), kCandidatePriority,
- "", "", IceCandidateType::kHost, kCandidateGeneration,
+ webrtc::SocketAddress("fe80::1234:5678:abcd:ef12", 1235),
+ kCandidatePriority, "", "", IceCandidateType::kHost, kCandidateGeneration,
kCandidateFoundation);
JsepIceCandidate jice1("audio", 0, candidate1);
@@ -441,11 +441,11 @@
// Stun has a high preference than local host.
cricket::Candidate candidate1(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kSrflx, kCandidateGeneration, kCandidateFoundation);
cricket::Candidate candidate2(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
JsepIceCandidate jice1("audio", 0, candidate1);
@@ -468,19 +468,19 @@
TEST_F(JsepSessionDescriptionTest, RemoveCandidateAndSetConnectionAddress) {
cricket::Candidate candidate1(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::1", 1234), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
candidate1.set_transport_name("audio");
cricket::Candidate candidate2(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
+ webrtc::SocketAddress("::2", 1235), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
candidate2.set_transport_name("audio");
cricket::Candidate candidate3(
cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
- rtc::SocketAddress("192.168.1.1", 1236), kCandidatePriority, "", "",
+ webrtc::SocketAddress("192.168.1.1", 1236), kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration, kCandidateFoundation);
candidate3.set_transport_name("audio");
diff --git a/pc/jsep_transport_controller_unittest.cc b/pc/jsep_transport_controller_unittest.cc
index fe53005..24fcf4a 100644
--- a/pc/jsep_transport_controller_unittest.cc
+++ b/pc/jsep_transport_controller_unittest.cc
@@ -279,7 +279,7 @@
Candidate CreateCandidate(const std::string& transport_name, int component) {
Candidate c;
c.set_transport_name(transport_name);
- c.set_address(rtc::SocketAddress("192.168.1.1", 8000));
+ c.set_address(SocketAddress("192.168.1.1", 8000));
c.set_component(component);
c.set_protocol(cricket::UDP_PROTOCOL_NAME);
c.set_priority(1);
diff --git a/pc/jsep_transport_unittest.cc b/pc/jsep_transport_unittest.cc
index 76a625c..1a930b6 100644
--- a/pc/jsep_transport_unittest.cc
+++ b/pc/jsep_transport_unittest.cc
@@ -181,7 +181,7 @@
Candidate CreateCandidate(int component) {
Candidate c;
- c.set_address(rtc::SocketAddress("192.168.1.1", 8000));
+ c.set_address(webrtc::SocketAddress("192.168.1.1", 8000));
c.set_component(component);
c.set_protocol(UDP_PROTOCOL_NAME);
c.set_priority(1);
diff --git a/pc/legacy_stats_collector_unittest.cc b/pc/legacy_stats_collector_unittest.cc
index c02562f..ee402e3 100644
--- a/pc/legacy_stats_collector_unittest.cc
+++ b/pc/legacy_stats_collector_unittest.cc
@@ -1322,11 +1322,11 @@
constexpr int kLocalPort = 2000;
const std::string kLocalIp = "192.168.0.1";
- const rtc::SocketAddress kLocalAddress(kLocalIp, kLocalPort);
+ const SocketAddress kLocalAddress(kLocalIp, kLocalPort);
constexpr int kRemotePort = 2001;
const std::string kRemoteIp = "192.168.0.2";
- const rtc::SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
+ const SocketAddress kRemoteAddress(kRemoteIp, kRemotePort);
auto pc = CreatePeerConnection();
auto stats = CreateStatsCollector(pc.get());
diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc
index e5f7bd1..d80b524 100644
--- a/pc/peer_connection_bundle_unittest.cc
+++ b/pc/peer_connection_bundle_unittest.cc
@@ -75,7 +75,7 @@
using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
using RtcpMuxPolicy = PeerConnectionInterface::RtcpMuxPolicy;
-using rtc::SocketAddress;
+
using ::testing::Combine;
using ::testing::UnorderedElementsAre;
using ::testing::Values;
@@ -261,8 +261,7 @@
return wrapper;
}
- cricket::Candidate CreateLocalUdpCandidate(
- const rtc::SocketAddress& address) {
+ cricket::Candidate CreateLocalUdpCandidate(const SocketAddress& address) {
cricket::Candidate candidate;
candidate.set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
candidate.set_protocol(cricket::UDP_PROTOCOL_NAME);
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index 7ca1ccc..aaa0417 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -473,7 +473,7 @@
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
- rtc::SocketAddress stun1("stun.l.google.com", 19302);
+ SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
VerifyStunServers(stun_servers);
std::vector<cricket::RelayServerConfig> turn_servers;
@@ -506,7 +506,7 @@
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
- rtc::SocketAddress stun1("stun.l.google.com", 19302);
+ SocketAddress stun1("stun.l.google.com", 19302);
stun_servers.insert(stun1);
VerifyStunServers(stun_servers);
std::vector<cricket::RelayServerConfig> turn_servers;
@@ -630,13 +630,13 @@
factory_->CreatePeerConnectionOrError(config, std::move(pc_dependencies));
ASSERT_TRUE(result.ok());
cricket::ServerAddresses stun_servers;
- rtc::SocketAddress stun1("1.2.3.4", 1234);
+ SocketAddress stun1("1.2.3.4", 1234);
stun_servers.insert(stun1);
- rtc::SocketAddress stun2("1.2.3.4", 3478);
+ SocketAddress stun2("1.2.3.4", 3478);
stun_servers.insert(stun2); // Default port
- rtc::SocketAddress stun3("2401:fa00:4::", 1234);
+ SocketAddress stun3("2401:fa00:4::", 1234);
stun_servers.insert(stun3);
- rtc::SocketAddress stun4("2401:fa00:4::", 3478);
+ SocketAddress stun4("2401:fa00:4::", 3478);
stun_servers.insert(stun4); // Default port
VerifyStunServers(stun_servers);
diff --git a/pc/peer_connection_histogram_unittest.cc b/pc/peer_connection_histogram_unittest.cc
index 5bd301a..5702a12 100644
--- a/pc/peer_connection_histogram_unittest.cc
+++ b/pc/peer_connection_histogram_unittest.cc
@@ -53,11 +53,10 @@
static const char kUsagePatternMetric[] = "WebRTC.PeerConnection.UsagePattern";
static constexpr webrtc::TimeDelta kDefaultTimeout =
webrtc::TimeDelta::Millis(10000);
-static const rtc::SocketAddress kLocalAddrs[2] = {
- rtc::SocketAddress("1.1.1.1", 0), rtc::SocketAddress("2.2.2.2", 0)};
-static const rtc::SocketAddress kPrivateLocalAddress("10.1.1.1", 0);
-static const rtc::SocketAddress kPrivateIpv6LocalAddress("fd12:3456:789a:1::1",
- 0);
+static const SocketAddress kLocalAddrs[2] = {SocketAddress("1.1.1.1", 0),
+ SocketAddress("2.2.2.2", 0)};
+static const SocketAddress kPrivateLocalAddress("10.1.1.1", 0);
+static const SocketAddress kPrivateIpv6LocalAddress("fd12:3456:789a:1::1", 0);
int MakeUsageFingerprint(std::set<UsageEvent> events) {
int signature = 0;
@@ -316,7 +315,7 @@
return metrics::MinSample(kUsagePatternMetric);
}
- rtc::SocketAddress NextLocalAddress() {
+ SocketAddress NextLocalAddress() {
RTC_DCHECK(next_local_address_ < (int)arraysize(kLocalAddrs));
return kLocalAddrs[next_local_address_++];
}
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index 02fb1b3..261d423 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -86,7 +86,7 @@
using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
-using rtc::SocketAddress;
+
using ::testing::Combine;
using ::testing::ElementsAre;
using ::testing::Pair;
@@ -209,8 +209,7 @@
return wrapper;
}
- cricket::Candidate CreateLocalUdpCandidate(
- const rtc::SocketAddress& address) {
+ cricket::Candidate CreateLocalUdpCandidate(const SocketAddress& address) {
cricket::Candidate candidate;
RTC_DCHECK_EQ(candidate.type(), IceCandidateType::kHost);
candidate.set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
diff --git a/pc/peer_connection_integrationtest.cc b/pc/peer_connection_integrationtest.cc
index e791784..863cd35 100644
--- a/pc/peer_connection_integrationtest.cc
+++ b/pc/peer_connection_integrationtest.cc
@@ -2531,14 +2531,10 @@
signaling_trip_delay_ms * required_signaling_trips +
allowed_internal_delay_ms;
- static const rtc::SocketAddress turn_server_1_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_1_external_address{"88.88.88.1",
- 0};
- static const rtc::SocketAddress turn_server_2_internal_address{"99.99.99.0",
- 3478};
- static const rtc::SocketAddress turn_server_2_external_address{"99.99.99.1",
- 0};
+ static const SocketAddress turn_server_1_internal_address{"88.88.88.0", 3478};
+ 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(
turn_server_1_internal_address, turn_server_1_external_address);
@@ -2680,14 +2676,10 @@
// is actually used by the underlying TURN candidate pair.
// Note that turnport_unittest.cc contains more detailed, lower-level tests.
TEST_P(PeerConnectionIntegrationTest, TurnCustomizerUsedForTurnConnections) {
- static const rtc::SocketAddress turn_server_1_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_1_external_address{"88.88.88.1",
- 0};
- static const rtc::SocketAddress turn_server_2_internal_address{"99.99.99.0",
- 3478};
- static const rtc::SocketAddress turn_server_2_external_address{"99.99.99.1",
- 0};
+ static const SocketAddress turn_server_1_internal_address{"88.88.88.0", 3478};
+ 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};
CreateTurnServer(turn_server_1_internal_address,
turn_server_1_external_address);
CreateTurnServer(turn_server_2_internal_address,
@@ -2734,9 +2726,8 @@
// Verifies that you can use TCP instead of UDP to connect to a TURN server and
// send media between the caller and the callee.
TEST_P(PeerConnectionIntegrationTest, TCPUsedForTurnConnections) {
- static const rtc::SocketAddress turn_server_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_external_address{"88.88.88.1", 0};
+ static const SocketAddress turn_server_internal_address{"88.88.88.0", 3478};
+ static const SocketAddress turn_server_external_address{"88.88.88.1", 0};
// Enable TCP for the fake turn server.
CreateTurnServer(turn_server_internal_address, turn_server_external_address,
@@ -2784,9 +2775,8 @@
// contains more detailed, lower-level tests.
TEST_P(PeerConnectionIntegrationTest,
SSLCertificateVerifierUsedForTurnConnections) {
- static const rtc::SocketAddress turn_server_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_external_address{"88.88.88.1", 0};
+ static const SocketAddress turn_server_internal_address{"88.88.88.0", 3478};
+ static const SocketAddress turn_server_external_address{"88.88.88.1", 0};
// Enable TCP-TLS for the fake turn server. We need to pass in 88.88.88.0 so
// that host name verification passes on the fake certificate.
@@ -3395,9 +3385,8 @@
}
TEST_P(PeerConnectionIntegrationTest, RegatherAfterChangingIceTransportType) {
- static const rtc::SocketAddress turn_server_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_external_address{"88.88.88.1", 0};
+ static const SocketAddress turn_server_internal_address{"88.88.88.0", 3478};
+ static const SocketAddress turn_server_external_address{"88.88.88.1", 0};
CreateTurnServer(turn_server_internal_address, turn_server_external_address);
@@ -3486,9 +3475,8 @@
}
TEST_P(PeerConnectionIntegrationTest, OnIceCandidateError) {
- static const rtc::SocketAddress turn_server_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_external_address{"88.88.88.1", 0};
+ static const SocketAddress turn_server_internal_address{"88.88.88.0", 3478};
+ static const SocketAddress turn_server_external_address{"88.88.88.1", 0};
CreateTurnServer(turn_server_internal_address, turn_server_external_address);
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index 643f29b..341d879 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -71,7 +71,7 @@
static const int kDefaultTestTimeMs = 15000;
static const int kRampUpTimeMs = 5000;
static const int kPollIntervalTimeMs = 50;
-static const rtc::SocketAddress kDefaultLocalAddress("1.1.1.1", 0);
+static const SocketAddress kDefaultLocalAddress("1.1.1.1", 0);
static const char kTurnInternalAddress[] = "88.88.88.0";
static const char kTurnExternalAddress[] = "88.88.88.1";
static const int kTurnInternalPort = 3478;
@@ -254,9 +254,9 @@
rtc::SocketFactory* factory = &firewall_socket_server_;
std::unique_ptr<cricket::TestTurnServer> turn_server;
SendTask(network_thread(), [&] {
- static const rtc::SocketAddress turn_server_internal_address{
+ static const SocketAddress turn_server_internal_address{
kTurnInternalAddress, kTurnInternalPort};
- static const rtc::SocketAddress turn_server_external_address{
+ static const SocketAddress turn_server_external_address{
kTurnExternalAddress, kTurnExternalPort};
turn_server = std::make_unique<cricket::TestTurnServer>(
thread, factory, turn_server_internal_address,
diff --git a/pc/rtc_stats_collector_unittest.cc b/pc/rtc_stats_collector_unittest.cc
index c22c5ea..b212efe 100644
--- a/pc/rtc_stats_collector_unittest.cc
+++ b/pc/rtc_stats_collector_unittest.cc
@@ -181,7 +181,7 @@
rtc::ADAPTER_TYPE_UNKNOWN) {
std::unique_ptr<cricket::Candidate> candidate(new cricket::Candidate(
cricket::ICE_CANDIDATE_COMPONENT_RTP, protocol,
- rtc::SocketAddress(hostname, port), priority, "iceusernamefragment",
+ SocketAddress(hostname, port), priority, "iceusernamefragment",
"" /* pwd */, candidate_type, 0 /* generation */, "foundationIsAString"));
candidate->set_network_type(adapter_type);
@@ -1914,7 +1914,7 @@
std::unique_ptr<cricket::Candidate> remote_candidate = CreateFakeCandidate(
"42.42.42.42", 42, "protocol", rtc::ADAPTER_TYPE_UNKNOWN,
IceCandidateType::kSrflx, 42);
- remote_candidate->set_related_address(rtc::SocketAddress("192.168.2.1", 43));
+ remote_candidate->set_related_address(SocketAddress("192.168.2.1", 43));
remote_candidate->set_username("remote_iceusernamefragment");
cricket::ConnectionInfo connection_info;
diff --git a/pc/session_description.h b/pc/session_description.h
index 1814d3a..46a225c 100644
--- a/pc/session_description.h
+++ b/pc/session_description.h
@@ -190,10 +190,10 @@
// https://tools.ietf.org/html/rfc4566#section-5.7
// May be present at the media or session level of SDP. If present at both
// levels, the media-level attribute overwrites the session-level one.
- void set_connection_address(const rtc::SocketAddress& address) {
+ void set_connection_address(const webrtc::SocketAddress& address) {
connection_address_ = address;
}
- const rtc::SocketAddress& connection_address() const {
+ const webrtc::SocketAddress& connection_address() const {
return connection_address_;
}
@@ -274,7 +274,7 @@
bool conference_mode_ = false;
webrtc::RtpTransceiverDirection direction_ =
webrtc::RtpTransceiverDirection::kSendRecv;
- rtc::SocketAddress connection_address_;
+ webrtc::SocketAddress connection_address_;
ExtmapAllowMixed extmap_allow_mixed_enum_ = kMedia;
SimulcastDescription simulcast_;
diff --git a/pc/slow_peer_connection_integration_test.cc b/pc/slow_peer_connection_integration_test.cc
index b52315f..b6fc7a4 100644
--- a/pc/slow_peer_connection_integration_test.cc
+++ b/pc/slow_peer_connection_integration_test.cc
@@ -172,9 +172,8 @@
TEST_P(PeerConnectionIntegrationTest,
SSLCertificateVerifierFailureUsedForTurnConnectionsFailsConnection) {
- static const rtc::SocketAddress turn_server_internal_address{"88.88.88.0",
- 3478};
- static const rtc::SocketAddress turn_server_external_address{"88.88.88.1", 0};
+ static const SocketAddress turn_server_internal_address{"88.88.88.0", 3478};
+ static const SocketAddress turn_server_external_address{"88.88.88.1", 0};
// Enable TCP-TLS for the fake turn server. We need to pass in 88.88.88.0 so
// that host name verification passes on the fake certificate.
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 2ab2187..fb2bf9a 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -101,7 +101,7 @@
using ::cricket::ContentInfo;
using ::cricket::StreamParams;
-using ::rtc::SocketAddress;
+
using ::testing::_;
using ::testing::Combine;
using ::testing::Contains;
@@ -1093,7 +1093,7 @@
remote_async_dns_resolved_addr_ = local_candidate.address();
remote_async_dns_resolved_addr_.SetResolvedIP(resolved_ip);
EXPECT_CALL(*remote_async_dns_resolver_, Start(_, _))
- .WillOnce([](const rtc::SocketAddress& addr,
+ .WillOnce([](const SocketAddress& addr,
absl::AnyInvocable<void()> callback) { callback(); });
EXPECT_CALL(*remote_async_dns_resolver_, result())
.WillOnce(ReturnRef(remote_async_dns_resolver_result_));
@@ -1186,7 +1186,7 @@
MockAsyncDnsResolver* remote_async_dns_resolver_ = nullptr;
// Result variables for the mock DNS resolver
NiceMock<MockAsyncDnsResolverResult> remote_async_dns_resolver_result_;
- rtc::SocketAddress remote_async_dns_resolved_addr_;
+ SocketAddress remote_async_dns_resolved_addr_;
// All data channels either created or observed on this peerconnection
std::vector<rtc::scoped_refptr<DataChannelInterface>> data_channels_;
@@ -1636,8 +1636,8 @@
}
cricket::TestTurnServer* CreateTurnServer(
- rtc::SocketAddress internal_address,
- rtc::SocketAddress external_address,
+ SocketAddress internal_address,
+ SocketAddress external_address,
ProtocolType type = ProtocolType::PROTO_UDP,
const std::string& common_name = "test turn server") {
rtc::Thread* thread = network_thread();
diff --git a/pc/webrtc_sdp.cc b/pc/webrtc_sdp.cc
index 93506b8..7085bc0 100644
--- a/pc/webrtc_sdp.cc
+++ b/pc/webrtc_sdp.cc
@@ -95,7 +95,7 @@
using cricket::TransportInfo;
using cricket::UnsupportedContentDescription;
using cricket::VideoContentDescription;
-using rtc::SocketAddress;
+using ::webrtc::SocketAddress;
// TODO(deadbeef): Switch to using anonymous namespace rather than declaring
// everything "static".
@@ -300,7 +300,7 @@
std::string* session_version,
TransportDescription* session_td,
RtpHeaderExtensions* session_extmaps,
- rtc::SocketAddress* connection_addr,
+ SocketAddress* connection_addr,
cricket::SessionDescription* desc,
SdpParseError* error);
static bool ParseMediaDescription(
@@ -308,7 +308,7 @@
const TransportDescription& session_td,
const RtpHeaderExtensions& session_extmaps,
size_t* pos,
- const rtc::SocketAddress& session_connection_addr,
+ const SocketAddress& session_connection_addr,
cricket::SessionDescription* desc,
std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
SdpParseError* error);
@@ -968,7 +968,7 @@
std::string session_version;
TransportDescription session_td("", "");
RtpHeaderExtensions session_extmaps;
- rtc::SocketAddress session_connection_addr;
+ SocketAddress session_connection_addr;
auto desc = std::make_unique<cricket::SessionDescription>();
size_t current_pos = 0;
@@ -2043,7 +2043,7 @@
}
bool ParseConnectionData(absl::string_view line,
- rtc::SocketAddress* addr,
+ SocketAddress* addr,
SdpParseError* error) {
// Parse the line from left to right.
std::string token;
@@ -2099,7 +2099,7 @@
std::string* session_version,
TransportDescription* session_td,
RtpHeaderExtensions* session_extmaps,
- rtc::SocketAddress* connection_addr,
+ SocketAddress* connection_addr,
cricket::SessionDescription* desc,
SdpParseError* error) {
std::optional<absl::string_view> line;
@@ -2659,7 +2659,7 @@
const TransportDescription& session_td,
const RtpHeaderExtensions& session_extmaps,
size_t* pos,
- const rtc::SocketAddress& session_connection_addr,
+ const SocketAddress& session_connection_addr,
cricket::SessionDescription* desc,
std::vector<std::unique_ptr<JsepIceCandidate>>* candidates,
SdpParseError* error) {
@@ -2822,7 +2822,7 @@
// Use the session level connection address if the media level addresses are
// not specified.
- rtc::SocketAddress address;
+ SocketAddress address;
address = content->connection_address().IsNil()
? session_connection_addr
: content->connection_address();
@@ -3093,7 +3093,7 @@
// Parse the media level connection data.
if (IsLineType(*line, kLineTypeConnection)) {
- rtc::SocketAddress addr;
+ SocketAddress addr;
if (!ParseConnectionData(*line, &addr, error)) {
return false;
}
diff --git a/pc/webrtc_sdp_unittest.cc b/pc/webrtc_sdp_unittest.cc
index 822d909..3b97c5f 100644
--- a/pc/webrtc_sdp_unittest.cc
+++ b/pc/webrtc_sdp_unittest.cc
@@ -973,7 +973,7 @@
audio_stream.set_stream_ids({kStreamId1});
audio_stream.ssrcs.push_back(kAudioTrack1Ssrc);
audio_desc_->AddStream(audio_stream);
- rtc::SocketAddress audio_addr("74.125.127.126", 2345);
+ webrtc::SocketAddress audio_addr("74.125.127.126", 2345);
audio_desc_->set_connection_address(audio_addr);
desc_.AddContent(kAudioContentName, MediaProtocolType::kRtp,
absl::WrapUnique(audio_desc_));
@@ -989,7 +989,7 @@
cricket::SsrcGroup ssrc_group(kFecSsrcGroupSemantics, video_stream.ssrcs);
video_stream.ssrc_groups.push_back(ssrc_group);
video_desc_->AddStream(video_stream);
- rtc::SocketAddress video_addr("74.125.224.39", 3457);
+ webrtc::SocketAddress video_addr("74.125.224.39", 3457);
video_desc_->set_connection_address(video_addr);
desc_.AddContent(kVideoContentName, MediaProtocolType::kRtp,
absl::WrapUnique(video_desc_));
@@ -1003,7 +1003,7 @@
// v4 host
int port = 1234;
- rtc::SocketAddress address("192.168.1.5", port++);
+ webrtc::SocketAddress address("192.168.1.5", port++);
Candidate candidate1(ICE_CANDIDATE_COMPONENT_RTP, "udp", address,
kCandidatePriority, "", "", IceCandidateType::kHost,
kCandidateGeneration, kCandidateFoundation1);
@@ -1021,7 +1021,7 @@
kCandidateGeneration, kCandidateFoundation1);
// v6 host
- rtc::SocketAddress v6_address("::1", port++);
+ webrtc::SocketAddress v6_address("::1", port++);
cricket::Candidate candidate5(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
v6_address, kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration,
@@ -1044,8 +1044,8 @@
// stun
int port_stun = 2345;
- rtc::SocketAddress address_stun("74.125.127.126", port_stun++);
- rtc::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
+ webrtc::SocketAddress address_stun("74.125.127.126", port_stun++);
+ webrtc::SocketAddress rel_address_stun("192.168.1.5", port_stun++);
cricket::Candidate candidate9(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
address_stun, kCandidatePriority, "", "",
IceCandidateType::kSrflx,
@@ -1062,7 +1062,7 @@
// relay
int port_relay = 3456;
- rtc::SocketAddress address_relay("74.125.224.39", port_relay++);
+ webrtc::SocketAddress address_relay("74.125.224.39", port_relay++);
cricket::Candidate candidate11(cricket::ICE_CANDIDATE_COMPONENT_RTCP, "udp",
address_relay, kCandidatePriority, "", "",
IceCandidateType::kRelay,
@@ -1972,8 +1972,8 @@
// 'connection address' field, previously set from the candidates, must also
// be reset.
void MakeDescriptionWithoutCandidates(JsepSessionDescription* jdesc) {
- rtc::SocketAddress audio_addr("0.0.0.0", 9);
- rtc::SocketAddress video_addr("0.0.0.0", 9);
+ webrtc::SocketAddress audio_addr("0.0.0.0", 9);
+ webrtc::SocketAddress video_addr("0.0.0.0", 9);
audio_desc_->set_connection_address(audio_addr);
video_desc_->set_connection_address(video_addr);
ASSERT_TRUE(jdesc->Initialize(desc_.Clone(), kSessionId, kSessionVersion));
@@ -2233,7 +2233,7 @@
}
TEST_F(WebRtcSdpTest, SerializeHostnameCandidate) {
- rtc::SocketAddress address("a.test", 1234);
+ webrtc::SocketAddress address("a.test", 1234);
cricket::Candidate candidate(cricket::ICE_CANDIDATE_COMPONENT_RTP, "udp",
address, kCandidatePriority, "", "",
IceCandidateType::kHost, kCandidateGeneration,
@@ -2245,9 +2245,9 @@
TEST_F(WebRtcSdpTest, SerializeTcpCandidates) {
Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
- "", "", IceCandidateType::kHost, kCandidateGeneration,
- kCandidateFoundation1);
+ webrtc::SocketAddress("192.168.1.5", 9),
+ kCandidatePriority, "", "", IceCandidateType::kHost,
+ kCandidateGeneration, kCandidateFoundation1);
candidate.set_tcptype(cricket::TCPTYPE_ACTIVE_STR);
std::unique_ptr<IceCandidateInterface> jcandidate(
new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
@@ -2651,9 +2651,9 @@
EXPECT_TRUE(SdpDeserializeCandidate(sdp, &jcandidate));
// Make a cricket::Candidate equivalent to kSdpTcpCandidate string.
Candidate candidate(ICE_CANDIDATE_COMPONENT_RTP, "tcp",
- rtc::SocketAddress("192.168.1.5", 9), kCandidatePriority,
- "", "", IceCandidateType::kHost, kCandidateGeneration,
- kCandidateFoundation1);
+ webrtc::SocketAddress("192.168.1.5", 9),
+ kCandidatePriority, "", "", IceCandidateType::kHost,
+ kCandidateGeneration, kCandidateFoundation1);
std::unique_ptr<IceCandidateInterface> jcandidate_template(
new JsepIceCandidate(std::string("audio_content_name"), 0, candidate));
EXPECT_TRUE(
diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc
index 5493548..f269e40 100644
--- a/rtc_base/async_dns_resolver.cc
+++ b/rtc_base/async_dns_resolver.cc
@@ -135,13 +135,13 @@
state_->Kill();
}
-void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+void AsyncDnsResolver::Start(const SocketAddress& addr,
absl::AnyInvocable<void()> callback) {
Start(addr, addr.family(), std::move(callback));
}
// Start address resolution of the hostname in `addr` matching `family`.
-void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+void AsyncDnsResolver::Start(const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) {
RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
@@ -178,9 +178,8 @@
return result_;
}
-bool AsyncDnsResolverResultImpl::GetResolvedAddress(
- int family,
- rtc::SocketAddress* addr) const {
+bool AsyncDnsResolverResultImpl::GetResolvedAddress(int family,
+ SocketAddress* addr) const {
RTC_DCHECK_RUN_ON(&sequence_checker_);
RTC_DCHECK(addr);
if (error_ != 0 || addresses_.empty())
diff --git a/rtc_base/async_dns_resolver.h b/rtc_base/async_dns_resolver.h
index 8ea5d0a..4a5f161 100644
--- a/rtc_base/async_dns_resolver.h
+++ b/rtc_base/async_dns_resolver.h
@@ -26,14 +26,14 @@
class AsyncDnsResolverResultImpl : public AsyncDnsResolverResult {
public:
- bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override;
+ bool GetResolvedAddress(int family, SocketAddress* addr) const override;
// Returns error from resolver.
int GetError() const override;
private:
friend class AsyncDnsResolver;
RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
- rtc::SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
+ SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
std::vector<IPAddress> addresses_ RTC_GUARDED_BY(sequence_checker_);
int error_ RTC_GUARDED_BY(sequence_checker_);
};
@@ -43,10 +43,10 @@
AsyncDnsResolver();
~AsyncDnsResolver();
// Start address resolution of the hostname in `addr`.
- void Start(const rtc::SocketAddress& addr,
+ void Start(const SocketAddress& addr,
absl::AnyInvocable<void()> callback) override;
// Start address resolution of the hostname in `addr` matching `family`.
- void Start(const rtc::SocketAddress& addr,
+ void Start(const SocketAddress& addr,
int family,
absl::AnyInvocable<void()> callback) override;
const AsyncDnsResolverResult& result() const override;
diff --git a/rtc_base/async_dns_resolver_unittest.cc b/rtc_base/async_dns_resolver_unittest.cc
index 23f541b..80b567d 100644
--- a/rtc_base/async_dns_resolver_unittest.cc
+++ b/rtc_base/async_dns_resolver_unittest.cc
@@ -38,9 +38,9 @@
TEST(AsyncDnsResolver, ResolvingLocalhostWorks) {
test::RunLoop loop; // Ensure that posting back to main thread works
AsyncDnsResolver resolver;
- rtc::SocketAddress address("localhost",
- kPortNumber); // Port number does not matter
- rtc::SocketAddress resolved_address;
+ SocketAddress address("localhost",
+ kPortNumber); // Port number does not matter
+ SocketAddress resolved_address;
bool done = false;
resolver.Start(address, [&done] { done = true; });
ASSERT_THAT(
@@ -48,7 +48,7 @@
IsRtcOk());
EXPECT_EQ(resolver.result().GetError(), 0);
if (resolver.result().GetResolvedAddress(AF_INET, &resolved_address)) {
- EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber));
+ EXPECT_EQ(resolved_address, SocketAddress("127.0.0.1", kPortNumber));
} else {
RTC_LOG(LS_INFO) << "Resolution gave no address, skipping test";
}
@@ -58,9 +58,9 @@
test::RunLoop loop;
std::unique_ptr<AsyncDnsResolver> resolver =
std::make_unique<AsyncDnsResolver>();
- rtc::SocketAddress address("localhost",
- kPortNumber); // Port number does not matter
- rtc::SocketAddress resolved_address;
+ SocketAddress address("localhost",
+ kPortNumber); // Port number does not matter
+ SocketAddress resolved_address;
bool done = false;
resolver->Start(address, [&done] { done = true; });
resolver.reset(); // Deletes resolver.
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index 4202fcc..1ff9d73 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -96,16 +96,16 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns STATE_BINDING).
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
// Returns remote address. Returns zeroes if this is not a client TCP socket.
- virtual SocketAddress GetRemoteAddress() const = 0;
+ virtual webrtc::SocketAddress GetRemoteAddress() const = 0;
// Send a packet.
virtual int Send(const void* pv, size_t cb, const PacketOptions& options) = 0;
virtual int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const PacketOptions& options) = 0;
// Close the socket.
@@ -143,7 +143,8 @@
// Emitted after address for the socket is allocated, i.e. binding
// is finished. State of the socket is changed from BINDING to BOUND
// (for UDP sockets).
- sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
+ sigslot::signal2<AsyncPacketSocket*, const webrtc::SocketAddress&>
+ SignalAddressReady;
// Emitted for client TCP sockets when state is changed from
// CONNECTING to CONNECTED.
@@ -188,7 +189,7 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns kBinding).
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
sigslot::signal2<AsyncListenSocket*, AsyncPacketSocket*> SignalNewConnection;
};
diff --git a/rtc_base/async_packet_socket_unittest.cc b/rtc_base/async_packet_socket_unittest.cc
index ce9f2c3..f0ce150 100644
--- a/rtc_base/async_packet_socket_unittest.cc
+++ b/rtc_base/async_packet_socket_unittest.cc
@@ -24,8 +24,8 @@
public:
~MockAsyncPacketSocket() = default;
- MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
- MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetLocalAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD(int,
Send,
(const void* pv, size_t cb, const rtc::PacketOptions& options),
@@ -35,7 +35,7 @@
SendTo,
(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options),
(override));
MOCK_METHOD(int, Close, (), (override));
@@ -58,7 +58,7 @@
EXPECT_CALL(received_packet, Call);
mock_socket.RegisterReceivedPacketCallback(received_packet.AsStdFunction());
- mock_socket.NotifyPacketReceived(ReceivedPacket({}, SocketAddress()));
+ mock_socket.NotifyPacketReceived(ReceivedPacket({}, webrtc::SocketAddress()));
}
} // namespace
diff --git a/rtc_base/async_socket.cc b/rtc_base/async_socket.cc
index 7289b5c..9730919 100644
--- a/rtc_base/async_socket.cc
+++ b/rtc_base/async_socket.cc
@@ -25,19 +25,19 @@
socket_->SignalCloseEvent.connect(this, &AsyncSocketAdapter::OnCloseEvent);
}
-SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
+webrtc::SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
-int AsyncSocketAdapter::Bind(const SocketAddress& addr) {
+int AsyncSocketAdapter::Bind(const webrtc::SocketAddress& addr) {
return socket_->Bind(addr);
}
-int AsyncSocketAdapter::Connect(const SocketAddress& addr) {
+int AsyncSocketAdapter::Connect(const webrtc::SocketAddress& addr) {
return socket_->Connect(addr);
}
@@ -47,7 +47,7 @@
int AsyncSocketAdapter::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
return socket_->SendTo(pv, cb, addr);
}
@@ -57,7 +57,7 @@
int AsyncSocketAdapter::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
return socket_->RecvFrom(pv, cb, paddr, timestamp);
}
@@ -66,7 +66,7 @@
return socket_->Listen(backlog);
}
-Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
+Socket* AsyncSocketAdapter::Accept(webrtc::SocketAddress* paddr) {
return socket_->Accept(paddr);
}
diff --git a/rtc_base/async_socket.h b/rtc_base/async_socket.h
index 0772cb8..89f4068 100644
--- a/rtc_base/async_socket.h
+++ b/rtc_base/async_socket.h
@@ -28,19 +28,21 @@
// TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers.
explicit AsyncSocketAdapter(Socket* socket);
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& addr) override;
- int Connect(const SocketAddress& addr) override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
+ int Bind(const webrtc::SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- Socket* Accept(SocketAddress* paddr) override;
+ Socket* Accept(webrtc::SocketAddress* paddr) override;
int Close() override;
int GetError() const override;
void SetError(int error) override;
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index b0f91f9..840a88f 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -48,8 +48,8 @@
// Binds and connects `socket`
Socket* AsyncTCPSocketBase::ConnectSocket(
rtc::Socket* socket,
- const rtc::SocketAddress& bind_address,
- const rtc::SocketAddress& remote_address) {
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address) {
std::unique_ptr<rtc::Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
@@ -77,11 +77,11 @@
AsyncTCPSocketBase::~AsyncTCPSocketBase() {}
-SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
+webrtc::SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -121,9 +121,9 @@
int AsyncTCPSocketBase::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) {
- const SocketAddress& remote_address = GetRemoteAddress();
+ const webrtc::SocketAddress& remote_address = GetRemoteAddress();
if (addr == remote_address)
return Send(pv, cb, options);
// Remote address may be empty if there is a sudden network change.
@@ -245,9 +245,10 @@
// Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
-AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address) {
+AsyncTCPSocket* AsyncTCPSocket::Create(
+ Socket* socket,
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address) {
return new AsyncTCPSocket(
AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
}
@@ -288,7 +289,7 @@
}
size_t AsyncTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
- SocketAddress remote_addr(GetRemoteAddress());
+ webrtc::SocketAddress remote_addr(GetRemoteAddress());
size_t processed_bytes = 0;
while (true) {
@@ -329,14 +330,14 @@
}
}
-SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
+webrtc::SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
void AsyncTcpListenSocket::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
- rtc::SocketAddress address;
+ webrtc::SocketAddress address;
rtc::Socket* new_socket = socket->Accept(&address);
if (!new_socket) {
// TODO(stefan): Do something better like forwarding the error
diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h
index d3aff60..9be56b6 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -42,11 +42,11 @@
// Must return the number of bytes processed.
virtual size_t ProcessInput(rtc::ArrayView<const uint8_t> data) = 0;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) override;
int Close() override;
@@ -61,8 +61,8 @@
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
static Socket* ConnectSocket(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address);
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address);
int FlushOutBuffer();
// Add data to `outbuf_`.
void AppendToOutBuffer(const void* pv, size_t cb);
@@ -91,8 +91,8 @@
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
static AsyncTCPSocket* Create(Socket* socket,
- const SocketAddress& bind_address,
- const SocketAddress& remote_address);
+ const webrtc::SocketAddress& bind_address,
+ const webrtc::SocketAddress& remote_address);
explicit AsyncTCPSocket(Socket* socket);
~AsyncTCPSocket() override {}
@@ -110,7 +110,7 @@
explicit AsyncTcpListenSocket(std::unique_ptr<Socket> socket);
State GetState() const override;
- SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
virtual void HandleIncomingConnection(rtc::Socket* socket);
diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc
index 046355c..feca7b9 100644
--- a/rtc_base/async_udp_socket.cc
+++ b/rtc_base/async_udp_socket.cc
@@ -29,8 +29,9 @@
namespace rtc {
-AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
- const SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(
+ Socket* socket,
+ const webrtc::SocketAddress& bind_address) {
std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
@@ -39,8 +40,9 @@
return new AsyncUDPSocket(owned_socket.release());
}
-AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
- const SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(
+ SocketFactory* factory,
+ const webrtc::SocketAddress& bind_address) {
Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
return nullptr;
@@ -54,11 +56,11 @@
socket_->SignalWriteEvent.connect(this, &AsyncUDPSocket::OnWriteEvent);
}
-SocketAddress AsyncUDPSocket::GetLocalAddress() const {
+webrtc::SocketAddress AsyncUDPSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
+webrtc::SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -75,7 +77,7 @@
int AsyncUDPSocket::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) {
rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis(),
options.info_signaled_after_sent);
@@ -129,7 +131,7 @@
// send datagram, indicating the remote address was unreachable.
// When doing ICE, this kind of thing will often happen.
// TODO: Do something better like forwarding the error to the user.
- SocketAddress local_addr = socket_->GetLocalAddress();
+ webrtc::SocketAddress local_addr = socket_->GetLocalAddress();
RTC_LOG(LS_INFO) << "AsyncUDPSocket[" << local_addr.ToSensitiveString()
<< "] receive failed with error " << socket_->GetError();
return;
diff --git a/rtc_base/async_udp_socket.h b/rtc_base/async_udp_socket.h
index cf68488..2dd61d3 100644
--- a/rtc_base/async_udp_socket.h
+++ b/rtc_base/async_udp_socket.h
@@ -36,22 +36,22 @@
// of `socket`. Returns null if bind() fails (`socket` is destroyed
// in that case).
static AsyncUDPSocket* Create(Socket* socket,
- const SocketAddress& bind_address);
+ const webrtc::SocketAddress& bind_address);
// Creates a new socket for sending asynchronous UDP packets using an
// asynchronous socket from the given factory.
static AsyncUDPSocket* Create(SocketFactory* factory,
- const SocketAddress& bind_address);
+ const webrtc::SocketAddress& bind_address);
explicit AsyncUDPSocket(Socket* socket);
~AsyncUDPSocket() = default;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
int Send(const void* pv,
size_t cb,
const rtc::PacketOptions& options) override;
int SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options) override;
int Close() override;
diff --git a/rtc_base/async_udp_socket_unittest.cc b/rtc_base/async_udp_socket_unittest.cc
index 26ab09e..1fd6bc2 100644
--- a/rtc_base/async_udp_socket_unittest.cc
+++ b/rtc_base/async_udp_socket_unittest.cc
@@ -22,7 +22,7 @@
namespace rtc {
-static const SocketAddress kAddr("22.22.22.22", 0);
+static const webrtc::SocketAddress kAddr("22.22.22.22", 0);
TEST(AsyncUDPSocketTest, SetSocketOptionIfEctChange) {
VirtualSocketServer socket_server;
diff --git a/rtc_base/fake_network.h b/rtc_base/fake_network.h
index 0c74593..8ccc881 100644
--- a/rtc_base/fake_network.h
+++ b/rtc_base/fake_network.h
@@ -34,33 +34,34 @@
FakeNetworkManager() {}
struct Iface {
- SocketAddress socket_address;
+ webrtc::SocketAddress socket_address;
AdapterType adapter_type;
std::optional<AdapterType> underlying_vpn_adapter_type;
};
typedef std::vector<Iface> IfaceList;
- void AddInterface(const SocketAddress& iface) {
+ void AddInterface(const webrtc::SocketAddress& iface) {
// Ensure a unique name for the interface if its name is not given.
AddInterface(iface, "test" + rtc::ToString(next_index_++));
}
- void AddInterface(const SocketAddress& iface, absl::string_view if_name) {
+ void AddInterface(const webrtc::SocketAddress& iface,
+ absl::string_view if_name) {
AddInterface(iface, if_name, ADAPTER_TYPE_UNKNOWN);
}
void AddInterface(
- const SocketAddress& iface,
+ const webrtc::SocketAddress& iface,
absl::string_view if_name,
AdapterType type,
std::optional<AdapterType> underlying_vpn_adapter_type = std::nullopt) {
- SocketAddress address(if_name, 0);
+ webrtc::SocketAddress address(if_name, 0);
address.SetResolvedIP(iface.ipaddr());
ifaces_.push_back({address, type, underlying_vpn_adapter_type});
DoUpdateNetworks();
}
- void RemoveInterface(const SocketAddress& iface) {
+ void RemoveInterface(const webrtc::SocketAddress& iface) {
for (IfaceList::iterator it = ifaces_.begin(); it != ifaces_.end(); ++it) {
if (it->socket_address.EqualIPs(iface)) {
ifaces_.erase(it);
diff --git a/rtc_base/firewall_socket_server.cc b/rtc_base/firewall_socket_server.cc
index cc1fb0c..87efc2e 100644
--- a/rtc_base/firewall_socket_server.cc
+++ b/rtc_base/firewall_socket_server.cc
@@ -28,7 +28,7 @@
FirewallSocket(FirewallSocketServer* server, Socket* socket, int type)
: AsyncSocketAdapter(socket), server_(server), type_(type) {}
- int Bind(const SocketAddress& addr) override {
+ int Bind(const webrtc::SocketAddress& addr) override {
if (!server_->IsBindableIp(addr.ipaddr())) {
SetError(EINVAL);
return SOCKET_ERROR;
@@ -36,7 +36,7 @@
return AsyncSocketAdapter::Bind(addr);
}
- int Connect(const SocketAddress& addr) override {
+ int Connect(const webrtc::SocketAddress& addr) override {
if (type_ == SOCK_STREAM) {
if (!server_->Check(FP_TCP, GetLocalAddress(), addr)) {
RTC_LOG(LS_VERBOSE) << "FirewallSocket outbound TCP connection from "
@@ -52,7 +52,9 @@
int Send(const void* pv, size_t cb) override {
return SendTo(pv, cb, GetRemoteAddress());
}
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override {
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override {
RTC_DCHECK(type_ == SOCK_DGRAM || type_ == SOCK_STREAM);
FirewallProtocol protocol = (type_ == SOCK_DGRAM) ? FP_UDP : FP_TCP;
if (!server_->Check(protocol, GetLocalAddress(), addr)) {
@@ -65,12 +67,12 @@
return AsyncSocketAdapter::SendTo(pv, cb, addr);
}
int Recv(void* pv, size_t cb, int64_t* timestamp) override {
- SocketAddress addr;
+ webrtc::SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override {
if (type_ == SOCK_DGRAM) {
while (true) {
@@ -96,8 +98,8 @@
return AsyncSocketAdapter::Listen(backlog);
}
- Socket* Accept(SocketAddress* paddr) override {
- SocketAddress addr;
+ Socket* Accept(webrtc::SocketAddress* paddr) override {
+ webrtc::SocketAddress addr;
while (Socket* sock = AsyncSocketAdapter::Accept(&addr)) {
if (server_->Check(FP_TCP, addr, GetLocalAddress())) {
if (paddr)
@@ -144,8 +146,8 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const SocketAddress& addr) {
- SocketAddress any;
+ const webrtc::SocketAddress& addr) {
+ webrtc::SocketAddress any;
if (d == FD_IN || d == FD_ANY) {
AddRule(allow, p, any, addr);
}
@@ -156,8 +158,8 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst) {
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst) {
Rule r;
r.allow = allow;
r.p = p;
@@ -173,8 +175,8 @@
}
bool FirewallSocketServer::Check(FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst) {
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst) {
webrtc::MutexLock scope(&mutex_);
for (size_t i = 0; i < rules_.size(); ++i) {
const Rule& r = rules_[i];
@@ -249,7 +251,7 @@
void FirewallManager::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
webrtc::MutexLock scope(&mutex_);
for (std::vector<FirewallSocketServer*>::const_iterator it = servers_.begin();
it != servers_.end(); ++it) {
diff --git a/rtc_base/firewall_socket_server.h b/rtc_base/firewall_socket_server.h
index ff48725..822b27d 100644
--- a/rtc_base/firewall_socket_server.h
+++ b/rtc_base/firewall_socket_server.h
@@ -55,16 +55,16 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const SocketAddress& addr = SocketAddress());
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress());
void AddRule(bool allow,
FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst);
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst);
void ClearRules();
bool Check(FirewallProtocol p,
- const SocketAddress& src,
- const SocketAddress& dst);
+ const webrtc::SocketAddress& src,
+ const webrtc::SocketAddress& dst);
// Set the IP addresses for which Bind will fail. By default this list is
// empty. This can be used to simulate a real OS that refuses to bind to
@@ -92,8 +92,8 @@
bool allow;
FirewallProtocol p;
FirewallDirection d;
- SocketAddress src;
- SocketAddress dst;
+ webrtc::SocketAddress src;
+ webrtc::SocketAddress dst;
};
std::vector<Rule> rules_;
std::vector<webrtc::IPAddress> unbindable_ips_;
@@ -116,7 +116,7 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const SocketAddress& addr = SocketAddress());
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress());
void ClearRules();
private:
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index 36e7112..2675df7 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -1038,7 +1038,7 @@
return webrtc::IPAddress();
}
- if (socket->Connect(SocketAddress(
+ if (socket->Connect(webrtc::SocketAddress(
family == AF_INET ? kPublicIPv4Host : kPublicIPv6Host, kPublicPort)) <
0) {
if (socket->GetError() != ENETUNREACH &&
diff --git a/rtc_base/network/received_packet.cc b/rtc_base/network/received_packet.cc
index 346a17f..b10245e 100644
--- a/rtc_base/network/received_packet.cc
+++ b/rtc_base/network/received_packet.cc
@@ -18,7 +18,7 @@
namespace rtc {
ReceivedPacket::ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
- const SocketAddress& source_address,
+ const webrtc::SocketAddress& source_address,
std::optional<webrtc::Timestamp> arrival_time,
EcnMarking ecn,
DecryptionInfo decryption)
@@ -39,7 +39,7 @@
const uint8_t* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& source_address) {
+ const webrtc::SocketAddress& source_address) {
RTC_DCHECK(packet_time_us == -1 || packet_time_us >= 0);
return ReceivedPacket(rtc::MakeArrayView(data, size), source_address,
(packet_time_us >= 0)
diff --git a/rtc_base/network/received_packet.h b/rtc_base/network/received_packet.h
index ec0b0bf..b46d0c8 100644
--- a/rtc_base/network/received_packet.h
+++ b/rtc_base/network/received_packet.h
@@ -37,7 +37,7 @@
// Caller must keep memory pointed to by payload and address valid for the
// lifetime of this ReceivedPacket.
ReceivedPacket(rtc::ArrayView<const uint8_t> payload,
- const SocketAddress& source_address,
+ const webrtc::SocketAddress& source_address,
std::optional<webrtc::Timestamp> arrival_time = std::nullopt,
EcnMarking ecn = EcnMarking::kNotEct,
DecryptionInfo decryption = kNotDecrypted);
@@ -45,7 +45,9 @@
ReceivedPacket CopyAndSet(DecryptionInfo decryption_info) const;
// Address/port of the packet sender.
- const SocketAddress& source_address() const { return source_address_; }
+ const webrtc::SocketAddress& source_address() const {
+ return source_address_;
+ }
rtc::ArrayView<const uint8_t> payload() const { return payload_; }
// Timestamp when this packet was received. Not available on all socket
@@ -63,7 +65,7 @@
const char* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& addr = rtc::SocketAddress()) {
+ const webrtc::SocketAddress& addr = webrtc::SocketAddress()) {
return CreateFromLegacy(reinterpret_cast<const uint8_t*>(data), size,
packet_time_us, addr);
}
@@ -72,12 +74,12 @@
const uint8_t* data,
size_t size,
int64_t packet_time_us,
- const rtc::SocketAddress& = rtc::SocketAddress());
+ const webrtc::SocketAddress& = webrtc::SocketAddress());
private:
rtc::ArrayView<const uint8_t> payload_;
std::optional<webrtc::Timestamp> arrival_time_;
- const SocketAddress& source_address_;
+ const webrtc::SocketAddress& source_address_;
EcnMarking ecn_;
DecryptionInfo decryption_info_;
};
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index b27d076..ea1e27c 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -405,7 +405,7 @@
sockaddr_storage storage;
memset(&storage, 0, sizeof(storage));
webrtc::IPAddress ip = (*it)->GetBestIP();
- SocketAddress bindaddress(ip, 0);
+ webrtc::SocketAddress bindaddress(ip, 0);
bindaddress.SetScopeID((*it)->scope_id());
// TODO(thaloun): Use rtc::Socket once it supports IPv6.
int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index 2879add..6db7f75 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -580,7 +580,7 @@
int OpenSSLAdapter::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
if (GetSocket()->GetState() == Socket::CS_CONNECTED &&
addr == GetSocket()->GetRemoteAddress()) {
return Send(pv, cb);
@@ -641,7 +641,7 @@
int OpenSSLAdapter::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
if (GetSocket()->GetState() == Socket::CS_CONNECTED) {
int ret = Recv(pv, cb, timestamp);
diff --git a/rtc_base/openssl_adapter.h b/rtc_base/openssl_adapter.h
index 9276f60..28ce6b5 100644
--- a/rtc_base/openssl_adapter.h
+++ b/rtc_base/openssl_adapter.h
@@ -62,11 +62,13 @@
void SetRole(webrtc::SSLRole role) override;
int StartSSL(absl::string_view hostname) override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Close() override;
// Note that the socket returns ST_CONNECTING while SSL is being negotiated.
diff --git a/rtc_base/openssl_adapter_unittest.cc b/rtc_base/openssl_adapter_unittest.cc
index 5783a87..835ee10 100644
--- a/rtc_base/openssl_adapter_unittest.cc
+++ b/rtc_base/openssl_adapter_unittest.cc
@@ -30,20 +30,20 @@
class MockAsyncSocket : public Socket {
public:
virtual ~MockAsyncSocket() = default;
- MOCK_METHOD(Socket*, Accept, (SocketAddress*), (override));
- MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
- MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
- MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
- MOCK_METHOD(int, Connect, (const SocketAddress&), (override));
+ MOCK_METHOD(Socket*, Accept, (webrtc::SocketAddress*), (override));
+ MOCK_METHOD(webrtc::SocketAddress, GetLocalAddress, (), (const, override));
+ MOCK_METHOD(webrtc::SocketAddress, GetRemoteAddress, (), (const, override));
+ MOCK_METHOD(int, Bind, (const webrtc::SocketAddress&), (override));
+ MOCK_METHOD(int, Connect, (const webrtc::SocketAddress&), (override));
MOCK_METHOD(int, Send, (const void*, size_t), (override));
MOCK_METHOD(int,
SendTo,
- (const void*, size_t, const SocketAddress&),
+ (const void*, size_t, const webrtc::SocketAddress&),
(override));
MOCK_METHOD(int, Recv, (void*, size_t, int64_t*), (override));
MOCK_METHOD(int,
RecvFrom,
- (void*, size_t, SocketAddress*, int64_t*),
+ (void*, size_t, webrtc::SocketAddress*, int64_t*),
(override));
MOCK_METHOD(int, Listen, (int), (override));
MOCK_METHOD(int, Close, (), (override));
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index f829fc5..a6df1a4 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -187,14 +187,14 @@
return s_ != INVALID_SOCKET;
}
-SocketAddress PhysicalSocket::GetLocalAddress() const {
+webrtc::SocketAddress PhysicalSocket::GetLocalAddress() const {
sockaddr_storage addr_storage = {};
socklen_t addrlen = sizeof(addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int result = ::getsockname(s_, addr, &addrlen);
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result >= 0) {
- SocketAddressFromSockAddrStorage(addr_storage, &address);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING) << "GetLocalAddress: unable to get local addr, socket="
<< s_;
@@ -202,14 +202,14 @@
return address;
}
-SocketAddress PhysicalSocket::GetRemoteAddress() const {
+webrtc::SocketAddress PhysicalSocket::GetRemoteAddress() const {
sockaddr_storage addr_storage = {};
socklen_t addrlen = sizeof(addr_storage);
sockaddr* addr = reinterpret_cast<sockaddr*>(&addr_storage);
int result = ::getpeername(s_, addr, &addrlen);
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result >= 0) {
- SocketAddressFromSockAddrStorage(addr_storage, &address);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
RTC_LOG(LS_WARNING)
<< "GetRemoteAddress: unable to get remote addr, socket=" << s_;
@@ -217,8 +217,8 @@
return address;
}
-int PhysicalSocket::Bind(const SocketAddress& bind_addr) {
- SocketAddress copied_bind_addr = bind_addr;
+int PhysicalSocket::Bind(const webrtc::SocketAddress& bind_addr) {
+ webrtc::SocketAddress copied_bind_addr = bind_addr;
// If a network binder is available, use it to bind a socket to an interface
// instead of bind(), since this is more reliable on an OS with a weak host
// model.
@@ -265,7 +265,7 @@
return err;
}
-int PhysicalSocket::Connect(const SocketAddress& addr) {
+int PhysicalSocket::Connect(const webrtc::SocketAddress& addr) {
// TODO(pthatcher): Implicit creation is required to reconnect...
// ...but should we make it more explicit?
if (state_ != CS_CLOSED) {
@@ -283,7 +283,7 @@
return DoConnect(addr);
}
-int PhysicalSocket::DoConnect(const SocketAddress& connect_addr) {
+int PhysicalSocket::DoConnect(const webrtc::SocketAddress& connect_addr) {
if ((s_ == INVALID_SOCKET) && !Create(connect_addr.family(), SOCK_STREAM)) {
return SOCKET_ERROR;
}
@@ -415,7 +415,7 @@
int PhysicalSocket::SendTo(const void* buffer,
size_t length,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
sockaddr_storage saddr;
size_t len = addr.ToSockAddrStorage(&saddr);
int sent =
@@ -467,7 +467,7 @@
int PhysicalSocket::RecvFrom(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp) {
int received = DoReadFromSocket(buffer, length, out_addr, timestamp, nullptr);
@@ -509,7 +509,7 @@
int PhysicalSocket::DoReadFromSocket(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn) {
sockaddr_storage addr_storage;
@@ -560,7 +560,7 @@
}
}
if (out_addr) {
- SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
}
return received;
@@ -595,7 +595,7 @@
return err;
}
-Socket* PhysicalSocket::Accept(SocketAddress* out_addr) {
+Socket* PhysicalSocket::Accept(webrtc::SocketAddress* out_addr) {
// Always re-subscribe DE_ACCEPT to make sure new incoming connections will
// trigger an event even if DoAccept returns an error here.
EnableEvents(DE_ACCEPT);
@@ -607,7 +607,7 @@
if (s == INVALID_SOCKET)
return nullptr;
if (out_addr != nullptr)
- SocketAddressFromSockAddrStorage(addr_storage, out_addr);
+ webrtc::SocketAddressFromSockAddrStorage(addr_storage, out_addr);
return ss_->WrapSocket(s);
}
@@ -648,7 +648,7 @@
const webrtc::AsyncDnsResolverResult& result) {
int error = result.GetError();
if (error == 0) {
- SocketAddress address;
+ webrtc::SocketAddress address;
if (result.GetResolvedAddress(AF_INET, &address)) {
error = DoConnect(address);
} else {
diff --git a/rtc_base/physical_socket_server.h b/rtc_base/physical_socket_server.h
index 3bab75a..39dbe38 100644
--- a/rtc_base/physical_socket_server.h
+++ b/rtc_base/physical_socket_server.h
@@ -165,11 +165,11 @@
// Creates the underlying OS socket (same as the "socket" function).
virtual bool Create(int family, int type);
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& bind_addr) override;
- int Connect(const SocketAddress& addr) override;
+ int Bind(const webrtc::SocketAddress& bind_addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int GetError() const override;
void SetError(int error) override;
@@ -182,18 +182,18 @@
int Send(const void* pv, size_t cb) override;
int SendTo(const void* buffer,
size_t length,
- const SocketAddress& addr) override;
+ const webrtc::SocketAddress& addr) override;
int Recv(void* buffer, size_t length, int64_t* timestamp) override;
// TODO(webrtc:15368): Deprecate and remove.
int RecvFrom(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp) override;
int RecvFrom(ReceiveBuffer& buffer) override;
int Listen(int backlog) override;
- Socket* Accept(SocketAddress* out_addr) override;
+ Socket* Accept(webrtc::SocketAddress* out_addr) override;
int Close() override;
@@ -202,7 +202,7 @@
SOCKET GetSocketFD() const { return s_; }
protected:
- int DoConnect(const SocketAddress& connect_addr);
+ int DoConnect(const webrtc::SocketAddress& connect_addr);
// Make virtual so ::accept can be overwritten in tests.
virtual SOCKET DoAccept(SOCKET socket, sockaddr* addr, socklen_t* addrlen);
@@ -220,7 +220,7 @@
int DoReadFromSocket(void* buffer,
size_t length,
- SocketAddress* out_addr,
+ webrtc::SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn);
diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc
index b30eff9..3d9dc05 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -203,7 +203,7 @@
void PhysicalSocketTest::ConnectInternalAcceptError(
const webrtc::IPAddress& loopback) {
webrtc::testing::StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create two clients.
std::unique_ptr<Socket> client1(
@@ -222,7 +222,7 @@
std::unique_ptr<Socket> server(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -504,7 +504,7 @@
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
- EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
+ EXPECT_EQ(-1, socket->Bind(webrtc::SocketAddress("192.168.0.1", 0)));
server_.set_network_binder(nullptr);
}
@@ -514,7 +514,7 @@
FakeNetworkBinder fake_network_binder;
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds());
server_.set_network_binder(nullptr);
}
@@ -528,7 +528,7 @@
server_.set_network_binder(&fake_network_binder);
std::unique_ptr<Socket> socket(server_.CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
- EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(kIPv4Loopback, 0)));
server_.set_network_binder(nullptr);
}
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index f8fe23d..9f282b3 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -22,9 +22,9 @@
// ProxyServer
ProxyServer::ProxyServer(SocketFactory* int_factory,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip)
+ const webrtc::SocketAddress& ext_ip)
: ext_factory_(ext_factory),
ext_ip_(ext_ip.ipaddr(), 0), // strip off port
server_socket_(
@@ -38,7 +38,7 @@
ProxyServer::~ProxyServer() = default;
-SocketAddress ProxyServer::GetServerAddress() {
+webrtc::SocketAddress ProxyServer::GetServerAddress() {
return server_socket_->GetLocalAddress();
}
@@ -82,7 +82,7 @@
ProxyBinding::~ProxyBinding() = default;
void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
RTC_DCHECK(!connected_);
RTC_DCHECK(ext_socket_);
ext_socket_->Connect(addr);
@@ -119,7 +119,7 @@
void ProxyBinding::OnExternalClose(Socket* socket, int err) {
if (!connected_) {
- int_socket_->SendConnectResult(err, SocketAddress());
+ int_socket_->SendConnectResult(err, webrtc::SocketAddress());
}
Destroy();
}
diff --git a/rtc_base/proxy_server.h b/rtc_base/proxy_server.h
index 033dd82..50afd96 100644
--- a/rtc_base/proxy_server.h
+++ b/rtc_base/proxy_server.h
@@ -43,7 +43,7 @@
private:
void OnConnectRequest(AsyncProxyServerSocket* socket,
- const SocketAddress& addr);
+ const webrtc::SocketAddress& addr);
void OnInternalRead(Socket* socket);
void OnInternalWrite(Socket* socket);
void OnInternalClose(Socket* socket, int err);
@@ -67,16 +67,16 @@
class ProxyServer : public sigslot::has_slots<> {
public:
ProxyServer(SocketFactory* int_factory,
- const SocketAddress& int_addr,
+ const webrtc::SocketAddress& int_addr,
SocketFactory* ext_factory,
- const SocketAddress& ext_ip);
+ const webrtc::SocketAddress& ext_ip);
~ProxyServer() override;
ProxyServer(const ProxyServer&) = delete;
ProxyServer& operator=(const ProxyServer&) = delete;
// Returns the address to which the proxy server is bound
- SocketAddress GetServerAddress();
+ webrtc::SocketAddress GetServerAddress();
protected:
void OnAcceptEvent(Socket* socket);
@@ -84,7 +84,7 @@
private:
SocketFactory* ext_factory_;
- SocketAddress ext_ip_;
+ webrtc::SocketAddress ext_ip_;
std::unique_ptr<Socket> server_socket_;
std::vector<std::unique_ptr<ProxyBinding>> bindings_;
};
diff --git a/rtc_base/server_socket_adapters.h b/rtc_base/server_socket_adapters.h
index 05dcd29..0480d41 100644
--- a/rtc_base/server_socket_adapters.h
+++ b/rtc_base/server_socket_adapters.h
@@ -20,9 +20,10 @@
public:
AsyncProxyServerSocket(Socket* socket, size_t buffer_size);
~AsyncProxyServerSocket() override;
- sigslot::signal2<AsyncProxyServerSocket*, const SocketAddress&>
+ sigslot::signal2<AsyncProxyServerSocket*, const webrtc::SocketAddress&>
SignalConnectRequest;
- virtual void SendConnectResult(int err, const SocketAddress& addr) = 0;
+ virtual void SendConnectResult(int err,
+ const webrtc::SocketAddress& addr) = 0;
};
// Implements a socket adapter that performs the server side of a
diff --git a/rtc_base/socket.h b/rtc_base/socket.h
index 4b9a169..acffcd3 100644
--- a/rtc_base/socket.h
+++ b/rtc_base/socket.h
@@ -89,7 +89,7 @@
ReceiveBuffer(Buffer& payload) : payload(payload) {}
std::optional<webrtc::Timestamp> arrival_time;
- SocketAddress source_address;
+ webrtc::SocketAddress source_address;
EcnMarking ecn = EcnMarking::kNotEct;
Buffer& payload;
};
@@ -100,22 +100,24 @@
// Returns the address to which the socket is bound. If the socket is not
// bound, then the any-address is returned.
- virtual SocketAddress GetLocalAddress() const = 0;
+ virtual webrtc::SocketAddress GetLocalAddress() const = 0;
// Returns the address to which the socket is connected. If the socket is
// not connected, then the any-address is returned.
- virtual SocketAddress GetRemoteAddress() const = 0;
+ virtual webrtc::SocketAddress GetRemoteAddress() const = 0;
- virtual int Bind(const SocketAddress& addr) = 0;
- virtual int Connect(const SocketAddress& addr) = 0;
+ virtual int Bind(const webrtc::SocketAddress& addr) = 0;
+ virtual int Connect(const webrtc::SocketAddress& addr) = 0;
virtual int Send(const void* pv, size_t cb) = 0;
- virtual int SendTo(const void* pv, size_t cb, const SocketAddress& addr) = 0;
+ virtual int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) = 0;
// `timestamp` is in units of microseconds.
virtual int Recv(void* pv, size_t cb, int64_t* timestamp) = 0;
// TODO(webrtc:15368): Deprecate and remove.
virtual int RecvFrom(void* /* pv */,
size_t /* cb */,
- SocketAddress* /* paddr */,
+ webrtc::SocketAddress* /* paddr */,
int64_t* /* timestamp */) {
// Not implemented. Use RecvFrom(ReceiveBuffer& buffer).
RTC_CHECK_NOTREACHED();
@@ -125,7 +127,7 @@
// Returns number of bytes received or a negative value on error.
virtual int RecvFrom(ReceiveBuffer& buffer);
virtual int Listen(int backlog) = 0;
- virtual Socket* Accept(SocketAddress* paddr) = 0;
+ virtual Socket* Accept(webrtc::SocketAddress* paddr) = 0;
virtual int Close() = 0;
virtual int GetError() const = 0;
virtual void SetError(int error) = 0;
diff --git a/rtc_base/socket_adapters.cc b/rtc_base/socket_adapters.cc
index 2a157bf..df9558a 100644
--- a/rtc_base/socket_adapters.cc
+++ b/rtc_base/socket_adapters.cc
@@ -172,7 +172,7 @@
AsyncSSLSocket::AsyncSSLSocket(Socket* socket)
: BufferedReadAdapter(socket, 1024) {}
-int AsyncSSLSocket::Connect(const SocketAddress& addr) {
+int AsyncSSLSocket::Connect(const webrtc::SocketAddress& addr) {
// Begin buffering before we connect, so that there isn't a race condition
// between potential senders and receiving the OnConnectEvent signal
BufferInput(true);
diff --git a/rtc_base/socket_adapters.h b/rtc_base/socket_adapters.h
index c41b4a8..8535faf 100644
--- a/rtc_base/socket_adapters.h
+++ b/rtc_base/socket_adapters.h
@@ -69,7 +69,7 @@
AsyncSSLSocket(const AsyncSSLSocket&) = delete;
AsyncSSLSocket& operator=(const AsyncSSLSocket&) = delete;
- int Connect(const SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
protected:
void OnConnectEvent(Socket* socket) override;
diff --git a/rtc_base/socket_address.cc b/rtc_base/socket_address.cc
index 2b31212..1e7d941 100644
--- a/rtc_base/socket_address.cc
+++ b/rtc_base/socket_address.cc
@@ -31,7 +31,7 @@
#include "rtc_base/numerics/safe_conversions.h"
#include "rtc_base/strings/string_builder.h"
-namespace rtc {
+namespace webrtc {
SocketAddress::SocketAddress() {
Clear();
@@ -43,11 +43,11 @@
}
SocketAddress::SocketAddress(uint32_t ip_as_host_order_integer, int port) {
- SetIP(webrtc::IPAddress(ip_as_host_order_integer));
+ SetIP(IPAddress(ip_as_host_order_integer));
SetPort(port);
}
-SocketAddress::SocketAddress(const webrtc::IPAddress& ip, int port) {
+SocketAddress::SocketAddress(const IPAddress& ip, int port) {
SetIP(ip);
SetPort(port);
}
@@ -59,7 +59,7 @@
void SocketAddress::Clear() {
hostname_.clear();
literal_ = false;
- ip_ = webrtc::IPAddress();
+ ip_ = IPAddress();
port_ = 0;
scope_id_ = 0;
}
@@ -84,11 +84,11 @@
void SocketAddress::SetIP(uint32_t ip_as_host_order_integer) {
hostname_.clear();
literal_ = false;
- ip_ = webrtc::IPAddress(ip_as_host_order_integer);
+ ip_ = IPAddress(ip_as_host_order_integer);
scope_id_ = 0;
}
-void SocketAddress::SetIP(const webrtc::IPAddress& ip) {
+void SocketAddress::SetIP(const IPAddress& ip) {
hostname_.clear();
literal_ = false;
ip_ = ip;
@@ -99,17 +99,17 @@
hostname_ = std::string(hostname);
literal_ = webrtc::IPFromString(hostname, &ip_);
if (!literal_) {
- ip_ = webrtc::IPAddress();
+ ip_ = IPAddress();
}
scope_id_ = 0;
}
void SocketAddress::SetResolvedIP(uint32_t ip_as_host_order_integer) {
- ip_ = webrtc::IPAddress(ip_as_host_order_integer);
+ ip_ = IPAddress(ip_as_host_order_integer);
scope_id_ = 0;
}
-void SocketAddress::SetResolvedIP(const webrtc::IPAddress& ip) {
+void SocketAddress::SetResolvedIP(const IPAddress& ip) {
ip_ = ip;
scope_id_ = 0;
}
@@ -122,7 +122,7 @@
return ip_.v4AddressAsHostOrderInteger();
}
-const webrtc::IPAddress& SocketAddress::ipaddr() const {
+const IPAddress& SocketAddress::ipaddr() const {
return ip_;
}
@@ -160,14 +160,14 @@
std::string SocketAddress::ToString() const {
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsURIString() << ":" << port();
return sb.str();
}
std::string SocketAddress::ToSensitiveString() const {
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsSensitiveURIString() << ":" << port();
return sb.str();
}
@@ -177,7 +177,7 @@
return ToSensitiveString();
}
char buf[1024];
- webrtc::SimpleStringBuilder sb(buf);
+ SimpleStringBuilder sb(buf);
sb << HostAsSensitiveURIString() << ":" << port();
sb << " (";
if (ip_.family() == AF_INET6) {
@@ -289,7 +289,7 @@
}
static size_t ToSockAddrStorageHelper(sockaddr_storage* addr,
- const webrtc::IPAddress& ip,
+ const IPAddress& ip,
uint16_t port,
int scope_id) {
memset(addr, 0, sizeof(sockaddr_storage));
@@ -324,12 +324,12 @@
}
if (addr.ss_family == AF_INET) {
const sockaddr_in* saddr = reinterpret_cast<const sockaddr_in*>(&addr);
- *out = SocketAddress(webrtc::IPAddress(saddr->sin_addr),
+ *out = SocketAddress(IPAddress(saddr->sin_addr),
webrtc::NetworkToHost16(saddr->sin_port));
return true;
} else if (addr.ss_family == AF_INET6) {
const sockaddr_in6* saddr = reinterpret_cast<const sockaddr_in6*>(&addr);
- *out = SocketAddress(webrtc::IPAddress(saddr->sin6_addr),
+ *out = SocketAddress(IPAddress(saddr->sin6_addr),
webrtc::NetworkToHost16(saddr->sin6_port));
out->SetScopeID(saddr->sin6_scope_id);
return true;
@@ -339,11 +339,11 @@
SocketAddress EmptySocketAddressWithFamily(int family) {
if (family == AF_INET) {
- return SocketAddress(webrtc::IPAddress(INADDR_ANY), 0);
+ return SocketAddress(IPAddress(INADDR_ANY), 0);
} else if (family == AF_INET6) {
- return SocketAddress(webrtc::IPAddress(in6addr_any), 0);
+ return SocketAddress(IPAddress(in6addr_any), 0);
}
return SocketAddress();
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_address.h b/rtc_base/socket_address.h
index ea5dbea..d189d3c 100644
--- a/rtc_base/socket_address.h
+++ b/rtc_base/socket_address.h
@@ -22,7 +22,7 @@
struct sockaddr_in;
struct sockaddr_storage;
-namespace rtc {
+namespace webrtc {
// Records an IP address and port.
class RTC_EXPORT SocketAddress {
@@ -42,7 +42,7 @@
// Creates the address with the given IP and port.
// DCHECKs that port is in valid range (0 to 2^16-1).
- SocketAddress(const webrtc::IPAddress& ip, int port);
+ SocketAddress(const IPAddress& ip, int port);
// Creates a copy of the given address.
SocketAddress(const SocketAddress& addr);
@@ -64,7 +64,7 @@
void SetIP(uint32_t ip_as_host_order_integer);
// Changes the IP of this address to the given one, and clears the hostname.
- void SetIP(const webrtc::IPAddress& ip);
+ void SetIP(const IPAddress& ip);
// Changes the hostname of this address to the given one.
// Does not resolve the address; use Resolve to do so.
@@ -77,7 +77,7 @@
// Sets the IP address while retaining the hostname. Useful for bypassing
// DNS for a pre-resolved IP.
- void SetResolvedIP(const webrtc::IPAddress& ip);
+ void SetResolvedIP(const IPAddress& ip);
// Changes the port of this address to the given one.
// DCHECKs that port is in valid range (0 to 2^16-1).
@@ -90,7 +90,7 @@
// Returns 0 for non-v4 addresses.
uint32_t ip() const;
- const webrtc::IPAddress& ipaddr() const;
+ const IPAddress& ipaddr() const;
int family() const { return ip_.family(); }
@@ -184,7 +184,7 @@
private:
std::string hostname_;
- webrtc::IPAddress ip_;
+ IPAddress ip_;
uint16_t port_;
int scope_id_;
bool literal_; // Indicates that 'hostname_' contains a literal IP string.
@@ -194,6 +194,14 @@
SocketAddress* out);
SocketAddress EmptySocketAddressWithFamily(int family);
+} // 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::EmptySocketAddressWithFamily;
+using ::webrtc::SocketAddress;
+using ::webrtc::SocketAddressFromSockAddrStorage;
} // namespace rtc
#endif // RTC_BASE_SOCKET_ADDRESS_H_
diff --git a/rtc_base/socket_address_pair.cc b/rtc_base/socket_address_pair.cc
index 351dbd3..b97c086 100644
--- a/rtc_base/socket_address_pair.cc
+++ b/rtc_base/socket_address_pair.cc
@@ -12,8 +12,8 @@
namespace webrtc {
-SocketAddressPair::SocketAddressPair(const rtc::SocketAddress& src,
- const rtc::SocketAddress& dest)
+SocketAddressPair::SocketAddressPair(const SocketAddress& src,
+ const SocketAddress& dest)
: src_(src), dest_(dest) {}
bool SocketAddressPair::operator==(const SocketAddressPair& p) const {
diff --git a/rtc_base/socket_address_pair.h b/rtc_base/socket_address_pair.h
index aa1b01c..5a3bf81 100644
--- a/rtc_base/socket_address_pair.h
+++ b/rtc_base/socket_address_pair.h
@@ -23,11 +23,10 @@
class SocketAddressPair {
public:
SocketAddressPair() {}
- SocketAddressPair(const rtc::SocketAddress& srs,
- const rtc::SocketAddress& dest);
+ SocketAddressPair(const SocketAddress& srs, const SocketAddress& dest);
- const rtc::SocketAddress& source() const { return src_; }
- const rtc::SocketAddress& destination() const { return dest_; }
+ const SocketAddress& source() const { return src_; }
+ const SocketAddress& destination() const { return dest_; }
bool operator==(const SocketAddressPair& r) const;
bool operator<(const SocketAddressPair& r) const;
@@ -35,8 +34,8 @@
size_t Hash() const;
private:
- rtc::SocketAddress src_;
- rtc::SocketAddress dest_;
+ SocketAddress src_;
+ SocketAddress dest_;
};
} // namespace webrtc
diff --git a/rtc_base/socket_address_unittest.cc b/rtc_base/socket_address_unittest.cc
index 14b6862..e81fb6d 100644
--- a/rtc_base/socket_address_unittest.cc
+++ b/rtc_base/socket_address_unittest.cc
@@ -18,7 +18,7 @@
#include "rtc_base/net_helpers.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
const in6_addr kTestV6Addr = {
{{0x20, 0x01, 0x0d, 0xb8, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
@@ -36,15 +36,15 @@
TEST(SocketAddressTest, TestDefaultCtor) {
SocketAddress addr;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(0, addr.port());
EXPECT_EQ("", addr.hostname());
}
TEST(SocketAddressTest, TestIPPortCtor) {
- SocketAddress addr(webrtc::IPAddress(0x01020304), 5678);
+ SocketAddress addr(IPAddress(0x01020304), 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -53,7 +53,7 @@
TEST(SocketAddressTest, TestIPv4StringPortCtor) {
SocketAddress addr("1.2.3.4", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -61,7 +61,7 @@
TEST(SocketAddressTest, TestIPv6StringPortCtor) {
SocketAddress addr2(kTestV6AddrString, 1234);
- webrtc::IPAddress tocheck(kTestV6Addr);
+ IPAddress tocheck(kTestV6Addr);
EXPECT_FALSE(addr2.IsUnresolvedIP());
EXPECT_EQ(tocheck, addr2.ipaddr());
@@ -74,7 +74,7 @@
// inet_addr doesn't handle this address properly.
SocketAddress addr("255.255.255.255", 5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0xFFFFFFFFU), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0xFFFFFFFFU), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("255.255.255.255", addr.hostname());
EXPECT_EQ("255.255.255.255:5678", addr.ToString());
@@ -83,7 +83,7 @@
TEST(SocketAddressTest, TestHostnamePortCtor) {
SocketAddress addr("a.b.com", 5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -93,7 +93,7 @@
SocketAddress from("1.2.3.4", 5678);
SocketAddress addr(from);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -101,49 +101,49 @@
TEST(SocketAddressTest, TestAssign) {
SocketAddress from("1.2.3.4", 5678);
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr = from;
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPPort) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
- addr.SetIP(webrtc::IPAddress(0x01020304));
+ SocketAddress addr(IPAddress(0x88888888), 9999);
+ addr.SetIP(IPAddress(0x01020304));
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromString) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("1.2.3.4");
addr.SetPort(5678);
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
}
TEST(SocketAddressTest, TestSetIPFromHostname) {
- SocketAddress addr(webrtc::IPAddress(0x88888888), 9999);
+ SocketAddress addr(IPAddress(0x88888888), 9999);
addr.SetIP("a.b.com");
addr.SetPort(5678);
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
- addr.SetResolvedIP(webrtc::IPAddress(0x01020304));
+ addr.SetResolvedIP(IPAddress(0x01020304));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
}
@@ -152,7 +152,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("1.2.3.4:5678"));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("1.2.3.4", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -171,7 +171,7 @@
SocketAddress addr;
EXPECT_TRUE(addr.FromString("a.b.com:5678"));
EXPECT_TRUE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(), addr.ipaddr());
+ EXPECT_EQ(IPAddress(), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("a.b.com", addr.hostname());
EXPECT_EQ("a.b.com:5678", addr.ToString());
@@ -183,7 +183,7 @@
from.ToSockAddr(&addr_in);
EXPECT_TRUE(addr.FromSockAddr(addr_in));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -195,7 +195,7 @@
from.ToSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(0x01020304U), addr.ipaddr());
+ EXPECT_EQ(IPAddress(0x01020304U), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("1.2.3.4:5678", addr.ToString());
@@ -204,7 +204,7 @@
from.ToDualStackSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kMappedV4Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kMappedV4Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ("[::ffff:1.2.3.4]:5678", addr.ToString());
@@ -216,7 +216,7 @@
from.ToSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
@@ -226,7 +226,7 @@
from.ToDualStackSockAddrStorage(&addr_storage);
EXPECT_TRUE(SocketAddressFromSockAddrStorage(addr_storage, &addr));
EXPECT_FALSE(addr.IsUnresolvedIP());
- EXPECT_EQ(webrtc::IPAddress(kTestV6Addr), addr.ipaddr());
+ EXPECT_EQ(IPAddress(kTestV6Addr), addr.ipaddr());
EXPECT_EQ(5678, addr.port());
EXPECT_EQ("", addr.hostname());
EXPECT_EQ(kTestV6AddrFullString, addr.ToString());
@@ -338,14 +338,14 @@
SocketAddress ipv4OnlyLiteral("1.2.3.4", 5678);
EXPECT_EQ("1.2.3.x:5678", ipv4OnlyLiteral.ToSensitiveNameAndAddressString());
- SocketAddress ipv4OnlyAddress(webrtc::IPAddress(0x01020304), 5678);
+ SocketAddress ipv4OnlyAddress(IPAddress(0x01020304), 5678);
EXPECT_EQ("1.2.3.x:5678", ipv4OnlyAddress.ToSensitiveNameAndAddressString());
SocketAddress hostOnly("webrtc.org", 443);
EXPECT_EQ("webrtc.org:443", hostOnly.ToSensitiveNameAndAddressString());
SocketAddress hostAndIpv4("webrtc.org", 80);
- hostAndIpv4.SetResolvedIP(webrtc::IPAddress(0x01020304));
+ hostAndIpv4.SetResolvedIP(IPAddress(0x01020304));
EXPECT_EQ("webrtc.org:80 (1.2.3.x:80)",
hostAndIpv4.ToSensitiveNameAndAddressString());
@@ -353,14 +353,14 @@
EXPECT_EQ(kTestV6AddrFullAnonymizedString,
ipv6OnlyLiteral.ToSensitiveNameAndAddressString());
- SocketAddress ipv6OnlyAddress(webrtc::IPAddress(kTestV6Addr), 5678);
+ SocketAddress ipv6OnlyAddress(IPAddress(kTestV6Addr), 5678);
EXPECT_EQ(kTestV6AddrFullAnonymizedString,
ipv6OnlyAddress.ToSensitiveNameAndAddressString());
SocketAddress hostAndIpv6("webrtc.org", 5678);
- hostAndIpv6.SetResolvedIP(webrtc::IPAddress(kTestV6Addr));
+ hostAndIpv6.SetResolvedIP(IPAddress(kTestV6Addr));
EXPECT_EQ("webrtc.org:5678 (" + kTestV6AddrFullAnonymizedString + ")",
hostAndIpv6.ToSensitiveNameAndAddressString());
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 76715b6..0067e55 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -262,7 +262,7 @@
void SocketTest::ConnectInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -275,7 +275,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -322,7 +322,7 @@
void SocketTest::ConnectWithDnsLookupInternal(const webrtc::IPAddress& loopback,
absl::string_view host) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -333,11 +333,11 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
- SocketAddress dns_addr(server->GetLocalAddress());
+ webrtc::SocketAddress dns_addr(server->GetLocalAddress());
dns_addr.SetIP(host);
EXPECT_EQ(0, client->Connect(dns_addr));
// TODO: Bind when doing DNS lookup.
@@ -375,7 +375,7 @@
void SocketTest::ConnectFailInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -386,12 +386,12 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
// Attempt connect to a non-existent socket.
// We don't connect to the server socket created above, since on
// MacOS it takes about 75 seconds to get back an error!
- SocketAddress bogus_addr(loopback, 65535);
+ webrtc::SocketAddress bogus_addr(loopback, 65535);
EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED).
@@ -411,7 +411,7 @@
void SocketTest::ConnectWithDnsLookupFailInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -422,12 +422,12 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
// Attempt connect to a non-existent host.
// We don't connect to the server socket created above, since on
// MacOS it takes about 75 seconds to get back an error!
- SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
+ webrtc::SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
EXPECT_EQ(0, client->Connect(bogus_dns_addr));
// Wait for connection to fail (EHOSTNOTFOUND).
@@ -456,7 +456,7 @@
// Create server and listen.
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state.
@@ -466,7 +466,8 @@
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
// Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
- EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0,
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
}
@@ -477,19 +478,20 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create client, connect.
std::unique_ptr<Socket> client(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0,
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
// Try to connect again. Should fail, but not interfere with original attempt.
EXPECT_EQ(SOCKET_ERROR,
- client->Connect(SocketAddress(server->GetLocalAddress())));
+ client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
// Accept the original connection.
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
EXPECT_THAT(
webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
@@ -510,7 +512,7 @@
// Try to connect again, to an unresolved hostname.
// Shouldn't break anything.
- EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(
+ EXPECT_EQ(SOCKET_ERROR, client->Connect(webrtc::SocketAddress(
"localhost", server->GetLocalAddress().port())));
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
@@ -531,7 +533,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -555,7 +557,7 @@
void SocketTest::ClientCloseDuringConnectInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -566,7 +568,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -598,7 +600,7 @@
void SocketTest::ServerCloseInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -609,7 +611,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -683,7 +685,7 @@
const webrtc::IPAddress& loopback) {
StreamSink sink;
SocketCloser closer;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -695,7 +697,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -757,8 +759,8 @@
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
std::unique_ptr<Socket> socket2(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
- EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket1->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket2->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
EXPECT_EQ(3, socket2->SendTo("bar", 3, socket1->GetLocalAddress()));
// Sleep a while to ensure sends are both completed at the same time.
@@ -775,7 +777,7 @@
void SocketTest::SocketServerWaitInternal(const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create & connect server and client sockets.
std::unique_ptr<Socket> client(
@@ -784,7 +786,7 @@
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
@@ -833,7 +835,7 @@
size_t data_size,
ptrdiff_t max_send_size) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create receiving client.
std::unique_ptr<Socket> receiver(
@@ -844,7 +846,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -973,7 +975,7 @@
void SocketTest::SingleFlowControlCallbackInternal(
const webrtc::IPAddress& loopback) {
StreamSink sink;
- SocketAddress accept_addr;
+ webrtc::SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -984,7 +986,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -1055,12 +1057,13 @@
}
void SocketTest::UdpInternal(const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior.
Socket* socket = socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress addr1 = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress addr1 = socket->GetLocalAddress();
EXPECT_EQ(0, socket->Connect(addr1));
EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
socket->Close();
@@ -1073,11 +1076,11 @@
auto client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr2;
+ webrtc::SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
- SocketAddress addr3;
+ webrtc::SocketAddress addr3;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
EXPECT_EQ(addr3, addr1);
@@ -1086,12 +1089,12 @@
client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr4;
+ webrtc::SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
- SocketAddress addr5;
+ webrtc::SocketAddress addr5;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
EXPECT_EQ(addr5, addr1);
@@ -1101,13 +1104,14 @@
}
void SocketTest::UdpReadyToSend(const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
// RFC 5737 - The blocks 192.0.2.0/24 (TEST-NET-1) ... are provided for use in
// documentation.
// RFC 3849 - 2001:DB8::/32 as a documentation-only prefix.
std::string dest =
(loopback.family() == AF_INET6) ? "2001:db8::1" : "192.0.2.0";
- SocketAddress test_addr(dest, 2345);
+ webrtc::SocketAddress test_addr(dest, 2345);
// Test send
auto client = std::make_unique<webrtc::TestClient>(
@@ -1151,7 +1155,7 @@
void SocketTest::GetSetOptionsInternal(const webrtc::IPAddress& loopback) {
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- socket->Bind(SocketAddress(loopback, 0));
+ socket->Bind(webrtc::SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF.
const int desired_size = 12345;
@@ -1204,7 +1208,7 @@
// Prepare on TCP specific options.
socket.reset(socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- socket->Bind(SocketAddress(loopback, 0));
+ socket->Bind(webrtc::SocketAddress(loopback, 0));
// Check that we can set NODELAY on a TCP socket.
ASSERT_NE(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
@@ -1245,8 +1249,8 @@
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
int64_t send_time_1 = TimeMicros();
@@ -1284,11 +1288,12 @@
void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(
const webrtc::IPAddress& loopback) {
- SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(loopback.family());
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
- SocketAddress address = socket->GetLocalAddress();
+ ASSERT_EQ(socket->Bind(webrtc::SocketAddress(loopback, 0)), 0);
+ webrtc::SocketAddress address = socket->GetLocalAddress();
socket = nullptr;
auto client1 = std::make_unique<webrtc::TestClient>(
@@ -1296,7 +1301,7 @@
auto client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- SocketAddress addr2;
+ webrtc::SocketAddress addr2;
client2->SendTo("foo", 3, address);
std::unique_ptr<webrtc::TestClient::Packet> packet_1 =
client1->NextPacket(10000);
@@ -1316,8 +1321,8 @@
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
- SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
+ webrtc::SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
rtc::Buffer buffer;
Socket::ReceiveBuffer receive_buffer(buffer);
diff --git a/rtc_base/ssl_adapter.h b/rtc_base/ssl_adapter.h
index 2bce106..c366081 100644
--- a/rtc_base/ssl_adapter.h
+++ b/rtc_base/ssl_adapter.h
@@ -107,7 +107,7 @@
private:
// Not supported.
int Listen(int backlog) override { RTC_CHECK(false); }
- Socket* Accept(SocketAddress* paddr) override { RTC_CHECK(false); }
+ Socket* Accept(webrtc::SocketAddress* paddr) override { RTC_CHECK(false); }
};
///////////////////////////////////////////////////////////////////////////////
diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc
index 032f3a0..6a8d0e6 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -39,7 +39,7 @@
static const webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Millis(5000);
static rtc::Socket* CreateSocket() {
- rtc::SocketAddress address(webrtc::IPAddress(INADDR_ANY), 0);
+ webrtc::SocketAddress address(webrtc::IPAddress(INADDR_ANY), 0);
rtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket(
address.family(), SOCK_STREAM);
@@ -93,7 +93,7 @@
ssl_adapter_->SetEllipticCurves(curves);
}
- rtc::SocketAddress GetAddress() const {
+ webrtc::SocketAddress GetAddress() const {
return ssl_adapter_->GetLocalAddress();
}
@@ -146,7 +146,8 @@
CreateSSLAdapter(socket_.release(), webrtc::SSL_CLIENT);
}
- int Connect(absl::string_view hostname, const rtc::SocketAddress& address) {
+ int Connect(absl::string_view hostname,
+ const webrtc::SocketAddress& address) {
RTC_LOG(LS_INFO) << "Initiating connection with " << address.ToString();
int rv = ssl_adapter_->Connect(address);
@@ -175,7 +176,9 @@
<< socket_->GetLocalAddress().ToString();
}
- rtc::SocketAddress GetAddress() const { return socket_->GetLocalAddress(); }
+ webrtc::SocketAddress GetAddress() const {
+ return socket_->GetLocalAddress();
+ }
std::string GetHostname() const {
// Since we don't have a real certificate anyway, the value here doesn't
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index 58409ea..a003599 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -65,7 +65,7 @@
int TestClient::SendTo(const char* buf,
size_t size,
- const rtc::SocketAddress& dest) {
+ const SocketAddress& dest) {
rtc::PacketOptions options;
return socket_->SendTo(buf, size, dest, options);
}
@@ -106,7 +106,7 @@
bool TestClient::CheckNextPacket(const char* buf,
size_t size,
- rtc::SocketAddress* addr) {
+ SocketAddress* addr) {
bool res = false;
std::unique_ptr<Packet> packet = NextPacket(kTimeoutMs);
if (packet) {
diff --git a/rtc_base/test_client.h b/rtc_base/test_client.h
index 1915c80..5adc108 100644
--- a/rtc_base/test_client.h
+++ b/rtc_base/test_client.h
@@ -32,7 +32,7 @@
Packet(const rtc::ReceivedPacket& received_packet);
Packet(const Packet& p);
- rtc::SocketAddress addr;
+ SocketAddress addr;
Buffer buf;
std::optional<Timestamp> packet_time;
};
@@ -53,10 +53,8 @@
TestClient(const TestClient&) = delete;
TestClient& operator=(const TestClient&) = delete;
- rtc::SocketAddress address() const { return socket_->GetLocalAddress(); }
- rtc::SocketAddress remote_address() const {
- return socket_->GetRemoteAddress();
- }
+ SocketAddress address() const { return socket_->GetLocalAddress(); }
+ SocketAddress remote_address() const { return socket_->GetRemoteAddress(); }
// Checks that the socket moves to the specified connect state.
bool CheckConnState(rtc::AsyncPacketSocket::State state);
@@ -70,7 +68,7 @@
int Send(const char* buf, size_t size);
// Sends using the clients socket to the given destination.
- int SendTo(const char* buf, size_t size, const rtc::SocketAddress& dest);
+ int SendTo(const char* buf, size_t size, const SocketAddress& dest);
// Returns the next packet received by the client or null if none is received
// within the specified timeout.
@@ -78,7 +76,7 @@
// Checks that the next packet has the given contents. Returns the remote
// address that the packet was sent from.
- bool CheckNextPacket(const char* buf, size_t len, rtc::SocketAddress* addr);
+ bool CheckNextPacket(const char* buf, size_t len, SocketAddress* addr);
// Checks that no packets have arrived or will arrive in the next second.
bool CheckNoPacket();
diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc
index 3b3a8e0..fd7d753 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -39,7 +39,7 @@
namespace webrtc {
namespace {
-void TestUdpInternal(const rtc::SocketAddress& loopback) {
+void TestUdpInternal(const SocketAddress& loopback) {
rtc::PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
rtc::Socket* socket =
@@ -47,14 +47,14 @@
socket->Bind(loopback);
TestClient client(std::make_unique<rtc::AsyncUDPSocket>(socket));
- rtc::SocketAddress addr = client.address(), from;
+ SocketAddress addr = client.address(), from;
EXPECT_EQ(3, client.SendTo("foo", 3, addr));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
EXPECT_EQ(from, addr);
EXPECT_TRUE(client.CheckNoPacket());
}
-void TestTcpInternal(const rtc::SocketAddress& loopback) {
+void TestTcpInternal(const SocketAddress& loopback) {
rtc::PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
webrtc::TestEchoServer server(&main_thread, loopback);
@@ -66,7 +66,7 @@
ASSERT_TRUE(tcp_socket != nullptr);
TestClient client(std::move(tcp_socket));
- rtc::SocketAddress addr = client.address(), from;
+ SocketAddress addr = client.address(), from;
EXPECT_TRUE(client.CheckConnected());
EXPECT_EQ(3, client.Send("foo", 3));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
@@ -77,7 +77,7 @@
// Tests whether the TestClient can send UDP to itself.
TEST(TestClientTest, TestUdpIPv4) {
MAYBE_SKIP_IPV4;
- TestUdpInternal(rtc::SocketAddress("127.0.0.1", 0));
+ TestUdpInternal(SocketAddress("127.0.0.1", 0));
}
#if defined(WEBRTC_LINUX)
@@ -87,13 +87,13 @@
#endif
TEST(TestClientTest, MAYBE_TestUdpIPv6) {
MAYBE_SKIP_IPV6;
- TestUdpInternal(rtc::SocketAddress("::1", 0));
+ TestUdpInternal(SocketAddress("::1", 0));
}
// Tests whether the TestClient can connect to a server and exchange data.
TEST(TestClientTest, TestTcpIPv4) {
MAYBE_SKIP_IPV4;
- TestTcpInternal(rtc::SocketAddress("127.0.0.1", 0));
+ TestTcpInternal(SocketAddress("127.0.0.1", 0));
}
#if defined(WEBRTC_LINUX)
@@ -103,7 +103,7 @@
#endif
TEST(TestClientTest, MAYBE_TestTcpIPv6) {
MAYBE_SKIP_IPV6;
- TestTcpInternal(rtc::SocketAddress("::1", 0));
+ TestTcpInternal(SocketAddress("::1", 0));
}
} // namespace
diff --git a/rtc_base/test_echo_server.cc b/rtc_base/test_echo_server.cc
index 1888a07..8f80220 100644
--- a/rtc_base/test_echo_server.cc
+++ b/rtc_base/test_echo_server.cc
@@ -14,8 +14,7 @@
namespace webrtc {
-TestEchoServer::TestEchoServer(rtc::Thread* thread,
- const rtc::SocketAddress& addr)
+TestEchoServer::TestEchoServer(rtc::Thread* thread, const SocketAddress& addr)
: server_socket_(
thread->socketserver()->CreateSocket(addr.family(), SOCK_STREAM)) {
server_socket_->Bind(addr);
diff --git a/rtc_base/test_echo_server.h b/rtc_base/test_echo_server.h
index c9d15f0..b549b50 100644
--- a/rtc_base/test_echo_server.h
+++ b/rtc_base/test_echo_server.h
@@ -33,15 +33,13 @@
// Useful for unit tests.
class TestEchoServer : public sigslot::has_slots<> {
public:
- TestEchoServer(rtc::Thread* thread, const rtc::SocketAddress& addr);
+ TestEchoServer(rtc::Thread* thread, const SocketAddress& addr);
~TestEchoServer() override;
TestEchoServer(const TestEchoServer&) = delete;
TestEchoServer& operator=(const TestEchoServer&) = delete;
- rtc::SocketAddress address() const {
- return server_socket_->GetLocalAddress();
- }
+ SocketAddress address() const { return server_socket_->GetLocalAddress(); }
private:
void OnAccept(rtc::Socket* socket) {
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index da7a36e..3184061 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -91,7 +91,7 @@
class SocketClient : public TestGenerator, public sigslot::has_slots<> {
public:
SocketClient(Socket* socket,
- const SocketAddress& addr,
+ const webrtc::SocketAddress& addr,
Thread* post_thread,
MessageClient* phandler)
: socket_(AsyncUDPSocket::Create(socket, addr)),
@@ -105,7 +105,7 @@
~SocketClient() override { delete socket_; }
- SocketAddress address() const { return socket_->GetLocalAddress(); }
+ webrtc::SocketAddress address() const { return socket_->GetLocalAddress(); }
void OnPacket(AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
EXPECT_EQ(packet.payload().size(), sizeof(uint32_t));
@@ -159,7 +159,7 @@
// See: https://code.google.com/p/webrtc/issues/detail?id=2409
TEST(ThreadTest, DISABLED_Main) {
rtc::AutoThread main_thread;
- const SocketAddress addr("127.0.0.1", 0);
+ const webrtc::SocketAddress addr("127.0.0.1", 0);
// Create the messaging client on its own thread.
auto th1 = Thread::CreateWithSocketServer();
diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc
index 9e2d657..ebac6b0 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -63,7 +63,9 @@
// the kernel does.
class VirtualSocketPacket {
public:
- VirtualSocketPacket(const char* data, size_t size, const SocketAddress& from)
+ VirtualSocketPacket(const char* data,
+ size_t size,
+ const webrtc::SocketAddress& from)
: size_(size), consumed_(0), from_(from) {
RTC_DCHECK(nullptr != data);
data_ = new char[size_];
@@ -74,7 +76,7 @@
const char* data() const { return data_ + consumed_; }
size_t size() const { return size_ - consumed_; }
- const SocketAddress& from() const { return from_; }
+ const webrtc::SocketAddress& from() const { return from_; }
// Remove the first size bytes from the data.
void Consume(size_t size) {
@@ -85,7 +87,7 @@
private:
char* data_;
size_t size_, consumed_;
- SocketAddress from_;
+ webrtc::SocketAddress from_;
};
VirtualSocket::VirtualSocket(VirtualSocketServer* server, int family, int type)
@@ -106,19 +108,19 @@
Close();
}
-SocketAddress VirtualSocket::GetLocalAddress() const {
+webrtc::SocketAddress VirtualSocket::GetLocalAddress() const {
return local_addr_;
}
-SocketAddress VirtualSocket::GetRemoteAddress() const {
+webrtc::SocketAddress VirtualSocket::GetRemoteAddress() const {
return remote_addr_;
}
-void VirtualSocket::SetLocalAddress(const SocketAddress& addr) {
+void VirtualSocket::SetLocalAddress(const webrtc::SocketAddress& addr) {
local_addr_ = addr;
}
-int VirtualSocket::Bind(const SocketAddress& addr) {
+int VirtualSocket::Bind(const webrtc::SocketAddress& addr) {
if (!local_addr_.IsNil()) {
error_ = EINVAL;
return -1;
@@ -135,7 +137,7 @@
return result;
}
-int VirtualSocket::Connect(const SocketAddress& addr) {
+int VirtualSocket::Connect(const webrtc::SocketAddress& addr) {
return InitiateConnect(addr, true);
}
@@ -152,7 +154,7 @@
void VirtualSocket::SafetyBlock::SetNotAlive() {
VirtualSocketServer* const server = socket_.server_;
- const SocketAddress& local_addr = socket_.local_addr_;
+ const webrtc::SocketAddress& local_addr = socket_.local_addr_;
MutexLock lock(&mutex_);
// Cancel pending sockets
@@ -242,7 +244,7 @@
int VirtualSocket::SendTo(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
if (SOCK_DGRAM == type_) {
return SendUdp(pv, cb, addr);
} else {
@@ -255,13 +257,13 @@
}
int VirtualSocket::Recv(void* pv, size_t cb, int64_t* timestamp) {
- SocketAddress addr;
+ webrtc::SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int VirtualSocket::RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) {
if (timestamp) {
*timestamp = -1;
@@ -286,7 +288,7 @@
int VirtualSocket::SafetyBlock::RecvFrom(void* buffer,
size_t size,
- SocketAddress& addr) {
+ webrtc::SocketAddress& addr) {
MutexLock lock(&mutex_);
// If we don't have a packet, then either error or wait for one to arrive.
if (recv_buffer_.empty()) {
@@ -332,7 +334,7 @@
listen_queue_.emplace();
}
-VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
+VirtualSocket* VirtualSocket::Accept(webrtc::SocketAddress* paddr) {
SafetyBlock::AcceptResult result = safety_->Accept();
if (result.error != 0) {
error_ = result.error;
@@ -360,7 +362,7 @@
socket->SetLocalAddress(socket_.local_addr_);
// Sockets made from a socket that 'was Any' need to inherit that.
socket->set_was_any(socket_.was_any());
- SocketAddress remote_addr = listen_queue_->front();
+ webrtc::SocketAddress remote_addr = listen_queue_->front();
listen_queue_->pop_front();
if (socket->InitiateConnect(remote_addr, false) != 0) {
continue;
@@ -424,12 +426,13 @@
}
void VirtualSocket::PostConnect(TimeDelta delay,
- const SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
safety_->PostConnect(delay, remote_addr);
}
-void VirtualSocket::SafetyBlock::PostConnect(TimeDelta delay,
- const SocketAddress& remote_addr) {
+void VirtualSocket::SafetyBlock::PostConnect(
+ TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr) {
rtc::scoped_refptr<SafetyBlock> safety(this);
MutexLock lock(&mutex_);
@@ -463,7 +466,7 @@
return Signal::kNone;
}
RTC_DCHECK(!posted_connects_.empty());
- SocketAddress remote_addr = *remote_addr_it;
+ webrtc::SocketAddress remote_addr = *remote_addr_it;
posted_connects_.erase(remote_addr_it);
if (listen_queue_.has_value()) {
@@ -506,7 +509,8 @@
server_->msg_queue_->PostDelayedTask(std::move(task), delay);
}
-int VirtualSocket::InitiateConnect(const SocketAddress& addr, bool use_delay) {
+int VirtualSocket::InitiateConnect(const webrtc::SocketAddress& addr,
+ bool use_delay) {
if (!remote_addr_.IsNil()) {
error_ = (CS_CONNECTED == state_) ? EISCONN : EINPROGRESS;
return -1;
@@ -515,9 +519,9 @@
// If there's no local address set, grab a random one in the correct AF.
int result = 0;
if (addr.ipaddr().family() == AF_INET) {
- result = Bind(SocketAddress("0.0.0.0", 0));
+ result = Bind(webrtc::SocketAddress("0.0.0.0", 0));
} else if (addr.ipaddr().family() == AF_INET6) {
- result = Bind(SocketAddress("::", 0));
+ result = Bind(webrtc::SocketAddress("::", 0));
}
if (result != 0) {
return result;
@@ -537,7 +541,7 @@
return 0;
}
-void VirtualSocket::CompleteConnect(const SocketAddress& addr) {
+void VirtualSocket::CompleteConnect(const webrtc::SocketAddress& addr) {
RTC_DCHECK(CS_CONNECTING == state_);
remote_addr_ = addr;
state_ = CS_CONNECTED;
@@ -546,11 +550,11 @@
int VirtualSocket::SendUdp(const void* pv,
size_t cb,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
// If we have not been assigned a local port, then get one.
if (local_addr_.IsNil()) {
local_addr_ = server_->AssignBindAddress(
- EmptySocketAddressWithFamily(addr.ipaddr().family()));
+ webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family()));
int result = server_->Bind(this, local_addr_);
if (result != 0) {
local_addr_.Clear();
@@ -773,8 +777,8 @@
}
bool VirtualSocketServer::CloseTcpConnections(
- const SocketAddress& addr_local,
- const SocketAddress& addr_remote) {
+ const webrtc::SocketAddress& addr_local,
+ const webrtc::SocketAddress& addr_remote) {
VirtualSocket* socket = LookupConnection(addr_local, addr_remote);
if (!socket) {
return false;
@@ -789,25 +793,25 @@
}
int VirtualSocketServer::Bind(VirtualSocket* socket,
- const SocketAddress& addr) {
+ const webrtc::SocketAddress& addr) {
RTC_DCHECK(nullptr != socket);
// Address must be completely specified at this point
RTC_DCHECK(!webrtc::IPIsUnspec(addr.ipaddr()));
RTC_DCHECK(addr.port() != 0);
// Normalize the address (turns v6-mapped addresses into v4-addresses).
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::value_type entry(normalized, socket);
return bindings_->insert(entry).second ? 0 : -1;
}
-SocketAddress VirtualSocketServer::AssignBindAddress(
- const SocketAddress& app_addr) {
+webrtc::SocketAddress VirtualSocketServer::AssignBindAddress(
+ const webrtc::SocketAddress& app_addr) {
RTC_DCHECK(!webrtc::IPIsUnspec(app_addr.ipaddr()));
// Normalize the IP.
- SocketAddress addr;
+ webrtc::SocketAddress addr;
addr.SetIP(app_addr.ipaddr().Normalized());
// If the IP appears in `alternative_address_mapping_`, meaning the test has
@@ -833,8 +837,9 @@
return addr;
}
-VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+VirtualSocket* VirtualSocketServer::LookupBinding(
+ const webrtc::SocketAddress& addr) {
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::iterator it = bindings_->find(normalized);
if (it != bindings_->end()) {
return it->second;
@@ -846,8 +851,8 @@
// If we can't find a binding for the packet which is sent to the interface
// corresponding to the default route, it should match a binding with the
// correct port to the any address.
- SocketAddress sock_addr =
- EmptySocketAddressWithFamily(addr.ipaddr().family());
+ webrtc::SocketAddress sock_addr =
+ webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family());
sock_addr.SetPort(addr.port());
return LookupBinding(sock_addr);
}
@@ -855,40 +860,47 @@
return nullptr;
}
-int VirtualSocketServer::Unbind(const SocketAddress& addr,
+int VirtualSocketServer::Unbind(const webrtc::SocketAddress& addr,
VirtualSocket* socket) {
- SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
RTC_DCHECK((*bindings_)[normalized] == socket);
bindings_->erase(bindings_->find(normalized));
return 0;
}
-void VirtualSocketServer::AddConnection(const SocketAddress& local,
- const SocketAddress& remote,
+void VirtualSocketServer::AddConnection(const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote,
VirtualSocket* remote_socket) {
// Add this socket pair to our routing table. This will allow
// multiple clients to connect to the same server address.
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
connections_->insert(std::pair<webrtc::SocketAddressPair, VirtualSocket*>(
address_pair, remote_socket));
}
VirtualSocket* VirtualSocketServer::LookupConnection(
- const SocketAddress& local,
- const SocketAddress& remote) {
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote) {
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
ConnectionMap::iterator it = connections_->find(address_pair);
return (connections_->end() != it) ? it->second : nullptr;
}
-void VirtualSocketServer::RemoveConnection(const SocketAddress& local,
- const SocketAddress& remote) {
- SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
- SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+void VirtualSocketServer::RemoveConnection(
+ const webrtc::SocketAddress& local,
+ const webrtc::SocketAddress& remote) {
+ webrtc::SocketAddress local_normalized(local.ipaddr().Normalized(),
+ local.port());
+ webrtc::SocketAddress remote_normalized(remote.ipaddr().Normalized(),
+ remote.port());
webrtc::SocketAddressPair address_pair(local_normalized, remote_normalized);
connections_->erase(address_pair);
}
@@ -898,7 +910,7 @@
}
int VirtualSocketServer::Connect(VirtualSocket* socket,
- const SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
bool use_delay) {
RTC_DCHECK(msg_queue_);
@@ -929,12 +941,12 @@
return true;
}
-bool VirtualSocketServer::Disconnect(const SocketAddress& addr) {
+bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& addr) {
return Disconnect(LookupBinding(addr));
}
-bool VirtualSocketServer::Disconnect(const SocketAddress& local_addr,
- const SocketAddress& remote_addr) {
+bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& local_addr,
+ const webrtc::SocketAddress& remote_addr) {
// Disconnect remote socket, check if it is a child of a server socket.
VirtualSocket* socket = LookupConnection(local_addr, remote_addr);
if (!socket) {
@@ -955,7 +967,7 @@
int VirtualSocketServer::SendUdp(VirtualSocket* socket,
const char* data,
size_t data_size,
- const SocketAddress& remote_addr) {
+ const webrtc::SocketAddress& remote_addr) {
{
webrtc::MutexLock lock(&mutex_);
++sent_packets_;
@@ -1074,7 +1086,7 @@
socket->MaybeSignalWriteEvent(send_buffer_capacity());
}
-void VirtualSocketServer::SendTcp(const SocketAddress& addr) {
+void VirtualSocketServer::SendTcp(const webrtc::SocketAddress& addr) {
VirtualSocket* sender = LookupBinding(addr);
RTC_DCHECK(nullptr != sender);
SendTcp(sender);
@@ -1096,7 +1108,7 @@
// When the incoming packet is from a binding of the any address, translate it
// to the default route here such that the recipient will see the default
// route.
- SocketAddress sender_addr = sender->GetLocalAddress();
+ webrtc::SocketAddress sender_addr = sender->GetLocalAddress();
webrtc::IPAddress default_ip =
GetDefaultSourceAddress(sender_addr.ipaddr().family());
if (sender_addr.IsAnyIP() && !webrtc::IPIsUnspec(default_ip)) {
diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h
index cec649b..9c7f2c3 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -39,21 +39,23 @@
VirtualSocket(VirtualSocketServer* server, int family, int type);
~VirtualSocket() override;
- SocketAddress GetLocalAddress() const override;
- SocketAddress GetRemoteAddress() const override;
+ webrtc::SocketAddress GetLocalAddress() const override;
+ webrtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const SocketAddress& addr) override;
- int Connect(const SocketAddress& addr) override;
+ int Bind(const webrtc::SocketAddress& addr) override;
+ int Connect(const webrtc::SocketAddress& addr) override;
int Close() override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
+ int SendTo(const void* pv,
+ size_t cb,
+ const webrtc::SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override;
int RecvFrom(void* pv,
size_t cb,
- SocketAddress* paddr,
+ webrtc::SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- VirtualSocket* Accept(SocketAddress* paddr) override;
+ VirtualSocket* Accept(webrtc::SocketAddress* paddr) override;
int GetError() const override;
void SetError(int error) override;
@@ -66,7 +68,7 @@
const char* send_buffer_data() const { return send_buffer_.data(); }
// Used by server sockets to set the local address without binding.
- void SetLocalAddress(const SocketAddress& addr);
+ void SetLocalAddress(const webrtc::SocketAddress& addr);
bool was_any() { return was_any_; }
void set_was_any(bool was_any) { was_any_ = was_any; }
@@ -88,7 +90,8 @@
void PostPacket(webrtc::TimeDelta delay,
std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay, const SocketAddress& remote_addr);
+ void PostConnect(webrtc::TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr);
void PostDisconnect(webrtc::TimeDelta delay);
private:
@@ -108,25 +111,26 @@
// Copies up to `size` bytes into buffer from the next received packet
// and fills `addr` with remote address of that received packet.
// Returns number of bytes copied or negative value on failure.
- int RecvFrom(void* buffer, size_t size, SocketAddress& addr);
+ int RecvFrom(void* buffer, size_t size, webrtc::SocketAddress& addr);
void Listen();
struct AcceptResult {
int error = 0;
std::unique_ptr<VirtualSocket> socket;
- SocketAddress remote_addr;
+ webrtc::SocketAddress remote_addr;
};
AcceptResult Accept();
bool AddPacket(std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay, const SocketAddress& remote_addr);
+ void PostConnect(webrtc::TimeDelta delay,
+ const webrtc::SocketAddress& remote_addr);
private:
enum class Signal { kNone, kReadEvent, kConnectEvent };
// `PostConnect` rely on the fact that std::list iterators are not
// invalidated on any changes to other elements in the container.
- using PostedConnects = std::list<SocketAddress>;
+ using PostedConnects = std::list<webrtc::SocketAddress>;
void PostSignalReadEvent() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void MaybeSignalReadEvent();
@@ -153,7 +157,7 @@
RTC_GUARDED_BY(mutex_);
// Pending sockets which can be Accepted
- std::optional<std::deque<SocketAddress>> listen_queue_
+ std::optional<std::deque<webrtc::SocketAddress>> listen_queue_
RTC_GUARDED_BY(mutex_);
};
@@ -166,9 +170,9 @@
typedef std::vector<char> SendBuffer;
typedef std::map<Option, int> OptionsMap;
- int InitiateConnect(const SocketAddress& addr, bool use_delay);
- void CompleteConnect(const SocketAddress& addr);
- int SendUdp(const void* pv, size_t cb, const SocketAddress& addr);
+ int InitiateConnect(const webrtc::SocketAddress& addr, bool use_delay);
+ void CompleteConnect(const webrtc::SocketAddress& addr);
+ int SendUdp(const void* pv, size_t cb, const webrtc::SocketAddress& addr);
int SendTcp(const void* pv, size_t cb);
void OnSocketServerReadyToSend();
@@ -177,8 +181,8 @@
const int type_;
ConnState state_;
int error_;
- SocketAddress local_addr_;
- SocketAddress remote_addr_;
+ webrtc::SocketAddress local_addr_;
+ webrtc::SocketAddress remote_addr_;
const scoped_refptr<SafetyBlock> safety_ =
make_ref_counted<SafetyBlock>(this);
@@ -289,7 +293,7 @@
bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
- void SetDelayOnAddress(const rtc::SocketAddress& address, int delay_ms) {
+ void SetDelayOnAddress(const webrtc::SocketAddress& address, int delay_ms) {
delay_by_ip_[address.ipaddr()] = delay_ms;
}
@@ -320,8 +324,8 @@
// Close a pair of Tcp connections by addresses. Both connections will have
// its own OnClose invoked.
- bool CloseTcpConnections(const SocketAddress& addr_local,
- const SocketAddress& addr_remote);
+ bool CloseTcpConnections(const webrtc::SocketAddress& addr_local,
+ const webrtc::SocketAddress& addr_remote);
// Number of packets that clients have attempted to send through this virtual
// socket server. Intended to be used for test assertions.
@@ -329,44 +333,45 @@
// Assign IP and Port if application's address is unspecified. Also apply
// `alternative_address_mapping_`.
- SocketAddress AssignBindAddress(const SocketAddress& app_addr);
+ webrtc::SocketAddress AssignBindAddress(
+ const webrtc::SocketAddress& app_addr);
// Binds the given socket to the given (fully-defined) address.
- int Bind(VirtualSocket* socket, const SocketAddress& addr);
+ int Bind(VirtualSocket* socket, const webrtc::SocketAddress& addr);
- int Unbind(const SocketAddress& addr, VirtualSocket* socket);
+ int Unbind(const webrtc::SocketAddress& addr, VirtualSocket* socket);
// Adds a mapping between this socket pair and the socket.
- void AddConnection(const SocketAddress& client,
- const SocketAddress& server,
+ void AddConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server,
VirtualSocket* socket);
// Connects the given socket to the socket at the given address
int Connect(VirtualSocket* socket,
- const SocketAddress& remote_addr,
+ const webrtc::SocketAddress& remote_addr,
bool use_delay);
// Sends a disconnect message to the socket at the given address
bool Disconnect(VirtualSocket* socket);
// Lookup address, and disconnect corresponding socket.
- bool Disconnect(const SocketAddress& addr);
+ bool Disconnect(const webrtc::SocketAddress& addr);
// Lookup connection, close corresponding socket.
- bool Disconnect(const SocketAddress& local_addr,
- const SocketAddress& remote_addr);
+ bool Disconnect(const webrtc::SocketAddress& local_addr,
+ const webrtc::SocketAddress& remote_addr);
// Sends the given packet to the socket at the given address (if one exists).
int SendUdp(VirtualSocket* socket,
const char* data,
size_t data_size,
- const SocketAddress& remote_addr);
+ const webrtc::SocketAddress& remote_addr);
// Moves as much data as possible from the sender's buffer to the network
void SendTcp(VirtualSocket* socket) RTC_LOCKS_EXCLUDED(mutex_);
// Like above, but lookup sender by address.
- void SendTcp(const SocketAddress& addr) RTC_LOCKS_EXCLUDED(mutex_);
+ void SendTcp(const webrtc::SocketAddress& addr) RTC_LOCKS_EXCLUDED(mutex_);
// Computes the number of milliseconds required to send a packet of this size.
uint32_t SendDelay(uint32_t size) RTC_LOCKS_EXCLUDED(mutex_);
@@ -379,18 +384,18 @@
webrtc::IPAddress GetNextIP(int family);
// Find the socket bound to the given address
- VirtualSocket* LookupBinding(const SocketAddress& addr);
+ VirtualSocket* LookupBinding(const webrtc::SocketAddress& addr);
private:
friend VirtualSocket;
uint16_t GetNextPort();
// Find the socket pair corresponding to this server address.
- VirtualSocket* LookupConnection(const SocketAddress& client,
- const SocketAddress& server);
+ VirtualSocket* LookupConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server);
- void RemoveConnection(const SocketAddress& client,
- const SocketAddress& server);
+ void RemoveConnection(const webrtc::SocketAddress& client,
+ const webrtc::SocketAddress& server);
// Places a packet on the network.
void AddPacketToNetwork(VirtualSocket* socket,
@@ -433,7 +438,7 @@
// NB: This scheme doesn't permit non-dualstack IPv6 sockets.
static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
- typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
+ typedef std::map<webrtc::SocketAddress, VirtualSocket*> AddressMap;
typedef std::map<webrtc::SocketAddressPair, VirtualSocket*> ConnectionMap;
// May be null if the test doesn't use a fake clock, or it does but doesn't
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index a9beba3..fd8186d 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -153,8 +153,8 @@
kIPv4AnyAddress(webrtc::IPAddress(INADDR_ANY), 0),
kIPv6AnyAddress(webrtc::IPAddress(in6addr_any), 0) {}
- void CheckPortIncrementalization(const SocketAddress& post,
- const SocketAddress& pre) {
+ void CheckPortIncrementalization(const webrtc::SocketAddress& post,
+ const webrtc::SocketAddress& pre) {
EXPECT_EQ(post.port(), pre.port() + 1);
webrtc::IPAddress post_ip = post.ipaddr();
webrtc::IPAddress pre_ip = pre.ipaddr();
@@ -180,37 +180,38 @@
// Create client1 bound to the any address.
Socket* socket = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket->Bind(EmptySocketAddressWithFamily(default_address.family()));
- SocketAddress client1_any_addr = socket->GetLocalAddress();
+ socket->Bind(
+ webrtc::EmptySocketAddressWithFamily(default_address.family()));
+ webrtc::SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
auto client1 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the address route.
Socket* socket2 = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
- socket2->Bind(SocketAddress(default_address, 0));
- SocketAddress client2_addr = socket2->GetLocalAddress();
+ socket2->Bind(webrtc::SocketAddress(default_address, 0));
+ webrtc::SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
// Client1 sends to client2, client2 should see the default address as
// client1's address.
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr,
- SocketAddress(default_address, client1_any_addr.port()));
+ webrtc::SocketAddress(default_address, client1_any_addr.port()));
// Client2 can send back to client1's default address.
EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
}
- void BasicTest(const SocketAddress& initial_addr) {
+ void BasicTest(const webrtc::SocketAddress& initial_addr) {
Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
- SocketAddress server_addr = socket->GetLocalAddress();
+ webrtc::SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
@@ -220,27 +221,28 @@
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
- SocketAddress client2_addr;
+ webrtc::SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, server_addr);
- SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress empty =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
client2 = std::make_unique<webrtc::TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
- SocketAddress next_client2_addr;
+ webrtc::SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
CheckPortIncrementalization(next_client2_addr, client2_addr);
// EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
- SocketAddress server_addr2;
+ webrtc::SocketAddress server_addr2;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
EXPECT_EQ(server_addr2, server_addr);
@@ -250,11 +252,11 @@
}
// initial_addr should be made from either INADDR_ANY or in6addr_any.
- void ConnectTest(const SocketAddress& initial_addr) {
+ void ConnectTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress kEmptyAddr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress kEmptyAddr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
std::unique_ptr<Socket> client =
@@ -318,12 +320,12 @@
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
- void ConnectToNonListenerTest(const SocketAddress& initial_addr) {
+ void ConnectToNonListenerTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress nil_addr;
- const SocketAddress empty_addr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress nil_addr;
+ const webrtc::SocketAddress empty_addr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
std::unique_ptr<Socket> client =
@@ -353,11 +355,11 @@
EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
}
- void CloseDuringConnectTest(const SocketAddress& initial_addr) {
+ void CloseDuringConnectTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- SocketAddress accept_addr;
- const SocketAddress empty_addr =
- EmptySocketAddressWithFamily(initial_addr.family());
+ webrtc::SocketAddress accept_addr;
+ const webrtc::SocketAddress empty_addr =
+ webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
std::unique_ptr<Socket> client(
@@ -440,9 +442,9 @@
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
- void CloseTest(const SocketAddress& initial_addr) {
+ void CloseTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- const SocketAddress kEmptyAddr;
+ const webrtc::SocketAddress kEmptyAddr;
// Create clients
std::unique_ptr<Socket> a =
@@ -490,9 +492,9 @@
EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
}
- void TcpSendTest(const SocketAddress& initial_addr) {
+ void TcpSendTest(const webrtc::SocketAddress& initial_addr) {
StreamSink sink;
- const SocketAddress kEmptyAddr;
+ const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
std::unique_ptr<Socket> a =
@@ -613,8 +615,8 @@
EXPECT_EQ(0, memcmp(recv_buffer, send_buffer, kDataSize));
}
- void TcpSendsPacketsInOrderTest(const SocketAddress& initial_addr) {
- const SocketAddress kEmptyAddr;
+ void TcpSendsPacketsInOrderTest(const webrtc::SocketAddress& initial_addr) {
+ const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
std::unique_ptr<Socket> a =
@@ -670,7 +672,7 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void BandwidthTest(const SocketAddress& initial_addr) {
+ void BandwidthTest(const webrtc::SocketAddress& initial_addr) {
Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
@@ -702,7 +704,7 @@
// It is important that initial_addr's port has to be 0 such that the
// incremental port behavior could ensure the 2 Binds result in different
// address.
- void DelayTest(const SocketAddress& initial_addr) {
+ void DelayTest(const webrtc::SocketAddress& initial_addr) {
time_t seed = ::time(nullptr);
RTC_LOG(LS_VERBOSE) << "seed = " << seed;
srand(static_cast<unsigned int>(seed));
@@ -757,12 +759,12 @@
// Test cross-family communication between a client bound to client_addr and a
// server bound to server_addr. shouldSucceed indicates if communication is
// expected to work or not.
- void CrossFamilyConnectionTest(const SocketAddress& client_addr,
- const SocketAddress& server_addr,
+ void CrossFamilyConnectionTest(const webrtc::SocketAddress& client_addr,
+ const webrtc::SocketAddress& server_addr,
bool shouldSucceed) {
StreamSink sink;
- SocketAddress accept_address;
- const SocketAddress kEmptyAddr;
+ webrtc::SocketAddress accept_address;
+ const webrtc::SocketAddress kEmptyAddr;
// Client gets a IPv4 address
std::unique_ptr<Socket> client =
@@ -808,12 +810,12 @@
// Test cross-family datagram sending between a client bound to client_addr
// and a server bound to server_addr. shouldSucceed indicates if sending is
// expected to succeed or not.
- void CrossFamilyDatagramTest(const SocketAddress& client_addr,
- const SocketAddress& server_addr,
+ void CrossFamilyDatagramTest(const webrtc::SocketAddress& client_addr,
+ const webrtc::SocketAddress& server_addr,
bool shouldSucceed) {
Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
- SocketAddress bound_server_addr = socket->GetLocalAddress();
+ webrtc::SocketAddress bound_server_addr = socket->GetLocalAddress();
auto client1 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
@@ -821,12 +823,12 @@
socket2->Bind(client_addr);
auto client2 = std::make_unique<webrtc::TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
- SocketAddress client2_addr;
+ webrtc::SocketAddress client2_addr;
if (shouldSucceed) {
EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
- SocketAddress client1_addr;
+ webrtc::SocketAddress client1_addr;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
EXPECT_EQ(client1_addr, bound_server_addr);
@@ -840,17 +842,17 @@
rtc::ScopedFakeClock fake_clock_;
VirtualSocketServer ss_;
AutoSocketServerThread thread_;
- const SocketAddress kIPv4AnyAddress;
- const SocketAddress kIPv6AnyAddress;
+ const webrtc::SocketAddress kIPv4AnyAddress;
+ const webrtc::SocketAddress kIPv6AnyAddress;
};
TEST_F(VirtualSocketServerTest, basic_v4) {
- SocketAddress ipv4_test_addr(webrtc::IPAddress(INADDR_ANY), 5000);
+ webrtc::SocketAddress ipv4_test_addr(webrtc::IPAddress(INADDR_ANY), 5000);
BasicTest(ipv4_test_addr);
}
TEST_F(VirtualSocketServerTest, basic_v6) {
- SocketAddress ipv6_test_addr(webrtc::IPAddress(in6addr_any), 5000);
+ webrtc::SocketAddress ipv6_test_addr(webrtc::IPAddress(in6addr_any), 5000);
BasicTest(ipv6_test_addr);
}
@@ -932,90 +934,94 @@
// Works, receiving socket sees 127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::ffff:127.0.0.2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::2", 0),
- SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), false);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("::2", 0),
- SocketAddress("::ffff:127.0.0.1", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
}
// Works. receiving socket sees ::ffff:127.0.0.2.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
// Fails.
TEST_F(VirtualSocketServerTest, CantConnectFromIPv4ToUnMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::1", 5000), false);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::1", 5000), false);
}
// Works. Receiving socket sees ::ffff:127.0.0.1.
TEST_F(VirtualSocketServerTest, CanConnectFromIPv4ToMappedIPv6) {
- CrossFamilyConnectionTest(SocketAddress("127.0.0.1", 0),
- SocketAddress("::ffff:127.0.0.2", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("127.0.0.1", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
}
// Works, receiving socket sees a result from GetNextIP.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv6ToIPv4Any) {
- CrossFamilyConnectionTest(SocketAddress("::", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("::", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
// Works, receiving socket sees whatever GetNextIP gave the client.
TEST_F(VirtualSocketServerTest, CanConnectFromUnboundIPv4ToIPv6Any) {
- CrossFamilyConnectionTest(SocketAddress("0.0.0.0", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyConnectionTest(webrtc::SocketAddress("0.0.0.0", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(SocketAddress("0.0.0.0", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("0.0.0.0", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::ffff:127.0.0.1", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::ffff:127.0.0.1", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::2", 0),
- SocketAddress("0.0.0.0", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), false);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromUnMappedIPv6ToMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("::2", 0),
- SocketAddress("::ffff:127.0.0.1", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::2", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.1", 5000),
+ false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToIPv6Any) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::", 5000), true);
}
TEST_F(VirtualSocketServerTest, CantSendDatagramFromIPv4ToUnMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.2", 0),
- SocketAddress("::1", 5000), false);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.2", 0),
+ webrtc::SocketAddress("::1", 5000), false);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromIPv4ToMappedIPv6) {
- CrossFamilyDatagramTest(SocketAddress("127.0.0.1", 0),
- SocketAddress("::ffff:127.0.0.2", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("127.0.0.1", 0),
+ webrtc::SocketAddress("::ffff:127.0.0.2", 5000),
+ true);
}
TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
- CrossFamilyDatagramTest(SocketAddress("::", 0),
- SocketAddress("0.0.0.0", 5000), true);
+ CrossFamilyDatagramTest(webrtc::SocketAddress("::", 0),
+ webrtc::SocketAddress("0.0.0.0", 5000), true);
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
diff --git a/rtc_tools/network_tester/test_controller.cc b/rtc_tools/network_tester/test_controller.cc
index ede2759..d5cd499 100644
--- a/rtc_tools/network_tester/test_controller.cc
+++ b/rtc_tools/network_tester/test_controller.cc
@@ -44,7 +44,7 @@
RTC_DCHECK_RUN_ON(packet_sender_thread_.get());
udp_socket_ =
std::unique_ptr<rtc::AsyncPacketSocket>(socket_factory_.CreateUdpSocket(
- rtc::SocketAddress(GetAnyIP(AF_INET), 0), min_port, max_port));
+ SocketAddress(GetAnyIP(AF_INET), 0), min_port, max_port));
RTC_CHECK(udp_socket_ != nullptr);
udp_socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
@@ -61,7 +61,7 @@
void TestController::SendConnectTo(const std::string& hostname, int port) {
RTC_DCHECK_RUN_ON(&test_controller_thread_checker_);
- remote_address_ = rtc::SocketAddress(hostname, port);
+ remote_address_ = SocketAddress(hostname, port);
NetworkTesterPacket packet;
packet.set_type(NetworkTesterPacket::HAND_SHAKING);
SendData(packet, std::nullopt);
diff --git a/rtc_tools/network_tester/test_controller.h b/rtc_tools/network_tester/test_controller.h
index ce4d793..0c77fea 100644
--- a/rtc_tools/network_tester/test_controller.h
+++ b/rtc_tools/network_tester/test_controller.h
@@ -80,7 +80,7 @@
RTC_GUARDED_BY(packet_sender_thread_);
std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_
RTC_GUARDED_BY(packet_sender_thread_);
- rtc::SocketAddress remote_address_;
+ SocketAddress remote_address_;
std::unique_ptr<PacketSender> packet_sender_
RTC_GUARDED_BY(packet_sender_thread_);
rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> task_safety_flag_;
diff --git a/test/network/emulated_turn_server.cc b/test/network/emulated_turn_server.cc
index 3e8fa71..49b29e4 100644
--- a/test/network/emulated_turn_server.cc
+++ b/test/network/emulated_turn_server.cc
@@ -48,22 +48,22 @@
// This method is called from TurnServer when making a TURN ALLOCATION.
// It will create a socket on the `peer_` endpoint.
- rtc::AsyncPacketSocket* CreateUdpSocket(const rtc::SocketAddress& address,
+ rtc::AsyncPacketSocket* CreateUdpSocket(const webrtc::SocketAddress& address,
uint16_t min_port,
uint16_t max_port) override {
return turn_server_->CreatePeerSocket();
}
rtc::AsyncListenSocket* CreateServerTcpSocket(
- const rtc::SocketAddress& local_address,
+ const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) override {
return nullptr;
}
rtc::AsyncPacketSocket* CreateClientTcpSocket(
- const rtc::SocketAddress& local_address,
- const rtc::SocketAddress& remote_address,
+ const webrtc::SocketAddress& local_address,
+ const webrtc::SocketAddress& remote_address,
const rtc::PacketSocketTcpOptions& tcp_options) override {
return nullptr;
}
@@ -92,14 +92,11 @@
uint16_t port)
: turn_server_(turn_server),
endpoint_(endpoint),
- local_address_(
- rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), port)) {}
+ local_address_(SocketAddress(endpoint_->GetPeerLocalAddress(), port)) {}
~AsyncPacketSocketWrapper() { turn_server_->Unbind(local_address_); }
- rtc::SocketAddress GetLocalAddress() const override { return local_address_; }
- rtc::SocketAddress GetRemoteAddress() const override {
- return rtc::SocketAddress();
- }
+ SocketAddress GetLocalAddress() const override { return local_address_; }
+ SocketAddress GetRemoteAddress() const override { return SocketAddress(); }
int Send(const void* pv,
size_t cb,
const rtc::PacketOptions& options) override {
@@ -108,7 +105,7 @@
}
int SendTo(const void* pv,
size_t cb,
- const rtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options) override {
// Copy from rtc::AsyncPacketSocket to EmulatedEndpoint.
rtc::CopyOnWriteBuffer buf(reinterpret_cast<const char*>(pv), cb);
@@ -131,7 +128,7 @@
private:
webrtc::test::EmulatedTURNServer* const turn_server_;
webrtc::EmulatedEndpoint* const endpoint_;
- const rtc::SocketAddress local_address_;
+ const SocketAddress local_address_;
};
EmulatedTURNServer::EmulatedTURNServer(const EmulatedTURNServerConfig& config,
@@ -153,7 +150,7 @@
auto client_socket = Wrap(client_);
turn_server_->AddInternalSocket(client_socket, cricket::PROTO_UDP);
turn_server_->SetExternalSocketFactory(new PacketSocketFactoryWrapper(this),
- rtc::SocketAddress());
+ SocketAddress());
client_address_ = client_socket->GetLocalAddress();
char buf[256];
rtc::SimpleStringBuilder str(buf);
@@ -181,7 +178,7 @@
RTC_DCHECK_RUN_ON(thread_.get());
auto port = endpoint->BindReceiver(0, this).value();
auto socket = new AsyncPacketSocketWrapper(this, endpoint, port);
- sockets_[rtc::SocketAddress(endpoint->GetPeerLocalAddress(), port)] = socket;
+ sockets_[SocketAddress(endpoint->GetPeerLocalAddress(), port)] = socket;
return socket;
}
@@ -197,7 +194,7 @@
});
}
-void EmulatedTURNServer::Unbind(rtc::SocketAddress address) {
+void EmulatedTURNServer::Unbind(SocketAddress address) {
RTC_DCHECK_RUN_ON(thread_.get());
if (GetClientEndpoint()->GetPeerLocalAddress() == address.ipaddr()) {
GetClientEndpoint()->UnbindReceiver(address.port());
diff --git a/test/network/emulated_turn_server.h b/test/network/emulated_turn_server.h
index aa91ecc..fed93aa 100644
--- a/test/network/emulated_turn_server.h
+++ b/test/network/emulated_turn_server.h
@@ -56,7 +56,7 @@
EmulatedEndpoint* GetClientEndpoint() const override { return client_; }
- rtc::SocketAddress GetClientEndpointAddress() const override {
+ SocketAddress GetClientEndpointAddress() const override {
return client_address_;
}
@@ -77,20 +77,20 @@
void OnPacketReceived(webrtc::EmulatedIpPacket packet) override;
// This is called when the TURN server deletes a socket.
- void Unbind(rtc::SocketAddress address);
+ void Unbind(SocketAddress address);
// Unbind all sockets.
void Stop();
private:
std::unique_ptr<rtc::Thread> thread_;
- rtc::SocketAddress client_address_;
+ SocketAddress client_address_;
IceServerConfig ice_config_;
EmulatedEndpoint* const client_;
EmulatedEndpoint* const peer_;
std::unique_ptr<cricket::TurnServer> turn_server_ RTC_GUARDED_BY(&thread_);
class AsyncPacketSocketWrapper;
- std::map<rtc::SocketAddress, AsyncPacketSocketWrapper*> sockets_
+ std::map<SocketAddress, AsyncPacketSocketWrapper*> sockets_
RTC_GUARDED_BY(&thread_);
// Wraps a EmulatedEndpoint in a AsyncPacketSocket to bridge interaction
diff --git a/test/network/fake_network_socket_server.cc b/test/network/fake_network_socket_server.cc
index 885ba1e..16fac0b 100644
--- a/test/network/fake_network_socket_server.cc
+++ b/test/network/fake_network_socket_server.cc
@@ -41,7 +41,7 @@
namespace webrtc {
namespace test {
namespace {
-std::string ToString(const rtc::SocketAddress& addr) {
+std::string ToString(const SocketAddress& addr) {
return addr.HostAsURIString() + ":" + std::to_string(addr.port());
}
@@ -59,22 +59,20 @@
void OnPacketReceived(EmulatedIpPacket packet) override;
// rtc::Socket methods:
- rtc::SocketAddress GetLocalAddress() const override;
- rtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const rtc::SocketAddress& addr) override;
- int Connect(const rtc::SocketAddress& addr) override;
+ SocketAddress GetLocalAddress() const override;
+ SocketAddress GetRemoteAddress() const override;
+ int Bind(const SocketAddress& addr) override;
+ int Connect(const SocketAddress& addr) override;
int Close() override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv,
- size_t cb,
- const rtc::SocketAddress& addr) override;
+ int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
int Recv(void* pv, size_t cb, int64_t* timestamp) override {
RTC_DCHECK_NOTREACHED() << " Use RecvFrom instead.";
return 0;
}
int RecvFrom(ReceiveBuffer& buffer) override;
int Listen(int backlog) override;
- rtc::Socket* Accept(rtc::SocketAddress* paddr) override;
+ rtc::Socket* Accept(SocketAddress* paddr) override;
int GetError() const override;
void SetError(int error) override;
ConnState GetState() const override;
@@ -85,8 +83,8 @@
FakeNetworkSocketServer* const socket_server_;
rtc::Thread* const thread_;
EmulatedEndpointImpl* endpoint_ RTC_GUARDED_BY(&thread_);
- rtc::SocketAddress local_addr_ RTC_GUARDED_BY(&thread_);
- rtc::SocketAddress remote_addr_ RTC_GUARDED_BY(&thread_);
+ SocketAddress local_addr_ RTC_GUARDED_BY(&thread_);
+ SocketAddress remote_addr_ RTC_GUARDED_BY(&thread_);
ConnState state_ RTC_GUARDED_BY(&thread_);
int error_ RTC_GUARDED_BY(&thread_);
std::map<Option, int> options_map_ RTC_GUARDED_BY(&thread_);
@@ -129,17 +127,17 @@
socket_server_->WakeUp();
}
-rtc::SocketAddress FakeNetworkSocket::GetLocalAddress() const {
+SocketAddress FakeNetworkSocket::GetLocalAddress() const {
RTC_DCHECK_RUN_ON(thread_);
return local_addr_;
}
-rtc::SocketAddress FakeNetworkSocket::GetRemoteAddress() const {
+SocketAddress FakeNetworkSocket::GetRemoteAddress() const {
RTC_DCHECK_RUN_ON(thread_);
return remote_addr_;
}
-int FakeNetworkSocket::Bind(const rtc::SocketAddress& addr) {
+int FakeNetworkSocket::Bind(const SocketAddress& addr) {
RTC_DCHECK_RUN_ON(thread_);
RTC_CHECK(local_addr_.IsNil())
<< "Socket already bound to address: " << ToString(local_addr_);
@@ -163,7 +161,7 @@
return 0;
}
-int FakeNetworkSocket::Connect(const rtc::SocketAddress& addr) {
+int FakeNetworkSocket::Connect(const SocketAddress& addr) {
RTC_DCHECK_RUN_ON(thread_);
RTC_CHECK(remote_addr_.IsNil())
<< "Socket already connected to address: " << ToString(remote_addr_);
@@ -182,7 +180,7 @@
int FakeNetworkSocket::SendTo(const void* pv,
size_t cb,
- const rtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
RTC_DCHECK_RUN_ON(thread_);
RTC_CHECK(!local_addr_.IsNil())
<< "Socket have to be bind to some local address";
@@ -217,7 +215,7 @@
RTC_CHECK(false) << "Listen() isn't valid for SOCK_DGRAM";
}
-rtc::Socket* FakeNetworkSocket::Accept(rtc::SocketAddress* /*paddr*/) {
+rtc::Socket* FakeNetworkSocket::Accept(SocketAddress* /*paddr*/) {
RTC_CHECK(false) << "Accept() isn't valid for SOCK_DGRAM";
}
diff --git a/test/network/network_emulation.cc b/test/network/network_emulation.cc
index 707d407..73d30b6 100644
--- a/test/network/network_emulation.cc
+++ b/test/network/network_emulation.cc
@@ -628,8 +628,8 @@
return options_.id;
}
-void EmulatedEndpointImpl::SendPacket(const rtc::SocketAddress& from,
- const rtc::SocketAddress& to,
+void EmulatedEndpointImpl::SendPacket(const SocketAddress& from,
+ const SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead,
EcnMarking ecn) {
diff --git a/test/network/network_emulation.h b/test/network/network_emulation.h
index 364d47d..f0e0127 100644
--- a/test/network/network_emulation.h
+++ b/test/network/network_emulation.h
@@ -293,8 +293,8 @@
NetworkRouterNode* router() { return &router_; }
- void SendPacket(const rtc::SocketAddress& from,
- const rtc::SocketAddress& to,
+ void SendPacket(const SocketAddress& from,
+ const SocketAddress& to,
rtc::CopyOnWriteBuffer packet_data,
uint16_t application_overhead = 0,
EcnMarking ecn = EcnMarking::kNotEct) override;
@@ -426,8 +426,8 @@
private:
EmulatedRoute* const route_;
const std::function<void(FakePacketType, Timestamp)> action_;
- const rtc::SocketAddress send_addr_;
- const rtc::SocketAddress recv_addr_;
+ const SocketAddress send_addr_;
+ const SocketAddress recv_addr_;
int next_packet_id_ = 0;
std::map<int, FakePacketType> sent_;
};
diff --git a/test/network/network_emulation_unittest.cc b/test/network/network_emulation_unittest.cc
index b4c99ed..bde398a 100644
--- a/test/network/network_emulation_unittest.cc
+++ b/test/network/network_emulation_unittest.cc
@@ -154,28 +154,24 @@
// Next code is using API of EmulatedEndpoint, that is visible only for
// internals of network emulation layer. Don't use this API in other tests.
// Send packet from e1 to e2.
- e1_->SendPacket(
- rtc::SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
- rtc::SocketAddress(e2_->GetPeerLocalAddress(), r_e1_e2_port),
- rtc::CopyOnWriteBuffer(10));
+ e1_->SendPacket(SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
+ SocketAddress(e2_->GetPeerLocalAddress(), r_e1_e2_port),
+ rtc::CopyOnWriteBuffer(10));
// Send packet from e2 to e1.
- e2_->SendPacket(
- rtc::SocketAddress(e2_->GetPeerLocalAddress(), common_send_port),
- rtc::SocketAddress(e1_->GetPeerLocalAddress(), r_e2_e1_port),
- rtc::CopyOnWriteBuffer(10));
+ e2_->SendPacket(SocketAddress(e2_->GetPeerLocalAddress(), common_send_port),
+ SocketAddress(e1_->GetPeerLocalAddress(), r_e2_e1_port),
+ rtc::CopyOnWriteBuffer(10));
// Send packet from e1 to e3.
- e1_->SendPacket(
- rtc::SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
- rtc::SocketAddress(e3_->GetPeerLocalAddress(), r_e1_e3_port),
- rtc::CopyOnWriteBuffer(10));
+ e1_->SendPacket(SocketAddress(e1_->GetPeerLocalAddress(), common_send_port),
+ SocketAddress(e3_->GetPeerLocalAddress(), r_e1_e3_port),
+ rtc::CopyOnWriteBuffer(10));
// Send packet from e3 to e1.
- e3_->SendPacket(
- rtc::SocketAddress(e3_->GetPeerLocalAddress(), common_send_port),
- rtc::SocketAddress(e1_->GetPeerLocalAddress(), r_e3_e1_port),
- rtc::CopyOnWriteBuffer(10));
+ e3_->SendPacket(SocketAddress(e3_->GetPeerLocalAddress(), common_send_port),
+ SocketAddress(e1_->GetPeerLocalAddress(), r_e3_e1_port),
+ rtc::CopyOnWriteBuffer(10));
// Sleep at the end to wait for async packets delivery.
emulation_.time_controller()->AdvanceTime(kNetworkPacketWaitTimeout);
@@ -269,8 +265,8 @@
SocketReader r1(s1, t1);
SocketReader r2(s2, t2);
- rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
- rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
SendTask(t1, [&] {
s1->Bind(a1);
@@ -420,8 +416,8 @@
SocketReader r1(s1, t1);
SocketReader r2(s2, t2);
- rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
- rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
SendTask(t1, [&] {
s1->Bind(a1);
@@ -510,8 +506,8 @@
SocketReader r1(s1, t1);
SocketReader r2(s2, t2);
- rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
- rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
SendTask(t1, [&] {
s1->Bind(a1);
@@ -611,8 +607,8 @@
SocketReader r1(s1, t1);
SocketReader r2(s2, t2);
- rtc::SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
- rtc::SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a1(alice_endpoint->GetPeerLocalAddress(), 0);
+ SocketAddress a2(bob_endpoint->GetPeerLocalAddress(), 0);
SendTask(t1, [&] {
s1->Bind(a1);
@@ -715,8 +711,8 @@
EXPECT_CALL(receiver, OnPacketReceived(::testing::_)).Times(1);
ASSERT_EQ(endpoint->BindReceiver(80, &receiver), 80);
- endpoint->SendPacket(rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
- rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
+ endpoint->SendPacket(SocketAddress(endpoint->GetPeerLocalAddress(), 80),
+ SocketAddress(endpoint->GetPeerLocalAddress(), 80),
"Hello");
network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
}
@@ -735,8 +731,8 @@
EXPECT_CALL(receiver, OnPacketReceived(::testing::_)).Times(1);
ASSERT_EQ(endpoint->BindReceiver(80, &receiver), 80);
- endpoint->SendPacket(rtc::SocketAddress(kSourceIp, 80),
- rtc::SocketAddress(endpoint->GetPeerLocalAddress(), 80),
+ endpoint->SendPacket(SocketAddress(kSourceIp, 80),
+ SocketAddress(endpoint->GetPeerLocalAddress(), 80),
"Hello");
network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
}
@@ -763,8 +759,8 @@
receiver_endpoint);
sender_endpoint->SendPacket(
- rtc::SocketAddress(sender_endpoint->GetPeerLocalAddress(), 80),
- rtc::SocketAddress(kDestIp, 80), "Hello");
+ SocketAddress(sender_endpoint->GetPeerLocalAddress(), 80),
+ SocketAddress(kDestIp, 80), "Hello");
network_manager.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
}
@@ -800,7 +796,7 @@
// We expect to get a ping reply.
EXPECT_CALL(recv, OnPacketReceived(::testing::_)).Times(1);
- ep->SendPacket(rtc::SocketAddress(ep->GetPeerLocalAddress(), port),
+ ep->SendPacket(SocketAddress(ep->GetPeerLocalAddress(), port),
turn->GetClientEndpointAddress(), packet);
emulation.time_controller()->AdvanceTime(TimeDelta::Seconds(1));
}
@@ -830,7 +826,7 @@
network_manager.time_controller()->GetClock()->TimeInMicroseconds() +
10));
link->OnPacketReceived(EmulatedIpPacket(
- rtc::SocketAddress(kEndpointIp, 50), rtc::SocketAddress(kEndpointIp, 79),
+ SocketAddress(kEndpointIp, 50), SocketAddress(kEndpointIp, 79),
rtc::CopyOnWriteBuffer(10), Timestamp::Millis(1)));
network_manager.time_controller()->AdvanceTime(TimeDelta::Zero());
diff --git a/test/network/traffic_route.cc b/test/network/traffic_route.cc
index 18d8ef5..1978c7a 100644
--- a/test/network/traffic_route.cc
+++ b/test/network/traffic_route.cc
@@ -87,8 +87,8 @@
rtc::CopyOnWriteBuffer data(packet_size);
std::fill_n(data.MutableData(), data.size(), 0);
receiver_->OnPacketReceived(EmulatedIpPacket(
- /*from=*/rtc::SocketAddress(),
- rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), data,
+ /*from=*/SocketAddress(),
+ SocketAddress(endpoint_->GetPeerLocalAddress(), dest_port), data,
clock_->CurrentTime()));
}
diff --git a/test/scenario/network_node.cc b/test/scenario/network_node.cc
index 9c44e08..0f174c7 100644
--- a/test/scenario/network_node.cc
+++ b/test/scenario/network_node.cc
@@ -118,7 +118,7 @@
}
void NetworkNodeTransport::Connect(EmulatedEndpoint* endpoint,
- const rtc::SocketAddress& receiver_address,
+ const SocketAddress& receiver_address,
DataSize packet_overhead) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
rtc::NetworkRoute route;
@@ -140,7 +140,7 @@
RTC_CHECK_EQ(receiver_address.family(), AF_INET);
MutexLock lock(&mutex_);
endpoint_ = endpoint;
- local_address_ = rtc::SocketAddress(endpoint_->GetPeerLocalAddress(), 0);
+ local_address_ = SocketAddress(endpoint_->GetPeerLocalAddress(), 0);
remote_address_ = receiver_address;
packet_overhead_ = packet_overhead;
current_network_route_ = route;
diff --git a/test/scenario/network_node.h b/test/scenario/network_node.h
index 21ee5a1..6e1ba36 100644
--- a/test/scenario/network_node.h
+++ b/test/scenario/network_node.h
@@ -65,7 +65,7 @@
bool SendRtcp(rtc::ArrayView<const uint8_t> packet) override;
void Connect(EmulatedEndpoint* endpoint,
- const rtc::SocketAddress& receiver_address,
+ const SocketAddress& receiver_address,
DataSize packet_overhead);
void Disconnect();
@@ -82,8 +82,8 @@
Clock* const sender_clock_;
Call* const sender_call_;
EmulatedEndpoint* endpoint_ RTC_GUARDED_BY(mutex_) = nullptr;
- rtc::SocketAddress local_address_ RTC_GUARDED_BY(mutex_);
- rtc::SocketAddress remote_address_ RTC_GUARDED_BY(mutex_);
+ SocketAddress local_address_ RTC_GUARDED_BY(mutex_);
+ SocketAddress remote_address_ RTC_GUARDED_BY(mutex_);
DataSize packet_overhead_ RTC_GUARDED_BY(mutex_) = DataSize::Zero();
rtc::NetworkRoute current_network_route_ RTC_GUARDED_BY(mutex_);
};
diff --git a/test/scenario/scenario.cc b/test/scenario/scenario.cc
index 0ff5fc7..a506e0c 100644
--- a/test/scenario/scenario.cc
+++ b/test/scenario/scenario.cc
@@ -164,7 +164,7 @@
DataSize overhead) {
EmulatedRoute* route = network_manager_.CreateRoute(over_nodes);
uint16_t port = clients.second->Bind(route->to);
- auto addr = rtc::SocketAddress(route->to->GetPeerLocalAddress(), port);
+ auto addr = SocketAddress(route->to->GetPeerLocalAddress(), port);
clients.first->transport_->Connect(route->from, addr, overhead);
}
