zqz/platform-external-webrtc
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
Download Patch File Download Diff File Expand all files Collapse all files

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);