From d0b88797705cfc6c1d60ad325d1923f326f10de1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Niels=20M=C3=B6ller?= Date: Thu, 12 Aug 2021 10:32:30 +0200 Subject: [PATCH] Delete AsyncSocket class, merge into Socket class Bug: webrtc:13065 Change-Id: I13afee2386ea9c4de0e4fa95133f0c4d3ec826e8 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/227031 Reviewed-by: Harald Alvestrand Reviewed-by: Mirko Bonadei Commit-Queue: Niels Moller Cr-Commit-Position: refs/heads/master@{#34787} --- .../androidvoip/jni/android_voip_client.cc | 4 +- .../client/peer_connection_client.cc | 16 +- .../client/peer_connection_client.h | 16 +- p2p/BUILD.gn | 4 +- p2p/base/async_stun_tcp_socket.cc | 6 +- p2p/base/async_stun_tcp_socket.h | 8 +- p2p/base/async_stun_tcp_socket_unittest.cc | 8 +- p2p/base/basic_packet_socket_factory.cc | 13 +- p2p/base/basic_packet_socket_factory.h | 4 +- p2p/base/port_unittest.cc | 5 +- p2p/base/stun_server.h | 2 +- p2p/base/test_stun_server.cc | 4 +- p2p/base/test_turn_server.h | 4 +- p2p/base/turn_port_unittest.cc | 6 +- p2p/base/turn_server.cc | 10 +- p2p/base/turn_server.h | 8 +- rtc_base/BUILD.gn | 12 +- rtc_base/async_socket.cc | 18 +- rtc_base/async_socket.h | 41 +--- rtc_base/async_tcp_socket.cc | 24 +- rtc_base/async_tcp_socket.h | 27 +-- rtc_base/async_tcp_socket_unittest.cc | 4 +- rtc_base/async_udp_socket.cc | 13 +- rtc_base/async_udp_socket.h | 11 +- rtc_base/async_udp_socket_unittest.cc | 4 +- rtc_base/firewall_socket_server.cc | 14 +- rtc_base/firewall_socket_server.h | 3 - rtc_base/nat_server.cc | 4 +- rtc_base/nat_socket_factory.cc | 48 ++-- rtc_base/nat_socket_factory.h | 27 +-- rtc_base/nat_unittest.cc | 26 +- rtc_base/network.cc | 4 +- rtc_base/network_unittest.cc | 2 +- rtc_base/null_socket_server.cc | 6 - rtc_base/null_socket_server.h | 2 - rtc_base/openssl_adapter.cc | 28 +-- rtc_base/openssl_adapter.h | 15 +- rtc_base/openssl_adapter_unittest.cc | 12 +- rtc_base/physical_socket_server.cc | 16 +- rtc_base/physical_socket_server.h | 7 +- rtc_base/physical_socket_server_unittest.cc | 41 ++-- rtc_base/proxy_server.cc | 32 +-- rtc_base/proxy_server.h | 32 +-- rtc_base/proxy_unittest.cc | 4 +- rtc_base/server_socket_adapters.cc | 6 +- rtc_base/server_socket_adapters.h | 6 +- rtc_base/socket.h | 17 ++ rtc_base/socket_adapters.cc | 18 +- rtc_base/socket_adapters.h | 18 +- rtc_base/socket_factory.h | 11 +- rtc_base/socket_stream.cc | 16 +- rtc_base/socket_stream.h | 20 +- rtc_base/socket_unittest.cc | 222 +++++++++--------- rtc_base/ssl_adapter.cc | 2 +- rtc_base/ssl_adapter.h | 6 +- rtc_base/ssl_adapter_unittest.cc | 37 ++- rtc_base/test_client_unittest.cc | 10 +- rtc_base/test_echo_server.cc | 4 +- rtc_base/test_echo_server.h | 8 +- rtc_base/test_utils.h | 26 +- rtc_base/thread_unittest.cc | 9 +- rtc_base/virtual_socket_server.cc | 4 - rtc_base/virtual_socket_server.h | 3 +- rtc_base/virtual_socket_unittest.cc | 146 ++++++------ rtc_base/win32_socket_server.cc | 4 - rtc_base/win32_socket_server.h | 6 +- test/network/BUILD.gn | 2 +- test/network/fake_network_socket_server.cc | 16 +- test/network/fake_network_socket_server.h | 3 +- test/network/network_emulation_unittest.cc | 30 +-- test/run_loop.cc | 5 - test/run_loop.h | 1 - test/time_controller/simulated_thread.cc | 4 - 73 files changed, 570 insertions(+), 685 deletions(-) diff --git a/examples/androidvoip/jni/android_voip_client.cc b/examples/androidvoip/jni/android_voip_client.cc index 95d3ed407f..9f859cba28 100644 --- a/examples/androidvoip/jni/android_voip_client.cc +++ b/examples/androidvoip/jni/android_voip_client.cc @@ -61,8 +61,8 @@ rtc::IPAddress QueryDefaultLocalAddress(int family) { RTC_DCHECK(thread->socketserver() != nullptr); RTC_DCHECK(family == AF_INET || family == AF_INET6); - std::unique_ptr socket( - thread->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM)); + std::unique_ptr socket( + thread->socketserver()->CreateSocket(family, SOCK_DGRAM)); if (!socket) { RTC_LOG_ERR(LERROR) << "Socket creation failed"; return rtc::IPAddress(); diff --git a/examples/peerconnection/client/peer_connection_client.cc b/examples/peerconnection/client/peer_connection_client.cc index 9bf2a0fecc..713259360c 100644 --- a/examples/peerconnection/client/peer_connection_client.cc +++ b/examples/peerconnection/client/peer_connection_client.cc @@ -26,7 +26,7 @@ const char kByeMessage[] = "BYE"; // Delay between server connection retries, in milliseconds const int kReconnectDelay = 2000; -rtc::AsyncSocket* CreateClientSocket(int family) { +rtc::Socket* CreateClientSocket(int family) { #ifdef WIN32 rtc::Win32Socket* sock = new rtc::Win32Socket(); sock->CreateT(family, SOCK_STREAM); @@ -34,7 +34,7 @@ rtc::AsyncSocket* CreateClientSocket(int family) { #elif defined(WEBRTC_POSIX) rtc::Thread* thread = rtc::Thread::Current(); RTC_DCHECK(thread != NULL); - return thread->socketserver()->CreateAsyncSocket(family, SOCK_STREAM); + return thread->socketserver()->CreateSocket(family, SOCK_STREAM); #else #error Platform not supported. #endif @@ -227,14 +227,14 @@ bool PeerConnectionClient::ConnectControlSocket() { return true; } -void PeerConnectionClient::OnConnect(rtc::AsyncSocket* socket) { +void PeerConnectionClient::OnConnect(rtc::Socket* socket) { RTC_DCHECK(!onconnect_data_.empty()); size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length()); RTC_DCHECK(sent == onconnect_data_.length()); onconnect_data_.clear(); } -void PeerConnectionClient::OnHangingGetConnect(rtc::AsyncSocket* socket) { +void PeerConnectionClient::OnHangingGetConnect(rtc::Socket* socket) { char buffer[1024]; snprintf(buffer, sizeof(buffer), "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n", my_id_); @@ -283,7 +283,7 @@ bool PeerConnectionClient::GetHeaderValue(const std::string& data, return false; } -bool PeerConnectionClient::ReadIntoBuffer(rtc::AsyncSocket* socket, +bool PeerConnectionClient::ReadIntoBuffer(rtc::Socket* socket, std::string* data, size_t* content_length) { char buffer[0xffff]; @@ -321,7 +321,7 @@ bool PeerConnectionClient::ReadIntoBuffer(rtc::AsyncSocket* socket, return ret; } -void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) { +void PeerConnectionClient::OnRead(rtc::Socket* socket) { size_t content_length = 0; if (ReadIntoBuffer(socket, &control_data_, &content_length)) { size_t peer_id = 0, eoh = 0; @@ -373,7 +373,7 @@ void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) { } } -void PeerConnectionClient::OnHangingGetRead(rtc::AsyncSocket* socket) { +void PeerConnectionClient::OnHangingGetRead(rtc::Socket* socket) { RTC_LOG(INFO) << __FUNCTION__; size_t content_length = 0; if (ReadIntoBuffer(socket, ¬ification_data_, &content_length)) { @@ -471,7 +471,7 @@ bool PeerConnectionClient::ParseServerResponse(const std::string& response, return true; } -void PeerConnectionClient::OnClose(rtc::AsyncSocket* socket, int err) { +void PeerConnectionClient::OnClose(rtc::Socket* socket, int err) { RTC_LOG(INFO) << __FUNCTION__; socket->Close(); diff --git a/examples/peerconnection/client/peer_connection_client.h b/examples/peerconnection/client/peer_connection_client.h index d7ae91343d..00d2192681 100644 --- a/examples/peerconnection/client/peer_connection_client.h +++ b/examples/peerconnection/client/peer_connection_client.h @@ -73,8 +73,8 @@ class PeerConnectionClient : public sigslot::has_slots<>, void Close(); void InitSocketSignals(); bool ConnectControlSocket(); - void OnConnect(rtc::AsyncSocket* socket); - void OnHangingGetConnect(rtc::AsyncSocket* socket); + void OnConnect(rtc::Socket* socket); + void OnHangingGetConnect(rtc::Socket* socket); void OnMessageFromPeer(int peer_id, const std::string& message); // Quick and dirty support for parsing HTTP header values. @@ -89,13 +89,13 @@ class PeerConnectionClient : public sigslot::has_slots<>, std::string* value); // Returns true if the whole response has been read. - bool ReadIntoBuffer(rtc::AsyncSocket* socket, + bool ReadIntoBuffer(rtc::Socket* socket, std::string* data, size_t* content_length); - void OnRead(rtc::AsyncSocket* socket); + void OnRead(rtc::Socket* socket); - void OnHangingGetRead(rtc::AsyncSocket* socket); + void OnHangingGetRead(rtc::Socket* socket); // Parses a single line entry in the form ",," bool ParseEntry(const std::string& entry, @@ -110,15 +110,15 @@ class PeerConnectionClient : public sigslot::has_slots<>, size_t* peer_id, size_t* eoh); - void OnClose(rtc::AsyncSocket* socket, int err); + void OnClose(rtc::Socket* socket, int err); void OnResolveResult(rtc::AsyncResolverInterface* resolver); PeerConnectionClientObserver* callback_; rtc::SocketAddress server_address_; rtc::AsyncResolver* resolver_; - std::unique_ptr control_socket_; - std::unique_ptr hanging_get_; + std::unique_ptr control_socket_; + std::unique_ptr hanging_get_; std::string onconnect_data_; std::string control_data_; std::string notification_data_; diff --git a/p2p/BUILD.gn b/p2p/BUILD.gn index 244bc39092..f88569480f 100644 --- a/p2p/BUILD.gn +++ b/p2p/BUILD.gn @@ -99,7 +99,6 @@ rtc_library("rtc_p2p") { "../logging:ice_log", "../rtc_base", "../rtc_base:async_resolver_interface", - "../rtc_base:async_socket", "../rtc_base:callback_list", "../rtc_base:checks", "../rtc_base:ip_address", @@ -189,10 +188,10 @@ if (rtc_include_tests) { "../api/transport:stun_types", "../rtc_base", "../rtc_base:async_resolver_interface", - "../rtc_base:async_socket", "../rtc_base:gunit_helpers", "../rtc_base:rtc_base_approved", "../rtc_base:rtc_base_tests_utils", + "../rtc_base:socket", "../rtc_base:socket_address", "../rtc_base:socket_server", "../rtc_base:threading", @@ -241,7 +240,6 @@ if (rtc_include_tests) { "../api/transport:stun_types", "../api/units:time_delta", "../rtc_base", - "../rtc_base:async_socket", "../rtc_base:checks", "../rtc_base:gunit_helpers", "../rtc_base:ip_address", diff --git a/p2p/base/async_stun_tcp_socket.cc b/p2p/base/async_stun_tcp_socket.cc index 676447ea7e..f4ead6696c 100644 --- a/p2p/base/async_stun_tcp_socket.cc +++ b/p2p/base/async_stun_tcp_socket.cc @@ -41,7 +41,7 @@ inline bool IsStunMessage(uint16_t msg_type) { // it. Takes ownership of `socket`. Returns NULL if bind() or // connect() fail (`socket` is destroyed in that case). AsyncStunTCPSocket* AsyncStunTCPSocket::Create( - rtc::AsyncSocket* socket, + rtc::Socket* socket, const rtc::SocketAddress& bind_address, const rtc::SocketAddress& remote_address) { return new AsyncStunTCPSocket( @@ -49,7 +49,7 @@ AsyncStunTCPSocket* AsyncStunTCPSocket::Create( false); } -AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen) +AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::Socket* socket, bool listen) : rtc::AsyncTCPSocketBase(socket, listen, kBufSize) {} int AsyncStunTCPSocket::Send(const void* pv, @@ -126,7 +126,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) { } } -void AsyncStunTCPSocket::HandleIncomingConnection(rtc::AsyncSocket* socket) { +void AsyncStunTCPSocket::HandleIncomingConnection(rtc::Socket* socket) { SignalNewConnection(this, new AsyncStunTCPSocket(socket, false)); } diff --git a/p2p/base/async_stun_tcp_socket.h b/p2p/base/async_stun_tcp_socket.h index 9453845c3a..2b7bc95627 100644 --- a/p2p/base/async_stun_tcp_socket.h +++ b/p2p/base/async_stun_tcp_socket.h @@ -14,9 +14,9 @@ #include #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_tcp_socket.h" #include "rtc_base/constructor_magic.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" namespace cricket { @@ -26,17 +26,17 @@ class AsyncStunTCPSocket : public rtc::AsyncTCPSocketBase { // 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::AsyncSocket* socket, + static AsyncStunTCPSocket* Create(rtc::Socket* socket, const rtc::SocketAddress& bind_address, const rtc::SocketAddress& remote_address); - AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen); + AsyncStunTCPSocket(rtc::Socket* socket, bool listen); int Send(const void* pv, size_t cb, const rtc::PacketOptions& options) override; void ProcessInput(char* data, size_t* len) override; - void HandleIncomingConnection(rtc::AsyncSocket* socket) override; + void HandleIncomingConnection(rtc::Socket* socket) override; private: // This method returns the message hdr + length written in the header. diff --git a/p2p/base/async_stun_tcp_socket_unittest.cc b/p2p/base/async_stun_tcp_socket_unittest.cc index d1dfac10d2..40b5405750 100644 --- a/p2p/base/async_stun_tcp_socket_unittest.cc +++ b/p2p/base/async_stun_tcp_socket_unittest.cc @@ -17,8 +17,8 @@ #include #include -#include "rtc_base/async_socket.h" #include "rtc_base/network/sent_packet.h" +#include "rtc_base/socket.h" #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread.h" #include "rtc_base/virtual_socket_server.h" @@ -67,15 +67,13 @@ class AsyncStunTCPSocketTest : public ::testing::Test, virtual void SetUp() { CreateSockets(); } void CreateSockets() { - rtc::AsyncSocket* server = - vss_->CreateAsyncSocket(kServerAddr.family(), SOCK_STREAM); + rtc::Socket* server = vss_->CreateSocket(kServerAddr.family(), SOCK_STREAM); server->Bind(kServerAddr); recv_socket_.reset(new AsyncStunTCPSocket(server, true)); recv_socket_->SignalNewConnection.connect( this, &AsyncStunTCPSocketTest::OnNewConnection); - rtc::AsyncSocket* client = - vss_->CreateAsyncSocket(kClientAddr.family(), SOCK_STREAM); + rtc::Socket* client = vss_->CreateSocket(kClientAddr.family(), SOCK_STREAM); send_socket_.reset(AsyncStunTCPSocket::Create( client, kClientAddr, recv_socket_->GetLocalAddress())); send_socket_->SignalSentPacket.connect( diff --git a/p2p/base/basic_packet_socket_factory.cc b/p2p/base/basic_packet_socket_factory.cc index 232e58b546..4aaad7ce07 100644 --- a/p2p/base/basic_packet_socket_factory.cc +++ b/p2p/base/basic_packet_socket_factory.cc @@ -46,8 +46,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket( uint16_t min_port, uint16_t max_port) { // UDP sockets are simple. - AsyncSocket* socket = - socket_factory()->CreateAsyncSocket(address.family(), SOCK_DGRAM); + Socket* socket = socket_factory()->CreateSocket(address.family(), SOCK_DGRAM); if (!socket) { return NULL; } @@ -70,8 +69,8 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket( return NULL; } - AsyncSocket* socket = - socket_factory()->CreateAsyncSocket(local_address.family(), SOCK_STREAM); + Socket* socket = + socket_factory()->CreateSocket(local_address.family(), SOCK_STREAM); if (!socket) { return NULL; } @@ -108,8 +107,8 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket( const ProxyInfo& proxy_info, const std::string& user_agent, const PacketSocketTcpOptions& tcp_options) { - AsyncSocket* socket = - socket_factory()->CreateAsyncSocket(local_address.family(), SOCK_STREAM); + Socket* socket = + socket_factory()->CreateSocket(local_address.family(), SOCK_STREAM); if (!socket) { return NULL; } @@ -203,7 +202,7 @@ AsyncResolverInterface* BasicPacketSocketFactory::CreateAsyncResolver() { return new AsyncResolver(); } -int BasicPacketSocketFactory::BindSocket(AsyncSocket* socket, +int BasicPacketSocketFactory::BindSocket(Socket* socket, const SocketAddress& local_address, uint16_t min_port, uint16_t max_port) { diff --git a/p2p/base/basic_packet_socket_factory.h b/p2p/base/basic_packet_socket_factory.h index 337efca843..22f30249b9 100644 --- a/p2p/base/basic_packet_socket_factory.h +++ b/p2p/base/basic_packet_socket_factory.h @@ -14,10 +14,10 @@ #include #include "api/packet_socket_factory.h" +#include "rtc_base/socket.h" namespace rtc { -class AsyncSocket; class SocketFactory; class Thread; @@ -45,7 +45,7 @@ class BasicPacketSocketFactory : public PacketSocketFactory { AsyncResolverInterface* CreateAsyncResolver() override; private: - int BindSocket(AsyncSocket* socket, + int BindSocket(Socket* socket, const SocketAddress& local_address, uint16_t min_port, uint16_t max_port); diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc index fe12a6dde4..7d7bfdb5e4 100644 --- a/p2p/base/port_unittest.cc +++ b/p2p/base/port_unittest.cc @@ -40,7 +40,6 @@ #include "p2p/client/relay_port_factory_interface.h" #include "rtc_base/arraysize.h" #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/byte_buffer.h" #include "rtc_base/checks.h" @@ -1217,8 +1216,8 @@ TEST_F(PortTest, TestTcpNeverConnect) { ch1.Start(); ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout); - std::unique_ptr server( - vss()->CreateAsyncSocket(kLocalAddr2.family(), SOCK_STREAM)); + std::unique_ptr server( + vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM)); // Bind but not listen. EXPECT_EQ(0, server->Bind(kLocalAddr2)); diff --git a/p2p/base/stun_server.h b/p2p/base/stun_server.h index 60e82485c4..f2126db191 100644 --- a/p2p/base/stun_server.h +++ b/p2p/base/stun_server.h @@ -34,7 +34,7 @@ class StunServer : public sigslot::has_slots<> { ~StunServer() override; protected: - // Slot for AsyncSocket.PacketRead: + // Slot for Socket.PacketRead: void OnPacket(rtc::AsyncPacketSocket* socket, const char* buf, size_t size, diff --git a/p2p/base/test_stun_server.cc b/p2p/base/test_stun_server.cc index 54bdfb3793..3bd793cfbb 100644 --- a/p2p/base/test_stun_server.cc +++ b/p2p/base/test_stun_server.cc @@ -10,14 +10,14 @@ #include "p2p/base/test_stun_server.h" -#include "rtc_base/async_socket.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_server.h" namespace cricket { TestStunServer* TestStunServer::Create(rtc::SocketServer* ss, const rtc::SocketAddress& addr) { - rtc::AsyncSocket* socket = ss->CreateAsyncSocket(addr.family(), SOCK_DGRAM); + rtc::Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM); rtc::AsyncUDPSocket* udp_socket = rtc::AsyncUDPSocket::Create(socket, addr); return new TestStunServer(udp_socket); diff --git a/p2p/base/test_turn_server.h b/p2p/base/test_turn_server.h index ecd934861b..479ca8bb39 100644 --- a/p2p/base/test_turn_server.h +++ b/p2p/base/test_turn_server.h @@ -99,8 +99,8 @@ class TestTurnServer : public TurnAuthInterface { } else if (proto == cricket::PROTO_TCP || proto == cricket::PROTO_TLS) { // For TCP we need to create a server socket which can listen for incoming // new connections. - rtc::AsyncSocket* socket = - thread_->socketserver()->CreateAsyncSocket(AF_INET, SOCK_STREAM); + rtc::Socket* socket = + thread_->socketserver()->CreateSocket(AF_INET, SOCK_STREAM); if (proto == cricket::PROTO_TLS) { // For TLS, wrap the TCP socket with an SSL adapter. The adapter must // be configured with a self-signed certificate for testing. diff --git a/p2p/base/turn_port_unittest.cc b/p2p/base/turn_port_unittest.cc index c45b8c97f9..7a7092d396 100644 --- a/p2p/base/turn_port_unittest.cc +++ b/p2p/base/turn_port_unittest.cc @@ -28,7 +28,6 @@ #include "p2p/base/transport_description.h" #include "p2p/base/turn_port.h" #include "p2p/base/turn_server.h" -#include "rtc_base/async_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/byte_buffer.h" #include "rtc_base/checks.h" @@ -37,6 +36,7 @@ #include "rtc_base/location.h" #include "rtc_base/message_handler.h" #include "rtc_base/net_helper.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" #include "rtc_base/thread.h" #include "rtc_base/time_utils.h" @@ -242,8 +242,8 @@ class TurnPortTest : public ::testing::Test, void OnTurnPortClosed(TurnPort* port) { turn_port_closed_ = true; } void OnTurnPortDestroyed(PortInterface* port) { turn_port_destroyed_ = true; } - rtc::AsyncSocket* CreateServerSocket(const SocketAddress addr) { - rtc::AsyncSocket* socket = ss_->CreateAsyncSocket(AF_INET, SOCK_STREAM); + rtc::Socket* CreateServerSocket(const SocketAddress addr) { + rtc::Socket* socket = ss_->CreateSocket(AF_INET, SOCK_STREAM); EXPECT_GE(socket->Bind(addr), 0); EXPECT_GE(socket->Listen(5), 0); return socket; diff --git a/p2p/base/turn_server.cc b/p2p/base/turn_server.cc index 53f283bc96..01856f4e64 100644 --- a/p2p/base/turn_server.cc +++ b/p2p/base/turn_server.cc @@ -139,7 +139,7 @@ TurnServer::~TurnServer() { for (ServerSocketMap::iterator it = server_listen_sockets_.begin(); it != server_listen_sockets_.end(); ++it) { - rtc::AsyncSocket* socket = it->first; + rtc::Socket* socket = it->first; delete socket; } } @@ -152,7 +152,7 @@ void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket, socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket); } -void TurnServer::AddInternalServerSocket(rtc::AsyncSocket* socket, +void TurnServer::AddInternalServerSocket(rtc::Socket* socket, ProtocolType proto) { RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK(server_listen_sockets_.end() == @@ -169,17 +169,17 @@ void TurnServer::SetExternalSocketFactory( external_addr_ = external_addr; } -void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) { +void TurnServer::OnNewInternalConnection(rtc::Socket* socket) { RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK(server_listen_sockets_.find(socket) != server_listen_sockets_.end()); AcceptConnection(socket); } -void TurnServer::AcceptConnection(rtc::AsyncSocket* server_socket) { +void TurnServer::AcceptConnection(rtc::Socket* server_socket) { // Check if someone is trying to connect to us. rtc::SocketAddress accept_addr; - rtc::AsyncSocket* accepted_socket = server_socket->Accept(&accept_addr); + rtc::Socket* accepted_socket = server_socket->Accept(&accept_addr); if (accepted_socket != NULL) { ProtocolType proto = server_listen_sockets_[server_socket]; cricket::AsyncStunTCPSocket* tcp_socket = diff --git a/p2p/base/turn_server.h b/p2p/base/turn_server.h index f90c3dac0d..7942c09af9 100644 --- a/p2p/base/turn_server.h +++ b/p2p/base/turn_server.h @@ -237,7 +237,7 @@ class TurnServer : public sigslot::has_slots<> { // 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::AsyncSocket* socket, ProtocolType proto); + void AddInternalServerSocket(rtc::Socket* socket, ProtocolType proto); // Specifies the factory to use for creating external sockets. void SetExternalSocketFactory(rtc::PacketSocketFactory* factory, const rtc::SocketAddress& address); @@ -265,10 +265,10 @@ class TurnServer : public sigslot::has_slots<> { const rtc::SocketAddress& address, const int64_t& packet_time_us); - void OnNewInternalConnection(rtc::AsyncSocket* socket); + void OnNewInternalConnection(rtc::Socket* socket); // Accept connections on this server socket. - void AcceptConnection(rtc::AsyncSocket* server_socket) RTC_RUN_ON(thread_); + void AcceptConnection(rtc::Socket* server_socket) RTC_RUN_ON(thread_); void OnInternalSocketClose(rtc::AsyncPacketSocket* socket, int err); void HandleStunMessage(TurnServerConnection* conn, @@ -320,7 +320,7 @@ class TurnServer : public sigslot::has_slots<> { RTC_RUN_ON(thread_); typedef std::map InternalSocketMap; - typedef std::map ServerSocketMap; + typedef std::map ServerSocketMap; rtc::Thread* const thread_; const std::string nonce_key_; diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index 40c4835456..90bb8b7266 100644 --- a/rtc_base/BUILD.gn +++ b/rtc_base/BUILD.gn @@ -737,7 +737,6 @@ rtc_library("null_socket_server") { "null_socket_server.h", ] deps = [ - ":async_socket", ":checks", ":rtc_event", ":socket", @@ -818,10 +817,7 @@ rtc_library("threading") { rtc_source_set("socket_factory") { sources = [ "socket_factory.h" ] - deps = [ - ":async_socket", - ":socket", - ] + deps = [ ":socket" ] } rtc_library("async_socket") { @@ -846,7 +842,9 @@ rtc_library("socket") { deps = [ ":macromagic", ":socket_address", + "third_party/sigslot", ] + absl_deps = [ "//third_party/abseil-cpp/absl/base:core_headers" ] if (is_win) { deps += [ ":win32" ] } @@ -1294,7 +1292,6 @@ if (rtc_include_tests) { "socket_unittest.h", ] deps = [ - ":async_socket", ":checks", ":gunit_helpers", ":ip_address", @@ -1369,7 +1366,6 @@ if (rtc_include_tests) { sources += [ "win/windows_version_unittest.cc" ] } deps = [ - ":async_socket", ":bounded_inline_vector", ":checks", ":criticalsection", @@ -1505,13 +1501,13 @@ if (rtc_include_tests) { "unique_id_generator_unittest.cc", ] deps = [ - ":async_socket", ":checks", ":gunit_helpers", ":ip_address", ":net_helpers", ":null_socket_server", ":rtc_base_tests_utils", + ":socket", ":socket_address", ":socket_factory", ":socket_server", diff --git a/rtc_base/async_socket.cc b/rtc_base/async_socket.cc index e80514db12..7289b5c959 100644 --- a/rtc_base/async_socket.cc +++ b/rtc_base/async_socket.cc @@ -15,11 +15,7 @@ namespace rtc { -AsyncSocket::AsyncSocket() {} - -AsyncSocket::~AsyncSocket() {} - -AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket) +AsyncSocketAdapter::AsyncSocketAdapter(Socket* socket) : socket_(absl::WrapUnique(socket)) { RTC_DCHECK(socket_); socket_->SignalConnectEvent.connect(this, @@ -70,7 +66,7 @@ int AsyncSocketAdapter::Listen(int backlog) { return socket_->Listen(backlog); } -AsyncSocket* AsyncSocketAdapter::Accept(SocketAddress* paddr) { +Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) { return socket_->Accept(paddr); } @@ -86,7 +82,7 @@ void AsyncSocketAdapter::SetError(int error) { return socket_->SetError(error); } -AsyncSocket::ConnState AsyncSocketAdapter::GetState() const { +Socket::ConnState AsyncSocketAdapter::GetState() const { return socket_->GetState(); } @@ -98,19 +94,19 @@ int AsyncSocketAdapter::SetOption(Option opt, int value) { return socket_->SetOption(opt, value); } -void AsyncSocketAdapter::OnConnectEvent(AsyncSocket* socket) { +void AsyncSocketAdapter::OnConnectEvent(Socket* socket) { SignalConnectEvent(this); } -void AsyncSocketAdapter::OnReadEvent(AsyncSocket* socket) { +void AsyncSocketAdapter::OnReadEvent(Socket* socket) { SignalReadEvent(this); } -void AsyncSocketAdapter::OnWriteEvent(AsyncSocket* socket) { +void AsyncSocketAdapter::OnWriteEvent(Socket* socket) { SignalWriteEvent(this); } -void AsyncSocketAdapter::OnCloseEvent(AsyncSocket* socket, int err) { +void AsyncSocketAdapter::OnCloseEvent(Socket* socket, int err) { SignalCloseEvent(this, err); } diff --git a/rtc_base/async_socket.h b/rtc_base/async_socket.h index 9dc236fd12..0772cb8d97 100644 --- a/rtc_base/async_socket.h +++ b/rtc_base/async_socket.h @@ -22,34 +22,11 @@ namespace rtc { -// TODO: Remove Socket and rename AsyncSocket to Socket. - -// Provides the ability to perform socket I/O asynchronously. -class AsyncSocket : public Socket { - public: - AsyncSocket(); - ~AsyncSocket() override; - - AsyncSocket* Accept(SocketAddress* paddr) override = 0; - - // SignalReadEvent and SignalWriteEvent use multi_threaded_local to allow - // access concurrently from different thread. - // For example SignalReadEvent::connect will be called in AsyncUDPSocket ctor - // but at the same time the SocketDispatcher maybe signaling the read event. - // ready to read - sigslot::signal1 SignalReadEvent; - // ready to write - sigslot::signal1 - SignalWriteEvent; - sigslot::signal1 SignalConnectEvent; // connected - sigslot::signal2 SignalCloseEvent; // closed -}; - -class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> { +class AsyncSocketAdapter : public Socket, public sigslot::has_slots<> { public: // Takes ownership of the passed in socket. // TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers. - explicit AsyncSocketAdapter(AsyncSocket* socket); + explicit AsyncSocketAdapter(Socket* socket); SocketAddress GetLocalAddress() const override; SocketAddress GetRemoteAddress() const override; @@ -63,7 +40,7 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> { SocketAddress* paddr, int64_t* timestamp) override; int Listen(int backlog) override; - AsyncSocket* Accept(SocketAddress* paddr) override; + Socket* Accept(SocketAddress* paddr) override; int Close() override; int GetError() const override; void SetError(int error) override; @@ -72,15 +49,15 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> { int SetOption(Option opt, int value) override; protected: - virtual void OnConnectEvent(AsyncSocket* socket); - virtual void OnReadEvent(AsyncSocket* socket); - virtual void OnWriteEvent(AsyncSocket* socket); - virtual void OnCloseEvent(AsyncSocket* socket, int err); + virtual void OnConnectEvent(Socket* socket); + virtual void OnReadEvent(Socket* socket); + virtual void OnWriteEvent(Socket* socket); + virtual void OnCloseEvent(Socket* socket, int err); - AsyncSocket* GetSocket() const { return socket_.get(); } + Socket* GetSocket() const { return socket_.get(); } private: - const std::unique_ptr socket_; + const std::unique_ptr socket_; }; } // namespace rtc diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc index 3d8b23d2fa..76efb6dec1 100644 --- a/rtc_base/async_tcp_socket.cc +++ b/rtc_base/async_tcp_socket.cc @@ -45,11 +45,11 @@ static const size_t kMinimumRecvSize = 128; static const int kListenBacklog = 5; // Binds and connects `socket` -AsyncSocket* AsyncTCPSocketBase::ConnectSocket( - rtc::AsyncSocket* socket, +Socket* AsyncTCPSocketBase::ConnectSocket( + rtc::Socket* socket, const rtc::SocketAddress& bind_address, const rtc::SocketAddress& remote_address) { - std::unique_ptr owned_socket(socket); + std::unique_ptr owned_socket(socket); if (socket->Bind(bind_address) < 0) { RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError(); return nullptr; @@ -61,7 +61,7 @@ AsyncSocket* AsyncTCPSocketBase::ConnectSocket( return owned_socket.release(); } -AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, +AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket, bool listen, size_t max_packet_size) : socket_(socket), @@ -193,16 +193,16 @@ void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) { outbuf_.AppendData(static_cast(pv), cb); } -void AsyncTCPSocketBase::OnConnectEvent(AsyncSocket* socket) { +void AsyncTCPSocketBase::OnConnectEvent(Socket* socket) { SignalConnect(this); } -void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) { +void AsyncTCPSocketBase::OnReadEvent(Socket* socket) { RTC_DCHECK(socket_.get() == socket); if (listen_) { rtc::SocketAddress address; - rtc::AsyncSocket* new_socket = socket->Accept(&address); + rtc::Socket* new_socket = socket->Accept(&address); if (!new_socket) { // TODO(stefan): Do something better like forwarding the error // to the user. @@ -259,7 +259,7 @@ void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) { } } -void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) { +void AsyncTCPSocketBase::OnWriteEvent(Socket* socket) { RTC_DCHECK(socket_.get() == socket); if (outbuf_.size() > 0) { @@ -271,7 +271,7 @@ void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) { } } -void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) { +void AsyncTCPSocketBase::OnCloseEvent(Socket* socket, int error) { SignalClose(this, error); } @@ -279,7 +279,7 @@ void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) { // 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(AsyncSocket* socket, +AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket, const SocketAddress& bind_address, const SocketAddress& remote_address) { return new AsyncTCPSocket( @@ -287,7 +287,7 @@ AsyncTCPSocket* AsyncTCPSocket::Create(AsyncSocket* socket, false); } -AsyncTCPSocket::AsyncTCPSocket(AsyncSocket* socket, bool listen) +AsyncTCPSocket::AsyncTCPSocket(Socket* socket, bool listen) : AsyncTCPSocketBase(socket, listen, kBufSize) {} int AsyncTCPSocket::Send(const void* pv, @@ -343,7 +343,7 @@ void AsyncTCPSocket::ProcessInput(char* data, size_t* len) { } } -void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) { +void AsyncTCPSocket::HandleIncomingConnection(Socket* socket) { SignalNewConnection(this, new AsyncTCPSocket(socket, false)); } diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h index 610d17d7fa..ddf9a436f6 100644 --- a/rtc_base/async_tcp_socket.h +++ b/rtc_base/async_tcp_socket.h @@ -16,7 +16,6 @@ #include #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/socket.h" @@ -29,7 +28,7 @@ namespace rtc { // buffer them in user space. class AsyncTCPSocketBase : public AsyncPacketSocket { public: - AsyncTCPSocketBase(AsyncSocket* socket, bool listen, size_t max_packet_size); + AsyncTCPSocketBase(Socket* socket, bool listen, size_t max_packet_size); ~AsyncTCPSocketBase() override; // Pure virtual methods to send and recv data. @@ -38,7 +37,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket { const rtc::PacketOptions& options) override = 0; virtual void ProcessInput(char* data, size_t* len) = 0; // Signals incoming connection. - virtual void HandleIncomingConnection(AsyncSocket* socket) = 0; + virtual void HandleIncomingConnection(Socket* socket) = 0; SocketAddress GetLocalAddress() const override; SocketAddress GetRemoteAddress() const override; @@ -58,9 +57,9 @@ class AsyncTCPSocketBase : public AsyncPacketSocket { // 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 AsyncSocket* ConnectSocket(AsyncSocket* socket, - const SocketAddress& bind_address, - const SocketAddress& remote_address); + static Socket* ConnectSocket(Socket* socket, + const SocketAddress& bind_address, + const SocketAddress& remote_address); int FlushOutBuffer(); // Add data to `outbuf_`. void AppendToOutBuffer(const void* pv, size_t cb); @@ -71,12 +70,12 @@ class AsyncTCPSocketBase : public AsyncPacketSocket { private: // Called by the underlying socket - void OnConnectEvent(AsyncSocket* socket); - void OnReadEvent(AsyncSocket* socket); - void OnWriteEvent(AsyncSocket* socket); - void OnCloseEvent(AsyncSocket* socket, int error); + void OnConnectEvent(Socket* socket); + void OnReadEvent(Socket* socket); + void OnWriteEvent(Socket* socket); + void OnCloseEvent(Socket* socket, int error); - std::unique_ptr socket_; + std::unique_ptr socket_; bool listen_; Buffer inbuf_; Buffer outbuf_; @@ -91,17 +90,17 @@ class AsyncTCPSocket : public AsyncTCPSocketBase { // 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 AsyncTCPSocket* Create(AsyncSocket* socket, + static AsyncTCPSocket* Create(Socket* socket, const SocketAddress& bind_address, const SocketAddress& remote_address); - AsyncTCPSocket(AsyncSocket* socket, bool listen); + AsyncTCPSocket(Socket* socket, bool listen); ~AsyncTCPSocket() override {} int Send(const void* pv, size_t cb, const rtc::PacketOptions& options) override; void ProcessInput(char* data, size_t* len) override; - void HandleIncomingConnection(AsyncSocket* socket) override; + void HandleIncomingConnection(Socket* socket) override; private: RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket); diff --git a/rtc_base/async_tcp_socket_unittest.cc b/rtc_base/async_tcp_socket_unittest.cc index c701433106..af82238a37 100644 --- a/rtc_base/async_tcp_socket_unittest.cc +++ b/rtc_base/async_tcp_socket_unittest.cc @@ -22,7 +22,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> { public: AsyncTCPSocketTest() : vss_(new rtc::VirtualSocketServer()), - socket_(vss_->CreateAsyncSocket(SOCK_STREAM)), + socket_(vss_->CreateSocket(SOCK_STREAM)), tcp_socket_(new AsyncTCPSocket(socket_, true)), ready_to_send_(false) { tcp_socket_->SignalReadyToSend.connect(this, @@ -33,7 +33,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> { protected: std::unique_ptr vss_; - AsyncSocket* socket_; + Socket* socket_; std::unique_ptr tcp_socket_; bool ready_to_send_; }; diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc index 378b687266..b4aefd6837 100644 --- a/rtc_base/async_udp_socket.cc +++ b/rtc_base/async_udp_socket.cc @@ -24,9 +24,9 @@ namespace rtc { static const int BUF_SIZE = 64 * 1024; -AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket, +AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket, const SocketAddress& bind_address) { - std::unique_ptr owned_socket(socket); + std::unique_ptr owned_socket(socket); if (socket->Bind(bind_address) < 0) { RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError(); return nullptr; @@ -36,14 +36,13 @@ AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket, AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory, const SocketAddress& bind_address) { - AsyncSocket* socket = - factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM); + Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM); if (!socket) return nullptr; return Create(socket, bind_address); } -AsyncUDPSocket::AsyncUDPSocket(AsyncSocket* socket) : socket_(socket) { +AsyncUDPSocket::AsyncUDPSocket(Socket* socket) : socket_(socket) { size_ = BUF_SIZE; buf_ = new char[size_]; @@ -111,7 +110,7 @@ void AsyncUDPSocket::SetError(int error) { return socket_->SetError(error); } -void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) { +void AsyncUDPSocket::OnReadEvent(Socket* socket) { RTC_DCHECK(socket_.get() == socket); SocketAddress remote_addr; @@ -134,7 +133,7 @@ void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) { (timestamp > -1 ? timestamp : TimeMicros())); } -void AsyncUDPSocket::OnWriteEvent(AsyncSocket* socket) { +void AsyncUDPSocket::OnWriteEvent(Socket* socket) { SignalReadyToSend(this); } diff --git a/rtc_base/async_udp_socket.h b/rtc_base/async_udp_socket.h index ce7f4767ee..5d738ffe94 100644 --- a/rtc_base/async_udp_socket.h +++ b/rtc_base/async_udp_socket.h @@ -16,7 +16,6 @@ #include #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/socket.h" #include "rtc_base/socket_address.h" #include "rtc_base/socket_factory.h" @@ -30,13 +29,13 @@ class AsyncUDPSocket : public AsyncPacketSocket { // Binds `socket` and creates AsyncUDPSocket for it. Takes ownership // of `socket`. Returns null if bind() fails (`socket` is destroyed // in that case). - static AsyncUDPSocket* Create(AsyncSocket* socket, + static AsyncUDPSocket* Create(Socket* socket, 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 SocketAddress& bind_address); - explicit AsyncUDPSocket(AsyncSocket* socket); + explicit AsyncUDPSocket(Socket* socket); ~AsyncUDPSocket() override; SocketAddress GetLocalAddress() const override; @@ -58,11 +57,11 @@ class AsyncUDPSocket : public AsyncPacketSocket { private: // Called when the underlying socket is ready to be read from. - void OnReadEvent(AsyncSocket* socket); + void OnReadEvent(Socket* socket); // Called when the underlying socket is ready to send. - void OnWriteEvent(AsyncSocket* socket); + void OnWriteEvent(Socket* socket); - std::unique_ptr socket_; + std::unique_ptr socket_; char* buf_; size_t size_; }; diff --git a/rtc_base/async_udp_socket_unittest.cc b/rtc_base/async_udp_socket_unittest.cc index ecb28c1b14..7df1ca0a46 100644 --- a/rtc_base/async_udp_socket_unittest.cc +++ b/rtc_base/async_udp_socket_unittest.cc @@ -24,7 +24,7 @@ class AsyncUdpSocketTest : public ::testing::Test, public sigslot::has_slots<> { AsyncUdpSocketTest() : pss_(new rtc::PhysicalSocketServer), vss_(new rtc::VirtualSocketServer(pss_.get())), - socket_(vss_->CreateAsyncSocket(SOCK_DGRAM)), + socket_(vss_->CreateSocket(SOCK_DGRAM)), udp_socket_(new AsyncUDPSocket(socket_)), ready_to_send_(false) { udp_socket_->SignalReadyToSend.connect(this, @@ -36,7 +36,7 @@ class AsyncUdpSocketTest : public ::testing::Test, public sigslot::has_slots<> { protected: std::unique_ptr pss_; std::unique_ptr vss_; - AsyncSocket* socket_; + Socket* socket_; std::unique_ptr udp_socket_; bool ready_to_send_; }; diff --git a/rtc_base/firewall_socket_server.cc b/rtc_base/firewall_socket_server.cc index 8f44753760..edb0cd2398 100644 --- a/rtc_base/firewall_socket_server.cc +++ b/rtc_base/firewall_socket_server.cc @@ -25,7 +25,7 @@ namespace rtc { class FirewallSocket : public AsyncSocketAdapter { public: - FirewallSocket(FirewallSocketServer* server, AsyncSocket* socket, int type) + FirewallSocket(FirewallSocketServer* server, Socket* socket, int type) : AsyncSocketAdapter(socket), server_(server), type_(type) {} int Bind(const SocketAddress& addr) override { @@ -96,9 +96,9 @@ class FirewallSocket : public AsyncSocketAdapter { return AsyncSocketAdapter::Listen(backlog); } - AsyncSocket* Accept(SocketAddress* paddr) override { + Socket* Accept(SocketAddress* paddr) override { SocketAddress addr; - while (AsyncSocket* sock = AsyncSocketAdapter::Accept(&addr)) { + while (Socket* sock = AsyncSocketAdapter::Accept(&addr)) { if (server_->Check(FP_TCP, addr, GetLocalAddress())) { if (paddr) *paddr = addr; @@ -203,11 +203,7 @@ bool FirewallSocketServer::IsBindableIp(const rtc::IPAddress& ip) { } Socket* FirewallSocketServer::CreateSocket(int family, int type) { - return WrapSocket(server_->CreateAsyncSocket(family, type), type); -} - -AsyncSocket* FirewallSocketServer::CreateAsyncSocket(int family, int type) { - return WrapSocket(server_->CreateAsyncSocket(family, type), type); + return WrapSocket(server_->CreateSocket(family, type), type); } void FirewallSocketServer::SetMessageQueue(Thread* queue) { @@ -222,7 +218,7 @@ void FirewallSocketServer::WakeUp() { return server_->WakeUp(); } -AsyncSocket* FirewallSocketServer::WrapSocket(AsyncSocket* sock, int type) { +Socket* FirewallSocketServer::WrapSocket(Socket* sock, int type) { if (!sock || (type == SOCK_STREAM && !tcp_sockets_enabled_) || (type == SOCK_DGRAM && !udp_sockets_enabled_)) { RTC_LOG(LS_VERBOSE) << "FirewallSocketServer socket creation denied"; diff --git a/rtc_base/firewall_socket_server.h b/rtc_base/firewall_socket_server.h index 23b91d6ad3..8a82f885c6 100644 --- a/rtc_base/firewall_socket_server.h +++ b/rtc_base/firewall_socket_server.h @@ -13,7 +13,6 @@ #include -#include "rtc_base/async_socket.h" #include "rtc_base/ip_address.h" #include "rtc_base/socket.h" #include "rtc_base/socket_address.h" @@ -78,14 +77,12 @@ class FirewallSocketServer : public SocketServer { bool IsBindableIp(const rtc::IPAddress& ip); Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; void SetMessageQueue(Thread* queue) override; bool Wait(int cms, bool process_io) override; void WakeUp() override; Socket* WrapSocket(Socket* sock, int type); - AsyncSocket* WrapSocket(AsyncSocket* sock, int type); private: SocketServer* server_; diff --git a/rtc_base/nat_server.cc b/rtc_base/nat_server.cc index 725a57be9f..b818685efb 100644 --- a/rtc_base/nat_server.cc +++ b/rtc_base/nat_server.cc @@ -70,7 +70,7 @@ bool AddrCmp::operator()(const SocketAddress& a1, // a TCP connection to the NAT server. class NATProxyServerSocket : public AsyncProxyServerSocket { public: - NATProxyServerSocket(AsyncSocket* socket) + NATProxyServerSocket(Socket* socket) : AsyncProxyServerSocket(socket, kNATEncodedIPv6AddressSize) { BufferInput(true); } @@ -119,7 +119,7 @@ class NATProxyServer : public ProxyServer { : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {} protected: - AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override { + AsyncProxyServerSocket* WrapSocket(Socket* socket) override { return new NATProxyServerSocket(socket); } }; diff --git a/rtc_base/nat_socket_factory.cc b/rtc_base/nat_socket_factory.cc index 874e9387c6..f6492a9305 100644 --- a/rtc_base/nat_socket_factory.cc +++ b/rtc_base/nat_socket_factory.cc @@ -69,7 +69,7 @@ size_t UnpackAddressFromNAT(const char* buf, } // NATSocket -class NATSocket : public AsyncSocket, public sigslot::has_slots<> { +class NATSocket : public Socket, public sigslot::has_slots<> { public: explicit NATSocket(NATInternalSocketFactory* sf, int family, int type) : sf_(sf), @@ -213,7 +213,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> { } int Listen(int backlog) override { return socket_->Listen(backlog); } - AsyncSocket* Accept(SocketAddress* paddr) override { + Socket* Accept(SocketAddress* paddr) override { return socket_->Accept(paddr); } int GetError() const override { @@ -236,7 +236,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> { return socket_ ? socket_->SetOption(opt, value) : -1; } - void OnConnectEvent(AsyncSocket* 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()) { @@ -246,7 +246,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> { SendConnectRequest(); } } - void OnReadEvent(AsyncSocket* 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_) { @@ -255,11 +255,11 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> { SignalReadEvent(this); } } - void OnWriteEvent(AsyncSocket* socket) { + void OnWriteEvent(Socket* socket) { RTC_DCHECK(socket == socket_); SignalWriteEvent(this); } - void OnCloseEvent(AsyncSocket* socket, int error) { + void OnCloseEvent(Socket* socket, int error) { RTC_DCHECK(socket == socket_); SignalCloseEvent(this, error); } @@ -320,7 +320,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> { bool connected_; SocketAddress remote_addr_; SocketAddress server_addr_; // address of the NAT server - AsyncSocket* socket_; + Socket* socket_; // Need to hold error in case it occurs before the socket is created. int error_ = 0; char* buf_; @@ -339,21 +339,16 @@ Socket* NATSocketFactory::CreateSocket(int family, int type) { return new NATSocket(this, family, type); } -AsyncSocket* NATSocketFactory::CreateAsyncSocket(int family, int type) { - return new NATSocket(this, family, type); -} - -AsyncSocket* 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 { *nat_addr = nat_udp_addr_; } - return factory_->CreateAsyncSocket(family, type); + return factory_->CreateSocket(family, type); } // NATSocketServer @@ -384,10 +379,6 @@ Socket* NATSocketServer::CreateSocket(int family, int type) { return new NATSocket(this, family, type); } -AsyncSocket* NATSocketServer::CreateAsyncSocket(int family, int type) { - return new NATSocket(this, family, type); -} - void NATSocketServer::SetMessageQueue(Thread* queue) { msg_queue_ = queue; server_->SetMessageQueue(queue); @@ -401,19 +392,18 @@ void NATSocketServer::WakeUp() { server_->WakeUp(); } -AsyncSocket* NATSocketServer::CreateInternalSocket( - int family, - int type, - const SocketAddress& local_addr, - SocketAddress* nat_addr) { - AsyncSocket* 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()->CreateAsyncSocket(family, type); + socket = nat->internal_factory()->CreateSocket(family, type); *nat_addr = (type == SOCK_STREAM) ? nat->internal_tcp_address() : nat->internal_udp_address(); } else { - socket = server_->CreateAsyncSocket(family, type); + socket = server_->CreateSocket(family, type); } return socket; } diff --git a/rtc_base/nat_socket_factory.h b/rtc_base/nat_socket_factory.h index 70030d834e..9b1d2f09e3 100644 --- a/rtc_base/nat_socket_factory.h +++ b/rtc_base/nat_socket_factory.h @@ -17,7 +17,6 @@ #include #include -#include "rtc_base/async_socket.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/nat_server.h" #include "rtc_base/nat_types.h" @@ -36,10 +35,10 @@ const size_t kNATEncodedIPv6AddressSize = 20U; class NATInternalSocketFactory { public: virtual ~NATInternalSocketFactory() {} - virtual AsyncSocket* 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 @@ -53,13 +52,12 @@ class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory { // SocketFactory implementation Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; // NATInternalSocketFactory implementation - AsyncSocket* 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: SocketFactory* factory_; @@ -148,17 +146,16 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory { // SocketServer implementation Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; void SetMessageQueue(Thread* queue) override; bool Wait(int cms, bool process_io) override; void WakeUp() override; // NATInternalSocketFactory implementation - AsyncSocket* 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: SocketServer* server_; diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc index 959a4e29c7..e757bfda97 100644 --- a/rtc_base/nat_unittest.cc +++ b/rtc_base/nat_unittest.cc @@ -17,7 +17,6 @@ #include "absl/memory/memory.h" #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_tcp_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/gunit.h" @@ -29,6 +28,7 @@ #include "rtc_base/net_helpers.h" #include "rtc_base/network.h" #include "rtc_base/physical_socket_server.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" #include "rtc_base/socket_factory.h" #include "rtc_base/socket_server.h" @@ -55,7 +55,7 @@ TestClient* CreateTestClient(SocketFactory* factory, absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr))); } -TestClient* CreateTCPTestClient(AsyncSocket* socket) { +TestClient* CreateTCPTestClient(Socket* socket) { return new TestClient(std::make_unique(socket, false)); } @@ -201,10 +201,8 @@ bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) { // 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 pss(new PhysicalSocketServer()); - std::unique_ptr client( - pss->CreateAsyncSocket(src.family(), SOCK_DGRAM)); - std::unique_ptr server( - pss->CreateAsyncSocket(src.family(), SOCK_DGRAM)); + std::unique_ptr client(pss->CreateSocket(src.family(), SOCK_DGRAM)); + std::unique_ptr server(pss->CreateSocket(src.family(), SOCK_DGRAM)); if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 || server->Bind(SocketAddress(dst, 0)) != 0) { return false; @@ -345,13 +343,13 @@ class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> { ext_thread_->Start(); } - void OnConnectEvent(AsyncSocket* socket) { connected_ = true; } + void OnConnectEvent(Socket* socket) { connected_ = true; } - void OnAcceptEvent(AsyncSocket* socket) { + void OnAcceptEvent(Socket* socket) { accepted_.reset(server_->Accept(nullptr)); } - void OnCloseEvent(AsyncSocket* socket, int error) {} + void OnCloseEvent(Socket* socket, int error) {} void ConnectEvents() { server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent); @@ -367,17 +365,17 @@ class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> { std::unique_ptr ext_thread_; std::unique_ptr nat_; std::unique_ptr natsf_; - std::unique_ptr client_; - std::unique_ptr server_; - std::unique_ptr accepted_; + std::unique_ptr client_; + std::unique_ptr server_; + std::unique_ptr accepted_; }; TEST_F(NatTcpTest, DISABLED_TestConnectOut) { - server_.reset(ext_vss_->CreateAsyncSocket(AF_INET, SOCK_STREAM)); + server_.reset(ext_vss_->CreateSocket(AF_INET, SOCK_STREAM)); server_->Bind(ext_addr_); server_->Listen(5); - client_.reset(natsf_->CreateAsyncSocket(AF_INET, SOCK_STREAM)); + client_.reset(natsf_->CreateSocket(AF_INET, SOCK_STREAM)); EXPECT_GE(0, client_->Bind(int_addr_)); EXPECT_GE(0, client_->Connect(server_->GetLocalAddress())); diff --git a/rtc_base/network.cc b/rtc_base/network.cc index 5725458cb1..ab0e1232ba 100644 --- a/rtc_base/network.cc +++ b/rtc_base/network.cc @@ -912,8 +912,8 @@ IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const { RTC_DCHECK(thread_->socketserver() != nullptr); RTC_DCHECK(family == AF_INET || family == AF_INET6); - std::unique_ptr socket( - thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM)); + std::unique_ptr socket( + thread_->socketserver()->CreateSocket(family, SOCK_DGRAM)); if (!socket) { RTC_LOG_ERR(LERROR) << "Socket creation failed"; return IPAddress(); diff --git a/rtc_base/network_unittest.cc b/rtc_base/network_unittest.cc index 01e18af7f8..4bfe93fa0c 100644 --- a/rtc_base/network_unittest.cc +++ b/rtc_base/network_unittest.cc @@ -367,7 +367,7 @@ TEST_F(NetworkTest, DISABLED_TestCreateNetworks) { IPAddress ip = (*it)->GetBestIP(); SocketAddress bindaddress(ip, 0); bindaddress.SetScopeID((*it)->scope_id()); - // TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6. + // TODO(thaloun): Use rtc::Socket once it supports IPv6. int fd = static_cast(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP)); if (fd > 0) { size_t ipsize = bindaddress.ToSockAddrStorage(&storage); diff --git a/rtc_base/null_socket_server.cc b/rtc_base/null_socket_server.cc index a7ee4f96e3..ce1e963be4 100644 --- a/rtc_base/null_socket_server.cc +++ b/rtc_base/null_socket_server.cc @@ -34,10 +34,4 @@ rtc::Socket* NullSocketServer::CreateSocket(int /* family */, int /* type */) { return nullptr; } -rtc::AsyncSocket* NullSocketServer::CreateAsyncSocket(int /* family */, - int /* type */) { - RTC_NOTREACHED(); - return nullptr; -} - } // namespace rtc diff --git a/rtc_base/null_socket_server.h b/rtc_base/null_socket_server.h index 7afa504190..6d4ae848e5 100644 --- a/rtc_base/null_socket_server.h +++ b/rtc_base/null_socket_server.h @@ -11,7 +11,6 @@ #ifndef RTC_BASE_NULL_SOCKET_SERVER_H_ #define RTC_BASE_NULL_SOCKET_SERVER_H_ -#include "rtc_base/async_socket.h" #include "rtc_base/event.h" #include "rtc_base/socket.h" #include "rtc_base/socket_server.h" @@ -28,7 +27,6 @@ class RTC_EXPORT NullSocketServer : public SocketServer { void WakeUp() override; Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; private: Event event_; diff --git a/rtc_base/openssl_adapter.cc b/rtc_base/openssl_adapter.cc index d6e1a60d5f..18142a0243 100644 --- a/rtc_base/openssl_adapter.cc +++ b/rtc_base/openssl_adapter.cc @@ -70,7 +70,7 @@ static BIO_METHOD* BIO_socket_method() { return methods; } -static BIO* BIO_new_socket(rtc::AsyncSocket* socket) { +static BIO* BIO_new_socket(rtc::Socket* socket) { BIO* ret = BIO_new(BIO_socket_method()); if (ret == nullptr) { return nullptr; @@ -95,7 +95,7 @@ static int socket_free(BIO* b) { static int socket_read(BIO* b, char* out, int outl) { if (!out) return -1; - rtc::AsyncSocket* socket = static_cast(BIO_get_data(b)); + rtc::Socket* socket = static_cast(BIO_get_data(b)); BIO_clear_retry_flags(b); int result = socket->Recv(out, outl, nullptr); if (result > 0) { @@ -109,7 +109,7 @@ static int socket_read(BIO* b, char* out, int outl) { static int socket_write(BIO* b, const char* in, int inl) { if (!in) return -1; - rtc::AsyncSocket* socket = static_cast(BIO_get_data(b)); + rtc::Socket* socket = static_cast(BIO_get_data(b)); BIO_clear_retry_flags(b); int result = socket->Send(in, inl); if (result > 0) { @@ -129,9 +129,9 @@ static long socket_ctrl(BIO* b, int cmd, long num, void* ptr) { // NOLINT case BIO_CTRL_RESET: return 0; case BIO_CTRL_EOF: { - rtc::AsyncSocket* socket = static_cast(ptr); + rtc::Socket* socket = static_cast(ptr); // 1 means socket closed. - return (socket->GetState() == rtc::AsyncSocket::CS_CLOSED) ? 1 : 0; + return (socket->GetState() == rtc::Socket::CS_CLOSED) ? 1 : 0; } case BIO_CTRL_WPENDING: case BIO_CTRL_PENDING: @@ -181,7 +181,7 @@ bool OpenSSLAdapter::CleanupSSL() { return true; } -OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket, +OpenSSLAdapter::OpenSSLAdapter(Socket* socket, OpenSSLSessionCache* ssl_session_cache, SSLCertificateVerifier* ssl_cert_verifier) : SSLAdapter(socket), @@ -250,9 +250,9 @@ void OpenSSLAdapter::SetRole(SSLRole role) { role_ = role; } -AsyncSocket* OpenSSLAdapter::Accept(SocketAddress* paddr) { +Socket* OpenSSLAdapter::Accept(SocketAddress* paddr) { RTC_DCHECK(role_ == SSL_SERVER); - AsyncSocket* socket = SSLAdapter::Accept(paddr); + Socket* socket = SSLAdapter::Accept(paddr); if (!socket) { return nullptr; } @@ -508,7 +508,7 @@ int OpenSSLAdapter::DoSslWrite(const void* pv, size_t cb, int* error) { } /////////////////////////////////////////////////////////////////////////////// -// AsyncSocket Implementation +// Socket Implementation /////////////////////////////////////////////////////////////////////////////// int OpenSSLAdapter::Send(const void* pv, size_t cb) { @@ -677,7 +677,7 @@ void OpenSSLAdapter::OnMessage(Message* msg) { } } -void OpenSSLAdapter::OnConnectEvent(AsyncSocket* socket) { +void OpenSSLAdapter::OnConnectEvent(Socket* socket) { RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnConnectEvent"; if (state_ != SSL_WAIT) { RTC_DCHECK(state_ == SSL_NONE); @@ -691,7 +691,7 @@ void OpenSSLAdapter::OnConnectEvent(AsyncSocket* socket) { } } -void OpenSSLAdapter::OnReadEvent(AsyncSocket* socket) { +void OpenSSLAdapter::OnReadEvent(Socket* socket) { if (state_ == SSL_NONE) { AsyncSocketAdapter::OnReadEvent(socket); return; @@ -717,7 +717,7 @@ void OpenSSLAdapter::OnReadEvent(AsyncSocket* socket) { AsyncSocketAdapter::OnReadEvent(socket); } -void OpenSSLAdapter::OnWriteEvent(AsyncSocket* socket) { +void OpenSSLAdapter::OnWriteEvent(Socket* socket) { if (state_ == SSL_NONE) { AsyncSocketAdapter::OnWriteEvent(socket); return; @@ -754,7 +754,7 @@ void OpenSSLAdapter::OnWriteEvent(AsyncSocket* socket) { AsyncSocketAdapter::OnWriteEvent(socket); } -void OpenSSLAdapter::OnCloseEvent(AsyncSocket* socket, int err) { +void OpenSSLAdapter::OnCloseEvent(Socket* socket, int err) { RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnCloseEvent(" << err << ")"; AsyncSocketAdapter::OnCloseEvent(socket, err); } @@ -1032,7 +1032,7 @@ void OpenSSLAdapterFactory::SetCertVerifier( ssl_cert_verifier_ = ssl_cert_verifier; } -OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(AsyncSocket* socket) { +OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(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 8d42967c71..4649de0d1d 100644 --- a/rtc_base/openssl_adapter.h +++ b/rtc_base/openssl_adapter.h @@ -19,7 +19,6 @@ #include #include -#include "rtc_base/async_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/message_handler.h" #ifdef OPENSSL_IS_BORINGSSL @@ -49,7 +48,7 @@ class OpenSSLAdapter final : public SSLAdapter, // 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(AsyncSocket* socket, + explicit OpenSSLAdapter(Socket* socket, OpenSSLSessionCache* ssl_session_cache = nullptr, SSLCertificateVerifier* ssl_cert_verifier = nullptr); ~OpenSSLAdapter() override; @@ -61,7 +60,7 @@ class OpenSSLAdapter final : public SSLAdapter, void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) override; void SetIdentity(std::unique_ptr identity) override; void SetRole(SSLRole role) override; - AsyncSocket* Accept(SocketAddress* paddr) override; + Socket* Accept(SocketAddress* paddr) override; int StartSSL(const char* hostname) override; int Send(const void* pv, size_t cb) override; int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override; @@ -83,10 +82,10 @@ class OpenSSLAdapter final : public SSLAdapter, static SSL_CTX* CreateContext(SSLMode mode, bool enable_cache); protected: - void OnConnectEvent(AsyncSocket* socket) override; - void OnReadEvent(AsyncSocket* socket) override; - void OnWriteEvent(AsyncSocket* socket) override; - void OnCloseEvent(AsyncSocket* socket, int err) override; + void OnConnectEvent(Socket* socket) override; + void OnReadEvent(Socket* socket) override; + void OnWriteEvent(Socket* socket) override; + void OnCloseEvent(Socket* socket, int err) override; private: class EarlyExitCatcher { @@ -197,7 +196,7 @@ class OpenSSLAdapterFactory : public SSLAdapterFactory { // 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(AsyncSocket* socket) override; + OpenSSLAdapter* CreateAdapter(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 4bd87992d4..0805cba56c 100644 --- a/rtc_base/openssl_adapter_unittest.cc +++ b/rtc_base/openssl_adapter_unittest.cc @@ -15,17 +15,17 @@ #include #include "absl/memory/memory.h" -#include "rtc_base/async_socket.h" #include "rtc_base/gunit.h" +#include "rtc_base/socket.h" #include "test/gmock.h" namespace rtc { namespace { -class MockAsyncSocket : public AsyncSocket { +class MockAsyncSocket : public Socket { public: virtual ~MockAsyncSocket() = default; - MOCK_METHOD(AsyncSocket*, Accept, (SocketAddress*), (override)); + MOCK_METHOD(Socket*, Accept, (SocketAddress*), (override)); MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override)); MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override)); MOCK_METHOD(int, Bind, (const SocketAddress&), (override)); @@ -84,7 +84,7 @@ TEST(OpenSSLAdapterTest, TestTransformAlpnProtocols) { // Verifies that SSLStart works when OpenSSLAdapter is started in standalone // mode. TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) { - AsyncSocket* async_socket = new MockAsyncSocket(); + Socket* async_socket = new MockAsyncSocket(); OpenSSLAdapter adapter(async_socket); EXPECT_EQ(adapter.StartSSL("webrtc.org"), 0); } @@ -92,7 +92,7 @@ TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) { // Verifies that the adapter factory can create new adapters. TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) { OpenSSLAdapterFactory adapter_factory; - AsyncSocket* async_socket = new MockAsyncSocket(); + Socket* async_socket = new MockAsyncSocket(); auto simple_adapter = std::unique_ptr( adapter_factory.CreateAdapter(async_socket)); EXPECT_NE(simple_adapter, nullptr); @@ -107,7 +107,7 @@ TEST(OpenSSLAdapterFactoryTest, CreateWorksWithCustomVerifier) { OpenSSLAdapterFactory adapter_factory; adapter_factory.SetCertVerifier(cert_verifier.get()); - AsyncSocket* async_socket = new MockAsyncSocket(); + Socket* async_socket = new MockAsyncSocket(); auto simple_adapter = std::unique_ptr( 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 ed6f81baf1..90df855314 100644 --- a/rtc_base/physical_socket_server.cc +++ b/rtc_base/physical_socket_server.cc @@ -283,7 +283,7 @@ void PhysicalSocket::SetError(int error) { error_ = error; } -AsyncSocket::ConnState PhysicalSocket::GetState() const { +Socket::ConnState PhysicalSocket::GetState() const { return state_; } @@ -460,7 +460,7 @@ int PhysicalSocket::Listen(int backlog) { return err; } -AsyncSocket* PhysicalSocket::Accept(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); @@ -1083,16 +1083,6 @@ void PhysicalSocketServer::WakeUp() { } Socket* PhysicalSocketServer::CreateSocket(int family, int type) { - PhysicalSocket* socket = new PhysicalSocket(this); - if (socket->Create(family, type)) { - return socket; - } else { - delete socket; - return nullptr; - } -} - -AsyncSocket* PhysicalSocketServer::CreateAsyncSocket(int family, int type) { SocketDispatcher* dispatcher = new SocketDispatcher(this); if (dispatcher->Create(family, type)) { return dispatcher; @@ -1102,7 +1092,7 @@ AsyncSocket* PhysicalSocketServer::CreateAsyncSocket(int family, int type) { } } -AsyncSocket* PhysicalSocketServer::WrapSocket(SOCKET s) { +Socket* PhysicalSocketServer::WrapSocket(SOCKET s) { SocketDispatcher* dispatcher = new SocketDispatcher(s, this); if (dispatcher->Initialize()) { return dispatcher; diff --git a/rtc_base/physical_socket_server.h b/rtc_base/physical_socket_server.h index 4b7957eb20..a01229d593 100644 --- a/rtc_base/physical_socket_server.h +++ b/rtc_base/physical_socket_server.h @@ -69,10 +69,9 @@ class RTC_EXPORT PhysicalSocketServer : public SocketServer { // SocketFactory: Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; // Internal Factory for Accept (virtual so it can be overwritten in tests). - virtual AsyncSocket* WrapSocket(SOCKET s); + virtual Socket* WrapSocket(SOCKET s); // SocketServer: bool Wait(int cms, bool process_io) override; @@ -130,7 +129,7 @@ class RTC_EXPORT PhysicalSocketServer : public SocketServer { bool waiting_ = false; }; -class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> { +class PhysicalSocket : public Socket, public sigslot::has_slots<> { public: PhysicalSocket(PhysicalSocketServer* ss, SOCKET s = INVALID_SOCKET); ~PhysicalSocket() override; @@ -164,7 +163,7 @@ class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> { int64_t* timestamp) override; int Listen(int backlog) override; - AsyncSocket* Accept(SocketAddress* out_addr) override; + Socket* Accept(SocketAddress* out_addr) override; int Close() override; diff --git a/rtc_base/physical_socket_server_unittest.cc b/rtc_base/physical_socket_server_unittest.cc index 3762762f85..e905375111 100644 --- a/rtc_base/physical_socket_server_unittest.cc +++ b/rtc_base/physical_socket_server_unittest.cc @@ -64,7 +64,7 @@ class FakePhysicalSocketServer : public PhysicalSocketServer { public: explicit FakePhysicalSocketServer(PhysicalSocketTest* test) : test_(test) {} - AsyncSocket* CreateAsyncSocket(int family, int type) override { + Socket* CreateSocket(int family, int type) override { SocketDispatcher* dispatcher = new FakeSocketDispatcher(this); if (!dispatcher->Create(family, type)) { delete dispatcher; @@ -73,7 +73,7 @@ class FakePhysicalSocketServer : public PhysicalSocketServer { return dispatcher; } - AsyncSocket* WrapSocket(SOCKET s) override { + Socket* WrapSocket(SOCKET s) override { SocketDispatcher* dispatcher = new FakeSocketDispatcher(s, this); if (!dispatcher->Initialize()) { delete dispatcher; @@ -106,7 +106,7 @@ class FakeNetworkBinder : public NetworkBinderInterface { class PhysicalSocketTest : public SocketTest { public: - // Set flag to simluate failures when calling "::accept" on a AsyncSocket. + // Set flag to simluate failures when calling "::accept" on a Socket. void SetFailAccept(bool fail) { fail_accept_ = fail; } bool FailAccept() const { return fail_accept_; } @@ -199,25 +199,25 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { SocketAddress accept_addr; // Create two clients. - std::unique_ptr client1( - server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client1( + server_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client1.get()); - EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, client1->GetState()); EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr())); - std::unique_ptr client2( - server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client2( + server_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client2.get()); - EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, client2->GetState()); EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr())); // Create server and listen. - std::unique_ptr server( - server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + server_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); - EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, server->GetState()); // Ensure no pending server connections, since we haven't done anything yet. EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ)); @@ -230,7 +230,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { EXPECT_NE(server->GetLocalAddress(), client1->GetLocalAddress()); // Client is connecting, outcome not yet determined. - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client1->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client1->GetState()); EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_OPEN)); EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE)); @@ -239,7 +239,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { kTimeout); // Simulate "::accept" returning an error. SetFailAccept(true); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); EXPECT_FALSE(accepted); ASSERT_TRUE(accept_addr.IsNil()); @@ -254,7 +254,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { EXPECT_NE(server->GetLocalAddress(), client2->GetLocalAddress()); // Client is connecting, outcome not yet determined. - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client2->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client2->GetState()); EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_OPEN)); EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE)); @@ -262,7 +262,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) { EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), kTimeout); SetFailAccept(false); - std::unique_ptr accepted2(server->Accept(&accept_addr)); + std::unique_ptr accepted2(server->Accept(&accept_addr)); ASSERT_TRUE(accepted2); EXPECT_FALSE(accept_addr.IsNil()); EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr); @@ -478,8 +478,7 @@ TEST_F(PhysicalSocketTest, MAYBE_SKIP_IPV4; FakeNetworkBinder fake_network_binder; server_->set_network_binder(&fake_network_binder); - std::unique_ptr socket( - server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM)); + std::unique_ptr socket(server_->CreateSocket(AF_INET, SOCK_DGRAM)); fake_network_binder.set_result(NetworkBindingResult::FAILURE); EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0))); server_->set_network_binder(nullptr); @@ -490,8 +489,7 @@ TEST_F(PhysicalSocketTest, NetworkBinderIsNotUsedForAnyIp) { MAYBE_SKIP_IPV4; FakeNetworkBinder fake_network_binder; server_->set_network_binder(&fake_network_binder); - std::unique_ptr socket( - server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM)); + std::unique_ptr socket(server_->CreateSocket(AF_INET, SOCK_DGRAM)); EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0))); EXPECT_EQ(0, fake_network_binder.num_binds()); server_->set_network_binder(nullptr); @@ -504,8 +502,7 @@ TEST_F(PhysicalSocketTest, MAYBE_SKIP_IPV4; FakeNetworkBinder fake_network_binder; server_->set_network_binder(&fake_network_binder); - std::unique_ptr socket( - server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM)); + std::unique_ptr socket(server_->CreateSocket(AF_INET, SOCK_DGRAM)); fake_network_binder.set_result(NetworkBindingResult::FAILURE); EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0))); server_->set_network_binder(nullptr); diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc index a7e8bf5cb7..652e4c5ce8 100644 --- a/rtc_base/proxy_server.cc +++ b/rtc_base/proxy_server.cc @@ -27,7 +27,7 @@ ProxyServer::ProxyServer(SocketFactory* int_factory, : ext_factory_(ext_factory), ext_ip_(ext_ip.ipaddr(), 0), // strip off port server_socket_( - int_factory->CreateAsyncSocket(int_addr.family(), SOCK_STREAM)) { + int_factory->CreateSocket(int_addr.family(), SOCK_STREAM)) { RTC_DCHECK(server_socket_.get() != nullptr); RTC_DCHECK(int_addr.family() == AF_INET || int_addr.family() == AF_INET6); server_socket_->Bind(int_addr); @@ -41,13 +41,13 @@ SocketAddress ProxyServer::GetServerAddress() { return server_socket_->GetLocalAddress(); } -void ProxyServer::OnAcceptEvent(AsyncSocket* socket) { +void ProxyServer::OnAcceptEvent(Socket* socket) { RTC_DCHECK(socket); RTC_DCHECK_EQ(socket, server_socket_.get()); - AsyncSocket* int_socket = socket->Accept(nullptr); + Socket* int_socket = socket->Accept(nullptr); AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket); - AsyncSocket* ext_socket = - ext_factory_->CreateAsyncSocket(ext_ip_.family(), SOCK_STREAM); + Socket* ext_socket = + ext_factory_->CreateSocket(ext_ip_.family(), SOCK_STREAM); if (ext_socket) { ext_socket->Bind(ext_ip_); bindings_.emplace_back( @@ -60,7 +60,7 @@ void ProxyServer::OnAcceptEvent(AsyncSocket* socket) { // ProxyBinding ProxyBinding::ProxyBinding(AsyncProxyServerSocket* int_socket, - AsyncSocket* ext_socket) + Socket* ext_socket) : int_socket_(int_socket), ext_socket_(ext_socket), connected_(false), @@ -88,42 +88,42 @@ void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket, // TODO: handle errors here } -void ProxyBinding::OnInternalRead(AsyncSocket* socket) { +void ProxyBinding::OnInternalRead(Socket* socket) { Read(int_socket_.get(), &out_buffer_); Write(ext_socket_.get(), &out_buffer_); } -void ProxyBinding::OnInternalWrite(AsyncSocket* socket) { +void ProxyBinding::OnInternalWrite(Socket* socket) { Write(int_socket_.get(), &in_buffer_); } -void ProxyBinding::OnInternalClose(AsyncSocket* socket, int err) { +void ProxyBinding::OnInternalClose(Socket* socket, int err) { Destroy(); } -void ProxyBinding::OnExternalConnect(AsyncSocket* socket) { +void ProxyBinding::OnExternalConnect(Socket* socket) { RTC_DCHECK(socket != nullptr); connected_ = true; int_socket_->SendConnectResult(0, socket->GetRemoteAddress()); } -void ProxyBinding::OnExternalRead(AsyncSocket* socket) { +void ProxyBinding::OnExternalRead(Socket* socket) { Read(ext_socket_.get(), &in_buffer_); Write(int_socket_.get(), &in_buffer_); } -void ProxyBinding::OnExternalWrite(AsyncSocket* socket) { +void ProxyBinding::OnExternalWrite(Socket* socket) { Write(ext_socket_.get(), &out_buffer_); } -void ProxyBinding::OnExternalClose(AsyncSocket* socket, int err) { +void ProxyBinding::OnExternalClose(Socket* socket, int err) { if (!connected_) { int_socket_->SendConnectResult(err, SocketAddress()); } Destroy(); } -void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) { +void ProxyBinding::Read(Socket* socket, FifoBuffer* buffer) { // Only read if the buffer is empty. RTC_DCHECK(socket != nullptr); size_t size; @@ -135,7 +135,7 @@ void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) { } } -void ProxyBinding::Write(AsyncSocket* socket, FifoBuffer* buffer) { +void ProxyBinding::Write(Socket* socket, FifoBuffer* buffer) { RTC_DCHECK(socket != nullptr); size_t size; int written; @@ -148,7 +148,7 @@ void ProxyBinding::Destroy() { SignalDestroyed(this); } -AsyncProxyServerSocket* SocksProxyServer::WrapSocket(AsyncSocket* socket) { +AsyncProxyServerSocket* SocksProxyServer::WrapSocket(Socket* socket) { return new AsyncSocksProxyServerSocket(socket); } diff --git a/rtc_base/proxy_server.h b/rtc_base/proxy_server.h index 139cc9138c..6db0e12897 100644 --- a/rtc_base/proxy_server.h +++ b/rtc_base/proxy_server.h @@ -15,10 +15,10 @@ #include #include "absl/memory/memory.h" -#include "rtc_base/async_socket.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/memory/fifo_buffer.h" #include "rtc_base/server_socket_adapters.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" namespace rtc { @@ -34,28 +34,28 @@ class SocketFactory; class ProxyBinding : public sigslot::has_slots<> { public: - ProxyBinding(AsyncProxyServerSocket* in_socket, AsyncSocket* out_socket); + ProxyBinding(AsyncProxyServerSocket* in_socket, Socket* out_socket); ~ProxyBinding() override; sigslot::signal1 SignalDestroyed; private: void OnConnectRequest(AsyncProxyServerSocket* socket, const SocketAddress& addr); - void OnInternalRead(AsyncSocket* socket); - void OnInternalWrite(AsyncSocket* socket); - void OnInternalClose(AsyncSocket* socket, int err); - void OnExternalConnect(AsyncSocket* socket); - void OnExternalRead(AsyncSocket* socket); - void OnExternalWrite(AsyncSocket* socket); - void OnExternalClose(AsyncSocket* socket, int err); + 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); - static void Read(AsyncSocket* socket, FifoBuffer* buffer); - static void Write(AsyncSocket* socket, FifoBuffer* buffer); + static void Read(Socket* socket, FifoBuffer* buffer); + static void Write(Socket* socket, FifoBuffer* buffer); void Destroy(); static const int kBufferSize = 4096; std::unique_ptr int_socket_; - std::unique_ptr ext_socket_; + std::unique_ptr ext_socket_; bool connected_; FifoBuffer out_buffer_; FifoBuffer in_buffer_; @@ -74,13 +74,13 @@ class ProxyServer : public sigslot::has_slots<> { SocketAddress GetServerAddress(); protected: - void OnAcceptEvent(AsyncSocket* socket); - virtual AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) = 0; + void OnAcceptEvent(Socket* socket); + virtual AsyncProxyServerSocket* WrapSocket(Socket* socket) = 0; private: SocketFactory* ext_factory_; SocketAddress ext_ip_; - std::unique_ptr server_socket_; + std::unique_ptr server_socket_; std::vector> bindings_; RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer); }; @@ -95,7 +95,7 @@ class SocksProxyServer : public ProxyServer { : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {} protected: - AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override; + AsyncProxyServerSocket* WrapSocket(Socket* socket) override; RTC_DISALLOW_COPY_AND_ASSIGN(SocksProxyServer); }; diff --git a/rtc_base/proxy_unittest.cc b/rtc_base/proxy_unittest.cc index d73d9de038..9e3898e430 100644 --- a/rtc_base/proxy_unittest.cc +++ b/rtc_base/proxy_unittest.cc @@ -43,8 +43,8 @@ class ProxyTest : public ::testing::Test { // Tests whether we can use a SOCKS5 proxy to connect to a server. TEST_F(ProxyTest, TestSocks5Connect) { - rtc::AsyncSocket* socket = - ss()->CreateAsyncSocket(kSocksProxyIntAddr.family(), SOCK_STREAM); + rtc::Socket* socket = + ss()->CreateSocket(kSocksProxyIntAddr.family(), SOCK_STREAM); rtc::AsyncSocksProxySocket* proxy_socket = new rtc::AsyncSocksProxySocket( socket, kSocksProxyIntAddr, "", rtc::CryptString()); // TODO: IPv6-ize these tests when proxy supports IPv6. diff --git a/rtc_base/server_socket_adapters.cc b/rtc_base/server_socket_adapters.cc index ebe420ca05..673083c7cd 100644 --- a/rtc_base/server_socket_adapters.cc +++ b/rtc_base/server_socket_adapters.cc @@ -16,13 +16,13 @@ namespace rtc { -AsyncProxyServerSocket::AsyncProxyServerSocket(AsyncSocket* socket, +AsyncProxyServerSocket::AsyncProxyServerSocket(Socket* socket, size_t buffer_size) : BufferedReadAdapter(socket, buffer_size) {} AsyncProxyServerSocket::~AsyncProxyServerSocket() = default; -AsyncSSLServerSocket::AsyncSSLServerSocket(AsyncSocket* socket) +AsyncSSLServerSocket::AsyncSSLServerSocket(Socket* socket) : BufferedReadAdapter(socket, 1024) { BufferInput(true); } @@ -55,7 +55,7 @@ void AsyncSSLServerSocket::ProcessInput(char* data, size_t* len) { BufferInput(false); } -AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(AsyncSocket* socket) +AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(Socket* socket) : AsyncProxyServerSocket(socket, kBufferSize), state_(SS_HELLO) { BufferInput(true); } diff --git a/rtc_base/server_socket_adapters.h b/rtc_base/server_socket_adapters.h index a534eeaf64..07e9636756 100644 --- a/rtc_base/server_socket_adapters.h +++ b/rtc_base/server_socket_adapters.h @@ -18,7 +18,7 @@ namespace rtc { // Interface for implementing proxy server sockets. class AsyncProxyServerSocket : public BufferedReadAdapter { public: - AsyncProxyServerSocket(AsyncSocket* socket, size_t buffer_size); + AsyncProxyServerSocket(Socket* socket, size_t buffer_size); ~AsyncProxyServerSocket() override; sigslot::signal2 SignalConnectRequest; @@ -29,7 +29,7 @@ class AsyncProxyServerSocket : public BufferedReadAdapter { // fake SSL handshake. Used when implementing a relay server that does "ssltcp". class AsyncSSLServerSocket : public BufferedReadAdapter { public: - explicit AsyncSSLServerSocket(AsyncSocket* socket); + explicit AsyncSSLServerSocket(Socket* socket); protected: void ProcessInput(char* data, size_t* len) override; @@ -39,7 +39,7 @@ class AsyncSSLServerSocket : public BufferedReadAdapter { // Implements a proxy server socket for the SOCKS protocol. class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket { public: - explicit AsyncSocksProxyServerSocket(AsyncSocket* socket); + explicit AsyncSocksProxyServerSocket(Socket* socket); private: void ProcessInput(char* data, size_t* len) override; diff --git a/rtc_base/socket.h b/rtc_base/socket.h index 81f4f0b1d4..e38f8afe3c 100644 --- a/rtc_base/socket.h +++ b/rtc_base/socket.h @@ -25,8 +25,10 @@ #include "rtc_base/win32.h" #endif +#include "absl/base/attributes.h" #include "rtc_base/constructor_magic.h" #include "rtc_base/socket_address.h" +#include "rtc_base/third_party/sigslot/sigslot.h" // Rather than converting errors into a private namespace, // Reuse the POSIX socket api errors. Note this depends on @@ -124,6 +126,17 @@ class Socket { virtual int GetOption(Option opt, int* value) = 0; virtual int SetOption(Option opt, int value) = 0; + // SignalReadEvent and SignalWriteEvent use multi_threaded_local to allow + // access concurrently from different thread. + // For example SignalReadEvent::connect will be called in AsyncUDPSocket ctor + // but at the same time the SocketDispatcher may be signaling the read event. + // ready to read + sigslot::signal1 SignalReadEvent; + // ready to write + sigslot::signal1 SignalWriteEvent; + sigslot::signal1 SignalConnectEvent; // connected + sigslot::signal2 SignalCloseEvent; // closed + protected: Socket() {} @@ -131,6 +144,10 @@ class Socket { RTC_DISALLOW_COPY_AND_ASSIGN(Socket); }; +// TODO(bugs.webrtc.org/13065): Old alias, delete ASAP, when downstream code is +// updated. +using AsyncSocket ABSL_DEPRECATED("bugs.webrtc.org/13065") = Socket; + } // namespace rtc #endif // RTC_BASE_SOCKET_H_ diff --git a/rtc_base/socket_adapters.cc b/rtc_base/socket_adapters.cc index ee20a76e32..08e967b6fa 100644 --- a/rtc_base/socket_adapters.cc +++ b/rtc_base/socket_adapters.cc @@ -26,7 +26,7 @@ namespace rtc { -BufferedReadAdapter::BufferedReadAdapter(AsyncSocket* socket, size_t size) +BufferedReadAdapter::BufferedReadAdapter(Socket* socket, size_t size) : AsyncSocketAdapter(socket), buffer_size_(size), data_len_(0), @@ -87,7 +87,7 @@ void BufferedReadAdapter::BufferInput(bool on) { buffering_ = on; } -void BufferedReadAdapter::OnReadEvent(AsyncSocket* socket) { +void BufferedReadAdapter::OnReadEvent(Socket* socket) { RTC_DCHECK(socket == GetSocket()); if (!buffering_) { @@ -168,7 +168,7 @@ ArrayView AsyncSSLSocket::SslServerHello() { return {kSslServerHello, sizeof(kSslServerHello)}; } -AsyncSSLSocket::AsyncSSLSocket(AsyncSocket* socket) +AsyncSSLSocket::AsyncSSLSocket(Socket* socket) : BufferedReadAdapter(socket, 1024) {} int AsyncSSLSocket::Connect(const SocketAddress& addr) { @@ -178,7 +178,7 @@ int AsyncSSLSocket::Connect(const SocketAddress& addr) { return BufferedReadAdapter::Connect(addr); } -void AsyncSSLSocket::OnConnectEvent(AsyncSocket* socket) { +void AsyncSSLSocket::OnConnectEvent(Socket* socket) { RTC_DCHECK(socket == GetSocket()); // TODO: we could buffer output too... const int res = DirectSend(kSslClientHello, sizeof(kSslClientHello)); @@ -211,7 +211,7 @@ void AsyncSSLSocket::ProcessInput(char* data, size_t* len) { /////////////////////////////////////////////////////////////////////////////// -AsyncHttpsProxySocket::AsyncHttpsProxySocket(AsyncSocket* socket, +AsyncHttpsProxySocket::AsyncHttpsProxySocket(Socket* socket, const std::string& user_agent, const SocketAddress& proxy, const std::string& username, @@ -266,7 +266,7 @@ Socket::ConnState AsyncHttpsProxySocket::GetState() const { } } -void AsyncHttpsProxySocket::OnConnectEvent(AsyncSocket* socket) { +void AsyncHttpsProxySocket::OnConnectEvent(Socket* socket) { RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnConnectEvent"; if (!ShouldIssueConnect()) { state_ = PS_TUNNEL; @@ -276,7 +276,7 @@ void AsyncHttpsProxySocket::OnConnectEvent(AsyncSocket* socket) { SendRequest(); } -void AsyncHttpsProxySocket::OnCloseEvent(AsyncSocket* socket, int err) { +void AsyncHttpsProxySocket::OnCloseEvent(Socket* socket, int err) { RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnCloseEvent(" << err << ")"; if ((state_ == PS_WAIT_CLOSE) && (err == 0)) { state_ = PS_ERROR; @@ -463,7 +463,7 @@ void AsyncHttpsProxySocket::Error(int error) { /////////////////////////////////////////////////////////////////////////////// -AsyncSocksProxySocket::AsyncSocksProxySocket(AsyncSocket* socket, +AsyncSocksProxySocket::AsyncSocksProxySocket(Socket* socket, const SocketAddress& proxy, const std::string& username, const CryptString& password) @@ -505,7 +505,7 @@ Socket::ConnState AsyncSocksProxySocket::GetState() const { } } -void AsyncSocksProxySocket::OnConnectEvent(AsyncSocket* socket) { +void AsyncSocksProxySocket::OnConnectEvent(Socket* socket) { SendHello(); } diff --git a/rtc_base/socket_adapters.h b/rtc_base/socket_adapters.h index 99c9109d7f..67d3bbff7d 100644 --- a/rtc_base/socket_adapters.h +++ b/rtc_base/socket_adapters.h @@ -31,7 +31,7 @@ class ByteBufferWriter; // protocol before commencing normal socket behavior. class BufferedReadAdapter : public AsyncSocketAdapter { public: - BufferedReadAdapter(AsyncSocket* socket, size_t buffer_size); + BufferedReadAdapter(Socket* socket, size_t buffer_size); ~BufferedReadAdapter() override; int Send(const void* pv, size_t cb) override; @@ -45,7 +45,7 @@ class BufferedReadAdapter : public AsyncSocketAdapter { void BufferInput(bool on = true); virtual void ProcessInput(char* data, size_t* len) = 0; - void OnReadEvent(AsyncSocket* socket) override; + void OnReadEvent(Socket* socket) override; private: char* buffer_; @@ -63,12 +63,12 @@ class AsyncSSLSocket : public BufferedReadAdapter { static ArrayView SslClientHello(); static ArrayView SslServerHello(); - explicit AsyncSSLSocket(AsyncSocket* socket); + explicit AsyncSSLSocket(Socket* socket); int Connect(const SocketAddress& addr) override; protected: - void OnConnectEvent(AsyncSocket* socket) override; + void OnConnectEvent(Socket* socket) override; void ProcessInput(char* data, size_t* len) override; RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket); }; @@ -78,7 +78,7 @@ class AsyncSSLSocket : public BufferedReadAdapter { // Implements a socket adapter that speaks the HTTP/S proxy protocol. class AsyncHttpsProxySocket : public BufferedReadAdapter { public: - AsyncHttpsProxySocket(AsyncSocket* socket, + AsyncHttpsProxySocket(Socket* socket, const std::string& user_agent, const SocketAddress& proxy, const std::string& username, @@ -96,8 +96,8 @@ class AsyncHttpsProxySocket : public BufferedReadAdapter { ConnState GetState() const override; protected: - void OnConnectEvent(AsyncSocket* socket) override; - void OnCloseEvent(AsyncSocket* socket, int err) override; + void OnConnectEvent(Socket* socket) override; + void OnCloseEvent(Socket* socket, int err) override; void ProcessInput(char* data, size_t* len) override; bool ShouldIssueConnect() const; @@ -136,7 +136,7 @@ class AsyncHttpsProxySocket : public BufferedReadAdapter { // Implements a socket adapter that speaks the SOCKS proxy protocol. class AsyncSocksProxySocket : public BufferedReadAdapter { public: - AsyncSocksProxySocket(AsyncSocket* socket, + AsyncSocksProxySocket(Socket* socket, const SocketAddress& proxy, const std::string& username, const CryptString& password); @@ -148,7 +148,7 @@ class AsyncSocksProxySocket : public BufferedReadAdapter { ConnState GetState() const override; protected: - void OnConnectEvent(AsyncSocket* socket) override; + void OnConnectEvent(Socket* socket) override; void ProcessInput(char* data, size_t* len) override; void SendHello(); diff --git a/rtc_base/socket_factory.h b/rtc_base/socket_factory.h index 7356745c72..b43bd1bf31 100644 --- a/rtc_base/socket_factory.h +++ b/rtc_base/socket_factory.h @@ -11,7 +11,6 @@ #ifndef RTC_BASE_SOCKET_FACTORY_H_ #define RTC_BASE_SOCKET_FACTORY_H_ -#include "rtc_base/async_socket.h" #include "rtc_base/socket.h" namespace rtc { @@ -20,12 +19,12 @@ class SocketFactory { public: virtual ~SocketFactory() {} - // Returns a new socket for blocking communication. The type can be - // SOCK_DGRAM and SOCK_STREAM. + // Returns a new socket. The type can be SOCK_DGRAM and SOCK_STREAM. virtual Socket* CreateSocket(int family, int type) = 0; - // Returns a new socket for nonblocking communication. The type can be - // SOCK_DGRAM and SOCK_STREAM. - virtual AsyncSocket* CreateAsyncSocket(int family, int type) = 0; + // TODO(nisse): Delete old alias, ASAP when downstream code is updated. + virtual Socket* CreateAsyncSocket(int family, int type) { + return CreateSocket(family, type); + } }; } // namespace rtc diff --git a/rtc_base/socket_stream.cc b/rtc_base/socket_stream.cc index e93d6aa3a0..a526f0c0c8 100644 --- a/rtc_base/socket_stream.cc +++ b/rtc_base/socket_stream.cc @@ -15,7 +15,7 @@ namespace rtc { -SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) { +SocketStream::SocketStream(Socket* socket) : socket_(nullptr) { Attach(socket); } @@ -23,7 +23,7 @@ SocketStream::~SocketStream() { delete socket_; } -void SocketStream::Attach(AsyncSocket* socket) { +void SocketStream::Attach(Socket* socket) { if (socket_) delete socket_; socket_ = socket; @@ -35,8 +35,8 @@ void SocketStream::Attach(AsyncSocket* socket) { } } -AsyncSocket* SocketStream::Detach() { - AsyncSocket* socket = socket_; +Socket* SocketStream::Detach() { + Socket* socket = socket_; if (socket_) { socket_->SignalConnectEvent.disconnect(this); socket_->SignalReadEvent.disconnect(this); @@ -104,22 +104,22 @@ void SocketStream::Close() { socket_->Close(); } -void SocketStream::OnConnectEvent(AsyncSocket* socket) { +void SocketStream::OnConnectEvent(Socket* socket) { RTC_DCHECK(socket == socket_); SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0); } -void SocketStream::OnReadEvent(AsyncSocket* socket) { +void SocketStream::OnReadEvent(Socket* socket) { RTC_DCHECK(socket == socket_); SignalEvent(this, SE_READ, 0); } -void SocketStream::OnWriteEvent(AsyncSocket* socket) { +void SocketStream::OnWriteEvent(Socket* socket) { RTC_DCHECK(socket == socket_); SignalEvent(this, SE_WRITE, 0); } -void SocketStream::OnCloseEvent(AsyncSocket* socket, int err) { +void SocketStream::OnCloseEvent(Socket* socket, int err) { RTC_DCHECK(socket == socket_); SignalEvent(this, SE_CLOSE, err); } diff --git a/rtc_base/socket_stream.h b/rtc_base/socket_stream.h index f9875fe41e..266a6e6fe6 100644 --- a/rtc_base/socket_stream.h +++ b/rtc_base/socket_stream.h @@ -13,8 +13,8 @@ #include -#include "rtc_base/async_socket.h" #include "rtc_base/constructor_magic.h" +#include "rtc_base/socket.h" #include "rtc_base/stream.h" #include "rtc_base/third_party/sigslot/sigslot.h" @@ -24,13 +24,13 @@ namespace rtc { class SocketStream : public StreamInterface, public sigslot::has_slots<> { public: - explicit SocketStream(AsyncSocket* socket); + explicit SocketStream(Socket* socket); ~SocketStream() override; - void Attach(AsyncSocket* socket); - AsyncSocket* Detach(); + void Attach(Socket* socket); + Socket* Detach(); - AsyncSocket* GetSocket() { return socket_; } + Socket* GetSocket() { return socket_; } StreamState GetState() const override; @@ -47,12 +47,12 @@ class SocketStream : public StreamInterface, public sigslot::has_slots<> { void Close() override; private: - void OnConnectEvent(AsyncSocket* socket); - void OnReadEvent(AsyncSocket* socket); - void OnWriteEvent(AsyncSocket* socket); - void OnCloseEvent(AsyncSocket* socket, int err); + void OnConnectEvent(Socket* socket); + void OnReadEvent(Socket* socket); + void OnWriteEvent(Socket* socket); + void OnCloseEvent(Socket* socket, int err); - AsyncSocket* socket_; + Socket* socket_; RTC_DISALLOW_COPY_AND_ASSIGN(SocketStream); }; diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc index 82e2f6d4b2..720dc6ccc7 100644 --- a/rtc_base/socket_unittest.cc +++ b/rtc_base/socket_unittest.cc @@ -19,7 +19,6 @@ #include "absl/memory/memory.h" #include "rtc_base/arraysize.h" #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/buffer.h" #include "rtc_base/gunit.h" @@ -242,19 +241,19 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); - EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, client->GetState()); EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr())); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); - EXPECT_EQ(AsyncSocket::CS_CONNECTING, server->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, server->GetState()); // Ensure no pending server connections, since we haven't done anything yet. EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); @@ -267,24 +266,24 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) { EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress()); // Client is connecting, outcome not yet determined. - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client->GetState()); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); // Server has pending connection, accept it. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); // Connected from server perspective, check the addresses are correct. - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); // Connected from client perspective, check the addresses are correct. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -297,13 +296,13 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback, SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -316,24 +315,24 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback, // EXPECT_NE(kEmptyAddr, client->GetLocalAddress()); // Implicit Bind // Client is connecting, outcome not yet determined. - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client->GetState()); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); // Server has pending connection, accept it. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); // Connected from server perspective, check the addresses are correct. - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); // Connected from client perspective, check the addresses are correct. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -345,13 +344,13 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server, but don't listen yet. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); @@ -362,7 +361,7 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(bogus_addr)); // Wait for connection to fail (ECONNREFUSED). - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(client->GetRemoteAddress().IsNil()); @@ -378,13 +377,13 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server, but don't listen yet. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); @@ -396,15 +395,14 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) { // Wait for connection to fail (EHOSTNOTFOUND). bool dns_lookup_finished = false; - WAIT_(client->GetState() == AsyncSocket::CS_CLOSED, kTimeout, - dns_lookup_finished); + WAIT_(client->GetState() == Socket::CS_CLOSED, kTimeout, dns_lookup_finished); if (!dns_lookup_finished) { RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 " "seconds."; return; } - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(client->GetRemoteAddress().IsNil()); @@ -416,35 +414,35 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) { void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) { // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); // Create a client and put in to CS_CLOSED state. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); EXPECT_EQ(0, client->Close()); - EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, client->GetState()); // Connect() should reinitialize the socket, and put it in to CS_CONNECTING. EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress()))); - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client->GetState()); } void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { // Create server and listen. StreamSink sink; - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); // Create client, connect. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress()))); - EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTING, client->GetState()); // Try to connect again. Should fail, but not interfere with original attempt. EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(server->GetLocalAddress()))); @@ -452,15 +450,15 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { // Accept the original connection. SocketAddress accept_addr; EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); EXPECT_FALSE(accept_addr.IsNil()); // Check the states and addresses. - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); @@ -468,8 +466,8 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { // Shouldn't break anything. EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress( "localhost", server->GetLocalAddress().port()))); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); } @@ -478,13 +476,13 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) { StreamSink sink; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -497,7 +495,7 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) { server->Close(); // This should fail the connection for the client. Clean up. - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); client->Close(); } @@ -507,13 +505,13 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -526,13 +524,13 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) { client->Close(); // The connection should still be able to be accepted. - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); // The accepted socket should then close (possibly with err, timing-related) - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, accepted->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, accepted->GetState(), kTimeout); EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) || sink.Check(accepted.get(), SSE_ERROR)); @@ -545,13 +543,13 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -561,12 +559,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { // Accept connection. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); @@ -574,12 +572,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { // Send data to the client, and then close the connection. EXPECT_EQ(1, accepted->Send("a", 1)); accepted->Close(); - EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState()); // Expect that the client is notified, and has not yet closed. EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); // Ensure the data can be read. char buffer[10]; @@ -587,7 +585,7 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { EXPECT_EQ('a', buffer[0]); // Now we should close, but the remote address will remain. - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP()); @@ -607,7 +605,7 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) { class SocketCloser : public sigslot::has_slots<> { public: - void OnClose(AsyncSocket* socket, int error) { + void OnClose(Socket* socket, int error) { socket->Close(); // Deleting here would blow up the vector of handlers // for the socket's signal. } @@ -619,14 +617,14 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -636,26 +634,26 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) { // Accept connection. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); // Send data to the client, and then close the connection. accepted->Close(); - EXPECT_EQ(AsyncSocket::CS_CLOSED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, accepted->GetState()); // Expect that the client is notified, and has not yet closed. EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, client->GetState()); // Now we should be closed and invalidated - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_TRUE(Socket::CS_CLOSED == client->GetState()); } @@ -663,25 +661,25 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) { // Helper class specifically for the test below. class SocketDeleter : public sigslot::has_slots<> { public: - explicit SocketDeleter(std::unique_ptr socket) + explicit SocketDeleter(std::unique_ptr socket) : socket_(std::move(socket)) {} - void Delete(AsyncSocket* other) { socket_.reset(); } + void Delete(Socket* other) { socket_.reset(); } bool deleted() const { return socket_ == nullptr; } private: - std::unique_ptr socket_; + std::unique_ptr socket_; }; // 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 IPAddress& loopback) { - std::unique_ptr socket1( - ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); - std::unique_ptr socket2( - ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); + std::unique_ptr socket1( + ss_->CreateSocket(loopback.family(), SOCK_DGRAM)); + std::unique_ptr socket2( + ss_->CreateSocket(loopback.family(), SOCK_DGRAM)); 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())); @@ -706,10 +704,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create & connect server and client sockets. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); @@ -718,14 +716,14 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(server->GetLocalAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); @@ -742,7 +740,7 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) { std::unique_ptr thread(Thread::CreateWithSocketServer()); thread->Start(); Sleeper sleeper; - TypedMessageData data(client.get()); + TypedMessageData data(client.get()); thread->Send(RTC_FROM_HERE, &sleeper, 0, &data); EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ)); @@ -758,13 +756,13 @@ void SocketTest::TcpInternal(const IPAddress& loopback, SocketAddress accept_addr; // Create receiving client. - std::unique_ptr receiver( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr receiver( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(receiver.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -774,12 +772,12 @@ void SocketTest::TcpInternal(const IPAddress& loopback, // Accept connection which will be used for sending. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr sender(server->Accept(&accept_addr)); + std::unique_ptr sender(server->Accept(&accept_addr)); ASSERT_TRUE(sender); sink.Monitor(sender.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, receiver->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, receiver->GetState(), kTimeout); EXPECT_TRUE(sink.Check(receiver.get(), SSE_OPEN)); EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress()); EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress()); @@ -874,7 +872,7 @@ void SocketTest::TcpInternal(const IPAddress& loopback, // Close down. sender->Close(); - EXPECT_EQ_WAIT(AsyncSocket::CS_CLOSED, receiver->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CLOSED, receiver->GetState(), kTimeout); EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE)); receiver->Close(); } @@ -884,13 +882,13 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { SocketAddress accept_addr; // Create client. - std::unique_ptr client( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server and listen. - std::unique_ptr server( - ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_->CreateSocket(loopback.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Listen(5)); @@ -900,12 +898,12 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { // Accept connection. EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(accepted); sink.Monitor(accepted.get()); // Both sides are now connected. - EXPECT_EQ_WAIT(AsyncSocket::CS_CONNECTED, client->GetState(), kTimeout); + EXPECT_EQ_WAIT(Socket::CS_CONNECTED, client->GetState(), kTimeout); EXPECT_TRUE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); @@ -951,14 +949,14 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) { void SocketTest::UdpInternal(const IPAddress& loopback) { SocketAddress empty = EmptySocketAddressWithFamily(loopback.family()); // Test basic bind and connect behavior. - AsyncSocket* socket = ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM); - EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState()); + Socket* socket = ss_->CreateSocket(loopback.family(), SOCK_DGRAM); + EXPECT_EQ(Socket::CS_CLOSED, socket->GetState()); EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0))); SocketAddress addr1 = socket->GetLocalAddress(); EXPECT_EQ(0, socket->Connect(addr1)); - EXPECT_EQ(AsyncSocket::CS_CONNECTED, socket->GetState()); + EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState()); socket->Close(); - EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState()); + EXPECT_EQ(Socket::CS_CLOSED, socket->GetState()); delete socket; // Test send/receive behavior. @@ -1041,8 +1039,8 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) { } void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) { - std::unique_ptr socket( - ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); + std::unique_ptr socket( + ss_->CreateSocket(loopback.family(), SOCK_DGRAM)); socket->Bind(SocketAddress(loopback, 0)); // Check SNDBUF/RCVBUF. diff --git a/rtc_base/ssl_adapter.cc b/rtc_base/ssl_adapter.cc index 9d414ea2ff..c9b54c4dc9 100644 --- a/rtc_base/ssl_adapter.cc +++ b/rtc_base/ssl_adapter.cc @@ -20,7 +20,7 @@ SSLAdapterFactory* SSLAdapterFactory::Create() { return new OpenSSLAdapterFactory(); } -SSLAdapter* SSLAdapter::Create(AsyncSocket* socket) { +SSLAdapter* SSLAdapter::Create(Socket* socket) { return new OpenSSLAdapter(socket); } diff --git a/rtc_base/ssl_adapter.h b/rtc_base/ssl_adapter.h index 2605770872..1f0616bffc 100644 --- a/rtc_base/ssl_adapter.h +++ b/rtc_base/ssl_adapter.h @@ -40,7 +40,7 @@ class SSLAdapterFactory { virtual void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) = 0; // Creates a new SSL adapter, but from a shared context. - virtual SSLAdapter* CreateAdapter(AsyncSocket* socket) = 0; + virtual SSLAdapter* CreateAdapter(Socket* socket) = 0; static SSLAdapterFactory* Create(); }; @@ -52,7 +52,7 @@ class SSLAdapterFactory { // After creation, call StartSSL to initiate the SSL handshake to the server. class SSLAdapter : public AsyncSocketAdapter { public: - explicit SSLAdapter(AsyncSocket* socket) : AsyncSocketAdapter(socket) {} + explicit SSLAdapter(Socket* socket) : AsyncSocketAdapter(socket) {} // Methods that control server certificate verification, used in unit tests. // Do not call these methods in production code. @@ -90,7 +90,7 @@ class SSLAdapter : public AsyncSocketAdapter { // 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(AsyncSocket* socket); + static SSLAdapter* Create(Socket* socket); }; /////////////////////////////////////////////////////////////////////////////// diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc index 498eba312b..2b55211086 100644 --- a/rtc_base/ssl_adapter_unittest.cc +++ b/rtc_base/ssl_adapter_unittest.cc @@ -30,13 +30,12 @@ using ::testing::Return; static const int kTimeout = 5000; -static rtc::AsyncSocket* CreateSocket(const rtc::SSLMode& ssl_mode) { +static rtc::Socket* CreateSocket(const rtc::SSLMode& ssl_mode) { rtc::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0); - rtc::AsyncSocket* socket = - rtc::Thread::Current()->socketserver()->CreateAsyncSocket( - address.family(), - (ssl_mode == rtc::SSL_MODE_DTLS) ? SOCK_DGRAM : SOCK_STREAM); + rtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket( + address.family(), + (ssl_mode == rtc::SSL_MODE_DTLS) ? SOCK_DGRAM : SOCK_STREAM); socket->Bind(address); return socket; @@ -59,7 +58,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> { public: explicit SSLAdapterTestDummyClient(const rtc::SSLMode& ssl_mode) : ssl_mode_(ssl_mode) { - rtc::AsyncSocket* socket = CreateSocket(ssl_mode_); + rtc::Socket* socket = CreateSocket(ssl_mode_); ssl_adapter_.reset(rtc::SSLAdapter::Create(socket)); @@ -96,9 +95,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> { return ssl_adapter_->GetLocalAddress(); } - rtc::AsyncSocket::ConnState GetState() const { - return ssl_adapter_->GetState(); - } + rtc::Socket::ConnState GetState() const { return ssl_adapter_->GetState(); } const std::string& GetReceivedData() const { return data_; } @@ -127,7 +124,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> { return ssl_adapter_->Send(message.data(), message.length()); } - void OnSSLAdapterReadEvent(rtc::AsyncSocket* socket) { + void OnSSLAdapterReadEvent(rtc::Socket* socket) { char buffer[4096] = ""; // Read data received from the server and store it in our internal buffer. @@ -141,11 +138,11 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> { } } - void OnSSLAdapterCloseEvent(rtc::AsyncSocket* socket, int error) { + void OnSSLAdapterCloseEvent(rtc::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::AsyncSocket::CS_CLOSED) { + if (socket->GetState() != rtc::Socket::CS_CLOSED) { socket->Close(); } } @@ -221,14 +218,14 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> { ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_); // Transfer ownership of the socket to the SSLStreamAdapter object. - rtc::AsyncSocket* socket = server_socket_.release(); + rtc::Socket* socket = server_socket_.release(); socket->Connect(address); DoHandshake(socket); } - void OnServerSocketReadEvent(rtc::AsyncSocket* socket) { + void OnServerSocketReadEvent(rtc::Socket* socket) { // Only a single connection is supported. ASSERT_TRUE(ssl_stream_adapter_ == nullptr); @@ -254,7 +251,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> { } private: - void DoHandshake(rtc::AsyncSocket* socket) { + void DoHandshake(rtc::Socket* socket) { ssl_stream_adapter_ = rtc::SSLStreamAdapter::Create( std::make_unique(socket)); @@ -284,7 +281,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> { const rtc::SSLMode ssl_mode_; - std::unique_ptr server_socket_; + std::unique_ptr server_socket_; std::unique_ptr ssl_stream_adapter_; std::unique_ptr ssl_identity_; @@ -335,13 +332,13 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { int rv; // The initial state is CS_CLOSED - ASSERT_EQ(rtc::AsyncSocket::CS_CLOSED, client_->GetState()); + ASSERT_EQ(rtc::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::AsyncSocket::CS_CONNECTING, client_->GetState()); + ASSERT_EQ(rtc::Socket::CS_CONNECTING, client_->GetState()); if (ssl_mode_ == rtc::SSL_MODE_DTLS) { // For DTLS, call AcceptConnection() with the client's address. @@ -351,7 +348,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { if (expect_success) { // If expecting success, the client should end up in the CS_CONNECTED // state after handshake. - EXPECT_EQ_WAIT(rtc::AsyncSocket::CS_CONNECTED, client_->GetState(), + EXPECT_EQ_WAIT(rtc::Socket::CS_CONNECTED, client_->GetState(), handshake_wait_); RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_) @@ -359,7 +356,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> { } else { // On handshake failure the client should end up in the CS_CLOSED state. - EXPECT_EQ_WAIT(rtc::AsyncSocket::CS_CLOSED, client_->GetState(), + EXPECT_EQ_WAIT(rtc::Socket::CS_CLOSED, client_->GetState(), handshake_wait_); RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_) << " handshake failed."; diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc index af8a4a7cdd..e150102dbc 100644 --- a/rtc_base/test_client_unittest.cc +++ b/rtc_base/test_client_unittest.cc @@ -13,11 +13,11 @@ #include #include "absl/memory/memory.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_tcp_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/logging.h" #include "rtc_base/net_helpers.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_server.h" #include "rtc_base/test_echo_server.h" #include "rtc_base/thread.h" @@ -40,8 +40,8 @@ namespace { void TestUdpInternal(const SocketAddress& loopback) { Thread* main = Thread::Current(); - AsyncSocket* socket = - main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_DGRAM); + Socket* socket = + main->socketserver()->CreateSocket(loopback.family(), SOCK_DGRAM); socket->Bind(loopback); TestClient client(std::make_unique(socket)); @@ -56,8 +56,8 @@ void TestTcpInternal(const SocketAddress& loopback) { Thread* main = Thread::Current(); TestEchoServer server(main, loopback); - AsyncSocket* socket = - main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_STREAM); + Socket* socket = + main->socketserver()->CreateSocket(loopback.family(), SOCK_STREAM); std::unique_ptr tcp_socket = absl::WrapUnique( AsyncTCPSocket::Create(socket, loopback, server.address())); ASSERT_TRUE(tcp_socket != nullptr); diff --git a/rtc_base/test_echo_server.cc b/rtc_base/test_echo_server.cc index d2e11d6a46..feda4cd8ae 100644 --- a/rtc_base/test_echo_server.cc +++ b/rtc_base/test_echo_server.cc @@ -15,8 +15,8 @@ namespace rtc { TestEchoServer::TestEchoServer(Thread* thread, const SocketAddress& addr) - : server_socket_(thread->socketserver()->CreateAsyncSocket(addr.family(), - SOCK_STREAM)) { + : server_socket_( + thread->socketserver()->CreateSocket(addr.family(), SOCK_STREAM)) { server_socket_->Bind(addr); server_socket_->Listen(5); server_socket_->SignalReadEvent.connect(this, &TestEchoServer::OnAccept); diff --git a/rtc_base/test_echo_server.h b/rtc_base/test_echo_server.h index da40ac4547..6fdfc249e4 100644 --- a/rtc_base/test_echo_server.h +++ b/rtc_base/test_echo_server.h @@ -19,9 +19,9 @@ #include "absl/algorithm/container.h" #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_tcp_socket.h" #include "rtc_base/constructor_magic.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_address.h" #include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/thread.h" @@ -38,8 +38,8 @@ class TestEchoServer : public sigslot::has_slots<> { SocketAddress address() const { return server_socket_->GetLocalAddress(); } private: - void OnAccept(AsyncSocket* socket) { - AsyncSocket* raw_socket = socket->Accept(nullptr); + void OnAccept(Socket* socket) { + Socket* raw_socket = socket->Accept(nullptr); if (raw_socket) { AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false); packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket); @@ -62,7 +62,7 @@ class TestEchoServer : public sigslot::has_slots<> { } typedef std::list ClientList; - std::unique_ptr server_socket_; + std::unique_ptr server_socket_; ClientList client_sockets_; RTC_DISALLOW_COPY_AND_ASSIGN(TestEchoServer); }; diff --git a/rtc_base/test_utils.h b/rtc_base/test_utils.h index 7068e73881..3f877fc9af 100644 --- a/rtc_base/test_utils.h +++ b/rtc_base/test_utils.h @@ -16,14 +16,14 @@ #include #include -#include "rtc_base/async_socket.h" +#include "rtc_base/socket.h" #include "rtc_base/third_party/sigslot/sigslot.h" namespace webrtc { namespace testing { /////////////////////////////////////////////////////////////////////////////// -// StreamSink - Monitor asynchronously signalled events from AsyncSocket. +// StreamSink - Monitor asynchronously signalled events from Socket. /////////////////////////////////////////////////////////////////////////////// // Note: Any event that is an error is treated as SSE_ERROR instead of that @@ -42,7 +42,7 @@ class StreamSink : public sigslot::has_slots<> { StreamSink(); ~StreamSink() override; - void Monitor(rtc::AsyncSocket* socket) { + void Monitor(rtc::Socket* socket) { socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent); socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent); socket->SignalWriteEvent.connect(this, &StreamSink::OnWriteEvent); @@ -50,30 +50,28 @@ class StreamSink : public sigslot::has_slots<> { // In case you forgot to unmonitor a previous object with this address events_.erase(socket); } - void Unmonitor(rtc::AsyncSocket* socket) { + void Unmonitor(rtc::Socket* socket) { socket->SignalConnectEvent.disconnect(this); socket->SignalReadEvent.disconnect(this); socket->SignalWriteEvent.disconnect(this); socket->SignalCloseEvent.disconnect(this); events_.erase(socket); } - bool Check(rtc::AsyncSocket* socket, - StreamSinkEvent event, - bool reset = true) { + bool Check(rtc::Socket* socket, StreamSinkEvent event, bool reset = true) { return DoCheck(socket, event, reset); } private: - typedef std::map EventMap; + typedef std::map EventMap; - void OnConnectEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_OPEN); } - void OnReadEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_READ); } - void OnWriteEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_WRITE); } - void OnCloseEvent(rtc::AsyncSocket* socket, int error) { + 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) { AddEvents(socket, (0 == error) ? SSE_CLOSE : SSE_ERROR); } - void AddEvents(rtc::AsyncSocket* obj, int events) { + void AddEvents(rtc::Socket* obj, int events) { EventMap::iterator it = events_.find(obj); if (events_.end() == it) { events_.insert(EventMap::value_type(obj, events)); @@ -81,7 +79,7 @@ class StreamSink : public sigslot::has_slots<> { it->second |= events; } } - bool DoCheck(rtc::AsyncSocket* obj, StreamSinkEvent event, bool reset) { + bool DoCheck(rtc::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_unittest.cc b/rtc_base/thread_unittest.cc index 6c1253ade4..430db3d606 100644 --- a/rtc_base/thread_unittest.cc +++ b/rtc_base/thread_unittest.cc @@ -64,7 +64,7 @@ struct TestMessage : public MessageData { // Receives on a socket and sends by posting messages. class SocketClient : public TestGenerator, public sigslot::has_slots<> { public: - SocketClient(AsyncSocket* socket, + SocketClient(Socket* socket, const SocketAddress& addr, Thread* post_thread, MessageHandler* phandler) @@ -221,14 +221,13 @@ TEST(ThreadTest, DISABLED_Main) { // Create the messaging client on its own thread. auto th1 = Thread::CreateWithSocketServer(); - Socket* socket = - th1->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM); + 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(); - AsyncSocket* asocket = - th2->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM); + Socket* asocket = + th2->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM); SocketClient sock_client(asocket, addr, th1.get(), &msg_client); socket->Connect(sock_client.address()); diff --git a/rtc_base/virtual_socket_server.cc b/rtc_base/virtual_socket_server.cc index 77d61742ac..8e97c0feae 100644 --- a/rtc_base/virtual_socket_server.cc +++ b/rtc_base/virtual_socket_server.cc @@ -614,10 +614,6 @@ Socket* VirtualSocketServer::CreateSocket(int family, int type) { return CreateSocketInternal(family, type); } -AsyncSocket* VirtualSocketServer::CreateAsyncSocket(int family, int type) { - return CreateSocketInternal(family, type); -} - VirtualSocket* VirtualSocketServer::CreateSocketInternal(int family, int type) { return new VirtualSocket(this, family, type, true); } diff --git a/rtc_base/virtual_socket_server.h b/rtc_base/virtual_socket_server.h index af86991ed4..dafab541b6 100644 --- a/rtc_base/virtual_socket_server.h +++ b/rtc_base/virtual_socket_server.h @@ -116,7 +116,6 @@ class VirtualSocketServer : public SocketServer { // SocketFactory: Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; // SocketServer: void SetMessageQueue(Thread* queue) override; @@ -326,7 +325,7 @@ class VirtualSocketServer : public SocketServer { // Implements the socket interface using the virtual network. Packets are // passed as messages using the message queue of the socket server. -class VirtualSocket : public AsyncSocket, +class VirtualSocket : public Socket, public MessageHandler, public sigslot::has_slots<> { public: diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc index 96a359d187..44e7288e8b 100644 --- a/rtc_base/virtual_socket_unittest.cc +++ b/rtc_base/virtual_socket_unittest.cc @@ -24,7 +24,6 @@ #include "absl/memory/memory.h" #include "rtc_base/arraysize.h" #include "rtc_base/async_packet_socket.h" -#include "rtc_base/async_socket.h" #include "rtc_base/async_udp_socket.h" #include "rtc_base/fake_clock.h" #include "rtc_base/gunit.h" @@ -54,7 +53,7 @@ using webrtc::testing::StreamSink; // Sends at a constant rate but with random packet sizes. struct Sender : public MessageHandlerAutoCleanup { - Sender(Thread* th, AsyncSocket* s, uint32_t rt) + Sender(Thread* th, Socket* s, uint32_t rt) : thread(th), socket(std::make_unique(s)), done(false), @@ -101,7 +100,7 @@ struct Sender : public MessageHandlerAutoCleanup { struct Receiver : public MessageHandlerAutoCleanup, public sigslot::has_slots<> { - Receiver(Thread* th, AsyncSocket* s, uint32_t bw) + Receiver(Thread* th, Socket* s, uint32_t bw) : thread(th), socket(std::make_unique(s)), bandwidth(bw), @@ -196,8 +195,7 @@ class VirtualSocketServerTest : public ::testing::Test { ss_.SetDefaultRoute(default_route); // Create client1 bound to the any address. - AsyncSocket* socket = - ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM); + Socket* socket = ss_.CreateSocket(default_route.family(), SOCK_DGRAM); socket->Bind(EmptySocketAddressWithFamily(default_route.family())); SocketAddress client1_any_addr = socket->GetLocalAddress(); EXPECT_TRUE(client1_any_addr.IsAnyIP()); @@ -205,8 +203,7 @@ class VirtualSocketServerTest : public ::testing::Test { std::make_unique(socket), &fake_clock_); // Create client2 bound to the default route. - AsyncSocket* socket2 = - ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM); + Socket* socket2 = ss_.CreateSocket(default_route.family(), SOCK_DGRAM); socket2->Bind(SocketAddress(default_route, 0)); SocketAddress client2_addr = socket2->GetLocalAddress(); EXPECT_FALSE(client2_addr.IsAnyIP()); @@ -227,8 +224,7 @@ class VirtualSocketServerTest : public ::testing::Test { } void BasicTest(const SocketAddress& initial_addr) { - AsyncSocket* socket = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); + Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); socket->Bind(initial_addr); SocketAddress server_addr = socket->GetLocalAddress(); // Make sure VSS didn't switch families on us. @@ -236,8 +232,7 @@ class VirtualSocketServerTest : public ::testing::Test { auto client1 = std::make_unique( std::make_unique(socket), &fake_clock_); - AsyncSocket* socket2 = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); + Socket* socket2 = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); auto client2 = std::make_unique( std::make_unique(socket2), &fake_clock_); @@ -278,21 +273,21 @@ class VirtualSocketServerTest : public ::testing::Test { EmptySocketAddressWithFamily(initial_addr.family()); // Create client - std::unique_ptr client = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr client = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(client.get()); - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), Socket::CS_CLOSED); EXPECT_TRUE(client->GetLocalAddress().IsNil()); // Create server - std::unique_ptr server = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr 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(), AsyncSocket::CS_CONNECTING); + EXPECT_EQ(server->GetState(), Socket::CS_CONNECTING); // No pending server connections EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); @@ -306,14 +301,14 @@ class VirtualSocketServerTest : public ::testing::Test { EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress()); // Client is connecting - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING); + EXPECT_EQ(client->GetState(), 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(), AsyncSocket::CS_CONNECTING); + EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); @@ -325,14 +320,14 @@ class VirtualSocketServerTest : public ::testing::Test { EXPECT_NE(accept_addr, kEmptyAddr); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); - EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED); + EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED); EXPECT_EQ(accepted->GetLocalAddress(), server->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); ss_.ProcessMessagesUntilIdle(); // Client has connected - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTED); + EXPECT_EQ(client->GetState(), 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()); @@ -347,13 +342,13 @@ class VirtualSocketServerTest : public ::testing::Test { EmptySocketAddressWithFamily(initial_addr.family()); // Create client - std::unique_ptr client = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr client = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(client.get()); // Create server - std::unique_ptr server = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr server = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); EXPECT_EQ(0, server->Bind(initial_addr)); EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family()); @@ -368,7 +363,7 @@ class VirtualSocketServerTest : public ::testing::Test { EXPECT_EQ(accept_addr, nil_addr); // Connection failed - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), 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); @@ -381,11 +376,11 @@ class VirtualSocketServerTest : public ::testing::Test { EmptySocketAddressWithFamily(initial_addr.family()); // Create client and server - std::unique_ptr client( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr client( + ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(client.get()); - std::unique_ptr server( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr server( + ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); // Initiate connect @@ -402,10 +397,10 @@ class VirtualSocketServerTest : public ::testing::Test { ss_.ProcessMessagesUntilIdle(); // Result: connection failed - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), Socket::CS_CLOSED); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); - server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); // Initiate connect @@ -424,11 +419,11 @@ class VirtualSocketServerTest : public ::testing::Test { ss_.ProcessMessagesUntilIdle(); // Result: connection failed - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), Socket::CS_CLOSED); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); // New server - server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); // Initiate connect @@ -442,21 +437,21 @@ class VirtualSocketServerTest : public ::testing::Test { // Server accepts connection EXPECT_TRUE(sink.Check(server.get(), SSE_READ)); - std::unique_ptr accepted(server->Accept(&accept_addr)); + std::unique_ptr accepted(server->Accept(&accept_addr)); ASSERT_TRUE(nullptr != accepted.get()); sink.Monitor(accepted.get()); // Client closes before connection complets - EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CONNECTED); + EXPECT_EQ(accepted->GetState(), Socket::CS_CONNECTED); // Connected message has not been processed yet. - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING); + EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING); client->Close(); ss_.ProcessMessagesUntilIdle(); // Result: accepted socket closes - EXPECT_EQ(accepted->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(accepted->GetState(), Socket::CS_CLOSED); EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); } @@ -466,14 +461,14 @@ class VirtualSocketServerTest : public ::testing::Test { const SocketAddress kEmptyAddr; // Create clients - std::unique_ptr a = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr 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 b = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr b = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(b.get()); b->Bind(initial_addr); EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family()); @@ -484,11 +479,11 @@ class VirtualSocketServerTest : public ::testing::Test { ss_.ProcessMessagesUntilIdle(); EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN)); - EXPECT_EQ(a->GetState(), AsyncSocket::CS_CONNECTED); + EXPECT_EQ(a->GetState(), Socket::CS_CONNECTED); EXPECT_EQ(a->GetRemoteAddress(), b->GetLocalAddress()); EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN)); - EXPECT_EQ(b->GetState(), AsyncSocket::CS_CONNECTED); + EXPECT_EQ(b->GetState(), Socket::CS_CONNECTED); EXPECT_EQ(b->GetRemoteAddress(), a->GetLocalAddress()); EXPECT_EQ(1, a->Send("a", 1)); @@ -502,12 +497,12 @@ class VirtualSocketServerTest : public ::testing::Test { EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr)); EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE)); - EXPECT_EQ(a->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(a->GetState(), Socket::CS_CLOSED); EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr); // No signal for Closer EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE)); - EXPECT_EQ(b->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(b->GetState(), Socket::CS_CLOSED); EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr); } @@ -516,14 +511,14 @@ class VirtualSocketServerTest : public ::testing::Test { const SocketAddress kEmptyAddr; // Connect two sockets - std::unique_ptr a = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr 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 b = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr b = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); sink.Monitor(b.get()); b->Bind(initial_addr); EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family()); @@ -638,10 +633,10 @@ class VirtualSocketServerTest : public ::testing::Test { const SocketAddress kEmptyAddr; // Connect two sockets - std::unique_ptr a = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); - std::unique_ptr b = absl::WrapUnique( - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr a = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); + std::unique_ptr b = + absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM)); a->Bind(initial_addr); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); @@ -692,10 +687,8 @@ class VirtualSocketServerTest : public ::testing::Test { // incremental port behavior could ensure the 2 Binds result in different // address. void BandwidthTest(const SocketAddress& initial_addr) { - AsyncSocket* send_socket = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); - AsyncSocket* recv_socket = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); + Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); + Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); ASSERT_EQ(0, send_socket->Bind(initial_addr)); ASSERT_EQ(0, recv_socket->Bind(initial_addr)); EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family()); @@ -737,10 +730,8 @@ class VirtualSocketServerTest : public ::testing::Test { ss_.set_delay_stddev(stddev); ss_.UpdateDelayDistribution(); - AsyncSocket* send_socket = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); - AsyncSocket* recv_socket = - ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); + Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); + Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM); ASSERT_EQ(0, send_socket->Bind(initial_addr)); ASSERT_EQ(0, recv_socket->Bind(initial_addr)); EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family()); @@ -789,17 +780,17 @@ class VirtualSocketServerTest : public ::testing::Test { const SocketAddress kEmptyAddr; // Client gets a IPv4 address - std::unique_ptr client = absl::WrapUnique( - ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM)); + std::unique_ptr client = + absl::WrapUnique(ss_.CreateSocket(client_addr.family(), SOCK_STREAM)); sink.Monitor(client.get()); - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), 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 server = absl::WrapUnique( - ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM)); + std::unique_ptr server = + absl::WrapUnique(ss_.CreateSocket(server_addr.family(), SOCK_STREAM)); sink.Monitor(server.get()); server->Bind(server_addr); server->Listen(5); @@ -823,7 +814,7 @@ class VirtualSocketServerTest : public ::testing::Test { EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); EXPECT_TRUE(nullptr == server->Accept(&accept_address)); EXPECT_EQ(accept_address, kEmptyAddr); - EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); + EXPECT_EQ(client->GetState(), Socket::CS_CLOSED); EXPECT_FALSE(sink.Check(client.get(), SSE_OPEN)); EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr); } @@ -835,13 +826,13 @@ class VirtualSocketServerTest : public ::testing::Test { void CrossFamilyDatagramTest(const SocketAddress& client_addr, const SocketAddress& server_addr, bool shouldSucceed) { - AsyncSocket* socket = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM); + Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM); socket->Bind(server_addr); SocketAddress bound_server_addr = socket->GetLocalAddress(); auto client1 = std::make_unique( std::make_unique(socket), &fake_clock_); - AsyncSocket* socket2 = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM); + Socket* socket2 = ss_.CreateSocket(AF_INET, SOCK_DGRAM); socket2->Bind(client_addr); auto client2 = std::make_unique( std::make_unique(socket2), &fake_clock_); @@ -1043,10 +1034,9 @@ TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) { } TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) { - AsyncSocket* socket1 = - ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); - std::unique_ptr socket2 = absl::WrapUnique( - ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM)); + Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); + std::unique_ptr socket2 = + absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM)); socket1->Bind(kIPv4AnyAddress); socket2->Bind(kIPv4AnyAddress); auto client1 = std::make_unique( @@ -1068,10 +1058,10 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) { ss_.set_recv_buffer_capacity(kBufferSize); StreamSink sink; - std::unique_ptr socket1 = absl::WrapUnique( - ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); - std::unique_ptr socket2 = absl::WrapUnique( - ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); + std::unique_ptr socket1 = + absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); + std::unique_ptr socket2 = + absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); sink.Monitor(socket1.get()); sink.Monitor(socket2.get()); socket1->Bind(kIPv4AnyAddress); diff --git a/rtc_base/win32_socket_server.cc b/rtc_base/win32_socket_server.cc index cfe21a3630..835d1a7081 100644 --- a/rtc_base/win32_socket_server.cc +++ b/rtc_base/win32_socket_server.cc @@ -686,10 +686,6 @@ Win32SocketServer::~Win32SocketServer() { } Socket* Win32SocketServer::CreateSocket(int family, int type) { - return CreateAsyncSocket(family, type); -} - -AsyncSocket* Win32SocketServer::CreateAsyncSocket(int family, int type) { Win32Socket* socket = new Win32Socket; if (socket->CreateT(family, type)) { return socket; diff --git a/rtc_base/win32_socket_server.h b/rtc_base/win32_socket_server.h index 317acce0d2..3e7d7286ab 100644 --- a/rtc_base/win32_socket_server.h +++ b/rtc_base/win32_socket_server.h @@ -12,7 +12,6 @@ #define RTC_BASE_WIN32_SOCKET_SERVER_H_ #if defined(WEBRTC_WIN) -#include "rtc_base/async_socket.h" #include "rtc_base/socket.h" #include "rtc_base/socket_factory.h" #include "rtc_base/socket_server.h" @@ -26,7 +25,7 @@ namespace rtc { // Win32Socket /////////////////////////////////////////////////////////////////////////////// -class Win32Socket : public AsyncSocket { +class Win32Socket : public Socket { public: Win32Socket(); ~Win32Socket() override; @@ -36,7 +35,7 @@ class Win32Socket : public AsyncSocket { int Attach(SOCKET s); void SetTimeout(int ms); - // AsyncSocket Interface + // Socket Interface SocketAddress GetLocalAddress() const override; SocketAddress GetRemoteAddress() const override; int Bind(const SocketAddress& addr) override; @@ -100,7 +99,6 @@ class Win32SocketServer : public SocketServer { // SocketServer Interface Socket* CreateSocket(int family, int type) override; - AsyncSocket* CreateAsyncSocket(int family, int type) override; void SetMessageQueue(Thread* queue) override; bool Wait(int cms, bool process_io) override; diff --git a/test/network/BUILD.gn b/test/network/BUILD.gn index 1e39a3f89b..3836cc1263 100644 --- a/test/network/BUILD.gn +++ b/test/network/BUILD.gn @@ -55,12 +55,12 @@ rtc_library("emulated_network") { "../../call:simulated_network", "../../p2p:p2p_server_utils", "../../rtc_base", - "../../rtc_base:async_socket", "../../rtc_base:ip_address", "../../rtc_base:network_constants", "../../rtc_base:rtc_base_tests_utils", "../../rtc_base:rtc_task_queue", "../../rtc_base:safe_minmax", + "../../rtc_base:socket", "../../rtc_base:socket_address", "../../rtc_base:socket_server", "../../rtc_base:stringutils", diff --git a/test/network/fake_network_socket_server.cc b/test/network/fake_network_socket_server.cc index 41200ad341..9597edbbbd 100644 --- a/test/network/fake_network_socket_server.cc +++ b/test/network/fake_network_socket_server.cc @@ -32,7 +32,7 @@ std::string ToString(const rtc::SocketAddress& addr) { } // namespace // Represents a socket, which will operate with emulated network. -class FakeNetworkSocket : public rtc::AsyncSocket, +class FakeNetworkSocket : public rtc::Socket, public EmulatedNetworkReceiverInterface { public: explicit FakeNetworkSocket(FakeNetworkSocketServer* scoket_manager, @@ -58,7 +58,7 @@ class FakeNetworkSocket : public rtc::AsyncSocket, rtc::SocketAddress* paddr, int64_t* timestamp) override; int Listen(int backlog) override; - rtc::AsyncSocket* Accept(rtc::SocketAddress* paddr) override; + rtc::Socket* Accept(rtc::SocketAddress* paddr) override; int GetError() const override; void SetError(int error) override; ConnState GetState() const override; @@ -223,7 +223,7 @@ int FakeNetworkSocket::Listen(int backlog) { RTC_CHECK(false) << "Listen() isn't valid for SOCK_DGRAM"; } -rtc::AsyncSocket* FakeNetworkSocket::Accept(rtc::SocketAddress* /*paddr*/) { +rtc::Socket* FakeNetworkSocket::Accept(rtc::SocketAddress* /*paddr*/) { RTC_CHECK(false) << "Accept() isn't valid for SOCK_DGRAM"; } @@ -249,7 +249,7 @@ void FakeNetworkSocket::SetError(int error) { error_ = error; } -rtc::AsyncSocket::ConnState FakeNetworkSocket::GetState() const { +rtc::Socket::ConnState FakeNetworkSocket::GetState() const { RTC_DCHECK_RUN_ON(thread_); return state_; } @@ -286,13 +286,7 @@ void FakeNetworkSocketServer::Unregister(FakeNetworkSocket* socket) { sockets_.erase(absl::c_find(sockets_, socket)); } -rtc::Socket* FakeNetworkSocketServer::CreateSocket(int /*family*/, - int /*type*/) { - RTC_CHECK(false) << "Only async sockets are supported"; -} - -rtc::AsyncSocket* FakeNetworkSocketServer::CreateAsyncSocket(int family, - int type) { +rtc::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 d8be2e24b8..5b23a01eee 100644 --- a/test/network/fake_network_socket_server.h +++ b/test/network/fake_network_socket_server.h @@ -15,8 +15,8 @@ #include #include "api/units/timestamp.h" -#include "rtc_base/async_socket.h" #include "rtc_base/event.h" +#include "rtc_base/socket.h" #include "rtc_base/socket_server.h" #include "rtc_base/synchronization/mutex.h" #include "system_wrappers/include/clock.h" @@ -35,7 +35,6 @@ class FakeNetworkSocketServer : public rtc::SocketServer { // rtc::SocketFactory methods: rtc::Socket* CreateSocket(int family, int type) override; - rtc::AsyncSocket* CreateAsyncSocket(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 fca10c40b7..7848a11e62 100644 --- a/test/network/network_emulation_unittest.cc +++ b/test/network/network_emulation_unittest.cc @@ -36,7 +36,7 @@ constexpr int kOverheadIpv4Udp = 20 + 8; class SocketReader : public sigslot::has_slots<> { public: - explicit SocketReader(rtc::AsyncSocket* socket, rtc::Thread* network_thread) + explicit SocketReader(rtc::Socket* socket, rtc::Thread* network_thread) : socket_(socket), network_thread_(network_thread) { socket_->SignalReadEvent.connect(this, &SocketReader::OnReadEvent); size_ = 128 * 1024; @@ -44,7 +44,7 @@ class SocketReader : public sigslot::has_slots<> { } ~SocketReader() override { delete[] buf_; } - void OnReadEvent(rtc::AsyncSocket* socket) { + void OnReadEvent(rtc::Socket* socket) { RTC_DCHECK(socket_ == socket); RTC_DCHECK(network_thread_->IsCurrent()); int64_t timestamp; @@ -60,7 +60,7 @@ class SocketReader : public sigslot::has_slots<> { } private: - rtc::AsyncSocket* const socket_; + rtc::Socket* const socket_; rtc::Thread* const network_thread_; char* buf_; size_t size_; @@ -207,13 +207,13 @@ TEST(NetworkEmulationManagerTest, Run) { rtc::CopyOnWriteBuffer data("Hello"); for (uint64_t j = 0; j < 2; j++) { - rtc::AsyncSocket* s1 = nullptr; - rtc::AsyncSocket* s2 = nullptr; + rtc::Socket* s1 = nullptr; + rtc::Socket* s2 = nullptr; t1->Invoke(RTC_FROM_HERE, [&] { - s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); t2->Invoke(RTC_FROM_HERE, [&] { - s2 = t2->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); SocketReader r1(s1, t1); @@ -363,13 +363,13 @@ TEST(NetworkEmulationManagerTest, DebugStatsCollectedInDebugMode) { rtc::CopyOnWriteBuffer data("Hello"); for (uint64_t j = 0; j < 2; j++) { - rtc::AsyncSocket* s1 = nullptr; - rtc::AsyncSocket* s2 = nullptr; + rtc::Socket* s1 = nullptr; + rtc::Socket* s2 = nullptr; t1->Invoke(RTC_FROM_HERE, [&] { - s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); t2->Invoke(RTC_FROM_HERE, [&] { - s2 = t2->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); SocketReader r1(s1, t1); @@ -467,13 +467,13 @@ TEST(NetworkEmulationManagerTest, ThroughputStats) { constexpr int64_t kSinglePacketSize = kUdpPayloadSize + kOverheadIpv4Udp; rtc::CopyOnWriteBuffer data(kUdpPayloadSize); - rtc::AsyncSocket* s1 = nullptr; - rtc::AsyncSocket* s2 = nullptr; + rtc::Socket* s1 = nullptr; + rtc::Socket* s2 = nullptr; t1->Invoke(RTC_FROM_HERE, [&] { - s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); t2->Invoke(RTC_FROM_HERE, [&] { - s2 = t2->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM); + s2 = t2->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM); }); SocketReader r1(s1, t1); diff --git a/test/run_loop.cc b/test/run_loop.cc index 643da5d56e..49ab0ee692 100644 --- a/test/run_loop.cc +++ b/test/run_loop.cc @@ -61,11 +61,6 @@ rtc::Socket* RunLoop::FakeSocketServer::CreateSocket(int family, int type) { return nullptr; } -rtc::AsyncSocket* RunLoop::FakeSocketServer::CreateAsyncSocket(int family, - int type) { - return nullptr; -} - RunLoop::WorkerThread::WorkerThread(rtc::SocketServer* ss) : rtc::Thread(ss), tq_setter_(this) {} diff --git a/test/run_loop.h b/test/run_loop.h index f350b2ce93..9a91d44db5 100644 --- a/test/run_loop.h +++ b/test/run_loop.h @@ -56,7 +56,6 @@ class RunLoop { void WakeUp() override; rtc::Socket* CreateSocket(int family, int type) override; - rtc::AsyncSocket* CreateAsyncSocket(int family, int type) override; private: bool fail_next_wait_ = false; diff --git a/test/time_controller/simulated_thread.cc b/test/time_controller/simulated_thread.cc index aa8b9ac90d..73a52b21c5 100644 --- a/test/time_controller/simulated_thread.cc +++ b/test/time_controller/simulated_thread.cc @@ -26,10 +26,6 @@ class DummySocketServer : public rtc::SocketServer { RTC_NOTREACHED(); return nullptr; } - rtc::AsyncSocket* CreateAsyncSocket(int family, int type) override { - RTC_NOTREACHED(); - return nullptr; - } bool Wait(int cms, bool process_io) override { RTC_CHECK_EQ(cms, 0); return true;