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