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