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(family == AF_INET || family == AF_INET6);
std::unique_ptr<rtc::AsyncSocket> socket(
thread->socketserver()->CreateAsyncSocket(family, SOCK_DGRAM));
std::unique_ptr<rtc::Socket> socket(
thread->socketserver()->CreateSocket(family, SOCK_DGRAM));
if (!socket) {
RTC_LOG_ERR(LERROR) << "Socket creation failed";
return rtc::IPAddress();

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

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

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

4
p2p/BUILD.gn
View File

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

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
// connect() fail (`socket` is destroyed in that case).
AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
rtc::AsyncSocket* socket,
rtc::Socket* socket,
const rtc::SocketAddress& bind_address,
const rtc::SocketAddress& remote_address) {
return new AsyncStunTCPSocket(
@ -49,7 +49,7 @@ AsyncStunTCPSocket* AsyncStunTCPSocket::Create(
false);
}
AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::AsyncSocket* socket, bool listen)
AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::Socket* socket, bool listen)
: rtc::AsyncTCPSocketBase(socket, listen, kBufSize) {}
int AsyncStunTCPSocket::Send(const void* pv,
@ -126,7 +126,7 @@ void AsyncStunTCPSocket::ProcessInput(char* data, size_t* len) {
}
}
void AsyncStunTCPSocket::HandleIncomingConnection(rtc::AsyncSocket* socket) {
void AsyncStunTCPSocket::HandleIncomingConnection(rtc::Socket* socket) {
SignalNewConnection(this, new AsyncStunTCPSocket(socket, false));
}

8
p2p/base/async_stun_tcp_socket.h
View File

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

8
p2p/base/async_stun_tcp_socket_unittest.cc
View File

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

13
p2p/base/basic_packet_socket_factory.cc
View File

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

4
p2p/base/basic_packet_socket_factory.h
View File

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

5
p2p/base/port_unittest.cc
View File

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

2
p2p/base/stun_server.h
View File

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

4
p2p/base/test_stun_server.cc
View File

@ -10,14 +10,14 @@
#include "p2p/base/test_stun_server.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_server.h"
namespace cricket {
TestStunServer* TestStunServer::Create(rtc::SocketServer* ss,
const rtc::SocketAddress& addr) {
rtc::AsyncSocket* socket = ss->CreateAsyncSocket(addr.family(), SOCK_DGRAM);
rtc::Socket* socket = ss->CreateSocket(addr.family(), SOCK_DGRAM);
rtc::AsyncUDPSocket* udp_socket = rtc::AsyncUDPSocket::Create(socket, addr);
return new TestStunServer(udp_socket);

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) {
// For TCP we need to create a server socket which can listen for incoming
// new connections.
rtc::AsyncSocket* socket =
thread_->socketserver()->CreateAsyncSocket(AF_INET, SOCK_STREAM);
rtc::Socket* socket =
thread_->socketserver()->CreateSocket(AF_INET, SOCK_STREAM);
if (proto == cricket::PROTO_TLS) {
// For TLS, wrap the TCP socket with an SSL adapter. The adapter must
// be configured with a self-signed certificate for testing.

6
p2p/base/turn_port_unittest.cc
View File

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

10
p2p/base/turn_server.cc
View File

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

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

12
rtc_base/BUILD.gn
View File

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

18
rtc_base/async_socket.cc
View File

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

41
rtc_base/async_socket.h
View File

@ -22,34 +22,11 @@
namespace rtc {
// TODO: Remove Socket and rename AsyncSocket to Socket.
// Provides the ability to perform socket I/O asynchronously.
class AsyncSocket : public Socket {
public:
AsyncSocket();
~AsyncSocket() override;
AsyncSocket* Accept(SocketAddress* paddr) override = 0;
// SignalReadEvent and SignalWriteEvent use multi_threaded_local to allow
// access concurrently from different thread.
// For example SignalReadEvent::connect will be called in AsyncUDPSocket ctor
// but at the same time the SocketDispatcher maybe signaling the read event.
// ready to read
sigslot::signal1<AsyncSocket*, sigslot::multi_threaded_local> SignalReadEvent;
// ready to write
sigslot::signal1<AsyncSocket*, sigslot::multi_threaded_local>
SignalWriteEvent;
sigslot::signal1<AsyncSocket*> SignalConnectEvent; // connected
sigslot::signal2<AsyncSocket*, int> SignalCloseEvent; // closed
};
class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
class AsyncSocketAdapter : public Socket, public sigslot::has_slots<> {
public:
// Takes ownership of the passed in socket.
// TODO(bugs.webrtc.org/6424): Change to unique_ptr here and in callers.
explicit AsyncSocketAdapter(AsyncSocket* socket);
explicit AsyncSocketAdapter(Socket* socket);
SocketAddress GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override;
@ -63,7 +40,7 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
SocketAddress* paddr,
int64_t* timestamp) override;
int Listen(int backlog) override;
AsyncSocket* Accept(SocketAddress* paddr) override;
Socket* Accept(SocketAddress* paddr) override;
int Close() override;
int GetError() const override;
void SetError(int error) override;
@ -72,15 +49,15 @@ class AsyncSocketAdapter : public AsyncSocket, public sigslot::has_slots<> {
int SetOption(Option opt, int value) override;
protected:
virtual void OnConnectEvent(AsyncSocket* socket);
virtual void OnReadEvent(AsyncSocket* socket);
virtual void OnWriteEvent(AsyncSocket* socket);
virtual void OnCloseEvent(AsyncSocket* socket, int err);
virtual void OnConnectEvent(Socket* socket);
virtual void OnReadEvent(Socket* socket);
virtual void OnWriteEvent(Socket* socket);
virtual void OnCloseEvent(Socket* socket, int err);
AsyncSocket* GetSocket() const { return socket_.get(); }
Socket* GetSocket() const { return socket_.get(); }
private:
const std::unique_ptr<AsyncSocket> socket_;
const std::unique_ptr<Socket> socket_;
};
} // 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;
// Binds and connects `socket`
AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
rtc::AsyncSocket* socket,
Socket* AsyncTCPSocketBase::ConnectSocket(
rtc::Socket* socket,
const rtc::SocketAddress& bind_address,
const rtc::SocketAddress& remote_address) {
std::unique_ptr<rtc::AsyncSocket> owned_socket(socket);
std::unique_ptr<rtc::Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr;
@ -61,7 +61,7 @@ AsyncSocket* AsyncTCPSocketBase::ConnectSocket(
return owned_socket.release();
}
AsyncTCPSocketBase::AsyncTCPSocketBase(AsyncSocket* socket,
AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket,
bool listen,
size_t max_packet_size)
: socket_(socket),
@ -193,16 +193,16 @@ void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) {
outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb);
}
void AsyncTCPSocketBase::OnConnectEvent(AsyncSocket* socket) {
void AsyncTCPSocketBase::OnConnectEvent(Socket* socket) {
SignalConnect(this);
}
void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
void AsyncTCPSocketBase::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
if (listen_) {
rtc::SocketAddress address;
rtc::AsyncSocket* new_socket = socket->Accept(&address);
rtc::Socket* new_socket = socket->Accept(&address);
if (!new_socket) {
// TODO(stefan): Do something better like forwarding the error
// to the user.
@ -259,7 +259,7 @@ void AsyncTCPSocketBase::OnReadEvent(AsyncSocket* socket) {
}
}
void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
void AsyncTCPSocketBase::OnWriteEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
if (outbuf_.size() > 0) {
@ -271,7 +271,7 @@ void AsyncTCPSocketBase::OnWriteEvent(AsyncSocket* socket) {
}
}
void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
void AsyncTCPSocketBase::OnCloseEvent(Socket* socket, int error) {
SignalClose(this, error);
}
@ -279,7 +279,7 @@ void AsyncTCPSocketBase::OnCloseEvent(AsyncSocket* socket, int error) {
// Binds and connects `socket` and creates AsyncTCPSocket for
// it. Takes ownership of `socket`. Returns null if bind() or
// connect() fail (`socket` is destroyed in that case).
AsyncTCPSocket* AsyncTCPSocket::Create(AsyncSocket* socket,
AsyncTCPSocket* AsyncTCPSocket::Create(Socket* socket,
const SocketAddress& bind_address,
const SocketAddress& remote_address) {
return new AsyncTCPSocket(
@ -287,7 +287,7 @@ AsyncTCPSocket* AsyncTCPSocket::Create(AsyncSocket* socket,
false);
}
AsyncTCPSocket::AsyncTCPSocket(AsyncSocket* socket, bool listen)
AsyncTCPSocket::AsyncTCPSocket(Socket* socket, bool listen)
: AsyncTCPSocketBase(socket, listen, kBufSize) {}
int AsyncTCPSocket::Send(const void* pv,
@ -343,7 +343,7 @@ void AsyncTCPSocket::ProcessInput(char* data, size_t* len) {
}
}
void AsyncTCPSocket::HandleIncomingConnection(AsyncSocket* socket) {
void AsyncTCPSocket::HandleIncomingConnection(Socket* socket) {
SignalNewConnection(this, new AsyncTCPSocket(socket, false));
}

23
rtc_base/async_tcp_socket.h
View File

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

4
rtc_base/async_tcp_socket_unittest.cc
View File

@ -22,7 +22,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> {
public:
AsyncTCPSocketTest()
: vss_(new rtc::VirtualSocketServer()),
socket_(vss_->CreateAsyncSocket(SOCK_STREAM)),
socket_(vss_->CreateSocket(SOCK_STREAM)),
tcp_socket_(new AsyncTCPSocket(socket_, true)),
ready_to_send_(false) {
tcp_socket_->SignalReadyToSend.connect(this,
@ -33,7 +33,7 @@ class AsyncTCPSocketTest : public ::testing::Test, public sigslot::has_slots<> {
protected:
std::unique_ptr<VirtualSocketServer> vss_;
AsyncSocket* socket_;
Socket* socket_;
std::unique_ptr<AsyncTCPSocket> tcp_socket_;
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;
AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket,
AsyncUDPSocket* AsyncUDPSocket::Create(Socket* socket,
const SocketAddress& bind_address) {
std::unique_ptr<AsyncSocket> owned_socket(socket);
std::unique_ptr<Socket> owned_socket(socket);
if (socket->Bind(bind_address) < 0) {
RTC_LOG(LS_ERROR) << "Bind() failed with error " << socket->GetError();
return nullptr;
@ -36,14 +36,13 @@ AsyncUDPSocket* AsyncUDPSocket::Create(AsyncSocket* socket,
AsyncUDPSocket* AsyncUDPSocket::Create(SocketFactory* factory,
const SocketAddress& bind_address) {
AsyncSocket* socket =
factory->CreateAsyncSocket(bind_address.family(), SOCK_DGRAM);
Socket* socket = factory->CreateSocket(bind_address.family(), SOCK_DGRAM);
if (!socket)
return nullptr;
return Create(socket, bind_address);
}
AsyncUDPSocket::AsyncUDPSocket(AsyncSocket* socket) : socket_(socket) {
AsyncUDPSocket::AsyncUDPSocket(Socket* socket) : socket_(socket) {
size_ = BUF_SIZE;
buf_ = new char[size_];
@ -111,7 +110,7 @@ void AsyncUDPSocket::SetError(int error) {
return socket_->SetError(error);
}
void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) {
void AsyncUDPSocket::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
SocketAddress remote_addr;
@ -134,7 +133,7 @@ void AsyncUDPSocket::OnReadEvent(AsyncSocket* socket) {
(timestamp > -1 ? timestamp : TimeMicros()));
}
void AsyncUDPSocket::OnWriteEvent(AsyncSocket* socket) {
void AsyncUDPSocket::OnWriteEvent(Socket* socket) {
SignalReadyToSend(this);
}

11
rtc_base/async_udp_socket.h
View File

@ -16,7 +16,6 @@
#include <memory>
#include "rtc_base/async_packet_socket.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/socket.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/socket_factory.h"
@ -30,13 +29,13 @@ class AsyncUDPSocket : public AsyncPacketSocket {
// Binds `socket` and creates AsyncUDPSocket for it. Takes ownership
// of `socket`. Returns null if bind() fails (`socket` is destroyed
// in that case).
static AsyncUDPSocket* Create(AsyncSocket* socket,
static AsyncUDPSocket* Create(Socket* socket,
const SocketAddress& bind_address);
// Creates a new socket for sending asynchronous UDP packets using an
// asynchronous socket from the given factory.
static AsyncUDPSocket* Create(SocketFactory* factory,
const SocketAddress& bind_address);
explicit AsyncUDPSocket(AsyncSocket* socket);
explicit AsyncUDPSocket(Socket* socket);
~AsyncUDPSocket() override;
SocketAddress GetLocalAddress() const override;
@ -58,11 +57,11 @@ class AsyncUDPSocket : public AsyncPacketSocket {
private:
// Called when the underlying socket is ready to be read from.
void OnReadEvent(AsyncSocket* socket);
void OnReadEvent(Socket* socket);
// Called when the underlying socket is ready to send.
void OnWriteEvent(AsyncSocket* socket);
void OnWriteEvent(Socket* socket);
std::unique_ptr<AsyncSocket> socket_;
std::unique_ptr<Socket> socket_;
char* buf_;
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()
: pss_(new rtc::PhysicalSocketServer),
vss_(new rtc::VirtualSocketServer(pss_.get())),
socket_(vss_->CreateAsyncSocket(SOCK_DGRAM)),
socket_(vss_->CreateSocket(SOCK_DGRAM)),
udp_socket_(new AsyncUDPSocket(socket_)),
ready_to_send_(false) {
udp_socket_->SignalReadyToSend.connect(this,
@ -36,7 +36,7 @@ class AsyncUdpSocketTest : public ::testing::Test, public sigslot::has_slots<> {
protected:
std::unique_ptr<PhysicalSocketServer> pss_;
std::unique_ptr<VirtualSocketServer> vss_;
AsyncSocket* socket_;
Socket* socket_;
std::unique_ptr<AsyncUDPSocket> udp_socket_;
bool ready_to_send_;
};

14
rtc_base/firewall_socket_server.cc
View File

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

3
rtc_base/firewall_socket_server.h
View File

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

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.
class NATProxyServerSocket : public AsyncProxyServerSocket {
public:
NATProxyServerSocket(AsyncSocket* socket)
NATProxyServerSocket(Socket* socket)
: AsyncProxyServerSocket(socket, kNATEncodedIPv6AddressSize) {
BufferInput(true);
}
@ -119,7 +119,7 @@ class NATProxyServer : public ProxyServer {
: ProxyServer(int_factory, int_addr, ext_factory, ext_ip) {}
protected:
AsyncProxyServerSocket* WrapSocket(AsyncSocket* socket) override {
AsyncProxyServerSocket* WrapSocket(Socket* socket) override {
return new NATProxyServerSocket(socket);
}
};

36
rtc_base/nat_socket_factory.cc
View File

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

9
rtc_base/nat_socket_factory.h
View File

@ -17,7 +17,6 @@
#include <memory>
#include <set>
#include "rtc_base/async_socket.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/nat_server.h"
#include "rtc_base/nat_types.h"
@ -36,7 +35,7 @@ const size_t kNATEncodedIPv6AddressSize = 20U;
class NATInternalSocketFactory {
public:
virtual ~NATInternalSocketFactory() {}
virtual AsyncSocket* CreateInternalSocket(int family,
virtual Socket* CreateInternalSocket(int family,
int type,
const SocketAddress& local_addr,
SocketAddress* nat_addr) = 0;
@ -53,10 +52,9 @@ class NATSocketFactory : public SocketFactory, public NATInternalSocketFactory {
// SocketFactory implementation
Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
// NATInternalSocketFactory implementation
AsyncSocket* CreateInternalSocket(int family,
Socket* CreateInternalSocket(int family,
int type,
const SocketAddress& local_addr,
SocketAddress* nat_addr) override;
@ -148,14 +146,13 @@ class NATSocketServer : public SocketServer, public NATInternalSocketFactory {
// SocketServer implementation
Socket* CreateSocket(int family, int type) override;
AsyncSocket* CreateAsyncSocket(int family, int type) override;
void SetMessageQueue(Thread* queue) override;
bool Wait(int cms, bool process_io) override;
void WakeUp() override;
// NATInternalSocketFactory implementation
AsyncSocket* CreateInternalSocket(int family,
Socket* CreateInternalSocket(int family,
int type,
const SocketAddress& local_addr,
SocketAddress* nat_addr) override;

26
rtc_base/nat_unittest.cc
View File

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

4
rtc_base/network.cc
View File

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

2
rtc_base/network_unittest.cc
View File

@ -367,7 +367,7 @@ TEST_F(NetworkTest, DISABLED_TestCreateNetworks) {
IPAddress ip = (*it)->GetBestIP();
SocketAddress bindaddress(ip, 0);
bindaddress.SetScopeID((*it)->scope_id());
// TODO(thaloun): Use rtc::AsyncSocket once it supports IPv6.
// TODO(thaloun): Use rtc::Socket once it supports IPv6.
int fd = static_cast<int>(socket(ip.family(), SOCK_STREAM, IPPROTO_TCP));
if (fd > 0) {
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;
}
rtc::AsyncSocket* NullSocketServer::CreateAsyncSocket(int /* family */,
int /* type */) {
RTC_NOTREACHED();
return nullptr;
}
} // namespace rtc

2
rtc_base/null_socket_server.h
View File

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

28
rtc_base/openssl_adapter.cc
View File

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

15
rtc_base/openssl_adapter.h
View File

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

12
rtc_base/openssl_adapter_unittest.cc
View File

@ -15,17 +15,17 @@
#include <vector>
#include "absl/memory/memory.h"
#include "rtc_base/async_socket.h"
#include "rtc_base/gunit.h"
#include "rtc_base/socket.h"
#include "test/gmock.h"
namespace rtc {
namespace {
class MockAsyncSocket : public AsyncSocket {
class MockAsyncSocket : public Socket {
public:
virtual ~MockAsyncSocket() = default;
MOCK_METHOD(AsyncSocket*, Accept, (SocketAddress*), (override));
MOCK_METHOD(Socket*, Accept, (SocketAddress*), (override));
MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
@ -84,7 +84,7 @@ TEST(OpenSSLAdapterTest, TestTransformAlpnProtocols) {
// Verifies that SSLStart works when OpenSSLAdapter is started in standalone
// mode.
TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
AsyncSocket* async_socket = new MockAsyncSocket();
Socket* async_socket = new MockAsyncSocket();
OpenSSLAdapter adapter(async_socket);
EXPECT_EQ(adapter.StartSSL("webrtc.org"), 0);
}
@ -92,7 +92,7 @@ TEST(OpenSSLAdapterTest, TestBeginSSLBeforeConnection) {
// Verifies that the adapter factory can create new adapters.
TEST(OpenSSLAdapterFactoryTest, CreateSingleOpenSSLAdapter) {
OpenSSLAdapterFactory adapter_factory;
AsyncSocket* async_socket = new MockAsyncSocket();
Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
EXPECT_NE(simple_adapter, nullptr);
@ -107,7 +107,7 @@ TEST(OpenSSLAdapterFactoryTest, CreateWorksWithCustomVerifier) {
OpenSSLAdapterFactory adapter_factory;
adapter_factory.SetCertVerifier(cert_verifier.get());
AsyncSocket* async_socket = new MockAsyncSocket();
Socket* async_socket = new MockAsyncSocket();
auto simple_adapter = std::unique_ptr<OpenSSLAdapter>(
adapter_factory.CreateAdapter(async_socket));
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;
}
AsyncSocket::ConnState PhysicalSocket::GetState() const {
Socket::ConnState PhysicalSocket::GetState() const {
return state_;
}
@ -460,7 +460,7 @@ int PhysicalSocket::Listen(int backlog) {
return err;
}
AsyncSocket* PhysicalSocket::Accept(SocketAddress* out_addr) {
Socket* PhysicalSocket::Accept(SocketAddress* out_addr) {
// Always re-subscribe DE_ACCEPT to make sure new incoming connections will
// trigger an event even if DoAccept returns an error here.
EnableEvents(DE_ACCEPT);
@ -1083,16 +1083,6 @@ void PhysicalSocketServer::WakeUp() {
}
Socket* PhysicalSocketServer::CreateSocket(int family, int type) {
PhysicalSocket* socket = new PhysicalSocket(this);
if (socket->Create(family, type)) {
return socket;
} else {
delete socket;
return nullptr;
}
}
AsyncSocket* PhysicalSocketServer::CreateAsyncSocket(int family, int type) {
SocketDispatcher* dispatcher = new SocketDispatcher(this);
if (dispatcher->Create(family, type)) {
return dispatcher;
@ -1102,7 +1092,7 @@ AsyncSocket* PhysicalSocketServer::CreateAsyncSocket(int family, int type) {
}
}
AsyncSocket* PhysicalSocketServer::WrapSocket(SOCKET s) {
Socket* PhysicalSocketServer::WrapSocket(SOCKET s) {
SocketDispatcher* dispatcher = new SocketDispatcher(s, this);
if (dispatcher->Initialize()) {
return dispatcher;

7
rtc_base/physical_socket_server.h
View File

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

41
rtc_base/physical_socket_server_unittest.cc
View File

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

32
rtc_base/proxy_server.cc
View File

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

32
rtc_base/proxy_server.h
View File

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

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.
TEST_F(ProxyTest, TestSocks5Connect) {
rtc::AsyncSocket* socket =
ss()->CreateAsyncSocket(kSocksProxyIntAddr.family(), SOCK_STREAM);
rtc::Socket* socket =
ss()->CreateSocket(kSocksProxyIntAddr.family(), SOCK_STREAM);
rtc::AsyncSocksProxySocket* proxy_socket = new rtc::AsyncSocksProxySocket(
socket, kSocksProxyIntAddr, "", rtc::CryptString());
// TODO: IPv6-ize these tests when proxy supports IPv6.

6
rtc_base/server_socket_adapters.cc
View File

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

6
rtc_base/server_socket_adapters.h
View File

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

17
rtc_base/socket.h
View File

@ -25,8 +25,10 @@
#include "rtc_base/win32.h"
#endif
#include "absl/base/attributes.h"
#include "rtc_base/constructor_magic.h"
#include "rtc_base/socket_address.h"
#include "rtc_base/third_party/sigslot/sigslot.h"
// Rather than converting errors into a private namespace,
// Reuse the POSIX socket api errors. Note this depends on
@ -124,6 +126,17 @@ class Socket {
virtual int GetOption(Option opt, int* value) = 0;
virtual int SetOption(Option opt, int value) = 0;
// SignalReadEvent and SignalWriteEvent use multi_threaded_local to allow
// access concurrently from different thread.
// For example SignalReadEvent::connect will be called in AsyncUDPSocket ctor
// but at the same time the SocketDispatcher may be signaling the read event.
// ready to read
sigslot::signal1<Socket*, sigslot::multi_threaded_local> SignalReadEvent;
// ready to write
sigslot::signal1<Socket*, sigslot::multi_threaded_local> SignalWriteEvent;
sigslot::signal1<Socket*> SignalConnectEvent; // connected
sigslot::signal2<Socket*, int> SignalCloseEvent; // closed
protected:
Socket() {}
@ -131,6 +144,10 @@ class Socket {
RTC_DISALLOW_COPY_AND_ASSIGN(Socket);
};
// TODO(bugs.webrtc.org/13065): Old alias, delete ASAP, when downstream code is
// updated.
using AsyncSocket ABSL_DEPRECATED("bugs.webrtc.org/13065") = Socket;
} // namespace rtc
#endif // RTC_BASE_SOCKET_H_

18
rtc_base/socket_adapters.cc
View File

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

18
rtc_base/socket_adapters.h
View File

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

11
rtc_base/socket_factory.h
View File

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

16
rtc_base/socket_stream.cc
View File

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

20
rtc_base/socket_stream.h
View File

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

222
rtc_base/socket_unittest.cc
View File

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

2
rtc_base/ssl_adapter.cc
View File

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

33
rtc_base/ssl_adapter_unittest.cc
View File

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

10
rtc_base/test_client_unittest.cc
View File

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

4
rtc_base/test_echo_server.cc
View File

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

8
rtc_base/test_echo_server.h
View File

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

26
rtc_base/test_utils.h
View File

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

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

4
rtc_base/virtual_socket_server.cc
View File

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

3
rtc_base/virtual_socket_server.h
View File

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

146
rtc_base/virtual_socket_unittest.cc
View File

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

4
rtc_base/win32_socket_server.cc
View File

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

6
rtc_base/win32_socket_server.h
View File

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

2
test/network/BUILD.gn
View File

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

16
test/network/fake_network_socket_server.cc
View File

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

3
test/network/fake_network_socket_server.h
View File

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

30
test/network/network_emulation_unittest.cc
View File

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

5
test/run_loop.cc
View File

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

1
test/run_loop.h
View File

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

4
test/time_controller/simulated_thread.cc
View File

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