Move socket related files to webrtc namespace
- socket_unittest.h
- socket.h
- physical_socket_server.h
- async_tcp_socket.h
- async_packet_socket.h
- virtual_socket_server.h
- null_socket_server.h
- packet_socket_factory.h
- async_udp_socket.h
- firewall_socket_server.h
- async_stun_tcp_socket.h
- socket_server.h
- server_socket_adapters.h
- socket_adapters.h
- basic_packet_socket_factory.h
- socket_factory.h
- async_socket.h
Bug: webrtc:42232595
Change-Id: If22aa5961174729eff8d5d3962994011d531d39c
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/381242
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#44159}
diff --git a/api/packet_socket_factory.h b/api/packet_socket_factory.h
index 8c5ea6f..e5470a6 100644
--- a/api/packet_socket_factory.h
+++ b/api/packet_socket_factory.h
@@ -20,11 +20,12 @@
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/system/rtc_export.h"
-
namespace rtc {
-
class SSLCertificateVerifier;
class AsyncResolverInterface;
+} // namespace rtc
+
+namespace webrtc {
struct PacketSocketTcpOptions {
PacketSocketTcpOptions() = default;
@@ -36,7 +37,7 @@
// An optional custom SSL certificate verifier that an API user can provide to
// inject their own certificate verification logic (not available to users
// outside of the WebRTC repo).
- SSLCertificateVerifier* tls_cert_verifier = nullptr;
+ rtc::SSLCertificateVerifier* tls_cert_verifier = nullptr;
};
class RTC_EXPORT PacketSocketFactory {
@@ -56,22 +57,21 @@
PacketSocketFactory() = default;
virtual ~PacketSocketFactory() = default;
- virtual AsyncPacketSocket* CreateUdpSocket(
- const webrtc::SocketAddress& address,
- uint16_t min_port,
- uint16_t max_port) = 0;
+ virtual AsyncPacketSocket* CreateUdpSocket(const SocketAddress& address,
+ uint16_t min_port,
+ uint16_t max_port) = 0;
virtual AsyncListenSocket* CreateServerTcpSocket(
- const webrtc::SocketAddress& local_address,
+ const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) = 0;
virtual AsyncPacketSocket* CreateClientTcpSocket(
- const webrtc::SocketAddress& local_address,
- const webrtc::SocketAddress& remote_address,
+ const SocketAddress& local_address,
+ const SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) = 0;
- virtual std::unique_ptr<webrtc::AsyncDnsResolverInterface>
+ virtual std::unique_ptr<AsyncDnsResolverInterface>
CreateAsyncDnsResolver() = 0;
private:
@@ -79,6 +79,13 @@
PacketSocketFactory& operator=(const PacketSocketFactory&) = delete;
};
+} // 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::PacketSocketFactory;
+using ::webrtc::PacketSocketTcpOptions;
} // namespace rtc
#endif // API_PACKET_SOCKET_FACTORY_H_
diff --git a/api/peer_connection_interface.h b/api/peer_connection_interface.h
index 65e9b18..93fb943 100644
--- a/api/peer_connection_interface.h
+++ b/api/peer_connection_interface.h
@@ -1438,10 +1438,10 @@
rtc::Thread* network_thread = nullptr;
rtc::Thread* worker_thread = nullptr;
rtc::Thread* signaling_thread = nullptr;
- rtc::SocketFactory* socket_factory = nullptr;
+ SocketFactory* socket_factory = nullptr;
// The `packet_socket_factory` will only be used if CreatePeerConnection is
// called without a `port_allocator`.
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory;
+ std::unique_ptr<PacketSocketFactory> packet_socket_factory;
std::unique_ptr<TaskQueueFactory> task_queue_factory;
std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
diff --git a/api/test/mock_packet_socket_factory.h b/api/test/mock_packet_socket_factory.h
index 0974297..bd42b3a 100644
--- a/api/test/mock_packet_socket_factory.h
+++ b/api/test/mock_packet_socket_factory.h
@@ -22,21 +22,21 @@
#include "test/gmock.h"
namespace webrtc {
-class MockPacketSocketFactory : public rtc::PacketSocketFactory {
+class MockPacketSocketFactory : public PacketSocketFactory {
public:
- MOCK_METHOD(rtc::AsyncPacketSocket*,
+ MOCK_METHOD(AsyncPacketSocket*,
CreateUdpSocket,
(const SocketAddress&, uint16_t, uint16_t),
(override));
- MOCK_METHOD(rtc::AsyncListenSocket*,
+ MOCK_METHOD(AsyncListenSocket*,
CreateServerTcpSocket,
(const SocketAddress&, uint16_t, uint16_t, int opts),
(override));
- MOCK_METHOD(rtc::AsyncPacketSocket*,
+ MOCK_METHOD(AsyncPacketSocket*,
CreateClientTcpSocket,
(const SocketAddress& local_address,
const SocketAddress&,
- const rtc::PacketSocketTcpOptions&),
+ const PacketSocketTcpOptions&),
(override));
MOCK_METHOD(std::unique_ptr<AsyncDnsResolverInterface>,
CreateAsyncDnsResolver,
diff --git a/api/test/pclf/media_quality_test_params.h b/api/test/pclf/media_quality_test_params.h
index 9a53913..657486d 100644
--- a/api/test/pclf/media_quality_test_params.h
+++ b/api/test/pclf/media_quality_test_params.h
@@ -57,7 +57,7 @@
// factories.
struct PeerConnectionFactoryComponents {
std::unique_ptr<rtc::NetworkManager> network_manager;
- rtc::SocketFactory* socket_factory = nullptr;
+ SocketFactory* socket_factory = nullptr;
std::unique_ptr<RtcEventLogFactoryInterface> event_log_factory;
std::unique_ptr<FecControllerFactoryInterface> fec_controller_factory;
std::unique_ptr<NetworkControllerFactoryInterface> network_controller_factory;
@@ -95,7 +95,7 @@
struct InjectableComponents {
InjectableComponents(rtc::Thread* network_thread,
std::unique_ptr<rtc::NetworkManager> network_manager,
- rtc::SocketFactory* socket_factory)
+ SocketFactory* socket_factory)
: network_thread(network_thread),
worker_thread(nullptr),
pcf_dependencies(std::make_unique<PeerConnectionFactoryComponents>()),
diff --git a/api/test/peer_network_dependencies.h b/api/test/peer_network_dependencies.h
index 7a072ad..c61fa14 100644
--- a/api/test/peer_network_dependencies.h
+++ b/api/test/peer_network_dependencies.h
@@ -28,7 +28,7 @@
virtual ~PeerNetworkDependencies() = default;
virtual absl::Nonnull<rtc::Thread*> network_thread() = 0;
- virtual absl::Nonnull<rtc::SocketFactory*> socket_factory() = 0;
+ virtual absl::Nonnull<SocketFactory*> socket_factory() = 0;
virtual absl::Nonnull<std::unique_ptr<rtc::NetworkManager>>
ReleaseNetworkManager() = 0;
};
diff --git a/api/test/time_controller.h b/api/test/time_controller.h
index a464f4d..b227df7 100644
--- a/api/test/time_controller.h
+++ b/api/test/time_controller.h
@@ -45,7 +45,7 @@
// Returned thread is not null and started.
virtual std::unique_ptr<rtc::Thread> CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server = nullptr) = 0;
+ std::unique_ptr<SocketServer> socket_server = nullptr) = 0;
// Creates an rtc::Thread instance that ensure that it's set as the current
// thread.
diff --git a/examples/stunserver/stunserver_main.cc b/examples/stunserver/stunserver_main.cc
index ec90361..28ae01b 100644
--- a/examples/stunserver/stunserver_main.cc
+++ b/examples/stunserver/stunserver_main.cc
@@ -32,8 +32,8 @@
rtc::Thread* pthMain = rtc::ThreadManager::Instance()->WrapCurrentThread();
RTC_DCHECK(pthMain);
- rtc::AsyncUDPSocket* server_socket =
- rtc::AsyncUDPSocket::Create(pthMain->socketserver(), server_addr);
+ webrtc::AsyncUDPSocket* server_socket =
+ webrtc::AsyncUDPSocket::Create(pthMain->socketserver(), server_addr);
if (!server_socket) {
std::cerr << "Failed to create a UDP socket" << std::endl;
return 1;
diff --git a/examples/turnserver/turnserver_main.cc b/examples/turnserver/turnserver_main.cc
index dd90ac5..4a58271 100644
--- a/examples/turnserver/turnserver_main.cc
+++ b/examples/turnserver/turnserver_main.cc
@@ -70,10 +70,10 @@
return 1;
}
- rtc::PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main(&socket_server);
- rtc::AsyncUDPSocket* int_socket =
- rtc::AsyncUDPSocket::Create(&socket_server, int_addr);
+ webrtc::AsyncUDPSocket* int_socket =
+ webrtc::AsyncUDPSocket::Create(&socket_server, int_addr);
if (!int_socket) {
std::cerr << "Failed to create a UDP socket bound at" << int_addr.ToString()
<< std::endl;
@@ -91,7 +91,7 @@
server.set_auth_hook(&auth);
server.AddInternalSocket(int_socket, cricket::PROTO_UDP);
server.SetExternalSocketFactory(
- new rtc::BasicPacketSocketFactory(&socket_server),
+ new webrtc::BasicPacketSocketFactory(&socket_server),
webrtc::SocketAddress(ext_addr, 0));
std::cout << "Listening internally at " << int_addr.ToString() << std::endl;
diff --git a/media/base/fake_network_interface.h b/media/base/fake_network_interface.h
index 678da58..f811033 100644
--- a/media/base/fake_network_interface.h
+++ b/media/base/fake_network_interface.h
@@ -155,14 +155,12 @@
return true;
}
- virtual int SetOption(SocketType /* type */,
- rtc::Socket::Option opt,
- int option) {
- if (opt == rtc::Socket::OPT_SNDBUF) {
+ virtual int SetOption(SocketType /* type */, Socket::Option opt, int option) {
+ if (opt == Socket::OPT_SNDBUF) {
sendbuf_size_ = option;
- } else if (opt == rtc::Socket::OPT_RCVBUF) {
+ } else if (opt == Socket::OPT_RCVBUF) {
recvbuf_size_ = option;
- } else if (opt == rtc::Socket::OPT_DSCP) {
+ } else if (opt == Socket::OPT_DSCP) {
dscp_ = static_cast<rtc::DiffServCodePoint>(option);
}
return 0;
diff --git a/media/base/media_channel.h b/media/base/media_channel.h
index c85d6a3..d1d5fa4 100644
--- a/media/base/media_channel.h
+++ b/media/base/media_channel.h
@@ -179,7 +179,7 @@
virtual bool SendRtcp(rtc::CopyOnWriteBuffer* packet,
const rtc::PacketOptions& options) = 0;
virtual int SetOption(SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option) = 0;
virtual ~MediaChannelNetworkInterface() {}
};
diff --git a/media/base/media_channel_impl.cc b/media/base/media_channel_impl.cc
index d41c9f9..915609d 100644
--- a/media/base/media_channel_impl.cc
+++ b/media/base/media_channel_impl.cc
@@ -82,7 +82,7 @@
}
int MediaChannelUtil::SetOption(MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option) {
return transport_.SetOption(type, opt, option);
}
@@ -249,10 +249,10 @@
rtc::DiffServCodePoint value =
enable_dscp_ ? preferred_dscp_ : rtc::DSCP_DEFAULT;
int ret = SetOptionLocked(MediaChannelNetworkInterface::ST_RTP,
- rtc::Socket::OPT_DSCP, value);
+ webrtc::Socket::OPT_DSCP, value);
if (ret == 0)
SetOptionLocked(MediaChannelNetworkInterface::ST_RTCP,
- rtc::Socket::OPT_DSCP, value);
+ webrtc::Socket::OPT_DSCP, value);
}
bool MediaChannelUtil::TransportForMediaChannels::DoSendPacket(
@@ -269,7 +269,7 @@
int MediaChannelUtil::TransportForMediaChannels::SetOption(
MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option) {
RTC_DCHECK_RUN_ON(network_thread_);
return SetOptionLocked(type, opt, option);
@@ -277,7 +277,7 @@
int MediaChannelUtil::TransportForMediaChannels::SetOptionLocked(
MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option) {
if (!network_interface_)
return -1;
diff --git a/media/base/media_channel_impl.h b/media/base/media_channel_impl.h
index 70bfe28..52e3f7a 100644
--- a/media/base/media_channel_impl.h
+++ b/media/base/media_channel_impl.h
@@ -87,7 +87,7 @@
const rtc::PacketOptions& options);
int SetOption(MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option);
// Functions that form part of one or more interface classes.
@@ -130,7 +130,7 @@
void SetInterface(MediaChannelNetworkInterface* iface);
int SetOption(MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option);
bool DoSendPacket(rtc::CopyOnWriteBuffer* packet,
@@ -159,7 +159,7 @@
void UpdateDscp() RTC_RUN_ON(network_thread_);
int SetOptionLocked(MediaChannelNetworkInterface::SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int option) RTC_RUN_ON(network_thread_);
const rtc::scoped_refptr<webrtc::PendingTaskSafetyFlag> network_safety_
diff --git a/media/base/rtp_utils.cc b/media/base/rtp_utils.cc
index 9225602..2143495 100644
--- a/media/base/rtp_utils.cc
+++ b/media/base/rtp_utils.cc
@@ -72,9 +72,10 @@
// Assumes `length` is actual packet length + tag length. Updates HMAC at end of
// the RTP packet.
-void UpdateRtpAuthTag(uint8_t* rtp,
- size_t length,
- const rtc::PacketTimeUpdateParams& packet_time_params) {
+void UpdateRtpAuthTag(
+ uint8_t* rtp,
+ size_t length,
+ const webrtc::PacketTimeUpdateParams& packet_time_params) {
// If there is no key, return.
if (packet_time_params.srtp_auth_key.empty()) {
return;
@@ -352,10 +353,11 @@
return found;
}
-bool ApplyPacketOptions(uint8_t* data,
- size_t length,
- const rtc::PacketTimeUpdateParams& packet_time_params,
- uint64_t time_us) {
+bool ApplyPacketOptions(
+ uint8_t* data,
+ size_t length,
+ const webrtc::PacketTimeUpdateParams& packet_time_params,
+ uint64_t time_us) {
RTC_DCHECK(data);
RTC_DCHECK(length);
diff --git a/media/base/rtp_utils.h b/media/base/rtp_utils.h
index 8ed3212..9b11650 100644
--- a/media/base/rtp_utils.h
+++ b/media/base/rtp_utils.h
@@ -15,13 +15,10 @@
#include "absl/strings/string_view.h"
#include "api/array_view.h"
+#include "rtc_base/async_packet_socket.h"
#include "rtc_base/byte_order.h"
#include "rtc_base/system/rtc_export.h"
-namespace rtc {
-struct PacketTimeUpdateParams;
-} // namespace rtc
-
namespace cricket {
const size_t kMinRtpPacketLen = 12;
@@ -74,7 +71,7 @@
bool RTC_EXPORT
ApplyPacketOptions(uint8_t* data,
size_t length,
- const rtc::PacketTimeUpdateParams& packet_time_params,
+ const webrtc::PacketTimeUpdateParams& packet_time_params,
uint64_t time_us);
} // namespace cricket
diff --git a/media/base/rtp_utils_unittest.cc b/media/base/rtp_utils_unittest.cc
index 7d48e72..6fdbff2 100644
--- a/media/base/rtp_utils_unittest.cc
+++ b/media/base/rtp_utils_unittest.cc
@@ -186,7 +186,7 @@
// Test without any packet options variables set. This method should return
// without HMAC value in the packet.
TEST(RtpUtilsTest, ApplyPacketOptionsWithDefaultValues) {
- rtc::PacketTimeUpdateParams packet_time_params;
+ webrtc::PacketTimeUpdateParams packet_time_params;
std::vector<uint8_t> rtp_packet(
kRtpMsgWithOneByteAbsSendTimeExtension,
kRtpMsgWithOneByteAbsSendTimeExtension +
@@ -207,7 +207,7 @@
// Veirfy HMAC is updated when packet option parameters are set.
TEST(RtpUtilsTest, ApplyPacketOptionsWithAuthParams) {
- rtc::PacketTimeUpdateParams packet_time_params;
+ webrtc::PacketTimeUpdateParams packet_time_params;
packet_time_params.srtp_auth_key.assign(kTestKey,
kTestKey + sizeof(kTestKey));
packet_time_params.srtp_auth_tag_len = 4;
@@ -264,7 +264,7 @@
// Verify we update both AbsSendTime extension header and HMAC.
TEST(RtpUtilsTest, ApplyPacketOptionsWithAuthParamsAndAbsSendTime) {
- rtc::PacketTimeUpdateParams packet_time_params;
+ webrtc::PacketTimeUpdateParams packet_time_params;
packet_time_params.srtp_auth_key.assign(kTestKey,
kTestKey + sizeof(kTestKey));
packet_time_params.srtp_auth_tag_len = 4;
diff --git a/media/engine/webrtc_video_engine.cc b/media/engine/webrtc_video_engine.cc
index 2c73bf8..f3dd471 100644
--- a/media/engine/webrtc_video_engine.cc
+++ b/media/engine/webrtc_video_engine.cc
@@ -1775,7 +1775,7 @@
}
MediaChannelUtil::SetOption(MediaChannelNetworkInterface::ST_RTP,
- rtc::Socket::OPT_SNDBUF, send_buffer_size);
+ webrtc::Socket::OPT_SNDBUF, send_buffer_size);
}
void WebRtcVideoSendChannel::SetFrameEncryptor(
@@ -3372,7 +3372,7 @@
MediaChannelUtil::SetInterface(iface);
// Set the RTP recv/send buffer to a bigger size.
MediaChannelUtil::SetOption(MediaChannelNetworkInterface::ST_RTP,
- rtc::Socket::OPT_RCVBUF, receive_buffer_size_);
+ webrtc::Socket::OPT_RCVBUF, receive_buffer_size_);
}
void WebRtcVideoReceiveChannel::SetFrameDecryptor(
diff --git a/media/engine/webrtc_video_engine_unittest.cc b/media/engine/webrtc_video_engine_unittest.cc
index 10179fb..f48219a 100644
--- a/media/engine/webrtc_video_engine_unittest.cc
+++ b/media/engine/webrtc_video_engine_unittest.cc
@@ -325,7 +325,7 @@
(override));
MOCK_METHOD(int,
SetOption,
- (SocketType type, rtc::Socket::Option opt, int option),
+ (SocketType type, webrtc::Socket::Option opt, int option),
(override));
};
diff --git a/media/sctp/dcsctp_transport.cc b/media/sctp/dcsctp_transport.cc
index 3bd8211..5c38ef5 100644
--- a/media/sctp/dcsctp_transport.cc
+++ b/media/sctp/dcsctp_transport.cc
@@ -461,7 +461,7 @@
<< ") failed with error: " << transport_->GetError()
<< ".";
- if (rtc::IsBlockingError(transport_->GetError())) {
+ if (IsBlockingError(transport_->GetError())) {
return SendPacketStatus::kTemporaryFailure;
}
return SendPacketStatus::kError;
diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn
index 43a937b..559783e 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -866,6 +866,8 @@
sources = [ "client/relay_port_factory_interface.h" ]
deps = [
":port_interface",
+ "../api:packet_socket_factory",
+ "../rtc_base:async_packet_socket",
"../rtc_base:refcount",
]
}
@@ -950,6 +952,7 @@
":udp_port",
"../rtc_base:net_helpers",
"../rtc_base:net_test_helpers",
+ "../rtc_base:socket_factory",
"../rtc_base:task_queue_for_test",
"../rtc_base:threading",
"../rtc_base/memory:always_valid_pointer",
diff --git a/p2p/base/async_stun_tcp_socket.cc b/p2p/base/async_stun_tcp_socket.cc
index d7228d8..931faca 100644
--- a/p2p/base/async_stun_tcp_socket.cc
+++ b/p2p/base/async_stun_tcp_socket.cc
@@ -26,14 +26,14 @@
#include "rtc_base/network/sent_packet.h"
#include "rtc_base/time_utils.h"
-namespace cricket {
+namespace webrtc {
static const size_t kMaxPacketSize = 64 * 1024;
typedef uint16_t PacketLength;
static const size_t kPacketLenSize = sizeof(PacketLength);
static const size_t kPacketLenOffset = 2;
-static const size_t kBufSize = kMaxPacketSize + kStunHeaderSize;
+static const size_t kBufSize = kMaxPacketSize + cricket::kStunHeaderSize;
static const size_t kTurnChannelDataHdrSize = 4;
inline bool IsStunMessage(uint16_t msg_type) {
@@ -46,15 +46,15 @@
// it. Takes ownership of `socket`. Returns NULL if bind() or
// connect() fail (`socket` is destroyed in that case).
AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
- rtc::Socket* socket,
- const webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address) {
+ Socket* socket,
+ const SocketAddress& bind_address,
+ const SocketAddress& remote_address) {
return new AsyncStunTCPSocket(
AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
}
-AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::Socket* socket)
- : rtc::AsyncTCPSocketBase(socket, kBufSize) {}
+AsyncStunTCPSocket::AsyncStunTCPSocket(Socket* socket)
+ : AsyncTCPSocketBase(socket, kBufSize) {}
int AsyncStunTCPSocket::Send(const void* pv,
size_t cb,
@@ -96,7 +96,7 @@
}
size_t AsyncStunTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
- webrtc::SocketAddress remote_addr(GetRemoteAddress());
+ SocketAddress remote_addr(GetRemoteAddress());
// STUN packet - First 4 bytes. Total header size is 20 bytes.
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |0 0| STUN Message Type | Message Length |
@@ -125,7 +125,7 @@
rtc::ReceivedPacket received_packet(
data.subview(processed_bytes, expected_pkt_len), remote_addr,
- webrtc::Timestamp::Micros(rtc::TimeMicros()));
+ Timestamp::Micros(rtc::TimeMicros()));
NotifyPacketReceived(received_packet);
processed_bytes += actual_length;
}
@@ -141,7 +141,7 @@
uint16_t msg_type = webrtc::GetBE16(data);
if (IsStunMessage(msg_type)) {
// STUN message.
- expected_pkt_len = kStunHeaderSize + pkt_len;
+ expected_pkt_len = cricket::kStunHeaderSize + pkt_len;
} else {
// TURN ChannelData message.
expected_pkt_len = kTurnChannelDataHdrSize + pkt_len;
@@ -159,4 +159,4 @@
return expected_pkt_len;
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/base/async_stun_tcp_socket.h b/p2p/base/async_stun_tcp_socket.h
index e4110d2..9204e19 100644
--- a/p2p/base/async_stun_tcp_socket.h
+++ b/p2p/base/async_stun_tcp_socket.h
@@ -18,19 +18,18 @@
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
-namespace cricket {
+namespace webrtc {
-class AsyncStunTCPSocket : public rtc::AsyncTCPSocketBase {
+class AsyncStunTCPSocket : public AsyncTCPSocketBase {
public:
// 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 webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address);
+ static AsyncStunTCPSocket* Create(Socket* socket,
+ const SocketAddress& bind_address,
+ const SocketAddress& remote_address);
- explicit AsyncStunTCPSocket(rtc::Socket* socket);
+ explicit AsyncStunTCPSocket(Socket* socket);
AsyncStunTCPSocket(const AsyncStunTCPSocket&) = delete;
AsyncStunTCPSocket& operator=(const AsyncStunTCPSocket&) = delete;
@@ -47,6 +46,12 @@
size_t GetExpectedLength(const void* data, size_t len, int* pad_bytes);
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace cricket {
+using ::webrtc::AsyncStunTCPSocket;
} // namespace cricket
#endif // P2P_BASE_ASYNC_STUN_TCP_SOCKET_H_
diff --git a/p2p/base/async_stun_tcp_socket_unittest.cc b/p2p/base/async_stun_tcp_socket_unittest.cc
index c38bb30..6f83bc1 100644
--- a/p2p/base/async_stun_tcp_socket_unittest.cc
+++ b/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -31,7 +31,7 @@
#include "rtc_base/virtual_socket_server.h"
#include "test/gtest.h"
-namespace cricket {
+namespace webrtc {
static unsigned char kStunMessageWithZeroLength[] = {
0x00, 0x01, 0x00, 0x00, // length of 0 (last 2 bytes)
@@ -62,14 +62,14 @@
0x40, 0x00, 0x00, 0x05, 0x21, 0x12, 0xA4, 0x42, '0',
};
-static const webrtc::SocketAddress kClientAddr("11.11.11.11", 0);
-static const webrtc::SocketAddress kServerAddr("22.22.22.22", 0);
+static const SocketAddress kClientAddr("11.11.11.11", 0);
+static const SocketAddress kServerAddr("22.22.22.22", 0);
-class AsyncStunServerTCPSocket : public rtc::AsyncTcpListenSocket {
+class AsyncStunServerTCPSocket : public AsyncTcpListenSocket {
public:
- explicit AsyncStunServerTCPSocket(std::unique_ptr<rtc::Socket> socket)
+ explicit AsyncStunServerTCPSocket(std::unique_ptr<Socket> socket)
: AsyncTcpListenSocket(std::move(socket)) {}
- void HandleIncomingConnection(rtc::Socket* socket) override {
+ void HandleIncomingConnection(Socket* socket) override {
SignalNewConnection(this, new AsyncStunTCPSocket(socket));
}
};
@@ -78,12 +78,12 @@
public sigslot::has_slots<> {
protected:
AsyncStunTCPSocketTest()
- : vss_(new rtc::VirtualSocketServer()), thread_(vss_.get()) {}
+ : vss_(new VirtualSocketServer()), thread_(vss_.get()) {}
virtual void SetUp() { CreateSockets(); }
void CreateSockets() {
- std::unique_ptr<rtc::Socket> server =
+ std::unique_ptr<Socket> server =
absl::WrapUnique(vss_->CreateSocket(kServerAddr.family(), SOCK_STREAM));
server->Bind(kServerAddr);
listen_socket_ =
@@ -91,7 +91,7 @@
listen_socket_->SignalNewConnection.connect(
this, &AsyncStunTCPSocketTest::OnNewConnection);
- rtc::Socket* client = vss_->CreateSocket(kClientAddr.family(), SOCK_STREAM);
+ Socket* client = vss_->CreateSocket(kClientAddr.family(), SOCK_STREAM);
send_socket_.reset(AsyncStunTCPSocket::Create(
client, kClientAddr, listen_socket_->GetLocalAddress()));
send_socket_->SignalSentPacket.connect(
@@ -100,20 +100,20 @@
vss_->ProcessMessagesUntilIdle();
}
- void OnReadPacket(rtc::AsyncPacketSocket* /* socket */,
+ void OnReadPacket(AsyncPacketSocket* /* socket */,
const rtc::ReceivedPacket& packet) {
recv_packets_.push_back(
std::string(reinterpret_cast<const char*>(packet.payload().data()),
packet.payload().size()));
}
- void OnSentPacket(rtc::AsyncPacketSocket* /* socket */,
+ void OnSentPacket(AsyncPacketSocket* /* socket */,
const rtc::SentPacket& /* packet */) {
++sent_packets_;
}
- void OnNewConnection(rtc::AsyncListenSocket* /*server*/,
- rtc::AsyncPacketSocket* new_socket) {
+ void OnNewConnection(AsyncListenSocket* /*server*/,
+ AsyncPacketSocket* new_socket) {
recv_socket_ = absl::WrapUnique(new_socket);
new_socket->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
@@ -139,11 +139,11 @@
return ret;
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread thread_;
std::unique_ptr<AsyncStunTCPSocket> send_socket_;
- std::unique_ptr<rtc::AsyncListenSocket> listen_socket_;
- std::unique_ptr<rtc::AsyncPacketSocket> recv_socket_;
+ std::unique_ptr<AsyncListenSocket> listen_socket_;
+ std::unique_ptr<AsyncPacketSocket> recv_socket_;
std::list<std::string> recv_packets_;
int sent_packets_ = 0;
};
@@ -178,7 +178,7 @@
std::string(reinterpret_cast<const char*>(packet.payload().data()),
packet.payload().size()));
});
- rtc::Buffer buffer;
+ Buffer buffer;
buffer.AppendData(kStunMessageWithZeroLength,
sizeof(kStunMessageWithZeroLength));
// ChannelData message MUST be padded to
@@ -316,4 +316,4 @@
EXPECT_EQ(0, sent_packets_);
}
-} // namespace cricket
+} // namespace webrtc
diff --git a/p2p/base/basic_packet_socket_factory.cc b/p2p/base/basic_packet_socket_factory.cc
index f401f3f..00cae1c 100644
--- a/p2p/base/basic_packet_socket_factory.cc
+++ b/p2p/base/basic_packet_socket_factory.cc
@@ -26,7 +26,7 @@
#include "rtc_base/socket_adapters.h"
#include "rtc_base/ssl_adapter.h"
-namespace rtc {
+namespace webrtc {
BasicPacketSocketFactory::BasicPacketSocketFactory(
SocketFactory* socket_factory)
@@ -35,7 +35,7 @@
BasicPacketSocketFactory::~BasicPacketSocketFactory() {}
AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
- const webrtc::SocketAddress& address,
+ const SocketAddress& address,
uint16_t min_port,
uint16_t max_port) {
// UDP sockets are simple.
@@ -52,7 +52,7 @@
}
AsyncListenSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
- const webrtc::SocketAddress& local_address,
+ const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) {
@@ -84,8 +84,8 @@
}
AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
- const webrtc::SocketAddress& local_address,
- const webrtc::SocketAddress& remote_address,
+ const SocketAddress& local_address,
+ const SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) {
Socket* socket =
socket_factory_->CreateSocket(local_address.family(), SOCK_STREAM);
@@ -126,7 +126,7 @@
if ((tlsOpts & PacketSocketFactory::OPT_TLS) ||
(tlsOpts & PacketSocketFactory::OPT_TLS_INSECURE)) {
// Using TLS, wrap the socket in an SSL adapter.
- SSLAdapter* ssl_adapter = SSLAdapter::Create(socket);
+ rtc::SSLAdapter* ssl_adapter = rtc::SSLAdapter::Create(socket);
if (!ssl_adapter) {
return NULL;
}
@@ -160,7 +160,7 @@
// Finally, wrap that socket in a TCP or STUN TCP packet socket.
AsyncPacketSocket* tcp_socket;
if (tcp_options.opts & PacketSocketFactory::OPT_STUN) {
- tcp_socket = new cricket::AsyncStunTCPSocket(socket);
+ tcp_socket = new AsyncStunTCPSocket(socket);
} else {
tcp_socket = new AsyncTCPSocket(socket);
}
@@ -168,16 +168,15 @@
return tcp_socket;
}
-std::unique_ptr<webrtc::AsyncDnsResolverInterface>
+std::unique_ptr<AsyncDnsResolverInterface>
BasicPacketSocketFactory::CreateAsyncDnsResolver() {
- return std::make_unique<webrtc::AsyncDnsResolver>();
+ return std::make_unique<AsyncDnsResolver>();
}
-int BasicPacketSocketFactory::BindSocket(
- Socket* socket,
- const webrtc::SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port) {
+int BasicPacketSocketFactory::BindSocket(Socket* socket,
+ const 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.
@@ -185,10 +184,10 @@
} 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(webrtc::SocketAddress(local_address.ipaddr(), port));
+ ret = socket->Bind(SocketAddress(local_address.ipaddr(), port));
}
}
return ret;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/p2p/base/basic_packet_socket_factory.h b/p2p/base/basic_packet_socket_factory.h
index 26d78e8..5477f7a 100644
--- a/p2p/base/basic_packet_socket_factory.h
+++ b/p2p/base/basic_packet_socket_factory.h
@@ -24,40 +24,42 @@
#include "rtc_base/socket_factory.h"
#include "rtc_base/system/rtc_export.h"
-namespace rtc {
-
-class SocketFactory;
+namespace webrtc {
class RTC_EXPORT BasicPacketSocketFactory : public PacketSocketFactory {
public:
explicit BasicPacketSocketFactory(SocketFactory* socket_factory);
~BasicPacketSocketFactory() override;
- AsyncPacketSocket* CreateUdpSocket(const webrtc::SocketAddress& local_address,
+ AsyncPacketSocket* CreateUdpSocket(const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port) override;
- AsyncListenSocket* CreateServerTcpSocket(
- const webrtc::SocketAddress& local_address,
- uint16_t min_port,
- uint16_t max_port,
- int opts) override;
+ AsyncListenSocket* CreateServerTcpSocket(const SocketAddress& local_address,
+ uint16_t min_port,
+ uint16_t max_port,
+ int opts) override;
AsyncPacketSocket* CreateClientTcpSocket(
- const webrtc::SocketAddress& local_address,
- const webrtc::SocketAddress& remote_address,
+ const SocketAddress& local_address,
+ const SocketAddress& remote_address,
const PacketSocketTcpOptions& tcp_options) override;
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAsyncDnsResolver()
- override;
+ std::unique_ptr<AsyncDnsResolverInterface> CreateAsyncDnsResolver() override;
private:
int BindSocket(Socket* socket,
- const webrtc::SocketAddress& local_address,
+ const SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port);
SocketFactory* socket_factory_;
};
+} // 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::BasicPacketSocketFactory;
} // namespace rtc
#endif // P2P_BASE_BASIC_PACKET_SOCKET_FACTORY_H_
diff --git a/p2p/base/p2p_transport_channel.cc b/p2p/base/p2p_transport_channel.cc
index 58e0e25..ebcd74b 100644
--- a/p2p/base/p2p_transport_channel.cc
+++ b/p2p/base/p2p_transport_channel.cc
@@ -798,7 +798,7 @@
->Parse(field_trials->Lookup("WebRTC-DscpFieldTrial"));
if (ice_field_trials_.override_dscp) {
- SetOption(rtc::Socket::OPT_DSCP, *ice_field_trials_.override_dscp);
+ SetOption(webrtc::Socket::OPT_DSCP, *ice_field_trials_.override_dscp);
}
std::string field_trial_string =
@@ -808,7 +808,7 @@
if (receive_buffer_size_kb > 0) {
RTC_LOG(LS_INFO) << "Set WebRTC-SetSocketReceiveBuffer: Enabled and set to "
<< receive_buffer_size_kb << "kb";
- SetOption(rtc::Socket::OPT_RCVBUF, receive_buffer_size_kb * 1024);
+ SetOption(webrtc::Socket::OPT_RCVBUF, receive_buffer_size_kb * 1024);
}
ice_field_trials_.piggyback_ice_check_acknowledgement =
@@ -825,7 +825,7 @@
int desired_recv_esn = 1;
RTC_LOG(LS_INFO) << "Set WebRTC-RFC8888CongestionControlFeedback: Enable "
"and set ECN recving mode";
- SetOption(rtc::Socket::OPT_RECV_ECN, desired_recv_esn);
+ SetOption(webrtc::Socket::OPT_RECV_ECN, desired_recv_esn);
}
}
@@ -1524,9 +1524,9 @@
// Set options on ourselves is simply setting options on all of our available
// port objects.
-int P2PTransportChannel::SetOption(rtc::Socket::Option opt, int value) {
+int P2PTransportChannel::SetOption(webrtc::Socket::Option opt, int value) {
RTC_DCHECK_RUN_ON(network_thread_);
- if (ice_field_trials_.override_dscp && opt == rtc::Socket::OPT_DSCP) {
+ if (ice_field_trials_.override_dscp && opt == webrtc::Socket::OPT_DSCP) {
value = *ice_field_trials_.override_dscp;
}
@@ -1551,7 +1551,7 @@
return 0;
}
-bool P2PTransportChannel::GetOption(rtc::Socket::Option opt, int* value) {
+bool P2PTransportChannel::GetOption(webrtc::Socket::Option opt, int* value) {
RTC_DCHECK_RUN_ON(network_thread_);
const auto& found = options_.find(opt);
@@ -1643,7 +1643,7 @@
rtc::DiffServCodePoint P2PTransportChannel::DefaultDscpValue() const {
RTC_DCHECK_RUN_ON(network_thread_);
- OptionMap::const_iterator it = options_.find(rtc::Socket::OPT_DSCP);
+ OptionMap::const_iterator it = options_.find(webrtc::Socket::OPT_DSCP);
if (it == options_.end()) {
return rtc::DSCP_NO_CHANGE;
}
diff --git a/p2p/base/p2p_transport_channel.h b/p2p/base/p2p_transport_channel.h
index 10212c5..754039d 100644
--- a/p2p/base/p2p_transport_channel.h
+++ b/p2p/base/p2p_transport_channel.h
@@ -152,8 +152,8 @@
size_t len,
const rtc::PacketOptions& options,
int flags) override;
- int SetOption(rtc::Socket::Option opt, int value) override;
- bool GetOption(rtc::Socket::Option opt, int* value) override;
+ int SetOption(webrtc::Socket::Option opt, int value) override;
+ bool GetOption(webrtc::Socket::Option opt, int* value) override;
int GetError() override;
bool GetStats(IceTransportStats* ice_transport_stats) override;
std::optional<int> GetRttEstimate() override;
@@ -438,7 +438,7 @@
RTC_GUARDED_BY(network_thread_);
bool had_connection_ RTC_GUARDED_BY(network_thread_) =
false; // if connections_ has ever been nonempty
- typedef std::map<rtc::Socket::Option, int> OptionMap;
+ typedef std::map<webrtc::Socket::Option, int> OptionMap;
OptionMap options_ RTC_GUARDED_BY(network_thread_);
IceParameters ice_parameters_ RTC_GUARDED_BY(network_thread_);
std::vector<IceParameters> remote_ice_parameters_
diff --git a/p2p/base/p2p_transport_channel_unittest.cc b/p2p/base/p2p_transport_channel_unittest.cc
index c7693af..088bb03 100644
--- a/p2p/base/p2p_transport_channel_unittest.cc
+++ b/p2p/base/p2p_transport_channel_unittest.cc
@@ -208,7 +208,7 @@
std::unique_ptr<cricket::BasicPortAllocator> CreateBasicPortAllocator(
const Environment& env,
rtc::NetworkManager* network_manager,
- rtc::PacketSocketFactory* socket_factory,
+ webrtc::PacketSocketFactory* socket_factory,
const cricket::ServerAddresses& stun_servers,
const webrtc::SocketAddress& turn_server_udp,
const webrtc::SocketAddress& turn_server_tcp) {
@@ -315,10 +315,10 @@
public sigslot::has_slots<> {
public:
P2PTransportChannelTestBase()
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new webrtc::VirtualSocketServer()),
nss_(new webrtc::NATSocketServer(vss_.get())),
- ss_(new rtc::FirewallSocketServer(nss_.get())),
- socket_factory_(new rtc::BasicPacketSocketFactory(ss_.get())),
+ ss_(new webrtc::FirewallSocketServer(nss_.get())),
+ socket_factory_(new webrtc::BasicPacketSocketFactory(ss_.get())),
main_(ss_.get()),
stun_server_(
webrtc::TestStunServer::Create(ss_.get(), kStunAddr, main_)),
@@ -547,7 +547,7 @@
P2PTransportChannel* ep2_ch2() { return ep2_.cd2_.ch_.get(); }
webrtc::TestTurnServer* test_turn_server() { return &turn_server_; }
- rtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
+ webrtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
// Common results.
static const Result kLocalUdpToLocalUdp;
@@ -566,7 +566,7 @@
static const Result kPrflxTcpToLocalTcp;
webrtc::NATSocketServer* nat() { return nss_.get(); }
- rtc::FirewallSocketServer* fw() { return ss_.get(); }
+ webrtc::FirewallSocketServer* fw() { return ss_.get(); }
Endpoint* GetEndpoint(int endpoint) {
if (endpoint == 0) {
@@ -594,7 +594,7 @@
}
void RemoveAddress(int endpoint, const SocketAddress& addr) {
GetEndpoint(endpoint)->network_manager_.RemoveInterface(addr);
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, addr);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, addr);
}
void SetAllocatorFlags(int endpoint, int flags) {
GetAllocator(endpoint)->set_flags(flags);
@@ -1044,10 +1044,10 @@
bool nominated() { return nominated_; }
private:
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> vss_;
std::unique_ptr<webrtc::NATSocketServer> nss_;
- std::unique_ptr<rtc::FirewallSocketServer> ss_;
- std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
+ std::unique_ptr<webrtc::FirewallSocketServer> ss_;
+ std::unique_ptr<webrtc::BasicPacketSocketFactory> socket_factory_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PendingTaskSafetyFlag> safety_ =
@@ -1202,18 +1202,19 @@
case BLOCK_ALL_BUT_OUTGOING_HTTP:
AddAddress(endpoint, kPublicAddrs[endpoint]);
// Block all UDP
- fw()->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kPublicAddrs[endpoint]);
+ fw()->AddRule(false, webrtc::FP_UDP, webrtc::FD_ANY,
+ kPublicAddrs[endpoint]);
if (config == BLOCK_UDP_AND_INCOMING_TCP) {
// Block TCP inbound to the endpoint
- fw()->AddRule(false, rtc::FP_TCP, SocketAddress(),
+ fw()->AddRule(false, webrtc::FP_TCP, SocketAddress(),
kPublicAddrs[endpoint]);
} else if (config == BLOCK_ALL_BUT_OUTGOING_HTTP) {
// Block all TCP to/from the endpoint except 80/443 out
- fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
+ fw()->AddRule(true, webrtc::FP_TCP, kPublicAddrs[endpoint],
SocketAddress(webrtc::IPAddress(INADDR_ANY), 80));
- fw()->AddRule(true, rtc::FP_TCP, kPublicAddrs[endpoint],
+ fw()->AddRule(true, webrtc::FP_TCP, kPublicAddrs[endpoint],
SocketAddress(webrtc::IPAddress(INADDR_ANY), 443));
- fw()->AddRule(false, rtc::FP_TCP, rtc::FD_ANY,
+ fw()->AddRule(false, webrtc::FP_TCP, webrtc::FD_ANY,
kPublicAddrs[endpoint]);
}
break;
@@ -1548,7 +1549,7 @@
.clock = &clock}),
webrtc::IsRtcOk());
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// Timeout value such that all connections are deleted.
const int kNetworkFailureTimeout = 35000;
SIMULATED_WAIT(false, kNetworkFailureTimeout, clock);
@@ -2107,12 +2108,12 @@
CreateChannels(env);
EXPECT_EQ(rtc::DSCP_NO_CHANGE, GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
EXPECT_EQ(rtc::DSCP_NO_CHANGE, GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
- GetEndpoint(0)->cd1_.ch_->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
- GetEndpoint(1)->cd1_.ch_->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
+ GetEndpoint(0)->cd1_.ch_->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
+ GetEndpoint(1)->cd1_.ch_->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_CS6);
EXPECT_EQ(rtc::DSCP_CS6, GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
EXPECT_EQ(rtc::DSCP_CS6, GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
- GetEndpoint(0)->cd1_.ch_->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
- GetEndpoint(1)->cd1_.ch_->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
+ GetEndpoint(0)->cd1_.ch_->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
+ GetEndpoint(1)->cd1_.ch_->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
EXPECT_EQ(rtc::DSCP_AF41, GetEndpoint(0)->cd1_.ch_->DefaultDscpValue());
EXPECT_EQ(rtc::DSCP_AF41, GetEndpoint(1)->cd1_.ch_->DefaultDscpValue());
DestroyChannels();
@@ -2600,7 +2601,7 @@
// Block the ingress traffic to ep1 so that there is no check response from
// ep2.
ASSERT_NE(nullptr, LocalCandidate(ep1_ch1()));
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_IN,
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_IN,
LocalCandidate(ep1_ch1())->address());
// Wait until ep1 becomes unwritable. At the same time ep2 should be still
// fine so that it will keep sending pings.
@@ -2618,7 +2619,7 @@
// though that ep1 should have stopped sending pings after becoming unwritable
// in the current design.
fw()->ClearRules();
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_OUT,
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_OUT,
LocalCandidate(ep1_ch1())->address());
EXPECT_THAT(webrtc::WaitUntil(
[&] { return ep1_ch1() != nullptr && ep1_ch1()->writable(); },
@@ -2784,7 +2785,7 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[1]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[1]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
@@ -2845,7 +2846,7 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// We should detect loss of receiving within 1 second or so.
// We should switch over to use the alternate addr on both sides
@@ -2921,8 +2922,8 @@
// Blackhole any traffic to or from the wifi on endpoint 1.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, wifi[0]);
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, wifiIpv6[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifi[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifiIpv6[0]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
@@ -3026,7 +3027,7 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// The selected connection on the controlling side should switch.
EXPECT_THAT(
@@ -3088,7 +3089,7 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[1]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[1]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
@@ -3156,7 +3157,7 @@
// Blackhole any traffic to or from the public addrs.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// The selected connections may switch, so keep references to them.
const Connection* selected_connection1 = ep1_ch1()->selected_connection();
// We should detect loss of receiving within 1 second or so.
@@ -3235,7 +3236,7 @@
reset_selected_candidate_pair_switches();
// Blackhole any traffic to or from the remote WiFi networks.
RTC_LOG(LS_INFO) << "Failing over...";
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, wifi[1]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, wifi[1]);
int num_switches = 0;
SIMULATED_WAIT((num_switches = reset_selected_candidate_pair_switches()) > 0,
@@ -3741,7 +3742,7 @@
webrtc::IsRtcOk());
// Block VPN.
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kAlternateAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kAlternateAddrs[0]);
// Check that it switches to non-VPN
EXPECT_THAT(
@@ -3780,7 +3781,7 @@
webrtc::IsRtcOk());
// Block non-VPN.
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// Check that it switches to VPN
EXPECT_THAT(webrtc::WaitUntil(
@@ -3818,7 +3819,7 @@
webrtc::IsRtcOk());
// Block non-VPN.
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kPublicAddrs[0]);
// Check that it does not switches to VPN
clock.AdvanceTime(webrtc::TimeDelta::Millis(kDefaultTimeout));
@@ -3853,7 +3854,7 @@
webrtc::IsRtcOk());
// Block VPN.
- fw()->AddRule(false, rtc::FP_ANY, rtc::FD_ANY, kAlternateAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, webrtc::FD_ANY, kAlternateAddrs[0]);
// Check that it does not switch to non-VPN
clock.AdvanceTime(webrtc::TimeDelta::Millis(kDefaultTimeout));
@@ -3909,9 +3910,9 @@
public sigslot::has_slots<> {
public:
P2PTransportChannelPingTest()
- : vss_(std::make_unique<rtc::VirtualSocketServer>()),
+ : vss_(std::make_unique<webrtc::VirtualSocketServer>()),
packet_socket_factory_(
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
+ std::make_unique<webrtc::BasicPacketSocketFactory>(vss_.get())),
thread_(vss_.get()) {}
protected:
@@ -4123,15 +4124,15 @@
}
}
- rtc::SocketServer* ss() const { return vss_.get(); }
+ webrtc::SocketServer* ss() const { return vss_.get(); }
- rtc::PacketSocketFactory* packet_socket_factory() const {
+ webrtc::PacketSocketFactory* packet_socket_factory() const {
return packet_socket_factory_.get();
}
private:
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
+ std::unique_ptr<webrtc::VirtualSocketServer> vss_;
+ std::unique_ptr<webrtc::PacketSocketFactory> packet_socket_factory_;
rtc::AutoSocketServerThread thread_;
int selected_candidate_pair_switches_ = 0;
int last_sent_packet_id_ = -1;
@@ -6033,10 +6034,10 @@
TEST(P2PTransportChannelResolverTest, HostnameCandidateIsResolved) {
const Environment env = CreateEnvironment();
ResolverFactoryFixture resolver_fixture;
- std::unique_ptr<rtc::SocketServer> socket_server =
+ std::unique_ptr<webrtc::SocketServer> socket_server =
rtc::CreateDefaultSocketServer();
rtc::AutoSocketServerThread main_thread(socket_server.get());
- rtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
+ webrtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
FakePortAllocator allocator(rtc::Thread::Current(), &packet_socket_factory,
&env.field_trials());
webrtc::IceTransportInit init;
@@ -6721,10 +6722,10 @@
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_local());
// Block the traffic over non-relay-to-relay routes and expect a route change.
- fw()->AddRule(false, rtc::FP_ANY, kPublicAddrs[0], kPublicAddrs[1]);
- fw()->AddRule(false, rtc::FP_ANY, kPublicAddrs[1], kPublicAddrs[0]);
- fw()->AddRule(false, rtc::FP_ANY, kPublicAddrs[0], kTurnUdpExtAddr);
- fw()->AddRule(false, rtc::FP_ANY, kPublicAddrs[1], kTurnUdpExtAddr);
+ fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[0], kPublicAddrs[1]);
+ fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[1], kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[0], kTurnUdpExtAddr);
+ fw()->AddRule(false, webrtc::FP_ANY, kPublicAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
EXPECT_THAT(webrtc::WaitUntil(
@@ -6814,10 +6815,10 @@
EXPECT_TRUE(ep2_ch1()->selected_connection()->remote_candidate().is_stun());
// Block the traffic over non-relay-to-relay routes and expect a route change.
- fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[0], kPublicAddrs[1]);
- fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[1], kPublicAddrs[0]);
- fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[0], kTurnUdpExtAddr);
- fw()->AddRule(false, rtc::FP_ANY, kPrivateAddrs[1], kTurnUdpExtAddr);
+ fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[0], kPublicAddrs[1]);
+ fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[1], kPublicAddrs[0]);
+ fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[0], kTurnUdpExtAddr);
+ fw()->AddRule(false, webrtc::FP_ANY, kPrivateAddrs[1], kTurnUdpExtAddr);
// We should be able to reuse the previously gathered relay candidates.
EXPECT_THAT(webrtc::WaitUntil(
[&] {
@@ -7170,10 +7171,10 @@
TEST(P2PTransportChannelIceControllerTest, InjectIceController) {
const Environment env = CreateEnvironment();
- std::unique_ptr<rtc::SocketServer> socket_server =
+ std::unique_ptr<webrtc::SocketServer> socket_server =
rtc::CreateDefaultSocketServer();
rtc::AutoSocketServerThread main_thread(socket_server.get());
- rtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
+ webrtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
webrtc::MockIceControllerFactory factory;
FakePortAllocator pa(rtc::Thread::Current(), &packet_socket_factory,
&env.field_trials());
@@ -7189,10 +7190,10 @@
TEST(P2PTransportChannel, InjectActiveIceController) {
const Environment env = CreateEnvironment();
- std::unique_ptr<rtc::SocketServer> socket_server =
+ std::unique_ptr<webrtc::SocketServer> socket_server =
rtc::CreateDefaultSocketServer();
rtc::AutoSocketServerThread main_thread(socket_server.get());
- rtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
+ webrtc::BasicPacketSocketFactory packet_socket_factory(socket_server.get());
webrtc::MockActiveIceControllerFactory factory;
FakePortAllocator pa(rtc::Thread::Current(), &packet_socket_factory,
&env.field_trials());
diff --git a/p2p/base/packet_transport_internal.cc b/p2p/base/packet_transport_internal.cc
index c38fd2b..0f44f63 100644
--- a/p2p/base/packet_transport_internal.cc
+++ b/p2p/base/packet_transport_internal.cc
@@ -19,7 +19,7 @@
PacketTransportInternal::~PacketTransportInternal() = default;
-bool PacketTransportInternal::GetOption(rtc::Socket::Option /* opt */,
+bool PacketTransportInternal::GetOption(webrtc::Socket::Option /* opt */,
int* /* value */) {
return false;
}
diff --git a/p2p/base/packet_transport_internal.h b/p2p/base/packet_transport_internal.h
index 3a9a871..b8b91c4 100644
--- a/p2p/base/packet_transport_internal.h
+++ b/p2p/base/packet_transport_internal.h
@@ -56,11 +56,11 @@
// Sets a socket option. Note that not all options are
// supported by all transport types.
- virtual int SetOption(rtc::Socket::Option opt, int value) = 0;
+ virtual int SetOption(webrtc::Socket::Option opt, int value) = 0;
// TODO(pthatcher): Once Chrome's MockPacketTransportInterface implements
// this, remove the default implementation.
- virtual bool GetOption(rtc::Socket::Option opt, int* value);
+ virtual bool GetOption(webrtc::Socket::Option opt, int* value);
// Returns the most recent error that occurred on this channel.
virtual int GetError() = 0;
diff --git a/p2p/base/port.cc b/p2p/base/port.cc
index 71c903e..ae8bf55 100644
--- a/p2p/base/port.cc
+++ b/p2p/base/port.cc
@@ -685,7 +685,7 @@
return std::string(remote_username) + ":" + username_fragment();
}
-bool Port::HandleIncomingPacket(rtc::AsyncPacketSocket* /* socket */,
+bool Port::HandleIncomingPacket(webrtc::AsyncPacketSocket* /* socket */,
const rtc::ReceivedPacket& /* packet */) {
RTC_DCHECK_NOTREACHED();
return false;
diff --git a/p2p/base/port.h b/p2p/base/port.h
index 83bd46f..076ae55 100644
--- a/p2p/base/port.h
+++ b/p2p/base/port.h
@@ -176,7 +176,7 @@
// CreateRelayPortArgs.
struct PortParametersRef {
webrtc::TaskQueueBase* network_thread;
- rtc::PacketSocketFactory* socket_factory;
+ webrtc::PacketSocketFactory* socket_factory;
const rtc::Network* network;
absl::string_view ice_username_fragment;
absl::string_view ice_password;
@@ -226,7 +226,9 @@
webrtc::TaskQueueBase* thread() override { return thread_; }
// The factory used to create the sockets of this port.
- rtc::PacketSocketFactory* socket_factory() const override { return factory_; }
+ webrtc::PacketSocketFactory* socket_factory() const override {
+ return factory_;
+ }
// For debugging purposes.
const std::string& content_name() const override { return content_name_; }
@@ -306,7 +308,7 @@
// to accept the packet based on the `remote_addr`. Currently only UDP
// port implemented this method.
// TODO(mallinath) - Make it pure virtual.
- virtual bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+ virtual bool HandleIncomingPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
// Shall the port handle packet from this `remote_addr`.
@@ -353,7 +355,7 @@
// This is made pure virtual to notify subclasses of Port that they MUST
// listen to AsyncPacketSocket::SignalSentPacket and then call
// PortInterface::OnSentPacket.
- virtual void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ virtual void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) = 0;
// Called when the socket is currently able to send.
@@ -469,7 +471,7 @@
void OnNetworkTypeChanged(const rtc::Network* network);
webrtc::TaskQueueBase* const thread_;
- rtc::PacketSocketFactory* const factory_;
+ webrtc::PacketSocketFactory* const factory_;
webrtc::AlwaysValidPointer<const webrtc::FieldTrialsView,
webrtc::FieldTrialBasedConfig>
field_trials_;
diff --git a/p2p/base/port_allocator_unittest.cc b/p2p/base/port_allocator_unittest.cc
index 2b2bdc2..1dffa76 100644
--- a/p2p/base/port_allocator_unittest.cc
+++ b/p2p/base/port_allocator_unittest.cc
@@ -32,10 +32,10 @@
class PortAllocatorTest : public ::testing::Test, public sigslot::has_slots<> {
public:
PortAllocatorTest()
- : vss_(std::make_unique<rtc::VirtualSocketServer>()),
+ : vss_(std::make_unique<webrtc::VirtualSocketServer>()),
main_(vss_.get()),
packet_socket_factory_(
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
+ std::make_unique<webrtc::BasicPacketSocketFactory>(vss_.get())),
allocator_(std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
packet_socket_factory_.get(),
@@ -87,9 +87,9 @@
}
webrtc::test::ScopedKeyValueConfig field_trials_;
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
+ std::unique_ptr<webrtc::PacketSocketFactory> packet_socket_factory_;
std::unique_ptr<cricket::FakePortAllocator> allocator_;
webrtc::SocketAddress stun_server_1{"11.11.11.11", 3478};
webrtc::SocketAddress stun_server_2{"22.22.22.22", 3478};
diff --git a/p2p/base/port_interface.h b/p2p/base/port_interface.h
index d1ca138..a650f8a 100644
--- a/p2p/base/port_interface.h
+++ b/p2p/base/port_interface.h
@@ -87,8 +87,8 @@
CandidateOrigin origin) = 0;
// Functions on the underlying socket(s).
- virtual int SetOption(rtc::Socket::Option opt, int value) = 0;
- virtual int GetOption(rtc::Socket::Option opt, int* value) = 0;
+ virtual int SetOption(Socket::Option opt, int value) = 0;
+ virtual int GetOption(Socket::Option opt, int* value) = 0;
virtual int GetError() = 0;
virtual ProtocolType GetProtocol() const = 0;
@@ -157,7 +157,7 @@
virtual TaskQueueBase* thread() = 0;
// The factory used to create the sockets of this port.
- virtual rtc::PacketSocketFactory* socket_factory() const = 0;
+ virtual PacketSocketFactory* socket_factory() const = 0;
// Identifies the generation that this port was created in.
virtual uint32_t generation() const = 0;
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 246778a..f9a015f 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -77,22 +77,22 @@
#include "test/scoped_key_value_config.h"
#include "test/wait_until.h"
-using rtc::AsyncListenSocket;
using rtc::AsyncPacketSocket;
using rtc::ByteBufferReader;
using rtc::ByteBufferWriter;
using rtc::PacketSocketFactory;
-using rtc::Socket;
using ::testing::Eq;
using ::testing::IsNull;
using ::testing::IsTrue;
using ::testing::NotNull;
+using ::webrtc::AsyncListenSocket;
using webrtc::IceCandidateType;
using ::webrtc::NAT_ADDR_RESTRICTED;
using ::webrtc::NAT_OPEN_CONE;
using ::webrtc::NAT_PORT_RESTRICTED;
using ::webrtc::NAT_SYMMETRIC;
using ::webrtc::NATType;
+using ::webrtc::Socket;
using ::webrtc::SocketAddress;
namespace cricket {
@@ -232,10 +232,10 @@
}
return static_cast<int>(size);
}
- virtual int SetOption(rtc::Socket::Option /* opt */, int /* value */) {
+ virtual int SetOption(webrtc::Socket::Option /* opt */, int /* value */) {
return 0;
}
- virtual int GetOption(rtc::Socket::Option opt, int* value) { return -1; }
+ virtual int GetOption(webrtc::Socket::Option opt, int* value) { return -1; }
virtual int GetError() { return 0; }
void Reset() {
last_stun_buf_.reset();
@@ -246,7 +246,7 @@
}
private:
- void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
webrtc::PortInterface::SignalSentPacket(sent_packet);
}
@@ -427,7 +427,7 @@
class PortTest : public ::testing::Test, public sigslot::has_slots<> {
public:
PortTest()
- : ss_(new rtc::VirtualSocketServer()),
+ : ss_(new webrtc::VirtualSocketServer()),
main_(ss_.get()),
socket_factory_(ss_.get()),
nat_factory1_(ss_.get(), kNatAddr1, SocketAddress()),
@@ -601,7 +601,7 @@
}
std::unique_ptr<StunPort> CreateStunPort(
const SocketAddress& addr,
- rtc::PacketSocketFactory* socket_factory) {
+ webrtc::PacketSocketFactory* socket_factory) {
ServerAddresses stun_servers;
stun_servers.insert(kStunAddr);
auto port = StunPort::Create({.network_thread = &main_,
@@ -933,26 +933,26 @@
void OnDestroyed(webrtc::PortInterface* port) { ++ports_destroyed_; }
int ports_destroyed() const { return ports_destroyed_; }
- rtc::BasicPacketSocketFactory* nat_socket_factory1() {
+ webrtc::BasicPacketSocketFactory* nat_socket_factory1() {
return &nat_socket_factory1_;
}
- rtc::VirtualSocketServer* vss() { return ss_.get(); }
+ webrtc::VirtualSocketServer* vss() { return ss_.get(); }
private:
// When a "create port" helper method is called with an IP, we create a
// Network with that IP and add it to this list. Using a list instead of a
// vector so that when it grows, pointers aren't invalidated.
std::list<rtc::Network> networks_;
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
- rtc::BasicPacketSocketFactory socket_factory_;
+ webrtc::BasicPacketSocketFactory socket_factory_;
std::unique_ptr<webrtc::NATServer> nat_server1_;
std::unique_ptr<webrtc::NATServer> nat_server2_;
webrtc::NATSocketFactory nat_factory1_;
webrtc::NATSocketFactory nat_factory2_;
- rtc::BasicPacketSocketFactory nat_socket_factory1_;
- rtc::BasicPacketSocketFactory nat_socket_factory2_;
+ webrtc::BasicPacketSocketFactory nat_socket_factory1_;
+ webrtc::BasicPacketSocketFactory nat_socket_factory2_;
webrtc::TestStunServer::StunServerPtr stun_server_;
webrtc::TestTurnServer turn_server_;
std::string username_;
@@ -1140,7 +1140,7 @@
webrtc::IsRtcOk());
}
-class FakePacketSocketFactory : public rtc::PacketSocketFactory {
+class FakePacketSocketFactory : public webrtc::PacketSocketFactory {
public:
FakePacketSocketFactory()
: next_udp_socket_(NULL), next_server_tcp_socket_(NULL) {}
@@ -1168,7 +1168,7 @@
AsyncPacketSocket* CreateClientTcpSocket(
const SocketAddress& local_address,
const SocketAddress& remote_address,
- const rtc::PacketSocketTcpOptions& opts) override {
+ const webrtc::PacketSocketTcpOptions& opts) override {
EXPECT_TRUE(next_client_tcp_socket_.has_value());
AsyncPacketSocket* result = *next_client_tcp_socket_;
next_client_tcp_socket_ = nullptr;
@@ -1423,7 +1423,7 @@
{.timeout = webrtc::TimeDelta::Millis(kDefaultTimeout)}),
webrtc::IsRtcOk());
- std::unique_ptr<rtc::Socket> server(
+ std::unique_ptr<webrtc::Socket> server(
vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM));
// Bind but not listen.
EXPECT_EQ(0, server->Bind(kLocalAddr2));
@@ -1743,7 +1743,7 @@
auto port1 = CreateTcpPort(kLocalAddr1);
port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
int option_value = -1;
- int success = port1->GetOption(rtc::Socket::OPT_NODELAY, &option_value);
+ int success = port1->GetOption(webrtc::Socket::OPT_NODELAY, &option_value);
ASSERT_EQ(0, success); // GetOption() should complete successfully w/ 0
EXPECT_EQ(1, option_value);
@@ -1785,14 +1785,14 @@
option_value = -1;
success = static_cast<TCPConnection*>(ch1.conn())
->socket()
- ->GetOption(rtc::Socket::OPT_NODELAY, &option_value);
+ ->GetOption(webrtc::Socket::OPT_NODELAY, &option_value);
ASSERT_EQ(0, success);
EXPECT_EQ(1, option_value);
option_value = -1;
success = static_cast<TCPConnection*>(ch2.conn())
->socket()
- ->GetOption(rtc::Socket::OPT_NODELAY, &option_value);
+ ->GetOption(webrtc::Socket::OPT_NODELAY, &option_value);
ASSERT_EQ(0, success);
EXPECT_EQ(1, option_value);
}
@@ -1997,28 +1997,28 @@
TEST_F(PortTest, TestDefaultDscpValue) {
int dscp;
auto udpport = CreateUdpPort(kLocalAddr1);
- EXPECT_EQ(0, udpport->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_CS6));
- EXPECT_EQ(0, udpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+ EXPECT_EQ(0, udpport->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_CS6));
+ EXPECT_EQ(0, udpport->GetOption(webrtc::Socket::OPT_DSCP, &dscp));
auto tcpport = CreateTcpPort(kLocalAddr1);
- EXPECT_EQ(0, tcpport->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF31));
- EXPECT_EQ(0, tcpport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+ EXPECT_EQ(0, tcpport->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_AF31));
+ EXPECT_EQ(0, tcpport->GetOption(webrtc::Socket::OPT_DSCP, &dscp));
EXPECT_EQ(rtc::DSCP_AF31, dscp);
auto stunport = CreateStunPort(kLocalAddr1, nat_socket_factory1());
- EXPECT_EQ(0, stunport->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF41));
- EXPECT_EQ(0, stunport->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+ EXPECT_EQ(0, stunport->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_AF41));
+ EXPECT_EQ(0, stunport->GetOption(webrtc::Socket::OPT_DSCP, &dscp));
EXPECT_EQ(rtc::DSCP_AF41, dscp);
auto turnport1 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
webrtc::PROTO_UDP, webrtc::PROTO_UDP);
// Socket is created in PrepareAddress.
turnport1->PrepareAddress();
- EXPECT_EQ(0, turnport1->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_CS7));
- EXPECT_EQ(0, turnport1->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+ EXPECT_EQ(0, turnport1->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_CS7));
+ EXPECT_EQ(0, turnport1->GetOption(webrtc::Socket::OPT_DSCP, &dscp));
EXPECT_EQ(rtc::DSCP_CS7, dscp);
// This will verify correct value returned without the socket.
auto turnport2 = CreateTurnPort(kLocalAddr1, nat_socket_factory1(),
webrtc::PROTO_UDP, webrtc::PROTO_UDP);
- EXPECT_EQ(0, turnport2->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_CS6));
- EXPECT_EQ(0, turnport2->GetOption(rtc::Socket::OPT_DSCP, &dscp));
+ EXPECT_EQ(0, turnport2->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_CS6));
+ EXPECT_EQ(0, turnport2->GetOption(webrtc::Socket::OPT_DSCP, &dscp));
EXPECT_EQ(rtc::DSCP_CS6, dscp);
}
diff --git a/p2p/base/regathering_controller_unittest.cc b/p2p/base/regathering_controller_unittest.cc
index 6b66b90..e739100 100644
--- a/p2p/base/regathering_controller_unittest.cc
+++ b/p2p/base/regathering_controller_unittest.cc
@@ -49,11 +49,11 @@
public sigslot::has_slots<> {
public:
RegatheringControllerTest()
- : vss_(std::make_unique<rtc::VirtualSocketServer>()),
+ : vss_(std::make_unique<VirtualSocketServer>()),
thread_(vss_.get()),
ice_transport_(std::make_unique<MockIceTransport>()),
packet_socket_factory_(
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
+ std::make_unique<BasicPacketSocketFactory>(vss_.get())),
allocator_(std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
packet_socket_factory_.get(),
@@ -110,11 +110,11 @@
private:
webrtc::test::ScopedKeyValueConfig field_trials_;
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread thread_;
std::unique_ptr<cricket::IceTransportInternal> ice_transport_;
std::unique_ptr<BasicRegatheringController> regathering_controller_;
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
+ std::unique_ptr<PacketSocketFactory> packet_socket_factory_;
std::unique_ptr<cricket::PortAllocator> allocator_;
std::unique_ptr<cricket::PortAllocatorSession> allocator_session_;
std::map<cricket::IceRegatheringReason, int> count_;
diff --git a/p2p/base/stun_port.cc b/p2p/base/stun_port.cc
index 9c8f712..aa7bf8b 100644
--- a/p2p/base/stun_port.cc
+++ b/p2p/base/stun_port.cc
@@ -122,7 +122,7 @@
};
UDPPort::AddressResolver::AddressResolver(
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
std::function<void(const webrtc::SocketAddress&, int)> done_callback)
: socket_factory_(factory), done_(std::move(done_callback)) {}
@@ -162,7 +162,7 @@
UDPPort::UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress)
: Port(args, type),
request_manager_(
@@ -224,7 +224,7 @@
void UDPPort::PrepareAddress() {
RTC_DCHECK(request_manager_.empty());
- if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
+ if (socket_->GetState() == webrtc::AsyncPacketSocket::STATE_BOUND) {
OnLocalAddressReady(socket_, socket_->GetLocalAddress());
}
}
@@ -312,15 +312,15 @@
return dscp_;
}
-int UDPPort::SetOption(rtc::Socket::Option opt, int value) {
- if (opt == rtc::Socket::OPT_DSCP) {
+int UDPPort::SetOption(webrtc::Socket::Option opt, int value) {
+ if (opt == webrtc::Socket::OPT_DSCP) {
// Save value for future packets we instantiate.
dscp_ = static_cast<rtc::DiffServCodePoint>(value);
}
return socket_->SetOption(opt, value);
}
-int UDPPort::GetOption(rtc::Socket::Option opt, int* value) {
+int UDPPort::GetOption(webrtc::Socket::Option opt, int* value) {
return socket_->GetOption(opt, value);
}
@@ -328,7 +328,7 @@
return error_;
}
-bool UDPPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+bool UDPPort::HandleIncomingPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
// All packets given to UDP port will be consumed.
OnReadPacket(socket, packet);
@@ -351,7 +351,7 @@
stun_keepalive_delay_ = delay.value_or(STUN_KEEPALIVE_INTERVAL);
}
-void UDPPort::OnLocalAddressReady(rtc::AsyncPacketSocket* /* socket */,
+void UDPPort::OnLocalAddressReady(webrtc::AsyncPacketSocket* /* socket */,
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
@@ -373,7 +373,7 @@
MaybeSetPortCompleteOrError();
}
-void UDPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void UDPPort::OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(socket == socket_);
RTC_DCHECK(!packet.source_address().IsUnresolvedIP());
@@ -397,12 +397,12 @@
}
}
-void UDPPort::OnSentPacket(rtc::AsyncPacketSocket* /* socket */,
+void UDPPort::OnSentPacket(webrtc::AsyncPacketSocket* /* socket */,
const rtc::SentPacket& sent_packet) {
webrtc::PortInterface::SignalSentPacket(sent_packet);
}
-void UDPPort::OnReadyToSend(rtc::AsyncPacketSocket* /* socket */) {
+void UDPPort::OnReadyToSend(webrtc::AsyncPacketSocket* /* socket */) {
Port::OnReadyToSend();
}
@@ -461,7 +461,7 @@
if (stun_addr.IsUnresolvedIP()) {
ResolveStunAddress(stun_addr);
- } else if (socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND) {
+ } else if (socket_->GetState() == webrtc::AsyncPacketSocket::STATE_BOUND) {
// Check if `server_addr_` is compatible with the port's ip.
if (IsCompatibleAddress(stun_addr)) {
request_manager_.Send(
@@ -628,7 +628,7 @@
std::unique_ptr<StunPort> StunPort::Create(
webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
diff --git a/p2p/base/stun_port.h b/p2p/base/stun_port.h
index 69363f6..29f2f73 100644
--- a/p2p/base/stun_port.h
+++ b/p2p/base/stun_port.h
@@ -37,7 +37,7 @@
public:
static std::unique_ptr<UDPPort> Create(
const PortParametersRef& args,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress,
std::optional<int> stun_keepalive_interval) {
// Using `new` to access a non-public constructor.
@@ -53,9 +53,9 @@
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<UDPPort>
Create(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
bool emit_local_for_anyaddress,
@@ -89,7 +89,7 @@
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<UDPPort>
Create(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
@@ -123,11 +123,11 @@
Connection* CreateConnection(const Candidate& address,
CandidateOrigin origin) override;
- int SetOption(rtc::Socket::Option opt, int value) override;
- int GetOption(rtc::Socket::Option opt, int* value) override;
+ int SetOption(webrtc::Socket::Option opt, int value) override;
+ int GetOption(webrtc::Socket::Option opt, int* value) override;
int GetError() override;
- bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+ bool HandleIncomingPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) override;
bool SupportsProtocol(absl::string_view protocol) const override;
@@ -149,7 +149,7 @@
protected:
UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
bool emit_local_for_anyaddress);
UDPPort(const PortParametersRef& args,
webrtc::IceCandidateType type,
@@ -168,18 +168,18 @@
rtc::DiffServCodePoint StunDscpValue() const override;
- void OnLocalAddressReady(rtc::AsyncPacketSocket* socket,
+ void OnLocalAddressReady(webrtc::AsyncPacketSocket* socket,
const webrtc::SocketAddress& address);
void PostAddAddress(bool is_final) override;
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) override;
- void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+ void OnReadyToSend(webrtc::AsyncPacketSocket* socket);
// This method will send STUN binding request if STUN server address is set.
void MaybePrepareStunCandidate();
@@ -199,7 +199,7 @@
class AddressResolver {
public:
explicit AddressResolver(
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
std::function<void(const webrtc::SocketAddress&, int)> done_callback);
void Resolve(const webrtc::SocketAddress& address,
@@ -214,7 +214,7 @@
std::unique_ptr<webrtc::AsyncDnsResolverInterface>>
ResolverMap;
- rtc::PacketSocketFactory* socket_factory_;
+ webrtc::PacketSocketFactory* socket_factory_;
// 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.
@@ -265,7 +265,7 @@
ServerAddresses bind_request_succeeded_servers_;
ServerAddresses bind_request_failed_servers_;
StunRequestManager request_manager_;
- rtc::AsyncPacketSocket* socket_;
+ webrtc::AsyncPacketSocket* socket_;
int error_;
int send_error_count_ = 0;
std::unique_ptr<AddressResolver> resolver_;
@@ -294,7 +294,7 @@
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<StunPort>
Create(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
diff --git a/p2p/base/stun_port_unittest.cc b/p2p/base/stun_port_unittest.cc
index 3a65d2f..e1f92e5 100644
--- a/p2p/base/stun_port_unittest.cc
+++ b/p2p/base/stun_port_unittest.cc
@@ -135,7 +135,7 @@
StunPortTestBase(const webrtc::IPAddress address,
const std::set<webrtc::SocketAddress>& stun_server_addresses,
const webrtc::SocketAddress& nat_server_address)
- : ss_(new rtc::VirtualSocketServer()),
+ : ss_(new webrtc::VirtualSocketServer()),
thread_(ss_.get()),
nat_factory_(ss_.get(), nat_server_address, nat_server_address),
nat_socket_factory_(&nat_factory_),
@@ -160,13 +160,13 @@
addr, thread_, ss_.get(), addr);
}
- virtual rtc::PacketSocketFactory* socket_factory() {
+ virtual webrtc::PacketSocketFactory* socket_factory() {
return &nat_socket_factory_;
}
- rtc::SocketServer* ss() const { return ss_.get(); }
+ webrtc::SocketServer* ss() const { return ss_.get(); }
cricket::UDPPort* port() const { return stun_port_.get(); }
- rtc::AsyncPacketSocket* socket() const { return socket_.get(); }
+ webrtc::AsyncPacketSocket* socket() const { return socket_.get(); }
bool done() const { return done_; }
bool error() const { return error_; }
@@ -211,7 +211,7 @@
void CreateSharedUdpPort(
const webrtc::SocketAddress& server_addr,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
const webrtc::FieldTrialsView* field_trials = nullptr) {
if (socket) {
socket_.reset(socket);
@@ -244,7 +244,7 @@
void PrepareAddress() { stun_port_->PrepareAddress(); }
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
stun_port_->HandleIncomingPacket(socket, packet);
}
@@ -295,19 +295,19 @@
webrtc::TestStunServer* stun_server_2() { return stun_servers_[1].get(); }
rtc::AutoSocketServerThread& thread() { return thread_; }
- rtc::SocketFactory* nat_factory() { return &nat_factory_; }
+ webrtc::SocketFactory* nat_factory() { return &nat_factory_; }
private:
std::vector<rtc::Network> networks_;
rtc::Network* network_;
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread thread_;
webrtc::NATSocketFactory nat_factory_;
- rtc::BasicPacketSocketFactory nat_socket_factory_;
+ webrtc::BasicPacketSocketFactory nat_socket_factory_;
std::unique_ptr<cricket::UDPPort> stun_port_;
std::vector<webrtc::TestStunServer::StunServerPtr> stun_servers_;
- std::unique_ptr<rtc::AsyncPacketSocket> socket_;
+ std::unique_ptr<webrtc::AsyncPacketSocket> socket_;
std::unique_ptr<rtc::MdnsResponderProvider> mdns_responder_provider_;
std::unique_ptr<webrtc::NATServer> nat_server_;
bool done_;
@@ -401,7 +401,7 @@
StunPortWithMockDnsResolverTest()
: StunPortTest(), socket_factory_(nat_factory()) {}
- rtc::PacketSocketFactory* socket_factory() override {
+ webrtc::PacketSocketFactory* socket_factory() override {
return &socket_factory_;
}
@@ -710,7 +710,7 @@
webrtc::IsRtcOk());
}
-class MockAsyncPacketSocket : public rtc::AsyncPacketSocket {
+class MockAsyncPacketSocket : public webrtc::AsyncPacketSocket {
public:
~MockAsyncPacketSocket() = default;
@@ -732,9 +732,12 @@
MOCK_METHOD(State, GetState, (), (const, override));
MOCK_METHOD(int,
GetOption,
- (rtc::Socket::Option opt, int* value),
+ (webrtc::Socket::Option opt, int* value),
(override));
- MOCK_METHOD(int, SetOption, (rtc::Socket::Option opt, int value), (override));
+ MOCK_METHOD(int,
+ SetOption,
+ (webrtc::Socket::Option opt, int value),
+ (override));
MOCK_METHOD(int, GetError, (), (const, override));
MOCK_METHOD(void, SetError, (int error), (override));
};
@@ -745,7 +748,7 @@
CreateSharedUdpPort(kStunServerAddr1, socket);
EXPECT_CALL(*socket, GetLocalAddress()).WillRepeatedly(Return(kPrivateIP));
EXPECT_CALL(*socket, GetState())
- .WillRepeatedly(Return(rtc::AsyncPacketSocket::STATE_BOUND));
+ .WillRepeatedly(Return(webrtc::AsyncPacketSocket::STATE_BOUND));
EXPECT_CALL(*socket, SetOption(_, _)).WillRepeatedly(Return(0));
// If DSCP is not set on the socket, stun packets should have no value.
@@ -756,7 +759,7 @@
PrepareAddress();
// Once it is set transport wide, they should inherit that value.
- port()->SetOption(rtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
+ port()->SetOption(webrtc::Socket::OPT_DSCP, rtc::DSCP_AF41);
EXPECT_CALL(*socket, SendTo(_, _, _,
::testing::Field(&rtc::PacketOptions::dscp,
Eq(rtc::DSCP_AF41))))
@@ -856,7 +859,7 @@
StunIPv6PortTestWithMockDnsResolver()
: StunIPv6PortTest(), socket_factory_(ss()) {}
- rtc::PacketSocketFactory* socket_factory() override {
+ webrtc::PacketSocketFactory* socket_factory() override {
return &socket_factory_;
}
diff --git a/p2p/base/tcp_port.cc b/p2p/base/tcp_port.cc
index 5ebecc6..6d035e9 100644
--- a/p2p/base/tcp_port.cc
+++ b/p2p/base/tcp_port.cc
@@ -106,7 +106,7 @@
// Set TCP_NODELAY (via OPT_NODELAY) for improved performance; this causes
// small media packets to be sent immediately rather than being buffered up,
// reducing latency.
- SetOption(rtc::Socket::OPT_NODELAY, 1);
+ SetOption(webrtc::Socket::OPT_NODELAY, 1);
}
TCPPort::~TCPPort() {
@@ -145,7 +145,8 @@
}
TCPConnection* conn = NULL;
- if (rtc::AsyncPacketSocket* socket = GetIncoming(address.address(), true)) {
+ if (webrtc::AsyncPacketSocket* socket =
+ GetIncoming(address.address(), true)) {
// Incoming connection; we already created a socket and connected signals,
// so we need to hand off the "read packet" responsibility to
// TCPConnection.
@@ -193,7 +194,7 @@
const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) {
- rtc::AsyncPacketSocket* socket = NULL;
+ webrtc::AsyncPacketSocket* socket = NULL;
TCPConnection* conn = static_cast<TCPConnection*>(GetConnection(addr));
// For Connection, this is the code path used by Ping() to establish
@@ -238,7 +239,7 @@
return sent;
}
-int TCPPort::GetOption(rtc::Socket::Option opt, int* value) {
+int TCPPort::GetOption(webrtc::Socket::Option opt, int* value) {
auto const& it = socket_options_.find(opt);
if (it == socket_options_.end()) {
return -1;
@@ -247,7 +248,7 @@
return 0;
}
-int TCPPort::SetOption(rtc::Socket::Option opt, int value) {
+int TCPPort::SetOption(webrtc::Socket::Option opt, int value) {
socket_options_[opt] = value;
return 0;
}
@@ -264,8 +265,8 @@
return webrtc::PROTO_TCP;
}
-void TCPPort::OnNewConnection(rtc::AsyncListenSocket* socket,
- rtc::AsyncPacketSocket* new_socket) {
+void TCPPort::OnNewConnection(webrtc::AsyncListenSocket* socket,
+ webrtc::AsyncPacketSocket* new_socket) {
RTC_DCHECK_EQ(socket, listen_socket_.get());
for (const auto& option : socket_options_) {
@@ -299,9 +300,10 @@
listen_socket_->SignalNewConnection.connect(this, &TCPPort::OnNewConnection);
}
-rtc::AsyncPacketSocket* TCPPort::GetIncoming(const webrtc::SocketAddress& addr,
- bool remove) {
- rtc::AsyncPacketSocket* socket = NULL;
+webrtc::AsyncPacketSocket* TCPPort::GetIncoming(
+ const webrtc::SocketAddress& addr,
+ bool remove) {
+ webrtc::AsyncPacketSocket* socket = NULL;
for (std::list<Incoming>::iterator it = incoming_.begin();
it != incoming_.end(); ++it) {
if (it->addr == addr) {
@@ -314,17 +316,17 @@
return socket;
}
-void TCPPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void TCPPort::OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
Port::OnReadPacket(packet, webrtc::PROTO_TCP);
}
-void TCPPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
+void TCPPort::OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
webrtc::PortInterface::SignalSentPacket(sent_packet);
}
-void TCPPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
+void TCPPort::OnReadyToSend(webrtc::AsyncPacketSocket* socket) {
Port::OnReadyToSend();
}
@@ -334,7 +336,7 @@
// we decide it is also applicable here.
TCPConnection::TCPConnection(rtc::WeakPtr<Port> tcp_port,
const Candidate& candidate,
- rtc::AsyncPacketSocket* socket)
+ webrtc::AsyncPacketSocket* socket)
: Connection(std::move(tcp_port), 0, candidate),
socket_(socket),
error_(0),
@@ -412,7 +414,7 @@
return error_;
}
-void TCPConnection::OnSentPacket(rtc::AsyncPacketSocket* socket,
+void TCPConnection::OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
RTC_DCHECK_RUN_ON(network_thread());
if (port()) {
@@ -435,7 +437,7 @@
RTC_DCHECK(write_state() == STATE_WRITABLE);
}
-void TCPConnection::OnConnect(rtc::AsyncPacketSocket* socket) {
+void TCPConnection::OnConnect(webrtc::AsyncPacketSocket* socket) {
RTC_DCHECK_EQ(socket, socket_.get());
if (!port_) {
@@ -494,7 +496,7 @@
connection_pending_ = false;
}
-void TCPConnection::OnClose(rtc::AsyncPacketSocket* socket, int error) {
+void TCPConnection::OnClose(webrtc::AsyncPacketSocket* socket, int error) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK_EQ(socket, socket_.get());
RTC_LOG(LS_INFO) << ToString() << ": Connection closed with error " << error;
@@ -553,14 +555,14 @@
error_ = EPIPE;
}
-void TCPConnection::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void TCPConnection::OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK_EQ(socket, socket_.get());
Connection::OnReadPacket(packet);
}
-void TCPConnection::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
+void TCPConnection::OnReadyToSend(webrtc::AsyncPacketSocket* socket) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK_EQ(socket, socket_.get());
Connection::OnReadyToSend();
@@ -577,14 +579,14 @@
void TCPConnection::CreateOutgoingTcpSocket() {
RTC_DCHECK(outgoing_);
int opts = (remote_candidate().protocol() == SSLTCP_PROTOCOL_NAME)
- ? rtc::PacketSocketFactory::OPT_TLS_FAKE
+ ? webrtc::PacketSocketFactory::OPT_TLS_FAKE
: 0;
if (socket_) {
DisconnectSocketSignals(socket_.get());
}
- rtc::PacketSocketTcpOptions tcp_opts;
+ webrtc::PacketSocketTcpOptions tcp_opts;
tcp_opts.opts = opts;
socket_.reset(port()->socket_factory()->CreateClientTcpSocket(
webrtc::SocketAddress(port()->Network()->GetBestIP(), 0),
@@ -610,7 +612,7 @@
}
}
-void TCPConnection::ConnectSocketSignals(rtc::AsyncPacketSocket* socket) {
+void TCPConnection::ConnectSocketSignals(webrtc::AsyncPacketSocket* socket) {
// Incoming connections register SignalSentPacket and SignalReadyToSend
// directly on the port in TCPPort::OnNewConnection.
if (outgoing_) {
@@ -632,7 +634,7 @@
});
}
-void TCPConnection::DisconnectSocketSignals(rtc::AsyncPacketSocket* socket) {
+void TCPConnection::DisconnectSocketSignals(webrtc::AsyncPacketSocket* socket) {
if (outgoing_) {
// Incoming connections do not register these signals in TCPConnection.
socket->SignalConnect.disconnect(this);
diff --git a/p2p/base/tcp_port.h b/p2p/base/tcp_port.h
index aa812ad..ea72432 100644
--- a/p2p/base/tcp_port.h
+++ b/p2p/base/tcp_port.h
@@ -47,7 +47,7 @@
[[deprecated("Pass arguments using PortParametersRef")]] static std::
unique_ptr<TCPPort>
Create(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
@@ -73,8 +73,8 @@
// Options apply to accepted sockets.
// TODO(bugs.webrtc.org/13065): Apply also to outgoing and existing
// connections.
- int GetOption(rtc::Socket::Option opt, int* value) override;
- int SetOption(rtc::Socket::Option opt, int value) override;
+ int GetOption(webrtc::Socket::Option opt, int* value) override;
+ int SetOption(webrtc::Socket::Option opt, int value) override;
int GetError() override;
bool SupportsProtocol(absl::string_view protocol) const override;
webrtc::ProtocolType GetProtocol() const override;
@@ -93,36 +93,36 @@
bool payload) override;
// Accepts incoming TCP connection.
- void OnNewConnection(rtc::AsyncListenSocket* socket,
- rtc::AsyncPacketSocket* new_socket);
+ void OnNewConnection(webrtc::AsyncListenSocket* socket,
+ webrtc::AsyncPacketSocket* new_socket);
private:
struct Incoming {
webrtc::SocketAddress addr;
- rtc::AsyncPacketSocket* socket;
+ webrtc::AsyncPacketSocket* socket;
};
void TryCreateServerSocket();
- rtc::AsyncPacketSocket* GetIncoming(const webrtc::SocketAddress& addr,
- bool remove = false);
+ webrtc::AsyncPacketSocket* GetIncoming(const webrtc::SocketAddress& addr,
+ bool remove = false);
// Receives packet signal from the local TCP Socket.
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) override;
- void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+ void OnReadyToSend(webrtc::AsyncPacketSocket* socket);
bool allow_listen_;
- std::unique_ptr<rtc::AsyncListenSocket> listen_socket_;
+ std::unique_ptr<webrtc::AsyncListenSocket> listen_socket_;
// Options to be applied to accepted sockets.
// TODO(bugs.webrtc:13065): Configure connect/accept in the same way, but
// currently, setting OPT_NODELAY for client sockets is done (unconditionally)
// by BasicPacketSocketFactory::CreateClientTcpSocket.
- webrtc::flat_map<rtc::Socket::Option, int> socket_options_;
+ webrtc::flat_map<webrtc::Socket::Option, int> socket_options_;
int error_;
std::list<Incoming> incoming_;
@@ -135,7 +135,7 @@
// Connection is outgoing unless socket is specified
TCPConnection(rtc::WeakPtr<Port> tcp_port,
const Candidate& candidate,
- rtc::AsyncPacketSocket* socket = nullptr);
+ webrtc::AsyncPacketSocket* socket = nullptr);
~TCPConnection() override;
int Send(const void* data,
@@ -143,7 +143,7 @@
const rtc::PacketOptions& options) override;
int GetError() override;
- rtc::AsyncPacketSocket* socket() { return socket_.get(); }
+ webrtc::AsyncPacketSocket* socket() { return socket_.get(); }
// Allow test cases to overwrite the default timeout period.
int reconnection_timeout() const { return reconnection_timeout_; }
@@ -166,19 +166,19 @@
void CreateOutgoingTcpSocket() RTC_RUN_ON(network_thread());
- void ConnectSocketSignals(rtc::AsyncPacketSocket* socket)
+ void ConnectSocketSignals(webrtc::AsyncPacketSocket* socket)
RTC_RUN_ON(network_thread());
- void DisconnectSocketSignals(rtc::AsyncPacketSocket* socket)
+ void DisconnectSocketSignals(webrtc::AsyncPacketSocket* socket)
RTC_RUN_ON(network_thread());
- void OnConnect(rtc::AsyncPacketSocket* socket);
- void OnClose(rtc::AsyncPacketSocket* socket, int error);
- void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ void OnConnect(webrtc::AsyncPacketSocket* socket);
+ void OnClose(webrtc::AsyncPacketSocket* socket, int error);
+ void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet);
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+ void OnReadyToSend(webrtc::AsyncPacketSocket* socket);
void OnDestroyed(Connection* c);
TCPPort* tcp_port() {
@@ -186,7 +186,7 @@
return static_cast<TCPPort*>(port());
}
- std::unique_ptr<rtc::AsyncPacketSocket> socket_;
+ std::unique_ptr<webrtc::AsyncPacketSocket> socket_;
int error_;
const bool outgoing_;
diff --git a/p2p/base/tcp_port_unittest.cc b/p2p/base/tcp_port_unittest.cc
index efcdfcb..587c5e9 100644
--- a/p2p/base/tcp_port_unittest.cc
+++ b/p2p/base/tcp_port_unittest.cc
@@ -86,7 +86,7 @@
class TCPPortTest : public ::testing::Test, public sigslot::has_slots<> {
public:
TCPPortTest()
- : ss_(new rtc::VirtualSocketServer()),
+ : ss_(new webrtc::VirtualSocketServer()),
main_(ss_.get()),
socket_factory_(ss_.get()),
username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
@@ -131,9 +131,9 @@
// Network with that IP and add it to this list. Using a list instead of a
// vector so that when it grows, pointers aren't invalidated.
std::list<rtc::Network> networks_;
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
- rtc::BasicPacketSocketFactory socket_factory_;
+ webrtc::BasicPacketSocketFactory socket_factory_;
std::string username_;
std::string password_;
webrtc::test::ScopedKeyValueConfig field_trials_;
diff --git a/p2p/base/turn_port.cc b/p2p/base/turn_port.cc
index 41d2d00..daf815e 100644
--- a/p2p/base/turn_port.cc
+++ b/p2p/base/turn_port.cc
@@ -207,7 +207,7 @@
};
TurnPort::TurnPort(const PortParametersRef& args,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
@@ -268,9 +268,9 @@
turn_customizer_(customizer) {}
TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address,
@@ -296,7 +296,7 @@
customizer,
tls_cert_verifier) {}
TurnPort::TurnPort(webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
@@ -458,19 +458,19 @@
} else if (server_address_.proto == webrtc::PROTO_TCP ||
server_address_.proto == webrtc::PROTO_TLS) {
RTC_DCHECK(!SharedSocket());
- int opts = rtc::PacketSocketFactory::OPT_STUN;
+ int opts = webrtc::PacketSocketFactory::OPT_STUN;
// Apply server address TLS and insecure bits to options.
if (server_address_.proto == webrtc::PROTO_TLS) {
if (tls_cert_policy_ ==
TlsCertPolicy::TLS_CERT_POLICY_INSECURE_NO_CHECK) {
- opts |= rtc::PacketSocketFactory::OPT_TLS_INSECURE;
+ opts |= webrtc::PacketSocketFactory::OPT_TLS_INSECURE;
} else {
- opts |= rtc::PacketSocketFactory::OPT_TLS;
+ opts |= webrtc::PacketSocketFactory::OPT_TLS;
}
}
- rtc::PacketSocketTcpOptions tcp_options;
+ webrtc::PacketSocketTcpOptions tcp_options;
tcp_options.opts = opts;
tcp_options.tls_alpn_protocols = tls_alpn_protocols_;
tcp_options.tls_elliptic_curves = tls_elliptic_curves_;
@@ -517,7 +517,7 @@
return true;
}
-void TurnPort::OnSocketConnect(rtc::AsyncPacketSocket* socket) {
+void TurnPort::OnSocketConnect(webrtc::AsyncPacketSocket* socket) {
// This slot should only be invoked if we're using a connection-oriented
// protocol.
RTC_DCHECK(server_address_.proto == webrtc::PROTO_TCP ||
@@ -579,7 +579,7 @@
SendRequest(new TurnAllocateRequest(this), 0);
}
-void TurnPort::OnSocketClose(rtc::AsyncPacketSocket* socket, int error) {
+void TurnPort::OnSocketClose(webrtc::AsyncPacketSocket* socket, int error) {
RTC_LOG(LS_WARNING) << ToString()
<< ": Connection with server failed with error: "
<< error;
@@ -664,9 +664,9 @@
return false;
}
-int TurnPort::SetOption(rtc::Socket::Option opt, int value) {
+int TurnPort::SetOption(webrtc::Socket::Option opt, int value) {
// Remember the last requested DSCP value, for STUN traffic.
- if (opt == rtc::Socket::OPT_DSCP)
+ if (opt == webrtc::Socket::OPT_DSCP)
stun_dscp_value_ = static_cast<rtc::DiffServCodePoint>(value);
if (!socket_) {
@@ -678,7 +678,7 @@
return socket_->SetOption(opt, value);
}
-int TurnPort::GetOption(rtc::Socket::Option opt, int* value) {
+int TurnPort::GetOption(webrtc::Socket::Option opt, int* value) {
if (!socket_) {
SocketOptionsMap::const_iterator it = socket_options_.find(opt);
if (it == socket_options_.end()) {
@@ -738,7 +738,7 @@
Port::SendBindingErrorResponse(message, addr, error_code, reason);
}
-bool TurnPort::HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+bool TurnPort::HandleIncomingPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
if (socket != socket_) {
// The packet was received on a shared socket after we've allocated a new
@@ -804,17 +804,17 @@
return true;
}
-void TurnPort::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void TurnPort::OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
HandleIncomingPacket(socket, packet);
}
-void TurnPort::OnSentPacket(rtc::AsyncPacketSocket* socket,
+void TurnPort::OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) {
webrtc::PortInterface::SignalSentPacket(sent_packet);
}
-void TurnPort::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
+void TurnPort::OnReadyToSend(webrtc::AsyncPacketSocket* socket) {
if (ready()) {
Port::OnReadyToSend();
}
diff --git a/p2p/base/turn_port.h b/p2p/base/turn_port.h
index 9878424..348df5b 100644
--- a/p2p/base/turn_port.h
+++ b/p2p/base/turn_port.h
@@ -75,7 +75,7 @@
// Create a TURN port using the shared UDP socket, `socket`.
static std::unique_ptr<TurnPort> Create(const CreateRelayPortArgs& args,
- rtc::AsyncPacketSocket* socket) {
+ webrtc::AsyncPacketSocket* socket) {
if (!Validate(args)) {
return nullptr;
}
@@ -150,11 +150,11 @@
const webrtc::SocketAddress& addr,
const rtc::PacketOptions& options,
bool payload) override;
- int SetOption(rtc::Socket::Option opt, int value) override;
- int GetOption(rtc::Socket::Option opt, int* value) override;
+ int SetOption(webrtc::Socket::Option opt, int value) override;
+ int GetOption(webrtc::Socket::Option opt, int* value) override;
int GetError() override;
- bool HandleIncomingPacket(rtc::AsyncPacketSocket* socket,
+ bool HandleIncomingPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) override;
bool CanHandleIncomingPacketsFrom(
const webrtc::SocketAddress& addr) const override;
@@ -166,16 +166,16 @@
int error_code,
absl::string_view reason) override;
- virtual void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ virtual void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnSentPacket(rtc::AsyncPacketSocket* socket,
+ void OnSentPacket(webrtc::AsyncPacketSocket* socket,
const rtc::SentPacket& sent_packet) override;
- virtual void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+ virtual void OnReadyToSend(webrtc::AsyncPacketSocket* socket);
bool SupportsProtocol(absl::string_view protocol) const override;
- void OnSocketConnect(rtc::AsyncPacketSocket* socket);
- void OnSocketClose(rtc::AsyncPacketSocket* socket, int error);
+ void OnSocketConnect(webrtc::AsyncPacketSocket* socket);
+ void OnSocketClose(webrtc::AsyncPacketSocket* socket, int error);
const std::string& hash() const { return hash_; }
const std::string& nonce() const { return nonce_; }
@@ -184,7 +184,7 @@
void OnAllocateMismatch();
- rtc::AsyncPacketSocket* socket() const { return socket_; }
+ webrtc::AsyncPacketSocket* socket() const { return socket_; }
StunRequestManager& request_manager() { return request_manager_; }
bool HasRequests() { return !request_manager_.empty(); }
@@ -208,7 +208,7 @@
protected:
TurnPort(const PortParametersRef& args,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
const ProtocolAddress& server_address,
const RelayCredentials& credentials,
int server_priority,
@@ -230,9 +230,9 @@
[[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
absl::string_view username,
absl::string_view password,
const ProtocolAddress& server_address,
@@ -246,7 +246,7 @@
[[deprecated("Pass arguments using PortParametersRef")]] TurnPort(
webrtc::TaskQueueBase* thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const rtc::Network* network,
uint16_t min_port,
uint16_t max_port,
@@ -271,7 +271,7 @@
void Close();
private:
- typedef std::map<rtc::Socket::Option, int> SocketOptionsMap;
+ typedef std::map<webrtc::Socket::Option, int> SocketOptionsMap;
typedef std::set<webrtc::SocketAddress> AttemptedServerSet;
static bool AllowedTurnPort(int port,
@@ -348,7 +348,7 @@
RelayCredentials credentials_;
AttemptedServerSet attempted_server_addresses_;
- rtc::AsyncPacketSocket* socket_;
+ webrtc::AsyncPacketSocket* socket_;
SocketOptionsMap socket_options_;
std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
int error_;
diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc
index fcdfd80..4929523 100644
--- a/p2p/base/turn_port_unittest.cc
+++ b/p2p/base/turn_port_unittest.cc
@@ -175,7 +175,7 @@
namespace cricket {
-class TurnPortTestVirtualSocketServer : public rtc::VirtualSocketServer {
+class TurnPortTestVirtualSocketServer : public webrtc::VirtualSocketServer {
public:
TurnPortTestVirtualSocketServer() {
// This configures the virtual socket server to always add a simulated
@@ -184,7 +184,7 @@
UpdateDelayDistribution();
}
- using rtc::VirtualSocketServer::LookupBinding;
+ using webrtc::VirtualSocketServer::LookupBinding;
};
class TestConnectionWrapper : public sigslot::has_slots<> {
@@ -243,7 +243,7 @@
turn_unknown_address_ = true;
}
void OnUdpPortComplete(Port* port) { udp_ready_ = true; }
- void OnSocketReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnSocketReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
turn_port_->HandleIncomingPacket(socket, packet);
}
@@ -264,8 +264,8 @@
connection->DeregisterReceivedPacketCallback();
}
- rtc::Socket* CreateServerSocket(const SocketAddress addr) {
- rtc::Socket* socket = ss_->CreateSocket(AF_INET, SOCK_STREAM);
+ webrtc::Socket* CreateServerSocket(const SocketAddress addr) {
+ webrtc::Socket* socket = ss_->CreateSocket(AF_INET, SOCK_STREAM);
EXPECT_GE(socket->Bind(addr), 0);
EXPECT_GE(socket->Listen(5), 0);
return socket;
@@ -629,7 +629,7 @@
// Make a socket and bind it to the local port, to make extra sure no
// packet is sent to this address.
- std::unique_ptr<rtc::Socket> loopback_socket(ss_->CreateSocket(
+ std::unique_ptr<webrtc::Socket> loopback_socket(ss_->CreateSocket(
AF_INET,
protocol_type == webrtc::PROTO_UDP ? SOCK_DGRAM : SOCK_STREAM));
ASSERT_NE(nullptr, loopback_socket.get());
@@ -660,7 +660,7 @@
char buf[1];
EXPECT_EQ(-1, loopback_socket->Recv(&buf, 1, nullptr));
} else {
- std::unique_ptr<rtc::Socket> accepted_socket(
+ std::unique_ptr<webrtc::Socket> accepted_socket(
loopback_socket->Accept(nullptr));
EXPECT_EQ(nullptr, accepted_socket.get());
}
@@ -940,7 +940,7 @@
}
protected:
- virtual rtc::PacketSocketFactory* socket_factory() {
+ virtual webrtc::PacketSocketFactory* socket_factory() {
return &socket_factory_;
}
@@ -952,7 +952,7 @@
std::list<rtc::Network> networks_;
std::unique_ptr<TurnPortTestVirtualSocketServer> ss_;
rtc::AutoSocketServerThread main_;
- std::unique_ptr<rtc::AsyncPacketSocket> socket_;
+ std::unique_ptr<webrtc::AsyncPacketSocket> socket_;
webrtc::TestTurnServer turn_server_;
std::unique_ptr<TurnPort> turn_port_;
std::unique_ptr<UDPPort> udp_port_;
@@ -972,7 +972,7 @@
cricket::IceCandidateErrorEvent error_event_;
private:
- rtc::BasicPacketSocketFactory socket_factory_;
+ webrtc::BasicPacketSocketFactory socket_factory_;
};
TEST_F(TurnPortTest, TestTurnPortType) {
@@ -1031,7 +1031,7 @@
// Do a normal TURN allocation.
TEST_F(TurnPortTest, TestTurnAllocate) {
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnUdpProtoAddr);
- EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10 * 1024));
+ EXPECT_EQ(0, turn_port_->SetOption(webrtc::Socket::OPT_SNDBUF, 10 * 1024));
TestTurnAllocateSucceeds(kSimulatedRtt * 2);
}
@@ -1125,7 +1125,7 @@
TEST_F(TurnPortTest, TestTurnTcpAllocate) {
turn_server_.AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
CreateTurnPort(kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
- EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10 * 1024));
+ EXPECT_EQ(0, turn_port_->SetOption(webrtc::Socket::OPT_SNDBUF, 10 * 1024));
TestTurnAllocateSucceeds(kSimulatedRtt * 3);
}
@@ -1140,7 +1140,7 @@
turn_server_.AddInternalSocket(kTurnTcpIntAddr, webrtc::PROTO_TCP);
CreateTurnPort(kLocalAddr1, kTurnUsername, kTurnPassword, kTurnTcpProtoAddr);
- EXPECT_EQ(0, turn_port_->SetOption(rtc::Socket::OPT_SNDBUF, 10 * 1024));
+ EXPECT_EQ(0, turn_port_->SetOption(webrtc::Socket::OPT_SNDBUF, 10 * 1024));
TestTurnAllocateSucceeds(kSimulatedRtt * 3);
// Verify that the socket actually used localhost, otherwise this test isn't
@@ -2199,7 +2199,7 @@
TurnPortWithMockDnsResolverTest()
: TurnPortTest(), socket_factory_(ss_.get()) {}
- rtc::PacketSocketFactory* socket_factory() override {
+ webrtc::PacketSocketFactory* socket_factory() override {
return &socket_factory_;
}
diff --git a/p2p/client/basic_port_allocator.cc b/p2p/client/basic_port_allocator.cc
index 94c80d7..db08587 100644
--- a/p2p/client/basic_port_allocator.cc
+++ b/p2p/client/basic_port_allocator.cc
@@ -184,7 +184,7 @@
// BasicPortAllocator
BasicPortAllocator::BasicPortAllocator(
rtc::NetworkManager* network_manager,
- rtc::PacketSocketFactory* socket_factory,
+ webrtc::PacketSocketFactory* socket_factory,
webrtc::TurnCustomizer* customizer,
RelayPortFactoryInterface* relay_port_factory,
const webrtc::FieldTrialsView* field_trials)
@@ -1673,7 +1673,7 @@
}
}
-void AllocationSequence::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void AllocationSequence::OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(socket == udp_socket_.get());
diff --git a/p2p/client/basic_port_allocator.h b/p2p/client/basic_port_allocator.h
index bcc3db0..75ee117 100644
--- a/p2p/client/basic_port_allocator.h
+++ b/p2p/client/basic_port_allocator.h
@@ -48,7 +48,7 @@
// optional. All pointers are owned by caller and must have a life time
// that exceeds that of BasicPortAllocator.
BasicPortAllocator(rtc::NetworkManager* network_manager,
- rtc::PacketSocketFactory* socket_factory,
+ webrtc::PacketSocketFactory* socket_factory,
webrtc::TurnCustomizer* customizer = nullptr,
RelayPortFactoryInterface* relay_port_factory = nullptr,
const webrtc::FieldTrialsView* field_trials = nullptr);
@@ -69,7 +69,7 @@
// If socket_factory() is set to NULL each PortAllocatorSession
// creates its own socket factory.
- rtc::PacketSocketFactory* socket_factory() {
+ webrtc::PacketSocketFactory* socket_factory() {
CheckRunOnValidThreadIfInitialized();
return socket_factory_;
}
@@ -102,7 +102,7 @@
field_trials_;
rtc::NetworkManager* network_manager_;
// Always externally-owned pointer to a socket factory.
- rtc::PacketSocketFactory* const socket_factory_;
+ webrtc::PacketSocketFactory* const socket_factory_;
int network_ignore_mask_ = rtc::kDefaultNetworkIgnoreMask;
// This instance is created if caller does pass a factory.
@@ -135,7 +135,7 @@
virtual BasicPortAllocator* allocator();
rtc::Thread* network_thread() { return network_thread_; }
- rtc::PacketSocketFactory* socket_factory() { return socket_factory_; }
+ webrtc::PacketSocketFactory* socket_factory() { return socket_factory_; }
// If the new filter allows new types of candidates compared to the previous
// filter, gathered candidates that were discarded because of not matching the
@@ -280,7 +280,7 @@
BasicPortAllocator* allocator_;
rtc::Thread* network_thread_;
- rtc::PacketSocketFactory* socket_factory_;
+ webrtc::PacketSocketFactory* socket_factory_;
bool allocation_started_;
bool network_manager_started_;
bool allocation_sequences_created_;
@@ -393,7 +393,7 @@
void CreateStunPorts();
void CreateRelayPorts();
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(webrtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
void OnPortDestroyed(webrtc::PortInterface* port);
@@ -407,7 +407,7 @@
State state_;
uint32_t flags_;
ProtocolList protocols_;
- std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_;
+ std::unique_ptr<webrtc::AsyncPacketSocket> udp_socket_;
// There will be only one udp port per AllocationSequence.
UDPPort* udp_port_;
std::vector<Port*> relay_ports_;
diff --git a/p2p/client/basic_port_allocator_unittest.cc b/p2p/client/basic_port_allocator_unittest.cc
index aa5edf8..40c15aa 100644
--- a/p2p/client/basic_port_allocator_unittest.cc
+++ b/p2p/client/basic_port_allocator_unittest.cc
@@ -68,7 +68,7 @@
using ::webrtc::SocketAddress;
#define MAYBE_SKIP_IPV4 \
- if (!rtc::HasIPv4Enabled()) { \
+ if (!::rtc::HasIPv4Enabled()) { \
RTC_LOG(LS_INFO) << "No IPv4... skipping"; \
return; \
}
@@ -153,14 +153,15 @@
public sigslot::has_slots<> {
public:
BasicPortAllocatorTestBase()
- : vss_(new rtc::VirtualSocketServer()),
- fss_(new rtc::FirewallSocketServer(vss_.get())),
+ : vss_(new webrtc::VirtualSocketServer()),
+ fss_(new webrtc::FirewallSocketServer(vss_.get())),
socket_factory_(fss_.get()),
thread_(fss_.get()),
// Note that the NAT is not used by default. ResetWithStunServerAndNat
// must be called.
nat_factory_(vss_.get(), kNatUdpAddr, kNatTcpAddr),
- nat_socket_factory_(new rtc::BasicPacketSocketFactory(&nat_factory_)),
+ nat_socket_factory_(
+ new webrtc::BasicPacketSocketFactory(&nat_factory_)),
stun_server_(
webrtc::TestStunServer::Create(fss_.get(), kStunAddr, thread_)),
turn_server_(rtc::Thread::Current(),
@@ -398,17 +399,17 @@
for (it = ports_.begin(); it < ports_.end(); ++it) {
int send_buffer_size;
if (expected == -1) {
- EXPECT_EQ(SOCKET_ERROR,
- (*it)->GetOption(rtc::Socket::OPT_SNDBUF, &send_buffer_size));
+ EXPECT_EQ(SOCKET_ERROR, (*it)->GetOption(webrtc::Socket::OPT_SNDBUF,
+ &send_buffer_size));
} else {
- EXPECT_EQ(0,
- (*it)->GetOption(rtc::Socket::OPT_SNDBUF, &send_buffer_size));
+ EXPECT_EQ(
+ 0, (*it)->GetOption(webrtc::Socket::OPT_SNDBUF, &send_buffer_size));
ASSERT_EQ(expected, send_buffer_size);
}
}
}
- rtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
+ webrtc::VirtualSocketServer* virtual_socket_server() { return vss_.get(); }
protected:
BasicPortAllocator& allocator() { return *allocator_; }
@@ -485,7 +486,7 @@
thread_, vss_.get(), webrtc::SocketAddress(kNatUdpAddr.ipaddr(), 0)));
} else {
nat_socket_factory_ =
- std::make_unique<rtc::BasicPacketSocketFactory>(fss_.get());
+ std::make_unique<webrtc::BasicPacketSocketFactory>(fss_.get());
}
ServerAddresses stun_servers;
@@ -503,13 +504,13 @@
allocator_->set_step_delay(kMinimumStepDelay);
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
- std::unique_ptr<rtc::FirewallSocketServer> fss_;
- rtc::BasicPacketSocketFactory socket_factory_;
+ std::unique_ptr<webrtc::VirtualSocketServer> vss_;
+ std::unique_ptr<webrtc::FirewallSocketServer> fss_;
+ webrtc::BasicPacketSocketFactory socket_factory_;
rtc::AutoSocketServerThread thread_;
std::unique_ptr<webrtc::NATServer> nat_server_;
webrtc::NATSocketFactory nat_factory_;
- std::unique_ptr<rtc::BasicPacketSocketFactory> nat_socket_factory_;
+ std::unique_ptr<webrtc::BasicPacketSocketFactory> nat_socket_factory_;
webrtc::TestStunServer::StunServerPtr stun_server_;
webrtc::TestTurnServer turn_server_;
webrtc::FakeNetworkManager network_manager_;
@@ -1634,7 +1635,7 @@
// Testing STUN timeout.
TEST_F(BasicPortAllocatorTest, TestGetAllPortsNoUdpAllowed) {
- fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr);
+ fss_->AddRule(false, webrtc::FP_UDP, webrtc::FD_ANY, kClientAddr);
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
@@ -2274,7 +2275,7 @@
allocator().set_flags(allocator().flags() | PORTALLOCATOR_DISABLE_RELAY |
PORTALLOCATOR_DISABLE_TCP |
PORTALLOCATOR_ENABLE_SHARED_SOCKET);
- fss_->AddRule(false, rtc::FP_UDP, rtc::FD_ANY, kClientAddr);
+ fss_->AddRule(false, webrtc::FP_UDP, webrtc::FD_ANY, kClientAddr);
AddInterface(kClientAddr);
ASSERT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
session_->StartGettingPorts();
diff --git a/p2p/client/relay_port_factory_interface.h b/p2p/client/relay_port_factory_interface.h
index 153eb4a..684e8c9 100644
--- a/p2p/client/relay_port_factory_interface.h
+++ b/p2p/client/relay_port_factory_interface.h
@@ -14,12 +14,14 @@
#include <memory>
#include <string>
+#include "api/packet_socket_factory.h"
#include "p2p/base/port_interface.h"
+#include "rtc_base/async_packet_socket.h"
namespace rtc {
-class AsyncPacketSocket;
+
class Network;
-class PacketSocketFactory;
+
class Thread;
} // namespace rtc
@@ -36,7 +38,7 @@
// A struct containing arguments to RelayPortFactory::Create()
struct CreateRelayPortArgs {
rtc::Thread* network_thread;
- rtc::PacketSocketFactory* socket_factory;
+ webrtc::PacketSocketFactory* socket_factory;
const rtc::Network* network;
const ProtocolAddress* server_address;
const RelayServerConfig* config;
@@ -57,8 +59,9 @@
// This variant is used for UDP connection to the relay server
// using a already existing shared socket.
- virtual std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
- rtc::AsyncPacketSocket* udp_socket) = 0;
+ virtual std::unique_ptr<Port> Create(
+ const CreateRelayPortArgs& args,
+ webrtc::AsyncPacketSocket* udp_socket) = 0;
// This variant is used for the other cases.
virtual std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
diff --git a/p2p/client/turn_port_factory.cc b/p2p/client/turn_port_factory.cc
index a7e2632..35a2a22 100644
--- a/p2p/client/turn_port_factory.cc
+++ b/p2p/client/turn_port_factory.cc
@@ -25,7 +25,7 @@
std::unique_ptr<Port> TurnPortFactory::Create(
const CreateRelayPortArgs& args,
- rtc::AsyncPacketSocket* udp_socket) {
+ webrtc::AsyncPacketSocket* udp_socket) {
auto port = TurnPort::Create(args, udp_socket);
if (!port)
return nullptr;
diff --git a/p2p/client/turn_port_factory.h b/p2p/client/turn_port_factory.h
index abb1f67..2e6b7b5 100644
--- a/p2p/client/turn_port_factory.h
+++ b/p2p/client/turn_port_factory.h
@@ -25,7 +25,7 @@
~TurnPortFactory() override;
std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
- rtc::AsyncPacketSocket* udp_socket) override;
+ webrtc::AsyncPacketSocket* udp_socket) override;
std::unique_ptr<Port> Create(const CreateRelayPortArgs& args,
int min_port,
diff --git a/p2p/dtls/dtls_ice_integrationtest.cc b/p2p/dtls/dtls_ice_integrationtest.cc
index efd54d3..03a38ca 100644
--- a/p2p/dtls/dtls_ice_integrationtest.cc
+++ b/p2p/dtls/dtls_ice_integrationtest.cc
@@ -82,7 +82,7 @@
dtls_stun_piggyback(dtls_in_stun) {}
webrtc::EmulatedNetworkManagerInterface* emulated_network_manager = nullptr;
std::unique_ptr<rtc::NetworkManager> network_manager;
- std::unique_ptr<rtc::BasicPacketSocketFactory> packet_socket_factory;
+ std::unique_ptr<webrtc::BasicPacketSocketFactory> packet_socket_factory;
std::unique_ptr<PortAllocator> allocator;
std::unique_ptr<IceTransportInternal> ice;
std::unique_ptr<DtlsTransport> dtls;
@@ -98,9 +98,9 @@
protected:
DtlsIceIntegrationTest()
- : ss_(std::make_unique<rtc::VirtualSocketServer>()),
+ : ss_(std::make_unique<webrtc::VirtualSocketServer>()),
socket_factory_(
- std::make_unique<rtc::BasicPacketSocketFactory>(ss_.get())),
+ std::make_unique<webrtc::BasicPacketSocketFactory>(ss_.get())),
client_(std::get<0>(GetParam())),
server_(std::get<1>(GetParam())),
client_ice_parameters_("c_ufrag",
@@ -143,7 +143,7 @@
ep.network_manager =
ep.emulated_network_manager->ReleaseNetworkManager();
ep.packet_socket_factory =
- std::make_unique<rtc::BasicPacketSocketFactory>(
+ std::make_unique<webrtc::BasicPacketSocketFactory>(
ep.emulated_network_manager->socket_factory());
ep.allocator = std::make_unique<BasicPortAllocator>(
ep.network_manager.get(), ep.packet_socket_factory.get());
@@ -317,8 +317,8 @@
webrtc::ScopedFakeClock fake_clock_;
webrtc::FakeNetworkManager network_manager_;
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
- std::unique_ptr<rtc::BasicPacketSocketFactory> socket_factory_;
+ std::unique_ptr<webrtc::VirtualSocketServer> ss_;
+ std::unique_ptr<webrtc::BasicPacketSocketFactory> socket_factory_;
std::unique_ptr<webrtc::NetworkEmulationManager> network_emulation_manager_;
std::unique_ptr<rtc::AutoSocketServerThread> thread_;
diff --git a/p2p/dtls/dtls_transport.cc b/p2p/dtls/dtls_transport.cc
index 7a865ce..5e55bdb 100644
--- a/p2p/dtls/dtls_transport.cc
+++ b/p2p/dtls/dtls_transport.cc
@@ -544,11 +544,11 @@
return ice_transport_->network_route();
}
-bool DtlsTransport::GetOption(rtc::Socket::Option opt, int* value) {
+bool DtlsTransport::GetOption(webrtc::Socket::Option opt, int* value) {
return ice_transport_->GetOption(opt, value);
}
-int DtlsTransport::SetOption(rtc::Socket::Option opt, int value) {
+int DtlsTransport::SetOption(webrtc::Socket::Option opt, int value) {
return ice_transport_->SetOption(opt, value);
}
diff --git a/p2p/dtls/dtls_transport.h b/p2p/dtls/dtls_transport.h
index cee8e5d..3f0a51e 100644
--- a/p2p/dtls/dtls_transport.h
+++ b/p2p/dtls/dtls_transport.h
@@ -173,7 +173,7 @@
const rtc::PacketOptions& options,
int flags) override;
- bool GetOption(rtc::Socket::Option opt, int* value) override;
+ bool GetOption(webrtc::Socket::Option opt, int* value) override;
// Find out which TLS version was negotiated
bool GetSslVersionBytes(int* version) const override;
@@ -218,7 +218,7 @@
std::optional<rtc::NetworkRoute> network_route() const override;
- int SetOption(rtc::Socket::Option opt, int value) override;
+ int SetOption(webrtc::Socket::Option opt, int value) override;
std::string ToString() const {
const absl::string_view RECEIVING_ABBREV[2] = {"_", "R"};
diff --git a/p2p/dtls/fake_dtls_transport.h b/p2p/dtls/fake_dtls_transport.h
index ece74ed..cf73989 100644
--- a/p2p/dtls/fake_dtls_transport.h
+++ b/p2p/dtls/fake_dtls_transport.h
@@ -276,10 +276,10 @@
}
return ice_transport_->SendPacket(data, len, options, flags);
}
- int SetOption(rtc::Socket::Option opt, int value) override {
+ int SetOption(Socket::Option opt, int value) override {
return ice_transport_->SetOption(opt, value);
}
- bool GetOption(rtc::Socket::Option opt, int* value) override {
+ bool GetOption(Socket::Option opt, int* value) override {
return ice_transport_->GetOption(opt, value);
}
int GetError() override { return ice_transport_->GetError(); }
diff --git a/p2p/test/fake_ice_transport.h b/p2p/test/fake_ice_transport.h
index 6aba406..c8c5000 100644
--- a/p2p/test/fake_ice_transport.h
+++ b/p2p/test/fake_ice_transport.h
@@ -353,12 +353,12 @@
return static_cast<int>(len);
}
- int SetOption(rtc::Socket::Option opt, int value) override {
+ int SetOption(webrtc::Socket::Option opt, int value) override {
RTC_DCHECK_RUN_ON(network_thread_);
socket_options_[opt] = value;
return true;
}
- bool GetOption(rtc::Socket::Option opt, int* value) override {
+ bool GetOption(webrtc::Socket::Option opt, int* value) override {
RTC_DCHECK_RUN_ON(network_thread_);
auto it = socket_options_.find(opt);
if (it != socket_options_.end()) {
@@ -616,7 +616,7 @@
rtc::CopyOnWriteBuffer send_packet_ RTC_GUARDED_BY(network_thread_);
std::optional<rtc::NetworkRoute> network_route_
RTC_GUARDED_BY(network_thread_);
- std::map<rtc::Socket::Option, int> socket_options_
+ std::map<webrtc::Socket::Option, int> socket_options_
RTC_GUARDED_BY(network_thread_);
rtc::CopyOnWriteBuffer last_sent_packet_ RTC_GUARDED_BY(network_thread_);
rtc::Thread* const network_thread_;
diff --git a/p2p/test/fake_packet_transport.h b/p2p/test/fake_packet_transport.h
index 86640b8..d977fad 100644
--- a/p2p/test/fake_packet_transport.h
+++ b/p2p/test/fake_packet_transport.h
@@ -72,12 +72,12 @@
return static_cast<int>(len);
}
- int SetOption(rtc::Socket::Option opt, int value) override {
+ int SetOption(Socket::Option opt, int value) override {
options_[opt] = value;
return 0;
}
- bool GetOption(rtc::Socket::Option opt, int* value) override {
+ bool GetOption(Socket::Option opt, int* value) override {
auto it = options_.find(opt);
if (it == options_.end()) {
return false;
@@ -138,7 +138,7 @@
bool writable_ = false;
bool receiving_ = false;
- std::map<rtc::Socket::Option, int> options_;
+ std::map<Socket::Option, int> options_;
int error_ = 0;
std::optional<rtc::NetworkRoute> network_route_;
diff --git a/p2p/test/fake_port_allocator.h b/p2p/test/fake_port_allocator.h
index 3e386ca..c89df01 100644
--- a/p2p/test/fake_port_allocator.h
+++ b/p2p/test/fake_port_allocator.h
@@ -24,13 +24,10 @@
#include "rtc_base/memory/always_valid_pointer.h"
#include "rtc_base/net_helpers.h"
#include "rtc_base/net_test_helpers.h"
+#include "rtc_base/socket_factory.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread.h"
-namespace rtc {
-class SocketFactory;
-}
-
namespace cricket {
class TestUDPPort : public UDPPort {
@@ -50,7 +47,7 @@
static std::unique_ptr<TestUDPPort> Create(
const PortParametersRef& args,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
bool emit_localhost_for_anyaddress) {
auto port = absl::WrapUnique(
new TestUDPPort(args, socket, emit_localhost_for_anyaddress));
@@ -72,7 +69,7 @@
emit_localhost_for_anyaddress) {}
TestUDPPort(const PortParametersRef& args,
- rtc::AsyncPacketSocket* socket,
+ webrtc::AsyncPacketSocket* socket,
bool emit_localhost_for_anyaddress)
: UDPPort(args,
webrtc::IceCandidateType::kHost,
@@ -87,7 +84,7 @@
public:
FakePortAllocatorSession(PortAllocator* allocator,
rtc::Thread* network_thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
absl::string_view content_name,
int component,
absl::string_view ice_ufrag,
@@ -210,7 +207,7 @@
PortAllocator* allocator_;
rtc::Thread* network_thread_;
- rtc::PacketSocketFactory* factory_;
+ webrtc::PacketSocketFactory* factory_;
rtc::Network ipv4_network_;
rtc::Network ipv6_network_;
std::unique_ptr<cricket::Port> port_;
@@ -230,12 +227,12 @@
class FakePortAllocator : public cricket::PortAllocator {
public:
FakePortAllocator(rtc::Thread* network_thread,
- rtc::PacketSocketFactory* factory,
+ webrtc::PacketSocketFactory* factory,
const webrtc::FieldTrialsView* field_trials)
: FakePortAllocator(network_thread, factory, nullptr, field_trials) {}
FakePortAllocator(rtc::Thread* network_thread,
- std::unique_ptr<rtc::PacketSocketFactory> factory,
+ std::unique_ptr<webrtc::PacketSocketFactory> factory,
const webrtc::FieldTrialsView* field_trials)
: FakePortAllocator(network_thread,
nullptr,
@@ -266,8 +263,8 @@
private:
FakePortAllocator(rtc::Thread* network_thread,
- rtc::PacketSocketFactory* factory,
- std::unique_ptr<rtc::PacketSocketFactory> owned_factory,
+ webrtc::PacketSocketFactory* factory,
+ std::unique_ptr<webrtc::PacketSocketFactory> owned_factory,
const webrtc::FieldTrialsView* field_trials)
: network_thread_(network_thread),
factory_(std::move(owned_factory), factory),
@@ -281,7 +278,8 @@
}
rtc::Thread* network_thread_;
- const webrtc::AlwaysValidPointerNoDefault<rtc::PacketSocketFactory> factory_;
+ const webrtc::AlwaysValidPointerNoDefault<webrtc::PacketSocketFactory>
+ factory_;
const webrtc::FieldTrialsView* field_trials_;
bool mdns_obfuscation_enabled_ = false;
};
diff --git a/p2p/test/mock_dns_resolving_packet_socket_factory.h b/p2p/test/mock_dns_resolving_packet_socket_factory.h
index f87f4cb..42df286 100644
--- a/p2p/test/mock_dns_resolving_packet_socket_factory.h
+++ b/p2p/test/mock_dns_resolving_packet_socket_factory.h
@@ -21,15 +21,13 @@
// A PacketSocketFactory implementation for tests that uses a mock DnsResolver
// and allows setting expectations on the resolver and results.
-class MockDnsResolvingPacketSocketFactory
- : public rtc::BasicPacketSocketFactory {
+class MockDnsResolvingPacketSocketFactory : public BasicPacketSocketFactory {
public:
using Expectations =
std::function<void(MockAsyncDnsResolver*, MockAsyncDnsResolverResult*)>;
- explicit MockDnsResolvingPacketSocketFactory(
- rtc::SocketFactory* socket_factory)
- : rtc::BasicPacketSocketFactory(socket_factory) {}
+ explicit MockDnsResolvingPacketSocketFactory(SocketFactory* socket_factory)
+ : BasicPacketSocketFactory(socket_factory) {}
std::unique_ptr<AsyncDnsResolverInterface> CreateAsyncDnsResolver() override {
std::unique_ptr<MockAsyncDnsResolver> resolver =
diff --git a/p2p/test/nat_server.cc b/p2p/test/nat_server.cc
index 5513a5d..a703e40 100644
--- a/p2p/test/nat_server.cc
+++ b/p2p/test/nat_server.cc
@@ -73,17 +73,16 @@
// Proxy socket that will capture the external destination address intended for
// a TCP connection to the NAT server.
-class NATProxyServerSocket : public rtc::AsyncProxyServerSocket {
+class NATProxyServerSocket : public AsyncProxyServerSocket {
public:
- explicit NATProxyServerSocket(rtc::Socket* socket)
- : rtc::AsyncProxyServerSocket(socket,
- webrtc::kNATEncodedIPv6AddressSize) {
+ explicit NATProxyServerSocket(Socket* socket)
+ : AsyncProxyServerSocket(socket, webrtc::kNATEncodedIPv6AddressSize) {
BufferInput(true);
}
void SendConnectResult(int err, const SocketAddress& addr) override {
char code = err ? 1 : 0;
- rtc::BufferedReadAdapter::DirectSend(&code, sizeof(char));
+ BufferedReadAdapter::DirectSend(&code, sizeof(char));
}
protected:
@@ -119,25 +118,25 @@
class NATProxyServer : public rtc::ProxyServer {
public:
- NATProxyServer(rtc::SocketFactory* int_factory,
+ NATProxyServer(SocketFactory* int_factory,
const SocketAddress& int_addr,
- rtc::SocketFactory* ext_factory,
+ SocketFactory* ext_factory,
const SocketAddress& ext_ip)
: rtc::ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected:
- rtc::AsyncProxyServerSocket* WrapSocket(rtc::Socket* socket) override {
+ AsyncProxyServerSocket* WrapSocket(Socket* socket) override {
return new NATProxyServerSocket(socket);
}
};
NATServer::NATServer(NATType type,
rtc::Thread& internal_socket_thread,
- rtc::SocketFactory* internal,
+ SocketFactory* internal,
const SocketAddress& internal_udp_addr,
const SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
- rtc::SocketFactory* external,
+ SocketFactory* external,
const SocketAddress& external_ip)
: internal_socket_thread_(internal_socket_thread),
external_socket_thread_(external_socket_thread),
@@ -146,8 +145,7 @@
nat_ = NAT::Create(type);
internal_socket_thread_.BlockingCall([&] {
- udp_server_socket_ =
- rtc::AsyncUDPSocket::Create(internal, internal_udp_addr);
+ udp_server_socket_ = AsyncUDPSocket::Create(internal, internal_udp_addr);
udp_server_socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
OnInternalUDPPacket(socket, packet);
@@ -173,7 +171,7 @@
delete ext_map_;
}
-void NATServer::OnInternalUDPPacket(rtc::AsyncPacketSocket* socket,
+void NATServer::OnInternalUDPPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(internal_socket_thread_.IsCurrent());
// Read the intended destination from the wire.
@@ -199,7 +197,7 @@
iter->second->socket->SendTo(buf + length, size - length, dest_addr, options);
}
-void NATServer::OnExternalUDPPacket(rtc::AsyncPacketSocket* socket,
+void NATServer::OnExternalUDPPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(external_socket_thread_.IsCurrent());
SocketAddress local_addr = socket->GetLocalAddress();
@@ -235,8 +233,7 @@
void NATServer::Translate(const SocketAddressPair& route) {
external_socket_thread_.BlockingCall([&] {
- rtc::AsyncUDPSocket* socket =
- rtc::AsyncUDPSocket::Create(external_, external_ip_);
+ AsyncUDPSocket* socket = AsyncUDPSocket::Create(external_, external_ip_);
if (!socket) {
RTC_LOG(LS_ERROR) << "Couldn't find a free port!";
@@ -259,7 +256,7 @@
}
NATServer::TransEntry::TransEntry(const SocketAddressPair& r,
- rtc::AsyncUDPSocket* s,
+ AsyncUDPSocket* s,
NAT* nat)
: route(r), socket(s) {
allowlist = new AddressSet(AddrCmp(nat));
diff --git a/p2p/test/nat_server.h b/p2p/test/nat_server.h
index 7ae038c..38ff496 100644
--- a/p2p/test/nat_server.h
+++ b/p2p/test/nat_server.h
@@ -62,11 +62,11 @@
public:
NATServer(NATType type,
rtc::Thread& internal_socket_thread,
- rtc::SocketFactory* internal,
+ SocketFactory* internal,
const SocketAddress& internal_udp_addr,
const SocketAddress& internal_tcp_addr,
rtc::Thread& external_socket_thread,
- rtc::SocketFactory* external,
+ SocketFactory* external,
const SocketAddress& external_ip);
~NATServer();
@@ -82,9 +82,9 @@
}
// Packets received on one of the networks.
- void OnInternalUDPPacket(rtc::AsyncPacketSocket* socket,
+ void OnInternalUDPPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
- void OnExternalUDPPacket(rtc::AsyncPacketSocket* socket,
+ void OnExternalUDPPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
private:
@@ -92,14 +92,14 @@
/* Records a translation and the associated external socket. */
struct TransEntry {
- TransEntry(const SocketAddressPair& r, rtc::AsyncUDPSocket* s, NAT* nat);
+ TransEntry(const SocketAddressPair& r, AsyncUDPSocket* s, NAT* nat);
~TransEntry();
void AllowlistInsert(const SocketAddress& addr);
bool AllowlistContains(const SocketAddress& ext_addr);
SocketAddressPair route;
- rtc::AsyncUDPSocket* socket;
+ AsyncUDPSocket* socket;
AddressSet* allowlist;
Mutex mutex_;
};
@@ -116,9 +116,9 @@
NAT* nat_;
rtc::Thread& internal_socket_thread_;
rtc::Thread& external_socket_thread_;
- rtc::SocketFactory* external_;
+ SocketFactory* external_;
SocketAddress external_ip_;
- rtc::AsyncUDPSocket* udp_server_socket_;
+ AsyncUDPSocket* udp_server_socket_;
rtc::ProxyServer* tcp_proxy_server_;
InternalMap* int_map_;
ExternalMap* ext_map_;
diff --git a/p2p/test/nat_socket_factory.cc b/p2p/test/nat_socket_factory.cc
index 04bd045..6888ece 100644
--- a/p2p/test/nat_socket_factory.cc
+++ b/p2p/test/nat_socket_factory.cc
@@ -71,7 +71,7 @@
}
// NATSocket
-class NATSocket : public rtc::Socket, public sigslot::has_slots<> {
+class NATSocket : public Socket, public sigslot::has_slots<> {
public:
explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
: sf_(sf),
@@ -165,7 +165,7 @@
buf_.EnsureCapacity(size + kNATEncodedIPv6AddressSize);
// Read the packet from the socket.
- rtc::Socket::ReceiveBuffer receive_buffer(buf_);
+ Socket::ReceiveBuffer receive_buffer(buf_);
int result = socket_->RecvFrom(receive_buffer);
if (result >= 0) {
RTC_DCHECK(receive_buffer.source_address == server_addr_);
@@ -207,7 +207,7 @@
}
int Listen(int backlog) override { return socket_->Listen(backlog); }
- rtc::Socket* Accept(SocketAddress* paddr) override {
+ Socket* Accept(SocketAddress* paddr) override {
return socket_->Accept(paddr);
}
int GetError() const override {
@@ -230,7 +230,7 @@
return socket_ ? socket_->SetOption(opt, value) : -1;
}
- void OnConnectEvent(rtc::Socket* socket) {
+ void OnConnectEvent(Socket* socket) {
// If we're NATed, we need to send a message with the real addr to use.
RTC_DCHECK(socket == socket_);
if (server_addr_.IsNil()) {
@@ -240,7 +240,7 @@
SendConnectRequest();
}
}
- void OnReadEvent(rtc::Socket* socket) {
+ void OnReadEvent(Socket* socket) {
// If we're NATed, we need to process the connect reply.
RTC_DCHECK(socket == socket_);
if (type_ == SOCK_STREAM && !server_addr_.IsNil() && !connected_) {
@@ -249,11 +249,11 @@
SignalReadEvent(this);
}
}
- void OnWriteEvent(rtc::Socket* socket) {
+ void OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket == socket_);
SignalWriteEvent(this);
}
- void OnCloseEvent(rtc::Socket* socket, int error) {
+ void OnCloseEvent(Socket* socket, int error) {
RTC_DCHECK(socket == socket_);
SignalCloseEvent(this, error);
}
@@ -305,29 +305,28 @@
bool connected_;
SocketAddress remote_addr_;
SocketAddress server_addr_; // address of the NAT server
- rtc::Socket* socket_;
+ Socket* socket_;
// Need to hold error in case it occurs before the socket is created.
int error_ = 0;
Buffer buf_;
};
// NATSocketFactory
-NATSocketFactory::NATSocketFactory(rtc::SocketFactory* factory,
+NATSocketFactory::NATSocketFactory(SocketFactory* factory,
const SocketAddress& nat_udp_addr,
const SocketAddress& nat_tcp_addr)
: factory_(factory),
nat_udp_addr_(nat_udp_addr),
nat_tcp_addr_(nat_tcp_addr) {}
-rtc::Socket* NATSocketFactory::CreateSocket(int family, int type) {
+Socket* NATSocketFactory::CreateSocket(int family, int type) {
return new NATSocket(this, family, type);
}
-rtc::Socket* NATSocketFactory::CreateInternalSocket(
- int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) {
+Socket* NATSocketFactory::CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) {
if (type == SOCK_STREAM) {
*nat_addr = nat_tcp_addr_;
} else {
@@ -337,7 +336,7 @@
}
// NATSocketServer
-NATSocketServer::NATSocketServer(rtc::SocketServer* server)
+NATSocketServer::NATSocketServer(SocketServer* server)
: server_(server), msg_queue_(nullptr) {}
NATSocketServer::Translator* NATSocketServer::GetTranslator(
@@ -361,7 +360,7 @@
nats_.Remove(ext_ip);
}
-rtc::Socket* NATSocketServer::CreateSocket(int family, int type) {
+Socket* NATSocketServer::CreateSocket(int family, int type) {
return new NATSocket(this, family, type);
}
@@ -378,12 +377,11 @@
server_->WakeUp();
}
-rtc::Socket* NATSocketServer::CreateInternalSocket(
- int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) {
- rtc::Socket* socket = nullptr;
+Socket* NATSocketServer::CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) {
+ Socket* socket = nullptr;
Translator* nat = nats_.FindClient(local_addr);
if (nat) {
socket = nat->internal_factory()->CreateSocket(family, type);
@@ -400,13 +398,13 @@
NATType type,
const SocketAddress& int_ip,
rtc::Thread& external_socket_thread,
- rtc::SocketFactory* ext_factory,
+ SocketFactory* ext_factory,
const SocketAddress& ext_ip)
: server_(server) {
// Create a new private network, and a NATServer running on the private
// network that bridges to the external network. Also tell the private
// network to use the same message queue as us.
- internal_server_ = std::make_unique<rtc::VirtualSocketServer>();
+ internal_server_ = std::make_unique<VirtualSocketServer>();
internal_server_->SetMessageQueue(server_->queue());
nat_server_ = std::make_unique<NATServer>(
type, *server->queue(), internal_server_.get(), int_ip, int_ip,
diff --git a/p2p/test/nat_socket_factory.h b/p2p/test/nat_socket_factory.h
index 4a4d712..82c462e 100644
--- a/p2p/test/nat_socket_factory.h
+++ b/p2p/test/nat_socket_factory.h
@@ -37,19 +37,18 @@
class NATInternalSocketFactory {
public:
virtual ~NATInternalSocketFactory() {}
- virtual rtc::Socket* CreateInternalSocket(int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) = 0;
+ virtual Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) = 0;
};
// Creates sockets that will send all traffic through a NAT, using an existing
// NATServer instance running at nat_addr. The actual data is sent using sockets
// from a socket factory, given to the constructor.
-class NATSocketFactory : public rtc::SocketFactory,
- public NATInternalSocketFactory {
+class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
public:
- NATSocketFactory(rtc::SocketFactory* factory,
+ NATSocketFactory(SocketFactory* factory,
const SocketAddress& nat_udp_addr,
const SocketAddress& nat_tcp_addr);
@@ -57,16 +56,16 @@
NATSocketFactory& operator=(const NATSocketFactory&) = delete;
// SocketFactory implementation
- rtc::Socket* CreateSocket(int family, int type) override;
+ Socket* CreateSocket(int family, int type) override;
// NATInternalSocketFactory implementation
- rtc::Socket* CreateInternalSocket(int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) override;
+ Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) override;
private:
- rtc::SocketFactory* factory_;
+ SocketFactory* factory_;
SocketAddress nat_udp_addr_;
SocketAddress nat_tcp_addr_;
};
@@ -86,8 +85,7 @@
// ss->GetTranslator("99.99.99.99")->AddClient("10.0.0.3");
// ss->GetTranslator("99.99.99.99")->GetTranslator("10.0.0.2")->
// AddClient("192.168.1.2");
-class NATSocketServer : public rtc::SocketServer,
- public NATInternalSocketFactory {
+class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
public:
class Translator;
@@ -108,11 +106,11 @@
NATType type,
const SocketAddress& int_addr,
rtc::Thread& external_socket_thread,
- rtc::SocketFactory* ext_factory,
+ SocketFactory* ext_factory,
const SocketAddress& ext_addr);
~Translator();
- rtc::SocketFactory* internal_factory() { return internal_server_.get(); }
+ SocketFactory* internal_factory() { return internal_server_.get(); }
SocketAddress internal_udp_address() const {
return nat_server_->internal_udp_address();
}
@@ -134,18 +132,18 @@
private:
NATSocketServer* server_;
- std::unique_ptr<rtc::SocketServer> internal_server_;
+ std::unique_ptr<SocketServer> internal_server_;
std::unique_ptr<NATServer> nat_server_;
TranslatorMap nats_;
std::set<SocketAddress> clients_;
};
- explicit NATSocketServer(rtc::SocketServer* ss);
+ explicit NATSocketServer(SocketServer* ss);
NATSocketServer(const NATSocketServer&) = delete;
NATSocketServer& operator=(const NATSocketServer&) = delete;
- rtc::SocketServer* socketserver() { return server_; }
+ SocketServer* socketserver() { return server_; }
rtc::Thread* queue() { return msg_queue_; }
Translator* GetTranslator(const SocketAddress& ext_ip);
@@ -155,20 +153,20 @@
void RemoveTranslator(const SocketAddress& ext_ip);
// SocketServer implementation
- rtc::Socket* CreateSocket(int family, int type) override;
+ Socket* CreateSocket(int family, int type) override;
void SetMessageQueue(rtc::Thread* queue) override;
bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
// NATInternalSocketFactory implementation
- rtc::Socket* CreateInternalSocket(int family,
- int type,
- const SocketAddress& local_addr,
- SocketAddress* nat_addr) override;
+ Socket* CreateInternalSocket(int family,
+ int type,
+ const SocketAddress& local_addr,
+ SocketAddress* nat_addr) override;
private:
- rtc::SocketServer* server_;
+ SocketServer* server_;
rtc::Thread* msg_queue_;
TranslatorMap nats_;
};
diff --git a/p2p/test/nat_unittest.cc b/p2p/test/nat_unittest.cc
index e49cbef..88055b8 100644
--- a/p2p/test/nat_unittest.cc
+++ b/p2p/test/nat_unittest.cc
@@ -53,22 +53,23 @@
: client->CheckNoPacket();
}
-webrtc::TestClient* CreateTestClient(SocketFactory* factory,
+webrtc::TestClient* CreateTestClient(webrtc::SocketFactory* factory,
const webrtc::SocketAddress& local_addr) {
return new webrtc::TestClient(
- absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
+ absl::WrapUnique(webrtc::AsyncUDPSocket::Create(factory, local_addr)));
}
-webrtc::TestClient* CreateTCPTestClient(Socket* socket) {
- return new webrtc::TestClient(std::make_unique<AsyncTCPSocket>(socket));
+webrtc::TestClient* CreateTCPTestClient(webrtc::Socket* socket) {
+ return new webrtc::TestClient(
+ std::make_unique<webrtc::AsyncTCPSocket>(socket));
}
// Tests that when sending from internal_addr to external_addrs through the
// 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,
+void TestSend(webrtc::SocketServer* internal,
const webrtc::SocketAddress& internal_addr,
- SocketServer* external,
+ webrtc::SocketServer* external,
const webrtc::SocketAddress external_addrs[4],
webrtc::NATType nat_type,
bool exp_same) {
@@ -127,9 +128,9 @@
// 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,
+void TestRecv(webrtc::SocketServer* internal,
const webrtc::SocketAddress& internal_addr,
- SocketServer* external,
+ webrtc::SocketServer* external,
const webrtc::SocketAddress external_addrs[4],
webrtc::NATType nat_type,
bool filter_ip,
@@ -189,9 +190,9 @@
}
// Tests that NATServer allocates bindings properly.
-void TestBindings(SocketServer* internal,
+void TestBindings(webrtc::SocketServer* internal,
const webrtc::SocketAddress& internal_addr,
- SocketServer* external,
+ webrtc::SocketServer* external,
const webrtc::SocketAddress external_addrs[4]) {
TestSend(internal, internal_addr, external, external_addrs,
webrtc::NAT_OPEN_CONE, true);
@@ -204,9 +205,9 @@
}
// Tests that NATServer filters packets properly.
-void TestFilters(SocketServer* internal,
+void TestFilters(webrtc::SocketServer* internal,
const webrtc::SocketAddress& internal_addr,
- SocketServer* external,
+ webrtc::SocketServer* external,
const webrtc::SocketAddress external_addrs[4]) {
TestRecv(internal, internal_addr, external, external_addrs,
webrtc::NAT_OPEN_CONE, false, false);
@@ -223,9 +224,12 @@
// 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));
+ std::unique_ptr<webrtc::PhysicalSocketServer> pss(
+ new webrtc::PhysicalSocketServer());
+ std::unique_ptr<webrtc::Socket> client(
+ pss->CreateSocket(src.family(), SOCK_DGRAM));
+ std::unique_ptr<webrtc::Socket> server(
+ pss->CreateSocket(src.family(), SOCK_DGRAM));
if (client->Bind(webrtc::SocketAddress(src.ipaddr(), 0)) != 0 ||
server->Bind(webrtc::SocketAddress(dst, 0)) != 0) {
return false;
@@ -236,7 +240,7 @@
Thread::Current()->SleepMs(100);
rtc::Buffer payload;
- Socket::ReceiveBuffer receive_buffer(payload);
+ webrtc::Socket::ReceiveBuffer receive_buffer(payload);
int received = server->RecvFrom(receive_buffer);
return received == sent && ::memcmp(buf, payload.data(), len) == 0;
}
@@ -244,7 +248,7 @@
void TestPhysicalInternal(const webrtc::SocketAddress& int_addr) {
webrtc::test::ScopedKeyValueConfig field_trials;
rtc::AutoThread main_thread;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager network_manager(nullptr, &socket_server, &field_trials);
network_manager.StartUpdating();
// Process pending messages so the network list is updated.
@@ -285,8 +289,10 @@
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());
+ std::unique_ptr<webrtc::PhysicalSocketServer> int_pss(
+ new webrtc::PhysicalSocketServer());
+ std::unique_ptr<webrtc::PhysicalSocketServer> ext_pss(
+ new webrtc::PhysicalSocketServer());
TestBindings(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
TestFilters(int_pss.get(), int_addr, ext_pss.get(), ext_addrs);
@@ -306,11 +312,11 @@
namespace {
-class TestVirtualSocketServer : public VirtualSocketServer {
+class TestVirtualSocketServer : public webrtc::VirtualSocketServer {
public:
// Expose this publicly
webrtc::IPAddress GetNextIP(int af) {
- return VirtualSocketServer::GetNextIP(af);
+ return webrtc::VirtualSocketServer::GetNextIP(af);
}
};
@@ -372,13 +378,13 @@
ext_thread_->Start();
}
- void OnConnectEvent(Socket* socket) { connected_ = true; }
+ void OnConnectEvent(webrtc::Socket* socket) { connected_ = true; }
- void OnAcceptEvent(Socket* socket) {
+ void OnAcceptEvent(webrtc::Socket* socket) {
accepted_.reset(server_->Accept(nullptr));
}
- void OnCloseEvent(Socket* socket, int error) {}
+ void OnCloseEvent(webrtc::Socket* socket, int error) {}
void ConnectEvents() {
server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent);
@@ -394,9 +400,9 @@
std::unique_ptr<Thread> ext_thread_;
std::unique_ptr<webrtc::NATServer> nat_;
std::unique_ptr<webrtc::NATSocketFactory> natsf_;
- std::unique_ptr<Socket> client_;
- std::unique_ptr<Socket> server_;
- std::unique_ptr<Socket> accepted_;
+ std::unique_ptr<webrtc::Socket> client_;
+ std::unique_ptr<webrtc::Socket> server_;
+ std::unique_ptr<webrtc::Socket> accepted_;
};
TEST_F(NatTcpTest, DISABLED_TestConnectOut) {
diff --git a/p2p/test/stun_server.cc b/p2p/test/stun_server.cc
index 4299a3d..e1b36db 100644
--- a/p2p/test/stun_server.cc
+++ b/p2p/test/stun_server.cc
@@ -22,7 +22,7 @@
namespace webrtc {
-StunServer::StunServer(rtc::AsyncUDPSocket* socket) : socket_(socket) {
+StunServer::StunServer(AsyncUDPSocket* socket) : socket_(socket) {
socket_->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
OnPacket(socket, packet);
@@ -34,7 +34,7 @@
socket_->DeregisterReceivedPacketCallback();
}
-void StunServer::OnPacket(rtc::AsyncPacketSocket* socket,
+void StunServer::OnPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK_RUN_ON(&sequence_checker_);
// Parse the STUN message; eat any messages that fail to parse.
diff --git a/p2p/test/stun_server.h b/p2p/test/stun_server.h
index 06346ad..8649ee5 100644
--- a/p2p/test/stun_server.h
+++ b/p2p/test/stun_server.h
@@ -28,14 +28,13 @@
class StunServer {
public:
// Creates a STUN server, which will listen on the given socket.
- explicit StunServer(rtc::AsyncUDPSocket* socket);
+ explicit StunServer(AsyncUDPSocket* socket);
// Removes the STUN server from the socket and deletes the socket.
virtual ~StunServer();
protected:
// Callback for packets from socket.
- void OnPacket(rtc::AsyncPacketSocket* socket,
- const rtc::ReceivedPacket& packet);
+ void OnPacket(AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet);
// Handlers for the different types of STUN/TURN requests:
virtual void OnBindingRequest(cricket::StunMessage* msg,
@@ -61,7 +60,7 @@
private:
SequenceChecker sequence_checker_;
- std::unique_ptr<rtc::AsyncUDPSocket> socket_;
+ std::unique_ptr<AsyncUDPSocket> socket_;
};
} // namespace webrtc
diff --git a/p2p/test/stun_server_unittest.cc b/p2p/test/stun_server_unittest.cc
index a53c803..200b445 100644
--- a/p2p/test/stun_server_unittest.cc
+++ b/p2p/test/stun_server_unittest.cc
@@ -33,12 +33,12 @@
class StunServerTest : public ::testing::Test {
public:
- StunServerTest() : ss_(new rtc::VirtualSocketServer()) {
+ StunServerTest() : ss_(new VirtualSocketServer()) {
ss_->SetMessageQueue(&main_thread);
server_.reset(
- new StunServer(rtc::AsyncUDPSocket::Create(ss_.get(), server_addr)));
+ new StunServer(AsyncUDPSocket::Create(ss_.get(), server_addr)));
client_.reset(new TestClient(
- absl::WrapUnique(rtc::AsyncUDPSocket::Create(ss_.get(), client_addr))));
+ absl::WrapUnique(AsyncUDPSocket::Create(ss_.get(), client_addr))));
}
void Send(const cricket::StunMessage& msg) {
@@ -65,7 +65,7 @@
private:
rtc::AutoThread main_thread;
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
+ std::unique_ptr<VirtualSocketServer> ss_;
std::unique_ptr<StunServer> server_;
std::unique_ptr<TestClient> client_;
};
diff --git a/p2p/test/test_stun_server.cc b/p2p/test/test_stun_server.cc
index 38ca094..0aa0178 100644
--- a/p2p/test/test_stun_server.cc
+++ b/p2p/test/test_stun_server.cc
@@ -18,12 +18,12 @@
namespace webrtc {
std::unique_ptr<TestStunServer, std::function<void(webrtc::TestStunServer*)>>
-TestStunServer::Create(rtc::SocketServer* ss,
+TestStunServer::Create(SocketServer* ss,
const SocketAddress& addr,
rtc::Thread& network_thread) {
- rtc::Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM);
+ Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM);
RTC_CHECK(socket != nullptr) << "Failed to create socket";
- rtc::AsyncUDPSocket* udp_socket = rtc::AsyncUDPSocket::Create(socket, addr);
+ AsyncUDPSocket* udp_socket = AsyncUDPSocket::Create(socket, addr);
RTC_CHECK(udp_socket != nullptr) << "Failed to create AsyncUDPSocket";
TestStunServer* server = nullptr;
network_thread.BlockingCall(
diff --git a/p2p/test/test_stun_server.h b/p2p/test/test_stun_server.h
index cef3ea2..b16cdb5 100644
--- a/p2p/test/test_stun_server.h
+++ b/p2p/test/test_stun_server.h
@@ -28,7 +28,7 @@
using StunServerPtr =
std::unique_ptr<TestStunServer,
std::function<void(webrtc::TestStunServer*)>>;
- static StunServerPtr Create(rtc::SocketServer* ss,
+ static StunServerPtr Create(SocketServer* ss,
const SocketAddress& addr,
rtc::Thread& network_thread);
@@ -38,7 +38,7 @@
private:
static void DeleteOnNetworkThread(TestStunServer* server);
- TestStunServer(rtc::AsyncUDPSocket* socket, rtc::Thread& network_thread)
+ TestStunServer(AsyncUDPSocket* socket, rtc::Thread& network_thread)
: StunServer(socket), network_thread_(network_thread) {}
void OnBindingRequest(cricket::StunMessage* msg,
diff --git a/p2p/test/test_turn_server.h b/p2p/test/test_turn_server.h
index 6e4821b..7999f6e 100644
--- a/p2p/test/test_turn_server.h
+++ b/p2p/test/test_turn_server.h
@@ -53,7 +53,7 @@
class TestTurnServer : public TurnAuthInterface {
public:
TestTurnServer(rtc::Thread* thread,
- rtc::SocketFactory* socket_factory,
+ SocketFactory* socket_factory,
const SocketAddress& int_addr,
const SocketAddress& udp_ext_addr,
ProtocolType int_protocol = webrtc::PROTO_UDP,
@@ -62,7 +62,7 @@
: server_(thread), socket_factory_(socket_factory) {
AddInternalSocket(int_addr, int_protocol, ignore_bad_cert, common_name);
server_.SetExternalSocketFactory(
- new rtc::BasicPacketSocketFactory(socket_factory), udp_ext_addr);
+ new BasicPacketSocketFactory(socket_factory), udp_ext_addr);
server_.set_realm(kTestRealm);
server_.set_software(kTestSoftware);
server_.set_auth_hook(this);
@@ -101,7 +101,7 @@
} else if (proto == webrtc::PROTO_TCP || proto == webrtc::PROTO_TLS) {
// For TCP we need to create a server socket which can listen for incoming
// new connections.
- rtc::Socket* socket = socket_factory_->CreateSocket(AF_INET, SOCK_STREAM);
+ Socket* socket = socket_factory_->CreateSocket(AF_INET, SOCK_STREAM);
socket->Bind(int_addr);
socket->Listen(5);
if (proto == webrtc::PROTO_TLS) {
@@ -151,7 +151,7 @@
}
TurnServer server_;
- rtc::SocketFactory* socket_factory_;
+ SocketFactory* socket_factory_;
SequenceChecker thread_checker_;
};
diff --git a/p2p/test/turn_server.cc b/p2p/test/turn_server.cc
index c560460..1381a54 100644
--- a/p2p/test/turn_server.cc
+++ b/p2p/test/turn_server.cc
@@ -84,18 +84,18 @@
RTC_DCHECK_RUN_ON(thread_);
for (InternalSocketMap::iterator it = server_sockets_.begin();
it != server_sockets_.end(); ++it) {
- rtc::AsyncPacketSocket* socket = it->first;
+ AsyncPacketSocket* socket = it->first;
delete socket;
}
for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
it != server_listen_sockets_.end(); ++it) {
- rtc::Socket* socket = it->first;
+ Socket* socket = it->first;
delete socket;
}
}
-void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
+void TurnServer::AddInternalSocket(AsyncPacketSocket* socket,
ProtocolType proto) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(server_sockets_.end() == server_sockets_.find(socket));
@@ -108,7 +108,7 @@
}
void TurnServer::AddInternalServerSocket(
- rtc::Socket* socket,
+ Socket* socket,
ProtocolType proto,
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory) {
RTC_DCHECK_RUN_ON(thread_);
@@ -119,26 +119,26 @@
socket->SignalReadEvent.connect(this, &TurnServer::OnNewInternalConnection);
}
-void TurnServer::SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
+void TurnServer::SetExternalSocketFactory(PacketSocketFactory* factory,
const SocketAddress& external_addr) {
RTC_DCHECK_RUN_ON(thread_);
external_socket_factory_.reset(factory);
external_addr_ = external_addr;
}
-void TurnServer::OnNewInternalConnection(rtc::Socket* socket) {
+void TurnServer::OnNewInternalConnection(Socket* socket) {
RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(server_listen_sockets_.find(socket) !=
server_listen_sockets_.end());
AcceptConnection(socket);
}
-void TurnServer::AcceptConnection(rtc::Socket* server_socket) {
+void TurnServer::AcceptConnection(Socket* server_socket) {
RTC_DCHECK_RUN_ON(thread_);
// Check if someone is trying to connect to us.
SocketAddress accept_addr;
- rtc::Socket* accepted_socket = server_socket->Accept(&accept_addr);
+ Socket* accepted_socket = server_socket->Accept(&accept_addr);
if (accepted_socket != NULL) {
const ServerSocketInfo& info = server_listen_sockets_[server_socket];
if (info.ssl_adapter_factory) {
@@ -147,8 +147,7 @@
ssl_adapter->StartSSL("");
accepted_socket = ssl_adapter;
}
- cricket::AsyncStunTCPSocket* tcp_socket =
- new cricket::AsyncStunTCPSocket(accepted_socket);
+ AsyncStunTCPSocket* tcp_socket = new AsyncStunTCPSocket(accepted_socket);
tcp_socket->SubscribeCloseEvent(this,
[this](rtc::AsyncPacketSocket* s, int err) {
@@ -159,13 +158,12 @@
}
}
-void TurnServer::OnInternalSocketClose(rtc::AsyncPacketSocket* socket,
- int err) {
+void TurnServer::OnInternalSocketClose(AsyncPacketSocket* socket, int err) {
RTC_DCHECK_RUN_ON(thread_);
DestroyInternalSocket(socket);
}
-void TurnServer::OnInternalPacket(rtc::AsyncPacketSocket* socket,
+void TurnServer::OnInternalPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK_RUN_ON(thread_);
// Fail if the packet is too small to even contain a channel header.
@@ -420,7 +418,7 @@
TurnServerAllocation* TurnServer::CreateAllocation(TurnServerConnection* conn,
int proto,
absl::string_view key) {
- rtc::AsyncPacketSocket* external_socket =
+ AsyncPacketSocket* external_socket =
(external_socket_factory_)
? external_socket_factory_->CreateUdpSocket(external_addr_, 0, 0)
: NULL;
@@ -505,7 +503,7 @@
void TurnServer::DestroyAllocation(TurnServerAllocation* allocation) {
// Removing the internal socket if the connection is not udp.
- rtc::AsyncPacketSocket* socket = allocation->conn()->socket();
+ AsyncPacketSocket* socket = allocation->conn()->socket();
InternalSocketMap::iterator iter = server_sockets_.find(socket);
// Skip if the socket serving this allocation is UDP, as this will be shared
// by all allocations.
@@ -518,14 +516,14 @@
allocations_.erase(*(allocation->conn()));
}
-void TurnServer::DestroyInternalSocket(rtc::AsyncPacketSocket* socket) {
+void TurnServer::DestroyInternalSocket(AsyncPacketSocket* socket) {
InternalSocketMap::iterator iter = server_sockets_.find(socket);
if (iter != server_sockets_.end()) {
- rtc::AsyncPacketSocket* socket = iter->first;
+ AsyncPacketSocket* socket = iter->first;
socket->UnsubscribeCloseEvent(this);
socket->DeregisterReceivedPacketCallback();
server_sockets_.erase(iter);
- std::unique_ptr<rtc::AsyncPacketSocket> socket_to_delete =
+ std::unique_ptr<AsyncPacketSocket> socket_to_delete =
absl::WrapUnique(socket);
// We must destroy the socket async to avoid invalidating the sigslot
// callback list iterator inside a sigslot callback. (In other words,
@@ -536,7 +534,7 @@
TurnServerConnection::TurnServerConnection(const SocketAddress& src,
ProtocolType proto,
- rtc::AsyncPacketSocket* socket)
+ AsyncPacketSocket* socket)
: src_(src),
dst_(socket->GetRemoteAddress()),
proto_(proto),
@@ -561,7 +559,7 @@
TurnServerAllocation::TurnServerAllocation(TurnServer* server,
TaskQueueBase* thread,
const TurnServerConnection& conn,
- rtc::AsyncPacketSocket* socket,
+ AsyncPacketSocket* socket,
absl::string_view key)
: server_(server),
thread_(thread),
@@ -801,7 +799,7 @@
}
}
-void TurnServerAllocation::OnExternalPacket(rtc::AsyncPacketSocket* socket,
+void TurnServerAllocation::OnExternalPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) {
RTC_DCHECK(external_socket_.get() == socket);
auto channel = FindChannel(packet.source_address());
diff --git a/p2p/test/turn_server.h b/p2p/test/turn_server.h
index 26d7d00..91f5889 100644
--- a/p2p/test/turn_server.h
+++ b/p2p/test/turn_server.h
@@ -20,6 +20,7 @@
#include <vector>
#include "absl/strings/string_view.h"
+#include "api/packet_socket_factory.h"
#include "api/sequence_checker.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
@@ -33,7 +34,7 @@
namespace rtc {
class ByteBufferWriter;
-class PacketSocketFactory;
+
} // namespace rtc
namespace cricket {
class StunMessage;
@@ -56,9 +57,9 @@
TurnServerConnection() : proto_(webrtc::PROTO_UDP), socket_(NULL) {}
TurnServerConnection(const SocketAddress& src,
ProtocolType proto,
- rtc::AsyncPacketSocket* socket);
+ AsyncPacketSocket* socket);
const SocketAddress& src() const { return src_; }
- rtc::AsyncPacketSocket* socket() { return socket_; }
+ AsyncPacketSocket* socket() { return socket_; }
bool operator==(const TurnServerConnection& t) const;
bool operator<(const TurnServerConnection& t) const;
std::string ToString() const;
@@ -67,7 +68,7 @@
SocketAddress src_;
SocketAddress dst_;
ProtocolType proto_;
- rtc::AsyncPacketSocket* socket_;
+ AsyncPacketSocket* socket_;
};
// Encapsulates a TURN allocation.
@@ -80,7 +81,7 @@
TurnServerAllocation(TurnServer* server_,
TaskQueueBase* thread,
const TurnServerConnection& conn,
- rtc::AsyncPacketSocket* server_socket,
+ AsyncPacketSocket* server_socket,
absl::string_view key);
~TurnServerAllocation();
@@ -119,7 +120,7 @@
void HandleCreatePermissionRequest(const cricket::TurnMessage* msg);
void HandleChannelBindRequest(const cricket::TurnMessage* msg);
- void OnExternalPacket(rtc::AsyncPacketSocket* socket,
+ void OnExternalPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet);
static TimeDelta ComputeLifetime(const cricket::TurnMessage& msg);
@@ -139,7 +140,7 @@
TurnServer* const server_;
TaskQueueBase* const thread_;
TurnServerConnection conn_;
- std::unique_ptr<rtc::AsyncPacketSocket> external_socket_;
+ std::unique_ptr<AsyncPacketSocket> external_socket_;
std::string key_;
std::string transaction_id_;
std::string username_;
@@ -246,16 +247,16 @@
}
// Starts listening for packets from internal clients.
- void AddInternalSocket(rtc::AsyncPacketSocket* socket, ProtocolType proto);
+ void AddInternalSocket(AsyncPacketSocket* socket, ProtocolType proto);
// Starts listening for the connections on this socket. When someone tries
// to connect, the connection will be accepted and a new internal socket
// will be added.
void AddInternalServerSocket(
- rtc::Socket* socket,
+ Socket* socket,
ProtocolType proto,
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory = nullptr);
// Specifies the factory to use for creating external sockets.
- void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
+ void SetExternalSocketFactory(PacketSocketFactory* factory,
const SocketAddress& address);
// For testing only.
std::string SetTimestampForNextNonce(int64_t timestamp) {
@@ -275,14 +276,14 @@
// TurnServerAllocation (via friend declaration).
std::string GenerateNonce(int64_t now) const RTC_RUN_ON(thread_);
- void OnInternalPacket(rtc::AsyncPacketSocket* socket,
+ void OnInternalPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) RTC_RUN_ON(thread_);
- void OnNewInternalConnection(rtc::Socket* socket);
+ void OnNewInternalConnection(Socket* socket);
// Accept connections on this server socket.
- void AcceptConnection(rtc::Socket* server_socket) RTC_RUN_ON(thread_);
- void OnInternalSocketClose(rtc::AsyncPacketSocket* socket, int err);
+ void AcceptConnection(Socket* server_socket) RTC_RUN_ON(thread_);
+ void OnInternalSocketClose(AsyncPacketSocket* socket, int err);
void HandleStunMessage(TurnServerConnection* conn,
rtc::ArrayView<const uint8_t> payload)
@@ -328,16 +329,15 @@
void Send(TurnServerConnection* conn, const rtc::ByteBufferWriter& buf);
void DestroyAllocation(TurnServerAllocation* allocation) RTC_RUN_ON(thread_);
- void DestroyInternalSocket(rtc::AsyncPacketSocket* socket)
- RTC_RUN_ON(thread_);
+ void DestroyInternalSocket(AsyncPacketSocket* socket) RTC_RUN_ON(thread_);
- typedef std::map<rtc::AsyncPacketSocket*, ProtocolType> InternalSocketMap;
+ typedef std::map<AsyncPacketSocket*, ProtocolType> InternalSocketMap;
struct ServerSocketInfo {
ProtocolType proto;
// If non-null, used to wrap accepted sockets.
std::unique_ptr<rtc::SSLAdapterFactory> ssl_adapter_factory;
};
- typedef std::map<rtc::Socket*, ServerSocketInfo> ServerSocketMap;
+ typedef std::map<Socket*, ServerSocketInfo> ServerSocketMap;
TaskQueueBase* const thread_;
const std::string nonce_key_;
@@ -355,7 +355,7 @@
InternalSocketMap server_sockets_ RTC_GUARDED_BY(thread_);
ServerSocketMap server_listen_sockets_ RTC_GUARDED_BY(thread_);
- std::unique_ptr<rtc::PacketSocketFactory> external_socket_factory_
+ std::unique_ptr<PacketSocketFactory> external_socket_factory_
RTC_GUARDED_BY(thread_);
SocketAddress external_addr_ RTC_GUARDED_BY(thread_);
diff --git a/p2p/test/turn_server_unittest.cc b/p2p/test/turn_server_unittest.cc
index a90b9fd..1cb69e7 100644
--- a/p2p/test/turn_server_unittest.cc
+++ b/p2p/test/turn_server_unittest.cc
@@ -45,15 +45,15 @@
}
protected:
- rtc::VirtualSocketServer vss_;
+ VirtualSocketServer vss_;
rtc::AutoSocketServerThread thread_;
- rtc::BasicPacketSocketFactory socket_factory_;
+ BasicPacketSocketFactory socket_factory_;
};
TEST_F(TurnServerConnectionTest, ComparisonOperators) {
- std::unique_ptr<rtc::AsyncPacketSocket> socket1(
+ std::unique_ptr<AsyncPacketSocket> socket1(
socket_factory_.CreateUdpSocket(SocketAddress("1.1.1.1", 1), 0, 0));
- std::unique_ptr<rtc::AsyncPacketSocket> socket2(
+ std::unique_ptr<AsyncPacketSocket> socket2(
socket_factory_.CreateUdpSocket(SocketAddress("2.2.2.2", 2), 0, 0));
TurnServerConnection connection1(socket2->GetLocalAddress(), PROTO_UDP,
socket1.get());
diff --git a/pc/channel.cc b/pc/channel.cc
index b7b4ec5..9c789dd 100644
--- a/pc/channel.cc
+++ b/pc/channel.cc
@@ -323,7 +323,7 @@
}
int BaseChannel::SetOption(SocketType type,
- rtc::Socket::Option opt,
+ webrtc::Socket::Option opt,
int value) {
RTC_DCHECK_RUN_ON(network_thread());
RTC_DCHECK(network_initialized());
@@ -331,11 +331,11 @@
switch (type) {
case ST_RTP:
socket_options_.push_back(
- std::pair<rtc::Socket::Option, int>(opt, value));
+ std::pair<webrtc::Socket::Option, int>(opt, value));
return rtp_transport_->SetRtpOption(opt, value);
case ST_RTCP:
rtcp_socket_options_.push_back(
- std::pair<rtc::Socket::Option, int>(opt, value));
+ std::pair<webrtc::Socket::Option, int>(opt, value));
return rtp_transport_->SetRtcpOption(opt, value);
}
return -1;
diff --git a/pc/channel.h b/pc/channel.h
index a69137c..3e02628 100644
--- a/pc/channel.h
+++ b/pc/channel.h
@@ -155,7 +155,7 @@
void OnTransportReadyToSend(bool ready);
// Only public for unit tests. Otherwise, consider protected.
- int SetOption(SocketType type, rtc::Socket::Option o, int val) override;
+ int SetOption(SocketType type, webrtc::Socket::Option o, int val) override;
// RtpPacketSinkInterface overrides.
void OnRtpPacket(const webrtc::RtpPacketReceived& packet) override;
@@ -325,9 +325,9 @@
webrtc::RtpTransportInternal* rtp_transport_
RTC_GUARDED_BY(network_thread()) = nullptr;
- std::vector<std::pair<rtc::Socket::Option, int> > socket_options_
+ std::vector<std::pair<webrtc::Socket::Option, int> > socket_options_
RTC_GUARDED_BY(network_thread());
- std::vector<std::pair<rtc::Socket::Option, int> > rtcp_socket_options_
+ std::vector<std::pair<webrtc::Socket::Option, int> > rtcp_socket_options_
RTC_GUARDED_BY(network_thread());
bool writable_ RTC_GUARDED_BY(network_thread()) = false;
bool was_ever_writable_n_ RTC_GUARDED_BY(network_thread()) = false;
diff --git a/pc/channel_unittest.cc b/pc/channel_unittest.cc
index b907848..187f659 100644
--- a/pc/channel_unittest.cc
+++ b/pc/channel_unittest.cc
@@ -1421,14 +1421,14 @@
new_rtp_transport_ = CreateDtlsSrtpTransport(
fake_rtp_dtls_transport2_.get(), fake_rtcp_dtls_transport2_.get());
channel1_->SetOption(cricket::BaseChannel::ST_RTP,
- rtc::Socket::Option::OPT_SNDBUF, kSndBufSize);
+ webrtc::Socket::Option::OPT_SNDBUF, kSndBufSize);
channel2_->SetOption(cricket::BaseChannel::ST_RTP,
- rtc::Socket::Option::OPT_RCVBUF, kRcvBufSize);
+ webrtc::Socket::Option::OPT_RCVBUF, kRcvBufSize);
channel1_->SetRtpTransport(new_rtp_transport_.get());
send_success = fake_rtp_dtls_transport2_->GetOption(
- rtc::Socket::Option::OPT_SNDBUF, &send_buf);
+ webrtc::Socket::Option::OPT_SNDBUF, &send_buf);
rcv_success = fake_rtp_dtls_transport2_->GetOption(
- rtc::Socket::Option::OPT_RCVBUF, &rcv_buf);
+ webrtc::Socket::Option::OPT_RCVBUF, &rcv_buf);
});
ASSERT_TRUE(send_success);
diff --git a/pc/connection_context.cc b/pc/connection_context.cc
index ab682b7..6123111 100644
--- a/pc/connection_context.cc
+++ b/pc/connection_context.cc
@@ -29,12 +29,12 @@
rtc::Thread* MaybeStartNetworkThread(
rtc::Thread* old_thread,
- std::unique_ptr<rtc::SocketFactory>& socket_factory_holder,
+ std::unique_ptr<SocketFactory>& socket_factory_holder,
std::unique_ptr<rtc::Thread>& thread_holder) {
if (old_thread) {
return old_thread;
}
- std::unique_ptr<rtc::SocketServer> socket_server =
+ std::unique_ptr<SocketServer> socket_server =
rtc::CreateDefaultSocketServer();
thread_holder = std::make_unique<rtc::Thread>(socket_server.get());
socket_factory_holder = std::move(socket_server);
@@ -137,7 +137,7 @@
rtc::InitRandom(rtc::Time32());
- rtc::SocketFactory* socket_factory = dependencies->socket_factory;
+ SocketFactory* socket_factory = dependencies->socket_factory;
if (socket_factory == nullptr) {
if (owned_socket_factory_) {
socket_factory = owned_socket_factory_.get();
@@ -158,7 +158,7 @@
}
if (!default_socket_factory_) {
default_socket_factory_ =
- std::make_unique<rtc::BasicPacketSocketFactory>(socket_factory);
+ std::make_unique<BasicPacketSocketFactory>(socket_factory);
}
// Set warning levels on the threads, to give warnings when response
// may be slower than is expected of the thread.
diff --git a/pc/connection_context.h b/pc/connection_context.h
index 8a5c91d..2af7f44 100644
--- a/pc/connection_context.h
+++ b/pc/connection_context.h
@@ -32,10 +32,6 @@
#include "rtc_base/thread_annotations.h"
#include "rtc_base/unique_id_generator.h"
-namespace rtc {
-class BasicPacketSocketFactory;
-} // namespace rtc
-
namespace webrtc {
// This class contains resources needed by PeerConnection and associated
@@ -83,7 +79,7 @@
RTC_DCHECK_RUN_ON(signaling_thread_);
return default_network_manager_.get();
}
- rtc::PacketSocketFactory* default_socket_factory() {
+ PacketSocketFactory* default_socket_factory() {
RTC_DCHECK_RUN_ON(signaling_thread_);
return default_socket_factory_.get();
}
@@ -112,7 +108,7 @@
// The following three variables are used to communicate between the
// constructor and the destructor, and are never exposed externally.
bool wraps_current_thread_;
- std::unique_ptr<rtc::SocketFactory> owned_socket_factory_;
+ std::unique_ptr<SocketFactory> owned_socket_factory_;
std::unique_ptr<rtc::Thread> owned_network_thread_
RTC_GUARDED_BY(signaling_thread_);
rtc::Thread* const network_thread_;
@@ -137,7 +133,7 @@
std::unique_ptr<MediaFactory> const call_factory_
RTC_GUARDED_BY(worker_thread());
- std::unique_ptr<rtc::PacketSocketFactory> default_socket_factory_
+ std::unique_ptr<PacketSocketFactory> default_socket_factory_
RTC_GUARDED_BY(signaling_thread_);
std::unique_ptr<SctpTransportFactoryInterface> const sctp_factory_;
diff --git a/pc/data_channel_controller_unittest.cc b/pc/data_channel_controller_unittest.cc
index ef71182..393362d 100644
--- a/pc/data_channel_controller_unittest.cc
+++ b/pc/data_channel_controller_unittest.cc
@@ -84,7 +84,7 @@
class DataChannelControllerTest : public ::testing::Test {
protected:
DataChannelControllerTest()
- : network_thread_(std::make_unique<rtc::NullSocketServer>()) {
+ : network_thread_(std::make_unique<NullSocketServer>()) {
network_thread_.Start();
pc_ = rtc::make_ref_counted<NiceMock<MockPeerConnectionInternal>>();
ON_CALL(*pc_, signaling_thread)
diff --git a/pc/data_channel_unittest.cc b/pc/data_channel_unittest.cc
index 38130a9..4e96638 100644
--- a/pc/data_channel_unittest.cc
+++ b/pc/data_channel_unittest.cc
@@ -84,7 +84,7 @@
class SctpDataChannelTest : public ::testing::Test {
protected:
SctpDataChannelTest()
- : network_thread_(std::make_unique<rtc::NullSocketServer>()),
+ : network_thread_(std::make_unique<NullSocketServer>()),
controller_(new FakeDataChannelController(&network_thread_)) {
network_thread_.Start();
inner_channel_ = controller_->CreateDataChannel("test", init_);
diff --git a/pc/ice_transport_unittest.cc b/pc/ice_transport_unittest.cc
index 847908a..4635a09 100644
--- a/pc/ice_transport_unittest.cc
+++ b/pc/ice_transport_unittest.cc
@@ -30,12 +30,12 @@
: socket_server_(rtc::CreateDefaultSocketServer()),
main_thread_(socket_server_.get()) {}
- rtc::SocketServer* socket_server() const { return socket_server_.get(); }
+ SocketServer* socket_server() const { return socket_server_.get(); }
test::ScopedKeyValueConfig field_trials_;
private:
- std::unique_ptr<rtc::SocketServer> socket_server_;
+ std::unique_ptr<SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
};
@@ -52,8 +52,7 @@
TEST_F(IceTransportTest, CreateSelfDeletingTransport) {
std::unique_ptr<cricket::FakePortAllocator> port_allocator(
std::make_unique<cricket::FakePortAllocator>(
- nullptr,
- std::make_unique<rtc::BasicPacketSocketFactory>(socket_server()),
+ nullptr, std::make_unique<BasicPacketSocketFactory>(socket_server()),
&field_trials_));
IceTransportInit init;
init.set_port_allocator(port_allocator.get());
diff --git a/pc/legacy_stats_collector_unittest.cc b/pc/legacy_stats_collector_unittest.cc
index 96dba2e..ed7f800 100644
--- a/pc/legacy_stats_collector_unittest.cc
+++ b/pc/legacy_stats_collector_unittest.cc
@@ -868,7 +868,7 @@
// Similar to `DetachAndMerge` above but detaches on one thread, merges on
// another to test that we don't trigger sequence checker.
TEST(StatsCollectionTest, DetachAndMergeThreaded) {
- rtc::Thread new_thread(std::make_unique<rtc::NullSocketServer>());
+ rtc::Thread new_thread(std::make_unique<NullSocketServer>());
new_thread.Start();
StatsReport::Id id(
diff --git a/pc/peer_connection_adaptation_integrationtest.cc b/pc/peer_connection_adaptation_integrationtest.cc
index 3ed90a0..5ad0fb2 100644
--- a/pc/peer_connection_adaptation_integrationtest.cc
+++ b/pc/peer_connection_adaptation_integrationtest.cc
@@ -104,7 +104,7 @@
}
protected:
- rtc::VirtualSocketServer virtual_socket_server_;
+ VirtualSocketServer virtual_socket_server_;
std::unique_ptr<rtc::Thread> network_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
};
diff --git a/pc/peer_connection_bundle_unittest.cc b/pc/peer_connection_bundle_unittest.cc
index 4bc41c1..f863117 100644
--- a/pc/peer_connection_bundle_unittest.cc
+++ b/pc/peer_connection_bundle_unittest.cc
@@ -269,7 +269,7 @@
return candidate;
}
- rtc::VirtualSocketServer vss_;
+ VirtualSocketServer vss_;
rtc::AutoSocketServerThread main_;
const SdpSemantics sdp_semantics_;
};
diff --git a/pc/peer_connection_crypto_unittest.cc b/pc/peer_connection_crypto_unittest.cc
index 4eda3f5..5d3b4a9 100644
--- a/pc/peer_connection_crypto_unittest.cc
+++ b/pc/peer_connection_crypto_unittest.cc
@@ -77,7 +77,7 @@
typedef std::unique_ptr<PeerConnectionWrapper> WrapperPtr;
explicit PeerConnectionCryptoBaseTest(SdpSemantics sdp_semantics)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
@@ -109,7 +109,7 @@
std::unique_ptr<RTCCertificateGeneratorInterface> cert_gen) {
auto fake_port_allocator = std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get()),
+ std::make_unique<BasicPacketSocketFactory>(vss_.get()),
field_trials_.get());
auto observer = std::make_unique<MockPeerConnectionObserver>();
RTCConfiguration modified_config = config;
@@ -161,7 +161,7 @@
}
std::unique_ptr<FieldTrials> field_trials_ = FieldTrials::CreateNoGlobal("");
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
const SdpSemantics sdp_semantics_;
diff --git a/pc/peer_connection_data_channel_unittest.cc b/pc/peer_connection_data_channel_unittest.cc
index 9f7a21b..b75a0a6 100644
--- a/pc/peer_connection_data_channel_unittest.cc
+++ b/pc/peer_connection_data_channel_unittest.cc
@@ -94,7 +94,7 @@
typedef std::unique_ptr<PeerConnectionWrapperForDataChannelTest> WrapperPtr;
explicit PeerConnectionDataChannelBaseTest(SdpSemantics sdp_semantics)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
@@ -158,7 +158,7 @@
data_desc->set_port(port);
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
const SdpSemantics sdp_semantics_;
};
diff --git a/pc/peer_connection_encodings_integrationtest.cc b/pc/peer_connection_encodings_integrationtest.cc
index 22b8a01..c37796f 100644
--- a/pc/peer_connection_encodings_integrationtest.cc
+++ b/pc/peer_connection_encodings_integrationtest.cc
@@ -427,7 +427,7 @@
return true;
}
- rtc::PhysicalSocketServer pss_;
+ PhysicalSocketServer pss_;
std::unique_ptr<rtc::Thread> background_thread_;
};
diff --git a/pc/peer_connection_end_to_end_unittest.cc b/pc/peer_connection_end_to_end_unittest.cc
index 21c935b..50b1b11 100644
--- a/pc/peer_connection_end_to_end_unittest.cc
+++ b/pc/peer_connection_end_to_end_unittest.cc
@@ -250,7 +250,7 @@
protected:
rtc::AutoThread main_thread_;
- rtc::PhysicalSocketServer pss_;
+ webrtc::PhysicalSocketServer pss_;
std::unique_ptr<rtc::Thread> network_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
diff --git a/pc/peer_connection_factory_unittest.cc b/pc/peer_connection_factory_unittest.cc
index 72d71a8..d0235cc 100644
--- a/pc/peer_connection_factory_unittest.cc
+++ b/pc/peer_connection_factory_unittest.cc
@@ -169,7 +169,7 @@
ASSERT_TRUE(factory_.get() != NULL);
packet_socket_factory_.reset(
- new rtc::BasicPacketSocketFactory(socket_server_.get()));
+ new BasicPacketSocketFactory(socket_server_.get()));
port_allocator_.reset(new cricket::FakePortAllocator(
rtc::Thread::Current(), packet_socket_factory_.get(),
field_trials_.get()));
@@ -268,11 +268,11 @@
}
std::unique_ptr<FieldTrials> field_trials_ = FieldTrials::CreateNoGlobal("");
- std::unique_ptr<rtc::SocketServer> socket_server_;
+ std::unique_ptr<SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> factory_;
NullPeerConnectionObserver observer_;
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
+ std::unique_ptr<PacketSocketFactory> packet_socket_factory_;
std::unique_ptr<cricket::FakePortAllocator> port_allocator_;
// Since the PC owns the port allocator after it's been initialized,
// this should only be used when known to be safe.
diff --git a/pc/peer_connection_field_trial_tests.cc b/pc/peer_connection_field_trial_tests.cc
index be9c49f..0f801e8 100644
--- a/pc/peer_connection_field_trial_tests.cc
+++ b/pc/peer_connection_field_trial_tests.cc
@@ -92,7 +92,7 @@
}
Clock* const clock_;
- std::unique_ptr<rtc::SocketServer> socket_server_;
+ std::unique_ptr<SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
PeerConnectionInterface::RTCConfiguration config_;
diff --git a/pc/peer_connection_header_extension_unittest.cc b/pc/peer_connection_header_extension_unittest.cc
index ef296f5..be83d43 100644
--- a/pc/peer_connection_header_extension_unittest.cc
+++ b/pc/peer_connection_header_extension_unittest.cc
@@ -94,7 +94,7 @@
auto fake_port_allocator = std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
- std::make_unique<rtc::BasicPacketSocketFactory>(socket_server_.get()),
+ std::make_unique<BasicPacketSocketFactory>(socket_server_.get()),
field_trials_.get());
auto observer = std::make_unique<MockPeerConnectionObserver>();
PeerConnectionInterface::RTCConfiguration config;
@@ -111,7 +111,7 @@
}
std::unique_ptr<FieldTrials> field_trials_ = FieldTrials::CreateNoGlobal("");
- std::unique_ptr<rtc::SocketServer> socket_server_;
+ std::unique_ptr<SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
std::vector<RtpHeaderExtensionCapability> extensions_;
};
diff --git a/pc/peer_connection_histogram_unittest.cc b/pc/peer_connection_histogram_unittest.cc
index de67d8e..8b92b29 100644
--- a/pc/peer_connection_histogram_unittest.cc
+++ b/pc/peer_connection_histogram_unittest.cc
@@ -321,7 +321,7 @@
}
int next_local_address_ = 0;
- rtc::VirtualSocketServer vss_;
+ VirtualSocketServer vss_;
rtc::AutoSocketServerThread main_;
};
diff --git a/pc/peer_connection_ice_unittest.cc b/pc/peer_connection_ice_unittest.cc
index 74d2e7d..6488cea 100644
--- a/pc/peer_connection_ice_unittest.cc
+++ b/pc/peer_connection_ice_unittest.cc
@@ -314,7 +314,7 @@
return sdesc->AddCandidate(jsep_candidate.get());
}
- rtc::VirtualSocketServer vss_;
+ VirtualSocketServer vss_;
rtc::AutoSocketServerThread main_;
const SdpSemantics sdp_semantics_;
};
@@ -1468,7 +1468,7 @@
}
void CreatePeerConnection(const RTCConfiguration& config) {
packet_socket_factory_.reset(
- new rtc::BasicPacketSocketFactory(socket_server_.get()));
+ new BasicPacketSocketFactory(socket_server_.get()));
std::unique_ptr<cricket::FakePortAllocator> port_allocator(
new cricket::FakePortAllocator(rtc::Thread::Current(),
packet_socket_factory_.get(),
@@ -1483,11 +1483,11 @@
}
std::unique_ptr<FieldTrials> field_trials_ = FieldTrials::CreateNoGlobal("");
- std::unique_ptr<rtc::SocketServer> socket_server_;
+ std::unique_ptr<SocketServer> socket_server_;
rtc::AutoSocketServerThread main_thread_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_ = nullptr;
rtc::scoped_refptr<PeerConnectionInterface> pc_ = nullptr;
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory_;
+ std::unique_ptr<PacketSocketFactory> packet_socket_factory_;
cricket::FakePortAllocator* port_allocator_ = nullptr;
MockPeerConnectionObserver observer_;
diff --git a/pc/peer_connection_interface_unittest.cc b/pc/peer_connection_interface_unittest.cc
index 7fa6cb4..606673c 100644
--- a/pc/peer_connection_interface_unittest.cc
+++ b/pc/peer_connection_interface_unittest.cc
@@ -641,7 +641,7 @@
class PeerConnectionInterfaceBaseTest : public ::testing::Test {
protected:
explicit PeerConnectionInterfaceBaseTest(SdpSemantics sdp_semantics)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
@@ -715,7 +715,7 @@
std::unique_ptr<cricket::FakePortAllocator> port_allocator(
new cricket::FakePortAllocator(
rtc::Thread::Current(),
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get()),
+ std::make_unique<BasicPacketSocketFactory>(vss_.get()),
field_trials_.get()));
port_allocator_ = port_allocator.get();
@@ -1258,10 +1258,10 @@
}
}
- rtc::SocketServer* socket_server() const { return vss_.get(); }
+ SocketServer* socket_server() const { return vss_.get(); }
std::unique_ptr<FieldTrials> field_trials_ = FieldTrials::CreateNoGlobal("");
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module_;
cricket::FakePortAllocator* port_allocator_ = nullptr;
@@ -1366,8 +1366,8 @@
TEST_P(PeerConnectionInterfaceTest,
CreatePeerConnectionAppliesNetworkConfigToPortAllocator) {
// Create fake port allocator.
- std::unique_ptr<rtc::PacketSocketFactory> packet_socket_factory(
- new rtc::BasicPacketSocketFactory(socket_server()));
+ std::unique_ptr<PacketSocketFactory> packet_socket_factory(
+ new BasicPacketSocketFactory(socket_server()));
std::unique_ptr<cricket::FakePortAllocator> port_allocator(
new cricket::FakePortAllocator(rtc::Thread::Current(),
packet_socket_factory.get(),
diff --git a/pc/peer_connection_jsep_unittest.cc b/pc/peer_connection_jsep_unittest.cc
index 547593b..da03d3b 100644
--- a/pc/peer_connection_jsep_unittest.cc
+++ b/pc/peer_connection_jsep_unittest.cc
@@ -86,7 +86,7 @@
typedef std::unique_ptr<PeerConnectionWrapper> WrapperPtr;
PeerConnectionJsepTest()
- : vss_(new rtc::VirtualSocketServer()), main_(vss_.get()) {
+ : vss_(new VirtualSocketServer()), main_(vss_.get()) {
#ifdef WEBRTC_ANDROID
InitializeAndroidObjects();
#endif
@@ -114,7 +114,7 @@
pc_factory, result.MoveValue(), std::move(observer));
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
};
diff --git a/pc/peer_connection_media_unittest.cc b/pc/peer_connection_media_unittest.cc
index f656494c..8c65950 100644
--- a/pc/peer_connection_media_unittest.cc
+++ b/pc/peer_connection_media_unittest.cc
@@ -138,7 +138,7 @@
typedef std::unique_ptr<PeerConnectionWrapperForMediaTest> WrapperPtr;
explicit PeerConnectionMediaBaseTest(SdpSemantics sdp_semantics)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
@@ -179,7 +179,7 @@
auto fake_port_allocator = std::make_unique<cricket::FakePortAllocator>(
rtc::Thread::Current(),
- std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get()), nullptr);
+ std::make_unique<BasicPacketSocketFactory>(vss_.get()), nullptr);
auto observer = std::make_unique<MockPeerConnectionObserver>();
auto modified_config = config;
modified_config.sdp_semantics = sdp_semantics_;
@@ -250,7 +250,7 @@
return sdp_semantics_ == SdpSemantics::kUnifiedPlan;
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
const SdpSemantics sdp_semantics_;
};
diff --git a/pc/peer_connection_rampup_tests.cc b/pc/peer_connection_rampup_tests.cc
index 428ca8c..d5ab770 100644
--- a/pc/peer_connection_rampup_tests.cc
+++ b/pc/peer_connection_rampup_tests.cc
@@ -251,7 +251,7 @@
void CreateTurnServer(ProtocolType type,
const std::string& common_name = "test turn server") {
rtc::Thread* thread = network_thread();
- rtc::SocketFactory* factory = &firewall_socket_server_;
+ SocketFactory* factory = &firewall_socket_server_;
std::unique_ptr<TestTurnServer> turn_server;
SendTask(network_thread(), [&] {
static const SocketAddress turn_server_internal_address{
@@ -291,7 +291,7 @@
rtc::Thread* network_thread() { return &network_thread_; }
- rtc::FirewallSocketServer* firewall_socket_server() {
+ FirewallSocketServer* firewall_socket_server() {
return &firewall_socket_server_;
}
@@ -343,8 +343,8 @@
// the VirtualSocketServer. The first ramp down time is very noisy and the
// second ramp up time can take up to 300 seconds, most likely due to a built
// up queue.
- rtc::VirtualSocketServer virtual_socket_server_;
- rtc::FirewallSocketServer firewall_socket_server_;
+ VirtualSocketServer virtual_socket_server_;
+ FirewallSocketServer firewall_socket_server_;
rtc::Thread network_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
diff --git a/pc/peer_connection_signaling_unittest.cc b/pc/peer_connection_signaling_unittest.cc
index a580cd8..3acec31 100644
--- a/pc/peer_connection_signaling_unittest.cc
+++ b/pc/peer_connection_signaling_unittest.cc
@@ -123,7 +123,7 @@
typedef std::unique_ptr<PeerConnectionWrapperForSignalingTest> WrapperPtr;
explicit PeerConnectionSignalingBaseTest(SdpSemantics sdp_semantics)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new VirtualSocketServer()),
main_(vss_.get()),
sdp_semantics_(sdp_semantics) {
#ifdef WEBRTC_ANDROID
@@ -196,7 +196,7 @@
return NumberOfDtlsTransports(pc_wrapper) > 0;
}
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<VirtualSocketServer> vss_;
rtc::AutoSocketServerThread main_;
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
const SdpSemantics sdp_semantics_;
diff --git a/pc/rtc_stats_integrationtest.cc b/pc/rtc_stats_integrationtest.cc
index f28f50a..063b999 100644
--- a/pc/rtc_stats_integrationtest.cc
+++ b/pc/rtc_stats_integrationtest.cc
@@ -151,7 +151,7 @@
// `network_thread_` uses `virtual_socket_server_` so they must be
// constructed/destructed in the correct order.
- rtc::VirtualSocketServer virtual_socket_server_;
+ VirtualSocketServer virtual_socket_server_;
std::unique_ptr<rtc::Thread> network_thread_;
std::unique_ptr<rtc::Thread> worker_thread_;
rtc::scoped_refptr<PeerConnectionTestWrapper> caller_;
diff --git a/pc/rtp_transport.cc b/pc/rtp_transport.cc
index b2124003..27341a4 100644
--- a/pc/rtp_transport.cc
+++ b/pc/rtp_transport.cc
@@ -35,11 +35,11 @@
return rtp_packet_transport_->transport_name();
}
-int RtpTransport::SetRtpOption(rtc::Socket::Option opt, int value) {
+int RtpTransport::SetRtpOption(Socket::Option opt, int value) {
return rtp_packet_transport_->SetOption(opt, value);
}
-int RtpTransport::SetRtcpOption(rtc::Socket::Option opt, int value) {
+int RtpTransport::SetRtcpOption(Socket::Option opt, int value) {
if (rtcp_packet_transport_) {
return rtcp_packet_transport_->SetOption(opt, value);
}
diff --git a/pc/rtp_transport.h b/pc/rtp_transport.h
index 748214f..ba8d97a 100644
--- a/pc/rtp_transport.h
+++ b/pc/rtp_transport.h
@@ -59,8 +59,8 @@
const std::string& transport_name() const override;
- int SetRtpOption(rtc::Socket::Option opt, int value) override;
- int SetRtcpOption(rtc::Socket::Option opt, int value) override;
+ int SetRtpOption(Socket::Option opt, int value) override;
+ int SetRtcpOption(Socket::Option opt, int value) override;
rtc::PacketTransportInternal* rtp_packet_transport() const {
return rtp_packet_transport_;
diff --git a/pc/rtp_transport_internal.h b/pc/rtp_transport_internal.h
index ee567dd..180289c 100644
--- a/pc/rtp_transport_internal.h
+++ b/pc/rtp_transport_internal.h
@@ -42,8 +42,8 @@
virtual const std::string& transport_name() const = 0;
// Sets socket options on the underlying RTP or RTCP transports.
- virtual int SetRtpOption(rtc::Socket::Option opt, int value) = 0;
- virtual int SetRtcpOption(rtc::Socket::Option opt, int value) = 0;
+ virtual int SetRtpOption(Socket::Option opt, int value) = 0;
+ virtual int SetRtcpOption(Socket::Option opt, int value) = 0;
virtual bool rtcp_mux_enabled() const = 0;
diff --git a/pc/test/integration_test_helpers.cc b/pc/test/integration_test_helpers.cc
index 04dd26f..19882a4 100644
--- a/pc/test/integration_test_helpers.cc
+++ b/pc/test/integration_test_helpers.cc
@@ -217,7 +217,7 @@
const PeerConnectionFactory::Options* options,
const PeerConnectionInterface::RTCConfiguration* config,
PeerConnectionDependencies dependencies,
- rtc::SocketServer* socket_server,
+ SocketServer* socket_server,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
std::unique_ptr<FieldTrialsView> field_trials,
diff --git a/pc/test/integration_test_helpers.h b/pc/test/integration_test_helpers.h
index 968c572..bf45337 100644
--- a/pc/test/integration_test_helpers.h
+++ b/pc/test/integration_test_helpers.h
@@ -795,7 +795,7 @@
bool Init(const PeerConnectionFactory::Options* options,
const PeerConnectionInterface::RTCConfiguration* config,
PeerConnectionDependencies dependencies,
- rtc::SocketServer* socket_server,
+ SocketServer* socket_server,
rtc::Thread* network_thread,
rtc::Thread* worker_thread,
std::unique_ptr<FieldTrialsView> field_trials,
@@ -1375,8 +1375,8 @@
explicit PeerConnectionIntegrationBaseTest(SdpSemantics sdp_semantics)
: sdp_semantics_(sdp_semantics),
- ss_(new rtc::VirtualSocketServer()),
- fss_(new rtc::FirewallSocketServer(ss_.get())),
+ ss_(new VirtualSocketServer()),
+ fss_(new FirewallSocketServer(ss_.get())),
network_thread_(new rtc::Thread(fss_.get())),
worker_thread_(rtc::Thread::Create()) {
network_thread_->SetName("PCNetworkThread", this);
@@ -1640,7 +1640,7 @@
ProtocolType type = ProtocolType::PROTO_UDP,
const std::string& common_name = "test turn server") {
rtc::Thread* thread = network_thread();
- rtc::SocketFactory* socket_factory = fss_.get();
+ SocketFactory* socket_factory = fss_.get();
std::unique_ptr<TestTurnServer> turn_server;
SendTask(network_thread(), [&] {
turn_server = std::make_unique<TestTurnServer>(
@@ -1709,7 +1709,7 @@
rtc::Thread* network_thread() { return network_thread_.get(); }
- rtc::VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
+ VirtualSocketServer* virtual_socket_server() { return ss_.get(); }
PeerConnectionIntegrationWrapper* caller() { return caller_.get(); }
@@ -1747,7 +1747,7 @@
return old;
}
- rtc::FirewallSocketServer* firewall() const { return fss_.get(); }
+ FirewallSocketServer* firewall() const { return fss_.get(); }
// Expects the provided number of new frames to be received within
// kMaxWaitForFramesMs. The new expected frames are specified in
@@ -1910,8 +1910,8 @@
private:
rtc::AutoThread main_thread_; // Used as the signal thread by most tests.
// `ss_` is used by `network_thread_` so it must be destroyed later.
- std::unique_ptr<rtc::VirtualSocketServer> ss_;
- std::unique_ptr<rtc::FirewallSocketServer> fss_;
+ std::unique_ptr<VirtualSocketServer> ss_;
+ std::unique_ptr<FirewallSocketServer> fss_;
// `network_thread_` and `worker_thread_` are used by both
// `caller_` and `callee_` so they must be destroyed
// later.
diff --git a/pc/test/peer_connection_test_wrapper.cc b/pc/test/peer_connection_test_wrapper.cc
index 64a038d..dccb56d 100644
--- a/pc/test/peer_connection_test_wrapper.cc
+++ b/pc/test/peer_connection_test_wrapper.cc
@@ -144,7 +144,7 @@
PeerConnectionTestWrapper::PeerConnectionTestWrapper(
const std::string& name,
- rtc::SocketServer* socket_server,
+ webrtc::SocketServer* socket_server,
rtc::Thread* network_thread,
rtc::Thread* worker_thread)
: name_(name),
@@ -179,7 +179,7 @@
std::unique_ptr<cricket::PortAllocator> port_allocator(
new cricket::FakePortAllocator(
network_thread_,
- std::make_unique<rtc::BasicPacketSocketFactory>(socket_server_),
+ std::make_unique<webrtc::BasicPacketSocketFactory>(socket_server_),
field_trials.get()));
RTC_DCHECK_RUN_ON(&pc_thread_checker_);
diff --git a/pc/test/peer_connection_test_wrapper.h b/pc/test/peer_connection_test_wrapper.h
index 3867570..973fd42 100644
--- a/pc/test/peer_connection_test_wrapper.h
+++ b/pc/test/peer_connection_test_wrapper.h
@@ -50,7 +50,7 @@
PeerConnectionTestWrapper* callee);
PeerConnectionTestWrapper(const std::string& name,
- rtc::SocketServer* socket_server,
+ webrtc::SocketServer* socket_server,
rtc::Thread* network_thread,
rtc::Thread* worker_thread);
virtual ~PeerConnectionTestWrapper();
@@ -144,7 +144,7 @@
bool CheckForVideo();
std::string name_;
- rtc::SocketServer* const socket_server_;
+ webrtc::SocketServer* const socket_server_;
rtc::Thread* const network_thread_;
rtc::Thread* const worker_thread_;
webrtc::SequenceChecker pc_thread_checker_;
diff --git a/rtc_base/async_packet_socket.cc b/rtc_base/async_packet_socket.cc
index bc5b3d8..c54bfaa 100644
--- a/rtc_base/async_packet_socket.cc
+++ b/rtc_base/async_packet_socket.cc
@@ -14,6 +14,15 @@
namespace rtc {
+PacketOptions::PacketOptions() = default;
+PacketOptions::PacketOptions(DiffServCodePoint dscp) : dscp(dscp) {}
+PacketOptions::PacketOptions(const PacketOptions& other) = default;
+PacketOptions::~PacketOptions() = default;
+
+} // namespace rtc
+
+namespace webrtc {
+
PacketTimeUpdateParams::PacketTimeUpdateParams() = default;
PacketTimeUpdateParams::PacketTimeUpdateParams(
@@ -21,16 +30,11 @@
PacketTimeUpdateParams::~PacketTimeUpdateParams() = default;
-PacketOptions::PacketOptions() = default;
-PacketOptions::PacketOptions(DiffServCodePoint dscp) : dscp(dscp) {}
-PacketOptions::PacketOptions(const PacketOptions& other) = default;
-PacketOptions::~PacketOptions() = default;
-
AsyncPacketSocket::~AsyncPacketSocket() = default;
void AsyncPacketSocket::SubscribeCloseEvent(
const void* removal_tag,
- std::function<void(AsyncPacketSocket*, int)> callback) {
+ std::function<void(webrtc::AsyncPacketSocket*, int)> callback) {
RTC_DCHECK_RUN_ON(&network_checker_);
on_close_.AddReceiver(removal_tag, std::move(callback));
}
@@ -41,7 +45,8 @@
}
void AsyncPacketSocket::RegisterReceivedPacketCallback(
- absl::AnyInvocable<void(AsyncPacketSocket*, const rtc::ReceivedPacket&)>
+ absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
+ const rtc::ReceivedPacket&)>
received_packet_callback) {
RTC_DCHECK_RUN_ON(&network_checker_);
RTC_CHECK(!received_packet_callback_);
@@ -69,4 +74,4 @@
info->ip_overhead_bytes = socket_from.GetLocalAddress().ipaddr().overhead();
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index 1ff9d73..4eb6cfa 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -31,7 +31,7 @@
#include "rtc_base/thread_annotations.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
// This structure holds the info needed to update the packet send time header
// extension, including the information needed to update the authentication tag
@@ -47,6 +47,10 @@
int64_t srtp_packet_index = -1; // Required for Rtp Packet authentication.
};
+} // namespace webrtc
+
+namespace rtc {
+
// This structure holds meta information for the packet which is about to send
// over network.
struct RTC_EXPORT PacketOptions {
@@ -65,7 +69,7 @@
// When used with RTP packets (for example, webrtc::PacketOptions), the value
// should be 16 bits. A value of -1 represents "not set".
int64_t packet_id = -1;
- PacketTimeUpdateParams packet_time_params;
+ webrtc::PacketTimeUpdateParams packet_time_params;
// PacketInfo is passed to SentPacket when signaling this packet is sent.
PacketInfo info_signaled_after_sent;
// True if this is a batchable packet. Batchable packets are collected at low
@@ -75,6 +79,9 @@
// True if this is the last packet of a batch.
bool last_packet_in_batch = false;
};
+} // namespace rtc
+
+namespace webrtc {
// Provides the ability to receive packets asynchronously. Sends are not
// buffered since it is acceptable to drop packets under high load.
@@ -96,17 +103,19 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns STATE_BINDING).
- virtual webrtc::SocketAddress GetLocalAddress() const = 0;
+ virtual SocketAddress GetLocalAddress() const = 0;
// Returns remote address. Returns zeroes if this is not a client TCP socket.
- virtual webrtc::SocketAddress GetRemoteAddress() const = 0;
+ virtual SocketAddress GetRemoteAddress() const = 0;
// Send a packet.
- virtual int Send(const void* pv, size_t cb, const PacketOptions& options) = 0;
+ virtual int Send(const void* pv,
+ size_t cb,
+ const rtc::PacketOptions& options) = 0;
virtual int SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr,
- const PacketOptions& options) = 0;
+ const SocketAddress& addr,
+ const rtc::PacketOptions& options) = 0;
// Close the socket.
virtual int Close() = 0;
@@ -126,16 +135,17 @@
// Register a callback to be called when the socket is closed.
void SubscribeCloseEvent(
const void* removal_tag,
- std::function<void(AsyncPacketSocket*, int)> callback);
+ std::function<void(webrtc::AsyncPacketSocket*, int)> callback);
void UnsubscribeCloseEvent(const void* removal_tag);
void RegisterReceivedPacketCallback(
- absl::AnyInvocable<void(AsyncPacketSocket*, const rtc::ReceivedPacket&)>
+ absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
+ const rtc::ReceivedPacket&)>
received_packet_callback);
void DeregisterReceivedPacketCallback();
// Emitted each time a packet is sent.
- sigslot::signal2<AsyncPacketSocket*, const SentPacket&> SignalSentPacket;
+ sigslot::signal2<AsyncPacketSocket*, const rtc::SentPacket&> SignalSentPacket;
// Emitted when the socket is currently able to send.
sigslot::signal1<AsyncPacketSocket*> SignalReadyToSend;
@@ -143,8 +153,7 @@
// 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 webrtc::SocketAddress&>
- SignalAddressReady;
+ sigslot::signal2<AsyncPacketSocket*, const SocketAddress&> SignalAddressReady;
// Emitted for client TCP sockets when state is changed from
// CONNECTING to CONNECTED.
@@ -166,13 +175,14 @@
void NotifyPacketReceived(const rtc::ReceivedPacket& packet);
- RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker network_checker_{
- webrtc::SequenceChecker::kDetached};
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker network_checker_{
+ SequenceChecker::kDetached};
private:
- webrtc::CallbackList<AsyncPacketSocket*, int> on_close_
+ CallbackList<AsyncPacketSocket*, int> on_close_
RTC_GUARDED_BY(&network_checker_);
- absl::AnyInvocable<void(AsyncPacketSocket*, const rtc::ReceivedPacket&)>
+ absl::AnyInvocable<void(webrtc::AsyncPacketSocket*,
+ const rtc::ReceivedPacket&)>
received_packet_callback_ RTC_GUARDED_BY(&network_checker_);
};
@@ -189,7 +199,7 @@
// Returns current local address. Address may be set to null if the
// socket is not bound yet (GetState() returns kBinding).
- virtual webrtc::SocketAddress GetLocalAddress() const = 0;
+ virtual SocketAddress GetLocalAddress() const = 0;
sigslot::signal2<AsyncListenSocket*, AsyncPacketSocket*> SignalNewConnection;
};
@@ -198,6 +208,15 @@
const AsyncPacketSocket& socket_from,
rtc::PacketInfo* info);
+} // 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::AsyncListenSocket;
+using ::webrtc::AsyncPacketSocket;
+using ::webrtc::CopySocketInformationToPacketInfo;
+using ::webrtc::PacketTimeUpdateParams;
} // namespace rtc
#endif // RTC_BASE_ASYNC_PACKET_SOCKET_H_
diff --git a/rtc_base/async_packet_socket_unittest.cc b/rtc_base/async_packet_socket_unittest.cc
index f0ce150..16a2bc7 100644
--- a/rtc_base/async_packet_socket_unittest.cc
+++ b/rtc_base/async_packet_socket_unittest.cc
@@ -15,17 +15,17 @@
#include "test/gmock.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
namespace {
using ::testing::MockFunction;
-class MockAsyncPacketSocket : public rtc::AsyncPacketSocket {
+class MockAsyncPacketSocket : public AsyncPacketSocket {
public:
~MockAsyncPacketSocket() = default;
- MOCK_METHOD(webrtc::SocketAddress, GetLocalAddress, (), (const, override));
- MOCK_METHOD(webrtc::SocketAddress, GetRemoteAddress, (), (const, override));
+ MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
+ MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD(int,
Send,
(const void* pv, size_t cb, const rtc::PacketOptions& options),
@@ -35,16 +35,13 @@
SendTo,
(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options),
(override));
MOCK_METHOD(int, Close, (), (override));
MOCK_METHOD(State, GetState, (), (const, override));
- MOCK_METHOD(int,
- GetOption,
- (rtc::Socket::Option opt, int* value),
- (override));
- MOCK_METHOD(int, SetOption, (rtc::Socket::Option opt, int value), (override));
+ MOCK_METHOD(int, GetOption, (Socket::Option opt, int* value), (override));
+ MOCK_METHOD(int, SetOption, (Socket::Option opt, int value), (override));
MOCK_METHOD(int, GetError, (), (const, override));
MOCK_METHOD(void, SetError, (int error), (override));
@@ -53,13 +50,13 @@
TEST(AsyncPacketSocket, RegisteredCallbackReceivePacketsFromNotify) {
MockAsyncPacketSocket mock_socket;
- MockFunction<void(AsyncPacketSocket*, const rtc::ReceivedPacket&)>
+ MockFunction<void(webrtc::AsyncPacketSocket*, const rtc::ReceivedPacket&)>
received_packet;
EXPECT_CALL(received_packet, Call);
mock_socket.RegisterReceivedPacketCallback(received_packet.AsStdFunction());
- mock_socket.NotifyPacketReceived(ReceivedPacket({}, webrtc::SocketAddress()));
+ mock_socket.NotifyPacketReceived(rtc::ReceivedPacket({}, SocketAddress()));
}
} // namespace
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/async_socket.cc b/rtc_base/async_socket.cc
index 9730919..fe6c0ef 100644
--- a/rtc_base/async_socket.cc
+++ b/rtc_base/async_socket.cc
@@ -13,7 +13,7 @@
#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
-namespace rtc {
+namespace webrtc {
AsyncSocketAdapter::AsyncSocketAdapter(Socket* socket)
: socket_(absl::WrapUnique(socket)) {
@@ -25,19 +25,19 @@
socket_->SignalCloseEvent.connect(this, &AsyncSocketAdapter::OnCloseEvent);
}
-webrtc::SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
+SocketAddress AsyncSocketAdapter::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-webrtc::SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
+SocketAddress AsyncSocketAdapter::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
-int AsyncSocketAdapter::Bind(const webrtc::SocketAddress& addr) {
+int AsyncSocketAdapter::Bind(const SocketAddress& addr) {
return socket_->Bind(addr);
}
-int AsyncSocketAdapter::Connect(const webrtc::SocketAddress& addr) {
+int AsyncSocketAdapter::Connect(const SocketAddress& addr) {
return socket_->Connect(addr);
}
@@ -47,7 +47,7 @@
int AsyncSocketAdapter::SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
return socket_->SendTo(pv, cb, addr);
}
@@ -57,7 +57,7 @@
int AsyncSocketAdapter::RecvFrom(void* pv,
size_t cb,
- webrtc::SocketAddress* paddr,
+ SocketAddress* paddr,
int64_t* timestamp) {
return socket_->RecvFrom(pv, cb, paddr, timestamp);
}
@@ -66,7 +66,7 @@
return socket_->Listen(backlog);
}
-Socket* AsyncSocketAdapter::Accept(webrtc::SocketAddress* paddr) {
+Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
return socket_->Accept(paddr);
}
@@ -110,4 +110,4 @@
SignalCloseEvent(this, err);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/async_socket.h b/rtc_base/async_socket.h
index 89f4068..abc471b 100644
--- a/rtc_base/async_socket.h
+++ b/rtc_base/async_socket.h
@@ -20,7 +20,7 @@
#include "rtc_base/socket_address.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
-namespace rtc {
+namespace webrtc {
class AsyncSocketAdapter : public Socket, public sigslot::has_slots<> {
public:
@@ -28,21 +28,19 @@
// TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers.
explicit AsyncSocketAdapter(Socket* socket);
- webrtc::SocketAddress GetLocalAddress() const override;
- webrtc::SocketAddress GetRemoteAddress() const override;
- int Bind(const webrtc::SocketAddress& addr) override;
- int Connect(const webrtc::SocketAddress& addr) override;
+ SocketAddress GetLocalAddress() const override;
+ SocketAddress GetRemoteAddress() const override;
+ int Bind(const SocketAddress& addr) override;
+ int Connect(const SocketAddress& addr) override;
int Send(const void* pv, size_t cb) override;
- int SendTo(const void* pv,
- size_t cb,
- const webrtc::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;
int RecvFrom(void* pv,
size_t cb,
- webrtc::SocketAddress* paddr,
+ SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- Socket* Accept(webrtc::SocketAddress* paddr) override;
+ Socket* Accept(SocketAddress* paddr) override;
int Close() override;
int GetError() const override;
void SetError(int error) override;
@@ -62,6 +60,12 @@
const std::unique_ptr<Socket> socket_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AsyncSocketAdapter;
} // namespace rtc
#endif // RTC_BASE_ASYNC_SOCKET_H_
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index 840a88f..065d0cc 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -29,7 +29,7 @@
#include <errno.h>
#endif // WEBRTC_POSIX
-namespace rtc {
+namespace webrtc {
static const size_t kMaxPacketSize = 64 * 1024;
@@ -46,11 +46,10 @@
static const int kListenBacklog = 5;
// Binds and connects `socket`
-Socket* AsyncTCPSocketBase::ConnectSocket(
- rtc::Socket* socket,
- const webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address) {
- std::unique_ptr<rtc::Socket> owned_socket(socket);
+Socket* AsyncTCPSocketBase::ConnectSocket(Socket* socket,
+ const SocketAddress& bind_address,
+ const SocketAddress& remote_address) {
+ std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr;
@@ -77,11 +76,11 @@
AsyncTCPSocketBase::~AsyncTCPSocketBase() {}
-webrtc::SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
+SocketAddress AsyncTCPSocketBase::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-webrtc::SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
+SocketAddress AsyncTCPSocketBase::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -121,9 +120,9 @@
int AsyncTCPSocketBase::SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options) {
- const webrtc::SocketAddress& remote_address = GetRemoteAddress();
+ const 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,10 +244,9 @@
// 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 webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address) {
+AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket,
+ const SocketAddress& bind_address,
+ const SocketAddress& remote_address) {
return new AsyncTCPSocket(
AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
}
@@ -289,7 +287,7 @@
}
size_t AsyncTCPSocket::ProcessInput(rtc::ArrayView<const uint8_t> data) {
- webrtc::SocketAddress remote_addr(GetRemoteAddress());
+ SocketAddress remote_addr(GetRemoteAddress());
size_t processed_bytes = 0;
while (true) {
@@ -303,7 +301,7 @@
rtc::ReceivedPacket received_packet(
data.subview(processed_bytes + kPacketLenSize, pkt_len), remote_addr,
- webrtc::Timestamp::Micros(rtc::TimeMicros()));
+ Timestamp::Micros(rtc::TimeMicros()));
NotifyPacketReceived(received_packet);
processed_bytes += kPacketLenSize + pkt_len;
}
@@ -330,15 +328,15 @@
}
}
-webrtc::SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
+SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
void AsyncTcpListenSocket::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
- webrtc::SocketAddress address;
- rtc::Socket* new_socket = socket->Accept(&address);
+ SocketAddress address;
+ Socket* new_socket = socket->Accept(&address);
if (!new_socket) {
// TODO(stefan): Do something better like forwarding the error
// to the user.
@@ -356,4 +354,4 @@
SignalNewConnection(this, new AsyncTCPSocket(socket));
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h
index 9be56b6..c081efe 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -22,7 +22,7 @@
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
-namespace rtc {
+namespace webrtc {
// Simulates UDP semantics over TCP. Send and Recv packet sizes
// are preserved, and drops packets silently on Send, rather than
@@ -42,11 +42,11 @@
// Must return the number of bytes processed.
virtual size_t ProcessInput(rtc::ArrayView<const uint8_t> data) = 0;
- webrtc::SocketAddress GetLocalAddress() const override;
- webrtc::SocketAddress GetRemoteAddress() const override;
+ SocketAddress GetLocalAddress() const override;
+ SocketAddress GetRemoteAddress() const override;
int SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr,
+ const 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 webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address);
+ const SocketAddress& bind_address,
+ const 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 webrtc::SocketAddress& bind_address,
- const webrtc::SocketAddress& remote_address);
+ const SocketAddress& bind_address,
+ const SocketAddress& remote_address);
explicit AsyncTCPSocket(Socket* socket);
~AsyncTCPSocket() override {}
@@ -110,9 +110,9 @@
explicit AsyncTcpListenSocket(std::unique_ptr<Socket> socket);
State GetState() const override;
- webrtc::SocketAddress GetLocalAddress() const override;
+ SocketAddress GetLocalAddress() const override;
- virtual void HandleIncomingConnection(rtc::Socket* socket);
+ virtual void HandleIncomingConnection(Socket* socket);
private:
// Called by the underlying socket
@@ -121,6 +121,14 @@
std::unique_ptr<Socket> socket_;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AsyncTcpListenSocket;
+using ::webrtc::AsyncTCPSocket;
+using ::webrtc::AsyncTCPSocketBase;
} // namespace rtc
#endif // RTC_BASE_ASYNC_TCP_SOCKET_H_
diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc
index feca7b9..5002892 100644
--- a/rtc_base/async_udp_socket.cc
+++ b/rtc_base/async_udp_socket.cc
@@ -27,11 +27,10 @@
#include "rtc_base/socket_factory.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
-AsyncUDPSocket* AsyncUDPSocket::Create(
- Socket* socket,
- const webrtc::SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
+ const 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();
@@ -40,9 +39,8 @@
return new AsyncUDPSocket(owned_socket.release());
}
-AsyncUDPSocket* AsyncUDPSocket::Create(
- SocketFactory* factory,
- const webrtc::SocketAddress& bind_address) {
+AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
+ const SocketAddress& bind_address) {
Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
return nullptr;
@@ -56,11 +54,11 @@
socket_->SignalWriteEvent.connect(this, &AsyncUDPSocket::OnWriteEvent);
}
-webrtc::SocketAddress AsyncUDPSocket::GetLocalAddress() const {
+SocketAddress AsyncUDPSocket::GetLocalAddress() const {
return socket_->GetLocalAddress();
}
-webrtc::SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
+SocketAddress AsyncUDPSocket::GetRemoteAddress() const {
return socket_->GetRemoteAddress();
}
@@ -69,7 +67,7 @@
const rtc::PacketOptions& options) {
rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis(),
options.info_signaled_after_sent);
- CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
+ webrtc::CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
int ret = socket_->Send(pv, cb);
SignalSentPacket(this, sent_packet);
return ret;
@@ -77,11 +75,11 @@
int AsyncUDPSocket::SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options) {
rtc::SentPacket sent_packet(options.packet_id, rtc::TimeMillis(),
options.info_signaled_after_sent);
- CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
+ webrtc::CopySocketInformationToPacketInfo(cb, *this, &sent_packet.info);
if (has_set_ect1_options_ != options.ecn_1) {
// It is unclear what is most efficient, setting options on every sent
// packet or when changed. Potentially, can separate send sockets be used?
@@ -131,7 +129,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.
- webrtc::SocketAddress local_addr = socket_->GetLocalAddress();
+ SocketAddress local_addr = socket_->GetLocalAddress();
RTC_LOG(LS_INFO) << "AsyncUDPSocket[" << local_addr.ToSensitiveString()
<< "] receive failed with error " << socket_->GetError();
return;
@@ -143,22 +141,22 @@
if (!receive_buffer.arrival_time) {
// Timestamp from socket is not available.
- receive_buffer.arrival_time = webrtc::Timestamp::Micros(rtc::TimeMicros());
+ receive_buffer.arrival_time = Timestamp::Micros(rtc::TimeMicros());
} else {
if (!socket_time_offset_) {
// Estimate timestamp offset from first packet arrival time.
- socket_time_offset_ = webrtc::Timestamp::Micros(rtc::TimeMicros()) -
- *receive_buffer.arrival_time;
+ socket_time_offset_ =
+ Timestamp::Micros(rtc::TimeMicros()) - *receive_buffer.arrival_time;
}
*receive_buffer.arrival_time += *socket_time_offset_;
}
NotifyPacketReceived(
- ReceivedPacket(receive_buffer.payload, receive_buffer.source_address,
- receive_buffer.arrival_time, receive_buffer.ecn));
+ rtc::ReceivedPacket(receive_buffer.payload, receive_buffer.source_address,
+ receive_buffer.arrival_time, receive_buffer.ecn));
}
void AsyncUDPSocket::OnWriteEvent(Socket* socket) {
SignalReadyToSend(this);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/async_udp_socket.h b/rtc_base/async_udp_socket.h
index 2dd61d3..765ec29 100644
--- a/rtc_base/async_udp_socket.h
+++ b/rtc_base/async_udp_socket.h
@@ -26,7 +26,7 @@
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/thread_annotations.h"
-namespace rtc {
+namespace webrtc {
// Provides the ability to receive packets asynchronously. Sends are not
// buffered since it is acceptable to drop packets under high load.
@@ -36,22 +36,22 @@
// of `socket`. Returns null if bind() fails (`socket` is destroyed
// in that case).
static AsyncUDPSocket* Create(Socket* socket,
- const webrtc::SocketAddress& bind_address);
+ const 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 webrtc::SocketAddress& bind_address);
+ const SocketAddress& bind_address);
explicit AsyncUDPSocket(Socket* socket);
~AsyncUDPSocket() = default;
- webrtc::SocketAddress GetLocalAddress() const override;
- webrtc::SocketAddress GetRemoteAddress() const override;
+ SocketAddress GetLocalAddress() const override;
+ 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 webrtc::SocketAddress& addr,
+ const SocketAddress& addr,
const rtc::PacketOptions& options) override;
int Close() override;
@@ -67,14 +67,20 @@
// Called when the underlying socket is ready to send.
void OnWriteEvent(Socket* socket);
- RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
+ RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_;
std::unique_ptr<Socket> socket_;
bool has_set_ect1_options_ = false;
- rtc::Buffer buffer_ RTC_GUARDED_BY(sequence_checker_);
- std::optional<webrtc::TimeDelta> socket_time_offset_
+ Buffer buffer_ RTC_GUARDED_BY(sequence_checker_);
+ std::optional<TimeDelta> socket_time_offset_
RTC_GUARDED_BY(sequence_checker_);
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AsyncUDPSocket;
} // namespace rtc
#endif // RTC_BASE_ASYNC_UDP_SOCKET_H_
diff --git a/rtc_base/async_udp_socket_unittest.cc b/rtc_base/async_udp_socket_unittest.cc
index 1fd6bc2..b7508be 100644
--- a/rtc_base/async_udp_socket_unittest.cc
+++ b/rtc_base/async_udp_socket_unittest.cc
@@ -20,9 +20,9 @@
#include "rtc_base/virtual_socket_server.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
-static const webrtc::SocketAddress kAddr("22.22.22.22", 0);
+static const SocketAddress kAddr("22.22.22.22", 0);
TEST(AsyncUDPSocketTest, SetSocketOptionIfEctChange) {
VirtualSocketServer socket_server;
@@ -52,4 +52,4 @@
EXPECT_EQ(ect, 0);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/firewall_socket_server.cc b/rtc_base/firewall_socket_server.cc
index 87efc2e..5d147f7 100644
--- a/rtc_base/firewall_socket_server.cc
+++ b/rtc_base/firewall_socket_server.cc
@@ -21,14 +21,14 @@
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
-namespace rtc {
+namespace webrtc {
class FirewallSocket : public AsyncSocketAdapter {
public:
FirewallSocket(FirewallSocketServer* server, Socket* socket, int type)
: AsyncSocketAdapter(socket), server_(server), type_(type) {}
- int Bind(const webrtc::SocketAddress& addr) override {
+ int Bind(const SocketAddress& addr) override {
if (!server_->IsBindableIp(addr.ipaddr())) {
SetError(EINVAL);
return SOCKET_ERROR;
@@ -36,7 +36,7 @@
return AsyncSocketAdapter::Bind(addr);
}
- int Connect(const webrtc::SocketAddress& addr) override {
+ int Connect(const SocketAddress& addr) override {
if (type_ == SOCK_STREAM) {
if (!server_->Check(FP_TCP, GetLocalAddress(), addr)) {
RTC_LOG(LS_VERBOSE) << "FirewallSocket outbound TCP connection from "
@@ -52,9 +52,7 @@
int Send(const void* pv, size_t cb) override {
return SendTo(pv, cb, GetRemoteAddress());
}
- int SendTo(const void* pv,
- size_t cb,
- const webrtc::SocketAddress& addr) override {
+ int SendTo(const void* pv, size_t cb, const 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)) {
@@ -67,12 +65,12 @@
return AsyncSocketAdapter::SendTo(pv, cb, addr);
}
int Recv(void* pv, size_t cb, int64_t* timestamp) override {
- webrtc::SocketAddress addr;
+ SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int RecvFrom(void* pv,
size_t cb,
- webrtc::SocketAddress* paddr,
+ SocketAddress* paddr,
int64_t* timestamp) override {
if (type_ == SOCK_DGRAM) {
while (true) {
@@ -98,8 +96,8 @@
return AsyncSocketAdapter::Listen(backlog);
}
- Socket* Accept(webrtc::SocketAddress* paddr) override {
- webrtc::SocketAddress addr;
+ Socket* Accept(SocketAddress* paddr) override {
+ SocketAddress addr;
while (Socket* sock = AsyncSocketAdapter::Accept(&addr)) {
if (server_->Check(FP_TCP, addr, GetLocalAddress())) {
if (paddr)
@@ -146,8 +144,8 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const webrtc::SocketAddress& addr) {
- webrtc::SocketAddress any;
+ const SocketAddress& addr) {
+ SocketAddress any;
if (d == FD_IN || d == FD_ANY) {
AddRule(allow, p, any, addr);
}
@@ -158,26 +156,26 @@
void FirewallSocketServer::AddRule(bool allow,
FirewallProtocol p,
- const webrtc::SocketAddress& src,
- const webrtc::SocketAddress& dst) {
+ const SocketAddress& src,
+ const SocketAddress& dst) {
Rule r;
r.allow = allow;
r.p = p;
r.src = src;
r.dst = dst;
- webrtc::MutexLock scope(&mutex_);
+ MutexLock scope(&mutex_);
rules_.push_back(r);
}
void FirewallSocketServer::ClearRules() {
- webrtc::MutexLock scope(&mutex_);
+ MutexLock scope(&mutex_);
rules_.clear();
}
bool FirewallSocketServer::Check(FirewallProtocol p,
- const webrtc::SocketAddress& src,
- const webrtc::SocketAddress& dst) {
- webrtc::MutexLock scope(&mutex_);
+ const SocketAddress& src,
+ const SocketAddress& dst) {
+ MutexLock scope(&mutex_);
for (size_t i = 0; i < rules_.size(); ++i) {
const Rule& r = rules_[i];
if ((r.p != p) && (r.p != FP_ANY))
@@ -196,11 +194,11 @@
}
void FirewallSocketServer::SetUnbindableIps(
- const std::vector<webrtc::IPAddress>& unbindable_ips) {
+ const std::vector<IPAddress>& unbindable_ips) {
unbindable_ips_ = unbindable_ips;
}
-bool FirewallSocketServer::IsBindableIp(const webrtc::IPAddress& ip) {
+bool FirewallSocketServer::IsBindableIp(const IPAddress& ip) {
return !absl::c_linear_search(unbindable_ips_, ip);
}
@@ -208,12 +206,11 @@
return WrapSocket(server_->CreateSocket(family, type), type);
}
-void FirewallSocketServer::SetMessageQueue(Thread* queue) {
+void FirewallSocketServer::SetMessageQueue(rtc::Thread* queue) {
server_->SetMessageQueue(queue);
}
-bool FirewallSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
- bool process_io) {
+bool FirewallSocketServer::Wait(TimeDelta max_wait_duration, bool process_io) {
return server_->Wait(max_wait_duration, process_io);
}
@@ -238,12 +235,12 @@
}
void FirewallManager::AddServer(FirewallSocketServer* server) {
- webrtc::MutexLock scope(&mutex_);
+ MutexLock scope(&mutex_);
servers_.push_back(server);
}
void FirewallManager::RemoveServer(FirewallSocketServer* server) {
- webrtc::MutexLock scope(&mutex_);
+ MutexLock scope(&mutex_);
servers_.erase(std::remove(servers_.begin(), servers_.end(), server),
servers_.end());
}
@@ -251,8 +248,8 @@
void FirewallManager::AddRule(bool allow,
FirewallProtocol p,
FirewallDirection d,
- const webrtc::SocketAddress& addr) {
- webrtc::MutexLock scope(&mutex_);
+ const SocketAddress& addr) {
+ MutexLock scope(&mutex_);
for (std::vector<FirewallSocketServer*>::const_iterator it = servers_.begin();
it != servers_.end(); ++it) {
(*it)->AddRule(allow, p, d, addr);
@@ -260,11 +257,11 @@
}
void FirewallManager::ClearRules() {
- webrtc::MutexLock scope(&mutex_);
+ MutexLock scope(&mutex_);
for (std::vector<FirewallSocketServer*>::const_iterator it = servers_.begin();
it != servers_.end(); ++it) {
(*it)->ClearRules();
}
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/firewall_socket_server.h b/rtc_base/firewall_socket_server.h
index 822b27d..b55ecdf 100644
--- a/rtc_base/firewall_socket_server.h
+++ b/rtc_base/firewall_socket_server.h
@@ -19,7 +19,7 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/synchronization/mutex.h"
-namespace rtc {
+namespace webrtc {
class FirewallManager;
@@ -55,16 +55,16 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const webrtc::SocketAddress& addr = webrtc::SocketAddress());
+ const SocketAddress& addr = SocketAddress());
void AddRule(bool allow,
FirewallProtocol p,
- const webrtc::SocketAddress& src,
- const webrtc::SocketAddress& dst);
+ const SocketAddress& src,
+ const SocketAddress& dst);
void ClearRules();
bool Check(FirewallProtocol p,
- const webrtc::SocketAddress& src,
- const webrtc::SocketAddress& dst);
+ const SocketAddress& src,
+ const 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
@@ -73,13 +73,13 @@
// No matter how many addresses are added (including INADDR_ANY), the server
// will still allow creating outgoing TCP connections, since they don't
// require explicitly binding a socket.
- void SetUnbindableIps(const std::vector<webrtc::IPAddress>& unbindable_ips);
- bool IsBindableIp(const webrtc::IPAddress& ip);
+ void SetUnbindableIps(const std::vector<IPAddress>& unbindable_ips);
+ bool IsBindableIp(const IPAddress& ip);
Socket* CreateSocket(int family, int type) override;
- void SetMessageQueue(Thread* queue) override;
- bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
+ void SetMessageQueue(rtc::Thread* queue) override;
+ bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
Socket* WrapSocket(Socket* sock, int type);
@@ -87,16 +87,16 @@
private:
SocketServer* server_;
FirewallManager* manager_;
- webrtc::Mutex mutex_;
+ Mutex mutex_;
struct Rule {
bool allow;
FirewallProtocol p;
FirewallDirection d;
- webrtc::SocketAddress src;
- webrtc::SocketAddress dst;
+ SocketAddress src;
+ SocketAddress dst;
};
std::vector<Rule> rules_;
- std::vector<webrtc::IPAddress> unbindable_ips_;
+ std::vector<IPAddress> unbindable_ips_;
bool should_delete_server_;
bool udp_sockets_enabled_;
bool tcp_sockets_enabled_;
@@ -116,14 +116,29 @@
void AddRule(bool allow,
FirewallProtocol p = FP_ANY,
FirewallDirection d = FD_ANY,
- const webrtc::SocketAddress& addr = webrtc::SocketAddress());
+ const SocketAddress& addr = SocketAddress());
void ClearRules();
private:
- webrtc::Mutex mutex_;
+ Mutex mutex_;
std::vector<FirewallSocketServer*> servers_;
};
+} // 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::FD_ANY;
+using ::webrtc::FD_IN;
+using ::webrtc::FD_OUT;
+using ::webrtc::FirewallDirection;
+using ::webrtc::FirewallManager;
+using ::webrtc::FirewallProtocol;
+using ::webrtc::FirewallSocketServer;
+using ::webrtc::FP_ANY;
+using ::webrtc::FP_TCP;
+using ::webrtc::FP_UDP;
} // namespace rtc
#endif // RTC_BASE_FIREWALL_SOCKET_SERVER_H_
diff --git a/rtc_base/internal/default_socket_server.cc b/rtc_base/internal/default_socket_server.cc
index 5632b98..744bd1a 100644
--- a/rtc_base/internal/default_socket_server.cc
+++ b/rtc_base/internal/default_socket_server.cc
@@ -22,11 +22,12 @@
namespace rtc {
-std::unique_ptr<SocketServer> CreateDefaultSocketServer() {
+std::unique_ptr<webrtc::SocketServer> CreateDefaultSocketServer() {
#if defined(__native_client__)
return std::unique_ptr<SocketServer>(new rtc::NullSocketServer);
#else
- return std::unique_ptr<SocketServer>(new rtc::PhysicalSocketServer);
+ return std::unique_ptr<webrtc::SocketServer>(
+ new webrtc::PhysicalSocketServer);
#endif
}
diff --git a/rtc_base/internal/default_socket_server.h b/rtc_base/internal/default_socket_server.h
index 5b3489f..7045ac6 100644
--- a/rtc_base/internal/default_socket_server.h
+++ b/rtc_base/internal/default_socket_server.h
@@ -17,7 +17,7 @@
namespace rtc {
-std::unique_ptr<SocketServer> CreateDefaultSocketServer();
+std::unique_ptr<webrtc::SocketServer> CreateDefaultSocketServer();
} // namespace rtc
diff --git a/rtc_base/network.cc b/rtc_base/network.cc
index 2675df7..5cc09f7 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -541,7 +541,7 @@
BasicNetworkManager::BasicNetworkManager(
NetworkMonitorFactory* network_monitor_factory,
- SocketFactory* socket_factory,
+ webrtc::SocketFactory* socket_factory,
const webrtc::FieldTrialsView* field_trials_view)
: field_trials_(field_trials_view),
network_monitor_factory_(network_monitor_factory),
@@ -1031,7 +1031,7 @@
int family) const {
RTC_DCHECK(family == AF_INET || family == AF_INET6);
- std::unique_ptr<Socket> socket(
+ std::unique_ptr<webrtc::Socket> socket(
socket_factory_->CreateSocket(family, SOCK_DGRAM));
if (!socket) {
RTC_LOG_ERR(LS_ERROR) << "Socket creation failed";
diff --git a/rtc_base/network.h b/rtc_base/network.h
index 7769259..1584382 100644
--- a/rtc_base/network.h
+++ b/rtc_base/network.h
@@ -487,14 +487,14 @@
public sigslot::has_slots<> {
public:
// This is used by lots of downstream code.
- BasicNetworkManager(SocketFactory* socket_factory,
+ BasicNetworkManager(webrtc::SocketFactory* socket_factory,
const webrtc::FieldTrialsView* field_trials = nullptr)
: BasicNetworkManager(/* network_monitor_factory= */ nullptr,
socket_factory,
field_trials) {}
BasicNetworkManager(NetworkMonitorFactory* network_monitor_factory,
- SocketFactory* socket_factory,
+ webrtc::SocketFactory* socket_factory,
const webrtc::FieldTrialsView* field_trials = nullptr);
~BasicNetworkManager() override;
@@ -580,7 +580,7 @@
field_trials_;
std::vector<std::string> network_ignore_list_;
NetworkMonitorFactory* const network_monitor_factory_;
- SocketFactory* const socket_factory_;
+ webrtc::SocketFactory* const socket_factory_;
std::unique_ptr<NetworkMonitorInterface> network_monitor_
RTC_GUARDED_BY(thread_);
bool allow_mac_based_ipv6_ RTC_GUARDED_BY(thread_) = false;
diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc
index ea1e27c..ebec042 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -58,14 +58,14 @@
using ::testing::UnorderedElementsAre;
using ::testing::UnorderedElementsAreArray;
-namespace rtc {
-
#define MAYBE_SKIP_IPV4 \
- if (!HasIPv4Enabled()) { \
+ if (!::rtc::HasIPv4Enabled()) { \
RTC_LOG(LS_INFO) << "No IPv4... skipping"; \
return; \
}
+namespace rtc {
+
namespace {
webrtc::IPAddress IPFromString(absl::string_view str) {
@@ -339,7 +339,7 @@
class TestBasicNetworkManager : public BasicNetworkManager {
public:
TestBasicNetworkManager(NetworkMonitorFactory* network_monitor_factory,
- SocketFactory* socket_factory,
+ webrtc::SocketFactory* socket_factory,
const webrtc::FieldTrialsView& field_trials)
: BasicNetworkManager(network_monitor_factory,
socket_factory,
@@ -367,7 +367,7 @@
Network ipv4_network2("test_eth1", "Test Network Adapter 2",
webrtc::IPAddress(0x010000U), 24,
ADAPTER_TYPE_ETHERNET);
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager network_manager(&socket_server);
network_manager.StartUpdating();
EXPECT_FALSE(IsIgnoredNetwork(network_manager, ipv4_network1));
@@ -380,7 +380,7 @@
webrtc::IPAddress(0x12345600U), 24);
Network include_me("include_me", "Include me please!",
webrtc::IPAddress(0x12345600U), 24);
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager default_network_manager(&socket_server);
default_network_manager.StartUpdating();
EXPECT_FALSE(IsIgnoredNetwork(default_network_manager, ignore_me));
@@ -397,7 +397,7 @@
// Test is failing on Windows opt: b/11288214
TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
std::vector<std::unique_ptr<Network>> result = GetNetworks(manager, true);
// We should be able to bind to any addresses we find.
@@ -431,7 +431,7 @@
// Test StartUpdating() and StopUpdating(). network_permission_state starts with
// ALLOWED.
TEST_F(NetworkTest, TestUpdateNetworks) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(nullptr, &socket_server, &field_trials_);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -471,7 +471,7 @@
webrtc::IPAddress(0x00010000U), 16);
ipv4_network1.AddIP(webrtc::IPAddress(0x12345678));
ipv4_network2.AddIP(webrtc::IPAddress(0x00010004));
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
// Add ipv4_network1 to the list of networks.
@@ -579,7 +579,7 @@
// Test that the basic network merging case works.
TEST_F(NetworkTest, TestIPv6MergeNetworkList) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -601,7 +601,7 @@
// merged, that the changed callback is not called, and that the original
// objects remain in the result list.
TEST_F(NetworkTest, TestNoChangeMerge) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -632,7 +632,7 @@
// a different IP. The original network should remain in the list, but have its
// IP changed.
TEST_F(NetworkTest, MergeWithChangedIP) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -670,7 +670,7 @@
}
TEST_F(NetworkTest, TestMultipleIPMergeNetworkList) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -726,7 +726,7 @@
// Test that merge correctly distinguishes multiple networks on an interface.
TEST_F(NetworkTest, TestMultiplePublicNetworksOnOneInterfaceMerge) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -770,7 +770,7 @@
// Test that DumpNetworks does not crash.
TEST_F(NetworkTest, TestCreateAndDumpNetworks) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
std::vector<std::unique_ptr<Network>> list = GetNetworks(manager, true);
@@ -780,7 +780,7 @@
}
TEST_F(NetworkTest, TestIPv6Toggle) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
bool ipv6_found = false;
@@ -796,7 +796,7 @@
// Test that when network interfaces are sorted and given preference values,
// IPv6 comes first.
TEST_F(NetworkTest, IPv6NetworksPreferredOverIPv4) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
Network ipv4_network1("test_eth0", "Test Network Adapter 1",
webrtc::IPAddress(0x12345600U), 24);
@@ -827,7 +827,7 @@
// When two interfaces are equivalent in everything but name, they're expected
// to be preference-ordered by name. For example, "eth0" before "eth1".
TEST_F(NetworkTest, NetworksSortedByInterfaceName) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server, &field_trials_);
auto eth0 = std::make_unique<Network>("test_eth0", "Test Network Adapter 1",
webrtc::IPAddress(0x65432100U), 24);
@@ -876,7 +876,7 @@
list.ifa_name = const_cast<char*>("test_iface");
std::vector<std::unique_ptr<Network>> result;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
CallConvertIfAddrs(manager, &list, true, &result);
@@ -893,7 +893,7 @@
list = AddIpv6Address(list, if_name, "1000:2000:3000:4000:0:0:0:2",
"FFFF:FFFF:FFFF:FFFF::", 0);
std::vector<std::unique_ptr<Network>> result;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
CallConvertIfAddrs(manager, list, true, &result);
@@ -915,7 +915,7 @@
list.ifa_netmask = &ifa_netmask;
std::vector<std::unique_ptr<Network>> result;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
CallConvertIfAddrs(manager, &list, true, &result);
@@ -930,7 +930,7 @@
list.ifa_netmask = nullptr;
std::vector<std::unique_ptr<Network>> result;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
CallConvertIfAddrs(manager, &list, true, &result);
@@ -943,7 +943,7 @@
char if_name[20] = "wifi0";
std::string ipv6_address = "1000:2000:3000:4000:0:0:0:1";
std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager_without_monitor(nullptr, &socket_server,
&field_trials_);
manager_without_monitor.StartUpdating();
@@ -975,7 +975,7 @@
std::string ipv6_address1 = "1000:2000:3000:4000:0:0:0:1";
std::string ipv6_address2 = "1000:2000:3000:8000:0:0:0:1";
std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF::";
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
@@ -1053,7 +1053,7 @@
// Sanity check that both interfaces are included by default.
FakeNetworkMonitorFactory factory;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&factory, &socket_server, &field_trials_);
manager.StartUpdating();
CallConvertIfAddrs(manager, list, /*include_ignored=*/false, &result);
@@ -1079,7 +1079,7 @@
// Test MergeNetworkList successfully combines all IPs for the same
// prefix/length into a single Network.
TEST_F(NetworkTest, TestMergeNetworkList) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
std::vector<std::unique_ptr<Network>> list;
@@ -1118,7 +1118,7 @@
// Test that MergeNetworkList successfully detects the change if
// a network becomes inactive and then active again.
TEST_F(NetworkTest, TestMergeNetworkListWithInactiveNetworks) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
Network network1("test_wifi", "Test Network Adapter 1",
webrtc::IPAddress(0x12345600U), 24);
@@ -1275,7 +1275,7 @@
TEST_F(NetworkTest, TestNetworkMonitoring) {
FakeNetworkMonitorFactory factory;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&factory, &socket_server, &field_trials_);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -1309,7 +1309,7 @@
MAYBE_SKIP_IPV4;
webrtc::IPAddress ip;
FakeNetworkMonitorFactory factory;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
TestBasicNetworkManager manager(&factory, &socket_server, field_trials_);
manager.SignalNetworksChanged.connect(static_cast<NetworkTest*>(this),
&NetworkTest::OnNetworksChanged);
@@ -1377,7 +1377,7 @@
// Test that MergeNetworkList does not set change = true
// when changing from cellular_X to cellular_Y.
TEST_F(NetworkTest, TestWhenNetworkListChangeReturnsChangedFlag) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
webrtc::IPAddress ip1;
@@ -1440,7 +1440,7 @@
TEST_F(NetworkTest, IgnoresMACBasedIPv6Address) {
std::string ipv6_address = "2607:fc20:f340:1dc8:214:22ff:fe01:2345";
std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF";
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
@@ -1459,7 +1459,7 @@
"WebRTC-AllowMACBasedIPv6/Enabled/");
std::string ipv6_address = "2607:fc20:f340:1dc8:214:22ff:fe01:2345";
std::string ipv6_mask = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF";
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.StartUpdating();
@@ -1486,7 +1486,7 @@
// Sanity check that both interfaces are included by default.
FakeNetworkMonitorFactory factory;
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&factory, &socket_server, &field_trials_);
manager.StartUpdating();
CallConvertIfAddrs(manager, list, /*include_ignored=*/false, &result);
@@ -1594,7 +1594,7 @@
}
TEST_F(NetworkTest, VpnList) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
{
BasicNetworkManager manager(&socket_server);
manager.set_vpn_list({NetworkMask(IPFromString("192.168.0.0"), 16)});
@@ -1619,7 +1619,7 @@
#if defined(WEBRTC_POSIX)
// TODO(webrtc:13114): Implement the InstallIpv4Network for windows.
TEST_F(NetworkTest, VpnListOverrideAdapterType) {
- PhysicalSocketServer socket_server;
+ webrtc::PhysicalSocketServer socket_server;
BasicNetworkManager manager(&socket_server);
manager.set_vpn_list({NetworkMask(IPFromString("192.168.0.0"), 16)});
manager.StartUpdating();
diff --git a/rtc_base/null_socket_server.cc b/rtc_base/null_socket_server.cc
index e8bdd66..5783c82 100644
--- a/rtc_base/null_socket_server.cc
+++ b/rtc_base/null_socket_server.cc
@@ -15,17 +15,17 @@
#include "rtc_base/event.h"
#include "rtc_base/socket_server.h"
-namespace rtc {
+namespace webrtc {
NullSocketServer::NullSocketServer() = default;
NullSocketServer::~NullSocketServer() {}
-bool NullSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
+bool NullSocketServer::Wait(TimeDelta max_wait_duration,
bool /* process_io */) {
// Wait with the given timeout. Do not log a warning if we end up waiting for
// a long time; that just means no one has any work for us, which is perfectly
// legitimate.
- event_.Wait(max_wait_duration, /*warn_after=*/Event::kForever);
+ event_.Wait(max_wait_duration, /*warn_after=*/rtc::Event::kForever);
return true;
}
@@ -33,9 +33,9 @@
event_.Set();
}
-rtc::Socket* NullSocketServer::CreateSocket(int /* family */, int /* type */) {
+Socket* NullSocketServer::CreateSocket(int /* family */, int /* type */) {
RTC_DCHECK_NOTREACHED();
return nullptr;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/null_socket_server.h b/rtc_base/null_socket_server.h
index 87f49f4..e0e10e7 100644
--- a/rtc_base/null_socket_server.h
+++ b/rtc_base/null_socket_server.h
@@ -16,22 +16,28 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/system/rtc_export.h"
-namespace rtc {
+namespace webrtc {
class RTC_EXPORT NullSocketServer : public SocketServer {
public:
NullSocketServer();
~NullSocketServer() override;
- bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
+ bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
Socket* CreateSocket(int family, int type) override;
private:
- Event event_;
+ rtc::Event event_;
};
+} // 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::NullSocketServer;
} // namespace rtc
#endif // RTC_BASE_NULL_SOCKET_SERVER_H_
diff --git a/rtc_base/null_socket_server_unittest.cc b/rtc_base/null_socket_server_unittest.cc
index d6366be..3754315 100644
--- a/rtc_base/null_socket_server_unittest.cc
+++ b/rtc_base/null_socket_server_unittest.cc
@@ -23,30 +23,29 @@
#include "test/gtest.h"
#include "test/wait_until.h"
-namespace rtc {
+namespace webrtc {
TEST(NullSocketServerTest, WaitAndSet) {
- AutoThread main_thread;
+ rtc::AutoThread main_thread;
NullSocketServer ss;
- auto thread = Thread::Create();
+ auto thread = rtc::Thread::Create();
EXPECT_TRUE(thread->Start());
thread->PostTask([&ss] { ss.WakeUp(); });
// The process_io will be ignored.
const bool process_io = true;
- EXPECT_THAT(
- webrtc::WaitUntil(
- [&] { return ss.Wait(SocketServer::kForever, process_io); },
- ::testing::IsTrue(), {.timeout = webrtc::TimeDelta::Millis(5'000)}),
- webrtc::IsRtcOk());
+ EXPECT_THAT(webrtc::WaitUntil(
+ [&] { return ss.Wait(SocketServer::kForever, process_io); },
+ ::testing::IsTrue(), {.timeout = TimeDelta::Millis(5'000)}),
+ webrtc::IsRtcOk());
}
TEST(NullSocketServerTest, TestWait) {
NullSocketServer ss;
- int64_t start = TimeMillis();
- ss.Wait(webrtc::TimeDelta::Millis(200), true);
+ int64_t start = rtc::TimeMillis();
+ ss.Wait(TimeDelta::Millis(200), true);
// The actual wait time is dependent on the resolution of the timer used by
// the Event class. Allow for the event to signal ~20ms early.
- EXPECT_GE(TimeSince(start), 180);
+ EXPECT_GE(rtc::TimeSince(start), 180);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index 6db7f75..e22d419 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -89,7 +89,7 @@
return methods;
}
-static BIO* BIO_new_socket(rtc::Socket* socket) {
+static BIO* BIO_new_socket(webrtc::Socket* socket) {
BIO* ret = BIO_new(BIO_socket_method());
if (ret == nullptr) {
return nullptr;
@@ -114,7 +114,7 @@
static int socket_read(BIO* b, char* out, int outl) {
if (!out)
return -1;
- rtc::Socket* socket = static_cast<rtc::Socket*>(BIO_get_data(b));
+ webrtc::Socket* socket = static_cast<webrtc::Socket*>(BIO_get_data(b));
BIO_clear_retry_flags(b);
int result = socket->Recv(out, outl, nullptr);
if (result > 0) {
@@ -128,7 +128,7 @@
static int socket_write(BIO* b, const char* in, int inl) {
if (!in)
return -1;
- rtc::Socket* socket = static_cast<rtc::Socket*>(BIO_get_data(b));
+ webrtc::Socket* socket = static_cast<webrtc::Socket*>(BIO_get_data(b));
BIO_clear_retry_flags(b);
int result = socket->Send(in, inl);
if (result > 0) {
@@ -148,9 +148,9 @@
case BIO_CTRL_RESET:
return 0;
case BIO_CTRL_EOF: {
- rtc::Socket* socket = static_cast<rtc::Socket*>(ptr);
+ webrtc::Socket* socket = static_cast<webrtc::Socket*>(ptr);
// 1 means socket closed.
- return (socket->GetState() == rtc::Socket::CS_CLOSED) ? 1 : 0;
+ return (socket->GetState() == webrtc::Socket::CS_CLOSED) ? 1 : 0;
}
case BIO_CTRL_WPENDING:
case BIO_CTRL_PENDING:
@@ -198,7 +198,7 @@
return true;
}
-OpenSSLAdapter::OpenSSLAdapter(Socket* socket,
+OpenSSLAdapter::OpenSSLAdapter(webrtc::Socket* socket,
OpenSSLSessionCache* ssl_session_cache,
SSLCertificateVerifier* ssl_cert_verifier)
: SSLAdapter(socket),
@@ -273,7 +273,7 @@
ssl_host_name_.assign(hostname.data(), hostname.size());
- if (GetSocket()->GetState() != Socket::CS_CONNECTED) {
+ if (GetSocket()->GetState() != webrtc::Socket::CS_CONNECTED) {
state_ = SSL_WAIT;
return 0;
}
@@ -405,7 +405,7 @@
}
state_ = SSL_CONNECTED;
- AsyncSocketAdapter::OnConnectEvent(this);
+ webrtc::AsyncSocketAdapter::OnConnectEvent(this);
// TODO(benwright): Refactor this code path.
// Don't let ourselves go away during the callbacks
// PRefPtr<OpenSSLAdapter> lock(this);
@@ -444,7 +444,7 @@
state_ = SSL_ERROR;
SetError(err);
if (signal) {
- AsyncSocketAdapter::OnCloseEvent(this, err);
+ webrtc::AsyncSocketAdapter::OnCloseEvent(this, err);
}
}
@@ -517,7 +517,7 @@
int OpenSSLAdapter::Send(const void* pv, size_t cb) {
switch (state_) {
case SSL_NONE:
- return AsyncSocketAdapter::Send(pv, cb);
+ return webrtc::AsyncSocketAdapter::Send(pv, cb);
case SSL_WAIT:
case SSL_CONNECTING:
SetError(ENOTCONN);
@@ -581,7 +581,7 @@
int OpenSSLAdapter::SendTo(const void* pv,
size_t cb,
const webrtc::SocketAddress& addr) {
- if (GetSocket()->GetState() == Socket::CS_CONNECTED &&
+ if (GetSocket()->GetState() == webrtc::Socket::CS_CONNECTED &&
addr == GetSocket()->GetRemoteAddress()) {
return Send(pv, cb);
}
@@ -593,7 +593,7 @@
int OpenSSLAdapter::Recv(void* pv, size_t cb, int64_t* timestamp) {
switch (state_) {
case SSL_NONE:
- return AsyncSocketAdapter::Recv(pv, cb, timestamp);
+ return webrtc::AsyncSocketAdapter::Recv(pv, cb, timestamp);
case SSL_WAIT:
case SSL_CONNECTING:
SetError(ENOTCONN);
@@ -643,7 +643,7 @@
size_t cb,
webrtc::SocketAddress* paddr,
int64_t* timestamp) {
- if (GetSocket()->GetState() == Socket::CS_CONNECTED) {
+ if (GetSocket()->GetState() == webrtc::Socket::CS_CONNECTED) {
int ret = Recv(pv, cb, timestamp);
*paddr = GetRemoteAddress();
return ret;
@@ -656,10 +656,10 @@
int OpenSSLAdapter::Close() {
Cleanup();
state_ = SSL_NONE;
- return AsyncSocketAdapter::Close();
+ return webrtc::AsyncSocketAdapter::Close();
}
-Socket::ConnState OpenSSLAdapter::GetState() const {
+webrtc::Socket::ConnState OpenSSLAdapter::GetState() const {
ConnState state = GetSocket()->GetState();
if ((state == CS_CONNECTED) &&
((state_ == SSL_WAIT) || (state_ == SSL_CONNECTING))) {
@@ -678,23 +678,23 @@
ContinueSSL();
}
-void OpenSSLAdapter::OnConnectEvent(Socket* socket) {
+void OpenSSLAdapter::OnConnectEvent(webrtc::Socket* socket) {
RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnConnectEvent";
if (state_ != SSL_WAIT) {
RTC_DCHECK(state_ == SSL_NONE);
- AsyncSocketAdapter::OnConnectEvent(socket);
+ webrtc::AsyncSocketAdapter::OnConnectEvent(socket);
return;
}
state_ = SSL_CONNECTING;
if (int err = BeginSSL()) {
- AsyncSocketAdapter::OnCloseEvent(socket, err);
+ webrtc::AsyncSocketAdapter::OnCloseEvent(socket, err);
}
}
-void OpenSSLAdapter::OnReadEvent(Socket* socket) {
+void OpenSSLAdapter::OnReadEvent(webrtc::Socket* socket) {
if (state_ == SSL_NONE) {
- AsyncSocketAdapter::OnReadEvent(socket);
+ webrtc::AsyncSocketAdapter::OnReadEvent(socket);
return;
}
@@ -712,15 +712,15 @@
// Don't let ourselves go away during the callbacks
// PRefPtr<OpenSSLAdapter> lock(this); // TODO(benwright): fix this
if (ssl_write_needs_read_) {
- AsyncSocketAdapter::OnWriteEvent(socket);
+ webrtc::AsyncSocketAdapter::OnWriteEvent(socket);
}
- AsyncSocketAdapter::OnReadEvent(socket);
+ webrtc::AsyncSocketAdapter::OnReadEvent(socket);
}
-void OpenSSLAdapter::OnWriteEvent(Socket* socket) {
+void OpenSSLAdapter::OnWriteEvent(webrtc::Socket* socket) {
if (state_ == SSL_NONE) {
- AsyncSocketAdapter::OnWriteEvent(socket);
+ webrtc::AsyncSocketAdapter::OnWriteEvent(socket);
return;
}
@@ -739,7 +739,7 @@
// PRefPtr<OpenSSLAdapter> lock(this); // TODO(benwright): fix this
if (ssl_read_needs_write_) {
- AsyncSocketAdapter::OnReadEvent(socket);
+ webrtc::AsyncSocketAdapter::OnReadEvent(socket);
}
// If a previous SSL_write failed due to the underlying socket being blocked,
@@ -752,12 +752,12 @@
}
}
- AsyncSocketAdapter::OnWriteEvent(socket);
+ webrtc::AsyncSocketAdapter::OnWriteEvent(socket);
}
-void OpenSSLAdapter::OnCloseEvent(Socket* socket, int err) {
+void OpenSSLAdapter::OnCloseEvent(webrtc::Socket* socket, int err) {
RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnCloseEvent(" << err << ")";
- AsyncSocketAdapter::OnCloseEvent(socket, err);
+ webrtc::AsyncSocketAdapter::OnCloseEvent(socket, err);
}
bool OpenSSLAdapter::SSLPostConnectionCheck(SSL* ssl, absl::string_view host) {
@@ -1055,7 +1055,7 @@
ignore_bad_cert_ = ignore;
}
-OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(Socket* socket) {
+OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(webrtc::Socket* socket) {
if (ssl_session_cache_ == nullptr) {
SSL_CTX* ssl_ctx = OpenSSLAdapter::CreateContext(ssl_mode_, true);
if (ssl_ctx == nullptr) {
diff --git a/rtc_base/openssl_adapter.h b/rtc_base/openssl_adapter.h
index 28ce6b5..902ab9e 100644
--- a/rtc_base/openssl_adapter.h
+++ b/rtc_base/openssl_adapter.h
@@ -48,7 +48,7 @@
// SSLCertificateVerifier which can override any existing trusted roots to
// validate a peer certificate. The cache and verifier are effectively
// immutable after the the SSL connection starts.
- explicit OpenSSLAdapter(Socket* socket,
+ explicit OpenSSLAdapter(webrtc::Socket* socket,
OpenSSLSessionCache* ssl_session_cache = nullptr,
SSLCertificateVerifier* ssl_cert_verifier = nullptr);
~OpenSSLAdapter() override;
@@ -83,10 +83,10 @@
static SSL_CTX* CreateContext(webrtc::SSLMode mode, bool enable_cache);
protected:
- void OnConnectEvent(Socket* socket) override;
- void OnReadEvent(Socket* socket) override;
- void OnWriteEvent(Socket* socket) override;
- void OnCloseEvent(Socket* socket, int err) override;
+ void OnConnectEvent(webrtc::Socket* socket) override;
+ void OnReadEvent(webrtc::Socket* socket) override;
+ void OnWriteEvent(webrtc::Socket* socket) override;
+ void OnCloseEvent(webrtc::Socket* socket, int err) override;
private:
class EarlyExitCatcher {
@@ -208,7 +208,7 @@
// Constructs a new socket using the shared OpenSSLSessionCache. This means
// existing SSLSessions already in the cache will be reused instead of
// re-created for improved performance.
- OpenSSLAdapter* CreateAdapter(Socket* socket) override;
+ OpenSSLAdapter* CreateAdapter(webrtc::Socket* socket) override;
private:
// Holds the SSLMode (DTLS,TLS) that will be used to set the session cache.
diff --git a/rtc_base/openssl_adapter_unittest.cc b/rtc_base/openssl_adapter_unittest.cc
index 835ee10..8d52875 100644
--- a/rtc_base/openssl_adapter_unittest.cc
+++ b/rtc_base/openssl_adapter_unittest.cc
@@ -27,10 +27,10 @@
namespace rtc {
namespace {
-class MockAsyncSocket : public Socket {
+class MockAsyncSocket : public webrtc::Socket {
public:
virtual ~MockAsyncSocket() = default;
- MOCK_METHOD(Socket*, Accept, (webrtc::SocketAddress*), (override));
+ MOCK_METHOD(webrtc::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));
@@ -90,7 +90,7 @@
// mode.
TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
rtc::AutoThread main_thread;
- Socket* async_socket = new MockAsyncSocket();
+ webrtc::Socket* async_socket = new MockAsyncSocket();
OpenSSLAdapter adapter(async_socket);
EXPECT_EQ(adapter.StartSSL("webrtc.org"), 0);
}
@@ -99,7 +99,7 @@
TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) {
rtc::AutoThread main_thread;
OpenSSLAdapterFactory adapter_factory;
- Socket* async_socket = new MockAsyncSocket();
+ webrtc::Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
@@ -115,7 +115,7 @@
OpenSSLAdapterFactory adapter_factory;
adapter_factory.SetCertVerifier(cert_verifier.get());
- Socket* async_socket = new MockAsyncSocket();
+ webrtc::Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index a6df1a4..81601ef 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -151,7 +151,7 @@
} // namespace
-namespace rtc {
+namespace webrtc {
PhysicalSocket::PhysicalSocket(PhysicalSocketServer* ss, SOCKET s)
: ss_(ss),
@@ -187,12 +187,12 @@
return s_ != INVALID_SOCKET;
}
-webrtc::SocketAddress PhysicalSocket::GetLocalAddress() const {
+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);
- webrtc::SocketAddress address;
+ SocketAddress address;
if (result >= 0) {
webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
@@ -202,12 +202,12 @@
return address;
}
-webrtc::SocketAddress PhysicalSocket::GetRemoteAddress() const {
+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);
- webrtc::SocketAddress address;
+ SocketAddress address;
if (result >= 0) {
webrtc::SocketAddressFromSockAddrStorage(addr_storage, &address);
} else {
@@ -217,21 +217,21 @@
return address;
}
-int PhysicalSocket::Bind(const webrtc::SocketAddress& bind_addr) {
- webrtc::SocketAddress copied_bind_addr = bind_addr;
+int PhysicalSocket::Bind(const SocketAddress& bind_addr) {
+ 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.
if (ss_->network_binder() && !bind_addr.IsAnyIP()) {
- NetworkBindingResult result =
+ rtc::NetworkBindingResult result =
ss_->network_binder()->BindSocketToNetwork(s_, bind_addr.ipaddr());
- if (result == NetworkBindingResult::SUCCESS) {
+ if (result == rtc::NetworkBindingResult::SUCCESS) {
// Since the network binder handled binding the socket to the desired
// network interface, we don't need to (and shouldn't) include an IP in
// the bind() call; bind() just needs to assign a port.
copied_bind_addr.SetIP(
webrtc::GetAnyIP(copied_bind_addr.ipaddr().family()));
- } else if (result == NetworkBindingResult::NOT_IMPLEMENTED) {
+ } else if (result == rtc::NetworkBindingResult::NOT_IMPLEMENTED) {
RTC_LOG(LS_INFO) << "Can't bind socket to network because "
"network binding is not implemented for this OS.";
} else {
@@ -265,7 +265,7 @@
return err;
}
-int PhysicalSocket::Connect(const webrtc::SocketAddress& addr) {
+int PhysicalSocket::Connect(const SocketAddress& addr) {
// TODO(pthatcher): Implicit creation is required to reconnect...
// ...but should we make it more explicit?
if (state_ != CS_CLOSED) {
@@ -274,7 +274,7 @@
}
if (addr.IsUnresolvedIP()) {
RTC_LOG(LS_VERBOSE) << "Resolving addr in PhysicalSocket::Connect";
- resolver_ = std::make_unique<webrtc::AsyncDnsResolver>();
+ resolver_ = std::make_unique<AsyncDnsResolver>();
resolver_->Start(addr, [this] { OnResolveResult(resolver_->result()); });
state_ = CS_CONNECTING;
return 0;
@@ -283,7 +283,7 @@
return DoConnect(addr);
}
-int PhysicalSocket::DoConnect(const webrtc::SocketAddress& connect_addr) {
+int PhysicalSocket::DoConnect(const SocketAddress& connect_addr) {
if ((s_ == INVALID_SOCKET) && !Create(connect_addr.family(), SOCK_STREAM)) {
return SOCKET_ERROR;
}
@@ -295,7 +295,7 @@
uint8_t events = DE_READ | DE_WRITE;
if (err == 0) {
state_ = CS_CONNECTED;
- } else if (IsBlockingError(GetError())) {
+ } else if (webrtc::IsBlockingError(GetError())) {
state_ = CS_CONNECTING;
events |= DE_CONNECT;
} else {
@@ -307,12 +307,12 @@
}
int PhysicalSocket::GetError() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return error_;
}
void PhysicalSocket::SetError(int error) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
error_ = error;
}
@@ -407,7 +407,7 @@
// We have seen minidumps where this may be false.
RTC_DCHECK(sent <= static_cast<int>(cb));
if ((sent > 0 && sent < static_cast<int>(cb)) ||
- (sent < 0 && IsBlockingError(GetError()))) {
+ (sent < 0 && webrtc::IsBlockingError(GetError()))) {
EnableEvents(DE_WRITE);
}
return sent;
@@ -415,7 +415,7 @@
int PhysicalSocket::SendTo(const void* buffer,
size_t length,
- const webrtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
sockaddr_storage saddr;
size_t len = addr.ToSockAddrStorage(&saddr);
int sent =
@@ -432,7 +432,7 @@
// We have seen minidumps where this may be false.
RTC_DCHECK(sent <= static_cast<int>(length));
if ((sent > 0 && sent < static_cast<int>(length)) ||
- (sent < 0 && IsBlockingError(GetError()))) {
+ (sent < 0 && webrtc::IsBlockingError(GetError()))) {
EnableEvents(DE_WRITE);
}
return sent;
@@ -455,7 +455,7 @@
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || IsBlockingError(error);
+ bool success = (received >= 0) || webrtc::IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -467,13 +467,13 @@
int PhysicalSocket::RecvFrom(void* buffer,
size_t length,
- webrtc::SocketAddress* out_addr,
+ SocketAddress* out_addr,
int64_t* timestamp) {
int received = DoReadFromSocket(buffer, length, out_addr, timestamp, nullptr);
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || IsBlockingError(error);
+ bool success = (received >= 0) || webrtc::IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -493,11 +493,11 @@
×tamp, ecn_ ? &buffer.ecn : nullptr);
buffer.payload.SetSize(received > 0 ? received : 0);
if (received > 0 && timestamp != -1) {
- buffer.arrival_time = webrtc::Timestamp::Micros(timestamp);
+ buffer.arrival_time = Timestamp::Micros(timestamp);
}
UpdateLastError();
int error = GetError();
- bool success = (received >= 0) || IsBlockingError(error);
+ bool success = (received >= 0) || webrtc::IsBlockingError(error);
if (udp_ || success) {
EnableEvents(DE_READ);
}
@@ -509,7 +509,7 @@
int PhysicalSocket::DoReadFromSocket(void* buffer,
size_t length,
- webrtc::SocketAddress* out_addr,
+ SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn) {
sockaddr_storage addr_storage;
@@ -595,7 +595,7 @@
return err;
}
-Socket* PhysicalSocket::Accept(webrtc::SocketAddress* out_addr) {
+Socket* PhysicalSocket::Accept(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);
@@ -644,11 +644,10 @@
return ::sendto(socket, buf, len, flags, dest_addr, addrlen);
}
-void PhysicalSocket::OnResolveResult(
- const webrtc::AsyncDnsResolverResult& result) {
+void PhysicalSocket::OnResolveResult(const AsyncDnsResolverResult& result) {
int error = result.GetError();
if (error == 0) {
- webrtc::SocketAddress address;
+ SocketAddress address;
if (result.GetResolvedAddress(AF_INET, &address)) {
error = DoConnect(address);
} else {
@@ -1157,7 +1156,7 @@
}
virtual void Signal() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
if (!fSignaled_) {
const uint8_t b[1] = {0};
const ssize_t res = write(afd_[1], b, sizeof(b));
@@ -1172,7 +1171,7 @@
// It is not possible to perfectly emulate an auto-resetting event with
// pipes. This simulates it by resetting before the event is handled.
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
if (fSignaled_) {
uint8_t b[4]; // Allow for reading more than 1 byte, but expect 1.
const ssize_t res = read(afd_[0], b, sizeof(b));
@@ -1190,7 +1189,7 @@
PhysicalSocketServer* const ss_;
const std::array<int, 2> afd_;
bool fSignaled_ RTC_GUARDED_BY(mutex_);
- webrtc::Mutex mutex_;
+ Mutex mutex_;
bool& flag_to_clear_;
};
@@ -1316,7 +1315,7 @@
}
void PhysicalSocketServer::Add(Dispatcher* pdispatcher) {
- CritScope cs(&crit_);
+ rtc::CritScope cs(&crit_);
if (key_by_dispatcher_.count(pdispatcher)) {
RTC_LOG(LS_WARNING)
<< "PhysicalSocketServer asked to add a duplicate dispatcher.";
@@ -1333,7 +1332,7 @@
}
void PhysicalSocketServer::Remove(Dispatcher* pdispatcher) {
- CritScope cs(&crit_);
+ rtc::CritScope cs(&crit_);
if (!key_by_dispatcher_.count(pdispatcher)) {
RTC_LOG(LS_WARNING)
<< "PhysicalSocketServer asked to remove a unknown "
@@ -1357,7 +1356,7 @@
}
// Don't update dispatchers that haven't yet been added.
- CritScope cs(&crit_);
+ rtc::CritScope cs(&crit_);
if (!key_by_dispatcher_.count(pdispatcher)) {
return;
}
@@ -1366,16 +1365,15 @@
#endif
}
-int PhysicalSocketServer::ToCmsWait(webrtc::TimeDelta max_wait_duration) {
- return max_wait_duration == Event::kForever
+int PhysicalSocketServer::ToCmsWait(TimeDelta max_wait_duration) {
+ return max_wait_duration == rtc::Event::kForever
? kForeverMs
- : max_wait_duration.RoundUpTo(webrtc::TimeDelta::Millis(1)).ms();
+ : max_wait_duration.RoundUpTo(TimeDelta::Millis(1)).ms();
}
#if defined(WEBRTC_POSIX)
-bool PhysicalSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
- bool process_io) {
+bool PhysicalSocketServer::Wait(TimeDelta max_wait_duration, bool process_io) {
// We don't support reentrant waiting.
RTC_DCHECK(!waiting_);
ScopedSetTrue s(&waiting_);
@@ -1537,7 +1535,7 @@
FD_ZERO(&fdsWrite);
int fdmax = -1;
{
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
current_dispatcher_keys_.clear();
for (auto const& kv : dispatcher_by_key_) {
uint64_t key = kv.first;
@@ -1581,7 +1579,7 @@
return true;
} else {
// We have signaled descriptors
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
// Iterate only on the dispatchers whose file descriptors were passed into
// select; this avoids the ABA problem (a socket being destroyed and a new
// one created with the same file descriptor).
@@ -1705,7 +1703,7 @@
int64_t msStop = -1;
if (cmsWait != kForeverMs) {
msWait = cmsWait;
- msStop = TimeAfter(cmsWait);
+ msStop = rtc::TimeAfter(cmsWait);
}
fWait_ = true;
@@ -1730,7 +1728,7 @@
return true;
} else {
// We have signaled descriptors
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
for (int i = 0; i < n; ++i) {
const epoll_event& event = epoll_events_[i];
uint64_t key = event.data.u64;
@@ -1749,7 +1747,7 @@
}
if (cmsWait != kForeverMs) {
- msWait = TimeDiff(msStop, TimeMillis());
+ msWait = rtc::TimeDiff(msStop, rtc::TimeMillis());
if (msWait <= 0) {
// Return success on timeout.
return true;
@@ -1767,7 +1765,7 @@
int64_t msStop = -1;
if (cmsWait != kForeverMs) {
msWait = cmsWait;
- msStop = TimeAfter(cmsWait);
+ msStop = rtc::TimeAfter(cmsWait);
}
fWait_ = true;
@@ -1801,7 +1799,7 @@
}
if (cmsWait != kForeverMs) {
- msWait = TimeDiff(msStop, TimeMillis());
+ msWait = rtc::TimeDiff(msStop, rtc::TimeMillis());
if (msWait < 0) {
// Return success on timeout.
return true;
@@ -1819,7 +1817,7 @@
int64_t msStop = -1;
if (cmsWait != kForeverMs) {
msWait = cmsWait;
- msStop = TimeAfter(cmsWait);
+ msStop = rtc::TimeAfter(cmsWait);
}
std::vector<pollfd> pollfds;
@@ -1827,7 +1825,7 @@
while (fWait_) {
{
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
current_dispatcher_keys_.clear();
pollfds.clear();
pollfds.reserve(dispatcher_by_key_.size());
@@ -1861,7 +1859,7 @@
return true;
} else {
// We have signaled descriptors
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
// Iterate only on the dispatchers whose file descriptors were passed into
// poll; this avoids the ABA problem (a socket being destroyed and a new
// one created with the same file descriptor).
@@ -1874,7 +1872,7 @@
}
if (cmsWait != kForeverMs) {
- msWait = TimeDiff(msStop, TimeMillis());
+ msWait = rtc::TimeDiff(msStop, rtc::TimeMillis());
if (msWait < 0) {
// Return success on timeout.
return true;
@@ -1899,7 +1897,7 @@
int cmsWait = ToCmsWait(max_wait_duration);
int64_t cmsTotal = cmsWait;
int64_t cmsElapsed = 0;
- int64_t msStart = Time();
+ int64_t msStart = rtc::Time();
fWait_ = true;
while (fWait_) {
@@ -1909,7 +1907,7 @@
events.push_back(socket_ev_);
{
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
// Get a snapshot of all current dispatchers; this is used to avoid the
// ABA problem (see later comment) and avoids the dispatcher_by_key_
// iterator being invalidated by calling CheckSignalClose, which may
@@ -1965,7 +1963,7 @@
return true;
} else {
// Figure out which one it is and call it
- CritScope cr(&crit_);
+ rtc::CritScope cr(&crit_);
int index = dw - WSA_WAIT_EVENT_0;
if (index > 0) {
--index; // The first event is the socket event
@@ -2058,7 +2056,7 @@
// Break?
if (!fWait_)
break;
- cmsElapsed = TimeSince(msStart);
+ cmsElapsed = rtc::TimeSince(msStart);
if ((cmsWait != kForeverMs) && (cmsElapsed >= cmsWait)) {
break;
}
@@ -2069,4 +2067,4 @@
}
#endif // WEBRTC_WIN
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/physical_socket_server.h b/rtc_base/physical_socket_server.h
index 39dbe38..2a1d10c 100644
--- a/rtc_base/physical_socket_server.h
+++ b/rtc_base/physical_socket_server.h
@@ -51,7 +51,9 @@
typedef int SOCKET;
#endif // WEBRTC_POSIX
-namespace rtc {
+namespace webrtc {
+
+class Signaler;
// Event constants for the Dispatcher class.
enum DispatcherEvent {
@@ -62,8 +64,6 @@
DE_ACCEPT = 0x0010,
};
-class Signaler;
-
class Dispatcher {
public:
virtual ~Dispatcher() {}
@@ -92,7 +92,7 @@
virtual Socket* WrapSocket(SOCKET s);
// SocketServer:
- bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
+ bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
void Add(Dispatcher* dispatcher);
@@ -105,7 +105,7 @@
// A local historical definition of "foreverness", in milliseconds.
static constexpr int kForeverMs = -1;
- static int ToCmsWait(webrtc::TimeDelta max_wait_duration);
+ static int ToCmsWait(TimeDelta max_wait_duration);
#if defined(WEBRTC_POSIX)
bool WaitSelect(int cmsWait, bool process_io);
@@ -147,7 +147,7 @@
// Kept as a member variable just for efficiency.
std::vector<uint64_t> current_dispatcher_keys_;
Signaler* signal_wakeup_; // Assigned in constructor only
- RecursiveCriticalSection crit_;
+ rtc::RecursiveCriticalSection crit_;
#if defined(WEBRTC_WIN)
const WSAEVENT socket_ev_;
#endif
@@ -165,11 +165,11 @@
// Creates the underlying OS socket (same as the "socket" function).
virtual bool Create(int family, int type);
- webrtc::SocketAddress GetLocalAddress() const override;
- webrtc::SocketAddress GetRemoteAddress() const override;
+ SocketAddress GetLocalAddress() const override;
+ SocketAddress GetRemoteAddress() const override;
- int Bind(const webrtc::SocketAddress& bind_addr) override;
- int Connect(const webrtc::SocketAddress& addr) override;
+ int Bind(const SocketAddress& bind_addr) override;
+ int Connect(const 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 webrtc::SocketAddress& addr) override;
+ const 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,
- webrtc::SocketAddress* out_addr,
+ SocketAddress* out_addr,
int64_t* timestamp) override;
int RecvFrom(ReceiveBuffer& buffer) override;
int Listen(int backlog) override;
- Socket* Accept(webrtc::SocketAddress* out_addr) override;
+ Socket* Accept(SocketAddress* out_addr) override;
int Close() override;
@@ -202,7 +202,7 @@
SOCKET GetSocketFD() const { return s_; }
protected:
- int DoConnect(const webrtc::SocketAddress& connect_addr);
+ int DoConnect(const SocketAddress& connect_addr);
// Make virtual so ::accept can be overwritten in tests.
virtual SOCKET DoAccept(SOCKET socket, sockaddr* addr, socklen_t* addrlen);
@@ -220,11 +220,11 @@
int DoReadFromSocket(void* buffer,
size_t length,
- webrtc::SocketAddress* out_addr,
+ SocketAddress* out_addr,
int64_t* timestamp,
EcnMarking* ecn);
- void OnResolveResult(const webrtc::AsyncDnsResolverResult& resolver);
+ void OnResolveResult(const AsyncDnsResolverResult& resolver);
void UpdateLastError();
void MaybeRemapSendError();
@@ -240,10 +240,10 @@
SOCKET s_;
bool udp_;
int family_ = 0;
- mutable webrtc::Mutex mutex_;
+ mutable Mutex mutex_;
int error_ RTC_GUARDED_BY(mutex_);
ConnState state_;
- std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver_;
+ std::unique_ptr<AsyncDnsResolverInterface> resolver_;
uint8_t dscp_ = 0; // 6bit.
uint8_t ecn_ = 0; // 2bits.
@@ -304,6 +304,21 @@
#endif
};
+} // 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::DE_ACCEPT;
+using ::webrtc::DE_CLOSE;
+using ::webrtc::DE_CONNECT;
+using ::webrtc::DE_READ;
+using ::webrtc::DE_WRITE;
+using ::webrtc::Dispatcher;
+using ::webrtc::DispatcherEvent;
+using ::webrtc::PhysicalSocket;
+using ::webrtc::PhysicalSocketServer;
+using ::webrtc::SocketDispatcher;
} // namespace rtc
#endif // RTC_BASE_PHYSICAL_SOCKET_SERVER_H_
diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc
index 3d9dc05..75a69bb 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -29,20 +29,20 @@
#include "test/gtest.h"
#include "test/wait_until.h"
-namespace rtc {
-
#define MAYBE_SKIP_IPV4 \
- if (!HasIPv4Enabled()) { \
+ if (!::rtc::HasIPv4Enabled()) { \
RTC_LOG(LS_INFO) << "No IPv4... skipping"; \
return; \
}
#define MAYBE_SKIP_IPV6 \
- if (!HasIPv6Enabled()) { \
+ if (!::rtc::HasIPv6Enabled()) { \
RTC_LOG(LS_INFO) << "No IPv6... skipping"; \
return; \
}
+namespace webrtc {
+
class PhysicalSocketTest;
class FakeSocketDispatcher : public SocketDispatcher {
@@ -92,20 +92,20 @@
PhysicalSocketTest* test_;
};
-class FakeNetworkBinder : public NetworkBinderInterface {
+class FakeNetworkBinder : public rtc::NetworkBinderInterface {
public:
- NetworkBindingResult BindSocketToNetwork(int,
- const webrtc::IPAddress&) override {
+ rtc::NetworkBindingResult BindSocketToNetwork(int,
+ const IPAddress&) override {
++num_binds_;
return result_;
}
- void set_result(NetworkBindingResult result) { result_ = result; }
+ void set_result(rtc::NetworkBindingResult result) { result_ = result; }
int num_binds() { return num_binds_; }
private:
- NetworkBindingResult result_ = NetworkBindingResult::SUCCESS;
+ rtc::NetworkBindingResult result_ = rtc::NetworkBindingResult::SUCCESS;
int num_binds_ = 0;
};
@@ -127,8 +127,8 @@
fail_accept_(false),
max_send_size_(-1) {}
- void ConnectInternalAcceptError(const webrtc::IPAddress& loopback);
- void WritableAfterPartialWrite(const webrtc::IPAddress& loopback);
+ void ConnectInternalAcceptError(const IPAddress& loopback);
+ void WritableAfterPartialWrite(const IPAddress& loopback);
FakePhysicalSocketServer server_;
rtc::AutoSocketServerThread thread_;
@@ -200,29 +200,28 @@
SocketTest::TestConnectFailIPv4();
}
-void PhysicalSocketTest::ConnectInternalAcceptError(
- const webrtc::IPAddress& loopback) {
- webrtc::testing::StreamSink sink;
- webrtc::SocketAddress accept_addr;
+void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
+ testing::StreamSink sink;
+ SocketAddress accept_addr;
// Create two clients.
std::unique_ptr<Socket> client1(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client1.get());
EXPECT_EQ(Socket::CS_CLOSED, client1->GetState());
- EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
+ EXPECT_TRUE(webrtc::IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
std::unique_ptr<Socket> client2(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client2.get());
EXPECT_EQ(Socket::CS_CLOSED, client2->GetState());
- EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
+ EXPECT_TRUE(webrtc::IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
// Create server and listen.
std::unique_ptr<Socket> server(
server_.CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -291,8 +290,7 @@
ConnectInternalAcceptError(kIPv6Loopback);
}
-void PhysicalSocketTest::WritableAfterPartialWrite(
- const webrtc::IPAddress& loopback) {
+void PhysicalSocketTest::WritableAfterPartialWrite(const IPAddress& loopback) {
// Simulate a really small maximum send size.
const int kMaxSendSize = 128;
SetMaxSendSize(kMaxSendSize);
@@ -503,8 +501,8 @@
FakeNetworkBinder fake_network_binder;
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(webrtc::SocketAddress("192.168.0.1", 0)));
+ fake_network_binder.set_result(rtc::NetworkBindingResult::FAILURE);
+ EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
server_.set_network_binder(nullptr);
}
@@ -514,7 +512,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(webrtc::SocketAddress("0.0.0.0", 0)));
+ EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds());
server_.set_network_binder(nullptr);
}
@@ -527,8 +525,8 @@
FakeNetworkBinder fake_network_binder;
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(webrtc::SocketAddress(kIPv4Loopback, 0)));
+ fake_network_binder.set_result(rtc::NetworkBindingResult::FAILURE);
+ EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
server_.set_network_binder(nullptr);
}
@@ -543,4 +541,4 @@
SocketTest::TestUdpSocketRecvTimestampUseRtcEpochIPv6();
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index 9f282b3..2bcfe6f 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -21,9 +21,9 @@
namespace rtc {
// ProxyServer
-ProxyServer::ProxyServer(SocketFactory* int_factory,
+ProxyServer::ProxyServer(webrtc::SocketFactory* int_factory,
const webrtc::SocketAddress& int_addr,
- SocketFactory* ext_factory,
+ webrtc::SocketFactory* ext_factory,
const webrtc::SocketAddress& ext_ip)
: ext_factory_(ext_factory),
ext_ip_(ext_ip.ipaddr(), 0), // strip off port
@@ -42,12 +42,12 @@
return server_socket_->GetLocalAddress();
}
-void ProxyServer::OnAcceptEvent(Socket* socket) {
+void ProxyServer::OnAcceptEvent(webrtc::Socket* socket) {
RTC_DCHECK(socket);
RTC_DCHECK_EQ(socket, server_socket_.get());
- Socket* int_socket = socket->Accept(nullptr);
- AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
- Socket* ext_socket =
+ webrtc::Socket* int_socket = socket->Accept(nullptr);
+ webrtc::AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
+ webrtc::Socket* ext_socket =
ext_factory_->CreateSocket(ext_ip_.family(), SOCK_STREAM);
if (ext_socket) {
ext_socket->Bind(ext_ip_);
@@ -60,8 +60,8 @@
}
// ProxyBinding
-ProxyBinding::ProxyBinding(AsyncProxyServerSocket* int_socket,
- Socket* ext_socket)
+ProxyBinding::ProxyBinding(webrtc::AsyncProxyServerSocket* int_socket,
+ webrtc::Socket* ext_socket)
: int_socket_(int_socket),
ext_socket_(ext_socket),
connected_(false),
@@ -81,7 +81,7 @@
ProxyBinding::~ProxyBinding() = default;
-void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
+void ProxyBinding::OnConnectRequest(webrtc::AsyncProxyServerSocket* socket,
const webrtc::SocketAddress& addr) {
RTC_DCHECK(!connected_);
RTC_DCHECK(ext_socket_);
@@ -89,42 +89,42 @@
// TODO: handle errors here
}
-void ProxyBinding::OnInternalRead(Socket* socket) {
+void ProxyBinding::OnInternalRead(webrtc::Socket* socket) {
Read(int_socket_.get(), &out_buffer_);
Write(ext_socket_.get(), &out_buffer_);
}
-void ProxyBinding::OnInternalWrite(Socket* socket) {
+void ProxyBinding::OnInternalWrite(webrtc::Socket* socket) {
Write(int_socket_.get(), &in_buffer_);
}
-void ProxyBinding::OnInternalClose(Socket* socket, int err) {
+void ProxyBinding::OnInternalClose(webrtc::Socket* socket, int err) {
Destroy();
}
-void ProxyBinding::OnExternalConnect(Socket* socket) {
+void ProxyBinding::OnExternalConnect(webrtc::Socket* socket) {
RTC_DCHECK(socket != nullptr);
connected_ = true;
int_socket_->SendConnectResult(0, socket->GetRemoteAddress());
}
-void ProxyBinding::OnExternalRead(Socket* socket) {
+void ProxyBinding::OnExternalRead(webrtc::Socket* socket) {
Read(ext_socket_.get(), &in_buffer_);
Write(int_socket_.get(), &in_buffer_);
}
-void ProxyBinding::OnExternalWrite(Socket* socket) {
+void ProxyBinding::OnExternalWrite(webrtc::Socket* socket) {
Write(ext_socket_.get(), &out_buffer_);
}
-void ProxyBinding::OnExternalClose(Socket* socket, int err) {
+void ProxyBinding::OnExternalClose(webrtc::Socket* socket, int err) {
if (!connected_) {
int_socket_->SendConnectResult(err, webrtc::SocketAddress());
}
Destroy();
}
-void ProxyBinding::Read(Socket* socket, FifoBuffer* buffer) {
+void ProxyBinding::Read(webrtc::Socket* socket, FifoBuffer* buffer) {
// Only read if the buffer is empty.
RTC_DCHECK(socket != nullptr);
size_t size;
@@ -136,7 +136,7 @@
}
}
-void ProxyBinding::Write(Socket* socket, FifoBuffer* buffer) {
+void ProxyBinding::Write(webrtc::Socket* socket, FifoBuffer* buffer) {
RTC_DCHECK(socket != nullptr);
size_t size;
int written;
diff --git a/rtc_base/proxy_server.h b/rtc_base/proxy_server.h
index 50afd96..fe75c5f 100644
--- a/rtc_base/proxy_server.h
+++ b/rtc_base/proxy_server.h
@@ -19,11 +19,10 @@
#include "rtc_base/server_socket_adapters.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
+#include "rtc_base/socket_factory.h"
namespace rtc {
-class SocketFactory;
-
// ProxyServer is a base class that allows for easy construction of proxy
// servers. With its helper class ProxyBinding, it contains all the necessary
// logic for receiving and bridging connections. The specific client-server
@@ -33,7 +32,8 @@
class ProxyBinding : public sigslot::has_slots<> {
public:
- ProxyBinding(AsyncProxyServerSocket* in_socket, Socket* out_socket);
+ ProxyBinding(webrtc::AsyncProxyServerSocket* in_socket,
+ webrtc::Socket* out_socket);
~ProxyBinding() override;
ProxyBinding(const ProxyBinding&) = delete;
@@ -42,23 +42,23 @@
sigslot::signal1<ProxyBinding*> SignalDestroyed;
private:
- void OnConnectRequest(AsyncProxyServerSocket* socket,
+ void OnConnectRequest(webrtc::AsyncProxyServerSocket* socket,
const webrtc::SocketAddress& addr);
- void OnInternalRead(Socket* socket);
- void OnInternalWrite(Socket* socket);
- void OnInternalClose(Socket* socket, int err);
- void OnExternalConnect(Socket* socket);
- void OnExternalRead(Socket* socket);
- void OnExternalWrite(Socket* socket);
- void OnExternalClose(Socket* socket, int err);
+ void OnInternalRead(webrtc::Socket* socket);
+ void OnInternalWrite(webrtc::Socket* socket);
+ void OnInternalClose(webrtc::Socket* socket, int err);
+ void OnExternalConnect(webrtc::Socket* socket);
+ void OnExternalRead(webrtc::Socket* socket);
+ void OnExternalWrite(webrtc::Socket* socket);
+ void OnExternalClose(webrtc::Socket* socket, int err);
- static void Read(Socket* socket, FifoBuffer* buffer);
- static void Write(Socket* socket, FifoBuffer* buffer);
+ static void Read(webrtc::Socket* socket, FifoBuffer* buffer);
+ static void Write(webrtc::Socket* socket, FifoBuffer* buffer);
void Destroy();
static const int kBufferSize = 4096;
- std::unique_ptr<AsyncProxyServerSocket> int_socket_;
- std::unique_ptr<Socket> ext_socket_;
+ std::unique_ptr<webrtc::AsyncProxyServerSocket> int_socket_;
+ std::unique_ptr<webrtc::Socket> ext_socket_;
bool connected_;
FifoBuffer out_buffer_;
FifoBuffer in_buffer_;
@@ -66,9 +66,9 @@
class ProxyServer : public sigslot::has_slots<> {
public:
- ProxyServer(SocketFactory* int_factory,
+ ProxyServer(webrtc::SocketFactory* int_factory,
const webrtc::SocketAddress& int_addr,
- SocketFactory* ext_factory,
+ webrtc::SocketFactory* ext_factory,
const webrtc::SocketAddress& ext_ip);
~ProxyServer() override;
@@ -79,13 +79,14 @@
webrtc::SocketAddress GetServerAddress();
protected:
- void OnAcceptEvent(Socket* socket);
- virtual AsyncProxyServerSocket* WrapSocket(Socket* socket) = 0;
+ void OnAcceptEvent(webrtc::Socket* socket);
+ virtual webrtc::AsyncProxyServerSocket* WrapSocket(
+ webrtc::Socket* socket) = 0;
private:
- SocketFactory* ext_factory_;
+ webrtc::SocketFactory* ext_factory_;
webrtc::SocketAddress ext_ip_;
- std::unique_ptr<Socket> server_socket_;
+ std::unique_ptr<webrtc::Socket> server_socket_;
std::vector<std::unique_ptr<ProxyBinding>> bindings_;
};
diff --git a/rtc_base/server_socket_adapters.cc b/rtc_base/server_socket_adapters.cc
index 5a4db26..9660186 100644
--- a/rtc_base/server_socket_adapters.cc
+++ b/rtc_base/server_socket_adapters.cc
@@ -14,7 +14,7 @@
#include "rtc_base/byte_buffer.h"
-namespace rtc {
+namespace webrtc {
AsyncProxyServerSocket::AsyncProxyServerSocket(Socket* socket,
size_t buffer_size)
@@ -29,7 +29,7 @@
void AsyncSSLServerSocket::ProcessInput(char* data, size_t* len) {
// We only accept client hello messages.
- const ArrayView<const uint8_t> client_hello =
+ const rtc::ArrayView<const uint8_t> client_hello =
AsyncSSLSocket::SslClientHello();
if (*len < client_hello.size()) {
return;
@@ -46,7 +46,7 @@
// Clients should not send more data until the handshake is completed.
RTC_DCHECK(*len == 0);
- const ArrayView<const uint8_t> server_hello =
+ const rtc::ArrayView<const uint8_t> server_hello =
AsyncSSLSocket::SslServerHello();
// Send a server hello back to the client.
DirectSend(server_hello.data(), server_hello.size());
@@ -55,4 +55,4 @@
BufferInput(false);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/server_socket_adapters.h b/rtc_base/server_socket_adapters.h
index 0480d41..068e7fe 100644
--- a/rtc_base/server_socket_adapters.h
+++ b/rtc_base/server_socket_adapters.h
@@ -13,17 +13,16 @@
#include "rtc_base/socket_adapters.h"
-namespace rtc {
+namespace webrtc {
// Interface for implementing proxy server sockets.
class AsyncProxyServerSocket : public BufferedReadAdapter {
public:
AsyncProxyServerSocket(Socket* socket, size_t buffer_size);
~AsyncProxyServerSocket() override;
- sigslot::signal2<AsyncProxyServerSocket*, const webrtc::SocketAddress&>
+ sigslot::signal2<AsyncProxyServerSocket*, const SocketAddress&>
SignalConnectRequest;
- virtual void SendConnectResult(int err,
- const webrtc::SocketAddress& addr) = 0;
+ virtual void SendConnectResult(int err, const SocketAddress& addr) = 0;
};
// Implements a socket adapter that performs the server side of a
@@ -39,6 +38,13 @@
void ProcessInput(char* data, size_t* len) override;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AsyncProxyServerSocket;
+using ::webrtc::AsyncSSLServerSocket;
} // namespace rtc
#endif // RTC_BASE_SERVER_SOCKET_ADAPTERS_H_
diff --git a/rtc_base/socket.cc b/rtc_base/socket.cc
index 0908c29..26a5081 100644
--- a/rtc_base/socket.cc
+++ b/rtc_base/socket.cc
@@ -14,7 +14,7 @@
#include "rtc_base/buffer.h"
-namespace rtc {
+namespace webrtc {
int Socket::RecvFrom(ReceiveBuffer& buffer) {
static constexpr int BUF_SIZE = 64 * 1024;
@@ -24,10 +24,10 @@
&buffer.source_address, ×tamp);
buffer.payload.SetSize(len > 0 ? len : 0);
if (len > 0 && timestamp != -1) {
- buffer.arrival_time = webrtc::Timestamp::Micros(timestamp);
+ buffer.arrival_time = Timestamp::Micros(timestamp);
}
return len;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket.h b/rtc_base/socket.h
index acffcd3..baf42c7 100644
--- a/rtc_base/socket.h
+++ b/rtc_base/socket.h
@@ -75,7 +75,7 @@
#define closesocket(s) close(s)
#endif // WEBRTC_POSIX
-namespace rtc {
+namespace webrtc {
inline bool IsBlockingError(int e) {
return (e == EWOULDBLOCK) || (e == EAGAIN) || (e == EINPROGRESS);
@@ -88,8 +88,8 @@
struct ReceiveBuffer {
ReceiveBuffer(Buffer& payload) : payload(payload) {}
- std::optional<webrtc::Timestamp> arrival_time;
- webrtc::SocketAddress source_address;
+ std::optional<Timestamp> arrival_time;
+ SocketAddress source_address;
EcnMarking ecn = EcnMarking::kNotEct;
Buffer& payload;
};
@@ -100,24 +100,22 @@
// Returns the address to which the socket is bound. If the socket is not
// bound, then the any-address is returned.
- virtual webrtc::SocketAddress GetLocalAddress() const = 0;
+ virtual 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 webrtc::SocketAddress GetRemoteAddress() const = 0;
+ virtual SocketAddress GetRemoteAddress() const = 0;
- virtual int Bind(const webrtc::SocketAddress& addr) = 0;
- virtual int Connect(const webrtc::SocketAddress& addr) = 0;
+ virtual int Bind(const SocketAddress& addr) = 0;
+ virtual int Connect(const SocketAddress& addr) = 0;
virtual int Send(const void* pv, size_t cb) = 0;
- virtual int SendTo(const void* pv,
- size_t cb,
- const webrtc::SocketAddress& addr) = 0;
+ virtual int SendTo(const void* pv, size_t cb, const 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 */,
- webrtc::SocketAddress* /* paddr */,
+ SocketAddress* /* paddr */,
int64_t* /* timestamp */) {
// Not implemented. Use RecvFrom(ReceiveBuffer& buffer).
RTC_CHECK_NOTREACHED();
@@ -127,7 +125,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(webrtc::SocketAddress* paddr) = 0;
+ virtual Socket* Accept(SocketAddress* paddr) = 0;
virtual int Close() = 0;
virtual int GetError() const = 0;
virtual void SetError(int error) = 0;
@@ -172,6 +170,13 @@
Socket() {}
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::IsBlockingError;
+using ::webrtc::Socket;
} // namespace rtc
#endif // RTC_BASE_SOCKET_H_
diff --git a/rtc_base/socket_adapters.cc b/rtc_base/socket_adapters.cc
index df9558a..b75bbad 100644
--- a/rtc_base/socket_adapters.cc
+++ b/rtc_base/socket_adapters.cc
@@ -25,7 +25,7 @@
#include "rtc_base/strings/string_builder.h"
#include "rtc_base/zero_memory.h"
-namespace rtc {
+namespace webrtc {
BufferedReadAdapter::BufferedReadAdapter(Socket* socket, size_t size)
: AsyncSocketAdapter(socket),
@@ -137,7 +137,7 @@
};
// static
-ArrayView<const uint8_t> AsyncSSLSocket::SslClientHello() {
+rtc::ArrayView<const uint8_t> AsyncSSLSocket::SslClientHello() {
// Implicit conversion directly from kSslClientHello to ArrayView fails when
// built with gcc.
return {kSslClientHello, sizeof(kSslClientHello)};
@@ -165,14 +165,14 @@
};
// static
-ArrayView<const uint8_t> AsyncSSLSocket::SslServerHello() {
+rtc::ArrayView<const uint8_t> AsyncSSLSocket::SslServerHello() {
return {kSslServerHello, sizeof(kSslServerHello)};
}
AsyncSSLSocket::AsyncSSLSocket(Socket* socket)
: BufferedReadAdapter(socket, 1024) {}
-int AsyncSSLSocket::Connect(const webrtc::SocketAddress& addr) {
+int AsyncSSLSocket::Connect(const 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);
@@ -215,4 +215,4 @@
SignalReadEvent(this);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_adapters.h b/rtc_base/socket_adapters.h
index 8535faf..acc8c28 100644
--- a/rtc_base/socket_adapters.h
+++ b/rtc_base/socket_adapters.h
@@ -16,12 +16,13 @@
#include "absl/strings/string_view.h"
#include "api/array_view.h"
#include "rtc_base/async_socket.h"
-
namespace rtc {
-
struct HttpAuthContext;
class ByteBufferReader;
class ByteBufferWriter;
+} // namespace rtc
+
+namespace webrtc {
///////////////////////////////////////////////////////////////////////////////
@@ -61,21 +62,28 @@
// fake SSL handshake. Used for "ssltcp" P2P functionality.
class AsyncSSLSocket : public BufferedReadAdapter {
public:
- static ArrayView<const uint8_t> SslClientHello();
- static ArrayView<const uint8_t> SslServerHello();
+ static rtc::ArrayView<const uint8_t> SslClientHello();
+ static rtc::ArrayView<const uint8_t> SslServerHello();
explicit AsyncSSLSocket(Socket* socket);
AsyncSSLSocket(const AsyncSSLSocket&) = delete;
AsyncSSLSocket& operator=(const AsyncSSLSocket&) = delete;
- int Connect(const webrtc::SocketAddress& addr) override;
+ int Connect(const SocketAddress& addr) override;
protected:
void OnConnectEvent(Socket* socket) override;
void ProcessInput(char* data, size_t* len) override;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::AsyncSSLSocket;
+using ::webrtc::BufferedReadAdapter;
} // namespace rtc
#endif // RTC_BASE_SOCKET_ADAPTERS_H_
diff --git a/rtc_base/socket_factory.h b/rtc_base/socket_factory.h
index 882b44f..db81238 100644
--- a/rtc_base/socket_factory.h
+++ b/rtc_base/socket_factory.h
@@ -13,7 +13,7 @@
#include "rtc_base/socket.h"
-namespace rtc {
+namespace webrtc {
class SocketFactory {
public:
@@ -23,6 +23,12 @@
virtual Socket* CreateSocket(int family, int type) = 0;
};
+} // namespace webrtc
+
+// Re-export symbols from the webrtc namespace for backwards compatibility.
+// TODO(bugs.webrtc.org/4222596): Remove once all references are updated.
+namespace rtc {
+using ::webrtc::SocketFactory;
} // namespace rtc
#endif // RTC_BASE_SOCKET_FACTORY_H_
diff --git a/rtc_base/socket_server.h b/rtc_base/socket_server.h
index 61b4f4d..a40a77b 100644
--- a/rtc_base/socket_server.h
+++ b/rtc_base/socket_server.h
@@ -16,14 +16,16 @@
#include "api/units/time_delta.h"
#include "rtc_base/event.h"
#include "rtc_base/socket_factory.h"
-
namespace rtc {
-
class Thread;
+class NetworkBinderInterface;
+} // namespace rtc
+
+namespace webrtc {
+
// Needs to be forward declared because there's a circular dependency between
// NetworkMonitor and Thread.
// TODO(deadbeef): Fix this.
-class NetworkBinderInterface;
// Provides the ability to wait for activity on a set of sockets. The Thread
// class provides a nice wrapper on a socket server.
@@ -32,36 +34,44 @@
// notified of asynchronous I/O from this server's Wait method.
class SocketServer : public SocketFactory {
public:
- static constexpr webrtc::TimeDelta kForever = rtc::Event::kForever;
+ static constexpr TimeDelta kForever = rtc::Event::kForever;
static std::unique_ptr<SocketServer> CreateDefault();
// When the socket server is installed into a Thread, this function is called
// to allow the socket server to use the thread's message queue for any
// messaging that it might need to perform. It is also called with a null
// argument before the thread is destroyed.
- virtual void SetMessageQueue(Thread* /* queue */) {}
+ virtual void SetMessageQueue(rtc::Thread* /* queue */) {}
// Sleeps until:
// 1) `max_wait_duration` has elapsed (unless `max_wait_duration` ==
// `kForever`)
// 2) WakeUp() is called
// While sleeping, I/O is performed if process_io is true.
- virtual bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) = 0;
+ virtual bool Wait(TimeDelta max_wait_duration, bool process_io) = 0;
// Causes the current wait (if one is in progress) to wake up.
virtual void WakeUp() = 0;
// A network binder will bind the created sockets to a network.
// It is only used in PhysicalSocketServer.
- void set_network_binder(NetworkBinderInterface* binder) {
+ void set_network_binder(rtc::NetworkBinderInterface* binder) {
network_binder_ = binder;
}
- NetworkBinderInterface* network_binder() const { return network_binder_; }
+ rtc::NetworkBinderInterface* network_binder() const {
+ return network_binder_;
+ }
private:
- NetworkBinderInterface* network_binder_ = nullptr;
+ rtc::NetworkBinderInterface* network_binder_ = nullptr;
};
+} // 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::SocketServer;
} // namespace rtc
#endif // RTC_BASE_SOCKET_SERVER_H_
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 0067e55..d54d2ac 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -45,7 +45,13 @@
#include "test/gtest.h"
#include "test/wait_until.h"
-namespace rtc {
+#define MAYBE_SKIP_IPV6 \
+ if (!::rtc::HasIPv6Enabled()) { \
+ RTC_LOG(LS_INFO) << "No IPv6... skipping"; \
+ return; \
+ }
+
+namespace webrtc {
using webrtc::testing::SSE_CLOSE;
using webrtc::testing::SSE_ERROR;
@@ -54,12 +60,6 @@
using webrtc::testing::SSE_WRITE;
using webrtc::testing::StreamSink;
-#define MAYBE_SKIP_IPV6 \
- if (!HasIPv6Enabled()) { \
- RTC_LOG(LS_INFO) << "No IPv6... skipping"; \
- return; \
- }
-
// Data size to be used in TcpInternal tests.
static const size_t kTcpInternalDataSize = 1024 * 1024; // bytes
@@ -252,7 +252,7 @@
// For unbound sockets, GetLocalAddress / GetRemoteAddress return AF_UNSPEC
// values on Windows, but an empty address of the same family on Linux/MacOS X.
-bool IsUnspecOrEmptyIP(const webrtc::IPAddress& address) {
+bool IsUnspecOrEmptyIP(const IPAddress& address) {
#if !defined(WEBRTC_WIN)
return webrtc::IPIsAny(address);
#else
@@ -260,9 +260,9 @@
#endif
}
-void SocketTest::ConnectInternal(const webrtc::IPAddress& loopback) {
+void SocketTest::ConnectInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ 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(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(Socket::CS_CONNECTING, server->GetState());
@@ -319,10 +319,10 @@
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
-void SocketTest::ConnectWithDnsLookupInternal(const webrtc::IPAddress& loopback,
+void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
absl::string_view host) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ 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(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
- webrtc::SocketAddress dns_addr(server->GetLocalAddress());
+ SocketAddress dns_addr(server->GetLocalAddress());
dns_addr.SetIP(host);
EXPECT_EQ(0, client->Connect(dns_addr));
// TODO: Bind when doing DNS lookup.
@@ -373,9 +373,9 @@
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
-void SocketTest::ConnectFailInternal(const webrtc::IPAddress& loopback) {
+void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ 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(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(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!
- webrtc::SocketAddress bogus_addr(loopback, 65535);
+ SocketAddress bogus_addr(loopback, 65535);
EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED).
@@ -405,13 +405,12 @@
// Should be no pending server connections.
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_addr));
- EXPECT_EQ(webrtc::IPAddress(), accept_addr.ipaddr());
+ EXPECT_EQ(IPAddress(), accept_addr.ipaddr());
}
-void SocketTest::ConnectWithDnsLookupFailInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -422,12 +421,12 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(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!
- webrtc::SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
+ SocketAddress bogus_dns_addr("not-a-real-hostname", 65535);
EXPECT_EQ(0, client->Connect(bogus_dns_addr));
// Wait for connection to fail (EHOSTNOTFOUND).
@@ -451,12 +450,11 @@
EXPECT_TRUE(accept_addr.IsNil());
}
-void SocketTest::ConnectWithClosedSocketInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
// Create server and listen.
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state.
@@ -466,32 +464,29 @@
EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
// Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
- EXPECT_EQ(0,
- client->Connect(webrtc::SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
}
-void SocketTest::ConnectWhileNotClosedInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Create server and listen.
StreamSink sink;
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(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(webrtc::SocketAddress(server->GetLocalAddress())));
+ EXPECT_EQ(0, client->Connect(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(webrtc::SocketAddress(server->GetLocalAddress())));
+ client->Connect(SocketAddress(server->GetLocalAddress())));
// Accept the original connection.
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
EXPECT_THAT(
webrtc::WaitUntil([&] { return (sink.Check(server.get(), SSE_READ)); },
::testing::IsTrue()),
@@ -512,7 +507,7 @@
// Try to connect again, to an unresolved hostname.
// Shouldn't break anything.
- EXPECT_EQ(SOCKET_ERROR, client->Connect(webrtc::SocketAddress(
+ EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(
"localhost", server->GetLocalAddress().port())));
EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
@@ -520,8 +515,7 @@
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
}
-void SocketTest::ServerCloseDuringConnectInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
StreamSink sink;
// Create client.
@@ -533,7 +527,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -554,10 +548,9 @@
client->Close();
}
-void SocketTest::ClientCloseDuringConnectInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -568,7 +561,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connect to listening socket.
@@ -598,9 +591,9 @@
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
-void SocketTest::ServerCloseInternal(const webrtc::IPAddress& loopback) {
+void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -611,7 +604,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -664,7 +657,7 @@
EXPECT_TRUE(accepted->GetRemoteAddress().IsNil());
// And the closee should only get a single signal.
- Thread::Current()->ProcessMessages(0);
+ rtc::Thread::Current()->ProcessMessages(0);
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Close down the client and ensure all is good.
@@ -681,11 +674,10 @@
}
};
-void SocketTest::CloseInClosedCallbackInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
StreamSink sink;
SocketCloser closer;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -697,7 +689,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -753,18 +745,17 @@
// Tested deleting a socket within another socket's read callback. A previous
// iteration of the select loop failed in this situation, if both sockets
// became readable at the same time.
-void SocketTest::DeleteInReadCallbackInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
std::unique_ptr<Socket> socket1(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
std::unique_ptr<Socket> socket2(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket1->Bind(webrtc::SocketAddress(loopback, 0)));
- EXPECT_EQ(0, socket2->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, socket2->Bind(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.
- Thread::SleepMs(1000);
+ rtc::Thread::SleepMs(1000);
// Configure the helper class to delete socket 2 when socket 1 has a read
// event.
@@ -775,9 +766,9 @@
webrtc::IsRtcOk());
}
-void SocketTest::SocketServerWaitInternal(const webrtc::IPAddress& loopback) {
+void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create & connect server and client sockets.
std::unique_ptr<Socket> client(
@@ -786,7 +777,7 @@
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
@@ -818,9 +809,9 @@
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// Shouldn't signal when blocked in a thread Send, where process_io is false.
- std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
+ std::unique_ptr<rtc::Thread> thread(rtc::Thread::CreateWithSocketServer());
thread->Start();
- thread->BlockingCall([] { Thread::SleepMs(500); });
+ thread->BlockingCall([] { rtc::Thread::SleepMs(500); });
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
// But should signal when process_io is true.
@@ -831,11 +822,11 @@
EXPECT_LT(0, accepted->Recv(buf, 1024, nullptr));
}
-void SocketTest::TcpInternal(const webrtc::IPAddress& loopback,
+void SocketTest::TcpInternal(const IPAddress& loopback,
size_t data_size,
ptrdiff_t max_send_size) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create receiving client.
std::unique_ptr<Socket> receiver(
@@ -846,7 +837,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -870,13 +861,13 @@
EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
// Create test data.
- rtc::Buffer send_buffer(0, data_size);
- rtc::Buffer recv_buffer(0, data_size);
+ Buffer send_buffer(0, data_size);
+ Buffer recv_buffer(0, data_size);
for (size_t i = 0; i < data_size; ++i) {
char ch = static_cast<char>(i % 256);
send_buffer.AppendData(&ch, sizeof(ch));
}
- rtc::Buffer recved_data(0, data_size);
+ Buffer recved_data(0, data_size);
// Send and receive a bunch of data.
size_t sent_size = 0;
@@ -972,10 +963,9 @@
receiver->Close();
}
-void SocketTest::SingleFlowControlCallbackInternal(
- const webrtc::IPAddress& loopback) {
+void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
StreamSink sink;
- webrtc::SocketAddress accept_addr;
+ SocketAddress accept_addr;
// Create client.
std::unique_ptr<Socket> client(
@@ -986,7 +976,7 @@
std::unique_ptr<Socket> server(
socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
- EXPECT_EQ(0, server->Bind(webrtc::SocketAddress(loopback, 0)));
+ EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5));
// Attempt connection.
@@ -1056,14 +1046,13 @@
client->Close();
}
-void SocketTest::UdpInternal(const webrtc::IPAddress& loopback) {
- webrtc::SocketAddress empty =
- webrtc::EmptySocketAddressWithFamily(loopback.family());
+void SocketTest::UdpInternal(const IPAddress& loopback) {
+ 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(webrtc::SocketAddress(loopback, 0)));
- webrtc::SocketAddress addr1 = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
+ SocketAddress addr1 = socket->GetLocalAddress();
EXPECT_EQ(0, socket->Connect(addr1));
EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
socket->Close();
@@ -1071,30 +1060,30 @@
delete socket;
// Test send/receive behavior.
- auto client1 = std::make_unique<webrtc::TestClient>(
+ auto client1 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, addr1)));
- auto client2 = std::make_unique<webrtc::TestClient>(
+ auto client2 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- webrtc::SocketAddress addr2;
+ SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr2));
- webrtc::SocketAddress addr3;
+ SocketAddress addr3;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr2));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr3));
EXPECT_EQ(addr3, addr1);
// TODO: figure out what the intent is here
for (int i = 0; i < 10; ++i) {
- client2 = std::make_unique<webrtc::TestClient>(
+ client2 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- webrtc::SocketAddress addr4;
+ SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &addr4));
EXPECT_EQ(addr4.ipaddr(), addr2.ipaddr());
- webrtc::SocketAddress addr5;
+ SocketAddress addr5;
EXPECT_EQ(6, client1->SendTo("bizbaz", 6, addr4));
EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &addr5));
EXPECT_EQ(addr5, addr1);
@@ -1103,18 +1092,17 @@
}
}
-void SocketTest::UdpReadyToSend(const webrtc::IPAddress& loopback) {
- webrtc::SocketAddress empty =
- webrtc::EmptySocketAddressWithFamily(loopback.family());
+void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
+ 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";
- webrtc::SocketAddress test_addr(dest, 2345);
+ SocketAddress test_addr(dest, 2345);
// Test send
- auto client = std::make_unique<webrtc::TestClient>(
+ auto client = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
int test_packet_size = 1200;
std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
@@ -1126,13 +1114,13 @@
#if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
send_buffer_size /= 2;
#endif
- client->SetOption(rtc::Socket::OPT_SNDBUF, send_buffer_size);
+ client->SetOption(Socket::OPT_SNDBUF, send_buffer_size);
int error = 0;
- uint32_t start_ms = Time();
+ uint32_t start_ms = rtc::Time();
int sent_packet_num = 0;
int expected_error = EWOULDBLOCK;
- while (start_ms + 5000 > Time()) {
+ while (start_ms + 5000 > rtc::Time()) {
int ret = client->SendTo(test_packet.get(), test_packet_size, test_addr);
++sent_packet_num;
if (ret != test_packet_size) {
@@ -1152,10 +1140,10 @@
RTC_LOG(LS_INFO) << "Got SignalReadyToSend";
}
-void SocketTest::GetSetOptionsInternal(const webrtc::IPAddress& loopback) {
+void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- socket->Bind(webrtc::SocketAddress(loopback, 0));
+ socket->Bind(SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF.
const int desired_size = 12345;
@@ -1208,7 +1196,7 @@
// Prepare on TCP specific options.
socket.reset(socket_factory_->CreateSocket(loopback.family(), SOCK_STREAM));
- socket->Bind(webrtc::SocketAddress(loopback, 0));
+ socket->Bind(SocketAddress(loopback, 0));
// Check that we can set NODELAY on a TCP socket.
ASSERT_NE(-1, socket->SetOption(Socket::OPT_NODELAY, desired_nd));
@@ -1245,15 +1233,15 @@
#endif
}
-void SocketTest::SocketRecvTimestamp(const webrtc::IPAddress& loopback) {
+void SocketTest::SocketRecvTimestamp(const IPAddress& loopback) {
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
- webrtc::SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
+ SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
- int64_t send_time_1 = TimeMicros();
+ int64_t send_time_1 = rtc::TimeMicros();
socket->SendTo("foo", 3, address);
// Wait until data is available.
@@ -1261,14 +1249,14 @@
webrtc::WaitUntil([&] { return sink.Check(socket.get(), SSE_READ); },
::testing::IsTrue()),
webrtc::IsRtcOk());
- rtc::Buffer buffer;
+ Buffer buffer;
Socket::ReceiveBuffer receive_buffer_1(buffer);
ASSERT_GT(socket->RecvFrom(receive_buffer_1), 0);
const int64_t kTimeBetweenPacketsMs = 100;
- Thread::SleepMs(kTimeBetweenPacketsMs);
+ rtc::Thread::SleepMs(kTimeBetweenPacketsMs);
- int64_t send_time_2 = TimeMicros();
+ int64_t send_time_2 = rtc::TimeMicros();
socket->SendTo("bar", 3, address);
// Wait until data is available.
EXPECT_THAT(
@@ -1286,45 +1274,41 @@
EXPECT_NEAR(system_time_diff, recv_timestamp_diff, 10000);
}
-void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(
- const webrtc::IPAddress& loopback) {
- webrtc::SocketAddress empty =
- webrtc::EmptySocketAddressWithFamily(loopback.family());
+void SocketTest::UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback) {
+ SocketAddress empty = webrtc::EmptySocketAddressWithFamily(loopback.family());
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- ASSERT_EQ(socket->Bind(webrtc::SocketAddress(loopback, 0)), 0);
- webrtc::SocketAddress address = socket->GetLocalAddress();
+ ASSERT_EQ(socket->Bind(SocketAddress(loopback, 0)), 0);
+ SocketAddress address = socket->GetLocalAddress();
socket = nullptr;
- auto client1 = std::make_unique<webrtc::TestClient>(
+ auto client1 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, address)));
- auto client2 = std::make_unique<webrtc::TestClient>(
+ auto client2 = std::make_unique<TestClient>(
absl::WrapUnique(AsyncUDPSocket::Create(socket_factory_, empty)));
- webrtc::SocketAddress addr2;
+ SocketAddress addr2;
client2->SendTo("foo", 3, address);
- std::unique_ptr<webrtc::TestClient::Packet> packet_1 =
- client1->NextPacket(10000);
+ std::unique_ptr<TestClient::Packet> packet_1 = client1->NextPacket(10000);
ASSERT_TRUE(packet_1 != nullptr);
EXPECT_NEAR(packet_1->packet_time->us(), rtc::TimeMicros(), 1000'000);
- Thread::SleepMs(100);
+ rtc::Thread::SleepMs(100);
client2->SendTo("bar", 3, address);
- std::unique_ptr<webrtc::TestClient::Packet> packet_2 =
- client1->NextPacket(10000);
+ std::unique_ptr<TestClient::Packet> packet_2 = client1->NextPacket(10000);
ASSERT_TRUE(packet_2 != nullptr);
EXPECT_GT(packet_2->packet_time->us(), packet_1->packet_time->us());
EXPECT_NEAR(packet_2->packet_time->us(), rtc::TimeMicros(), 1000'000);
}
-void SocketTest::SocketSendRecvWithEcn(const webrtc::IPAddress& loopback) {
+void SocketTest::SocketSendRecvWithEcn(const IPAddress& loopback) {
StreamSink sink;
std::unique_ptr<Socket> socket(
socket_factory_->CreateSocket(loopback.family(), SOCK_DGRAM));
- EXPECT_EQ(0, socket->Bind(webrtc::SocketAddress(loopback, 0)));
- webrtc::SocketAddress address = socket->GetLocalAddress();
+ EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
+ SocketAddress address = socket->GetLocalAddress();
sink.Monitor(socket.get());
- rtc::Buffer buffer;
+ Buffer buffer;
Socket::ReceiveBuffer receive_buffer(buffer);
socket->SendTo("foo", 3, address);
@@ -1365,4 +1349,4 @@
EXPECT_EQ(receive_buffer.ecn, EcnMarking::kCe);
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/socket_unittest.h b/rtc_base/socket_unittest.h
index 0e89186..5c4f10a 100644
--- a/rtc_base/socket_unittest.h
+++ b/rtc_base/socket_unittest.h
@@ -18,7 +18,7 @@
#include "rtc_base/socket_factory.h"
#include "test/gtest.h"
-namespace rtc {
+namespace webrtc {
// Generic socket tests, to be used when testing individual socket servers.
// Derive your specific test class from SocketTest, install your
@@ -70,44 +70,51 @@
void TestSocketSendRecvWithEcnIPV4();
void TestSocketSendRecvWithEcnIPV6();
- const webrtc::IPAddress kIPv4Loopback;
- const webrtc::IPAddress kIPv6Loopback;
+ const IPAddress kIPv4Loopback;
+ const IPAddress kIPv6Loopback;
protected:
- void TcpInternal(const webrtc::IPAddress& loopback,
+ void TcpInternal(const IPAddress& loopback,
size_t data_size,
ptrdiff_t max_send_size);
private:
- void ConnectInternal(const webrtc::IPAddress& loopback);
- void ConnectWithDnsLookupInternal(const webrtc::IPAddress& loopback,
+ void ConnectInternal(const IPAddress& loopback);
+ void ConnectWithDnsLookupInternal(const IPAddress& loopback,
absl::string_view host);
- void ConnectFailInternal(const webrtc::IPAddress& loopback);
+ void ConnectFailInternal(const IPAddress& loopback);
- void ConnectWithDnsLookupFailInternal(const webrtc::IPAddress& loopback);
- void ConnectWithClosedSocketInternal(const webrtc::IPAddress& loopback);
- void ConnectWhileNotClosedInternal(const webrtc::IPAddress& loopback);
- void ServerCloseDuringConnectInternal(const webrtc::IPAddress& loopback);
- void ClientCloseDuringConnectInternal(const webrtc::IPAddress& loopback);
- void ServerCloseInternal(const webrtc::IPAddress& loopback);
- void CloseInClosedCallbackInternal(const webrtc::IPAddress& loopback);
- void DeleteInReadCallbackInternal(const webrtc::IPAddress& loopback);
- void SocketServerWaitInternal(const webrtc::IPAddress& loopback);
- void SingleFlowControlCallbackInternal(const webrtc::IPAddress& loopback);
- void UdpInternal(const webrtc::IPAddress& loopback);
- void UdpReadyToSend(const webrtc::IPAddress& loopback);
- void GetSetOptionsInternal(const webrtc::IPAddress& loopback);
- void SocketRecvTimestamp(const webrtc::IPAddress& loopback);
- void UdpSocketRecvTimestampUseRtcEpoch(const webrtc::IPAddress& loopback);
- void SocketSendRecvWithEcn(const webrtc::IPAddress& loopback);
+ void ConnectWithDnsLookupFailInternal(const IPAddress& loopback);
+ void ConnectWithClosedSocketInternal(const IPAddress& loopback);
+ void ConnectWhileNotClosedInternal(const IPAddress& loopback);
+ void ServerCloseDuringConnectInternal(const IPAddress& loopback);
+ void ClientCloseDuringConnectInternal(const IPAddress& loopback);
+ void ServerCloseInternal(const IPAddress& loopback);
+ void CloseInClosedCallbackInternal(const IPAddress& loopback);
+ void DeleteInReadCallbackInternal(const IPAddress& loopback);
+ void SocketServerWaitInternal(const IPAddress& loopback);
+ void SingleFlowControlCallbackInternal(const IPAddress& loopback);
+ void UdpInternal(const IPAddress& loopback);
+ void UdpReadyToSend(const IPAddress& loopback);
+ void GetSetOptionsInternal(const IPAddress& loopback);
+ void SocketRecvTimestamp(const IPAddress& loopback);
+ void UdpSocketRecvTimestampUseRtcEpoch(const IPAddress& loopback);
+ void SocketSendRecvWithEcn(const IPAddress& loopback);
- SocketFactory* socket_factory_;
+ rtc::SocketFactory* socket_factory_;
};
// For unbound sockets, GetLocalAddress / GetRemoteAddress return AF_UNSPEC
// values on Windows, but an empty address of the same family on Linux/MacOS X.
-bool IsUnspecOrEmptyIP(const webrtc::IPAddress& address);
+bool IsUnspecOrEmptyIP(const IPAddress& address);
+} // 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::IsUnspecOrEmptyIP;
+using ::webrtc::SocketTest;
} // namespace rtc
#endif // RTC_BASE_SOCKET_UNITTEST_H_
diff --git a/rtc_base/ssl_adapter.cc b/rtc_base/ssl_adapter.cc
index 126c83d..6365f16 100644
--- a/rtc_base/ssl_adapter.cc
+++ b/rtc_base/ssl_adapter.cc
@@ -23,7 +23,7 @@
return std::make_unique<OpenSSLAdapterFactory>();
}
-SSLAdapter* SSLAdapter::Create(Socket* socket) {
+SSLAdapter* SSLAdapter::Create(webrtc::Socket* socket) {
return new OpenSSLAdapter(socket);
}
diff --git a/rtc_base/ssl_adapter.h b/rtc_base/ssl_adapter.h
index c366081..b25ed45 100644
--- a/rtc_base/ssl_adapter.h
+++ b/rtc_base/ssl_adapter.h
@@ -52,7 +52,7 @@
virtual void SetIgnoreBadCert(bool ignore) = 0;
// Creates a new SSL adapter, but from a shared context.
- virtual SSLAdapter* CreateAdapter(Socket* socket) = 0;
+ virtual SSLAdapter* CreateAdapter(webrtc::Socket* socket) = 0;
static std::unique_ptr<SSLAdapterFactory> Create();
};
@@ -62,9 +62,10 @@
// in which case it will share state with other SSLAdapters created from the
// same factory.
// After creation, call StartSSL to initiate the SSL handshake to the server.
-class SSLAdapter : public AsyncSocketAdapter {
+class SSLAdapter : public webrtc::AsyncSocketAdapter {
public:
- explicit SSLAdapter(Socket* socket) : AsyncSocketAdapter(socket) {}
+ explicit SSLAdapter(webrtc::Socket* socket)
+ : webrtc::AsyncSocketAdapter(socket) {}
// Methods that control server certificate verification, used in unit tests.
// Do not call these methods in production code.
@@ -102,12 +103,14 @@
// Create the default SSL adapter for this platform. On failure, returns null
// and deletes `socket`. Otherwise, the returned SSLAdapter takes ownership
// of `socket`.
- static SSLAdapter* Create(Socket* socket);
+ static SSLAdapter* Create(webrtc::Socket* socket);
private:
// Not supported.
int Listen(int backlog) override { RTC_CHECK(false); }
- Socket* Accept(webrtc::SocketAddress* paddr) override { RTC_CHECK(false); }
+ webrtc::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 6a8d0e6..b8c24bf 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -38,10 +38,10 @@
static const webrtc::TimeDelta kTimeout = webrtc::TimeDelta::Millis(5000);
-static rtc::Socket* CreateSocket() {
+static webrtc::Socket* CreateSocket() {
webrtc::SocketAddress address(webrtc::IPAddress(INADDR_ANY), 0);
- rtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket(
+ webrtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket(
address.family(), SOCK_STREAM);
socket->Bind(address);
@@ -62,7 +62,7 @@
explicit SSLAdapterTestDummy() : socket_(CreateSocket()) {}
virtual ~SSLAdapterTestDummy() = default;
- void CreateSSLAdapter(rtc::Socket* socket, webrtc::SSLRole role) {
+ void CreateSSLAdapter(webrtc::Socket* socket, webrtc::SSLRole role) {
ssl_adapter_.reset(rtc::SSLAdapter::Create(socket));
// Ignore any certificate errors for the purpose of testing.
@@ -97,7 +97,9 @@
return ssl_adapter_->GetLocalAddress();
}
- rtc::Socket::ConnState GetState() const { return ssl_adapter_->GetState(); }
+ webrtc::Socket::ConnState GetState() const {
+ return ssl_adapter_->GetState();
+ }
const std::string& GetReceivedData() const { return data_; }
@@ -109,7 +111,7 @@
return ssl_adapter_->Send(message.data(), message.length());
}
- void OnSSLAdapterReadEvent(rtc::Socket* socket) {
+ void OnSSLAdapterReadEvent(webrtc::Socket* socket) {
char buffer[4096] = "";
// Read data received from the server and store it in our internal buffer.
@@ -123,18 +125,18 @@
}
}
- void OnSSLAdapterCloseEvent(rtc::Socket* socket, int error) {
+ void OnSSLAdapterCloseEvent(webrtc::Socket* socket, int error) {
// OpenSSLAdapter signals handshake failure with a close event, but without
// closing the socket! Let's close the socket here. This way GetState() can
// return CS_CLOSED after failure.
- if (socket->GetState() != rtc::Socket::CS_CLOSED) {
+ if (socket->GetState() != webrtc::Socket::CS_CLOSED) {
socket->Close();
}
}
protected:
std::unique_ptr<rtc::SSLAdapter> ssl_adapter_;
- std::unique_ptr<rtc::Socket> socket_;
+ std::unique_ptr<webrtc::Socket> socket_;
private:
std::string data_;
@@ -187,7 +189,7 @@
}
protected:
- void OnReadEvent(rtc::Socket* socket) {
+ void OnReadEvent(webrtc::Socket* socket) {
CreateSSLAdapter(socket_->Accept(nullptr), webrtc::SSL_SERVER);
ssl_adapter_->SetIdentity(ssl_identity_->Clone());
if (ssl_adapter_->StartSSL(GetHostname()) != 0) {
@@ -202,7 +204,7 @@
class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
public:
explicit SSLAdapterTestBase(const rtc::KeyParams& key_params)
- : vss_(new rtc::VirtualSocketServer()),
+ : vss_(new webrtc::VirtualSocketServer()),
thread_(vss_.get()),
server_(new SSLAdapterTestDummyServer(key_params)),
client_(new SSLAdapterTestDummyClient()),
@@ -242,19 +244,19 @@
int rv;
// The initial state is CS_CLOSED
- ASSERT_EQ(rtc::Socket::CS_CLOSED, client_->GetState());
+ ASSERT_EQ(webrtc::Socket::CS_CLOSED, client_->GetState());
rv = client_->Connect(server_->GetHostname(), server_->GetAddress());
ASSERT_EQ(0, rv);
// Now the state should be CS_CONNECTING
- ASSERT_EQ(rtc::Socket::CS_CONNECTING, client_->GetState());
+ ASSERT_EQ(webrtc::Socket::CS_CONNECTING, client_->GetState());
if (expect_success) {
// If expecting success, the client should end up in the CS_CONNECTED
// state after handshake.
EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); },
- ::testing::Eq(rtc::Socket::CS_CONNECTED),
+ ::testing::Eq(webrtc::Socket::CS_CONNECTED),
{.timeout = handshake_wait_}),
webrtc::IsRtcOk());
@@ -263,7 +265,7 @@
} else {
// On handshake failure the client should end up in the CS_CLOSED state.
EXPECT_THAT(webrtc::WaitUntil([&] { return client_->GetState(); },
- ::testing::Eq(rtc::Socket::CS_CLOSED),
+ ::testing::Eq(webrtc::Socket::CS_CLOSED),
{.timeout = handshake_wait_}),
webrtc::IsRtcOk());
@@ -296,7 +298,7 @@
}
protected:
- std::unique_ptr<rtc::VirtualSocketServer> vss_;
+ std::unique_ptr<webrtc::VirtualSocketServer> vss_;
rtc::AutoSocketServerThread thread_;
std::unique_ptr<SSLAdapterTestDummyServer> server_;
std::unique_ptr<SSLAdapterTestDummyClient> client_;
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index b61c887..8a422b9 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -34,10 +34,10 @@
// Callers can retrieve received packets from any thread by calling
// NextPacket.
-TestClient::TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket)
+TestClient::TestClient(std::unique_ptr<AsyncPacketSocket> socket)
: TestClient(std::move(socket), nullptr) {}
-TestClient::TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket,
+TestClient::TestClient(std::unique_ptr<AsyncPacketSocket> socket,
ThreadProcessingFakeClock* fake_clock)
: fake_clock_(fake_clock), socket_(std::move(socket)) {
socket_->RegisterReceivedPacketCallback(
@@ -49,7 +49,7 @@
TestClient::~TestClient() {}
-bool TestClient::CheckConnState(rtc::AsyncPacketSocket::State state) {
+bool TestClient::CheckConnState(AsyncPacketSocket::State state) {
// Wait for our timeout value until the socket reaches the desired state.
int64_t end = rtc::TimeAfter(kTimeoutMs);
while (socket_->GetState() != state && rtc::TimeUntil(end) > 0) {
@@ -153,17 +153,17 @@
return socket_->GetError();
}
-int TestClient::SetOption(rtc::Socket::Option opt, int value) {
+int TestClient::SetOption(Socket::Option opt, int value) {
return socket_->SetOption(opt, value);
}
-void TestClient::OnPacket(rtc::AsyncPacketSocket* socket,
+void TestClient::OnPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& received_packet) {
MutexLock lock(&mutex_);
packets_.push_back(std::make_unique<Packet>(received_packet));
}
-void TestClient::OnReadyToSend(rtc::AsyncPacketSocket* socket) {
+void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
++ready_to_send_count_;
}
diff --git a/rtc_base/test_client.h b/rtc_base/test_client.h
index 8f2f25e..ea30be1 100644
--- a/rtc_base/test_client.h
+++ b/rtc_base/test_client.h
@@ -42,11 +42,11 @@
// Creates a client that will send and receive with the given socket and
// will post itself messages with the given thread.
- explicit TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket);
+ explicit TestClient(std::unique_ptr<AsyncPacketSocket> socket);
// Create a test client that will use a fake clock. NextPacket needs to wait
// for a packet to be received, and thus it needs to advance the fake clock
// if the test is using one, rather than just sleeping.
- TestClient(std::unique_ptr<rtc::AsyncPacketSocket> socket,
+ TestClient(std::unique_ptr<AsyncPacketSocket> socket,
ThreadProcessingFakeClock* fake_clock);
~TestClient() override;
@@ -57,11 +57,11 @@
SocketAddress remote_address() const { return socket_->GetRemoteAddress(); }
// Checks that the socket moves to the specified connect state.
- bool CheckConnState(rtc::AsyncPacketSocket::State state);
+ bool CheckConnState(AsyncPacketSocket::State state);
// Checks that the socket is connected to the remote side.
bool CheckConnected() {
- return CheckConnState(rtc::AsyncPacketSocket::STATE_CONNECTED);
+ return CheckConnState(AsyncPacketSocket::STATE_CONNECTED);
}
// Sends using the clients socket.
@@ -82,7 +82,7 @@
bool CheckNoPacket();
int GetError();
- int SetOption(rtc::Socket::Option opt, int value);
+ int SetOption(Socket::Option opt, int value);
bool ready_to_send() const { return ready_to_send_count() > 0; }
@@ -93,17 +93,17 @@
// Timeout for reads when no packet is expected.
static const int kNoPacketTimeoutMs = 1000;
// Workaround for the fact that AsyncPacketSocket::GetConnState doesn't exist.
- rtc::Socket::ConnState GetState();
+ Socket::ConnState GetState();
- void OnPacket(rtc::AsyncPacketSocket* socket,
+ void OnPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& received_packet);
- void OnReadyToSend(rtc::AsyncPacketSocket* socket);
+ void OnReadyToSend(AsyncPacketSocket* socket);
bool CheckTimestamp(std::optional<Timestamp> packet_timestamp);
void AdvanceTime(int ms);
ThreadProcessingFakeClock* fake_clock_ = nullptr;
Mutex mutex_;
- std::unique_ptr<rtc::AsyncPacketSocket> socket_;
+ std::unique_ptr<AsyncPacketSocket> socket_;
std::vector<std::unique_ptr<Packet>> packets_;
int ready_to_send_count_ = 0;
std::optional<Timestamp> prev_packet_timestamp_;
diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc
index fd7d753..b83eaa5 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -40,13 +40,12 @@
namespace {
void TestUdpInternal(const SocketAddress& loopback) {
- rtc::PhysicalSocketServer socket_server;
+ PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
- rtc::Socket* socket =
- socket_server.CreateSocket(loopback.family(), SOCK_DGRAM);
+ Socket* socket = socket_server.CreateSocket(loopback.family(), SOCK_DGRAM);
socket->Bind(loopback);
- TestClient client(std::make_unique<rtc::AsyncUDPSocket>(socket));
+ TestClient client(std::make_unique<AsyncUDPSocket>(socket));
SocketAddress addr = client.address(), from;
EXPECT_EQ(3, client.SendTo("foo", 3, addr));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
@@ -55,14 +54,13 @@
}
void TestTcpInternal(const SocketAddress& loopback) {
- rtc::PhysicalSocketServer socket_server;
+ PhysicalSocketServer socket_server;
rtc::AutoSocketServerThread main_thread(&socket_server);
webrtc::TestEchoServer server(&main_thread, loopback);
- rtc::Socket* socket =
- socket_server.CreateSocket(loopback.family(), SOCK_STREAM);
- std::unique_ptr<rtc::AsyncTCPSocket> tcp_socket = absl::WrapUnique(
- rtc::AsyncTCPSocket::Create(socket, loopback, server.address()));
+ Socket* socket = socket_server.CreateSocket(loopback.family(), SOCK_STREAM);
+ std::unique_ptr<AsyncTCPSocket> tcp_socket = absl::WrapUnique(
+ AsyncTCPSocket::Create(socket, loopback, server.address()));
ASSERT_TRUE(tcp_socket != nullptr);
TestClient client(std::move(tcp_socket));
diff --git a/rtc_base/test_echo_server.h b/rtc_base/test_echo_server.h
index b549b50..7b8243e 100644
--- a/rtc_base/test_echo_server.h
+++ b/rtc_base/test_echo_server.h
@@ -42,10 +42,10 @@
SocketAddress address() const { return server_socket_->GetLocalAddress(); }
private:
- void OnAccept(rtc::Socket* socket) {
- rtc::Socket* raw_socket = socket->Accept(nullptr);
+ void OnAccept(Socket* socket) {
+ Socket* raw_socket = socket->Accept(nullptr);
if (raw_socket) {
- rtc::AsyncTCPSocket* packet_socket = new rtc::AsyncTCPSocket(raw_socket);
+ AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket);
packet_socket->RegisterReceivedPacketCallback(
[&](rtc::AsyncPacketSocket* socket,
const rtc::ReceivedPacket& packet) { OnPacket(socket, packet); });
@@ -68,8 +68,8 @@
rtc::Thread::Current()->PostTask([socket = absl::WrapUnique(socket)] {});
}
- typedef std::list<rtc::AsyncTCPSocket*> ClientList;
- std::unique_ptr<rtc::Socket> server_socket_;
+ typedef std::list<AsyncTCPSocket*> ClientList;
+ std::unique_ptr<Socket> server_socket_;
ClientList client_sockets_;
};
diff --git a/rtc_base/test_utils.h b/rtc_base/test_utils.h
index 3f877fc..53a7a03 100644
--- a/rtc_base/test_utils.h
+++ b/rtc_base/test_utils.h
@@ -42,7 +42,7 @@
StreamSink();
~StreamSink() override;
- void Monitor(rtc::Socket* socket) {
+ void Monitor(Socket* socket) {
socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent);
socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent);
socket->SignalWriteEvent.connect(this, &StreamSink::OnWriteEvent);
@@ -50,28 +50,28 @@
// In case you forgot to unmonitor a previous object with this address
events_.erase(socket);
}
- void Unmonitor(rtc::Socket* socket) {
+ void Unmonitor(Socket* socket) {
socket->SignalConnectEvent.disconnect(this);
socket->SignalReadEvent.disconnect(this);
socket->SignalWriteEvent.disconnect(this);
socket->SignalCloseEvent.disconnect(this);
events_.erase(socket);
}
- bool Check(rtc::Socket* socket, StreamSinkEvent event, bool reset = true) {
+ bool Check(Socket* socket, StreamSinkEvent event, bool reset = true) {
return DoCheck(socket, event, reset);
}
private:
- typedef std::map<rtc::Socket*, int> EventMap;
+ typedef std::map<Socket*, int> EventMap;
- void OnConnectEvent(rtc::Socket* socket) { AddEvents(socket, SSE_OPEN); }
- void OnReadEvent(rtc::Socket* socket) { AddEvents(socket, SSE_READ); }
- void OnWriteEvent(rtc::Socket* socket) { AddEvents(socket, SSE_WRITE); }
- void OnCloseEvent(rtc::Socket* socket, int error) {
+ void OnConnectEvent(Socket* socket) { AddEvents(socket, SSE_OPEN); }
+ void OnReadEvent(Socket* socket) { AddEvents(socket, SSE_READ); }
+ void OnWriteEvent(Socket* socket) { AddEvents(socket, SSE_WRITE); }
+ void OnCloseEvent(Socket* socket, int error) {
AddEvents(socket, (0 == error) ? SSE_CLOSE : SSE_ERROR);
}
- void AddEvents(rtc::Socket* obj, int events) {
+ void AddEvents(Socket* obj, int events) {
EventMap::iterator it = events_.find(obj);
if (events_.end() == it) {
events_.insert(EventMap::value_type(obj, events));
@@ -79,7 +79,7 @@
it->second |= events;
}
}
- bool DoCheck(rtc::Socket* obj, StreamSinkEvent event, bool reset) {
+ bool DoCheck(Socket* obj, StreamSinkEvent event, bool reset) {
EventMap::iterator it = events_.find(obj);
if ((events_.end() == it) || (0 == (it->second & event))) {
return false;
diff --git a/rtc_base/thread.cc b/rtc_base/thread.cc
index a082627..bc42d74 100644
--- a/rtc_base/thread.cc
+++ b/rtc_base/thread.cc
@@ -310,12 +310,12 @@
}
#endif
-Thread::Thread(SocketServer* ss) : Thread(ss, /*do_init=*/true) {}
+Thread::Thread(webrtc::SocketServer* ss) : Thread(ss, /*do_init=*/true) {}
-Thread::Thread(std::unique_ptr<SocketServer> ss)
+Thread::Thread(std::unique_ptr<webrtc::SocketServer> ss)
: Thread(std::move(ss), /*do_init=*/true) {}
-Thread::Thread(SocketServer* ss, bool do_init)
+Thread::Thread(webrtc::SocketServer* ss, bool do_init)
: delayed_next_num_(0),
fInitialized_(false),
fDestroyed_(false),
@@ -329,7 +329,7 @@
}
}
-Thread::Thread(std::unique_ptr<SocketServer> ss, bool do_init)
+Thread::Thread(std::unique_ptr<webrtc::SocketServer> ss, bool do_init)
: Thread(ss.get(), do_init) {
own_ss_ = std::move(ss);
}
@@ -367,7 +367,7 @@
delayed_messages_ = {};
}
-SocketServer* Thread::socketserver() {
+webrtc::SocketServer* Thread::socketserver() {
return ss_;
}
@@ -437,7 +437,7 @@
{
// Wait and multiplex in the meantime
- if (!ss_->Wait(cmsNext == kForever ? SocketServer::kForever
+ if (!ss_->Wait(cmsNext == kForever ? webrtc::SocketServer::kForever
: webrtc::TimeDelta::Millis(cmsNext),
/*process_io=*/true))
return nullptr;
@@ -543,8 +543,8 @@
}
std::unique_ptr<Thread> Thread::Create() {
- return std::unique_ptr<Thread>(
- new Thread(std::unique_ptr<SocketServer>(new NullSocketServer())));
+ return std::unique_ptr<Thread>(new Thread(
+ std::unique_ptr<webrtc::SocketServer>(new webrtc::NullSocketServer())));
}
bool Thread::SleepMs(int milliseconds) {
@@ -909,7 +909,7 @@
}
}
-AutoSocketServerThread::AutoSocketServerThread(SocketServer* ss)
+AutoSocketServerThread::AutoSocketServerThread(webrtc::SocketServer* ss)
: Thread(ss, /*do_init=*/false) {
DoInit();
old_thread_ = ThreadManager::Instance()->CurrentThread();
diff --git a/rtc_base/thread.h b/rtc_base/thread.h
index b126da0..0d55087 100644
--- a/rtc_base/thread.h
+++ b/rtc_base/thread.h
@@ -169,14 +169,14 @@
// init_queue and call DoInit() from their constructor to prevent races
// with the ThreadManager using the object while the vtable is still
// being created.
- explicit Thread(SocketServer* ss);
- explicit Thread(std::unique_ptr<SocketServer> ss);
+ explicit Thread(webrtc::SocketServer* ss);
+ explicit Thread(std::unique_ptr<webrtc::SocketServer> ss);
// Constructors meant for subclasses; they should call DoInit themselves and
// pass false for `do_init`, so that DoInit is called only on the fully
// instantiated class, which avoids a vptr data race.
- Thread(SocketServer* ss, bool do_init);
- Thread(std::unique_ptr<SocketServer> ss, bool do_init);
+ Thread(webrtc::SocketServer* ss, bool do_init);
+ Thread(std::unique_ptr<webrtc::SocketServer> ss, bool do_init);
// NOTE: ALL SUBCLASSES OF Thread MUST CALL Stop() IN THEIR DESTRUCTORS (or
// guarantee Stop() is explicitly called before the subclass is destroyed).
@@ -246,7 +246,7 @@
uint32_t GetCouldBeBlockingCallCount() const;
#endif
- SocketServer* socketserver();
+ webrtc::SocketServer* socketserver();
// Note: The behavior of Thread has changed. When a thread is stopped,
// futher Posts and Sends will fail. However, any pending Sends and *ready*
@@ -501,9 +501,9 @@
std::atomic<int> stop_;
// The SocketServer might not be owned by Thread.
- SocketServer* const ss_;
+ webrtc::SocketServer* const ss_;
// Used if SocketServer ownership lies with `this`.
- std::unique_ptr<SocketServer> own_ss_;
+ std::unique_ptr<webrtc::SocketServer> own_ss_;
std::string name_;
@@ -557,7 +557,7 @@
class AutoSocketServerThread : public Thread {
public:
- explicit AutoSocketServerThread(SocketServer* ss);
+ explicit AutoSocketServerThread(webrtc::SocketServer* ss);
~AutoSocketServerThread() override;
AutoSocketServerThread(const AutoSocketServerThread&) = delete;
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index ee885b5..50c59ea 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -74,7 +74,7 @@
// Receives messages and sends on a socket.
class MessageClient : public TestGenerator {
public:
- MessageClient(Thread* pth, Socket* socket) : socket_(socket) {}
+ MessageClient(Thread* pth, webrtc::Socket* socket) : socket_(socket) {}
~MessageClient() { delete socket_; }
@@ -84,17 +84,17 @@
}
private:
- Socket* socket_;
+ webrtc::Socket* socket_;
};
// Receives on a socket and sends by posting messages.
class SocketClient : public TestGenerator, public sigslot::has_slots<> {
public:
- SocketClient(Socket* socket,
+ SocketClient(webrtc::Socket* socket,
const webrtc::SocketAddress& addr,
Thread* post_thread,
MessageClient* phandler)
- : socket_(AsyncUDPSocket::Create(socket, addr)),
+ : socket_(webrtc::AsyncUDPSocket::Create(socket, addr)),
post_thread_(post_thread),
post_handler_(phandler) {
socket_->RegisterReceivedPacketCallback(
@@ -107,7 +107,8 @@
webrtc::SocketAddress address() const { return socket_->GetLocalAddress(); }
- void OnPacket(AsyncPacketSocket* socket, const rtc::ReceivedPacket& packet) {
+ void OnPacket(webrtc::AsyncPacketSocket* socket,
+ const rtc::ReceivedPacket& packet) {
EXPECT_EQ(packet.payload().size(), sizeof(uint32_t));
uint32_t prev =
reinterpret_cast<const uint32_t*>(packet.payload().data())[0];
@@ -119,7 +120,7 @@
}
private:
- AsyncUDPSocket* socket_;
+ webrtc::AsyncUDPSocket* socket_;
Thread* post_thread_;
MessageClient* post_handler_;
};
@@ -127,7 +128,8 @@
class CustomThread : public rtc::Thread {
public:
CustomThread()
- : Thread(std::unique_ptr<SocketServer>(new rtc::NullSocketServer())) {}
+ : Thread(std::unique_ptr<webrtc::SocketServer>(
+ new webrtc::NullSocketServer())) {}
~CustomThread() override { Stop(); }
bool Start() { return false; }
@@ -140,7 +142,8 @@
class SignalWhenDestroyedThread : public Thread {
public:
SignalWhenDestroyedThread(Event* event)
- : Thread(std::unique_ptr<SocketServer>(new NullSocketServer())),
+ : Thread(std::unique_ptr<webrtc::SocketServer>(
+ new webrtc::NullSocketServer())),
event_(event) {}
~SignalWhenDestroyedThread() override {
@@ -163,12 +166,13 @@
// Create the messaging client on its own thread.
auto th1 = Thread::CreateWithSocketServer();
- Socket* socket = th1->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
+ webrtc::Socket* socket =
+ th1->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
MessageClient msg_client(th1.get(), socket);
// Create the socket client on its own thread.
auto th2 = Thread::CreateWithSocketServer();
- Socket* asocket =
+ webrtc::Socket* asocket =
th2->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
SocketClient sock_client(asocket, addr, th1.get(), &msg_client);
@@ -520,7 +524,7 @@
q.Start();
DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(clock, q);
- NullSocketServer nullss;
+ webrtc::NullSocketServer nullss;
Thread q_nullss(&nullss, true);
q_nullss.Start();
DelayedPostsWithIdenticalTimesAreProcessedInFifoOrder(clock, q_nullss);
diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc
index 3305be7..d170bf3 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -29,7 +29,7 @@
#include "rtc_base/thread.h"
#include "rtc_base/time_utils.h"
-namespace rtc {
+namespace webrtc {
using ::webrtc::MutexLock;
using ::webrtc::TaskQueueBase;
@@ -63,9 +63,7 @@
// the kernel does.
class VirtualSocketPacket {
public:
- VirtualSocketPacket(const char* data,
- size_t size,
- const webrtc::SocketAddress& from)
+ VirtualSocketPacket(const char* data, size_t size, const SocketAddress& from)
: size_(size), consumed_(0), from_(from) {
RTC_DCHECK(nullptr != data);
data_ = new char[size_];
@@ -76,7 +74,7 @@
const char* data() const { return data_ + consumed_; }
size_t size() const { return size_ - consumed_; }
- const webrtc::SocketAddress& from() const { return from_; }
+ const SocketAddress& from() const { return from_; }
// Remove the first size bytes from the data.
void Consume(size_t size) {
@@ -87,7 +85,7 @@
private:
char* data_;
size_t size_, consumed_;
- webrtc::SocketAddress from_;
+ SocketAddress from_;
};
VirtualSocket::VirtualSocket(VirtualSocketServer* server, int family, int type)
@@ -108,19 +106,19 @@
Close();
}
-webrtc::SocketAddress VirtualSocket::GetLocalAddress() const {
+SocketAddress VirtualSocket::GetLocalAddress() const {
return local_addr_;
}
-webrtc::SocketAddress VirtualSocket::GetRemoteAddress() const {
+SocketAddress VirtualSocket::GetRemoteAddress() const {
return remote_addr_;
}
-void VirtualSocket::SetLocalAddress(const webrtc::SocketAddress& addr) {
+void VirtualSocket::SetLocalAddress(const SocketAddress& addr) {
local_addr_ = addr;
}
-int VirtualSocket::Bind(const webrtc::SocketAddress& addr) {
+int VirtualSocket::Bind(const SocketAddress& addr) {
if (!local_addr_.IsNil()) {
error_ = EINVAL;
return -1;
@@ -137,7 +135,7 @@
return result;
}
-int VirtualSocket::Connect(const webrtc::SocketAddress& addr) {
+int VirtualSocket::Connect(const SocketAddress& addr) {
return InitiateConnect(addr, true);
}
@@ -154,7 +152,7 @@
void VirtualSocket::SafetyBlock::SetNotAlive() {
VirtualSocketServer* const server = socket_.server_;
- const webrtc::SocketAddress& local_addr = socket_.local_addr_;
+ const SocketAddress& local_addr = socket_.local_addr_;
MutexLock lock(&mutex_);
// Cancel pending sockets
@@ -194,7 +192,7 @@
}
pending_read_signal_event_ = true;
- rtc::scoped_refptr<SafetyBlock> safety(this);
+ scoped_refptr<SafetyBlock> safety(this);
socket_.server_->msg_queue_->PostTask(
[safety = std::move(safety)] { safety->MaybeSignalReadEvent(); });
}
@@ -244,7 +242,7 @@
int VirtualSocket::SendTo(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
if (SOCK_DGRAM == type_) {
return SendUdp(pv, cb, addr);
} else {
@@ -257,13 +255,13 @@
}
int VirtualSocket::Recv(void* pv, size_t cb, int64_t* timestamp) {
- webrtc::SocketAddress addr;
+ SocketAddress addr;
return RecvFrom(pv, cb, &addr, timestamp);
}
int VirtualSocket::RecvFrom(void* pv,
size_t cb,
- webrtc::SocketAddress* paddr,
+ SocketAddress* paddr,
int64_t* timestamp) {
if (timestamp) {
*timestamp = -1;
@@ -288,7 +286,7 @@
int VirtualSocket::SafetyBlock::RecvFrom(void* buffer,
size_t size,
- webrtc::SocketAddress& addr) {
+ 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()) {
@@ -334,7 +332,7 @@
listen_queue_.emplace();
}
-VirtualSocket* VirtualSocket::Accept(webrtc::SocketAddress* paddr) {
+VirtualSocket* VirtualSocket::Accept(SocketAddress* paddr) {
SafetyBlock::AcceptResult result = safety_->Accept();
if (result.error != 0) {
error_ = result.error;
@@ -362,7 +360,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());
- webrtc::SocketAddress remote_addr = listen_queue_->front();
+ SocketAddress remote_addr = listen_queue_->front();
listen_queue_->pop_front();
if (socket->InitiateConnect(remote_addr, false) != 0) {
continue;
@@ -404,7 +402,7 @@
void VirtualSocket::PostPacket(TimeDelta delay,
std::unique_ptr<VirtualSocketPacket> packet) {
- rtc::scoped_refptr<SafetyBlock> safety = safety_;
+ scoped_refptr<SafetyBlock> safety = safety_;
VirtualSocket* socket = this;
server_->msg_queue_->PostDelayedTask(
[safety = std::move(safety), socket,
@@ -426,14 +424,13 @@
}
void VirtualSocket::PostConnect(TimeDelta delay,
- const webrtc::SocketAddress& remote_addr) {
+ const SocketAddress& remote_addr) {
safety_->PostConnect(delay, remote_addr);
}
-void VirtualSocket::SafetyBlock::PostConnect(
- TimeDelta delay,
- const webrtc::SocketAddress& remote_addr) {
- rtc::scoped_refptr<SafetyBlock> safety(this);
+void VirtualSocket::SafetyBlock::PostConnect(TimeDelta delay,
+ const SocketAddress& remote_addr) {
+ scoped_refptr<SafetyBlock> safety(this);
MutexLock lock(&mutex_);
RTC_DCHECK(alive_);
@@ -466,7 +463,7 @@
return Signal::kNone;
}
RTC_DCHECK(!posted_connects_.empty());
- webrtc::SocketAddress remote_addr = *remote_addr_it;
+ SocketAddress remote_addr = *remote_addr_it;
posted_connects_.erase(remote_addr_it);
if (listen_queue_.has_value()) {
@@ -492,7 +489,7 @@
// Posted task may outlive this. Use different name for `this` inside the task
// to avoid accidental unsafe `this->safety_` instead of safe `safety`
VirtualSocket* socket = this;
- rtc::scoped_refptr<SafetyBlock> safety = safety_;
+ scoped_refptr<SafetyBlock> safety = safety_;
auto task = [safety = std::move(safety), socket] {
if (!safety->IsAlive()) {
return;
@@ -509,8 +506,7 @@
server_->msg_queue_->PostDelayedTask(std::move(task), delay);
}
-int VirtualSocket::InitiateConnect(const webrtc::SocketAddress& addr,
- bool use_delay) {
+int VirtualSocket::InitiateConnect(const SocketAddress& addr, bool use_delay) {
if (!remote_addr_.IsNil()) {
error_ = (CS_CONNECTED == state_) ? EISCONN : EINPROGRESS;
return -1;
@@ -519,9 +515,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(webrtc::SocketAddress("0.0.0.0", 0));
+ result = Bind(SocketAddress("0.0.0.0", 0));
} else if (addr.ipaddr().family() == AF_INET6) {
- result = Bind(webrtc::SocketAddress("::", 0));
+ result = Bind(SocketAddress("::", 0));
}
if (result != 0) {
return result;
@@ -541,7 +537,7 @@
return 0;
}
-void VirtualSocket::CompleteConnect(const webrtc::SocketAddress& addr) {
+void VirtualSocket::CompleteConnect(const SocketAddress& addr) {
RTC_DCHECK(CS_CONNECTING == state_);
remote_addr_ = addr;
state_ = CS_CONNECTED;
@@ -550,7 +546,7 @@
int VirtualSocket::SendUdp(const void* pv,
size_t cb,
- const webrtc::SocketAddress& addr) {
+ const SocketAddress& addr) {
// If we have not been assigned a local port, then get one.
if (local_addr_.IsNil()) {
local_addr_ = server_->AssignBindAddress(
@@ -657,8 +653,7 @@
VirtualSocketServer::VirtualSocketServer() : VirtualSocketServer(nullptr) {}
-VirtualSocketServer::VirtualSocketServer(
- webrtc::ThreadProcessingFakeClock* fake_clock)
+VirtualSocketServer::VirtualSocketServer(ThreadProcessingFakeClock* fake_clock)
: fake_clock_(fake_clock),
msg_queue_(nullptr),
stop_on_idle_(false),
@@ -683,19 +678,19 @@
delete connections_;
}
-webrtc::IPAddress VirtualSocketServer::GetNextIP(int family) {
+IPAddress VirtualSocketServer::GetNextIP(int family) {
if (family == AF_INET) {
- webrtc::IPAddress next_ip(next_ipv4_);
+ IPAddress next_ip(next_ipv4_);
next_ipv4_.s_addr =
webrtc::HostToNetwork32(webrtc::NetworkToHost32(next_ipv4_.s_addr) + 1);
return next_ip;
} else if (family == AF_INET6) {
- webrtc::IPAddress next_ip(next_ipv6_);
+ IPAddress next_ip(next_ipv6_);
uint32_t* as_ints = reinterpret_cast<uint32_t*>(&next_ipv6_.s6_addr);
as_ints[3] += 1;
return next_ip;
}
- return webrtc::IPAddress();
+ return IPAddress();
}
uint16_t VirtualSocketServer::GetNextPort() {
@@ -710,7 +705,7 @@
void VirtualSocketServer::SetSendingBlocked(bool blocked) {
{
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
if (blocked == sending_blocked_) {
// Unchanged; nothing to do.
return;
@@ -728,14 +723,13 @@
return new VirtualSocket(this, family, type);
}
-void VirtualSocketServer::SetMessageQueue(Thread* msg_queue) {
+void VirtualSocketServer::SetMessageQueue(rtc::Thread* msg_queue) {
msg_queue_ = msg_queue;
}
-bool VirtualSocketServer::Wait(webrtc::TimeDelta max_wait_duration,
- bool process_io) {
+bool VirtualSocketServer::Wait(TimeDelta max_wait_duration, bool process_io) {
RTC_DCHECK_RUN_ON(msg_queue_);
- if (stop_on_idle_ && Thread::Current()->empty()) {
+ if (stop_on_idle_ && rtc::Thread::Current()->empty()) {
return false;
}
// Note: we don't need to do anything with `process_io` since we don't have
@@ -751,8 +745,8 @@
}
void VirtualSocketServer::SetAlternativeLocalAddress(
- const webrtc::IPAddress& address,
- const webrtc::IPAddress& alternative) {
+ const IPAddress& address,
+ const IPAddress& alternative) {
alternative_address_mapping_[address] = alternative;
}
@@ -763,10 +757,10 @@
if (fake_clock_) {
// If using a fake clock, advance it in millisecond increments until the
// queue is empty.
- fake_clock_->AdvanceTime(webrtc::TimeDelta::Millis(1));
+ fake_clock_->AdvanceTime(TimeDelta::Millis(1));
} else {
// Otherwise, run a normal message loop.
- msg_queue_->ProcessMessages(Thread::kForever);
+ msg_queue_->ProcessMessages(rtc::Thread::kForever);
}
}
stop_on_idle_ = false;
@@ -778,8 +772,8 @@
}
bool VirtualSocketServer::CloseTcpConnections(
- const webrtc::SocketAddress& addr_local,
- const webrtc::SocketAddress& addr_remote) {
+ const SocketAddress& addr_local,
+ const SocketAddress& addr_remote) {
VirtualSocket* socket = LookupConnection(addr_local, addr_remote);
if (!socket) {
return false;
@@ -794,25 +788,25 @@
}
int VirtualSocketServer::Bind(VirtualSocket* socket,
- const webrtc::SocketAddress& addr) {
+ const 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).
- webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::value_type entry(normalized, socket);
return bindings_->insert(entry).second ? 0 : -1;
}
-webrtc::SocketAddress VirtualSocketServer::AssignBindAddress(
- const webrtc::SocketAddress& app_addr) {
+SocketAddress VirtualSocketServer::AssignBindAddress(
+ const SocketAddress& app_addr) {
RTC_DCHECK(!webrtc::IPIsUnspec(app_addr.ipaddr()));
// Normalize the IP.
- webrtc::SocketAddress addr;
+ SocketAddress addr;
addr.SetIP(app_addr.ipaddr().Normalized());
// If the IP appears in `alternative_address_mapping_`, meaning the test has
@@ -838,21 +832,19 @@
return addr;
}
-VirtualSocket* VirtualSocketServer::LookupBinding(
- const webrtc::SocketAddress& addr) {
- webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+VirtualSocket* VirtualSocketServer::LookupBinding(const SocketAddress& addr) {
+ SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
AddressMap::iterator it = bindings_->find(normalized);
if (it != bindings_->end()) {
return it->second;
}
- webrtc::IPAddress default_ip =
- GetDefaultSourceAddress(addr.ipaddr().family());
+ IPAddress default_ip = GetDefaultSourceAddress(addr.ipaddr().family());
if (!webrtc::IPIsUnspec(default_ip) && addr.ipaddr() == default_ip) {
// 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.
- webrtc::SocketAddress sock_addr =
+ SocketAddress sock_addr =
webrtc::EmptySocketAddressWithFamily(addr.ipaddr().family());
sock_addr.SetPort(addr.port());
return LookupBinding(sock_addr);
@@ -861,48 +853,41 @@
return nullptr;
}
-int VirtualSocketServer::Unbind(const webrtc::SocketAddress& addr,
+int VirtualSocketServer::Unbind(const SocketAddress& addr,
VirtualSocket* socket) {
- webrtc::SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
+ SocketAddress normalized(addr.ipaddr().Normalized(), addr.port());
RTC_DCHECK((*bindings_)[normalized] == socket);
bindings_->erase(bindings_->find(normalized));
return 0;
}
-void VirtualSocketServer::AddConnection(const webrtc::SocketAddress& local,
- const webrtc::SocketAddress& remote,
+void VirtualSocketServer::AddConnection(const SocketAddress& local,
+ const 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.
- 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*>(
+ SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
+ SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ SocketAddressPair address_pair(local_normalized, remote_normalized);
+ connections_->insert(std::pair<SocketAddressPair, VirtualSocket*>(
address_pair, remote_socket));
}
VirtualSocket* VirtualSocketServer::LookupConnection(
- 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);
+ const SocketAddress& local,
+ const SocketAddress& remote) {
+ SocketAddress local_normalized(local.ipaddr().Normalized(), local.port());
+ SocketAddress remote_normalized(remote.ipaddr().Normalized(), remote.port());
+ 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 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);
+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());
+ SocketAddressPair address_pair(local_normalized, remote_normalized);
connections_->erase(address_pair);
}
@@ -911,7 +896,7 @@
}
int VirtualSocketServer::Connect(VirtualSocket* socket,
- const webrtc::SocketAddress& remote_addr,
+ const SocketAddress& remote_addr,
bool use_delay) {
RTC_DCHECK(msg_queue_);
@@ -942,12 +927,12 @@
return true;
}
-bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& addr) {
+bool VirtualSocketServer::Disconnect(const SocketAddress& addr) {
return Disconnect(LookupBinding(addr));
}
-bool VirtualSocketServer::Disconnect(const webrtc::SocketAddress& local_addr,
- const webrtc::SocketAddress& remote_addr) {
+bool VirtualSocketServer::Disconnect(const SocketAddress& local_addr,
+ const 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) {
@@ -968,9 +953,9 @@
int VirtualSocketServer::SendUdp(VirtualSocket* socket,
const char* data,
size_t data_size,
- const webrtc::SocketAddress& remote_addr) {
+ const SocketAddress& remote_addr) {
{
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
++sent_packets_;
if (sending_blocked_) {
socket->SetToBlocked();
@@ -1016,7 +1001,7 @@
}
{
- int64_t cur_time = TimeMillis();
+ int64_t cur_time = rtc::TimeMillis();
size_t network_size = socket->PurgeNetworkPackets(cur_time);
// Determine whether we have enough bandwidth to accept this packet. To do
@@ -1027,7 +1012,7 @@
// "Derivative Random Drop"); however, this algorithm is a more accurate
// simulation of what a normal network would do.
{
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
size_t packet_size = data_size + UDP_HEADER_SIZE;
if (network_size + packet_size > network_capacity_) {
RTC_LOG(LS_VERBOSE) << "Dropping packet: network capacity exceeded";
@@ -1044,7 +1029,7 @@
void VirtualSocketServer::SendTcp(VirtualSocket* socket) {
{
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
++sent_packets_;
if (sending_blocked_) {
// Eventually the socket's buffer will fill and VirtualSocket::SendTcp
@@ -1067,7 +1052,7 @@
return;
}
- int64_t cur_time = TimeMillis();
+ int64_t cur_time = rtc::TimeMillis();
socket->PurgeNetworkPackets(cur_time);
while (true) {
@@ -1087,7 +1072,7 @@
socket->MaybeSignalWriteEvent(send_buffer_capacity());
}
-void VirtualSocketServer::SendTcp(const webrtc::SocketAddress& addr) {
+void VirtualSocketServer::SendTcp(const SocketAddress& addr) {
VirtualSocket* sender = LookupBinding(addr);
RTC_DCHECK(nullptr != sender);
SendTcp(sender);
@@ -1109,9 +1094,8 @@
// 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.
- webrtc::SocketAddress sender_addr = sender->GetLocalAddress();
- webrtc::IPAddress default_ip =
- GetDefaultSourceAddress(sender_addr.ipaddr().family());
+ SocketAddress sender_addr = sender->GetLocalAddress();
+ IPAddress default_ip = GetDefaultSourceAddress(sender_addr.ipaddr().family());
if (sender_addr.IsAnyIP() && !webrtc::IPIsUnspec(default_ip)) {
sender_addr.SetIP(default_ip);
}
@@ -1126,7 +1110,7 @@
}
uint32_t VirtualSocketServer::SendDelay(uint32_t size) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
if (bandwidth_ == 0)
return 0;
else
@@ -1155,7 +1139,7 @@
#endif // <unused>
void VirtualSocketServer::UpdateDelayDistribution() {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
delay_dist_ = CreateDistribution(delay_mean_, delay_stddev_, delay_samples_);
}
@@ -1287,10 +1271,10 @@
if (!local || !remote) {
return false;
}
- webrtc::IPAddress local_ip = local->GetLocalAddress().ipaddr();
- webrtc::IPAddress remote_ip = remote->GetLocalAddress().ipaddr();
- webrtc::IPAddress local_normalized = local_ip.Normalized();
- webrtc::IPAddress remote_normalized = remote_ip.Normalized();
+ IPAddress local_ip = local->GetLocalAddress().ipaddr();
+ IPAddress remote_ip = remote->GetLocalAddress().ipaddr();
+ IPAddress local_normalized = local_ip.Normalized();
+ IPAddress remote_normalized = remote_ip.Normalized();
// Check if the addresses are the same family after Normalization (turns
// mapped IPv6 address into IPv4 addresses).
// This will stop unmapped V6 addresses from talking to mapped V6 addresses.
@@ -1325,17 +1309,16 @@
return false;
}
-webrtc::IPAddress VirtualSocketServer::GetDefaultSourceAddress(int family) {
+IPAddress VirtualSocketServer::GetDefaultSourceAddress(int family) {
if (family == AF_INET) {
return default_source_address_v4_;
}
if (family == AF_INET6) {
return default_source_address_v6_;
}
- return webrtc::IPAddress();
+ return IPAddress();
}
-void VirtualSocketServer::SetDefaultSourceAddress(
- const webrtc::IPAddress& from_addr) {
+void VirtualSocketServer::SetDefaultSourceAddress(const IPAddress& from_addr) {
RTC_DCHECK(!webrtc::IPIsAny(from_addr));
if (from_addr.family() == AF_INET) {
default_source_address_v4_ = from_addr;
@@ -1345,42 +1328,42 @@
}
void VirtualSocketServer::set_bandwidth(uint32_t bandwidth) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
bandwidth_ = bandwidth;
}
void VirtualSocketServer::set_network_capacity(uint32_t capacity) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
network_capacity_ = capacity;
}
uint32_t VirtualSocketServer::send_buffer_capacity() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return send_buffer_capacity_;
}
void VirtualSocketServer::set_send_buffer_capacity(uint32_t capacity) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
send_buffer_capacity_ = capacity;
}
uint32_t VirtualSocketServer::recv_buffer_capacity() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return recv_buffer_capacity_;
}
void VirtualSocketServer::set_recv_buffer_capacity(uint32_t capacity) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
recv_buffer_capacity_ = capacity;
}
void VirtualSocketServer::set_delay_mean(uint32_t delay_mean) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
delay_mean_ = delay_mean;
}
void VirtualSocketServer::set_delay_stddev(uint32_t delay_stddev) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
delay_stddev_ = delay_stddev;
}
void VirtualSocketServer::set_delay_samples(uint32_t delay_samples) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
delay_samples_ = delay_samples;
}
@@ -1388,18 +1371,18 @@
RTC_DCHECK_GE(drop_prob, 0.0);
RTC_DCHECK_LE(drop_prob, 1.0);
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
drop_prob_ = drop_prob;
}
void VirtualSocketServer::set_max_udp_payload(size_t payload_size) {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
max_udp_payload_ = payload_size;
}
uint32_t VirtualSocketServer::sent_packets() const {
- webrtc::MutexLock lock(&mutex_);
+ MutexLock lock(&mutex_);
return sent_packets_;
}
-} // namespace rtc
+} // namespace webrtc
diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h
index 5e86e2a..6700238 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -27,7 +27,7 @@
#include "rtc_base/socket_server.h"
#include "rtc_base/synchronization/mutex.h"
-namespace rtc {
+namespace webrtc {
class VirtualSocketPacket;
class VirtualSocketServer;
@@ -39,23 +39,21 @@
VirtualSocket(VirtualSocketServer* server, int family, int type);
~VirtualSocket() override;
- webrtc::SocketAddress GetLocalAddress() const override;
- webrtc::SocketAddress GetRemoteAddress() const override;
+ SocketAddress GetLocalAddress() const override;
+ SocketAddress GetRemoteAddress() const override;
- int Bind(const webrtc::SocketAddress& addr) override;
- int Connect(const webrtc::SocketAddress& addr) 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 webrtc::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;
int RecvFrom(void* pv,
size_t cb,
- webrtc::SocketAddress* paddr,
+ SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
- VirtualSocket* Accept(webrtc::SocketAddress* paddr) override;
+ VirtualSocket* Accept(SocketAddress* paddr) override;
int GetError() const override;
void SetError(int error) override;
@@ -68,7 +66,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 webrtc::SocketAddress& addr);
+ void SetLocalAddress(const SocketAddress& addr);
bool was_any() { return was_any_; }
void set_was_any(bool was_any) { was_any_ = was_any; }
@@ -88,11 +86,9 @@
// Removes stale packets from the network. Returns current size.
size_t PurgeNetworkPackets(int64_t cur_time);
- void PostPacket(webrtc::TimeDelta delay,
- std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay,
- const webrtc::SocketAddress& remote_addr);
- void PostDisconnect(webrtc::TimeDelta delay);
+ void PostPacket(TimeDelta delay, std::unique_ptr<VirtualSocketPacket> packet);
+ void PostConnect(TimeDelta delay, const SocketAddress& remote_addr);
+ void PostDisconnect(TimeDelta delay);
private:
// Struct shared with pending tasks that may outlive VirtualSocket.
@@ -111,32 +107,31 @@
// 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, webrtc::SocketAddress& addr);
+ int RecvFrom(void* buffer, size_t size, SocketAddress& addr);
void Listen();
struct AcceptResult {
int error = 0;
std::unique_ptr<VirtualSocket> socket;
- webrtc::SocketAddress remote_addr;
+ SocketAddress remote_addr;
};
AcceptResult Accept();
bool AddPacket(std::unique_ptr<VirtualSocketPacket> packet);
- void PostConnect(webrtc::TimeDelta delay,
- const webrtc::SocketAddress& remote_addr);
+ void PostConnect(TimeDelta delay, const 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<webrtc::SocketAddress>;
+ using PostedConnects = std::list<SocketAddress>;
void PostSignalReadEvent() RTC_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
void MaybeSignalReadEvent();
Signal Connect(PostedConnects::iterator remote_addr_it);
- webrtc::Mutex mutex_;
+ Mutex mutex_;
VirtualSocket& socket_;
bool alive_ RTC_GUARDED_BY(mutex_) = true;
// Flag indicating if async Task to signal SignalReadEvent is posted.
@@ -157,7 +152,7 @@
RTC_GUARDED_BY(mutex_);
// Pending sockets which can be Accepted
- std::optional<std::deque<webrtc::SocketAddress>> listen_queue_
+ std::optional<std::deque<SocketAddress>> listen_queue_
RTC_GUARDED_BY(mutex_);
};
@@ -170,9 +165,9 @@
typedef std::vector<char> SendBuffer;
typedef std::map<Option, int> OptionsMap;
- 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 InitiateConnect(const SocketAddress& addr, bool use_delay);
+ void CompleteConnect(const SocketAddress& addr);
+ int SendUdp(const void* pv, size_t cb, const SocketAddress& addr);
int SendTcp(const void* pv, size_t cb);
void OnSocketServerReadyToSend();
@@ -181,8 +176,8 @@
const int type_;
ConnState state_;
int error_;
- webrtc::SocketAddress local_addr_;
- webrtc::SocketAddress remote_addr_;
+ SocketAddress local_addr_;
+ SocketAddress remote_addr_;
const scoped_refptr<SafetyBlock> safety_ =
make_ref_counted<SafetyBlock>(this);
@@ -226,7 +221,7 @@
// This constructor needs to be used if the test uses a fake clock and
// ProcessMessagesUntilIdle, since ProcessMessagesUntilIdle needs a way of
// advancing time.
- explicit VirtualSocketServer(webrtc::ThreadProcessingFakeClock* fake_clock);
+ explicit VirtualSocketServer(ThreadProcessingFakeClock* fake_clock);
~VirtualSocketServer() override;
VirtualSocketServer(const VirtualSocketServer&) = delete;
@@ -236,8 +231,8 @@
// socket is bound to the 'any' address, e.g. 0.0.0.0. (If not set, the 'any'
// address is used as the source address on outgoing virtual packets, exposed
// to recipient's RecvFrom).
- webrtc::IPAddress GetDefaultSourceAddress(int family);
- void SetDefaultSourceAddress(const webrtc::IPAddress& from_addr);
+ IPAddress GetDefaultSourceAddress(int family);
+ void SetDefaultSourceAddress(const IPAddress& from_addr);
// Limits the network bandwidth (maximum bytes per second). Zero means that
// all sends occur instantly. Defaults to 0.
@@ -289,11 +284,11 @@
VirtualSocket* CreateSocket(int family, int type) override;
// SocketServer:
- void SetMessageQueue(Thread* queue) override;
- bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
+ void SetMessageQueue(rtc::Thread* queue) override;
+ bool Wait(TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
- void SetDelayOnAddress(const webrtc::SocketAddress& address, int delay_ms) {
+ void SetDelayOnAddress(const SocketAddress& address, int delay_ms) {
delay_by_ip_[address.ipaddr()] = delay_ms;
}
@@ -304,8 +299,8 @@
// If SetAlternativeLocalAddress(A, B) is called, then when something
// attempts to bind a socket to address A, it will get a socket bound to
// address B instead.
- void SetAlternativeLocalAddress(const webrtc::IPAddress& address,
- const webrtc::IPAddress& alternative);
+ void SetAlternativeLocalAddress(const IPAddress& address,
+ const IPAddress& alternative);
typedef std::pair<double, double> Point;
typedef std::vector<Point> Function;
@@ -324,8 +319,8 @@
// Close a pair of Tcp connections by addresses. Both connections will have
// its own OnClose invoked.
- bool CloseTcpConnections(const webrtc::SocketAddress& addr_local,
- const webrtc::SocketAddress& addr_remote);
+ bool CloseTcpConnections(const SocketAddress& addr_local,
+ const SocketAddress& addr_remote);
// Number of packets that clients have attempted to send through this virtual
// socket server. Intended to be used for test assertions.
@@ -333,45 +328,44 @@
// Assign IP and Port if application's address is unspecified. Also apply
// `alternative_address_mapping_`.
- webrtc::SocketAddress AssignBindAddress(
- const webrtc::SocketAddress& app_addr);
+ SocketAddress AssignBindAddress(const SocketAddress& app_addr);
// Binds the given socket to the given (fully-defined) address.
- int Bind(VirtualSocket* socket, const webrtc::SocketAddress& addr);
+ int Bind(VirtualSocket* socket, const SocketAddress& addr);
- int Unbind(const webrtc::SocketAddress& addr, VirtualSocket* socket);
+ int Unbind(const SocketAddress& addr, VirtualSocket* socket);
// Adds a mapping between this socket pair and the socket.
- void AddConnection(const webrtc::SocketAddress& client,
- const webrtc::SocketAddress& server,
+ void AddConnection(const SocketAddress& client,
+ const SocketAddress& server,
VirtualSocket* socket);
// Connects the given socket to the socket at the given address
int Connect(VirtualSocket* socket,
- const webrtc::SocketAddress& remote_addr,
+ const 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 webrtc::SocketAddress& addr);
+ bool Disconnect(const SocketAddress& addr);
// Lookup connection, close corresponding socket.
- bool Disconnect(const webrtc::SocketAddress& local_addr,
- const webrtc::SocketAddress& remote_addr);
+ bool Disconnect(const SocketAddress& local_addr,
+ const 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 webrtc::SocketAddress& remote_addr);
+ const 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 webrtc::SocketAddress& addr) RTC_LOCKS_EXCLUDED(mutex_);
+ void SendTcp(const 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_);
@@ -381,21 +375,21 @@
protected:
// Returns a new IP not used before in this network.
- webrtc::IPAddress GetNextIP(int family);
+ IPAddress GetNextIP(int family);
// Find the socket bound to the given address
- VirtualSocket* LookupBinding(const webrtc::SocketAddress& addr);
+ VirtualSocket* LookupBinding(const SocketAddress& addr);
private:
friend VirtualSocket;
uint16_t GetNextPort();
// Find the socket pair corresponding to this server address.
- VirtualSocket* LookupConnection(const webrtc::SocketAddress& client,
- const webrtc::SocketAddress& server);
+ VirtualSocket* LookupConnection(const SocketAddress& client,
+ const SocketAddress& server);
- void RemoveConnection(const webrtc::SocketAddress& client,
- const webrtc::SocketAddress& server);
+ void RemoveConnection(const SocketAddress& client,
+ const SocketAddress& server);
// Places a packet on the network.
void AddPacketToNetwork(VirtualSocket* socket,
@@ -438,16 +432,16 @@
// NB: This scheme doesn't permit non-dualstack IPv6 sockets.
static bool CanInteractWith(VirtualSocket* local, VirtualSocket* remote);
- typedef std::map<webrtc::SocketAddress, VirtualSocket*> AddressMap;
- typedef std::map<webrtc::SocketAddressPair, VirtualSocket*> ConnectionMap;
+ typedef std::map<SocketAddress, VirtualSocket*> AddressMap;
+ typedef std::map<SocketAddressPair, VirtualSocket*> ConnectionMap;
// May be null if the test doesn't use a fake clock, or it does but doesn't
// use ProcessMessagesUntilIdle.
- webrtc::ThreadProcessingFakeClock* fake_clock_ = nullptr;
+ ThreadProcessingFakeClock* fake_clock_ = nullptr;
// Used to implement Wait/WakeUp.
- Event wakeup_;
- Thread* msg_queue_;
+ rtc::Event wakeup_;
+ rtc::Thread* msg_queue_;
bool stop_on_idle_;
in_addr next_ipv4_;
in6_addr next_ipv6_;
@@ -455,10 +449,10 @@
AddressMap* bindings_;
ConnectionMap* connections_;
- webrtc::IPAddress default_source_address_v4_;
- webrtc::IPAddress default_source_address_v6_;
+ IPAddress default_source_address_v4_;
+ IPAddress default_source_address_v6_;
- mutable webrtc::Mutex mutex_;
+ mutable Mutex mutex_;
uint32_t bandwidth_ RTC_GUARDED_BY(mutex_);
uint32_t network_capacity_ RTC_GUARDED_BY(mutex_);
@@ -471,8 +465,8 @@
// Used for testing.
uint32_t sent_packets_ RTC_GUARDED_BY(mutex_) = 0;
- std::map<webrtc::IPAddress, int> delay_by_ip_;
- std::map<webrtc::IPAddress, webrtc::IPAddress> alternative_address_mapping_;
+ std::map<IPAddress, int> delay_by_ip_;
+ std::map<IPAddress, IPAddress> alternative_address_mapping_;
std::unique_ptr<Function> delay_dist_;
double drop_prob_ RTC_GUARDED_BY(mutex_);
@@ -484,6 +478,12 @@
bool sending_blocked_ RTC_GUARDED_BY(mutex_) = false;
};
-} // namespace rtc
+} // 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::VirtualSocketServer;
+}
#endif // RTC_BASE_VIRTUAL_SOCKET_SERVER_H_
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index 8d24fbc..261d4da 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -53,9 +53,9 @@
// Sends at a constant rate but with random packet sizes.
struct Sender {
- Sender(Thread* th, Socket* s, uint32_t rt)
+ Sender(Thread* th, webrtc::Socket* s, uint32_t rt)
: thread(th),
- socket(std::make_unique<AsyncUDPSocket>(s)),
+ socket(std::make_unique<webrtc::AsyncUDPSocket>(s)),
rate(rt),
count(0) {
last_send = rtc::TimeMillis();
@@ -80,7 +80,7 @@
}
Thread* thread;
- std::unique_ptr<AsyncUDPSocket> socket;
+ std::unique_ptr<webrtc::AsyncUDPSocket> socket;
rtc::PacketOptions options;
RepeatingTaskHandle periodic;
uint32_t rate; // bytes per second
@@ -90,9 +90,9 @@
};
struct Receiver : public sigslot::has_slots<> {
- Receiver(Thread* th, Socket* s, uint32_t bw)
+ Receiver(Thread* th, webrtc::Socket* s, uint32_t bw)
: thread(th),
- socket(std::make_unique<AsyncUDPSocket>(s)),
+ socket(std::make_unique<webrtc::AsyncUDPSocket>(s)),
bandwidth(bw),
count(0),
sec_count(0),
@@ -117,7 +117,8 @@
~Receiver() override { periodic.Stop(); }
- void OnReadPacket(AsyncPacketSocket* s, const rtc::ReceivedPacket& packet) {
+ void OnReadPacket(webrtc::AsyncPacketSocket* s,
+ const rtc::ReceivedPacket& packet) {
ASSERT_EQ(socket.get(), s);
ASSERT_GE(packet.payload().size(), 4U);
@@ -134,7 +135,7 @@
}
Thread* thread;
- std::unique_ptr<AsyncUDPSocket> socket;
+ std::unique_ptr<webrtc::AsyncUDPSocket> socket;
uint32_t bandwidth;
RepeatingTaskHandle periodic;
size_t count;
@@ -179,21 +180,23 @@
ss_.SetDefaultSourceAddress(default_address);
// Create client1 bound to the any address.
- Socket* socket = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ webrtc::Socket* socket =
+ ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
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_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the address route.
- Socket* socket2 = ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
+ webrtc::Socket* socket2 =
+ ss_.CreateSocket(default_address.family(), SOCK_DGRAM);
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_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
// Client1 sends to client2, client2 should see the default address as
// client1's address.
@@ -209,17 +212,19 @@
}
void BasicTest(const webrtc::SocketAddress& initial_addr) {
- Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ webrtc::Socket* socket =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr);
webrtc::SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
- Socket* socket2 = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
+ webrtc::Socket* socket2 =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
auto client2 = std::make_unique<webrtc::TestClient>(
- std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
webrtc::SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -234,7 +239,8 @@
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_);
+ absl::WrapUnique(webrtc::AsyncUDPSocket::Create(&ss_, empty)),
+ &fake_clock_);
webrtc::SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -259,21 +265,21 @@
webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<Socket> client =
+ std::unique_ptr<webrtc::Socket> client =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server
- std::unique_ptr<Socket> server =
+ std::unique_ptr<webrtc::Socket> server =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
EXPECT_EQ(0, server->Listen(5));
- EXPECT_EQ(server->GetState(), Socket::CS_CONNECTING);
+ EXPECT_EQ(server->GetState(), webrtc::Socket::CS_CONNECTING);
// No pending server connections
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
@@ -287,33 +293,33 @@
EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
// Client is connecting
- EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
ss_.ProcessMessagesUntilIdle();
// Client still connecting
- EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<Socket> accepted =
+ std::unique_ptr<webrtc::Socket> accepted =
absl::WrapUnique(server->Accept(&accept_addr));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(accept_addr, kEmptyAddr);
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
- EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED);
+ EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CONNECTED);
EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
ss_.ProcessMessagesUntilIdle();
// Client has connected
- EXPECT_EQ(client->GetState(), Socket::CS_CONNECTED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTED);
EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@@ -328,12 +334,12 @@
webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<Socket> client =
+ std::unique_ptr<webrtc::Socket> client =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server
- std::unique_ptr<Socket> server =
+ std::unique_ptr<webrtc::Socket> server =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(initial_addr));
@@ -349,7 +355,7 @@
EXPECT_EQ(accept_addr, nil_addr);
// Connection failed
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
@@ -362,10 +368,10 @@
webrtc::EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
- std::unique_ptr<Socket> client(
+ std::unique_ptr<webrtc::Socket> client(
ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- std::unique_ptr<Socket> server(
+ std::unique_ptr<webrtc::Socket> server(
ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
@@ -383,7 +389,7 @@
ss_.ProcessMessagesUntilIdle();
// Result: connection failed
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
@@ -405,7 +411,7 @@
ss_.ProcessMessagesUntilIdle();
// Result: connection failed
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server
@@ -423,21 +429,21 @@
// Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<webrtc::Socket> accepted(server->Accept(&accept_addr));
ASSERT_TRUE(nullptr != accepted.get());
sink.Monitor(accepted.get());
// Client closes before connection complets
- EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED);
+ EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CONNECTED);
// Connected message has not been processed yet.
- EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CONNECTING);
client->Close();
ss_.ProcessMessagesUntilIdle();
// Result: accepted socket closes
- EXPECT_EQ(accepted->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(accepted->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
}
@@ -447,13 +453,13 @@
const webrtc::SocketAddress kEmptyAddr;
// Create clients
- std::unique_ptr<Socket> a =
+ std::unique_ptr<webrtc::Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<Socket> b =
+ std::unique_ptr<webrtc::Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
@@ -465,11 +471,11 @@
ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN));
- EXPECT_EQ(a->GetState(), Socket::CS_CONNECTED);
+ EXPECT_EQ(a->GetState(), webrtc::Socket::CS_CONNECTED);
EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN));
- EXPECT_EQ(b->GetState(), Socket::CS_CONNECTED);
+ EXPECT_EQ(b->GetState(), webrtc::Socket::CS_CONNECTED);
EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress());
EXPECT_EQ(1, a->Send("a", 1));
@@ -483,12 +489,12 @@
EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE));
- EXPECT_EQ(a->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(a->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
// No signal for Closer
EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE));
- EXPECT_EQ(b->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(b->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
}
@@ -497,13 +503,13 @@
const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<Socket> a =
+ std::unique_ptr<webrtc::Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<Socket> b =
+ std::unique_ptr<webrtc::Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
@@ -619,9 +625,9 @@
const webrtc::SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<Socket> a =
+ std::unique_ptr<webrtc::Socket> a =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
- std::unique_ptr<Socket> b =
+ std::unique_ptr<webrtc::Socket> b =
absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@@ -673,8 +679,10 @@
// incremental port behavior could ensure the 2 Binds result in different
// address.
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);
+ webrtc::Socket* send_socket =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ webrtc::Socket* recv_socket =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -716,8 +724,10 @@
ss_.set_delay_stddev(stddev);
ss_.UpdateDelayDistribution();
- Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
- Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ webrtc::Socket* send_socket =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
+ webrtc::Socket* recv_socket =
+ ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@@ -767,16 +777,16 @@
const webrtc::SocketAddress kEmptyAddr;
// Client gets a IPv4 address
- std::unique_ptr<Socket> client =
+ std::unique_ptr<webrtc::Socket> client =
absl::WrapUnique(ss_.CreateSocket(client_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
client->Bind(client_addr);
// Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this.
- std::unique_ptr<Socket> server =
+ std::unique_ptr<webrtc::Socket> server =
absl::WrapUnique(ss_.CreateSocket(server_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
server->Bind(server_addr);
@@ -786,7 +796,7 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<Socket> accepted =
+ std::unique_ptr<webrtc::Socket> accepted =
absl::WrapUnique(server->Accept(&accept_address));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
@@ -801,7 +811,7 @@
EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_address));
EXPECT_EQ(accept_address, kEmptyAddr);
- EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
+ EXPECT_EQ(client->GetState(), webrtc::Socket::CS_CLOSED);
EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
}
@@ -813,16 +823,16 @@
void CrossFamilyDatagramTest(const webrtc::SocketAddress& client_addr,
const webrtc::SocketAddress& server_addr,
bool shouldSucceed) {
- Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ webrtc::Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
webrtc::SocketAddress bound_server_addr = socket->GetLocalAddress();
auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket), &fake_clock_);
- Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
+ webrtc::Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket2->Bind(client_addr);
auto client2 = std::make_unique<webrtc::TestClient>(
- std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket2), &fake_clock_);
webrtc::SocketAddress client2_addr;
if (shouldSucceed) {
@@ -840,7 +850,7 @@
protected:
webrtc::ScopedFakeClock fake_clock_;
- VirtualSocketServer ss_;
+ webrtc::VirtualSocketServer ss_;
AutoSocketServerThread thread_;
const webrtc::SocketAddress kIPv4AnyAddress;
const webrtc::SocketAddress kIPv6AnyAddress;
@@ -1025,13 +1035,14 @@
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
- Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
- std::unique_ptr<Socket> socket2 =
+ webrtc::Socket* socket1 =
+ ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ std::unique_ptr<webrtc::Socket> socket2 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
auto client1 = std::make_unique<webrtc::TestClient>(
- std::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
+ std::make_unique<webrtc::AsyncUDPSocket>(socket1), &fake_clock_);
ss_.SetSendingBlocked(true);
EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
@@ -1049,9 +1060,9 @@
ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink;
- std::unique_ptr<Socket> socket1 =
+ std::unique_ptr<webrtc::Socket> socket1 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
- std::unique_ptr<Socket> socket2 =
+ std::unique_ptr<webrtc::Socket> socket2 =
absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
sink.Monitor(socket1.get());
sink.Monitor(socket2.get());
@@ -1098,9 +1109,9 @@
ASSERT_LT(0u, kTestSamples[sidx]);
const uint32_t kStdDev =
static_cast<uint32_t>(kTestDev[didx] * kTestMean[midx]);
- std::unique_ptr<VirtualSocketServer::Function> f =
- VirtualSocketServer::CreateDistribution(kTestMean[midx], kStdDev,
- kTestSamples[sidx]);
+ std::unique_ptr<webrtc::VirtualSocketServer::Function> f =
+ webrtc::VirtualSocketServer::CreateDistribution(
+ kTestMean[midx], kStdDev, kTestSamples[sidx]);
ASSERT_TRUE(nullptr != f.get());
ASSERT_EQ(kTestSamples[sidx], f->size());
double sum = 0;
diff --git a/rtc_tools/network_tester/server.cc b/rtc_tools/network_tester/server.cc
index a6cd09f..781b8b0 100644
--- a/rtc_tools/network_tester/server.cc
+++ b/rtc_tools/network_tester/server.cc
@@ -13,7 +13,7 @@
#include "rtc_tools/network_tester/test_controller.h"
int main(int /*argn*/, char* /*argv*/[]) {
- rtc::Thread main_thread(std::make_unique<rtc::NullSocketServer>());
+ rtc::Thread main_thread(std::make_unique<webrtc::NullSocketServer>());
webrtc::TestController server(9090, 9090, "server_config.dat",
"server_packet_log.dat");
while (!server.IsTestDone()) {
diff --git a/rtc_tools/network_tester/test_controller.cc b/rtc_tools/network_tester/test_controller.cc
index d5cd499..3150d5f 100644
--- a/rtc_tools/network_tester/test_controller.cc
+++ b/rtc_tools/network_tester/test_controller.cc
@@ -43,7 +43,7 @@
packet_sender_thread_->BlockingCall([&] {
RTC_DCHECK_RUN_ON(packet_sender_thread_.get());
udp_socket_ =
- std::unique_ptr<rtc::AsyncPacketSocket>(socket_factory_.CreateUdpSocket(
+ std::unique_ptr<AsyncPacketSocket>(socket_factory_.CreateUdpSocket(
SocketAddress(GetAnyIP(AF_INET), 0), min_port, max_port));
RTC_CHECK(udp_socket_ != nullptr);
udp_socket_->RegisterReceivedPacketCallback(
@@ -107,7 +107,7 @@
return local_test_done_ && remote_test_done_;
}
-void TestController::OnReadPacket(rtc::AsyncPacketSocket* socket,
+void TestController::OnReadPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& received_packet) {
RTC_DCHECK_RUN_ON(packet_sender_thread_.get());
RTC_LOG(LS_VERBOSE) << "OnReadPacket";
diff --git a/rtc_tools/network_tester/test_controller.h b/rtc_tools/network_tester/test_controller.h
index 0c77fea..e18c8a0 100644
--- a/rtc_tools/network_tester/test_controller.h
+++ b/rtc_tools/network_tester/test_controller.h
@@ -64,12 +64,12 @@
bool IsTestDone();
private:
- void OnReadPacket(rtc::AsyncPacketSocket* socket,
+ void OnReadPacket(AsyncPacketSocket* socket,
const rtc::ReceivedPacket& received_packet);
RTC_NO_UNIQUE_ADDRESS SequenceChecker test_controller_thread_checker_;
std::unique_ptr<rtc::SocketServer> socket_server_;
std::unique_ptr<rtc::Thread> packet_sender_thread_;
- rtc::BasicPacketSocketFactory socket_factory_
+ BasicPacketSocketFactory socket_factory_
RTC_GUARDED_BY(packet_sender_thread_);
const std::string config_file_path_;
PacketLogger packet_logger_ RTC_GUARDED_BY(packet_sender_thread_);
@@ -78,7 +78,7 @@
bool remote_test_done_ RTC_GUARDED_BY(test_done_lock_);
std::array<char, kEthernetMtu> send_data_
RTC_GUARDED_BY(packet_sender_thread_);
- std::unique_ptr<rtc::AsyncPacketSocket> udp_socket_
+ std::unique_ptr<AsyncPacketSocket> udp_socket_
RTC_GUARDED_BY(packet_sender_thread_);
SocketAddress remote_address_;
std::unique_ptr<PacketSender> packet_sender_
diff --git a/sdk/android/native_api/peerconnection/peer_connection_factory.cc b/sdk/android/native_api/peerconnection/peer_connection_factory.cc
index 87ab991..3c2abee 100644
--- a/sdk/android/native_api/peerconnection/peer_connection_factory.cc
+++ b/sdk/android/native_api/peerconnection/peer_connection_factory.cc
@@ -21,7 +21,7 @@
jobject NativeToJavaPeerConnectionFactory(
JNIEnv* jni,
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread) {
diff --git a/sdk/android/native_api/peerconnection/peer_connection_factory.h b/sdk/android/native_api/peerconnection/peer_connection_factory.h
index 959eb79..4994aaa 100644
--- a/sdk/android/native_api/peerconnection/peer_connection_factory.h
+++ b/sdk/android/native_api/peerconnection/peer_connection_factory.h
@@ -24,7 +24,7 @@
jobject NativeToJavaPeerConnectionFactory(
JNIEnv* jni,
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread);
diff --git a/sdk/android/src/jni/pc/owned_factory_and_threads.cc b/sdk/android/src/jni/pc/owned_factory_and_threads.cc
index d595c48..e4e379c 100644
--- a/sdk/android/src/jni/pc/owned_factory_and_threads.cc
+++ b/sdk/android/src/jni/pc/owned_factory_and_threads.cc
@@ -16,7 +16,7 @@
namespace jni {
OwnedFactoryAndThreads::OwnedFactoryAndThreads(
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread,
diff --git a/sdk/android/src/jni/pc/owned_factory_and_threads.h b/sdk/android/src/jni/pc/owned_factory_and_threads.h
index 865063d..83d386c 100644
--- a/sdk/android/src/jni/pc/owned_factory_and_threads.h
+++ b/sdk/android/src/jni/pc/owned_factory_and_threads.h
@@ -31,7 +31,7 @@
class OwnedFactoryAndThreads {
public:
OwnedFactoryAndThreads(
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread,
@@ -40,7 +40,7 @@
~OwnedFactoryAndThreads() = default;
PeerConnectionFactoryInterface* factory() { return factory_.get(); }
- rtc::SocketFactory* socket_factory() { return socket_factory_.get(); }
+ SocketFactory* socket_factory() { return socket_factory_.get(); }
rtc::Thread* network_thread() { return network_thread_.get(); }
rtc::Thread* signaling_thread() { return signaling_thread_.get(); }
rtc::Thread* worker_thread() { return worker_thread_.get(); }
@@ -48,7 +48,7 @@
private:
// Usually implemented by the SocketServer associated with the network thread,
// so needs to outlive the network thread.
- const std::unique_ptr<rtc::SocketFactory> socket_factory_;
+ const std::unique_ptr<SocketFactory> socket_factory_;
const std::unique_ptr<rtc::Thread> network_thread_;
const std::unique_ptr<rtc::Thread> worker_thread_;
const std::unique_ptr<rtc::Thread> signaling_thread_;
diff --git a/sdk/android/src/jni/pc/peer_connection_factory.cc b/sdk/android/src/jni/pc/peer_connection_factory.cc
index d6219c2..c5ead55 100644
--- a/sdk/android/src/jni/pc/peer_connection_factory.cc
+++ b/sdk/android/src/jni/pc/peer_connection_factory.cc
@@ -114,7 +114,7 @@
ScopedJavaLocalRef<jobject> NativeToScopedJavaPeerConnectionFactory(
JNIEnv* env,
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread) {
@@ -154,7 +154,7 @@
jobject NativeToJavaPeerConnectionFactory(
JNIEnv* jni,
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread) {
@@ -249,7 +249,7 @@
// think about ramifications of auto-wrapping there.
rtc::ThreadManager::Instance()->WrapCurrentThread();
- auto socket_server = std::make_unique<rtc::PhysicalSocketServer>();
+ auto socket_server = std::make_unique<PhysicalSocketServer>();
auto network_thread = std::make_unique<rtc::Thread>(socket_server.get());
network_thread->SetName("network_thread", nullptr);
RTC_CHECK(network_thread->Start()) << "Failed to start thread";
diff --git a/sdk/android/src/jni/pc/peer_connection_factory.h b/sdk/android/src/jni/pc/peer_connection_factory.h
index 337d32a..211b0dd 100644
--- a/sdk/android/src/jni/pc/peer_connection_factory.h
+++ b/sdk/android/src/jni/pc/peer_connection_factory.h
@@ -23,7 +23,7 @@
jobject NativeToJavaPeerConnectionFactory(
JNIEnv* jni,
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> pcf,
- std::unique_ptr<rtc::SocketFactory> socket_factory,
+ std::unique_ptr<SocketFactory> socket_factory,
std::unique_ptr<rtc::Thread> network_thread,
std::unique_ptr<rtc::Thread> worker_thread,
std::unique_ptr<rtc::Thread> signaling_thread);
diff --git a/test/network/emulated_turn_server.cc b/test/network/emulated_turn_server.cc
index b4ae8f2..e2a6ad5 100644
--- a/test/network/emulated_turn_server.cc
+++ b/test/network/emulated_turn_server.cc
@@ -39,7 +39,7 @@
static const char kTestSoftware[] = "TestTurnServer";
// A wrapper class for cricket::TurnServer to allocate sockets.
-class PacketSocketFactoryWrapper : public rtc::PacketSocketFactory {
+class PacketSocketFactoryWrapper : public webrtc::PacketSocketFactory {
public:
explicit PacketSocketFactoryWrapper(
webrtc::test::EmulatedTURNServer* turn_server)
@@ -48,23 +48,24 @@
// This method is called from TurnServer when making a TURN ALLOCATION.
// It will create a socket on the `peer_` endpoint.
- rtc::AsyncPacketSocket* CreateUdpSocket(const webrtc::SocketAddress& address,
- uint16_t min_port,
- uint16_t max_port) override {
+ webrtc::AsyncPacketSocket* CreateUdpSocket(
+ const webrtc::SocketAddress& address,
+ uint16_t min_port,
+ uint16_t max_port) override {
return turn_server_->CreatePeerSocket();
}
- rtc::AsyncListenSocket* CreateServerTcpSocket(
+ webrtc::AsyncListenSocket* CreateServerTcpSocket(
const webrtc::SocketAddress& local_address,
uint16_t min_port,
uint16_t max_port,
int opts) override {
return nullptr;
}
- rtc::AsyncPacketSocket* CreateClientTcpSocket(
+ webrtc::AsyncPacketSocket* CreateClientTcpSocket(
const webrtc::SocketAddress& local_address,
const webrtc::SocketAddress& remote_address,
- const rtc::PacketSocketTcpOptions& tcp_options) override {
+ const webrtc::PacketSocketTcpOptions& tcp_options) override {
return nullptr;
}
std::unique_ptr<webrtc::AsyncDnsResolverInterface> CreateAsyncDnsResolver()
@@ -84,8 +85,7 @@
// A wrapper class for copying data between an AsyncPacketSocket and a
// EmulatedEndpoint. This is used by the cricket::TurnServer when
// sending data back into the emulated network.
-class EmulatedTURNServer::AsyncPacketSocketWrapper
- : public rtc::AsyncPacketSocket {
+class EmulatedTURNServer::AsyncPacketSocketWrapper : public AsyncPacketSocket {
public:
AsyncPacketSocketWrapper(webrtc::test::EmulatedTURNServer* turn_server,
webrtc::EmulatedEndpoint* endpoint,
@@ -114,14 +114,14 @@
}
int Close() override { return 0; }
void NotifyPacketReceived(const rtc::ReceivedPacket& packet) {
- rtc::AsyncPacketSocket::NotifyPacketReceived(packet);
+ AsyncPacketSocket::NotifyPacketReceived(packet);
}
- rtc::AsyncPacketSocket::State GetState() const override {
- return rtc::AsyncPacketSocket::STATE_BOUND;
+ AsyncPacketSocket::State GetState() const override {
+ return AsyncPacketSocket::STATE_BOUND;
}
- int GetOption(rtc::Socket::Option opt, int* value) override { return 0; }
- int SetOption(rtc::Socket::Option opt, int value) override { return 0; }
+ int GetOption(Socket::Option opt, int* value) override { return 0; }
+ int SetOption(Socket::Option opt, int value) override { return 0; }
int GetError() const override { return 0; }
void SetError(int error) override {}
@@ -174,7 +174,7 @@
});
}
-rtc::AsyncPacketSocket* EmulatedTURNServer::Wrap(EmulatedEndpoint* endpoint) {
+AsyncPacketSocket* EmulatedTURNServer::Wrap(EmulatedEndpoint* endpoint) {
RTC_DCHECK_RUN_ON(thread_.get());
auto port = endpoint->BindReceiver(0, this).value();
auto socket = new AsyncPacketSocketWrapper(this, endpoint, port);
diff --git a/test/network/emulated_turn_server.h b/test/network/emulated_turn_server.h
index eedd86b..dc77cd2 100644
--- a/test/network/emulated_turn_server.h
+++ b/test/network/emulated_turn_server.h
@@ -70,7 +70,7 @@
std::string(username), std::string(realm), std::string(username), key);
}
- rtc::AsyncPacketSocket* CreatePeerSocket() { return Wrap(peer_); }
+ AsyncPacketSocket* CreatePeerSocket() { return Wrap(peer_); }
// This method is called by network emulation when a packet
// comes from an emulated link.
@@ -95,7 +95,7 @@
// Wraps a EmulatedEndpoint in a AsyncPacketSocket to bridge interaction
// with TurnServer. cricket::TurnServer gets ownership of the socket.
- rtc::AsyncPacketSocket* Wrap(EmulatedEndpoint* endpoint);
+ AsyncPacketSocket* Wrap(EmulatedEndpoint* endpoint);
};
} // namespace test
diff --git a/test/network/fake_network_socket_server.cc b/test/network/fake_network_socket_server.cc
index 16fac0b..5fc6cbb 100644
--- a/test/network/fake_network_socket_server.cc
+++ b/test/network/fake_network_socket_server.cc
@@ -48,7 +48,7 @@
} // namespace
// Represents a socket, which will operate with emulated network.
-class FakeNetworkSocket : public rtc::Socket,
+class FakeNetworkSocket : public Socket,
public EmulatedNetworkReceiverInterface {
public:
explicit FakeNetworkSocket(FakeNetworkSocketServer* scoket_manager,
@@ -72,7 +72,7 @@
}
int RecvFrom(ReceiveBuffer& buffer) override;
int Listen(int backlog) override;
- rtc::Socket* Accept(SocketAddress* paddr) override;
+ Socket* Accept(SocketAddress* paddr) override;
int GetError() const override;
void SetError(int error) override;
ConnState GetState() const override;
@@ -215,7 +215,7 @@
RTC_CHECK(false) << "Listen() isn't valid for SOCK_DGRAM";
}
-rtc::Socket* FakeNetworkSocket::Accept(SocketAddress* /*paddr*/) {
+Socket* FakeNetworkSocket::Accept(SocketAddress* /*paddr*/) {
RTC_CHECK(false) << "Accept() isn't valid for SOCK_DGRAM";
}
@@ -241,7 +241,7 @@
error_ = error;
}
-rtc::Socket::ConnState FakeNetworkSocket::GetState() const {
+Socket::ConnState FakeNetworkSocket::GetState() const {
RTC_DCHECK_RUN_ON(thread_);
return state_;
}
@@ -278,7 +278,7 @@
sockets_.erase(absl::c_find(sockets_, socket));
}
-rtc::Socket* FakeNetworkSocketServer::CreateSocket(int family, int type) {
+Socket* FakeNetworkSocketServer::CreateSocket(int family, int type) {
RTC_DCHECK(family == AF_INET || family == AF_INET6);
// We support only UDP sockets for now.
RTC_DCHECK(type == SOCK_DGRAM) << "Only UDP sockets are supported";
diff --git a/test/network/fake_network_socket_server.h b/test/network/fake_network_socket_server.h
index 270fac6..dbc6bb1 100644
--- a/test/network/fake_network_socket_server.h
+++ b/test/network/fake_network_socket_server.h
@@ -33,7 +33,7 @@
~FakeNetworkSocketServer() override;
// rtc::SocketFactory methods:
- rtc::Socket* CreateSocket(int family, int type) override;
+ Socket* CreateSocket(int family, int type) override;
// rtc::SocketServer methods:
// Called by the network thread when this server is installed, kicking off the
diff --git a/test/network/network_emulation_unittest.cc b/test/network/network_emulation_unittest.cc
index bde398a..eee94c0 100644
--- a/test/network/network_emulation_unittest.cc
+++ b/test/network/network_emulation_unittest.cc
@@ -64,16 +64,16 @@
class SocketReader : public sigslot::has_slots<> {
public:
- explicit SocketReader(rtc::Socket* socket, rtc::Thread* network_thread)
+ explicit SocketReader(Socket* socket, rtc::Thread* network_thread)
: socket_(socket), network_thread_(network_thread) {
socket_->SignalReadEvent.connect(this, &SocketReader::OnReadEvent);
}
- void OnReadEvent(rtc::Socket* socket) {
+ void OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_ == socket);
RTC_DCHECK(network_thread_->IsCurrent());
- rtc::Socket::ReceiveBuffer receive_buffer(payload_);
+ Socket::ReceiveBuffer receive_buffer(payload_);
socket_->RecvFrom(receive_buffer);
last_ecn_mark_ = receive_buffer.ecn;
@@ -92,7 +92,7 @@
}
private:
- rtc::Socket* const socket_;
+ Socket* const socket_;
rtc::Thread* const network_thread_;
rtc::Buffer payload_;
webrtc::EcnMarking last_ecn_mark_;
@@ -253,8 +253,8 @@
rtc::CopyOnWriteBuffer data("Hello");
for (uint64_t j = 0; j < 2; j++) {
- rtc::Socket* s1 = nullptr;
- rtc::Socket* s2 = nullptr;
+ Socket* s1 = nullptr;
+ Socket* s2 = nullptr;
SendTask(t1, [&] {
s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
});
@@ -406,8 +406,8 @@
rtc::Thread* t1 = nt1->network_thread();
rtc::Thread* t2 = nt2->network_thread();
- rtc::Socket* s1 = nullptr;
- rtc::Socket* s2 = nullptr;
+ Socket* s1 = nullptr;
+ Socket* s2 = nullptr;
SendTask(t1,
[&] { s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); });
SendTask(t2,
@@ -432,7 +432,7 @@
SendTask(t2, [&] { s2->Connect(a1); });
t1->PostTask([&]() {
- s1->SetOption(rtc::Socket::Option::OPT_SEND_ECN, 1);
+ s1->SetOption(Socket::Option::OPT_SEND_ECN, 1);
rtc::CopyOnWriteBuffer data("Hello");
s1->Send(data.data(), data.size());
});
@@ -494,8 +494,8 @@
rtc::CopyOnWriteBuffer data("Hello");
for (uint64_t j = 0; j < 2; j++) {
- rtc::Socket* s1 = nullptr;
- rtc::Socket* s2 = nullptr;
+ Socket* s1 = nullptr;
+ Socket* s2 = nullptr;
SendTask(t1, [&] {
s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
});
@@ -597,8 +597,8 @@
constexpr int64_t kSinglePacketSize = kUdpPayloadSize + kOverheadIpv4Udp;
rtc::CopyOnWriteBuffer data(kUdpPayloadSize);
- rtc::Socket* s1 = nullptr;
- rtc::Socket* s2 = nullptr;
+ Socket* s1 = nullptr;
+ Socket* s2 = nullptr;
SendTask(t1,
[&] { s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); });
SendTask(t2,
diff --git a/test/peer_scenario/scenario_connection.cc b/test/peer_scenario/scenario_connection.cc
index 40ee4c5..82eba21 100644
--- a/test/peer_scenario/scenario_connection.cc
+++ b/test/peer_scenario/scenario_connection.cc
@@ -97,7 +97,7 @@
cricket::TransportDescription const transport_description_
RTC_GUARDED_BY(signaling_thread_);
std::unique_ptr<rtc::NetworkManager> network_manager_;
- rtc::BasicPacketSocketFactory packet_socket_factory_;
+ BasicPacketSocketFactory packet_socket_factory_;
std::unique_ptr<cricket::BasicPortAllocator> port_allocator_
RTC_GUARDED_BY(network_thread_);
PayloadTypePicker payload_type_picker_;
diff --git a/test/run_loop.cc b/test/run_loop.cc
index 7cc80ab..7420006 100644
--- a/test/run_loop.cc
+++ b/test/run_loop.cc
@@ -62,11 +62,11 @@
void RunLoop::FakeSocketServer::WakeUp() {}
-rtc::Socket* RunLoop::FakeSocketServer::CreateSocket(int family, int type) {
+Socket* RunLoop::FakeSocketServer::CreateSocket(int family, int type) {
return nullptr;
}
-RunLoop::WorkerThread::WorkerThread(rtc::SocketServer* ss)
+RunLoop::WorkerThread::WorkerThread(SocketServer* ss)
: rtc::Thread(ss), tq_setter_(this) {}
} // namespace test
diff --git a/test/run_loop.h b/test/run_loop.h
index 8a2bf54..828a104 100644
--- a/test/run_loop.h
+++ b/test/run_loop.h
@@ -39,7 +39,7 @@
}
private:
- class FakeSocketServer : public rtc::SocketServer {
+ class FakeSocketServer : public SocketServer {
public:
FakeSocketServer();
~FakeSocketServer();
@@ -50,7 +50,7 @@
bool Wait(webrtc::TimeDelta max_wait_duration, bool process_io) override;
void WakeUp() override;
- rtc::Socket* CreateSocket(int family, int type) override;
+ Socket* CreateSocket(int family, int type) override;
private:
bool fail_next_wait_ = false;
@@ -58,7 +58,7 @@
class WorkerThread : public rtc::Thread {
public:
- explicit WorkerThread(rtc::SocketServer* ss);
+ explicit WorkerThread(SocketServer* ss);
private:
CurrentTaskQueueSetter tq_setter_;
diff --git a/test/time_controller/real_time_controller.cc b/test/time_controller/real_time_controller.cc
index 537532d..275e90f 100644
--- a/test/time_controller/real_time_controller.cc
+++ b/test/time_controller/real_time_controller.cc
@@ -18,7 +18,7 @@
class MainThread : public rtc::Thread {
public:
MainThread()
- : Thread(std::make_unique<rtc::NullSocketServer>(), false),
+ : Thread(std::make_unique<NullSocketServer>(), false),
current_setter_(this) {
DoInit();
}
@@ -47,9 +47,9 @@
std::unique_ptr<rtc::Thread> RealTimeController::CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server) {
+ std::unique_ptr<SocketServer> socket_server) {
if (!socket_server)
- socket_server = std::make_unique<rtc::NullSocketServer>();
+ socket_server = std::make_unique<NullSocketServer>();
auto res = std::make_unique<rtc::Thread>(std::move(socket_server));
res->SetName(name, nullptr);
res->Start();
diff --git a/test/time_controller/real_time_controller.h b/test/time_controller/real_time_controller.h
index 0085732..1f6b001 100644
--- a/test/time_controller/real_time_controller.h
+++ b/test/time_controller/real_time_controller.h
@@ -28,7 +28,7 @@
TaskQueueFactory* GetTaskQueueFactory() override;
std::unique_ptr<rtc::Thread> CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server) override;
+ std::unique_ptr<SocketServer> socket_server) override;
rtc::Thread* GetMainThread() override;
void AdvanceTime(TimeDelta duration) override;
diff --git a/test/time_controller/simulated_thread.cc b/test/time_controller/simulated_thread.cc
index 80ff830..26292fc 100644
--- a/test/time_controller/simulated_thread.cc
+++ b/test/time_controller/simulated_thread.cc
@@ -18,9 +18,9 @@
// A socket server that does nothing. It's different from NullSocketServer in
// that it does allow sleep/wakeup. This avoids usage of an Event instance which
// otherwise would cause issues with the simulated Yeild behavior.
-class DummySocketServer : public rtc::SocketServer {
+class DummySocketServer : public SocketServer {
public:
- rtc::Socket* CreateSocket(int family, int type) override {
+ Socket* CreateSocket(int family, int type) override {
RTC_DCHECK_NOTREACHED();
return nullptr;
}
@@ -36,7 +36,7 @@
SimulatedThread::SimulatedThread(
sim_time_impl::SimulatedTimeControllerImpl* handler,
absl::string_view name,
- std::unique_ptr<rtc::SocketServer> socket_server)
+ std::unique_ptr<SocketServer> socket_server)
: rtc::Thread(socket_server ? std::move(socket_server)
: std::make_unique<DummySocketServer>()),
handler_(handler),
diff --git a/test/time_controller/simulated_thread.h b/test/time_controller/simulated_thread.h
index 77bd701..883f976 100644
--- a/test/time_controller/simulated_thread.h
+++ b/test/time_controller/simulated_thread.h
@@ -23,7 +23,7 @@
using CurrentThreadSetter = CurrentThreadSetter;
SimulatedThread(sim_time_impl::SimulatedTimeControllerImpl* handler,
absl::string_view name,
- std::unique_ptr<rtc::SocketServer> socket_server);
+ std::unique_ptr<SocketServer> socket_server);
~SimulatedThread() override;
void RunReady(Timestamp at_time) override;
diff --git a/test/time_controller/simulated_time_controller.cc b/test/time_controller/simulated_time_controller.cc
index ff4baed..0683988 100644
--- a/test/time_controller/simulated_time_controller.cc
+++ b/test/time_controller/simulated_time_controller.cc
@@ -55,7 +55,7 @@
std::unique_ptr<rtc::Thread> SimulatedTimeControllerImpl::CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server) {
+ std::unique_ptr<SocketServer> socket_server) {
auto thread =
std::make_unique<SimulatedThread>(this, name, std::move(socket_server));
Register(thread.get());
@@ -184,7 +184,7 @@
std::unique_ptr<rtc::Thread> GlobalSimulatedTimeController::CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server) {
+ std::unique_ptr<SocketServer> socket_server) {
return impl_.CreateThread(name, std::move(socket_server));
}
diff --git a/test/time_controller/simulated_time_controller.h b/test/time_controller/simulated_time_controller.h
index c070146..70ece0e 100644
--- a/test/time_controller/simulated_time_controller.h
+++ b/test/time_controller/simulated_time_controller.h
@@ -60,7 +60,7 @@
// Create thread using provided `socket_server`.
std::unique_ptr<rtc::Thread> CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server)
+ std::unique_ptr<SocketServer> socket_server)
RTC_LOCKS_EXCLUDED(time_lock_, lock_);
// Runs all runners in `runners_` that has tasks or modules ready for
@@ -133,7 +133,7 @@
TaskQueueFactory* GetTaskQueueFactory() override;
std::unique_ptr<rtc::Thread> CreateThread(
const std::string& name,
- std::unique_ptr<rtc::SocketServer> socket_server) override;
+ std::unique_ptr<SocketServer> socket_server) override;
rtc::Thread* GetMainThread() override;
void AdvanceTime(TimeDelta duration) override;
