admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Delete AsyncSocket class, merge into Socket class

Browse Source 
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}
This commit is contained in:
Niels Möller 2021-08-12 10:32:30 +02:00 committed by WebRTC LUCI CQ
parent 45b3e530cb
commit d0b8879770
73 changed files with 570 additions and 685 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/androidvoip/jni/android_voip_client.cc
View File

@ -61,8 +61,8 @@ rtc::IPAddress QueryDefaultLocalAddress(int family) {
RTC_DCHECK(thread->socketserver() != nullptr); RTC_DCHECK(thread->socketserver() != nullptr);
RTC_DCHECK(family == AF_INET || family == AF_INET6); RTC_DCHECK(family == AF_INET || family == AF_INET6);
std::unique_ptr<rtc::AsyncSocket> socket( std::unique_ptr<rtc::Socket> socket(
thread->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM)); thread->socketserver()->CreateSocket(family, SOCK_DGRAM));
if (!socket) { if (!socket) {
RTC_LOG_ERR(LERROR) << "Socket creation failed"; RTC_LOG_ERR(LERROR) << "Socket creation failed";
return rtc::IPAddress(); return rtc::IPAddress();

16
examples/peerconnection/client/peer_connection_client.cc
View File

@ -26,7 +26,7 @@ const char kByeMessage[] = "BYE";
// Delay between server connection retries, in milliseconds // Delay between server connection retries, in milliseconds
const int kReconnectDelay = 2000; const int kReconnectDelay = 2000;
rtc::AsyncSocket* CreateClientSocket(int family) { rtc::Socket* CreateClientSocket(int family) {
#ifdef WIN32 #ifdef WIN32
rtc::Win32Socket* sock = new rtc::Win32Socket(); rtc::Win32Socket* sock = new rtc::Win32Socket();
sock->CreateT(family, SOCK_STREAM); sock->CreateT(family, SOCK_STREAM);
@ -34,7 +34,7 @@ rtc::AsyncSocket* CreateClientSocket(int family) {
#elif defined(WEBRTC_POSIX) #elif defined(WEBRTC_POSIX)
rtc::Thread* thread = rtc::Thread::Current(); rtc::Thread* thread = rtc::Thread::Current();
RTC_DCHECK(thread != NULL); RTC_DCHECK(thread != NULL);
return thread->socketserver()->CreateAsyncSocket(family, SOCK_STREAM); return thread->socketserver()->CreateSocket(family, SOCK_STREAM);
#else #else
#error Platform not supported. #error Platform not supported.
#endif #endif
@ -227,14 +227,14 @@ bool PeerConnectionClient::ConnectControlSocket() {
return true; return true;
} }
void PeerConnectionClient::OnConnect(rtc::AsyncSocket* socket) { void PeerConnectionClient::OnConnect(rtc::Socket* socket) {
RTC_DCHECK(!onconnect_data_.empty()); RTC_DCHECK(!onconnect_data_.empty());
size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length()); size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length());
RTC_DCHECK(sent == onconnect_data_.length()); RTC_DCHECK(sent == onconnect_data_.length());
onconnect_data_.clear(); onconnect_data_.clear();
} }
void PeerConnectionClient::OnHangingGetConnect(rtc::AsyncSocket* socket) { void PeerConnectionClient::OnHangingGetConnect(rtc::Socket* socket) {
char buffer[1024]; char buffer[1024];
snprintf(buffer, sizeof(buffer), "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n", snprintf(buffer, sizeof(buffer), "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n",
my_id_); my_id_);
@ -283,7 +283,7 @@ bool PeerConnectionClient::GetHeaderValue(const std::string& data,
return false; return false;
} }
bool PeerConnectionClient::ReadIntoBuffer(rtc::AsyncSocket* socket, bool PeerConnectionClient::ReadIntoBuffer(rtc::Socket* socket,
std::string* data, std::string* data,
size_t* content_length) { size_t* content_length) {
char buffer[0xffff]; char buffer[0xffff];
@ -321,7 +321,7 @@ bool PeerConnectionClient::ReadIntoBuffer(rtc::AsyncSocket* socket,
return ret; return ret;
} }
void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) { void PeerConnectionClient::OnRead(rtc::Socket* socket) {
size_t content_length = 0; size_t content_length = 0;
if (ReadIntoBuffer(socket, &control_data_, &content_length)) { if (ReadIntoBuffer(socket, &control_data_, &content_length)) {
size_t peer_id = 0, eoh = 0; size_t peer_id = 0, eoh = 0;
@ -373,7 +373,7 @@ void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) {
} }
} }
void PeerConnectionClient::OnHangingGetRead(rtc::AsyncSocket* socket) { void PeerConnectionClient::OnHangingGetRead(rtc::Socket* socket) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(INFO) << __FUNCTION__;
size_t content_length = 0; size_t content_length = 0;
if (ReadIntoBuffer(socket, &notification_data_, &content_length)) { if (ReadIntoBuffer(socket, &notification_data_, &content_length)) {
@ -471,7 +471,7 @@ bool PeerConnectionClient::ParseServerResponse(const std::string& response,
return true; return true;
} }
void PeerConnectionClient::OnClose(rtc::AsyncSocket* socket, int err) { void PeerConnectionClient::OnClose(rtc::Socket* socket, int err) {
RTC_LOG(INFO) << __FUNCTION__; RTC_LOG(INFO) << __FUNCTION__;
socket->Close(); socket->Close();

16
examples/peerconnection/client/peer_connection_client.h
View File

@ -73,8 +73,8 @@ class PeerConnectionClient : public sigslot::has_slots<>,
void Close(); void Close();
void InitSocketSignals(); void InitSocketSignals();
bool ConnectControlSocket(); bool ConnectControlSocket();
void OnConnect(rtc::AsyncSocket* socket); void OnConnect(rtc::Socket* socket);
void OnHangingGetConnect(rtc::AsyncSocket* socket); void OnHangingGetConnect(rtc::Socket* socket);
void OnMessageFromPeer(int peer_id, const std::string& message); void OnMessageFromPeer(int peer_id, const std::string& message);
// Quick and dirty support for parsing HTTP header values. // Quick and dirty support for parsing HTTP header values.
@ -89,13 +89,13 @@ class PeerConnectionClient : public sigslot::has_slots<>,
std::string* value); std::string* value);
// Returns true if the whole response has been read. // Returns true if the whole response has been read.
bool ReadIntoBuffer(rtc::AsyncSocket* socket, bool ReadIntoBuffer(rtc::Socket* socket,
std::string* data, std::string* data,
size_t* content_length); 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>" // Parses a single line entry in the form "<name>,<id>,<connected>"
bool ParseEntry(const std::string& entry, bool ParseEntry(const std::string& entry,
@ -110,15 +110,15 @@ class PeerConnectionClient : public sigslot::has_slots<>,
size_t* peer_id, size_t* peer_id,
size_t* eoh); size_t* eoh);
void OnClose(rtc::AsyncSocket* socket, int err); void OnClose(rtc::Socket* socket, int err);
void OnResolveResult(rtc::AsyncResolverInterface* resolver); void OnResolveResult(rtc::AsyncResolverInterface* resolver);
PeerConnectionClientObserver* callback_; PeerConnectionClientObserver* callback_;
rtc::SocketAddress server_address_; rtc::SocketAddress server_address_;
rtc::AsyncResolver* resolver_; rtc::AsyncResolver* resolver_;
std::unique_ptr<rtc::AsyncSocket> control_socket_; std::unique_ptr<rtc::Socket> control_socket_;
std::unique_ptr<rtc::AsyncSocket> hanging_get_; std::unique_ptr<rtc::Socket> hanging_get_;
std::string onconnect_data_; std::string onconnect_data_;
std::string control_data_; std::string control_data_;
std::string notification_data_; std::string notification_data_;

4
p2p/BUILD.gn
View File

@ -99,7 +99,6 @@ rtc_library("rtc_p2p") {
"../logging:ice_log", "../logging:ice_log",
"../rtc_base", "../rtc_base",
"../rtc_base:async_resolver_interface", "../rtc_base:async_resolver_interface",
"../rtc_base:async_socket",
"../rtc_base:callback_list", "../rtc_base:callback_list",
"../rtc_base:checks", "../rtc_base:checks",
"../rtc_base:ip_address", "../rtc_base:ip_address",
@ -189,10 +188,10 @@ if (rtc_include_tests) {
"../api/transport:stun_types", "../api/transport:stun_types",
"../rtc_base", "../rtc_base",
"../rtc_base:async_resolver_interface", "../rtc_base:async_resolver_interface",
"../rtc_base:async_socket",
"../rtc_base:gunit_helpers", "../rtc_base:gunit_helpers",
"../rtc_base:rtc_base_approved", "../rtc_base:rtc_base_approved",
"../rtc_base:rtc_base_tests_utils", "../rtc_base:rtc_base_tests_utils",
"../rtc_base:socket",
"../rtc_base:socket_address", "../rtc_base:socket_address",
"../rtc_base:socket_server", "../rtc_base:socket_server",
"../rtc_base:threading", "../rtc_base:threading",
@ -241,7 +240,6 @@ if (rtc_include_tests) {
"../api/transport:stun_types", "../api/transport:stun_types",
"../api/units:time_delta", "../api/units:time_delta",
"../rtc_base", "../rtc_base",
"../rtc_base:async_socket",
"../rtc_base:checks", "../rtc_base:checks",
"../rtc_base:gunit_helpers", "../rtc_base:gunit_helpers",
"../rtc_base:ip_address", "../rtc_base:ip_address",

6
p2p/base/async_stun_tcp_socket.cc
View File

@ -41,7 +41,7 @@ inline bool IsStunMessage(uint16_t msg_type) {
// it. Takes ownership of `socket`. Returns NULL if bind() or // it. Takes ownership of `socket`. Returns NULL if bind() or
// connect() fail (`socket` is destroyed in that case). // connect() fail (`socket` is destroyed in that case).
AsyncStunTCPSocket* AsyncStunTCPSocket::Create( AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
rtc::AsyncSocket* socket, rtc::Socket* socket,
const rtc::SocketAddress& bind_address, const rtc::SocketAddress& bind_address,
const rtc::SocketAddress& remote_address) { const rtc::SocketAddress& remote_address) {
return new AsyncStunTCPSocket( return new AsyncStunTCPSocket(
@ -49,7 +49,7 @@ AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
false); false);
} }
AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen) AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::Socket* socket, bool listen)
: rtc::AsyncTCPSocketBase(socket, listen, kBufSize) {} : rtc::AsyncTCPSocketBase(socket, listen, kBufSize) {}
int AsyncStunTCPSocket::Send(const void* pv, int AsyncStunTCPSocket::Send(const void* pv,
@ -126,7 +126,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
} }
} }
void AsyncStunTCPSocket::HandleIncomingConnection(rtc::AsyncSocket* socket) { void AsyncStunTCPSocket::HandleIncomingConnection(rtc::Socket* socket) {
SignalNewConnection(this, new AsyncStunTCPSocket(socket, false)); SignalNewConnection(this, new AsyncStunTCPSocket(socket, false));
} }

8
p2p/base/async_stun_tcp_socket.h
View File

@ -14,9 +14,9 @@
#include <stddef.h> #include <stddef.h>
#include "rtc_base/async_packet_socket.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_tcp_socket.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
namespace cricket { namespace cricket {
@ -26,17 +26,17 @@ class AsyncStunTCPSocket : public rtc::AsyncTCPSocketBase {
// Binds and connects `socket` and creates AsyncTCPSocket for // Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns NULL if bind() or // it. Takes ownership of `socket`. Returns NULL if bind() or
// connect() fail (`socket` is destroyed in that case). // 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& bind_address,
const rtc::SocketAddress& remote_address); const rtc::SocketAddress& remote_address);
AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen); AsyncStunTCPSocket(rtc::Socket* socket, bool listen);
int Send(const void* pv, int Send(const void* pv,
size_t cb, size_t cb,
const rtc::PacketOptions& options) override; const rtc::PacketOptions& options) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
void HandleIncomingConnection(rtc::AsyncSocket* socket) override; void HandleIncomingConnection(rtc::Socket* socket) override;
private: private:
// This method returns the message hdr + length written in the header. // This method returns the message hdr + length written in the header.

8
p2p/base/async_stun_tcp_socket_unittest.cc
View File

@ -17,8 +17,8 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include "rtc_base/async_socket.h"
#include "rtc_base/network/sent_packet.h" #include "rtc_base/network/sent_packet.h"
#include "rtc_base/socket.h"
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/virtual_socket_server.h" #include "rtc_base/virtual_socket_server.h"
@ -67,15 +67,13 @@ class AsyncStunTCPSocketTest : public ::testing::Test,
virtual void SetUp() { CreateSockets(); } virtual void SetUp() { CreateSockets(); }
void CreateSockets() { void CreateSockets() {
rtc::AsyncSocket* server = rtc::Socket* server = vss_->CreateSocket(kServerAddr.family(), SOCK_STREAM);
vss_->CreateAsyncSocket(kServerAddr.family(), SOCK_STREAM);
server->Bind(kServerAddr); server->Bind(kServerAddr);
recv_socket_.reset(new AsyncStunTCPSocket(server, true)); recv_socket_.reset(new AsyncStunTCPSocket(server, true));
recv_socket_->SignalNewConnection.connect( recv_socket_->SignalNewConnection.connect(
this, &AsyncStunTCPSocketTest::OnNewConnection); this, &AsyncStunTCPSocketTest::OnNewConnection);
rtc::AsyncSocket* client = rtc::Socket* client = vss_->CreateSocket(kClientAddr.family(), SOCK_STREAM);
vss_->CreateAsyncSocket(kClientAddr.family(), SOCK_STREAM);
send_socket_.reset(AsyncStunTCPSocket::Create( send_socket_.reset(AsyncStunTCPSocket::Create(
client, kClientAddr, recv_socket_->GetLocalAddress())); client, kClientAddr, recv_socket_->GetLocalAddress()));
send_socket_->SignalSentPacket.connect( send_socket_->SignalSentPacket.connect(

13
p2p/base/basic_packet_socket_factory.cc
View File

@ -46,8 +46,7 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateUdpSocket(
uint16_t min_port, uint16_t min_port,
uint16_t max_port) { uint16_t max_port) {
// UDP sockets are simple. // UDP sockets are simple.
AsyncSocket* socket = Socket* socket = socket_factory()->CreateSocket(address.family(), SOCK_DGRAM);
socket_factory()->CreateAsyncSocket(address.family(), SOCK_DGRAM);
if (!socket) { if (!socket) {
return NULL; return NULL;
} }
@ -70,8 +69,8 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateServerTcpSocket(
return NULL; return NULL;
} }
AsyncSocket* socket = Socket* socket =
socket_factory()->CreateAsyncSocket(local_address.family(), SOCK_STREAM); socket_factory()->CreateSocket(local_address.family(), SOCK_STREAM);
if (!socket) { if (!socket) {
return NULL; return NULL;
} }
@ -108,8 +107,8 @@ AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
const ProxyInfo& proxy_info, const ProxyInfo& proxy_info,
const std::string& user_agent, const std::string& user_agent,
const PacketSocketTcpOptions& tcp_options) { const PacketSocketTcpOptions& tcp_options) {
AsyncSocket* socket = Socket* socket =
socket_factory()->CreateAsyncSocket(local_address.family(), SOCK_STREAM); socket_factory()->CreateSocket(local_address.family(), SOCK_STREAM);
if (!socket) { if (!socket) {
return NULL; return NULL;
} }
@ -203,7 +202,7 @@ AsyncResolverInterface* BasicPacketSocketFactory::CreateAsyncResolver() {
return new AsyncResolver(); return new AsyncResolver();
} }
int BasicPacketSocketFactory::BindSocket(AsyncSocket* socket, int BasicPacketSocketFactory::BindSocket(Socket* socket,
const SocketAddress& local_address, const SocketAddress& local_address,
uint16_t min_port, uint16_t min_port,
uint16_t max_port) { uint16_t max_port) {

4
p2p/base/basic_packet_socket_factory.h
View File

@ -14,10 +14,10 @@
#include <string> #include <string>
#include "api/packet_socket_factory.h" #include "api/packet_socket_factory.h"
#include "rtc_base/socket.h"
namespace rtc { namespace rtc {
class AsyncSocket;
class SocketFactory; class SocketFactory;
class Thread; class Thread;
@ -45,7 +45,7 @@ class BasicPacketSocketFactory : public PacketSocketFactory {
AsyncResolverInterface* CreateAsyncResolver() override; AsyncResolverInterface* CreateAsyncResolver() override;
private: private:
int BindSocket(AsyncSocket* socket, int BindSocket(Socket* socket,
const SocketAddress& local_address, const SocketAddress& local_address,
uint16_t min_port, uint16_t min_port,
uint16_t max_port); uint16_t max_port);

5
p2p/base/port_unittest.cc
View File

@ -40,7 +40,6 @@
#include "p2p/client/relay_port_factory_interface.h" #include "p2p/client/relay_port_factory_interface.h"
#include "rtc_base/arraysize.h" #include "rtc_base/arraysize.h"
#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/byte_buffer.h" #include "rtc_base/byte_buffer.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -1217,8 +1216,8 @@ TEST_F(PortTest, TestTcpNeverConnect) {
ch1.Start(); ch1.Start();
ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout); ASSERT_EQ_WAIT(1, ch1.complete_count(), kDefaultTimeout);
std::unique_ptr<rtc::AsyncSocket> server( std::unique_ptr<rtc::Socket> server(
vss()->CreateAsyncSocket(kLocalAddr2.family(), SOCK_STREAM)); vss()->CreateSocket(kLocalAddr2.family(), SOCK_STREAM));
// Bind but not listen. // Bind but not listen.
EXPECT_EQ(0, server->Bind(kLocalAddr2)); EXPECT_EQ(0, server->Bind(kLocalAddr2));

2
p2p/base/stun_server.h
View File

@ -34,7 +34,7 @@ class StunServer : public sigslot::has_slots<> {
~StunServer() override; ~StunServer() override;
protected: protected:
// Slot for AsyncSocket.PacketRead: // Slot for Socket.PacketRead:
void OnPacket(rtc::AsyncPacketSocket* socket, void OnPacket(rtc::AsyncPacketSocket* socket,
const char* buf, const char* buf,
size_t size, size_t size,

4
p2p/base/test_stun_server.cc
View File

@ -10,14 +10,14 @@
#include "p2p/base/test_stun_server.h" #include "p2p/base/test_stun_server.h"
#include "rtc_base/async_socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
namespace cricket { namespace cricket {
TestStunServer* TestStunServer::Create(rtc::SocketServer* ss, TestStunServer* TestStunServer::Create(rtc::SocketServer* ss,
const rtc::SocketAddress& addr) { 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); rtc::AsyncUDPSocket* udp_socket = rtc::AsyncUDPSocket::Create(socket, addr);
return new TestStunServer(udp_socket); return new TestStunServer(udp_socket);

4
p2p/base/test_turn_server.h
View File

@ -99,8 +99,8 @@ class TestTurnServer : public TurnAuthInterface {
} else if (proto == cricket::PROTO_TCP || proto == cricket::PROTO_TLS) { } else if (proto == cricket::PROTO_TCP || proto == cricket::PROTO_TLS) {
// For TCP we need to create a server socket which can listen for incoming // For TCP we need to create a server socket which can listen for incoming
// new connections. // new connections.
rtc::AsyncSocket* socket = rtc::Socket* socket =
thread_->socketserver()->CreateAsyncSocket(AF_INET, SOCK_STREAM); thread_->socketserver()->CreateSocket(AF_INET, SOCK_STREAM);
if (proto == cricket::PROTO_TLS) { if (proto == cricket::PROTO_TLS) {
// For TLS, wrap the TCP socket with an SSL adapter. The adapter must // For TLS, wrap the TCP socket with an SSL adapter. The adapter must
// be configured with a self-signed certificate for testing. // be configured with a self-signed certificate for testing.

6
p2p/base/turn_port_unittest.cc
View File

@ -28,7 +28,6 @@
#include "p2p/base/transport_description.h" #include "p2p/base/transport_description.h"
#include "p2p/base/turn_port.h" #include "p2p/base/turn_port.h"
#include "p2p/base/turn_server.h" #include "p2p/base/turn_server.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/byte_buffer.h" #include "rtc_base/byte_buffer.h"
#include "rtc_base/checks.h" #include "rtc_base/checks.h"
@ -37,6 +36,7 @@
#include "rtc_base/location.h" #include "rtc_base/location.h"
#include "rtc_base/message_handler.h" #include "rtc_base/message_handler.h"
#include "rtc_base/net_helper.h" #include "rtc_base/net_helper.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
#include "rtc_base/time_utils.h" #include "rtc_base/time_utils.h"
@ -242,8 +242,8 @@ class TurnPortTest : public ::testing::Test,
void OnTurnPortClosed(TurnPort* port) { turn_port_closed_ = true; } void OnTurnPortClosed(TurnPort* port) { turn_port_closed_ = true; }
void OnTurnPortDestroyed(PortInterface* port) { turn_port_destroyed_ = true; } void OnTurnPortDestroyed(PortInterface* port) { turn_port_destroyed_ = true; }
rtc::AsyncSocket* CreateServerSocket(const SocketAddress addr) { rtc::Socket* CreateServerSocket(const SocketAddress addr) {
rtc::AsyncSocket* socket = ss_->CreateAsyncSocket(AF_INET, SOCK_STREAM); rtc::Socket* socket = ss_->CreateSocket(AF_INET, SOCK_STREAM);
EXPECT_GE(socket->Bind(addr), 0); EXPECT_GE(socket->Bind(addr), 0);
EXPECT_GE(socket->Listen(5), 0); EXPECT_GE(socket->Listen(5), 0);
return socket; return socket;

10
p2p/base/turn_server.cc
View File

@ -139,7 +139,7 @@ TurnServer::~TurnServer() {
for (ServerSocketMap::iterator it = server_listen_sockets_.begin(); for (ServerSocketMap::iterator it = server_listen_sockets_.begin();
it != server_listen_sockets_.end(); ++it) { it != server_listen_sockets_.end(); ++it) {
rtc::AsyncSocket* socket = it->first; rtc::Socket* socket = it->first;
delete socket; delete socket;
} }
} }
@ -152,7 +152,7 @@ void TurnServer::AddInternalSocket(rtc::AsyncPacketSocket* socket,
socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket); socket->SignalReadPacket.connect(this, &TurnServer::OnInternalPacket);
} }
void TurnServer::AddInternalServerSocket(rtc::AsyncSocket* socket, void TurnServer::AddInternalServerSocket(rtc::Socket* socket,
ProtocolType proto) { ProtocolType proto) {
RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(server_listen_sockets_.end() == RTC_DCHECK(server_listen_sockets_.end() ==
@ -169,17 +169,17 @@ void TurnServer::SetExternalSocketFactory(
external_addr_ = external_addr; external_addr_ = external_addr;
} }
void TurnServer::OnNewInternalConnection(rtc::AsyncSocket* socket) { void TurnServer::OnNewInternalConnection(rtc::Socket* socket) {
RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK_RUN_ON(thread_);
RTC_DCHECK(server_listen_sockets_.find(socket) != RTC_DCHECK(server_listen_sockets_.find(socket) !=
server_listen_sockets_.end()); server_listen_sockets_.end());
AcceptConnection(socket); 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. // Check if someone is trying to connect to us.
rtc::SocketAddress accept_addr; 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) { if (accepted_socket != NULL) {
ProtocolType proto = server_listen_sockets_[server_socket]; ProtocolType proto = server_listen_sockets_[server_socket];
cricket::AsyncStunTCPSocket* tcp_socket = cricket::AsyncStunTCPSocket* tcp_socket =

8
p2p/base/turn_server.h
View File

@ -237,7 +237,7 @@ class TurnServer : public sigslot::has_slots<> {
// Starts listening for the connections on this socket. When someone tries // Starts listening for the connections on this socket. When someone tries
// to connect, the connection will be accepted and a new internal socket // to connect, the connection will be accepted and a new internal socket
// will be added. // 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. // Specifies the factory to use for creating external sockets.
void SetExternalSocketFactory(rtc::PacketSocketFactory* factory, void SetExternalSocketFactory(rtc::PacketSocketFactory* factory,
const rtc::SocketAddress& address); const rtc::SocketAddress& address);
@ -265,10 +265,10 @@ class TurnServer : public sigslot::has_slots<> {
const rtc::SocketAddress& address, const rtc::SocketAddress& address,
const int64_t& packet_time_us); const int64_t& packet_time_us);
void OnNewInternalConnection(rtc::AsyncSocket* socket); void OnNewInternalConnection(rtc::Socket* socket);
// Accept connections on this server 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 OnInternalSocketClose(rtc::AsyncPacketSocket* socket, int err);
void HandleStunMessage(TurnServerConnection* conn, void HandleStunMessage(TurnServerConnection* conn,
@ -320,7 +320,7 @@ class TurnServer : public sigslot::has_slots<> {
RTC_RUN_ON(thread_); RTC_RUN_ON(thread_);
typedef std::map<rtc::AsyncPacketSocket*, ProtocolType> InternalSocketMap; 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_; rtc::Thread* const thread_;
const std::string nonce_key_; const std::string nonce_key_;

12
rtc_base/BUILD.gn
View File

@ -737,7 +737,6 @@ rtc_library("null_socket_server") {
"null_socket_server.h", "null_socket_server.h",
] ]
deps = [ deps = [
":async_socket",
":checks", ":checks",
":rtc_event", ":rtc_event",
":socket", ":socket",
@ -818,10 +817,7 @@ rtc_library("threading") {
rtc_source_set("socket_factory") { rtc_source_set("socket_factory") {
sources = [ "socket_factory.h" ] sources = [ "socket_factory.h" ]
deps = [ deps = [ ":socket" ]
":async_socket",
":socket",
]
} }
rtc_library("async_socket") { rtc_library("async_socket") {
@ -846,7 +842,9 @@ rtc_library("socket") {
deps = [ deps = [
":macromagic", ":macromagic",
":socket_address", ":socket_address",
"third_party/sigslot",
] ]
absl_deps = [ "//third_party/abseil-cpp/absl/base:core_headers" ]
if (is_win) { if (is_win) {
deps += [ ":win32" ] deps += [ ":win32" ]
} }
@ -1294,7 +1292,6 @@ if (rtc_include_tests) {
"socket_unittest.h", "socket_unittest.h",
] ]
deps = [ deps = [
":async_socket",
":checks", ":checks",
":gunit_helpers", ":gunit_helpers",
":ip_address", ":ip_address",
@ -1369,7 +1366,6 @@ if (rtc_include_tests) {
sources += [ "win/windows_version_unittest.cc" ] sources += [ "win/windows_version_unittest.cc" ]
} }
deps = [ deps = [
":async_socket",
":bounded_inline_vector", ":bounded_inline_vector",
":checks", ":checks",
":criticalsection", ":criticalsection",
@ -1505,13 +1501,13 @@ if (rtc_include_tests) {
"unique_id_generator_unittest.cc", "unique_id_generator_unittest.cc",
] ]
deps = [ deps = [
":async_socket",
":checks", ":checks",
":gunit_helpers", ":gunit_helpers",
":ip_address", ":ip_address",
":net_helpers", ":net_helpers",
":null_socket_server", ":null_socket_server",
":rtc_base_tests_utils", ":rtc_base_tests_utils",
":socket",
":socket_address", ":socket_address",
":socket_factory", ":socket_factory",
":socket_server", ":socket_server",

18
rtc_base/async_socket.cc
View File

@ -15,11 +15,7 @@
namespace rtc { namespace rtc {
AsyncSocket::AsyncSocket() {} AsyncSocketAdapter::AsyncSocketAdapter(Socket* socket)
AsyncSocket::~AsyncSocket() {}
AsyncSocketAdapter::AsyncSocketAdapter(AsyncSocket* socket)
: socket_(absl::WrapUnique(socket)) { : socket_(absl::WrapUnique(socket)) {
RTC_DCHECK(socket_); RTC_DCHECK(socket_);
socket_->SignalConnectEvent.connect(this, socket_->SignalConnectEvent.connect(this,
@ -70,7 +66,7 @@ int AsyncSocketAdapter::Listen(int backlog) {
return socket_->Listen(backlog); return socket_->Listen(backlog);
} }
AsyncSocket* AsyncSocketAdapter::Accept(SocketAddress* paddr) { Socket* AsyncSocketAdapter::Accept(SocketAddress* paddr) {
return socket_->Accept(paddr); return socket_->Accept(paddr);
} }
@ -86,7 +82,7 @@ void AsyncSocketAdapter::SetError(int error) {
return socket_->SetError(error); return socket_->SetError(error);
} }
AsyncSocket::ConnState AsyncSocketAdapter::GetState() const { Socket::ConnState AsyncSocketAdapter::GetState() const {
return socket_->GetState(); return socket_->GetState();
} }
@ -98,19 +94,19 @@ int AsyncSocketAdapter::SetOption(Option opt, int value) {
return socket_->SetOption(opt, value); return socket_->SetOption(opt, value);
} }
void AsyncSocketAdapter::OnConnectEvent(AsyncSocket* socket) { void AsyncSocketAdapter::OnConnectEvent(Socket* socket) {
SignalConnectEvent(this); SignalConnectEvent(this);
} }
void AsyncSocketAdapter::OnReadEvent(AsyncSocket* socket) { void AsyncSocketAdapter::OnReadEvent(Socket* socket) {
SignalReadEvent(this); SignalReadEvent(this);
} }
void AsyncSocketAdapter::OnWriteEvent(AsyncSocket* socket) { void AsyncSocketAdapter::OnWriteEvent(Socket* socket) {
SignalWriteEvent(this); SignalWriteEvent(this);
} }
void AsyncSocketAdapter::OnCloseEvent(AsyncSocket* socket, int err) { void AsyncSocketAdapter::OnCloseEvent(Socket* socket, int err) {
SignalCloseEvent(this, err); SignalCloseEvent(this, err);
} }

41
rtc_base/async_socket.h
View File

@ -22,34 +22,11 @@
namespace rtc { namespace rtc {
// TODO: Remove Socket and rename AsyncSocket to Socket. class AsyncSocketAdapter : public Socket, public sigslot::has_slots<> {
// 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<> {
public: public:
// Takes ownership of the passed in socket. // Takes ownership of the passed in socket.
// TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers. // 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 GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override; SocketAddress GetRemoteAddress() const override;
@ -63,7 +40,7 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
SocketAddress* paddr, SocketAddress* paddr,
int64_t* timestamp) override; int64_t* timestamp) override;
int Listen(int backlog) override; int Listen(int backlog) override;
AsyncSocket* Accept(SocketAddress* paddr) override; Socket* Accept(SocketAddress* paddr) override;
int Close() override; int Close() override;
int GetError() const override; int GetError() const override;
void SetError(int error) override; void SetError(int error) override;
@ -72,15 +49,15 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
int SetOption(Option opt, int value) override; int SetOption(Option opt, int value) override;
protected: protected:
virtual void OnConnectEvent(AsyncSocket* socket); virtual void OnConnectEvent(Socket* socket);
virtual void OnReadEvent(AsyncSocket* socket); virtual void OnReadEvent(Socket* socket);
virtual void OnWriteEvent(AsyncSocket* socket); virtual void OnWriteEvent(Socket* socket);
virtual void OnCloseEvent(AsyncSocket* socket, int err); virtual void OnCloseEvent(Socket* socket, int err);
AsyncSocket* GetSocket() const { return socket_.get(); } Socket* GetSocket() const { return socket_.get(); }
private: private:
const std::unique_ptr<AsyncSocket> socket_; const std::unique_ptr<Socket> socket_;
}; };
} // namespace rtc } // namespace rtc

24
rtc_base/async_tcp_socket.cc
View File

@ -45,11 +45,11 @@ static const size_t kMinimumRecvSize = 128;
static const int kListenBacklog = 5; static const int kListenBacklog = 5;
// Binds and connects `socket` // Binds and connects `socket`
AsyncSocket* AsyncTCPSocketBase::ConnectSocket( Socket* AsyncTCPSocketBase::ConnectSocket(
rtc::AsyncSocket* socket, rtc::Socket* socket,
const rtc::SocketAddress& bind_address, const rtc::SocketAddress& bind_address,
const rtc::SocketAddress& remote_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) { if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError(); RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr; return nullptr;
@ -61,7 +61,7 @@ AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
return owned_socket.release(); return owned_socket.release();
} }
AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket, AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket,
bool listen, bool listen,
size_t max_packet_size) size_t max_packet_size)
: socket_(socket), : socket_(socket),
@ -193,16 +193,16 @@ void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) {
outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb); outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb);
} }
void AsyncTCPSocketBase::OnConnectEvent(AsyncSocket* socket) { void AsyncTCPSocketBase::OnConnectEvent(Socket* socket) {
SignalConnect(this); SignalConnect(this);
} }
void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) { void AsyncTCPSocketBase::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket); RTC_DCHECK(socket_.get() == socket);
if (listen_) { if (listen_) {
rtc::SocketAddress address; rtc::SocketAddress address;
rtc::AsyncSocket* new_socket = socket->Accept(&address); rtc::Socket* new_socket = socket->Accept(&address);
if (!new_socket) { if (!new_socket) {
// TODO(stefan): Do something better like forwarding the error // TODO(stefan): Do something better like forwarding the error
// to the user. // to the user.
@ -259,7 +259,7 @@ void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
} }
} }
void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) { void AsyncTCPSocketBase::OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket); RTC_DCHECK(socket_.get() == socket);
if (outbuf_.size() > 0) { if (outbuf_.size() > 0) {
@ -271,7 +271,7 @@ void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
} }
} }
void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) { void AsyncTCPSocketBase::OnCloseEvent(Socket* socket, int error) {
SignalClose(this, error); SignalClose(this, error);
} }
@ -279,7 +279,7 @@ void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
// Binds and connects `socket` and creates AsyncTCPSocket for // Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or // it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case). // connect() fail (`socket` is destroyed in that case).
AsyncTCPSocket* AsyncTCPSocket::Create(AsyncSocket* socket, AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket,
const SocketAddress& bind_address, const SocketAddress& bind_address,
const SocketAddress& remote_address) { const SocketAddress& remote_address) {
return new AsyncTCPSocket( return new AsyncTCPSocket(
@ -287,7 +287,7 @@ AsyncTCPSocket* AsyncTCPSocket::Create(AsyncSocket* socket,
false); false);
} }
AsyncTCPSocket::AsyncTCPSocket(AsyncSocket* socket, bool listen) AsyncTCPSocket::AsyncTCPSocket(Socket* socket, bool listen)
: AsyncTCPSocketBase(socket, listen, kBufSize) {} : AsyncTCPSocketBase(socket, listen, kBufSize) {}
int AsyncTCPSocket::Send(const void* pv, int AsyncTCPSocket::Send(const void* pv,
@ -343,7 +343,7 @@ void AsyncTCPSocket::ProcessInput(char* data, size_t* len) {
} }
} }
void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) { void AsyncTCPSocket::HandleIncomingConnection(Socket* socket) {
SignalNewConnection(this, new AsyncTCPSocket(socket, false)); SignalNewConnection(this, new AsyncTCPSocket(socket, false));
} }

27
rtc_base/async_tcp_socket.h
View File

@ -16,7 +16,6 @@
#include <memory> #include <memory>
#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
@ -29,7 +28,7 @@ namespace rtc {
// buffer them in user space. // buffer them in user space.
class AsyncTCPSocketBase : public AsyncPacketSocket { class AsyncTCPSocketBase : public AsyncPacketSocket {
public: public:
AsyncTCPSocketBase(AsyncSocket* socket, bool listen, size_t max_packet_size); AsyncTCPSocketBase(Socket* socket, bool listen, size_t max_packet_size);
~AsyncTCPSocketBase() override; ~AsyncTCPSocketBase() override;
// Pure virtual methods to send and recv data. // Pure virtual methods to send and recv data.
@ -38,7 +37,7 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
const rtc::PacketOptions& options) override = 0; const rtc::PacketOptions& options) override = 0;
virtual void ProcessInput(char* data, size_t* len) = 0; virtual void ProcessInput(char* data, size_t* len) = 0;
// Signals incoming connection. // Signals incoming connection.
virtual void HandleIncomingConnection(AsyncSocket* socket) = 0; virtual void HandleIncomingConnection(Socket* socket) = 0;
SocketAddress GetLocalAddress() const override; SocketAddress GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override; SocketAddress GetRemoteAddress() const override;
@ -58,9 +57,9 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
// Binds and connects `socket` and creates AsyncTCPSocket for // Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or // it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case). // connect() fail (`socket` is destroyed in that case).
static AsyncSocket* ConnectSocket(AsyncSocket* socket, static Socket* ConnectSocket(Socket* socket,
const SocketAddress& bind_address, const SocketAddress& bind_address,
const SocketAddress& remote_address); const SocketAddress& remote_address);
int FlushOutBuffer(); int FlushOutBuffer();
// Add data to `outbuf_`. // Add data to `outbuf_`.
void AppendToOutBuffer(const void* pv, size_t cb); void AppendToOutBuffer(const void* pv, size_t cb);
@ -71,12 +70,12 @@ class AsyncTCPSocketBase : public AsyncPacketSocket {
private: private:
// Called by the underlying socket // Called by the underlying socket
void OnConnectEvent(AsyncSocket* socket); void OnConnectEvent(Socket* socket);
void OnReadEvent(AsyncSocket* socket); void OnReadEvent(Socket* socket);
void OnWriteEvent(AsyncSocket* socket); void OnWriteEvent(Socket* socket);
void OnCloseEvent(AsyncSocket* socket, int error); void OnCloseEvent(Socket* socket, int error);
std::unique_ptr<AsyncSocket> socket_; std::unique_ptr<Socket> socket_;
bool listen_; bool listen_;
Buffer inbuf_; Buffer inbuf_;
Buffer outbuf_; Buffer outbuf_;
@ -91,17 +90,17 @@ class AsyncTCPSocket : public AsyncTCPSocketBase {
// Binds and connects `socket` and creates AsyncTCPSocket for // Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or // it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case). // connect() fail (`socket` is destroyed in that case).
static AsyncTCPSocket* Create(AsyncSocket* socket, static AsyncTCPSocket* Create(Socket* socket,
const SocketAddress& bind_address, const SocketAddress& bind_address,
const SocketAddress& remote_address); const SocketAddress& remote_address);
AsyncTCPSocket(AsyncSocket* socket, bool listen); AsyncTCPSocket(Socket* socket, bool listen);
~AsyncTCPSocket() override {} ~AsyncTCPSocket() override {}
int Send(const void* pv, int Send(const void* pv,
size_t cb, size_t cb,
const rtc::PacketOptions& options) override; const rtc::PacketOptions& options) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
void HandleIncomingConnection(AsyncSocket* socket) override; void HandleIncomingConnection(Socket* socket) override;
private: private:
RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket);

4
rtc_base/async_tcp_socket_unittest.cc
View File

@ -22,7 +22,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> {
public: public:
AsyncTCPSocketTest() AsyncTCPSocketTest()
: vss_(new rtc::VirtualSocketServer()), : vss_(new rtc::VirtualSocketServer()),
socket_(vss_->CreateAsyncSocket(SOCK_STREAM)), socket_(vss_->CreateSocket(SOCK_STREAM)),
tcp_socket_(new AsyncTCPSocket(socket_, true)), tcp_socket_(new AsyncTCPSocket(socket_, true)),
ready_to_send_(false) { ready_to_send_(false) {
tcp_socket_->SignalReadyToSend.connect(this, tcp_socket_->SignalReadyToSend.connect(this,
@ -33,7 +33,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> {
protected: protected:
std::unique_ptr<VirtualSocketServer> vss_; std::unique_ptr<VirtualSocketServer> vss_;
AsyncSocket* socket_; Socket* socket_;
std::unique_ptr<AsyncTCPSocket> tcp_socket_; std::unique_ptr<AsyncTCPSocket> tcp_socket_;
bool ready_to_send_; bool ready_to_send_;
}; };

13
rtc_base/async_udp_socket.cc
View File

@ -24,9 +24,9 @@ namespace rtc {
static const int BUF_SIZE = 64 * 1024; static const int BUF_SIZE = 64 * 1024;
AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket, AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
const SocketAddress& bind_address) { const SocketAddress& bind_address) {
std::unique_ptr<AsyncSocket> owned_socket(socket); std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) { if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError(); RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr; return nullptr;
@ -36,14 +36,13 @@ AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket,
AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory, AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
const SocketAddress& bind_address) { const SocketAddress& bind_address) {
AsyncSocket* socket = Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM);
factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM);
if (!socket) if (!socket)
return nullptr; return nullptr;
return Create(socket, bind_address); return Create(socket, bind_address);
} }
AsyncUDPSocket::AsyncUDPSocket(AsyncSocket* socket) : socket_(socket) { AsyncUDPSocket::AsyncUDPSocket(Socket* socket) : socket_(socket) {
size_ = BUF_SIZE; size_ = BUF_SIZE;
buf_ = new char[size_]; buf_ = new char[size_];
@ -111,7 +110,7 @@ void AsyncUDPSocket::SetError(int error) {
return socket_->SetError(error); return socket_->SetError(error);
} }
void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) { void AsyncUDPSocket::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket); RTC_DCHECK(socket_.get() == socket);
SocketAddress remote_addr; SocketAddress remote_addr;
@ -134,7 +133,7 @@ void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) {
(timestamp > -1 ? timestamp : TimeMicros())); (timestamp > -1 ? timestamp : TimeMicros()));
} }
void AsyncUDPSocket::OnWriteEvent(AsyncSocket* socket) { void AsyncUDPSocket::OnWriteEvent(Socket* socket) {
SignalReadyToSend(this); SignalReadyToSend(this);
} }

11
rtc_base/async_udp_socket.h
View File

@ -16,7 +16,6 @@
#include <memory> #include <memory>
#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/socket_factory.h" #include "rtc_base/socket_factory.h"
@ -30,13 +29,13 @@ class AsyncUDPSocket : public AsyncPacketSocket {
// Binds `socket` and creates AsyncUDPSocket for it. Takes ownership // Binds `socket` and creates AsyncUDPSocket for it. Takes ownership
// of `socket`. Returns null if bind() fails (`socket` is destroyed // of `socket`. Returns null if bind() fails (`socket` is destroyed
// in that case). // in that case).
static AsyncUDPSocket* Create(AsyncSocket* socket, static AsyncUDPSocket* Create(Socket* socket,
const SocketAddress& bind_address); const SocketAddress& bind_address);
// Creates a new socket for sending asynchronous UDP packets using an // Creates a new socket for sending asynchronous UDP packets using an
// asynchronous socket from the given factory. // asynchronous socket from the given factory.
static AsyncUDPSocket* Create(SocketFactory* factory, static AsyncUDPSocket* Create(SocketFactory* factory,
const SocketAddress& bind_address); const SocketAddress& bind_address);
explicit AsyncUDPSocket(AsyncSocket* socket); explicit AsyncUDPSocket(Socket* socket);
~AsyncUDPSocket() override; ~AsyncUDPSocket() override;
SocketAddress GetLocalAddress() const override; SocketAddress GetLocalAddress() const override;
@ -58,11 +57,11 @@ class AsyncUDPSocket : public AsyncPacketSocket {
private: private:
// Called when the underlying socket is ready to be read from. // 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. // 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_; char* buf_;
size_t size_; size_t size_;
}; };

4
rtc_base/async_udp_socket_unittest.cc
View File

@ -24,7 +24,7 @@ class AsyncUdpSocketTest : public ::testing::Test, public sigslot::has_slots<> {
AsyncUdpSocketTest() AsyncUdpSocketTest()
: pss_(new rtc::PhysicalSocketServer), : pss_(new rtc::PhysicalSocketServer),
vss_(new rtc::VirtualSocketServer(pss_.get())), vss_(new rtc::VirtualSocketServer(pss_.get())),
socket_(vss_->CreateAsyncSocket(SOCK_DGRAM)), socket_(vss_->CreateSocket(SOCK_DGRAM)),
udp_socket_(new AsyncUDPSocket(socket_)), udp_socket_(new AsyncUDPSocket(socket_)),
ready_to_send_(false) { ready_to_send_(false) {
udp_socket_->SignalReadyToSend.connect(this, udp_socket_->SignalReadyToSend.connect(this,
@ -36,7 +36,7 @@ class AsyncUdpSocketTest : public ::testing::Test, public sigslot::has_slots<> {
protected: protected:
std::unique_ptr<PhysicalSocketServer> pss_; std::unique_ptr<PhysicalSocketServer> pss_;
std::unique_ptr<VirtualSocketServer> vss_; std::unique_ptr<VirtualSocketServer> vss_;
AsyncSocket* socket_; Socket* socket_;
std::unique_ptr<AsyncUDPSocket> udp_socket_; std::unique_ptr<AsyncUDPSocket> udp_socket_;
bool ready_to_send_; bool ready_to_send_;
}; };

14
rtc_base/firewall_socket_server.cc
View File

@ -25,7 +25,7 @@ namespace rtc {
class FirewallSocket : public AsyncSocketAdapter { class FirewallSocket : public AsyncSocketAdapter {
public: public:
FirewallSocket(FirewallSocketServer* server, AsyncSocket* socket, int type) FirewallSocket(FirewallSocketServer* server, Socket* socket, int type)
: AsyncSocketAdapter(socket), server_(server), type_(type) {} : AsyncSocketAdapter(socket), server_(server), type_(type) {}
int Bind(const SocketAddress& addr) override { int Bind(const SocketAddress& addr) override {
@ -96,9 +96,9 @@ class FirewallSocket : public AsyncSocketAdapter {
return AsyncSocketAdapter::Listen(backlog); return AsyncSocketAdapter::Listen(backlog);
} }
AsyncSocket* Accept(SocketAddress* paddr) override { Socket* Accept(SocketAddress* paddr) override {
SocketAddress addr; SocketAddress addr;
while (AsyncSocket* sock = AsyncSocketAdapter::Accept(&addr)) { while (Socket* sock = AsyncSocketAdapter::Accept(&addr)) {
if (server_->Check(FP_TCP, addr, GetLocalAddress())) { if (server_->Check(FP_TCP, addr, GetLocalAddress())) {
if (paddr) if (paddr)
*paddr = addr; *paddr = addr;
@ -203,11 +203,7 @@ bool FirewallSocketServer::IsBindableIp(const rtc::IPAddress& ip) {
} }
Socket* FirewallSocketServer::CreateSocket(int family, int type) { Socket* FirewallSocketServer::CreateSocket(int family, int type) {
return WrapSocket(server_->CreateAsyncSocket(family, type), type); return WrapSocket(server_->CreateSocket(family, type), type);
}
AsyncSocket* FirewallSocketServer::CreateAsyncSocket(int family, int type) {
return WrapSocket(server_->CreateAsyncSocket(family, type), type);
} }
void FirewallSocketServer::SetMessageQueue(Thread* queue) { void FirewallSocketServer::SetMessageQueue(Thread* queue) {
@ -222,7 +218,7 @@ void FirewallSocketServer::WakeUp() {
return server_->WakeUp(); return server_->WakeUp();
} }
AsyncSocket* FirewallSocketServer::WrapSocket(AsyncSocket* sock, int type) { Socket* FirewallSocketServer::WrapSocket(Socket* sock, int type) {
if (!sock || (type == SOCK_STREAM && !tcp_sockets_enabled_) || if (!sock || (type == SOCK_STREAM && !tcp_sockets_enabled_) ||
(type == SOCK_DGRAM && !udp_sockets_enabled_)) { (type == SOCK_DGRAM && !udp_sockets_enabled_)) {
RTC_LOG(LS_VERBOSE) << "FirewallSocketServer socket creation denied"; RTC_LOG(LS_VERBOSE) << "FirewallSocketServer socket creation denied";

3
rtc_base/firewall_socket_server.h
View File

@ -13,7 +13,6 @@
#include <vector> #include <vector>
#include "rtc_base/async_socket.h"
#include "rtc_base/ip_address.h" #include "rtc_base/ip_address.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
@ -78,14 +77,12 @@ class FirewallSocketServer : public SocketServer {
bool IsBindableIp(const rtc::IPAddress& ip); bool IsBindableIp(const rtc::IPAddress& ip);
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
void SetMessageQueue(Thread* queue) override; void SetMessageQueue(Thread* queue) override;
bool Wait(int cms, bool process_io) override; bool Wait(int cms, bool process_io) override;
void WakeUp() override; void WakeUp() override;
Socket* WrapSocket(Socket* sock, int type); Socket* WrapSocket(Socket* sock, int type);
AsyncSocket* WrapSocket(AsyncSocket* sock, int type);
private: private:
SocketServer* server_; SocketServer* server_;

4
rtc_base/nat_server.cc
View File

@ -70,7 +70,7 @@ bool AddrCmp::operator()(const SocketAddress& a1,
// a TCP connection to the NAT server. // a TCP connection to the NAT server.
class NATProxyServerSocket : public AsyncProxyServerSocket { class NATProxyServerSocket : public AsyncProxyServerSocket {
public: public:
NATProxyServerSocket(AsyncSocket* socket) NATProxyServerSocket(Socket* socket)
: AsyncProxyServerSocket(socket, kNATEncodedIPv6AddressSize) { : AsyncProxyServerSocket(socket, kNATEncodedIPv6AddressSize) {
BufferInput(true); BufferInput(true);
} }
@ -119,7 +119,7 @@ class NATProxyServer : public ProxyServer {
: ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {} : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected: protected:
AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override { AsyncProxyServerSocket* WrapSocket(Socket* socket) override {
return new NATProxyServerSocket(socket); return new NATProxyServerSocket(socket);
} }
}; };

48
rtc_base/nat_socket_factory.cc
View File

@ -69,7 +69,7 @@ size_t UnpackAddressFromNAT(const char* buf,
} }
// NATSocket // NATSocket
class NATSocket : public AsyncSocket, public sigslot::has_slots<> { class NATSocket : public Socket, public sigslot::has_slots<> {
public: public:
explicit NATSocket(NATInternalSocketFactory* sf, int family, int type) explicit NATSocket(NATInternalSocketFactory* sf, int family, int type)
: sf_(sf), : sf_(sf),
@ -213,7 +213,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
} }
int Listen(int backlog) override { return socket_->Listen(backlog); } int Listen(int backlog) override { return socket_->Listen(backlog); }
AsyncSocket* Accept(SocketAddress* paddr) override { Socket* Accept(SocketAddress* paddr) override {
return socket_->Accept(paddr); return socket_->Accept(paddr);
} }
int GetError() const override { int GetError() const override {
@ -236,7 +236,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
return socket_ ? socket_->SetOption(opt, value) : -1; 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. // If we're NATed, we need to send a message with the real addr to use.
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
if (server_addr_.IsNil()) { if (server_addr_.IsNil()) {
@ -246,7 +246,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
SendConnectRequest(); SendConnectRequest();
} }
} }
void OnReadEvent(AsyncSocket* socket) { void OnReadEvent(Socket* socket) {
// If we're NATed, we need to process the connect reply. // If we're NATed, we need to process the connect reply.
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
if (type_ == SOCK_STREAM && !server_addr_.IsNil() && !connected_) { if (type_ == SOCK_STREAM && !server_addr_.IsNil() && !connected_) {
@ -255,11 +255,11 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
SignalReadEvent(this); SignalReadEvent(this);
} }
} }
void OnWriteEvent(AsyncSocket* socket) { void OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalWriteEvent(this); SignalWriteEvent(this);
} }
void OnCloseEvent(AsyncSocket* socket, int error) { void OnCloseEvent(Socket* socket, int error) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalCloseEvent(this, error); SignalCloseEvent(this, error);
} }
@ -320,7 +320,7 @@ class NATSocket : public AsyncSocket, public sigslot::has_slots<> {
bool connected_; bool connected_;
SocketAddress remote_addr_; SocketAddress remote_addr_;
SocketAddress server_addr_; // address of the NAT server 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. // Need to hold error in case it occurs before the socket is created.
int error_ = 0; int error_ = 0;
char* buf_; char* buf_;
@ -339,21 +339,16 @@ Socket* NATSocketFactory::CreateSocket(int family, int type) {
return new NATSocket(this, family, type); return new NATSocket(this, family, type);
} }
AsyncSocket* NATSocketFactory::CreateAsyncSocket(int family, int type) { Socket* NATSocketFactory::CreateInternalSocket(int family,
return new NATSocket(this, family, type); int type,
} const SocketAddress& local_addr,
SocketAddress* nat_addr) {
AsyncSocket* NATSocketFactory::CreateInternalSocket(
int family,
int type,
const SocketAddress& local_addr,
SocketAddress* nat_addr) {
if (type == SOCK_STREAM) { if (type == SOCK_STREAM) {
*nat_addr = nat_tcp_addr_; *nat_addr = nat_tcp_addr_;
} else { } else {
*nat_addr = nat_udp_addr_; *nat_addr = nat_udp_addr_;
} }
return factory_->CreateAsyncSocket(family, type); return factory_->CreateSocket(family, type);
} }
// NATSocketServer // NATSocketServer
@ -384,10 +379,6 @@ Socket* NATSocketServer::CreateSocket(int family, int type) {
return new NATSocket(this, family, type); return new NATSocket(this, family, type);
} }
AsyncSocket* NATSocketServer::CreateAsyncSocket(int family, int type) {
return new NATSocket(this, family, type);
}
void NATSocketServer::SetMessageQueue(Thread* queue) { void NATSocketServer::SetMessageQueue(Thread* queue) {
msg_queue_ = queue; msg_queue_ = queue;
server_->SetMessageQueue(queue); server_->SetMessageQueue(queue);
@ -401,19 +392,18 @@ void NATSocketServer::WakeUp() {
server_->WakeUp(); server_->WakeUp();
} }
AsyncSocket* NATSocketServer::CreateInternalSocket( Socket* NATSocketServer::CreateInternalSocket(int family,
int family, int type,
int type, const SocketAddress& local_addr,
const SocketAddress& local_addr, SocketAddress* nat_addr) {
SocketAddress* nat_addr) { Socket* socket = nullptr;
AsyncSocket* socket = nullptr;
Translator* nat = nats_.FindClient(local_addr); Translator* nat = nats_.FindClient(local_addr);
if (nat) { 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_addr = (type == SOCK_STREAM) ? nat->internal_tcp_address()
: nat->internal_udp_address(); : nat->internal_udp_address();
} else { } else {
socket = server_->CreateAsyncSocket(family, type); socket = server_->CreateSocket(family, type);
} }
return socket; return socket;
} }

27
rtc_base/nat_socket_factory.h
View File

@ -17,7 +17,6 @@
#include <memory> #include <memory>
#include <set> #include <set>
#include "rtc_base/async_socket.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/nat_server.h" #include "rtc_base/nat_server.h"
#include "rtc_base/nat_types.h" #include "rtc_base/nat_types.h"
@ -36,10 +35,10 @@ const size_t kNATEncodedIPv6AddressSize = 20U;
class NATInternalSocketFactory { class NATInternalSocketFactory {
public: public:
virtual ~NATInternalSocketFactory() {} virtual ~NATInternalSocketFactory() {}
virtual AsyncSocket* CreateInternalSocket(int family, virtual Socket* CreateInternalSocket(int family,
int type, int type,
const SocketAddress& local_addr, const SocketAddress& local_addr,
SocketAddress* nat_addr) = 0; SocketAddress* nat_addr) = 0;
}; };
// Creates sockets that will send all traffic through a NAT, using an existing // Creates sockets that will send all traffic through a NAT, using an existing
@ -53,13 +52,12 @@ class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
// SocketFactory implementation // SocketFactory implementation
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
// NATInternalSocketFactory implementation // NATInternalSocketFactory implementation
AsyncSocket* CreateInternalSocket(int family, Socket* CreateInternalSocket(int family,
int type, int type,
const SocketAddress& local_addr, const SocketAddress& local_addr,
SocketAddress* nat_addr) override; SocketAddress* nat_addr) override;
private: private:
SocketFactory* factory_; SocketFactory* factory_;
@ -148,17 +146,16 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
// SocketServer implementation // SocketServer implementation
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
void SetMessageQueue(Thread* queue) override; void SetMessageQueue(Thread* queue) override;
bool Wait(int cms, bool process_io) override; bool Wait(int cms, bool process_io) override;
void WakeUp() override; void WakeUp() override;
// NATInternalSocketFactory implementation // NATInternalSocketFactory implementation
AsyncSocket* CreateInternalSocket(int family, Socket* CreateInternalSocket(int family,
int type, int type,
const SocketAddress& local_addr, const SocketAddress& local_addr,
SocketAddress* nat_addr) override; SocketAddress* nat_addr) override;
private: private:
SocketServer* server_; SocketServer* server_;

26
rtc_base/nat_unittest.cc
View File

@ -17,7 +17,6 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/async_packet_socket.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_tcp_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"
@ -29,6 +28,7 @@
#include "rtc_base/net_helpers.h" #include "rtc_base/net_helpers.h"
#include "rtc_base/network.h" #include "rtc_base/network.h"
#include "rtc_base/physical_socket_server.h" #include "rtc_base/physical_socket_server.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/socket_factory.h" #include "rtc_base/socket_factory.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
@ -55,7 +55,7 @@ TestClient* CreateTestClient(SocketFactory* factory,
absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr))); absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
} }
TestClient* CreateTCPTestClient(AsyncSocket* socket) { TestClient* CreateTCPTestClient(Socket* socket) {
return new TestClient(std::make_unique<AsyncTCPSocket>(socket, false)); return new TestClient(std::make_unique<AsyncTCPSocket>(socket, false));
} }
@ -201,10 +201,8 @@ bool TestConnectivity(const SocketAddress& src, const IPAddress& dst) {
// internal address used for the NAT. Things like firewalls can break that, so // 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. // check to see if it's worth even trying with this ip.
std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer()); std::unique_ptr<PhysicalSocketServer> pss(new PhysicalSocketServer());
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(pss->CreateSocket(src.family(), SOCK_DGRAM));
pss->CreateAsyncSocket(src.family(), SOCK_DGRAM)); std::unique_ptr<Socket> server(pss->CreateSocket(src.family(), SOCK_DGRAM));
std::unique_ptr<AsyncSocket> server(
pss->CreateAsyncSocket(src.family(), SOCK_DGRAM));
if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 || if (client->Bind(SocketAddress(src.ipaddr(), 0)) != 0 ||
server->Bind(SocketAddress(dst, 0)) != 0) { server->Bind(SocketAddress(dst, 0)) != 0) {
return false; return false;
@ -345,13 +343,13 @@ class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> {
ext_thread_->Start(); 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)); accepted_.reset(server_->Accept(nullptr));
} }
void OnCloseEvent(AsyncSocket* socket, int error) {} void OnCloseEvent(Socket* socket, int error) {}
void ConnectEvents() { void ConnectEvents() {
server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent); server_->SignalReadEvent.connect(this, &NatTcpTest::OnAcceptEvent);
@ -367,17 +365,17 @@ class NatTcpTest : public ::testing::Test, public sigslot::has_slots<> {
std::unique_ptr<Thread> ext_thread_; std::unique_ptr<Thread> ext_thread_;
std::unique_ptr<NATServer> nat_; std::unique_ptr<NATServer> nat_;
std::unique_ptr<NATSocketFactory> natsf_; std::unique_ptr<NATSocketFactory> natsf_;
std::unique_ptr<AsyncSocket> client_; std::unique_ptr<Socket> client_;
std::unique_ptr<AsyncSocket> server_; std::unique_ptr<Socket> server_;
std::unique_ptr<AsyncSocket> accepted_; std::unique_ptr<Socket> accepted_;
}; };
TEST_F(NatTcpTest, DISABLED_TestConnectOut) { 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_->Bind(ext_addr_);
server_->Listen(5); 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_->Bind(int_addr_));
EXPECT_GE(0, client_->Connect(server_->GetLocalAddress())); EXPECT_GE(0, client_->Connect(server_->GetLocalAddress()));

4
rtc_base/network.cc
View File

@ -912,8 +912,8 @@ IPAddress BasicNetworkManager::QueryDefaultLocalAddress(int family) const {
RTC_DCHECK(thread_->socketserver() != nullptr); RTC_DCHECK(thread_->socketserver() != nullptr);
RTC_DCHECK(family == AF_INET || family == AF_INET6); RTC_DCHECK(family == AF_INET || family == AF_INET6);
std::unique_ptr<AsyncSocket> socket( std::unique_ptr<Socket> socket(
thread_->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM)); thread_->socketserver()->CreateSocket(family, SOCK_DGRAM));
if (!socket) { if (!socket) {
RTC_LOG_ERR(LERROR) << "Socket creation failed"; RTC_LOG_ERR(LERROR) << "Socket creation failed";
return IPAddress(); return IPAddress();

2
rtc_base/network_unittest.cc
View File

@ -367,7 +367,7 @@ TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
IPAddress ip = (*it)->GetBestIP(); IPAddress ip = (*it)->GetBestIP();
SocketAddress bindaddress(ip, 0); SocketAddress bindaddress(ip, 0);
bindaddress.SetScopeID((*it)->scope_id()); 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)); int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
if (fd > 0) { if (fd > 0) {
size_t ipsize = bindaddress.ToSockAddrStorage(&storage); size_t ipsize = bindaddress.ToSockAddrStorage(&storage);

6
rtc_base/null_socket_server.cc
View File

@ -34,10 +34,4 @@ rtc::Socket* NullSocketServer::CreateSocket(int /* family */, int /* type */) {
return nullptr; return nullptr;
} }
rtc::AsyncSocket* NullSocketServer::CreateAsyncSocket(int /* family */,
int /* type */) {
RTC_NOTREACHED();
return nullptr;
}
} // namespace rtc } // namespace rtc

2
rtc_base/null_socket_server.h
View File

@ -11,7 +11,6 @@
#ifndef RTC_BASE_NULL_SOCKET_SERVER_H_ #ifndef RTC_BASE_NULL_SOCKET_SERVER_H_
#define 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/event.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
@ -28,7 +27,6 @@ class RTC_EXPORT NullSocketServer : public SocketServer {
void WakeUp() override; void WakeUp() override;
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
private: private:
Event event_; Event event_;

28
rtc_base/openssl_adapter.cc
View File

@ -70,7 +70,7 @@ static BIO_METHOD* BIO_socket_method() {
return methods; 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()); BIO* ret = BIO_new(BIO_socket_method());
if (ret == nullptr) { if (ret == nullptr) {
return nullptr; return nullptr;
@ -95,7 +95,7 @@ static int socket_free(BIO* b) {
static int socket_read(BIO* b, char* out, int outl) { static int socket_read(BIO* b, char* out, int outl) {
if (!out) if (!out)
return -1; 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); BIO_clear_retry_flags(b);
int result = socket->Recv(out, outl, nullptr); int result = socket->Recv(out, outl, nullptr);
if (result > 0) { if (result > 0) {
@ -109,7 +109,7 @@ static int socket_read(BIO* b, char* out, int outl) {
static int socket_write(BIO* b, const char* in, int inl) { static int socket_write(BIO* b, const char* in, int inl) {
if (!in) if (!in)
return -1; 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); BIO_clear_retry_flags(b);
int result = socket->Send(in, inl); int result = socket->Send(in, inl);
if (result > 0) { if (result > 0) {
@ -129,9 +129,9 @@ static long socket_ctrl(BIO* b, int cmd, long num, void* ptr) { // NOLINT
case BIO_CTRL_RESET: case BIO_CTRL_RESET:
return 0; return 0;
case BIO_CTRL_EOF: { case BIO_CTRL_EOF: {
rtc::AsyncSocket* socket = static_cast<rtc::AsyncSocket*>(ptr); rtc::Socket* socket = static_cast<rtc::Socket*>(ptr);
// 1 means socket closed. // 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_WPENDING:
case BIO_CTRL_PENDING: case BIO_CTRL_PENDING:
@ -181,7 +181,7 @@ bool OpenSSLAdapter::CleanupSSL() {
return true; return true;
} }
OpenSSLAdapter::OpenSSLAdapter(AsyncSocket* socket, OpenSSLAdapter::OpenSSLAdapter(Socket* socket,
OpenSSLSessionCache* ssl_session_cache, OpenSSLSessionCache* ssl_session_cache,
SSLCertificateVerifier* ssl_cert_verifier) SSLCertificateVerifier* ssl_cert_verifier)
: SSLAdapter(socket), : SSLAdapter(socket),
@ -250,9 +250,9 @@ void OpenSSLAdapter::SetRole(SSLRole role) {
role_ = role; role_ = role;
} }
AsyncSocket* OpenSSLAdapter::Accept(SocketAddress* paddr) { Socket* OpenSSLAdapter::Accept(SocketAddress* paddr) {
RTC_DCHECK(role_ == SSL_SERVER); RTC_DCHECK(role_ == SSL_SERVER);
AsyncSocket* socket = SSLAdapter::Accept(paddr); Socket* socket = SSLAdapter::Accept(paddr);
if (!socket) { if (!socket) {
return nullptr; return nullptr;
} }
@ -508,7 +508,7 @@ int OpenSSLAdapter::DoSslWrite(const void* pv, size_t cb, int* error) {
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// AsyncSocket Implementation // Socket Implementation
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
int OpenSSLAdapter::Send(const void* pv, size_t cb) { int OpenSSLAdapter::Send(const void* pv, size_t cb) {
@ -677,7 +677,7 @@ void OpenSSLAdapter::OnMessage(Message* msg) {
} }
} }
void OpenSSLAdapter::OnConnectEvent(AsyncSocket* socket) { void OpenSSLAdapter::OnConnectEvent(Socket* socket) {
RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnConnectEvent"; RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnConnectEvent";
if (state_ != SSL_WAIT) { if (state_ != SSL_WAIT) {
RTC_DCHECK(state_ == SSL_NONE); RTC_DCHECK(state_ == SSL_NONE);
@ -691,7 +691,7 @@ void OpenSSLAdapter::OnConnectEvent(AsyncSocket* socket) {
} }
} }
void OpenSSLAdapter::OnReadEvent(AsyncSocket* socket) { void OpenSSLAdapter::OnReadEvent(Socket* socket) {
if (state_ == SSL_NONE) { if (state_ == SSL_NONE) {
AsyncSocketAdapter::OnReadEvent(socket); AsyncSocketAdapter::OnReadEvent(socket);
return; return;
@ -717,7 +717,7 @@ void OpenSSLAdapter::OnReadEvent(AsyncSocket* socket) {
AsyncSocketAdapter::OnReadEvent(socket); AsyncSocketAdapter::OnReadEvent(socket);
} }
void OpenSSLAdapter::OnWriteEvent(AsyncSocket* socket) { void OpenSSLAdapter::OnWriteEvent(Socket* socket) {
if (state_ == SSL_NONE) { if (state_ == SSL_NONE) {
AsyncSocketAdapter::OnWriteEvent(socket); AsyncSocketAdapter::OnWriteEvent(socket);
return; return;
@ -754,7 +754,7 @@ void OpenSSLAdapter::OnWriteEvent(AsyncSocket* socket) {
AsyncSocketAdapter::OnWriteEvent(socket); AsyncSocketAdapter::OnWriteEvent(socket);
} }
void OpenSSLAdapter::OnCloseEvent(AsyncSocket* socket, int err) { void OpenSSLAdapter::OnCloseEvent(Socket* socket, int err) {
RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnCloseEvent(" << err << ")"; RTC_LOG(LS_INFO) << "OpenSSLAdapter::OnCloseEvent(" << err << ")";
AsyncSocketAdapter::OnCloseEvent(socket, err); AsyncSocketAdapter::OnCloseEvent(socket, err);
} }
@ -1032,7 +1032,7 @@ void OpenSSLAdapterFactory::SetCertVerifier(
ssl_cert_verifier_ = ssl_cert_verifier; ssl_cert_verifier_ = ssl_cert_verifier;
} }
OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(AsyncSocket* socket) { OpenSSLAdapter* OpenSSLAdapterFactory::CreateAdapter(Socket* socket) {
if (ssl_session_cache_ == nullptr) { if (ssl_session_cache_ == nullptr) {
SSL_CTX* ssl_ctx = OpenSSLAdapter::CreateContext(ssl_mode_, true); SSL_CTX* ssl_ctx = OpenSSLAdapter::CreateContext(ssl_mode_, true);
if (ssl_ctx == nullptr) { if (ssl_ctx == nullptr) {

15
rtc_base/openssl_adapter.h
View File

@ -19,7 +19,6 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "rtc_base/async_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/message_handler.h" #include "rtc_base/message_handler.h"
#ifdef OPENSSL_IS_BORINGSSL #ifdef OPENSSL_IS_BORINGSSL
@ -49,7 +48,7 @@ class OpenSSLAdapter final : public SSLAdapter,
// SSLCertificateVerifier which can override any existing trusted roots to // SSLCertificateVerifier which can override any existing trusted roots to
// validate a peer certificate. The cache and verifier are effectively // validate a peer certificate. The cache and verifier are effectively
// immutable after the the SSL connection starts. // immutable after the the SSL connection starts.
explicit OpenSSLAdapter(AsyncSocket* socket, explicit OpenSSLAdapter(Socket* socket,
OpenSSLSessionCache* ssl_session_cache = nullptr, OpenSSLSessionCache* ssl_session_cache = nullptr,
SSLCertificateVerifier* ssl_cert_verifier = nullptr); SSLCertificateVerifier* ssl_cert_verifier = nullptr);
~OpenSSLAdapter() override; ~OpenSSLAdapter() override;
@ -61,7 +60,7 @@ class OpenSSLAdapter final : public SSLAdapter,
void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) override; void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) override;
void SetIdentity(std::unique_ptr<SSLIdentity> identity) override; void SetIdentity(std::unique_ptr<SSLIdentity> identity) override;
void SetRole(SSLRole role) override; void SetRole(SSLRole role) override;
AsyncSocket* Accept(SocketAddress* paddr) override; Socket* Accept(SocketAddress* paddr) override;
int StartSSL(const char* hostname) override; int StartSSL(const char* hostname) override;
int Send(const void* pv, size_t cb) override; int Send(const void* pv, size_t cb) override;
int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override; int SendTo(const void* pv, size_t cb, const SocketAddress& addr) override;
@ -83,10 +82,10 @@ class OpenSSLAdapter final : public SSLAdapter,
static SSL_CTX* CreateContext(SSLMode mode, bool enable_cache); static SSL_CTX* CreateContext(SSLMode mode, bool enable_cache);
protected: protected:
void OnConnectEvent(AsyncSocket* socket) override; void OnConnectEvent(Socket* socket) override;
void OnReadEvent(AsyncSocket* socket) override; void OnReadEvent(Socket* socket) override;
void OnWriteEvent(AsyncSocket* socket) override; void OnWriteEvent(Socket* socket) override;
void OnCloseEvent(AsyncSocket* socket, int err) override; void OnCloseEvent(Socket* socket, int err) override;
private: private:
class EarlyExitCatcher { class EarlyExitCatcher {
@ -197,7 +196,7 @@ class OpenSSLAdapterFactory : public SSLAdapterFactory {
// Constructs a new socket using the shared OpenSSLSessionCache. This means // Constructs a new socket using the shared OpenSSLSessionCache. This means
// existing SSLSessions already in the cache will be reused instead of // existing SSLSessions already in the cache will be reused instead of
// re-created for improved performance. // re-created for improved performance.
OpenSSLAdapter* CreateAdapter(AsyncSocket* socket) override; OpenSSLAdapter* CreateAdapter(Socket* socket) override;
private: private:
// Holds the SSLMode (DTLS,TLS) that will be used to set the session cache. // Holds the SSLMode (DTLS,TLS) that will be used to set the session cache.

12
rtc_base/openssl_adapter_unittest.cc
View File

@ -15,17 +15,17 @@
#include <vector> #include <vector>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"
#include "rtc_base/socket.h"
#include "test/gmock.h" #include "test/gmock.h"
namespace rtc { namespace rtc {
namespace { namespace {
class MockAsyncSocket : public AsyncSocket { class MockAsyncSocket : public Socket {
public: public:
virtual ~MockAsyncSocket() = default; virtual ~MockAsyncSocket() = default;
MOCK_METHOD(AsyncSocket*, Accept, (SocketAddress*), (override)); MOCK_METHOD(Socket*, Accept, (SocketAddress*), (override));
MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override)); MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override)); MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD(int, Bind, (const SocketAddress&), (override)); MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
@ -84,7 +84,7 @@ TEST(OpenSSLAdapterTest, TestTransformAlpnProtocols) {
// Verifies that SSLStart works when OpenSSLAdapter is started in standalone // Verifies that SSLStart works when OpenSSLAdapter is started in standalone
// mode. // mode.
TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) { TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
AsyncSocket* async_socket = new MockAsyncSocket(); Socket* async_socket = new MockAsyncSocket();
OpenSSLAdapter adapter(async_socket); OpenSSLAdapter adapter(async_socket);
EXPECT_EQ(adapter.StartSSL("webrtc.org"), 0); EXPECT_EQ(adapter.StartSSL("webrtc.org"), 0);
} }
@ -92,7 +92,7 @@ TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
// Verifies that the adapter factory can create new adapters. // Verifies that the adapter factory can create new adapters.
TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) { TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) {
OpenSSLAdapterFactory adapter_factory; OpenSSLAdapterFactory adapter_factory;
AsyncSocket* async_socket = new MockAsyncSocket(); Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>( auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket)); adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr); EXPECT_NE(simple_adapter, nullptr);
@ -107,7 +107,7 @@ TEST(OpenSSLAdapterFactoryTest, CreateWorksWithCustomVerifier) {
OpenSSLAdapterFactory adapter_factory; OpenSSLAdapterFactory adapter_factory;
adapter_factory.SetCertVerifier(cert_verifier.get()); adapter_factory.SetCertVerifier(cert_verifier.get());
AsyncSocket* async_socket = new MockAsyncSocket(); Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>( auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket)); adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr); EXPECT_NE(simple_adapter, nullptr);

16
rtc_base/physical_socket_server.cc
View File

@ -283,7 +283,7 @@ void PhysicalSocket::SetError(int error) {
error_ = error; error_ = error;
} }
AsyncSocket::ConnState PhysicalSocket::GetState() const { Socket::ConnState PhysicalSocket::GetState() const {
return state_; return state_;
} }
@ -460,7 +460,7 @@ int PhysicalSocket::Listen(int backlog) {
return err; 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 // Always re-subscribe DE_ACCEPT to make sure new incoming connections will
// trigger an event even if DoAccept returns an error here. // trigger an event even if DoAccept returns an error here.
EnableEvents(DE_ACCEPT); EnableEvents(DE_ACCEPT);
@ -1083,16 +1083,6 @@ void PhysicalSocketServer::WakeUp() {
} }
Socket* PhysicalSocketServer::CreateSocket(int family, int type) { 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); SocketDispatcher* dispatcher = new SocketDispatcher(this);
if (dispatcher->Create(family, type)) { if (dispatcher->Create(family, type)) {
return dispatcher; return dispatcher;
@ -1102,7 +1092,7 @@ AsyncSocket* PhysicalSocketServer::CreateAsyncSocket(int family, int type) {
} }
} }
AsyncSocket* PhysicalSocketServer::WrapSocket(SOCKET s) { Socket* PhysicalSocketServer::WrapSocket(SOCKET s) {
SocketDispatcher* dispatcher = new SocketDispatcher(s, this); SocketDispatcher* dispatcher = new SocketDispatcher(s, this);
if (dispatcher->Initialize()) { if (dispatcher->Initialize()) {
return dispatcher; return dispatcher;

7
rtc_base/physical_socket_server.h
View File

@ -69,10 +69,9 @@ class RTC_EXPORT PhysicalSocketServer : public SocketServer {
// SocketFactory: // SocketFactory:
Socket* CreateSocket(int family, int type) override; 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). // Internal Factory for Accept (virtual so it can be overwritten in tests).
virtual AsyncSocket* WrapSocket(SOCKET s); virtual Socket* WrapSocket(SOCKET s);
// SocketServer: // SocketServer:
bool Wait(int cms, bool process_io) override; bool Wait(int cms, bool process_io) override;
@ -130,7 +129,7 @@ class RTC_EXPORT PhysicalSocketServer : public SocketServer {
bool waiting_ = false; bool waiting_ = false;
}; };
class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> { class PhysicalSocket : public Socket, public sigslot::has_slots<> {
public: public:
PhysicalSocket(PhysicalSocketServer* ss, SOCKET s = INVALID_SOCKET); PhysicalSocket(PhysicalSocketServer* ss, SOCKET s = INVALID_SOCKET);
~PhysicalSocket() override; ~PhysicalSocket() override;
@ -164,7 +163,7 @@ class PhysicalSocket : public AsyncSocket, public sigslot::has_slots<> {
int64_t* timestamp) override; int64_t* timestamp) override;
int Listen(int backlog) override; int Listen(int backlog) override;
AsyncSocket* Accept(SocketAddress* out_addr) override; Socket* Accept(SocketAddress* out_addr) override;
int Close() override; int Close() override;

41
rtc_base/physical_socket_server_unittest.cc
View File

@ -64,7 +64,7 @@ class FakePhysicalSocketServer : public PhysicalSocketServer {
public: public:
explicit FakePhysicalSocketServer(PhysicalSocketTest* test) : test_(test) {} 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); SocketDispatcher* dispatcher = new FakeSocketDispatcher(this);
if (!dispatcher->Create(family, type)) { if (!dispatcher->Create(family, type)) {
delete dispatcher; delete dispatcher;
@ -73,7 +73,7 @@ class FakePhysicalSocketServer : public PhysicalSocketServer {
return dispatcher; return dispatcher;
} }
AsyncSocket* WrapSocket(SOCKET s) override { Socket* WrapSocket(SOCKET s) override {
SocketDispatcher* dispatcher = new FakeSocketDispatcher(s, this); SocketDispatcher* dispatcher = new FakeSocketDispatcher(s, this);
if (!dispatcher->Initialize()) { if (!dispatcher->Initialize()) {
delete dispatcher; delete dispatcher;
@ -106,7 +106,7 @@ class FakeNetworkBinder : public NetworkBinderInterface {
class PhysicalSocketTest : public SocketTest { class PhysicalSocketTest : public SocketTest {
public: 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; } void SetFailAccept(bool fail) { fail_accept_ = fail; }
bool FailAccept() const { return fail_accept_; } bool FailAccept() const { return fail_accept_; }
@ -199,25 +199,25 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create two clients. // Create two clients.
std::unique_ptr<AsyncSocket> client1( std::unique_ptr<Socket> client1(
server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); server_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client1.get()); sink.Monitor(client1.get());
EXPECT_EQ(AsyncSocket::CS_CLOSED, client1->GetState()); EXPECT_EQ(Socket::CS_CLOSED, client1->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr())); EXPECT_TRUE(IsUnspecOrEmptyIP(client1->GetLocalAddress().ipaddr()));
std::unique_ptr<AsyncSocket> client2( std::unique_ptr<Socket> client2(
server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); server_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client2.get()); sink.Monitor(client2.get());
EXPECT_EQ(AsyncSocket::CS_CLOSED, client2->GetState()); EXPECT_EQ(Socket::CS_CLOSED, client2->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr())); EXPECT_TRUE(IsUnspecOrEmptyIP(client2->GetLocalAddress().ipaddr()));
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
server_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); server_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); 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. // Ensure no pending server connections, since we haven't done anything yet.
EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ)); EXPECT_FALSE(sink.Check(server.get(), webrtc::testing::SSE_READ));
@ -230,7 +230,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
EXPECT_NE(server->GetLocalAddress(), client1->GetLocalAddress()); EXPECT_NE(server->GetLocalAddress(), client1->GetLocalAddress());
// Client is connecting, outcome not yet determined. // 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_OPEN));
EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE)); EXPECT_FALSE(sink.Check(client1.get(), webrtc::testing::SSE_CLOSE));
@ -239,7 +239,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
kTimeout); kTimeout);
// Simulate "::accept" returning an error. // Simulate "::accept" returning an error.
SetFailAccept(true); SetFailAccept(true);
std::unique_ptr<AsyncSocket> accepted(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted(server->Accept(&accept_addr));
EXPECT_FALSE(accepted); EXPECT_FALSE(accepted);
ASSERT_TRUE(accept_addr.IsNil()); ASSERT_TRUE(accept_addr.IsNil());
@ -254,7 +254,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
EXPECT_NE(server->GetLocalAddress(), client2->GetLocalAddress()); EXPECT_NE(server->GetLocalAddress(), client2->GetLocalAddress());
// Client is connecting, outcome not yet determined. // 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_OPEN));
EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE)); EXPECT_FALSE(sink.Check(client2.get(), webrtc::testing::SSE_CLOSE));
@ -262,7 +262,7 @@ void PhysicalSocketTest::ConnectInternalAcceptError(const IPAddress& loopback) {
EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)), EXPECT_TRUE_WAIT((sink.Check(server.get(), webrtc::testing::SSE_READ)),
kTimeout); kTimeout);
SetFailAccept(false); SetFailAccept(false);
std::unique_ptr<AsyncSocket> accepted2(server->Accept(&accept_addr)); std::unique_ptr<Socket> accepted2(server->Accept(&accept_addr));
ASSERT_TRUE(accepted2); ASSERT_TRUE(accepted2);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr); EXPECT_EQ(accepted2->GetRemoteAddress(), accept_addr);
@ -478,8 +478,7 @@ TEST_F(PhysicalSocketTest,
MAYBE_SKIP_IPV4; MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder; FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder); server_->set_network_binder(&fake_network_binder);
std::unique_ptr<AsyncSocket> socket( std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE); fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0))); EXPECT_EQ(-1, socket->Bind(SocketAddress("192.168.0.1", 0)));
server_->set_network_binder(nullptr); server_->set_network_binder(nullptr);
@ -490,8 +489,7 @@ TEST_F(PhysicalSocketTest, NetworkBinderIsNotUsedForAnyIp) {
MAYBE_SKIP_IPV4; MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder; FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder); server_->set_network_binder(&fake_network_binder);
std::unique_ptr<AsyncSocket> socket( std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0))); EXPECT_EQ(0, socket->Bind(SocketAddress("0.0.0.0", 0)));
EXPECT_EQ(0, fake_network_binder.num_binds()); EXPECT_EQ(0, fake_network_binder.num_binds());
server_->set_network_binder(nullptr); server_->set_network_binder(nullptr);
@ -504,8 +502,7 @@ TEST_F(PhysicalSocketTest,
MAYBE_SKIP_IPV4; MAYBE_SKIP_IPV4;
FakeNetworkBinder fake_network_binder; FakeNetworkBinder fake_network_binder;
server_->set_network_binder(&fake_network_binder); server_->set_network_binder(&fake_network_binder);
std::unique_ptr<AsyncSocket> socket( std::unique_ptr<Socket> socket(server_->CreateSocket(AF_INET, SOCK_DGRAM));
server_->CreateAsyncSocket(AF_INET, SOCK_DGRAM));
fake_network_binder.set_result(NetworkBindingResult::FAILURE); fake_network_binder.set_result(NetworkBindingResult::FAILURE);
EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0))); EXPECT_EQ(0, socket->Bind(SocketAddress(kIPv4Loopback, 0)));
server_->set_network_binder(nullptr); server_->set_network_binder(nullptr);

32
rtc_base/proxy_server.cc
View File

@ -27,7 +27,7 @@ ProxyServer::ProxyServer(SocketFactory* int_factory,
: ext_factory_(ext_factory), : ext_factory_(ext_factory),
ext_ip_(ext_ip.ipaddr(), 0), // strip off port ext_ip_(ext_ip.ipaddr(), 0), // strip off port
server_socket_( 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(server_socket_.get() != nullptr);
RTC_DCHECK(int_addr.family() == AF_INET || int_addr.family() == AF_INET6); RTC_DCHECK(int_addr.family() == AF_INET || int_addr.family() == AF_INET6);
server_socket_->Bind(int_addr); server_socket_->Bind(int_addr);
@ -41,13 +41,13 @@ SocketAddress ProxyServer::GetServerAddress() {
return server_socket_->GetLocalAddress(); return server_socket_->GetLocalAddress();
} }
void ProxyServer::OnAcceptEvent(AsyncSocket* socket) { void ProxyServer::OnAcceptEvent(Socket* socket) {
RTC_DCHECK(socket); RTC_DCHECK(socket);
RTC_DCHECK_EQ(socket, server_socket_.get()); 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); AsyncProxyServerSocket* wrapped_socket = WrapSocket(int_socket);
AsyncSocket* ext_socket = Socket* ext_socket =
ext_factory_->CreateAsyncSocket(ext_ip_.family(), SOCK_STREAM); ext_factory_->CreateSocket(ext_ip_.family(), SOCK_STREAM);
if (ext_socket) { if (ext_socket) {
ext_socket->Bind(ext_ip_); ext_socket->Bind(ext_ip_);
bindings_.emplace_back( bindings_.emplace_back(
@ -60,7 +60,7 @@ void ProxyServer::OnAcceptEvent(AsyncSocket* socket) {
// ProxyBinding // ProxyBinding
ProxyBinding::ProxyBinding(AsyncProxyServerSocket* int_socket, ProxyBinding::ProxyBinding(AsyncProxyServerSocket* int_socket,
AsyncSocket* ext_socket) Socket* ext_socket)
: int_socket_(int_socket), : int_socket_(int_socket),
ext_socket_(ext_socket), ext_socket_(ext_socket),
connected_(false), connected_(false),
@ -88,42 +88,42 @@ void ProxyBinding::OnConnectRequest(AsyncProxyServerSocket* socket,
// TODO: handle errors here // TODO: handle errors here
} }
void ProxyBinding::OnInternalRead(AsyncSocket* socket) { void ProxyBinding::OnInternalRead(Socket* socket) {
Read(int_socket_.get(), &out_buffer_); Read(int_socket_.get(), &out_buffer_);
Write(ext_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_); Write(int_socket_.get(), &in_buffer_);
} }
void ProxyBinding::OnInternalClose(AsyncSocket* socket, int err) { void ProxyBinding::OnInternalClose(Socket* socket, int err) {
Destroy(); Destroy();
} }
void ProxyBinding::OnExternalConnect(AsyncSocket* socket) { void ProxyBinding::OnExternalConnect(Socket* socket) {
RTC_DCHECK(socket != nullptr); RTC_DCHECK(socket != nullptr);
connected_ = true; connected_ = true;
int_socket_->SendConnectResult(0, socket->GetRemoteAddress()); int_socket_->SendConnectResult(0, socket->GetRemoteAddress());
} }
void ProxyBinding::OnExternalRead(AsyncSocket* socket) { void ProxyBinding::OnExternalRead(Socket* socket) {
Read(ext_socket_.get(), &in_buffer_); Read(ext_socket_.get(), &in_buffer_);
Write(int_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_); Write(ext_socket_.get(), &out_buffer_);
} }
void ProxyBinding::OnExternalClose(AsyncSocket* socket, int err) { void ProxyBinding::OnExternalClose(Socket* socket, int err) {
if (!connected_) { if (!connected_) {
int_socket_->SendConnectResult(err, SocketAddress()); int_socket_->SendConnectResult(err, SocketAddress());
} }
Destroy(); Destroy();
} }
void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) { void ProxyBinding::Read(Socket* socket, FifoBuffer* buffer) {
// Only read if the buffer is empty. // Only read if the buffer is empty.
RTC_DCHECK(socket != nullptr); RTC_DCHECK(socket != nullptr);
size_t size; size_t size;
@ -135,7 +135,7 @@ void ProxyBinding::Read(AsyncSocket* socket, FifoBuffer* buffer) {
} }
} }
void ProxyBinding::Write(AsyncSocket* socket, FifoBuffer* buffer) { void ProxyBinding::Write(Socket* socket, FifoBuffer* buffer) {
RTC_DCHECK(socket != nullptr); RTC_DCHECK(socket != nullptr);
size_t size; size_t size;
int written; int written;
@ -148,7 +148,7 @@ void ProxyBinding::Destroy() {
SignalDestroyed(this); SignalDestroyed(this);
} }
AsyncProxyServerSocket* SocksProxyServer::WrapSocket(AsyncSocket* socket) { AsyncProxyServerSocket* SocksProxyServer::WrapSocket(Socket* socket) {
return new AsyncSocksProxyServerSocket(socket); return new AsyncSocksProxyServerSocket(socket);
} }

32
rtc_base/proxy_server.h
View File

@ -15,10 +15,10 @@
#include <vector> #include <vector>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/memory/fifo_buffer.h" #include "rtc_base/memory/fifo_buffer.h"
#include "rtc_base/server_socket_adapters.h" #include "rtc_base/server_socket_adapters.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
namespace rtc { namespace rtc {
@ -34,28 +34,28 @@ class SocketFactory;
class ProxyBinding : public sigslot::has_slots<> { class ProxyBinding : public sigslot::has_slots<> {
public: public:
ProxyBinding(AsyncProxyServerSocket* in_socket, AsyncSocket* out_socket); ProxyBinding(AsyncProxyServerSocket* in_socket, Socket* out_socket);
~ProxyBinding() override; ~ProxyBinding() override;
sigslot::signal1<ProxyBinding*> SignalDestroyed; sigslot::signal1<ProxyBinding*> SignalDestroyed;
private: private:
void OnConnectRequest(AsyncProxyServerSocket* socket, void OnConnectRequest(AsyncProxyServerSocket* socket,
const SocketAddress& addr); const SocketAddress& addr);
void OnInternalRead(AsyncSocket* socket); void OnInternalRead(Socket* socket);
void OnInternalWrite(AsyncSocket* socket); void OnInternalWrite(Socket* socket);
void OnInternalClose(AsyncSocket* socket, int err); void OnInternalClose(Socket* socket, int err);
void OnExternalConnect(AsyncSocket* socket); void OnExternalConnect(Socket* socket);
void OnExternalRead(AsyncSocket* socket); void OnExternalRead(Socket* socket);
void OnExternalWrite(AsyncSocket* socket); void OnExternalWrite(Socket* socket);
void OnExternalClose(AsyncSocket* socket, int err); void OnExternalClose(Socket* socket, int err);
static void Read(AsyncSocket* socket, FifoBuffer* buffer); static void Read(Socket* socket, FifoBuffer* buffer);
static void Write(AsyncSocket* socket, FifoBuffer* buffer); static void Write(Socket* socket, FifoBuffer* buffer);
void Destroy(); void Destroy();
static const int kBufferSize = 4096; static const int kBufferSize = 4096;
std::unique_ptr<AsyncProxyServerSocket> int_socket_; std::unique_ptr<AsyncProxyServerSocket> int_socket_;
std::unique_ptr<AsyncSocket> ext_socket_; std::unique_ptr<Socket> ext_socket_;
bool connected_; bool connected_;
FifoBuffer out_buffer_; FifoBuffer out_buffer_;
FifoBuffer in_buffer_; FifoBuffer in_buffer_;
@ -74,13 +74,13 @@ class ProxyServer : public sigslot::has_slots<> {
SocketAddress GetServerAddress(); SocketAddress GetServerAddress();
protected: protected:
void OnAcceptEvent(AsyncSocket* socket); void OnAcceptEvent(Socket* socket);
virtual AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) = 0; virtual AsyncProxyServerSocket* WrapSocket(Socket* socket) = 0;
private: private:
SocketFactory* ext_factory_; SocketFactory* ext_factory_;
SocketAddress ext_ip_; SocketAddress ext_ip_;
std::unique_ptr<AsyncSocket> server_socket_; std::unique_ptr<Socket> server_socket_;
std::vector<std::unique_ptr<ProxyBinding>> bindings_; std::vector<std::unique_ptr<ProxyBinding>> bindings_;
RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer); RTC_DISALLOW_COPY_AND_ASSIGN(ProxyServer);
}; };
@ -95,7 +95,7 @@ class SocksProxyServer : public ProxyServer {
: ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {} : ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected: protected:
AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override; AsyncProxyServerSocket* WrapSocket(Socket* socket) override;
RTC_DISALLOW_COPY_AND_ASSIGN(SocksProxyServer); RTC_DISALLOW_COPY_AND_ASSIGN(SocksProxyServer);
}; };

4
rtc_base/proxy_unittest.cc
View File

@ -43,8 +43,8 @@ class ProxyTest : public ::testing::Test {
// Tests whether we can use a SOCKS5 proxy to connect to a server. // Tests whether we can use a SOCKS5 proxy to connect to a server.
TEST_F(ProxyTest, TestSocks5Connect) { TEST_F(ProxyTest, TestSocks5Connect) {
rtc::AsyncSocket* socket = rtc::Socket* socket =
ss()->CreateAsyncSocket(kSocksProxyIntAddr.family(), SOCK_STREAM); ss()->CreateSocket(kSocksProxyIntAddr.family(), SOCK_STREAM);
rtc::AsyncSocksProxySocket* proxy_socket = new rtc::AsyncSocksProxySocket( rtc::AsyncSocksProxySocket* proxy_socket = new rtc::AsyncSocksProxySocket(
socket, kSocksProxyIntAddr, "", rtc::CryptString()); socket, kSocksProxyIntAddr, "", rtc::CryptString());
// TODO: IPv6-ize these tests when proxy supports IPv6. // TODO: IPv6-ize these tests when proxy supports IPv6.

6
rtc_base/server_socket_adapters.cc
View File

@ -16,13 +16,13 @@
namespace rtc { namespace rtc {
AsyncProxyServerSocket::AsyncProxyServerSocket(AsyncSocket* socket, AsyncProxyServerSocket::AsyncProxyServerSocket(Socket* socket,
size_t buffer_size) size_t buffer_size)
: BufferedReadAdapter(socket, buffer_size) {} : BufferedReadAdapter(socket, buffer_size) {}
AsyncProxyServerSocket::~AsyncProxyServerSocket() = default; AsyncProxyServerSocket::~AsyncProxyServerSocket() = default;
AsyncSSLServerSocket::AsyncSSLServerSocket(AsyncSocket* socket) AsyncSSLServerSocket::AsyncSSLServerSocket(Socket* socket)
: BufferedReadAdapter(socket, 1024) { : BufferedReadAdapter(socket, 1024) {
BufferInput(true); BufferInput(true);
} }
@ -55,7 +55,7 @@ void AsyncSSLServerSocket::ProcessInput(char* data, size_t* len) {
BufferInput(false); BufferInput(false);
} }
AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(AsyncSocket* socket) AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(Socket* socket)
: AsyncProxyServerSocket(socket, kBufferSize), state_(SS_HELLO) { : AsyncProxyServerSocket(socket, kBufferSize), state_(SS_HELLO) {
BufferInput(true); BufferInput(true);
} }

6
rtc_base/server_socket_adapters.h
View File

@ -18,7 +18,7 @@ namespace rtc {
// Interface for implementing proxy server sockets. // Interface for implementing proxy server sockets.
class AsyncProxyServerSocket : public BufferedReadAdapter { class AsyncProxyServerSocket : public BufferedReadAdapter {
public: public:
AsyncProxyServerSocket(AsyncSocket* socket, size_t buffer_size); AsyncProxyServerSocket(Socket* socket, size_t buffer_size);
~AsyncProxyServerSocket() override; ~AsyncProxyServerSocket() override;
sigslot::signal2<AsyncProxyServerSocket*, const SocketAddress&> sigslot::signal2<AsyncProxyServerSocket*, const SocketAddress&>
SignalConnectRequest; SignalConnectRequest;
@ -29,7 +29,7 @@ class AsyncProxyServerSocket : public BufferedReadAdapter {
// fake SSL handshake. Used when implementing a relay server that does "ssltcp". // fake SSL handshake. Used when implementing a relay server that does "ssltcp".
class AsyncSSLServerSocket : public BufferedReadAdapter { class AsyncSSLServerSocket : public BufferedReadAdapter {
public: public:
explicit AsyncSSLServerSocket(AsyncSocket* socket); explicit AsyncSSLServerSocket(Socket* socket);
protected: protected:
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
@ -39,7 +39,7 @@ class AsyncSSLServerSocket : public BufferedReadAdapter {
// Implements a proxy server socket for the SOCKS protocol. // Implements a proxy server socket for the SOCKS protocol.
class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket { class AsyncSocksProxyServerSocket : public AsyncProxyServerSocket {
public: public:
explicit AsyncSocksProxyServerSocket(AsyncSocket* socket); explicit AsyncSocksProxyServerSocket(Socket* socket);
private: private:
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;

17
rtc_base/socket.h
View File

@ -25,8 +25,10 @@
#include "rtc_base/win32.h" #include "rtc_base/win32.h"
#endif #endif
#include "absl/base/attributes.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
// Rather than converting errors into a private namespace, // Rather than converting errors into a private namespace,
// Reuse the POSIX socket api errors. Note this depends on // Reuse the POSIX socket api errors. Note this depends on
@ -124,6 +126,17 @@ class Socket {
virtual int GetOption(Option opt, int* value) = 0; virtual int GetOption(Option opt, int* value) = 0;
virtual int SetOption(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: protected:
Socket() {} Socket() {}
@ -131,6 +144,10 @@ class Socket {
RTC_DISALLOW_COPY_AND_ASSIGN(Socket); RTC_DISALLOW_COPY_AND_ASSIGN(Socket);
}; };
// TODO(bugs.webrtc.org/13065): Old alias, delete ASAP, when downstream code is
// updated.
using AsyncSocket ABSL_DEPRECATED("bugs.webrtc.org/13065") = Socket;
} // namespace rtc } // namespace rtc
#endif // RTC_BASE_SOCKET_H_ #endif // RTC_BASE_SOCKET_H_

18
rtc_base/socket_adapters.cc
View File

@ -26,7 +26,7 @@
namespace rtc { namespace rtc {
BufferedReadAdapter::BufferedReadAdapter(AsyncSocket* socket, size_t size) BufferedReadAdapter::BufferedReadAdapter(Socket* socket, size_t size)
: AsyncSocketAdapter(socket), : AsyncSocketAdapter(socket),
buffer_size_(size), buffer_size_(size),
data_len_(0), data_len_(0),
@ -87,7 +87,7 @@ void BufferedReadAdapter::BufferInput(bool on) {
buffering_ = on; buffering_ = on;
} }
void BufferedReadAdapter::OnReadEvent(AsyncSocket* socket) { void BufferedReadAdapter::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket == GetSocket()); RTC_DCHECK(socket == GetSocket());
if (!buffering_) { if (!buffering_) {
@ -168,7 +168,7 @@ ArrayView<const uint8_t> AsyncSSLSocket::SslServerHello() {
return {kSslServerHello, sizeof(kSslServerHello)}; return {kSslServerHello, sizeof(kSslServerHello)};
} }
AsyncSSLSocket::AsyncSSLSocket(AsyncSocket* socket) AsyncSSLSocket::AsyncSSLSocket(Socket* socket)
: BufferedReadAdapter(socket, 1024) {} : BufferedReadAdapter(socket, 1024) {}
int AsyncSSLSocket::Connect(const SocketAddress& addr) { int AsyncSSLSocket::Connect(const SocketAddress& addr) {
@ -178,7 +178,7 @@ int AsyncSSLSocket::Connect(const SocketAddress& addr) {
return BufferedReadAdapter::Connect(addr); return BufferedReadAdapter::Connect(addr);
} }
void AsyncSSLSocket::OnConnectEvent(AsyncSocket* socket) { void AsyncSSLSocket::OnConnectEvent(Socket* socket) {
RTC_DCHECK(socket == GetSocket()); RTC_DCHECK(socket == GetSocket());
// TODO: we could buffer output too... // TODO: we could buffer output too...
const int res = DirectSend(kSslClientHello, sizeof(kSslClientHello)); const int res = DirectSend(kSslClientHello, sizeof(kSslClientHello));
@ -211,7 +211,7 @@ void AsyncSSLSocket::ProcessInput(char* data, size_t* len) {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
AsyncHttpsProxySocket::AsyncHttpsProxySocket(AsyncSocket* socket, AsyncHttpsProxySocket::AsyncHttpsProxySocket(Socket* socket,
const std::string& user_agent, const std::string& user_agent,
const SocketAddress& proxy, const SocketAddress& proxy,
const std::string& username, const std::string& username,
@ -266,7 +266,7 @@ Socket::ConnState AsyncHttpsProxySocket::GetState() const {
} }
} }
void AsyncHttpsProxySocket::OnConnectEvent(AsyncSocket* socket) { void AsyncHttpsProxySocket::OnConnectEvent(Socket* socket) {
RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnConnectEvent"; RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnConnectEvent";
if (!ShouldIssueConnect()) { if (!ShouldIssueConnect()) {
state_ = PS_TUNNEL; state_ = PS_TUNNEL;
@ -276,7 +276,7 @@ void AsyncHttpsProxySocket::OnConnectEvent(AsyncSocket* socket) {
SendRequest(); SendRequest();
} }
void AsyncHttpsProxySocket::OnCloseEvent(AsyncSocket* socket, int err) { void AsyncHttpsProxySocket::OnCloseEvent(Socket* socket, int err) {
RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnCloseEvent(" << err << ")"; RTC_LOG(LS_VERBOSE) << "AsyncHttpsProxySocket::OnCloseEvent(" << err << ")";
if ((state_ == PS_WAIT_CLOSE) && (err == 0)) { if ((state_ == PS_WAIT_CLOSE) && (err == 0)) {
state_ = PS_ERROR; state_ = PS_ERROR;
@ -463,7 +463,7 @@ void AsyncHttpsProxySocket::Error(int error) {
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
AsyncSocksProxySocket::AsyncSocksProxySocket(AsyncSocket* socket, AsyncSocksProxySocket::AsyncSocksProxySocket(Socket* socket,
const SocketAddress& proxy, const SocketAddress& proxy,
const std::string& username, const std::string& username,
const CryptString& password) const CryptString& password)
@ -505,7 +505,7 @@ Socket::ConnState AsyncSocksProxySocket::GetState() const {
} }
} }
void AsyncSocksProxySocket::OnConnectEvent(AsyncSocket* socket) { void AsyncSocksProxySocket::OnConnectEvent(Socket* socket) {
SendHello(); SendHello();
} }

18
rtc_base/socket_adapters.h
View File

@ -31,7 +31,7 @@ class ByteBufferWriter;
// protocol before commencing normal socket behavior. // protocol before commencing normal socket behavior.
class BufferedReadAdapter : public AsyncSocketAdapter { class BufferedReadAdapter : public AsyncSocketAdapter {
public: public:
BufferedReadAdapter(AsyncSocket* socket, size_t buffer_size); BufferedReadAdapter(Socket* socket, size_t buffer_size);
~BufferedReadAdapter() override; ~BufferedReadAdapter() override;
int Send(const void* pv, size_t cb) override; int Send(const void* pv, size_t cb) override;
@ -45,7 +45,7 @@ class BufferedReadAdapter : public AsyncSocketAdapter {
void BufferInput(bool on = true); void BufferInput(bool on = true);
virtual void ProcessInput(char* data, size_t* len) = 0; virtual void ProcessInput(char* data, size_t* len) = 0;
void OnReadEvent(AsyncSocket* socket) override; void OnReadEvent(Socket* socket) override;
private: private:
char* buffer_; char* buffer_;
@ -63,12 +63,12 @@ class AsyncSSLSocket : public BufferedReadAdapter {
static ArrayView<const uint8_t> SslClientHello(); static ArrayView<const uint8_t> SslClientHello();
static ArrayView<const uint8_t> SslServerHello(); static ArrayView<const uint8_t> SslServerHello();
explicit AsyncSSLSocket(AsyncSocket* socket); explicit AsyncSSLSocket(Socket* socket);
int Connect(const SocketAddress& addr) override; int Connect(const SocketAddress& addr) override;
protected: protected:
void OnConnectEvent(AsyncSocket* socket) override; void OnConnectEvent(Socket* socket) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket); RTC_DISALLOW_COPY_AND_ASSIGN(AsyncSSLSocket);
}; };
@ -78,7 +78,7 @@ class AsyncSSLSocket : public BufferedReadAdapter {
// Implements a socket adapter that speaks the HTTP/S proxy protocol. // Implements a socket adapter that speaks the HTTP/S proxy protocol.
class AsyncHttpsProxySocket : public BufferedReadAdapter { class AsyncHttpsProxySocket : public BufferedReadAdapter {
public: public:
AsyncHttpsProxySocket(AsyncSocket* socket, AsyncHttpsProxySocket(Socket* socket,
const std::string& user_agent, const std::string& user_agent,
const SocketAddress& proxy, const SocketAddress& proxy,
const std::string& username, const std::string& username,
@ -96,8 +96,8 @@ class AsyncHttpsProxySocket : public BufferedReadAdapter {
ConnState GetState() const override; ConnState GetState() const override;
protected: protected:
void OnConnectEvent(AsyncSocket* socket) override; void OnConnectEvent(Socket* socket) override;
void OnCloseEvent(AsyncSocket* socket, int err) override; void OnCloseEvent(Socket* socket, int err) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
bool ShouldIssueConnect() const; bool ShouldIssueConnect() const;
@ -136,7 +136,7 @@ class AsyncHttpsProxySocket : public BufferedReadAdapter {
// Implements a socket adapter that speaks the SOCKS proxy protocol. // Implements a socket adapter that speaks the SOCKS proxy protocol.
class AsyncSocksProxySocket : public BufferedReadAdapter { class AsyncSocksProxySocket : public BufferedReadAdapter {
public: public:
AsyncSocksProxySocket(AsyncSocket* socket, AsyncSocksProxySocket(Socket* socket,
const SocketAddress& proxy, const SocketAddress& proxy,
const std::string& username, const std::string& username,
const CryptString& password); const CryptString& password);
@ -148,7 +148,7 @@ class AsyncSocksProxySocket : public BufferedReadAdapter {
ConnState GetState() const override; ConnState GetState() const override;
protected: protected:
void OnConnectEvent(AsyncSocket* socket) override; void OnConnectEvent(Socket* socket) override;
void ProcessInput(char* data, size_t* len) override; void ProcessInput(char* data, size_t* len) override;
void SendHello(); void SendHello();

11
rtc_base/socket_factory.h
View File

@ -11,7 +11,6 @@
#ifndef RTC_BASE_SOCKET_FACTORY_H_ #ifndef RTC_BASE_SOCKET_FACTORY_H_
#define RTC_BASE_SOCKET_FACTORY_H_ #define RTC_BASE_SOCKET_FACTORY_H_
#include "rtc_base/async_socket.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
namespace rtc { namespace rtc {
@ -20,12 +19,12 @@ class SocketFactory {
public: public:
virtual ~SocketFactory() {} virtual ~SocketFactory() {}
// Returns a new socket for blocking communication. The type can be // Returns a new socket. The type can be SOCK_DGRAM and SOCK_STREAM.
// SOCK_DGRAM and SOCK_STREAM.
virtual Socket* CreateSocket(int family, int type) = 0; virtual Socket* CreateSocket(int family, int type) = 0;
// Returns a new socket for nonblocking communication. The type can be // TODO(nisse): Delete old alias, ASAP when downstream code is updated.
// SOCK_DGRAM and SOCK_STREAM. virtual Socket* CreateAsyncSocket(int family, int type) {
virtual AsyncSocket* CreateAsyncSocket(int family, int type) = 0; return CreateSocket(family, type);
}
}; };
} // namespace rtc } // namespace rtc

16
rtc_base/socket_stream.cc
View File

@ -15,7 +15,7 @@
namespace rtc { namespace rtc {
SocketStream::SocketStream(AsyncSocket* socket) : socket_(nullptr) { SocketStream::SocketStream(Socket* socket) : socket_(nullptr) {
Attach(socket); Attach(socket);
} }
@ -23,7 +23,7 @@ SocketStream::~SocketStream() {
delete socket_; delete socket_;
} }
void SocketStream::Attach(AsyncSocket* socket) { void SocketStream::Attach(Socket* socket) {
if (socket_) if (socket_)
delete socket_; delete socket_;
socket_ = socket; socket_ = socket;
@ -35,8 +35,8 @@ void SocketStream::Attach(AsyncSocket* socket) {
} }
} }
AsyncSocket* SocketStream::Detach() { Socket* SocketStream::Detach() {
AsyncSocket* socket = socket_; Socket* socket = socket_;
if (socket_) { if (socket_) {
socket_->SignalConnectEvent.disconnect(this); socket_->SignalConnectEvent.disconnect(this);
socket_->SignalReadEvent.disconnect(this); socket_->SignalReadEvent.disconnect(this);
@ -104,22 +104,22 @@ void SocketStream::Close() {
socket_->Close(); socket_->Close();
} }
void SocketStream::OnConnectEvent(AsyncSocket* socket) { void SocketStream::OnConnectEvent(Socket* socket) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0); SignalEvent(this, SE_OPEN | SE_READ | SE_WRITE, 0);
} }
void SocketStream::OnReadEvent(AsyncSocket* socket) { void SocketStream::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalEvent(this, SE_READ, 0); SignalEvent(this, SE_READ, 0);
} }
void SocketStream::OnWriteEvent(AsyncSocket* socket) { void SocketStream::OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalEvent(this, SE_WRITE, 0); SignalEvent(this, SE_WRITE, 0);
} }
void SocketStream::OnCloseEvent(AsyncSocket* socket, int err) { void SocketStream::OnCloseEvent(Socket* socket, int err) {
RTC_DCHECK(socket == socket_); RTC_DCHECK(socket == socket_);
SignalEvent(this, SE_CLOSE, err); SignalEvent(this, SE_CLOSE, err);
} }

20
rtc_base/socket_stream.h
View File

@ -13,8 +13,8 @@
#include <stddef.h> #include <stddef.h>
#include "rtc_base/async_socket.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/socket.h"
#include "rtc_base/stream.h" #include "rtc_base/stream.h"
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
@ -24,13 +24,13 @@ namespace rtc {
class SocketStream : public StreamInterface, public sigslot::has_slots<> { class SocketStream : public StreamInterface, public sigslot::has_slots<> {
public: public:
explicit SocketStream(AsyncSocket* socket); explicit SocketStream(Socket* socket);
~SocketStream() override; ~SocketStream() override;
void Attach(AsyncSocket* socket); void Attach(Socket* socket);
AsyncSocket* Detach(); Socket* Detach();
AsyncSocket* GetSocket() { return socket_; } Socket* GetSocket() { return socket_; }
StreamState GetState() const override; StreamState GetState() const override;
@ -47,12 +47,12 @@ class SocketStream : public StreamInterface, public sigslot::has_slots<> {
void Close() override; void Close() override;
private: private:
void OnConnectEvent(AsyncSocket* socket); void OnConnectEvent(Socket* socket);
void OnReadEvent(AsyncSocket* socket); void OnReadEvent(Socket* socket);
void OnWriteEvent(AsyncSocket* socket); void OnWriteEvent(Socket* socket);
void OnCloseEvent(AsyncSocket* socket, int err); void OnCloseEvent(Socket* socket, int err);
AsyncSocket* socket_; Socket* socket_;
RTC_DISALLOW_COPY_AND_ASSIGN(SocketStream); RTC_DISALLOW_COPY_AND_ASSIGN(SocketStream);
}; };

222
rtc_base/socket_unittest.cc
View File

@ -19,7 +19,6 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/arraysize.h" #include "rtc_base/arraysize.h"
#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/buffer.h" #include "rtc_base/buffer.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"
@ -242,19 +241,19 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
EXPECT_EQ(AsyncSocket::CS_CLOSED, client->GetState()); EXPECT_EQ(Socket::CS_CLOSED, client->GetState());
EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr())); EXPECT_TRUE(IsUnspecOrEmptyIP(client->GetLocalAddress().ipaddr()));
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); 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. // Ensure no pending server connections, since we haven't done anything yet.
EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
@ -267,24 +266,24 @@ void SocketTest::ConnectInternal(const IPAddress& loopback) {
EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress()); EXPECT_NE(server->GetLocalAddress(), client->GetLocalAddress());
// Client is connecting, outcome not yet determined. // 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_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it. // Server has pending connection, accept it.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
// Connected from server perspective, check the addresses are correct. // 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(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -297,13 +296,13 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -316,24 +315,24 @@ void SocketTest::ConnectWithDnsLookupInternal(const IPAddress& loopback,
// EXPECT_NE(kEmptyAddr, client->GetLocalAddress()); // Implicit Bind // EXPECT_NE(kEmptyAddr, client->GetLocalAddress()); // Implicit Bind
// Client is connecting, outcome not yet determined. // 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_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
// Server has pending connection, accept it. // Server has pending connection, accept it.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
// Connected from server perspective, check the addresses are correct. // 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(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress());
// Connected from client perspective, check the addresses are correct. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -345,13 +344,13 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server, but don't listen yet. // Create server, but don't listen yet.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -362,7 +361,7 @@ void SocketTest::ConnectFailInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(bogus_addr)); EXPECT_EQ(0, client->Connect(bogus_addr));
// Wait for connection to fail (ECONNREFUSED). // 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil()); EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@ -378,13 +377,13 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server, but don't listen yet. // Create server, but don't listen yet.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -396,15 +395,14 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
// Wait for connection to fail (EHOSTNOTFOUND). // Wait for connection to fail (EHOSTNOTFOUND).
bool dns_lookup_finished = false; bool dns_lookup_finished = false;
WAIT_(client->GetState() == AsyncSocket::CS_CLOSED, kTimeout, WAIT_(client->GetState() == Socket::CS_CLOSED, kTimeout, dns_lookup_finished);
dns_lookup_finished);
if (!dns_lookup_finished) { if (!dns_lookup_finished) {
RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 " RTC_LOG(LS_WARNING) << "Skipping test; DNS resolution took longer than 5 "
"seconds."; "seconds.";
return; 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_TRUE(client->GetRemoteAddress().IsNil()); EXPECT_TRUE(client->GetRemoteAddress().IsNil());
@ -416,35 +414,35 @@ void SocketTest::ConnectWithDnsLookupFailInternal(const IPAddress& loopback) {
void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) { void SocketTest::ConnectWithClosedSocketInternal(const IPAddress& loopback) {
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
// Create a client and put in to CS_CLOSED state. // Create a client and put in to CS_CLOSED state.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, client->Close()); 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. // Connect() should reinitialize the socket, and put it in to CS_CONNECTING.
EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress()))); EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress())));
EXPECT_EQ(AsyncSocket::CS_CONNECTING, client->GetState()); EXPECT_EQ(Socket::CS_CONNECTING, client->GetState());
} }
void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) { void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Create server and listen. // Create server and listen.
StreamSink sink; StreamSink sink;
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
// Create client, connect. // Create client, connect.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
EXPECT_EQ(0, client->Connect(SocketAddress(server->GetLocalAddress()))); 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. // Try to connect again. Should fail, but not interfere with original attempt.
EXPECT_EQ(SOCKET_ERROR, EXPECT_EQ(SOCKET_ERROR,
client->Connect(SocketAddress(server->GetLocalAddress()))); client->Connect(SocketAddress(server->GetLocalAddress())));
@ -452,15 +450,15 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Accept the original connection. // Accept the original connection.
SocketAddress accept_addr; SocketAddress accept_addr;
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
EXPECT_FALSE(accept_addr.IsNil()); EXPECT_FALSE(accept_addr.IsNil());
// Check the states and addresses. // 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(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); 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(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
@ -468,8 +466,8 @@ void SocketTest::ConnectWhileNotClosedInternal(const IPAddress& loopback) {
// Shouldn't break anything. // Shouldn't break anything.
EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress( EXPECT_EQ(SOCKET_ERROR, client->Connect(SocketAddress(
"localhost", server->GetLocalAddress().port()))); "localhost", server->GetLocalAddress().port())));
EXPECT_EQ(AsyncSocket::CS_CONNECTED, accepted->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, accepted->GetState());
EXPECT_EQ(AsyncSocket::CS_CONNECTED, client->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, client->GetState());
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
} }
@ -478,13 +476,13 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
StreamSink sink; StreamSink sink;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -497,7 +495,7 @@ void SocketTest::ServerCloseDuringConnectInternal(const IPAddress& loopback) {
server->Close(); server->Close();
// This should fail the connection for the client. Clean up. // 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)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
client->Close(); client->Close();
} }
@ -507,13 +505,13 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -526,13 +524,13 @@ void SocketTest::ClientCloseDuringConnectInternal(const IPAddress& loopback) {
client->Close(); client->Close();
// The connection should still be able to be accepted. // 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); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); 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) // 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) || EXPECT_TRUE(sink.Check(accepted.get(), SSE_CLOSE) ||
sink.Check(accepted.get(), SSE_ERROR)); sink.Check(accepted.get(), SSE_ERROR));
@ -545,13 +543,13 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -561,12 +559,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
// Accept connection. // Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@ -574,12 +572,12 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
// Send data to the client, and then close the connection. // Send data to the client, and then close the connection.
EXPECT_EQ(1, accepted->Send("a", 1)); EXPECT_EQ(1, accepted->Send("a", 1));
accepted->Close(); 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 that the client is notified, and has not yet closed.
EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout); EXPECT_TRUE_WAIT(sink.Check(client.get(), SSE_READ), kTimeout);
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); 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. // Ensure the data can be read.
char buffer[10]; char buffer[10];
@ -587,7 +585,7 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
EXPECT_EQ('a', buffer[0]); EXPECT_EQ('a', buffer[0]);
// Now we should close, but the remote address will remain. // 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_TRUE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP()); EXPECT_FALSE(client->GetRemoteAddress().IsAnyIP());
@ -607,7 +605,7 @@ void SocketTest::ServerCloseInternal(const IPAddress& loopback) {
class SocketCloser : public sigslot::has_slots<> { class SocketCloser : public sigslot::has_slots<> {
public: public:
void OnClose(AsyncSocket* socket, int error) { void OnClose(Socket* socket, int error) {
socket->Close(); // Deleting here would blow up the vector of handlers socket->Close(); // Deleting here would blow up the vector of handlers
// for the socket's signal. // for the socket's signal.
} }
@ -619,14 +617,14 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose); client->SignalCloseEvent.connect(&closer, &SocketCloser::OnClose);
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -636,26 +634,26 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
// Accept connection. // Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
// Send data to the client, and then close the connection. // Send data to the client, and then close the connection.
accepted->Close(); 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 that the client is notified, and has not yet closed.
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); 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 // 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(sink.Check(client.get(), SSE_CLOSE));
EXPECT_TRUE(Socket::CS_CLOSED == client->GetState()); EXPECT_TRUE(Socket::CS_CLOSED == client->GetState());
} }
@ -663,25 +661,25 @@ void SocketTest::CloseInClosedCallbackInternal(const IPAddress& loopback) {
// Helper class specifically for the test below. // Helper class specifically for the test below.
class SocketDeleter : public sigslot::has_slots<> { class SocketDeleter : public sigslot::has_slots<> {
public: public:
explicit SocketDeleter(std::unique_ptr<AsyncSocket> socket) explicit SocketDeleter(std::unique_ptr<Socket> socket)
: socket_(std::move(socket)) {} : socket_(std::move(socket)) {}
void Delete(AsyncSocket* other) { socket_.reset(); } void Delete(Socket* other) { socket_.reset(); }
bool deleted() const { return socket_ == nullptr; } bool deleted() const { return socket_ == nullptr; }
private: private:
std::unique_ptr<AsyncSocket> socket_; std::unique_ptr<Socket> socket_;
}; };
// Tested deleting a socket within another socket's read callback. A previous // Tested deleting a socket within another socket's read callback. A previous
// iteration of the select loop failed in this situation, if both sockets // iteration of the select loop failed in this situation, if both sockets
// became readable at the same time. // became readable at the same time.
void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) { void SocketTest::DeleteInReadCallbackInternal(const IPAddress& loopback) {
std::unique_ptr<AsyncSocket> socket1( std::unique_ptr<Socket> socket1(
ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
std::unique_ptr<AsyncSocket> socket2( std::unique_ptr<Socket> socket2(
ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, socket1->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, socket2->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress())); EXPECT_EQ(3, socket1->SendTo("foo", 3, socket1->GetLocalAddress()));
@ -706,10 +704,10 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create & connect server and client sockets. // Create & connect server and client sockets.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
@ -718,14 +716,14 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
EXPECT_EQ(0, client->Connect(server->GetLocalAddress())); EXPECT_EQ(0, client->Connect(server->GetLocalAddress()));
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); 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(server->GetLocalAddress(), accepted->GetLocalAddress());
EXPECT_EQ(client->GetLocalAddress(), accepted->GetRemoteAddress()); 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -742,7 +740,7 @@ void SocketTest::SocketServerWaitInternal(const IPAddress& loopback) {
std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer()); std::unique_ptr<Thread> thread(Thread::CreateWithSocketServer());
thread->Start(); thread->Start();
Sleeper sleeper; Sleeper sleeper;
TypedMessageData<AsyncSocket*> data(client.get()); TypedMessageData<Socket*> data(client.get());
thread->Send(RTC_FROM_HERE, &sleeper, 0, &data); thread->Send(RTC_FROM_HERE, &sleeper, 0, &data);
EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ)); EXPECT_FALSE(sink.Check(accepted.get(), SSE_READ));
@ -758,13 +756,13 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
SocketAddress accept_addr; SocketAddress accept_addr;
// Create receiving client. // Create receiving client.
std::unique_ptr<AsyncSocket> receiver( std::unique_ptr<Socket> receiver(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(receiver.get()); sink.Monitor(receiver.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -774,12 +772,12 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
// Accept connection which will be used for sending. // Accept connection which will be used for sending.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(sender);
sink.Monitor(sender.get()); sink.Monitor(sender.get());
// Both sides are now connected. // 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_TRUE(sink.Check(receiver.get(), SSE_OPEN));
EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress()); EXPECT_EQ(receiver->GetRemoteAddress(), sender->GetLocalAddress());
EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress()); EXPECT_EQ(sender->GetRemoteAddress(), receiver->GetLocalAddress());
@ -874,7 +872,7 @@ void SocketTest::TcpInternal(const IPAddress& loopback,
// Close down. // Close down.
sender->Close(); 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)); EXPECT_TRUE(sink.Check(receiver.get(), SSE_CLOSE));
receiver->Close(); receiver->Close();
} }
@ -884,13 +882,13 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
SocketAddress accept_addr; SocketAddress accept_addr;
// Create client. // Create client.
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server and listen. // Create server and listen.
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_->CreateAsyncSocket(loopback.family(), SOCK_STREAM)); ss_->CreateSocket(loopback.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, server->Bind(SocketAddress(loopback, 0)));
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
@ -900,12 +898,12 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
// Accept connection. // Accept connection.
EXPECT_TRUE_WAIT((sink.Check(server.get(), SSE_READ)), kTimeout); 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); ASSERT_TRUE(accepted);
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Both sides are now connected. // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), accepted->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
@ -951,14 +949,14 @@ void SocketTest::SingleFlowControlCallbackInternal(const IPAddress& loopback) {
void SocketTest::UdpInternal(const IPAddress& loopback) { void SocketTest::UdpInternal(const IPAddress& loopback) {
SocketAddress empty = EmptySocketAddressWithFamily(loopback.family()); SocketAddress empty = EmptySocketAddressWithFamily(loopback.family());
// Test basic bind and connect behavior. // Test basic bind and connect behavior.
AsyncSocket* socket = ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM); Socket* socket = ss_->CreateSocket(loopback.family(), SOCK_DGRAM);
EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState()); EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0))); EXPECT_EQ(0, socket->Bind(SocketAddress(loopback, 0)));
SocketAddress addr1 = socket->GetLocalAddress(); SocketAddress addr1 = socket->GetLocalAddress();
EXPECT_EQ(0, socket->Connect(addr1)); EXPECT_EQ(0, socket->Connect(addr1));
EXPECT_EQ(AsyncSocket::CS_CONNECTED, socket->GetState()); EXPECT_EQ(Socket::CS_CONNECTED, socket->GetState());
socket->Close(); socket->Close();
EXPECT_EQ(AsyncSocket::CS_CLOSED, socket->GetState()); EXPECT_EQ(Socket::CS_CLOSED, socket->GetState());
delete socket; delete socket;
// Test send/receive behavior. // Test send/receive behavior.
@ -1041,8 +1039,8 @@ void SocketTest::UdpReadyToSend(const IPAddress& loopback) {
} }
void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) { void SocketTest::GetSetOptionsInternal(const IPAddress& loopback) {
std::unique_ptr<AsyncSocket> socket( std::unique_ptr<Socket> socket(
ss_->CreateAsyncSocket(loopback.family(), SOCK_DGRAM)); ss_->CreateSocket(loopback.family(), SOCK_DGRAM));
socket->Bind(SocketAddress(loopback, 0)); socket->Bind(SocketAddress(loopback, 0));
// Check SNDBUF/RCVBUF. // Check SNDBUF/RCVBUF.

2
rtc_base/ssl_adapter.cc
View File

@ -20,7 +20,7 @@ SSLAdapterFactory* SSLAdapterFactory::Create() {
return new OpenSSLAdapterFactory(); return new OpenSSLAdapterFactory();
} }
SSLAdapter* SSLAdapter::Create(AsyncSocket* socket) { SSLAdapter* SSLAdapter::Create(Socket* socket) {
return new OpenSSLAdapter(socket); return new OpenSSLAdapter(socket);
} }

6
rtc_base/ssl_adapter.h
View File

@ -40,7 +40,7 @@ class SSLAdapterFactory {
virtual void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) = 0; virtual void SetCertVerifier(SSLCertificateVerifier* ssl_cert_verifier) = 0;
// Creates a new SSL adapter, but from a shared context. // 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(); static SSLAdapterFactory* Create();
}; };
@ -52,7 +52,7 @@ class SSLAdapterFactory {
// After creation, call StartSSL to initiate the SSL handshake to the server. // After creation, call StartSSL to initiate the SSL handshake to the server.
class SSLAdapter : public AsyncSocketAdapter { class SSLAdapter : public AsyncSocketAdapter {
public: public:
explicit SSLAdapter(AsyncSocket* socket) : AsyncSocketAdapter(socket) {} explicit SSLAdapter(Socket* socket) : AsyncSocketAdapter(socket) {}
// Methods that control server certificate verification, used in unit tests. // Methods that control server certificate verification, used in unit tests.
// Do not call these methods in production code. // Do not call these methods in production code.
@ -90,7 +90,7 @@ class SSLAdapter : public AsyncSocketAdapter {
// Create the default SSL adapter for this platform. On failure, returns null // Create the default SSL adapter for this platform. On failure, returns null
// and deletes `socket`. Otherwise, the returned SSLAdapter takes ownership // and deletes `socket`. Otherwise, the returned SSLAdapter takes ownership
// of `socket`. // of `socket`.
static SSLAdapter* Create(AsyncSocket* socket); static SSLAdapter* Create(Socket* socket);
}; };
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////

37
rtc_base/ssl_adapter_unittest.cc
View File

@ -30,13 +30,12 @@ using ::testing::Return;
static const int kTimeout = 5000; 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::SocketAddress address(rtc::IPAddress(INADDR_ANY), 0);
rtc::AsyncSocket* socket = rtc::Socket* socket = rtc::Thread::Current()->socketserver()->CreateSocket(
rtc::Thread::Current()->socketserver()->CreateAsyncSocket( address.family(),
address.family(), (ssl_mode == rtc::SSL_MODE_DTLS) ? SOCK_DGRAM : SOCK_STREAM);
(ssl_mode == rtc::SSL_MODE_DTLS) ? SOCK_DGRAM : SOCK_STREAM);
socket->Bind(address); socket->Bind(address);
return socket; return socket;
@ -59,7 +58,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
public: public:
explicit SSLAdapterTestDummyClient(const rtc::SSLMode& ssl_mode) explicit SSLAdapterTestDummyClient(const rtc::SSLMode& ssl_mode)
: ssl_mode_(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)); ssl_adapter_.reset(rtc::SSLAdapter::Create(socket));
@ -96,9 +95,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
return ssl_adapter_->GetLocalAddress(); return ssl_adapter_->GetLocalAddress();
} }
rtc::AsyncSocket::ConnState GetState() const { rtc::Socket::ConnState GetState() const { return ssl_adapter_->GetState(); }
return ssl_adapter_->GetState();
}
const std::string& GetReceivedData() const { return data_; } const std::string& GetReceivedData() const { return data_; }
@ -127,7 +124,7 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
return ssl_adapter_->Send(message.data(), message.length()); return ssl_adapter_->Send(message.data(), message.length());
} }
void OnSSLAdapterReadEvent(rtc::AsyncSocket* socket) { void OnSSLAdapterReadEvent(rtc::Socket* socket) {
char buffer[4096] = ""; char buffer[4096] = "";
// Read data received from the server and store it in our internal buffer. // Read data received from the server and store it in our internal buffer.
@ -141,11 +138,11 @@ class SSLAdapterTestDummyClient : public sigslot::has_slots<> {
} }
} }
void OnSSLAdapterCloseEvent(rtc::AsyncSocket* socket, int error) { void OnSSLAdapterCloseEvent(rtc::Socket* socket, int error) {
// OpenSSLAdapter signals handshake failure with a close event, but without // OpenSSLAdapter signals handshake failure with a close event, but without
// closing the socket! Let's close the socket here. This way GetState() can // closing the socket! Let's close the socket here. This way GetState() can
// return CS_CLOSED after failure. // return CS_CLOSED after failure.
if (socket->GetState() != rtc::AsyncSocket::CS_CLOSED) { if (socket->GetState() != rtc::Socket::CS_CLOSED) {
socket->Close(); socket->Close();
} }
} }
@ -221,14 +218,14 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_); ASSERT_EQ(rtc::SSL_MODE_DTLS, ssl_mode_);
// Transfer ownership of the socket to the SSLStreamAdapter object. // Transfer ownership of the socket to the SSLStreamAdapter object.
rtc::AsyncSocket* socket = server_socket_.release(); rtc::Socket* socket = server_socket_.release();
socket->Connect(address); socket->Connect(address);
DoHandshake(socket); DoHandshake(socket);
} }
void OnServerSocketReadEvent(rtc::AsyncSocket* socket) { void OnServerSocketReadEvent(rtc::Socket* socket) {
// Only a single connection is supported. // Only a single connection is supported.
ASSERT_TRUE(ssl_stream_adapter_ == nullptr); ASSERT_TRUE(ssl_stream_adapter_ == nullptr);
@ -254,7 +251,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
} }
private: private:
void DoHandshake(rtc::AsyncSocket* socket) { void DoHandshake(rtc::Socket* socket) {
ssl_stream_adapter_ = rtc::SSLStreamAdapter::Create( ssl_stream_adapter_ = rtc::SSLStreamAdapter::Create(
std::make_unique<rtc::SocketStream>(socket)); std::make_unique<rtc::SocketStream>(socket));
@ -284,7 +281,7 @@ class SSLAdapterTestDummyServer : public sigslot::has_slots<> {
const rtc::SSLMode ssl_mode_; 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::SSLStreamAdapter> ssl_stream_adapter_;
std::unique_ptr<rtc::SSLIdentity> ssl_identity_; std::unique_ptr<rtc::SSLIdentity> ssl_identity_;
@ -335,13 +332,13 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
int rv; int rv;
// The initial state is CS_CLOSED // 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()); rv = client_->Connect(server_->GetHostname(), server_->GetAddress());
ASSERT_EQ(0, rv); ASSERT_EQ(0, rv);
// Now the state should be CS_CONNECTING // 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) { if (ssl_mode_ == rtc::SSL_MODE_DTLS) {
// For DTLS, call AcceptConnection() with the client's address. // For DTLS, call AcceptConnection() with the client's address.
@ -351,7 +348,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
if (expect_success) { if (expect_success) {
// If expecting success, the client should end up in the CS_CONNECTED // If expecting success, the client should end up in the CS_CONNECTED
// state after handshake. // state after handshake.
EXPECT_EQ_WAIT(rtc::AsyncSocket::CS_CONNECTED, client_->GetState(), EXPECT_EQ_WAIT(rtc::Socket::CS_CONNECTED, client_->GetState(),
handshake_wait_); handshake_wait_);
RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_) RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_)
@ -359,7 +356,7 @@ class SSLAdapterTestBase : public ::testing::Test, public sigslot::has_slots<> {
} else { } else {
// On handshake failure the client should end up in the CS_CLOSED state. // 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_); handshake_wait_);
RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_) << " handshake failed."; RTC_LOG(LS_INFO) << GetSSLProtocolName(ssl_mode_) << " handshake failed.";

10
rtc_base/test_client_unittest.cc
View File

@ -13,11 +13,11 @@
#include <utility> #include <utility>
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/async_tcp_socket.h" #include "rtc_base/async_tcp_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/logging.h" #include "rtc_base/logging.h"
#include "rtc_base/net_helpers.h" #include "rtc_base/net_helpers.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
#include "rtc_base/test_echo_server.h" #include "rtc_base/test_echo_server.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
@ -40,8 +40,8 @@ namespace {
void TestUdpInternal(const SocketAddress& loopback) { void TestUdpInternal(const SocketAddress& loopback) {
Thread* main = Thread::Current(); Thread* main = Thread::Current();
AsyncSocket* socket = Socket* socket =
main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_DGRAM); main->socketserver()->CreateSocket(loopback.family(), SOCK_DGRAM);
socket->Bind(loopback); socket->Bind(loopback);
TestClient client(std::make_unique<AsyncUDPSocket>(socket)); TestClient client(std::make_unique<AsyncUDPSocket>(socket));
@ -56,8 +56,8 @@ void TestTcpInternal(const SocketAddress& loopback) {
Thread* main = Thread::Current(); Thread* main = Thread::Current();
TestEchoServer server(main, loopback); TestEchoServer server(main, loopback);
AsyncSocket* socket = Socket* socket =
main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_STREAM); main->socketserver()->CreateSocket(loopback.family(), SOCK_STREAM);
std::unique_ptr<AsyncTCPSocket> tcp_socket = absl::WrapUnique( std::unique_ptr<AsyncTCPSocket> tcp_socket = absl::WrapUnique(
AsyncTCPSocket::Create(socket, loopback, server.address())); AsyncTCPSocket::Create(socket, loopback, server.address()));
ASSERT_TRUE(tcp_socket != nullptr); ASSERT_TRUE(tcp_socket != nullptr);

4
rtc_base/test_echo_server.cc
View File

@ -15,8 +15,8 @@
namespace rtc { namespace rtc {
TestEchoServer::TestEchoServer(Thread* thread, const SocketAddress& addr) TestEchoServer::TestEchoServer(Thread* thread, const SocketAddress& addr)
: server_socket_(thread->socketserver()->CreateAsyncSocket(addr.family(), : server_socket_(
SOCK_STREAM)) { thread->socketserver()->CreateSocket(addr.family(), SOCK_STREAM)) {
server_socket_->Bind(addr); server_socket_->Bind(addr);
server_socket_->Listen(5); server_socket_->Listen(5);
server_socket_->SignalReadEvent.connect(this, &TestEchoServer::OnAccept); server_socket_->SignalReadEvent.connect(this, &TestEchoServer::OnAccept);

8
rtc_base/test_echo_server.h
View File

@ -19,9 +19,9 @@
#include "absl/algorithm/container.h" #include "absl/algorithm/container.h"
#include "rtc_base/async_packet_socket.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_tcp_socket.h"
#include "rtc_base/constructor_magic.h" #include "rtc_base/constructor_magic.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h" #include "rtc_base/socket_address.h"
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
#include "rtc_base/thread.h" #include "rtc_base/thread.h"
@ -38,8 +38,8 @@ class TestEchoServer : public sigslot::has_slots<> {
SocketAddress address() const { return server_socket_->GetLocalAddress(); } SocketAddress address() const { return server_socket_->GetLocalAddress(); }
private: private:
void OnAccept(AsyncSocket* socket) { void OnAccept(Socket* socket) {
AsyncSocket* raw_socket = socket->Accept(nullptr); Socket* raw_socket = socket->Accept(nullptr);
if (raw_socket) { if (raw_socket) {
AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false); AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false);
packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket); packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket);
@ -62,7 +62,7 @@ class TestEchoServer : public sigslot::has_slots<> {
} }
typedef std::list<AsyncTCPSocket*> ClientList; typedef std::list<AsyncTCPSocket*> ClientList;
std::unique_ptr<AsyncSocket> server_socket_; std::unique_ptr<Socket> server_socket_;
ClientList client_sockets_; ClientList client_sockets_;
RTC_DISALLOW_COPY_AND_ASSIGN(TestEchoServer); RTC_DISALLOW_COPY_AND_ASSIGN(TestEchoServer);
}; };

26
rtc_base/test_utils.h
View File

@ -16,14 +16,14 @@
#include <map> #include <map>
#include <utility> #include <utility>
#include "rtc_base/async_socket.h" #include "rtc_base/socket.h"
#include "rtc_base/third_party/sigslot/sigslot.h" #include "rtc_base/third_party/sigslot/sigslot.h"
namespace webrtc { namespace webrtc {
namespace testing { 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 // Note: Any event that is an error is treated as SSE_ERROR instead of that
@ -42,7 +42,7 @@ class StreamSink : public sigslot::has_slots<> {
StreamSink(); StreamSink();
~StreamSink() override; ~StreamSink() override;
void Monitor(rtc::AsyncSocket* socket) { void Monitor(rtc::Socket* socket) {
socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent); socket->SignalConnectEvent.connect(this, &StreamSink::OnConnectEvent);
socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent); socket->SignalReadEvent.connect(this, &StreamSink::OnReadEvent);
socket->SignalWriteEvent.connect(this, &StreamSink::OnWriteEvent); socket->SignalWriteEvent.connect(this, &StreamSink::OnWriteEvent);
@ -50,30 +50,28 @@ class StreamSink : public sigslot::has_slots<> {
// In case you forgot to unmonitor a previous object with this address // In case you forgot to unmonitor a previous object with this address
events_.erase(socket); events_.erase(socket);
} }
void Unmonitor(rtc::AsyncSocket* socket) { void Unmonitor(rtc::Socket* socket) {
socket->SignalConnectEvent.disconnect(this); socket->SignalConnectEvent.disconnect(this);
socket->SignalReadEvent.disconnect(this); socket->SignalReadEvent.disconnect(this);
socket->SignalWriteEvent.disconnect(this); socket->SignalWriteEvent.disconnect(this);
socket->SignalCloseEvent.disconnect(this); socket->SignalCloseEvent.disconnect(this);
events_.erase(socket); events_.erase(socket);
} }
bool Check(rtc::AsyncSocket* socket, bool Check(rtc::Socket* socket, StreamSinkEvent event, bool reset = true) {
StreamSinkEvent event,
bool reset = true) {
return DoCheck(socket, event, reset); return DoCheck(socket, event, reset);
} }
private: 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 OnConnectEvent(rtc::Socket* socket) { AddEvents(socket, SSE_OPEN); }
void OnReadEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_READ); } void OnReadEvent(rtc::Socket* socket) { AddEvents(socket, SSE_READ); }
void OnWriteEvent(rtc::AsyncSocket* socket) { AddEvents(socket, SSE_WRITE); } void OnWriteEvent(rtc::Socket* socket) { AddEvents(socket, SSE_WRITE); }
void OnCloseEvent(rtc::AsyncSocket* socket, int error) { void OnCloseEvent(rtc::Socket* socket, int error) {
AddEvents(socket, (0 == error) ? SSE_CLOSE : SSE_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); EventMap::iterator it = events_.find(obj);
if (events_.end() == it) { if (events_.end() == it) {
events_.insert(EventMap::value_type(obj, events)); events_.insert(EventMap::value_type(obj, events));
@ -81,7 +79,7 @@ class StreamSink : public sigslot::has_slots<> {
it->second |= events; 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); EventMap::iterator it = events_.find(obj);
if ((events_.end() == it) || (0 == (it->second & event))) { if ((events_.end() == it) || (0 == (it->second & event))) {
return false; return false;

9
rtc_base/thread_unittest.cc
View File

@ -64,7 +64,7 @@ struct TestMessage : public MessageData {
// Receives on a socket and sends by posting messages. // Receives on a socket and sends by posting messages.
class SocketClient : public TestGenerator, public sigslot::has_slots<> { class SocketClient : public TestGenerator, public sigslot::has_slots<> {
public: public:
SocketClient(AsyncSocket* socket, SocketClient(Socket* socket,
const SocketAddress& addr, const SocketAddress& addr,
Thread* post_thread, Thread* post_thread,
MessageHandler* phandler) MessageHandler* phandler)
@ -221,14 +221,13 @@ TEST(ThreadTest, DISABLED_Main) {
// Create the messaging client on its own thread. // Create the messaging client on its own thread.
auto th1 = Thread::CreateWithSocketServer(); auto th1 = Thread::CreateWithSocketServer();
Socket* socket = Socket* socket = th1->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
th1->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
MessageClient msg_client(th1.get(), socket); MessageClient msg_client(th1.get(), socket);
// Create the socket client on its own thread. // Create the socket client on its own thread.
auto th2 = Thread::CreateWithSocketServer(); auto th2 = Thread::CreateWithSocketServer();
AsyncSocket* asocket = Socket* asocket =
th2->socketserver()->CreateAsyncSocket(addr.family(), SOCK_DGRAM); th2->socketserver()->CreateSocket(addr.family(), SOCK_DGRAM);
SocketClient sock_client(asocket, addr, th1.get(), &msg_client); SocketClient sock_client(asocket, addr, th1.get(), &msg_client);
socket->Connect(sock_client.address()); socket->Connect(sock_client.address());

4
rtc_base/virtual_socket_server.cc
View File

@ -614,10 +614,6 @@ Socket* VirtualSocketServer::CreateSocket(int family, int type) {
return CreateSocketInternal(family, type); return CreateSocketInternal(family, type);
} }
AsyncSocket* VirtualSocketServer::CreateAsyncSocket(int family, int type) {
return CreateSocketInternal(family, type);
}
VirtualSocket* VirtualSocketServer::CreateSocketInternal(int family, int type) { VirtualSocket* VirtualSocketServer::CreateSocketInternal(int family, int type) {
return new VirtualSocket(this, family, type, true); return new VirtualSocket(this, family, type, true);
} }

3
rtc_base/virtual_socket_server.h
View File

@ -116,7 +116,6 @@ class VirtualSocketServer : public SocketServer {
// SocketFactory: // SocketFactory:
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
// SocketServer: // SocketServer:
void SetMessageQueue(Thread* queue) override; void SetMessageQueue(Thread* queue) override;
@ -326,7 +325,7 @@ class VirtualSocketServer : public SocketServer {
// Implements the socket interface using the virtual network. Packets are // Implements the socket interface using the virtual network. Packets are
// passed as messages using the message queue of the socket server. // passed as messages using the message queue of the socket server.
class VirtualSocket : public AsyncSocket, class VirtualSocket : public Socket,
public MessageHandler, public MessageHandler,
public sigslot::has_slots<> { public sigslot::has_slots<> {
public: public:

146
rtc_base/virtual_socket_unittest.cc
View File

@ -24,7 +24,6 @@
#include "absl/memory/memory.h" #include "absl/memory/memory.h"
#include "rtc_base/arraysize.h" #include "rtc_base/arraysize.h"
#include "rtc_base/async_packet_socket.h" #include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/async_udp_socket.h" #include "rtc_base/async_udp_socket.h"
#include "rtc_base/fake_clock.h" #include "rtc_base/fake_clock.h"
#include "rtc_base/gunit.h" #include "rtc_base/gunit.h"
@ -54,7 +53,7 @@ using webrtc::testing::StreamSink;
// Sends at a constant rate but with random packet sizes. // Sends at a constant rate but with random packet sizes.
struct Sender : public MessageHandlerAutoCleanup { struct Sender : public MessageHandlerAutoCleanup {
Sender(Thread* th, AsyncSocket* s, uint32_t rt) Sender(Thread* th, Socket* s, uint32_t rt)
: thread(th), : thread(th),
socket(std::make_unique<AsyncUDPSocket>(s)), socket(std::make_unique<AsyncUDPSocket>(s)),
done(false), done(false),
@ -101,7 +100,7 @@ struct Sender : public MessageHandlerAutoCleanup {
struct Receiver : public MessageHandlerAutoCleanup, struct Receiver : public MessageHandlerAutoCleanup,
public sigslot::has_slots<> { public sigslot::has_slots<> {
Receiver(Thread* th, AsyncSocket* s, uint32_t bw) Receiver(Thread* th, Socket* s, uint32_t bw)
: thread(th), : thread(th),
socket(std::make_unique<AsyncUDPSocket>(s)), socket(std::make_unique<AsyncUDPSocket>(s)),
bandwidth(bw), bandwidth(bw),
@ -196,8 +195,7 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.SetDefaultRoute(default_route); ss_.SetDefaultRoute(default_route);
// Create client1 bound to the any address. // Create client1 bound to the any address.
AsyncSocket* socket = Socket* socket = ss_.CreateSocket(default_route.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
socket->Bind(EmptySocketAddressWithFamily(default_route.family())); socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
SocketAddress client1_any_addr = socket->GetLocalAddress(); SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP()); EXPECT_TRUE(client1_any_addr.IsAnyIP());
@ -205,8 +203,7 @@ class VirtualSocketServerTest : public ::testing::Test {
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_); std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the default route. // Create client2 bound to the default route.
AsyncSocket* socket2 = Socket* socket2 = ss_.CreateSocket(default_route.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
socket2->Bind(SocketAddress(default_route, 0)); socket2->Bind(SocketAddress(default_route, 0));
SocketAddress client2_addr = socket2->GetLocalAddress(); SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP()); EXPECT_FALSE(client2_addr.IsAnyIP());
@ -227,8 +224,7 @@ class VirtualSocketServerTest : public ::testing::Test {
} }
void BasicTest(const SocketAddress& initial_addr) { void BasicTest(const SocketAddress& initial_addr) {
AsyncSocket* socket = Socket* socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
socket->Bind(initial_addr); socket->Bind(initial_addr);
SocketAddress server_addr = socket->GetLocalAddress(); SocketAddress server_addr = socket->GetLocalAddress();
// Make sure VSS didn't switch families on us. // Make sure VSS didn't switch families on us.
@ -236,8 +232,7 @@ class VirtualSocketServerTest : public ::testing::Test {
auto client1 = std::make_unique<TestClient>( auto client1 = std::make_unique<TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_); std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
AsyncSocket* socket2 = Socket* socket2 = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
auto client2 = std::make_unique<TestClient>( auto client2 = std::make_unique<TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_); std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
@ -278,21 +273,21 @@ class VirtualSocketServerTest : public ::testing::Test {
EmptySocketAddressWithFamily(initial_addr.family()); EmptySocketAddressWithFamily(initial_addr.family());
// Create client // Create client
std::unique_ptr<AsyncSocket> client = absl::WrapUnique( std::unique_ptr<Socket> client =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil()); EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server // Create server
std::unique_ptr<AsyncSocket> server = absl::WrapUnique( std::unique_ptr<Socket> server =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr)); EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
EXPECT_EQ(0, server->Listen(5)); EXPECT_EQ(0, server->Listen(5));
EXPECT_EQ(server->GetState(), AsyncSocket::CS_CONNECTING); EXPECT_EQ(server->GetState(), Socket::CS_CONNECTING);
// No pending server connections // No pending server connections
EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
@ -306,14 +301,14 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress()); EXPECT_NE(client->GetLocalAddress(), server->GetLocalAddress());
// Client is connecting // 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_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
// Client still connecting // 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_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
@ -325,14 +320,14 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_NE(accept_addr, kEmptyAddr); EXPECT_NE(accept_addr, kEmptyAddr);
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr); 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->GetLocalAddress(), server->GetLocalAddress());
EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress()); EXPECT_EQ(accepted->GetRemoteAddress(), client->GetLocalAddress());
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
// Client has connected // 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_TRUE(sink.Check(client.get(), SSE_OPEN));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress()); EXPECT_EQ(client->GetRemoteAddress(), server->GetLocalAddress());
@ -347,13 +342,13 @@ class VirtualSocketServerTest : public ::testing::Test {
EmptySocketAddressWithFamily(initial_addr.family()); EmptySocketAddressWithFamily(initial_addr.family());
// Create client // Create client
std::unique_ptr<AsyncSocket> client = absl::WrapUnique( std::unique_ptr<Socket> client =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
// Create server // Create server
std::unique_ptr<AsyncSocket> server = absl::WrapUnique( std::unique_ptr<Socket> server =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(initial_addr)); EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
@ -368,7 +363,7 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_EQ(accept_addr, nil_addr); EXPECT_EQ(accept_addr, nil_addr);
// Connection failed // 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
EXPECT_EQ(client->GetRemoteAddress(), nil_addr); EXPECT_EQ(client->GetRemoteAddress(), nil_addr);
@ -381,11 +376,11 @@ class VirtualSocketServerTest : public ::testing::Test {
EmptySocketAddressWithFamily(initial_addr.family()); EmptySocketAddressWithFamily(initial_addr.family());
// Create client and server // Create client and server
std::unique_ptr<AsyncSocket> client( std::unique_ptr<Socket> client(
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
std::unique_ptr<AsyncSocket> server( std::unique_ptr<Socket> server(
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
// Initiate connect // Initiate connect
@ -402,10 +397,10 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
// Result: connection failed // 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)); 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()); sink.Monitor(server.get());
// Initiate connect // Initiate connect
@ -424,11 +419,11 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
// Result: connection failed // 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)); EXPECT_TRUE(sink.Check(client.get(), SSE_ERROR));
// New server // New server
server.reset(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); server.reset(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
// Initiate connect // Initiate connect
@ -442,21 +437,21 @@ class VirtualSocketServerTest : public ::testing::Test {
// Server accepts connection // Server accepts connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ)); 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()); ASSERT_TRUE(nullptr != accepted.get());
sink.Monitor(accepted.get()); sink.Monitor(accepted.get());
// Client closes before connection complets // 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. // Connected message has not been processed yet.
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CONNECTING); EXPECT_EQ(client->GetState(), Socket::CS_CONNECTING);
client->Close(); client->Close();
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
// Result: accepted socket closes // 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_TRUE(sink.Check(accepted.get(), SSE_CLOSE));
EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE)); EXPECT_FALSE(sink.Check(client.get(), SSE_CLOSE));
} }
@ -466,14 +461,14 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr; const SocketAddress kEmptyAddr;
// Create clients // Create clients
std::unique_ptr<AsyncSocket> a = absl::WrapUnique( std::unique_ptr<Socket> a =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get()); sink.Monitor(a.get());
a->Bind(initial_addr); a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
std::unique_ptr<AsyncSocket> b = absl::WrapUnique( std::unique_ptr<Socket> b =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get()); sink.Monitor(b.get());
b->Bind(initial_addr); b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@ -484,11 +479,11 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.ProcessMessagesUntilIdle(); ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(a.get(), SSE_OPEN)); 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_EQ(a->GetRemoteAddress(), b->GetLocalAddress());
EXPECT_TRUE(sink.Check(b.get(), SSE_OPEN)); 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(b->GetRemoteAddress(), a->GetLocalAddress());
EXPECT_EQ(1, a->Send("a", 1)); EXPECT_EQ(1, a->Send("a", 1));
@ -502,12 +497,12 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr)); EXPECT_EQ(-1, b->Recv(buffer, 10, nullptr));
EXPECT_TRUE(sink.Check(a.get(), SSE_CLOSE)); 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); EXPECT_EQ(a->GetRemoteAddress(), kEmptyAddr);
// No signal for Closer // No signal for Closer
EXPECT_FALSE(sink.Check(b.get(), SSE_CLOSE)); 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); EXPECT_EQ(b->GetRemoteAddress(), kEmptyAddr);
} }
@ -516,14 +511,14 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr; const SocketAddress kEmptyAddr;
// Connect two sockets // Connect two sockets
std::unique_ptr<AsyncSocket> a = absl::WrapUnique( std::unique_ptr<Socket> a =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(a.get()); sink.Monitor(a.get());
a->Bind(initial_addr); a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
std::unique_ptr<AsyncSocket> b = absl::WrapUnique( std::unique_ptr<Socket> b =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get()); sink.Monitor(b.get());
b->Bind(initial_addr); b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@ -638,10 +633,10 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr; const SocketAddress kEmptyAddr;
// Connect two sockets // Connect two sockets
std::unique_ptr<AsyncSocket> a = absl::WrapUnique( std::unique_ptr<Socket> a =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
std::unique_ptr<AsyncSocket> b = absl::WrapUnique( std::unique_ptr<Socket> b =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(initial_addr.family(), SOCK_STREAM));
a->Bind(initial_addr); a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@ -692,10 +687,8 @@ class VirtualSocketServerTest : public ::testing::Test {
// incremental port behavior could ensure the 2 Binds result in different // incremental port behavior could ensure the 2 Binds result in different
// address. // address.
void BandwidthTest(const SocketAddress& initial_addr) { void BandwidthTest(const SocketAddress& initial_addr) {
AsyncSocket* send_socket = Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
AsyncSocket* recv_socket =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr)); ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr)); ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@ -737,10 +730,8 @@ class VirtualSocketServerTest : public ::testing::Test {
ss_.set_delay_stddev(stddev); ss_.set_delay_stddev(stddev);
ss_.UpdateDelayDistribution(); ss_.UpdateDelayDistribution();
AsyncSocket* send_socket = Socket* send_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM); Socket* recv_socket = ss_.CreateSocket(initial_addr.family(), SOCK_DGRAM);
AsyncSocket* recv_socket =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
ASSERT_EQ(0, send_socket->Bind(initial_addr)); ASSERT_EQ(0, send_socket->Bind(initial_addr));
ASSERT_EQ(0, recv_socket->Bind(initial_addr)); ASSERT_EQ(0, recv_socket->Bind(initial_addr));
EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family()); EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
@ -789,17 +780,17 @@ class VirtualSocketServerTest : public ::testing::Test {
const SocketAddress kEmptyAddr; const SocketAddress kEmptyAddr;
// Client gets a IPv4 address // Client gets a IPv4 address
std::unique_ptr<AsyncSocket> client = absl::WrapUnique( std::unique_ptr<Socket> client =
ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(client_addr.family(), SOCK_STREAM));
sink.Monitor(client.get()); sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED); EXPECT_EQ(client->GetState(), Socket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr); EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
client->Bind(client_addr); client->Bind(client_addr);
// Server gets a non-mapped non-any IPv6 address. // Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this. // IPv4 sockets should not be able to connect to this.
std::unique_ptr<AsyncSocket> server = absl::WrapUnique( std::unique_ptr<Socket> server =
ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(server_addr.family(), SOCK_STREAM));
sink.Monitor(server.get()); sink.Monitor(server.get());
server->Bind(server_addr); server->Bind(server_addr);
server->Listen(5); server->Listen(5);
@ -823,7 +814,7 @@ class VirtualSocketServerTest : public ::testing::Test {
EXPECT_FALSE(sink.Check(server.get(), SSE_READ)); EXPECT_FALSE(sink.Check(server.get(), SSE_READ));
EXPECT_TRUE(nullptr == server->Accept(&accept_address)); EXPECT_TRUE(nullptr == server->Accept(&accept_address));
EXPECT_EQ(accept_address, kEmptyAddr); 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_FALSE(sink.Check(client.get(), SSE_OPEN));
EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr); EXPECT_EQ(client->GetRemoteAddress(), kEmptyAddr);
} }
@ -835,13 +826,13 @@ class VirtualSocketServerTest : public ::testing::Test {
void CrossFamilyDatagramTest(const SocketAddress& client_addr, void CrossFamilyDatagramTest(const SocketAddress& client_addr,
const SocketAddress& server_addr, const SocketAddress& server_addr,
bool shouldSucceed) { bool shouldSucceed) {
AsyncSocket* socket = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM); Socket* socket = ss_.CreateSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr); socket->Bind(server_addr);
SocketAddress bound_server_addr = socket->GetLocalAddress(); SocketAddress bound_server_addr = socket->GetLocalAddress();
auto client1 = std::make_unique<TestClient>( auto client1 = std::make_unique<TestClient>(
std::make_unique<AsyncUDPSocket>(socket), &fake_clock_); 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); socket2->Bind(client_addr);
auto client2 = std::make_unique<TestClient>( auto client2 = std::make_unique<TestClient>(
std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_); std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
@ -1043,10 +1034,9 @@ TEST_F(VirtualSocketServerTest, CanSendDatagramFromUnboundIPv6ToIPv4Any) {
} }
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) { TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
AsyncSocket* socket1 = Socket* socket1 = ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM); std::unique_ptr<Socket> socket2 =
std::unique_ptr<AsyncSocket> socket2 = absl::WrapUnique( absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
socket1->Bind(kIPv4AnyAddress); socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress); socket2->Bind(kIPv4AnyAddress);
auto client1 = std::make_unique<TestClient>( auto client1 = std::make_unique<TestClient>(
@ -1068,10 +1058,10 @@ TEST_F(VirtualSocketServerTest, SetSendingBlockedWithTcpSocket) {
ss_.set_recv_buffer_capacity(kBufferSize); ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink; StreamSink sink;
std::unique_ptr<AsyncSocket> socket1 = absl::WrapUnique( std::unique_ptr<Socket> socket1 =
ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
std::unique_ptr<AsyncSocket> socket2 = absl::WrapUnique( std::unique_ptr<Socket> socket2 =
ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM)); absl::WrapUnique(ss_.CreateSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
sink.Monitor(socket1.get()); sink.Monitor(socket1.get());
sink.Monitor(socket2.get()); sink.Monitor(socket2.get());
socket1->Bind(kIPv4AnyAddress); socket1->Bind(kIPv4AnyAddress);

4
rtc_base/win32_socket_server.cc
View File

@ -686,10 +686,6 @@ Win32SocketServer::~Win32SocketServer() {
} }
Socket* Win32SocketServer::CreateSocket(int family, int type) { Socket* Win32SocketServer::CreateSocket(int family, int type) {
return CreateAsyncSocket(family, type);
}
AsyncSocket* Win32SocketServer::CreateAsyncSocket(int family, int type) {
Win32Socket* socket = new Win32Socket; Win32Socket* socket = new Win32Socket;
if (socket->CreateT(family, type)) { if (socket->CreateT(family, type)) {
return socket; return socket;

6
rtc_base/win32_socket_server.h
View File

@ -12,7 +12,6 @@
#define RTC_BASE_WIN32_SOCKET_SERVER_H_ #define RTC_BASE_WIN32_SOCKET_SERVER_H_
#if defined(WEBRTC_WIN) #if defined(WEBRTC_WIN)
#include "rtc_base/async_socket.h"
#include "rtc_base/socket.h" #include "rtc_base/socket.h"
#include "rtc_base/socket_factory.h" #include "rtc_base/socket_factory.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
@ -26,7 +25,7 @@ namespace rtc {
// Win32Socket // Win32Socket
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
class Win32Socket : public AsyncSocket { class Win32Socket : public Socket {
public: public:
Win32Socket(); Win32Socket();
~Win32Socket() override; ~Win32Socket() override;
@ -36,7 +35,7 @@ class Win32Socket : public AsyncSocket {
int Attach(SOCKET s); int Attach(SOCKET s);
void SetTimeout(int ms); void SetTimeout(int ms);
// AsyncSocket Interface // Socket Interface
SocketAddress GetLocalAddress() const override; SocketAddress GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override; SocketAddress GetRemoteAddress() const override;
int Bind(const SocketAddress& addr) override; int Bind(const SocketAddress& addr) override;
@ -100,7 +99,6 @@ class Win32SocketServer : public SocketServer {
// SocketServer Interface // SocketServer Interface
Socket* CreateSocket(int family, int type) override; Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
void SetMessageQueue(Thread* queue) override; void SetMessageQueue(Thread* queue) override;
bool Wait(int cms, bool process_io) override; bool Wait(int cms, bool process_io) override;

2
test/network/BUILD.gn
View File

@ -55,12 +55,12 @@ rtc_library("emulated_network") {
"../../call:simulated_network", "../../call:simulated_network",
"../../p2p:p2p_server_utils", "../../p2p:p2p_server_utils",
"../../rtc_base", "../../rtc_base",
"../../rtc_base:async_socket",
"../../rtc_base:ip_address", "../../rtc_base:ip_address",
"../../rtc_base:network_constants", "../../rtc_base:network_constants",
"../../rtc_base:rtc_base_tests_utils", "../../rtc_base:rtc_base_tests_utils",
"../../rtc_base:rtc_task_queue", "../../rtc_base:rtc_task_queue",
"../../rtc_base:safe_minmax", "../../rtc_base:safe_minmax",
"../../rtc_base:socket",
"../../rtc_base:socket_address", "../../rtc_base:socket_address",
"../../rtc_base:socket_server", "../../rtc_base:socket_server",
"../../rtc_base:stringutils", "../../rtc_base:stringutils",

16
test/network/fake_network_socket_server.cc
View File

@ -32,7 +32,7 @@ std::string ToString(const rtc::SocketAddress& addr) {
} // namespace } // namespace
// Represents a socket, which will operate with emulated network. // Represents a socket, which will operate with emulated network.
class FakeNetworkSocket : public rtc::AsyncSocket, class FakeNetworkSocket : public rtc::Socket,
public EmulatedNetworkReceiverInterface { public EmulatedNetworkReceiverInterface {
public: public:
explicit FakeNetworkSocket(FakeNetworkSocketServer* scoket_manager, explicit FakeNetworkSocket(FakeNetworkSocketServer* scoket_manager,
@ -58,7 +58,7 @@ class FakeNetworkSocket : public rtc::AsyncSocket,
rtc::SocketAddress* paddr, rtc::SocketAddress* paddr,
int64_t* timestamp) override; int64_t* timestamp) override;
int Listen(int backlog) override; int Listen(int backlog) override;
rtc::AsyncSocket* Accept(rtc::SocketAddress* paddr) override; rtc::Socket* Accept(rtc::SocketAddress* paddr) override;
int GetError() const override; int GetError() const override;
void SetError(int error) override; void SetError(int error) override;
ConnState GetState() const override; ConnState GetState() const override;
@ -223,7 +223,7 @@ int FakeNetworkSocket::Listen(int backlog) {
RTC_CHECK(false) << "Listen() isn't valid for SOCK_DGRAM"; RTC_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"; RTC_CHECK(false) << "Accept() isn't valid for SOCK_DGRAM";
} }
@ -249,7 +249,7 @@ void FakeNetworkSocket::SetError(int error) {
error_ = error; error_ = error;
} }
rtc::AsyncSocket::ConnState FakeNetworkSocket::GetState() const { rtc::Socket::ConnState FakeNetworkSocket::GetState() const {
RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK_RUN_ON(thread_);
return state_; return state_;
} }
@ -286,13 +286,7 @@ void FakeNetworkSocketServer::Unregister(FakeNetworkSocket* socket) {
sockets_.erase(absl::c_find(sockets_, socket)); sockets_.erase(absl::c_find(sockets_, socket));
} }
rtc::Socket* FakeNetworkSocketServer::CreateSocket(int /*family*/, rtc::Socket* FakeNetworkSocketServer::CreateSocket(int family, int type) {
int /*type*/) {
RTC_CHECK(false) << "Only async sockets are supported";
}
rtc::AsyncSocket* FakeNetworkSocketServer::CreateAsyncSocket(int family,
int type) {
RTC_DCHECK(family == AF_INET || family == AF_INET6); RTC_DCHECK(family == AF_INET || family == AF_INET6);
// We support only UDP sockets for now. // We support only UDP sockets for now.
RTC_DCHECK(type == SOCK_DGRAM) << "Only UDP sockets are supported"; RTC_DCHECK(type == SOCK_DGRAM) << "Only UDP sockets are supported";

3
test/network/fake_network_socket_server.h
View File

@ -15,8 +15,8 @@
#include <vector> #include <vector>
#include "api/units/timestamp.h" #include "api/units/timestamp.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/event.h" #include "rtc_base/event.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_server.h" #include "rtc_base/socket_server.h"
#include "rtc_base/synchronization/mutex.h" #include "rtc_base/synchronization/mutex.h"
#include "system_wrappers/include/clock.h" #include "system_wrappers/include/clock.h"
@ -35,7 +35,6 @@ class FakeNetworkSocketServer : public rtc::SocketServer {
// rtc::SocketFactory methods: // rtc::SocketFactory methods:
rtc::Socket* CreateSocket(int family, int type) override; rtc::Socket* CreateSocket(int family, int type) override;
rtc::AsyncSocket* CreateAsyncSocket(int family, int type) override;
// rtc::SocketServer methods: // rtc::SocketServer methods:
// Called by the network thread when this server is installed, kicking off the // Called by the network thread when this server is installed, kicking off the

30
test/network/network_emulation_unittest.cc
View File

@ -36,7 +36,7 @@ constexpr int kOverheadIpv4Udp = 20 + 8;
class SocketReader : public sigslot::has_slots<> { class SocketReader : public sigslot::has_slots<> {
public: 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_(socket), network_thread_(network_thread) {
socket_->SignalReadEvent.connect(this, &SocketReader::OnReadEvent); socket_->SignalReadEvent.connect(this, &SocketReader::OnReadEvent);
size_ = 128 * 1024; size_ = 128 * 1024;
@ -44,7 +44,7 @@ class SocketReader : public sigslot::has_slots<> {
} }
~SocketReader() override { delete[] buf_; } ~SocketReader() override { delete[] buf_; }
void OnReadEvent(rtc::AsyncSocket* socket) { void OnReadEvent(rtc::Socket* socket) {
RTC_DCHECK(socket_ == socket); RTC_DCHECK(socket_ == socket);
RTC_DCHECK(network_thread_->IsCurrent()); RTC_DCHECK(network_thread_->IsCurrent());
int64_t timestamp; int64_t timestamp;
@ -60,7 +60,7 @@ class SocketReader : public sigslot::has_slots<> {
} }
private: private:
rtc::AsyncSocket* const socket_; rtc::Socket* const socket_;
rtc::Thread* const network_thread_; rtc::Thread* const network_thread_;
char* buf_; char* buf_;
size_t size_; size_t size_;
@ -207,13 +207,13 @@ TEST(NetworkEmulationManagerTest, Run) {
rtc::CopyOnWriteBuffer data("Hello"); rtc::CopyOnWriteBuffer data("Hello");
for (uint64_t j = 0; j < 2; j++) { for (uint64_t j = 0; j < 2; j++) {
rtc::AsyncSocket* s1 = nullptr; rtc::Socket* s1 = nullptr;
rtc::AsyncSocket* s2 = nullptr; rtc::Socket* s2 = nullptr;
t1->Invoke<void>(RTC_FROM_HERE, [&] { 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, [&] { 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); SocketReader r1(s1, t1);
@ -363,13 +363,13 @@ TEST(NetworkEmulationManagerTest, DebugStatsCollectedInDebugMode) {
rtc::CopyOnWriteBuffer data("Hello"); rtc::CopyOnWriteBuffer data("Hello");
for (uint64_t j = 0; j < 2; j++) { for (uint64_t j = 0; j < 2; j++) {
rtc::AsyncSocket* s1 = nullptr; rtc::Socket* s1 = nullptr;
rtc::AsyncSocket* s2 = nullptr; rtc::Socket* s2 = nullptr;
t1->Invoke<void>(RTC_FROM_HERE, [&] { 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, [&] { 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); SocketReader r1(s1, t1);
@ -467,13 +467,13 @@ TEST(NetworkEmulationManagerTest, ThroughputStats) {
constexpr int64_t kSinglePacketSize = kUdpPayloadSize + kOverheadIpv4Udp; constexpr int64_t kSinglePacketSize = kUdpPayloadSize + kOverheadIpv4Udp;
rtc::CopyOnWriteBuffer data(kUdpPayloadSize); rtc::CopyOnWriteBuffer data(kUdpPayloadSize);
rtc::AsyncSocket* s1 = nullptr; rtc::Socket* s1 = nullptr;
rtc::AsyncSocket* s2 = nullptr; rtc::Socket* s2 = nullptr;
t1->Invoke<void>(RTC_FROM_HERE, [&] { 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, [&] { 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); SocketReader r1(s1, t1);

5
test/run_loop.cc
View File

@ -61,11 +61,6 @@ rtc::Socket* RunLoop::FakeSocketServer::CreateSocket(int family, int type) {
return nullptr; return nullptr;
} }
rtc::AsyncSocket* RunLoop::FakeSocketServer::CreateAsyncSocket(int family,
int type) {
return nullptr;
}
RunLoop::WorkerThread::WorkerThread(rtc::SocketServer* ss) RunLoop::WorkerThread::WorkerThread(rtc::SocketServer* ss)
: rtc::Thread(ss), tq_setter_(this) {} : rtc::Thread(ss), tq_setter_(this) {}

1
test/run_loop.h
View File

@ -56,7 +56,6 @@ class RunLoop {
void WakeUp() override; void WakeUp() override;
rtc::Socket* CreateSocket(int family, int type) override; rtc::Socket* CreateSocket(int family, int type) override;
rtc::AsyncSocket* CreateAsyncSocket(int family, int type) override;
private: private:
bool fail_next_wait_ = false; bool fail_next_wait_ = false;

4
test/time_controller/simulated_thread.cc
View File

@ -26,10 +26,6 @@ class DummySocketServer : public rtc::SocketServer {
RTC_NOTREACHED(); RTC_NOTREACHED();
return nullptr; return nullptr;
} }
rtc::AsyncSocket* CreateAsyncSocket(int family, int type) override {
RTC_NOTREACHED();
return nullptr;
}
bool Wait(int cms, bool process_io) override { bool Wait(int cms, bool process_io) override {
RTC_CHECK_EQ(cms, 0); RTC_CHECK_EQ(cms, 0);
return true; return true;