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 <hta@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#34787}
diff --git a/examples/androidvoip/jni/android_voip_client.cc b/examples/androidvoip/jni/android_voip_client.cc
index 95d3ed4..9f859cb 100644
--- a/examples/androidvoip/jni/android_voip_client.cc
+++ b/examples/androidvoip/jni/android_voip_client.cc
@@ -61,8 +61,8 @@
RTC_DCHECK(thread->socketserver() != nullptr);
RTC_DCHECK(family == AF_INET || family == AF_INET6);
- std::unique_ptr<rtc::AsyncSocket> socket(
- thread->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
+ std::unique_ptr<rtc::Socket> 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 9bf2a0f..7132593 100644
--- a/examples/peerconnection/client/peer_connection_client.cc
+++ b/examples/peerconnection/client/peer_connection_client.cc
@@ -26,7 +26,7 @@
// 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 @@
#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 @@
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 @@
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 @@
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::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 @@
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 d7ae913..00d2192 100644
--- a/examples/peerconnection/client/peer_connection_client.h
+++ b/examples/peerconnection/client/peer_connection_client.h
@@ -73,8 +73,8 @@
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 @@
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 "<name>,<id>,<connected>"
bool ParseEntry(const std::string& entry,
@@ -110,15 +110,15 @@
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<rtc::AsyncSocket> control_socket_;
- std::unique_ptr<rtc::AsyncSocket> hanging_get_;
+ std::unique_ptr<rtc::Socket> control_socket_;
+ std::unique_ptr<rtc::Socket> 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 244bc39..f885694 100644
--- a/p2p/BUILD.gn
+++ b/p2p/BUILD.gn
@@ -99,7 +99,6 @@
"../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 @@
"../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 @@
"../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 676447e..f4ead66 100644
--- a/p2p/base/async_stun_tcp_socket.cc
+++ b/p2p/base/async_stun_tcp_socket.cc
@@ -41,7 +41,7 @@
// 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 @@
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::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 9453845..2b7bc95 100644
--- a/p2p/base/async_stun_tcp_socket.h
+++ b/p2p/base/async_stun_tcp_socket.h
@@ -14,9 +14,9 @@
#include <stddef.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"
namespace cricket {
@@ -26,17 +26,17 @@
// 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 d1dfac1..40b5405 100644
--- a/p2p/base/async_stun_tcp_socket_unittest.cc
+++ b/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -17,8 +17,8 @@
#include <memory>
#include <string>
-#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 @@
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 232e58b..4aaad7c 100644
--- a/p2p/base/basic_packet_socket_factory.cc
+++ b/p2p/base/basic_packet_socket_factory.cc
@@ -46,8 +46,7 @@
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 @@
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 @@
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 @@
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 337efca..22f3024 100644
--- a/p2p/base/basic_packet_socket_factory.h
+++ b/p2p/base/basic_packet_socket_factory.h
@@ -14,10 +14,10 @@
#include <string>
#include "api/packet_socket_factory.h"
+#include "rtc_base/socket.h"
namespace rtc {
-class AsyncSocket;
class SocketFactory;
class Thread;
@@ -45,7 +45,7 @@
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 fe12a6d..7d7bfdb 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 @@
ch1.Start();
ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
- std::unique_ptr<rtc::AsyncSocket> server(
- vss()->CreateAsyncSocket(kLocalAddr2.family(), SOCK_STREAM));
+ std::unique_ptr<rtc::Socket> 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 60e8248..f2126db 100644
--- a/p2p/base/stun_server.h
+++ b/p2p/base/stun_server.h
@@ -34,7 +34,7 @@
~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 54bdfb3..3bd793c 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 ecd9348..479ca8b 100644
--- a/p2p/base/test_turn_server.h
+++ b/p2p/base/test_turn_server.h
@@ -99,8 +99,8 @@
} 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 c45b8c9..7a7092d 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 @@
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 53f283b..01856f4 100644
--- a/p2p/base/turn_server.cc
+++ b/p2p/base/turn_server.cc
@@ -139,7 +139,7 @@
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 @@
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 @@
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 f90c3da..7942c09 100644
--- a/p2p/base/turn_server.h
+++ b/p2p/base/turn_server.h
@@ -237,7 +237,7 @@
// 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 @@
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 @@
RTC_RUN_ON(thread_);
typedef std::map<rtc::AsyncPacketSocket*, ProtocolType> InternalSocketMap;
- typedef std::map<rtc::AsyncSocket*, ProtocolType> ServerSocketMap;
+ typedef std::map<rtc::Socket*, ProtocolType> ServerSocketMap;
rtc::Thread* const thread_;
const std::string nonce_key_;
diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 40c4835..90bb8b7 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -737,7 +737,6 @@
"null_socket_server.h",
]
deps = [
- ":async_socket",
":checks",
":rtc_event",
":socket",
@@ -818,10 +817,7 @@
rtc_source_set("socket_factory") {
sources = [ "socket_factory.h" ]
- deps = [
- ":async_socket",
- ":socket",
- ]
+ deps = [ ":socket" ]
}
rtc_library("async_socket") {
@@ -846,7 +842,9 @@
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 @@
"socket_unittest.h",
]
deps = [
- ":async_socket",
":checks",
":gunit_helpers",
":ip_address",
@@ -1369,7 +1366,6 @@
sources += [ "win/windows_version_unittest.cc" ]
}
deps = [
- ":async_socket",
":bounded_inline_vector",
":checks",
":criticalsection",
@@ -1505,13 +1501,13 @@
"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 e80514d..7289b5c 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 @@
return socket_->Listen(backlog);
}
-AsyncSocket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
+Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
return socket_->Accept(paddr);
}
@@ -86,7 +82,7 @@
return socket_->SetError(error);
}
-AsyncSocket::ConnState AsyncSocketAdapter::GetState() const {
+Socket::ConnState AsyncSocketAdapter::GetState() const {
return socket_->GetState();
}
@@ -98,19 +94,19 @@
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 9dc236f..0772cb8 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<AsyncSocket*, sigslot::multi_threaded_local> SignalReadEvent;
- // ready to write
- sigslot::signal1<AsyncSocket*, sigslot::multi_threaded_local>
- SignalWriteEvent;
- sigslot::signal1<AsyncSocket*> SignalConnectEvent; // connected
- sigslot::signal2<AsyncSocket*, int> 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 @@
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 @@
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<AsyncSocket> socket_;
+ const std::unique_ptr<Socket> socket_;
};
} // namespace rtc
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index 3d8b23d..76efb6d 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -45,11 +45,11 @@
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<rtc::AsyncSocket> owned_socket(socket);
+ std::unique_ptr<rtc::Socket> 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 @@
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 @@
outbuf_.AppendData(static_cast<const uint8_t*>(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::OnWriteEvent(AsyncSocket* socket) {
+void AsyncTCPSocketBase::OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
if (outbuf_.size() > 0) {
@@ -271,7 +271,7 @@
}
}
-void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
+void AsyncTCPSocketBase::OnCloseEvent(Socket* socket, int error) {
SignalClose(this, error);
}
@@ -279,7 +279,7 @@
// 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 @@
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::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 610d17d..ddf9a43 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -16,7 +16,6 @@
#include <memory>
#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 @@
// 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 @@
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 @@
// 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 @@
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<AsyncSocket> socket_;
+ std::unique_ptr<Socket> socket_;
bool listen_;
Buffer inbuf_;
Buffer outbuf_;
@@ -91,17 +90,17 @@
// 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 c701433..af82238 100644
--- a/rtc_base/async_tcp_socket_unittest.cc
+++ b/rtc_base/async_tcp_socket_unittest.cc
@@ -22,7 +22,7 @@
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 @@
protected:
std::unique_ptr<VirtualSocketServer> vss_;
- AsyncSocket* socket_;
+ Socket* socket_;
std::unique_ptr<AsyncTCPSocket> tcp_socket_;
bool ready_to_send_;
};
diff --git a/rtc_base/async_udp_socket.cc b/rtc_base/async_udp_socket.cc
index 378b687..b4aefd6 100644
--- a/rtc_base/async_udp_socket.cc
+++ b/rtc_base/async_udp_socket.cc
@@ -24,9 +24,9 @@
static const int BUF_SIZE = 64 * 1024;
-AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket,
+AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
const SocketAddress& bind_address) {
- std::unique_ptr<AsyncSocket> owned_socket(socket);
+ std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr;
@@ -36,14 +36,13 @@
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 @@
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 @@
(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 ce7f476..5d738ff 100644
--- a/rtc_base/async_udp_socket.h
+++ b/rtc_base/async_udp_socket.h
@@ -16,7 +16,6 @@
#include <memory>
#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 @@
// 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 @@
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<AsyncSocket> socket_;
+ std::unique_ptr<Socket> 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 ecb28c1..7df1ca0 100644
--- a/rtc_base/async_udp_socket_unittest.cc
+++ b/rtc_base/async_udp_socket_unittest.cc
@@ -24,7 +24,7 @@
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 @@
protected:
std::unique_ptr<PhysicalSocketServer> pss_;
std::unique_ptr<VirtualSocketServer> vss_;
- AsyncSocket* socket_;
+ Socket* socket_;
std::unique_ptr<AsyncUDPSocket> udp_socket_;
bool ready_to_send_;
};
diff --git a/rtc_base/firewall_socket_server.cc b/rtc_base/firewall_socket_server.cc
index 8f44753..edb0cd2 100644
--- a/rtc_base/firewall_socket_server.cc
+++ b/rtc_base/firewall_socket_server.cc
@@ -25,7 +25,7 @@
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 @@
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 @@
}
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 @@
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 23b91d6..8a82f88 100644
--- a/rtc_base/firewall_socket_server.h
+++ b/rtc_base/firewall_socket_server.h
@@ -13,7 +13,6 @@
#include <vector>
-#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 @@
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 725a57b..b818685 100644
--- a/rtc_base/nat_server.cc
+++ b/rtc_base/nat_server.cc
@@ -70,7 +70,7 @@
// 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 @@
: 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 874e938..f6492a9 100644
--- a/rtc_base/nat_socket_factory.cc
+++ b/rtc_base/nat_socket_factory.cc
@@ -69,7 +69,7 @@
}
// 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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 70030d8..9b1d2f0 100644
--- a/rtc_base/nat_socket_factory.h
+++ b/rtc_base/nat_socket_factory.h
@@ -17,7 +17,6 @@
#include <memory>
#include <set>
-#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 @@
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 @@
// 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 @@
// 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 959a4e2..e757bfd 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 @@
absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
}
-TestClient* CreateTCPTestClient(AsyncSocket* socket) {
+TestClient* CreateTCPTestClient(Socket* socket) {
return new TestClient(std::make_unique<AsyncTCPSocket>(socket, false));
}
@@ -201,10 +201,8 @@
// internal address used for the NAT. Things like firewalls can break that, so
// check to see if it's worth even trying with this ip.
std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
- std::unique_ptr<AsyncSocket> client(
- pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
- std::unique_ptr<AsyncSocket> server(
- pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> client(pss->CreateSocket(src.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> server(pss->CreateSocket(src.family(), SOCK_DGRAM));
if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
server->Bind(SocketAddress(dst, 0)) != 0) {
return false;
@@ -345,13 +343,13 @@
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 @@
std::unique_ptr<Thread> ext_thread_;
std::unique_ptr<NATServer> nat_;
std::unique_ptr<NATSocketFactory> natsf_;
- std::unique_ptr<AsyncSocket> client_;
- std::unique_ptr<AsyncSocket> server_;
- std::unique_ptr<AsyncSocket> accepted_;
+ std::unique_ptr<Socket> client_;
+ std::unique_ptr<Socket> server_;
+ std::unique_ptr<Socket> 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 5725458..ab0e123 100644
--- a/rtc_base/network.cc
+++ b/rtc_base/network.cc
@@ -912,8 +912,8 @@
RTC_DCHECK(thread_->socketserver() != nullptr);
RTC_DCHECK(family == AF_INET || family == AF_INET6);
- std::unique_ptr<AsyncSocket> socket(
- thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
+ std::unique_ptr<Socket> 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 01e18af..4bfe93f 100644
--- a/rtc_base/network_unittest.cc
+++ b/rtc_base/network_unittest.cc
@@ -367,7 +367,7 @@
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<int>(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 a7ee4f9..ce1e963 100644
--- a/rtc_base/null_socket_server.cc
+++ b/rtc_base/null_socket_server.cc
@@ -34,10 +34,4 @@
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 7afa504..6d4ae84 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 @@
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 d6e1a60..18142a0 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -70,7 +70,7 @@
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_read(BIO* b, char* out, int outl) {
if (!out)
return -1;
- rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(BIO_get_data(b));
+ rtc::Socket* socket = static_cast<rtc::Socket*>(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_write(BIO* b, const char* in, int inl) {
if (!in)
return -1;
- rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(BIO_get_data(b));
+ rtc::Socket* socket = static_cast<rtc::Socket*>(BIO_get_data(b));
BIO_clear_retry_flags(b);
int result = socket->Send(in, inl);
if (result > 0) {
@@ -129,9 +129,9 @@
case BIO_CTRL_RESET:
return 0;
case BIO_CTRL_EOF: {
- rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(ptr);
+ rtc::Socket* socket = static_cast<rtc::Socket*>(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 @@
return true;
}
-OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket,
+OpenSSLAdapter::OpenSSLAdapter(Socket* socket,
OpenSSLSessionCache* ssl_session_cache,
SSLCertificateVerifier* ssl_cert_verifier)
: SSLAdapter(socket),
@@ -250,9 +250,9 @@
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 @@
}
///////////////////////////////////////////////////////////////////////////////
-// AsyncSocket Implementation
+// Socket Implementation
///////////////////////////////////////////////////////////////////////////////
int OpenSSLAdapter::Send(const void* pv, size_t cb) {
@@ -677,7 +677,7 @@
}
}
-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::OnReadEvent(AsyncSocket* socket) {
+void OpenSSLAdapter::OnReadEvent(Socket* socket) {
if (state_ == SSL_NONE) {
AsyncSocketAdapter::OnReadEvent(socket);
return;
@@ -717,7 +717,7 @@
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 @@
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 @@
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 8d42967..4649de0 100644
--- a/rtc_base/openssl_adapter.h
+++ b/rtc_base/openssl_adapter.h
@@ -19,7 +19,6 @@
#include <string>
#include <vector>
-#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 @@
// 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 @@
void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) override;
void SetIdentity(std::unique_ptr<SSLIdentity> 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 @@
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 @@
// 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 4bd8799..0805cba 100644
--- a/rtc_base/openssl_adapter_unittest.cc
+++ b/rtc_base/openssl_adapter_unittest.cc
@@ -15,17 +15,17 @@
#include <vector>
#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 @@
// 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 @@
// 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<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
@@ -107,7 +107,7 @@
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<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
diff --git a/rtc_base/physical_socket_server.cc b/rtc_base/physical_socket_server.cc
index ed6f81b..90df855 100644
--- a/rtc_base/physical_socket_server.cc
+++ b/rtc_base/physical_socket_server.cc
@@ -283,7 +283,7 @@
error_ = error;
}
-AsyncSocket::ConnState PhysicalSocket::GetState() const {
+Socket::ConnState PhysicalSocket::GetState() const {
return state_;
}
@@ -460,7 +460,7 @@
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 @@
}
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::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 4b7957e..a01229d 100644
--- a/rtc_base/physical_socket_server.h
+++ b/rtc_base/physical_socket_server.h
@@ -69,10 +69,9 @@
// 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 @@
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 @@
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 3762762..e905375 100644
--- a/rtc_base/physical_socket_server_unittest.cc
+++ b/rtc_base/physical_socket_server_unittest.cc
@@ -64,7 +64,7 @@
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 @@
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 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 @@
SocketAddress accept_addr;
// Create two clients.
- std::unique_ptr<AsyncSocket> client1(
- server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> client2(
- server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> server(
- server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server(
+ server_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->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 @@
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 @@
kTimeout);
// Simulate "::accept" returning an error.
SetFailAccept(true);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
EXPECT_FALSE(accepted);
ASSERT_TRUE(accept_addr.IsNil());
@@ -254,7 +254,7 @@
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 @@
EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)),
kTimeout);
SetFailAccept(false);
- std::unique_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> accepted2(server->Accept(&accept_addr));
ASSERT_TRUE(accepted2);
EXPECT_FALSE(accept_addr.IsNil());
EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr);
@@ -478,8 +478,7 @@
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
- std::unique_ptr<AsyncSocket> socket(
- server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
+ std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
server_->set_network_binder(nullptr);
@@ -490,8 +489,7 @@
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
- std::unique_ptr<AsyncSocket> socket(
- server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
+ std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds());
server_->set_network_binder(nullptr);
@@ -504,8 +502,7 @@
MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder);
- std::unique_ptr<AsyncSocket> socket(
- server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
+ std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
server_->set_network_binder(nullptr);
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index a7e8bf5..652e4c5 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -27,7 +27,7 @@
: 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 @@
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 @@
// 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 @@
// 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::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 @@
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 139cc91..6db0e12 100644
--- a/rtc_base/proxy_server.h
+++ b/rtc_base/proxy_server.h
@@ -15,10 +15,10 @@
#include <vector>
#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 ProxyBinding : public sigslot::has_slots<> {
public:
- ProxyBinding(AsyncProxyServerSocket* in_socket, AsyncSocket* out_socket);
+ ProxyBinding(AsyncProxyServerSocket* in_socket, Socket* out_socket);
~ProxyBinding() override;
sigslot::signal1<ProxyBinding*> 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<AsyncProxyServerSocket> int_socket_;
- std::unique_ptr<AsyncSocket> ext_socket_;
+ std::unique_ptr<Socket> ext_socket_;
bool connected_;
FifoBuffer out_buffer_;
FifoBuffer in_buffer_;
@@ -74,13 +74,13 @@
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<AsyncSocket> server_socket_;
+ std::unique_ptr<Socket> server_socket_;
std::vector<std::unique_ptr<ProxyBinding>> bindings_;
RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer);
};
@@ -95,7 +95,7 @@
: 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 d73d9de..9e3898e 100644
--- a/rtc_base/proxy_unittest.cc
+++ b/rtc_base/proxy_unittest.cc
@@ -43,8 +43,8 @@
// 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 ebe420c..673083c 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 @@
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 a534eea..07e9636 100644
--- a/rtc_base/server_socket_adapters.h
+++ b/rtc_base/server_socket_adapters.h
@@ -18,7 +18,7 @@
// 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<AsyncProxyServerSocket*, const SocketAddress&>
SignalConnectRequest;
@@ -29,7 +29,7 @@
// 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 @@
// 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 81f4f0b..e38f8af 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 @@
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<Socket*, sigslot::multi_threaded_local> SignalReadEvent;
+ // ready to write
+ sigslot::signal1<Socket*, sigslot::multi_threaded_local> SignalWriteEvent;
+ sigslot::signal1<Socket*> SignalConnectEvent; // connected
+ sigslot::signal2<Socket*, int> SignalCloseEvent; // closed
+
protected:
Socket() {}
@@ -131,6 +144,10 @@
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 ee20a76..08e967b 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 @@
buffering_ = on;
}
-void BufferedReadAdapter::OnReadEvent(AsyncSocket* socket) {
+void BufferedReadAdapter::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket == GetSocket());
if (!buffering_) {
@@ -168,7 +168,7 @@
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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-AsyncHttpsProxySocket::AsyncHttpsProxySocket(AsyncSocket* socket,
+AsyncHttpsProxySocket::AsyncHttpsProxySocket(Socket* socket,
const std::string& user_agent,
const SocketAddress& proxy,
const std::string& username,
@@ -266,7 +266,7 @@
}
}
-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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-AsyncSocksProxySocket::AsyncSocksProxySocket(AsyncSocket* socket,
+AsyncSocksProxySocket::AsyncSocksProxySocket(Socket* socket,
const SocketAddress& proxy,
const std::string& username,
const CryptString& password)
@@ -505,7 +505,7 @@
}
}
-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 99c9109..67d3bbf 100644
--- a/rtc_base/socket_adapters.h
+++ b/rtc_base/socket_adapters.h
@@ -31,7 +31,7 @@
// 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 @@
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 @@
static ArrayView<const uint8_t> SslClientHello();
static ArrayView<const uint8_t> 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 @@
// 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 @@
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 @@
// 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 @@
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 7356745..b43bd1b 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 @@
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 e93d6aa..a526f0c 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 @@
delete socket_;
}
-void SocketStream::Attach(AsyncSocket* socket) {
+void SocketStream::Attach(Socket* socket) {
if (socket_)
delete socket_;
socket_ = socket;
@@ -35,8 +35,8 @@
}
}
-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 @@
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 f9875fe..266a6e6 100644
--- a/rtc_base/socket_stream.h
+++ b/rtc_base/socket_stream.h
@@ -13,8 +13,8 @@
#include <stddef.h>
-#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 @@
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 @@
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 82e2f6d..720dc6c 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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
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<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// 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<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server, but don't listen yet.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -362,7 +361,7 @@
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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server, but don't listen yet.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@@ -396,15 +395,14 @@
// 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::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// Accept the original connection.
SocketAddress accept_addr;
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
// 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 @@
StreamSink sink;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
client->Close();
// The connection should still be able to be accepted.
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
// 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 @@
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 @@
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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
// Helper class specifically for the test below.
class SocketDeleter : public sigslot::has_slots<> {
public:
- explicit SocketDeleter(std::unique_ptr<AsyncSocket> socket)
+ explicit SocketDeleter(std::unique_ptr<Socket> 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<AsyncSocket> socket_;
+ std::unique_ptr<Socket> 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<AsyncSocket> socket1(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
- std::unique_ptr<AsyncSocket> socket2(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> socket1(
+ ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> 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 @@
SocketAddress accept_addr;
// Create & connect server and client sockets.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
thread->Start();
Sleeper sleeper;
- TypedMessageData<AsyncSocket*> data(client.get());
+ TypedMessageData<Socket*> data(client.get());
thread->Send(RTC_FROM_HERE, &sleeper, 0, &data);
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
@@ -758,13 +756,13 @@
SocketAddress accept_addr;
// Create receiving client.
- std::unique_ptr<AsyncSocket> receiver(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> receiver(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(receiver.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// Accept connection which will be used for sending.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> sender(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
// 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 @@
SocketAddress accept_addr;
// Create client.
- std::unique_ptr<AsyncSocket> client(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server and listen.
- std::unique_ptr<AsyncSocket> server(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout);
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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::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::GetSetOptionsInternal(const IPAddress& loopback) {
- std::unique_ptr<AsyncSocket> socket(
- ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM));
+ std::unique_ptr<Socket> 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 9d414ea..c9b54c4 100644
--- a/rtc_base/ssl_adapter.cc
+++ b/rtc_base/ssl_adapter.cc
@@ -20,7 +20,7 @@
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 2605770..1f0616b 100644
--- a/rtc_base/ssl_adapter.h
+++ b/rtc_base/ssl_adapter.h
@@ -40,7 +40,7 @@
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 @@
// 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 @@
// 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 498eba3..2b55211 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -30,13 +30,12 @@
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 @@
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 @@
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 @@
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 @@
}
}
- 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 @@
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 @@
}
private:
- void DoHandshake(rtc::AsyncSocket* socket) {
+ void DoHandshake(rtc::Socket* socket) {
ssl_stream_adapter_ = rtc::SSLStreamAdapter::Create(
std::make_unique<rtc::SocketStream>(socket));
@@ -284,7 +281,7 @@
const rtc::SSLMode ssl_mode_;
- std::unique_ptr<rtc::AsyncSocket> server_socket_;
+ std::unique_ptr<rtc::Socket> server_socket_;
std::unique_ptr<rtc::SSLStreamAdapter> ssl_stream_adapter_;
std::unique_ptr<rtc::SSLIdentity> ssl_identity_;
@@ -335,13 +332,13 @@
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 @@
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 @@
} 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 af8a4a7..e150102 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -13,11 +13,11 @@
#include <utility>
#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 @@
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<AsyncUDPSocket>(socket));
@@ -56,8 +56,8 @@
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<AsyncTCPSocket> 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 d2e11d6..feda4cd 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 da40ac4..6fdfc24 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 @@
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 @@
}
typedef std::list<AsyncTCPSocket*> ClientList;
- std::unique_ptr<AsyncSocket> server_socket_;
+ std::unique_ptr<Socket> 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 7068e73..3f877fc 100644
--- a/rtc_base/test_utils.h
+++ b/rtc_base/test_utils.h
@@ -16,14 +16,14 @@
#include <map>
#include <utility>
-#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 @@
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 @@
// 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<rtc::AsyncSocket*, int> EventMap;
+ typedef std::map<rtc::Socket*, int> 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 @@
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 6c1253a..430db3d 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -64,7 +64,7 @@
// 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 @@
// 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 77d6174..8e97c0f 100644
--- a/rtc_base/virtual_socket_server.cc
+++ b/rtc_base/virtual_socket_server.cc
@@ -614,10 +614,6 @@
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 af86991..dafab54 100644
--- a/rtc_base/virtual_socket_server.h
+++ b/rtc_base/virtual_socket_server.h
@@ -116,7 +116,6 @@
// 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 @@
// 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 96a359d..44e7288 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 @@
// 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<AsyncUDPSocket>(s)),
done(false),
@@ -101,7 +100,7 @@
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<AsyncUDPSocket>(s)),
bandwidth(bw),
@@ -196,8 +195,7 @@
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 @@
std::make_unique<AsyncUDPSocket>(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 @@
}
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 @@
auto client1 = std::make_unique<TestClient>(
std::make_unique<AsyncUDPSocket>(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<TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
@@ -278,21 +273,21 @@
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> server = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server =
+ absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
EXPECT_EQ(0, server->Listen(5));
- EXPECT_EQ(server->GetState(), 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 @@
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 @@
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 @@
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client =
+ absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server
- std::unique_ptr<AsyncSocket> server = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
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 @@
EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server
- std::unique_ptr<AsyncSocket> client(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> client(
+ ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
- std::unique_ptr<AsyncSocket> server(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> server(
+ ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
// Initiate connect
@@ -402,10 +397,10 @@
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 @@
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 @@
// Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> 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 @@
const SocketAddress kEmptyAddr;
// Create clients
- std::unique_ptr<AsyncSocket> a = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a =
+ absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<AsyncSocket> b = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
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 @@
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 @@
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<AsyncSocket> a = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a =
+ absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get());
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
- std::unique_ptr<AsyncSocket> b = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<AsyncSocket> a = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
- std::unique_ptr<AsyncSocket> b = absl::WrapUnique(
- ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> a =
+ absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
// 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 @@
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 @@
const SocketAddress kEmptyAddr;
// Client gets a IPv4 address
- std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
- ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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<AsyncSocket> server = absl::WrapUnique(
- ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 @@
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 @@
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<TestClient>(
std::make_unique<AsyncUDPSocket>(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<TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
@@ -1043,10 +1034,9 @@
}
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
- AsyncSocket* socket1 =
- ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
- std::unique_ptr<AsyncSocket> socket2 = absl::WrapUnique(
- ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
+ Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
+ std::unique_ptr<Socket> socket2 =
+ absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
auto client1 = std::make_unique<TestClient>(
@@ -1068,10 +1058,10 @@
ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink;
- std::unique_ptr<AsyncSocket> socket1 = absl::WrapUnique(
- ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
- std::unique_ptr<AsyncSocket> socket2 = absl::WrapUnique(
- ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> socket1 =
+ absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
+ std::unique_ptr<Socket> 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 cfe21a3..835d1a7 100644
--- a/rtc_base/win32_socket_server.cc
+++ b/rtc_base/win32_socket_server.cc
@@ -686,10 +686,6 @@
}
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 317acce..3e7d728 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 @@
// Win32Socket
///////////////////////////////////////////////////////////////////////////////
-class Win32Socket : public AsyncSocket {
+class Win32Socket : public Socket {
public:
Win32Socket();
~Win32Socket() override;
@@ -36,7 +35,7 @@
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 @@
// 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 1e39a3f..3836cc1 100644
--- a/test/network/BUILD.gn
+++ b/test/network/BUILD.gn
@@ -55,12 +55,12 @@
"../../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 41200ad..9597edb 100644
--- a/test/network/fake_network_socket_server.cc
+++ b/test/network/fake_network_socket_server.cc
@@ -32,7 +32,7 @@
} // 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 @@
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 @@
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 @@
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 @@
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 d8be2e2..5b23a01 100644
--- a/test/network/fake_network_socket_server.h
+++ b/test/network/fake_network_socket_server.h
@@ -15,8 +15,8 @@
#include <vector>
#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 @@
// 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 fca10c4..7848a11 100644
--- a/test/network/network_emulation_unittest.cc
+++ b/test/network/network_emulation_unittest.cc
@@ -36,7 +36,7 @@
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 @@
}
~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 @@
}
private:
- rtc::AsyncSocket* const socket_;
+ rtc::Socket* const socket_;
rtc::Thread* const network_thread_;
char* buf_;
size_t size_;
@@ -207,13 +207,13 @@
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<void>(RTC_FROM_HERE, [&] {
- s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM);
+ s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
});
t2->Invoke<void>(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 @@
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<void>(RTC_FROM_HERE, [&] {
- s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM);
+ s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
});
t2->Invoke<void>(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 @@
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<void>(RTC_FROM_HERE, [&] {
- s1 = t1->socketserver()->CreateAsyncSocket(AF_INET, SOCK_DGRAM);
+ s1 = t1->socketserver()->CreateSocket(AF_INET, SOCK_DGRAM);
});
t2->Invoke<void>(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 643da5d..49ab0ee 100644
--- a/test/run_loop.cc
+++ b/test/run_loop.cc
@@ -61,11 +61,6 @@
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 f350b2c..9a91d44 100644
--- a/test/run_loop.h
+++ b/test/run_loop.h
@@ -56,7 +56,6 @@
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 aa8b9ac..73a52b2 100644
--- a/test/time_controller/simulated_thread.cc
+++ b/test/time_controller/simulated_thread.cc
@@ -26,10 +26,6 @@
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;
