Revert "Take out listen support from AsyncPacketSocket"
This reverts commit b141c162ee2ef88a7498ba8cb8bc852287f93ad2.
Reason for revert: Breaking WebRTC rolls. See https://ci.chromium.org/ui/b/8832847811929676465 for an example failed build.
Original change's description:
> Take out listen support from AsyncPacketSocket
>
> Moved to new interface class AsyncListenSocket.
>
> Bug: webrtc:13065
> Change-Id: Ib96ce154ba19979360ecd8144981d947ff5b8b18
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/232607
> Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
> Reviewed-by: Harald Alvestrand <hta@webrtc.org>
> Commit-Queue: Niels Moller <nisse@webrtc.org>
> Cr-Commit-Position: refs/heads/main@{#35234}
# Not skipping CQ checks because original CL landed > 1 day ago.
Bug: webrtc:13065
Change-Id: Id5d5b35cb21704ca4e3006caf1636906df062609
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/235824
Reviewed-by: Evan Shrubsole <eshr@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#35249}
diff --git a/p2p/base/async_stun_tcp_socket.cc b/p2p/base/async_stun_tcp_socket.cc
index 5f8f072..64c19c4 100644
--- a/p2p/base/async_stun_tcp_socket.cc
+++ b/p2p/base/async_stun_tcp_socket.cc
@@ -49,7 +49,7 @@
}
AsyncStunTCPSocket::AsyncStunTCPSocket(rtc::Socket* socket)
- : rtc::AsyncTCPSocketBase(socket, kBufSize) {}
+ : rtc::AsyncTCPSocketBase(socket, /*listen=*/false, kBufSize) {}
int AsyncStunTCPSocket::Send(const void* pv,
size_t cb,
@@ -125,6 +125,10 @@
}
}
+void AsyncStunTCPSocket::HandleIncomingConnection(rtc::Socket* socket) {
+ SignalNewConnection(this, new AsyncStunTCPSocket(socket));
+}
+
size_t AsyncStunTCPSocket::GetExpectedLength(const void* data,
size_t len,
int* pad_bytes) {
diff --git a/p2p/base/async_stun_tcp_socket.h b/p2p/base/async_stun_tcp_socket.h
index eb4eef7..2dc9613 100644
--- a/p2p/base/async_stun_tcp_socket.h
+++ b/p2p/base/async_stun_tcp_socket.h
@@ -36,6 +36,7 @@
size_t cb,
const rtc::PacketOptions& options) override;
void ProcessInput(char* data, size_t* len) override;
+ void HandleIncomingConnection(rtc::Socket* socket) override;
private:
// This method returns the message hdr + length written in the header.
diff --git a/p2p/base/async_stun_tcp_socket_unittest.cc b/p2p/base/async_stun_tcp_socket_unittest.cc
index 72d6a7f..c774b52 100644
--- a/p2p/base/async_stun_tcp_socket_unittest.cc
+++ b/p2p/base/async_stun_tcp_socket_unittest.cc
@@ -16,7 +16,6 @@
#include <list>
#include <memory>
#include <string>
-#include <utility>
#include "absl/memory/memory.h"
#include "rtc_base/network/sent_packet.h"
@@ -60,10 +59,10 @@
static const rtc::SocketAddress kClientAddr("11.11.11.11", 0);
static const rtc::SocketAddress kServerAddr("22.22.22.22", 0);
-class AsyncStunServerTCPSocket : public rtc::AsyncTcpListenSocket {
+class AsyncStunServerTCPSocket : public rtc::AsyncTCPSocket {
public:
- explicit AsyncStunServerTCPSocket(std::unique_ptr<rtc::Socket> socket)
- : AsyncTcpListenSocket(std::move(socket)) {}
+ explicit AsyncStunServerTCPSocket(rtc::Socket* socket)
+ : AsyncTCPSocket(socket, true) {}
void HandleIncomingConnection(rtc::Socket* socket) override {
SignalNewConnection(this, new AsyncStunTCPSocket(socket));
}
@@ -78,11 +77,9 @@
virtual void SetUp() { CreateSockets(); }
void CreateSockets() {
- std::unique_ptr<rtc::Socket> server =
- absl::WrapUnique(vss_->CreateSocket(kServerAddr.family(), SOCK_STREAM));
+ rtc::Socket* server = vss_->CreateSocket(kServerAddr.family(), SOCK_STREAM);
server->Bind(kServerAddr);
- listen_socket_ =
- std::make_unique<AsyncStunServerTCPSocket>(std::move(server));
+ listen_socket_ = std::make_unique<AsyncStunServerTCPSocket>(server);
listen_socket_->SignalNewConnection.connect(
this, &AsyncStunTCPSocketTest::OnNewConnection);
diff --git a/p2p/base/basic_packet_socket_factory.cc b/p2p/base/basic_packet_socket_factory.cc
index e0f21fe..901e3b9 100644
--- a/p2p/base/basic_packet_socket_factory.cc
+++ b/p2p/base/basic_packet_socket_factory.cc
@@ -14,7 +14,6 @@
#include <string>
-#include "absl/memory/memory.h"
#include "api/async_dns_resolver.h"
#include "api/wrapping_async_dns_resolver.h"
#include "p2p/base/async_stun_tcp_socket.h"
@@ -90,7 +89,7 @@
RTC_CHECK(!(opts & PacketSocketFactory::OPT_STUN));
- return new AsyncTcpListenSocket(absl::WrapUnique(socket));
+ return new AsyncTCPSocket(socket, true);
}
AsyncPacketSocket* BasicPacketSocketFactory::CreateClientTcpSocket(
@@ -184,7 +183,7 @@
if (tcp_options.opts & PacketSocketFactory::OPT_STUN) {
tcp_socket = new cricket::AsyncStunTCPSocket(socket);
} else {
- tcp_socket = new AsyncTCPSocket(socket);
+ tcp_socket = new AsyncTCPSocket(socket, false);
}
return tcp_socket;
diff --git a/p2p/base/port_unittest.cc b/p2p/base/port_unittest.cc
index 5bcc186..52153d8 100644
--- a/p2p/base/port_unittest.cc
+++ b/p2p/base/port_unittest.cc
@@ -1060,24 +1060,6 @@
State state_;
};
-class FakeAsyncListenSocket : public AsyncListenSocket {
- public:
- // Returns current local address. Address may be set to NULL if the
- // socket is not bound yet (GetState() returns STATE_BINDING).
- virtual SocketAddress GetLocalAddress() const { return local_address_; }
- void Bind(const SocketAddress& address) {
- local_address_ = address;
- state_ = State::kBound;
- }
- virtual int GetOption(Socket::Option opt, int* value) { return 0; }
- virtual int SetOption(Socket::Option opt, int value) { return 0; }
- virtual State GetState() const { return state_; }
-
- private:
- SocketAddress local_address_;
- State state_ = State::kClosed;
-};
-
// Local -> XXXX
TEST_F(PortTest, TestLocalToLocal) {
TestLocalToLocal();
@@ -1526,8 +1508,8 @@
}
TEST_F(PortTest, TestDisableInterfaceOfTcpPort) {
- FakeAsyncListenSocket* lsocket = new FakeAsyncListenSocket();
- FakeAsyncListenSocket* rsocket = new FakeAsyncListenSocket();
+ FakeAsyncPacketSocket* lsocket = new FakeAsyncPacketSocket();
+ FakeAsyncPacketSocket* rsocket = new FakeAsyncPacketSocket();
FakePacketSocketFactory socket_factory;
socket_factory.set_next_server_tcp_socket(lsocket);
@@ -1536,8 +1518,10 @@
socket_factory.set_next_server_tcp_socket(rsocket);
auto rport = CreateTcpPort(kLocalAddr2, &socket_factory);
- lsocket->Bind(kLocalAddr1);
- rsocket->Bind(kLocalAddr2);
+ lsocket->set_state(AsyncPacketSocket::STATE_BOUND);
+ lsocket->local_address_ = kLocalAddr1;
+ rsocket->set_state(AsyncPacketSocket::STATE_BOUND);
+ rsocket->local_address_ = kLocalAddr2;
lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
lport->SetIceTiebreaker(kTiebreaker1);
@@ -1576,17 +1560,17 @@
SocketAddress("192.168.1.3", 0), SocketAddress("192.168.1.4", 0),
SocketAddress("2001:db8::1", 0), SocketAddress("2001:db8::2", 0)};
for (int i = 0; i < 4; i++) {
+ FakeAsyncPacketSocket* socket = new FakeAsyncPacketSocket();
if (type == SOCK_DGRAM) {
- FakeAsyncPacketSocket* socket = new FakeAsyncPacketSocket();
factory.set_next_udp_socket(socket);
ports[i] = CreateUdpPort(addresses[i], &factory);
socket->set_state(AsyncPacketSocket::STATE_BINDING);
socket->SignalAddressReady(socket, addresses[i]);
} else if (type == SOCK_STREAM) {
- FakeAsyncListenSocket* socket = new FakeAsyncListenSocket();
factory.set_next_server_tcp_socket(socket);
ports[i] = CreateTcpPort(addresses[i], &factory);
- socket->Bind(addresses[i]);
+ socket->set_state(AsyncPacketSocket::STATE_BOUND);
+ socket->local_address_ = addresses[i];
}
ports[i]->PrepareAddress();
}
diff --git a/p2p/base/tcp_port.cc b/p2p/base/tcp_port.cc
index ea805e5..f9dd185 100644
--- a/p2p/base/tcp_port.cc
+++ b/p2p/base/tcp_port.cc
@@ -169,11 +169,13 @@
// Socket may be in the CLOSED state if Listen()
// failed, we still want to add the socket address.
RTC_LOG(LS_VERBOSE) << "Preparing TCP address, current state: "
- << static_cast<int>(listen_socket_->GetState());
- AddAddress(listen_socket_->GetLocalAddress(),
- listen_socket_->GetLocalAddress(), rtc::SocketAddress(),
- TCP_PROTOCOL_NAME, "", TCPTYPE_PASSIVE_STR, LOCAL_PORT_TYPE,
- ICE_TYPE_PREFERENCE_HOST_TCP, 0, "", true);
+ << listen_socket_->GetState();
+ if (listen_socket_->GetState() == rtc::AsyncPacketSocket::STATE_BOUND ||
+ listen_socket_->GetState() == rtc::AsyncPacketSocket::STATE_CLOSED)
+ AddAddress(listen_socket_->GetLocalAddress(),
+ listen_socket_->GetLocalAddress(), rtc::SocketAddress(),
+ TCP_PROTOCOL_NAME, "", TCPTYPE_PASSIVE_STR, LOCAL_PORT_TYPE,
+ ICE_TYPE_PREFERENCE_HOST_TCP, 0, "", true);
} else {
RTC_LOG(LS_INFO) << ToString()
<< ": Not listening due to firewall restrictions.";
diff --git a/rtc_base/async_packet_socket.h b/rtc_base/async_packet_socket.h
index ce36dd6..8362604 100644
--- a/rtc_base/async_packet_socket.h
+++ b/rtc_base/async_packet_socket.h
@@ -128,31 +128,17 @@
// CONNECTED to CLOSED.
sigslot::signal2<AsyncPacketSocket*, int> SignalClose;
+ // Used only for listening TCP sockets.
+ sigslot::signal2<AsyncPacketSocket*, AsyncPacketSocket*> SignalNewConnection;
+
private:
RTC_DISALLOW_COPY_AND_ASSIGN(AsyncPacketSocket);
};
-// Listen socket, producing an AsyncPacketSocket when a peer connects.
-class RTC_EXPORT AsyncListenSocket : public sigslot::has_slots<> {
- public:
- enum class State {
- kClosed,
- kBound,
- };
-
- // Returns current state of the socket.
- virtual State GetState() const = 0;
-
- // Returns current local address. Address may be set to null if the
- // socket is not bound yet (GetState() returns kBinding).
- virtual SocketAddress GetLocalAddress() const = 0;
-
- // Get/set options.
- virtual int GetOption(Socket::Option opt, int* value) = 0;
- virtual int SetOption(Socket::Option opt, int value) = 0;
-
- sigslot::signal2<AsyncListenSocket*, AsyncPacketSocket*> SignalNewConnection;
-};
+// TODO(bugs.webrtc.org/13065): Intended to be broken out into a separate class,
+// after downstream has adapted the new name. The main feature to move from
+// AsyncPacketSocket to AsyncListenSocket is the SignalNewConnection.
+using AsyncListenSocket = AsyncPacketSocket;
void CopySocketInformationToPacketInfo(size_t packet_size_bytes,
const AsyncPacketSocket& socket_from,
diff --git a/rtc_base/async_tcp_socket.cc b/rtc_base/async_tcp_socket.cc
index 37a1052..76efb6d 100644
--- a/rtc_base/async_tcp_socket.cc
+++ b/rtc_base/async_tcp_socket.cc
@@ -62,11 +62,16 @@
}
AsyncTCPSocketBase::AsyncTCPSocketBase(Socket* socket,
+ bool listen,
size_t max_packet_size)
: socket_(socket),
+ listen_(listen),
max_insize_(max_packet_size),
max_outsize_(max_packet_size) {
- inbuf_.EnsureCapacity(kMinimumRecvSize);
+ if (!listen_) {
+ // Listening sockets don't send/receive data, so they don't need buffers.
+ inbuf_.EnsureCapacity(kMinimumRecvSize);
+ }
RTC_DCHECK(socket_.get() != nullptr);
socket_->SignalConnectEvent.connect(this,
@@ -74,6 +79,12 @@
socket_->SignalReadEvent.connect(this, &AsyncTCPSocketBase::OnReadEvent);
socket_->SignalWriteEvent.connect(this, &AsyncTCPSocketBase::OnWriteEvent);
socket_->SignalCloseEvent.connect(this, &AsyncTCPSocketBase::OnCloseEvent);
+
+ if (listen_) {
+ if (socket_->Listen(kListenBacklog) < 0) {
+ RTC_LOG(LS_ERROR) << "Listen() failed with error " << socket_->GetError();
+ }
+ }
}
AsyncTCPSocketBase::~AsyncTCPSocketBase() {}
@@ -95,7 +106,11 @@
case Socket::CS_CLOSED:
return STATE_CLOSED;
case Socket::CS_CONNECTING:
- return STATE_CONNECTING;
+ if (listen_) {
+ return STATE_BOUND;
+ } else {
+ return STATE_CONNECTING;
+ }
case Socket::CS_CONNECTED:
return STATE_CONNECTED;
default:
@@ -134,6 +149,7 @@
}
int AsyncTCPSocketBase::FlushOutBuffer() {
+ RTC_DCHECK(!listen_);
RTC_DCHECK_GT(outbuf_.size(), 0);
rtc::ArrayView<uint8_t> view = outbuf_;
int res;
@@ -173,6 +189,7 @@
void AsyncTCPSocketBase::AppendToOutBuffer(const void* pv, size_t cb) {
RTC_DCHECK(outbuf_.size() + cb <= max_outsize_);
+ RTC_DCHECK(!listen_);
outbuf_.AppendData(static_cast<const uint8_t*>(pv), cb);
}
@@ -183,44 +200,62 @@
void AsyncTCPSocketBase::OnReadEvent(Socket* socket) {
RTC_DCHECK(socket_.get() == socket);
- size_t total_recv = 0;
- while (true) {
- size_t free_size = inbuf_.capacity() - inbuf_.size();
- if (free_size < kMinimumRecvSize && inbuf_.capacity() < max_insize_) {
- inbuf_.EnsureCapacity(std::min(max_insize_, inbuf_.capacity() * 2));
- free_size = inbuf_.capacity() - inbuf_.size();
+ if (listen_) {
+ rtc::SocketAddress address;
+ rtc::Socket* new_socket = socket->Accept(&address);
+ if (!new_socket) {
+ // TODO(stefan): Do something better like forwarding the error
+ // to the user.
+ RTC_LOG(LS_ERROR) << "TCP accept failed with error "
+ << socket_->GetError();
+ return;
}
- int len = socket_->Recv(inbuf_.data() + inbuf_.size(), free_size, nullptr);
- if (len < 0) {
- // TODO(stefan): Do something better like forwarding the error to the
- // user.
- if (!socket_->IsBlocking()) {
- RTC_LOG(LS_ERROR) << "Recv() returned error: " << socket_->GetError();
- }
- break;
- }
+ HandleIncomingConnection(new_socket);
- total_recv += len;
- inbuf_.SetSize(inbuf_.size() + len);
- if (!len || static_cast<size_t>(len) < free_size) {
- break;
- }
- }
-
- if (!total_recv) {
- return;
- }
-
- size_t size = inbuf_.size();
- ProcessInput(inbuf_.data<char>(), &size);
-
- if (size > inbuf_.size()) {
- RTC_LOG(LS_ERROR) << "input buffer overflow";
- RTC_NOTREACHED();
- inbuf_.Clear();
+ // Prime a read event in case data is waiting.
+ new_socket->SignalReadEvent(new_socket);
} else {
- inbuf_.SetSize(size);
+ size_t total_recv = 0;
+ while (true) {
+ size_t free_size = inbuf_.capacity() - inbuf_.size();
+ if (free_size < kMinimumRecvSize && inbuf_.capacity() < max_insize_) {
+ inbuf_.EnsureCapacity(std::min(max_insize_, inbuf_.capacity() * 2));
+ free_size = inbuf_.capacity() - inbuf_.size();
+ }
+
+ int len =
+ socket_->Recv(inbuf_.data() + inbuf_.size(), free_size, nullptr);
+ if (len < 0) {
+ // TODO(stefan): Do something better like forwarding the error to the
+ // user.
+ if (!socket_->IsBlocking()) {
+ RTC_LOG(LS_ERROR) << "Recv() returned error: " << socket_->GetError();
+ }
+ break;
+ }
+
+ total_recv += len;
+ inbuf_.SetSize(inbuf_.size() + len);
+ if (!len || static_cast<size_t>(len) < free_size) {
+ break;
+ }
+ }
+
+ if (!total_recv) {
+ return;
+ }
+
+ size_t size = inbuf_.size();
+ ProcessInput(inbuf_.data<char>(), &size);
+
+ if (size > inbuf_.size()) {
+ RTC_LOG(LS_ERROR) << "input buffer overflow";
+ RTC_NOTREACHED();
+ inbuf_.Clear();
+ } else {
+ inbuf_.SetSize(size);
+ }
}
}
@@ -248,11 +283,12 @@
const SocketAddress& bind_address,
const SocketAddress& remote_address) {
return new AsyncTCPSocket(
- AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address));
+ AsyncTCPSocketBase::ConnectSocket(socket, bind_address, remote_address),
+ false);
}
-AsyncTCPSocket::AsyncTCPSocket(Socket* socket)
- : AsyncTCPSocketBase(socket, kBufSize) {}
+AsyncTCPSocket::AsyncTCPSocket(Socket* socket, bool listen)
+ : AsyncTCPSocketBase(socket, listen, kBufSize) {}
int AsyncTCPSocket::Send(const void* pv,
size_t cb,
@@ -307,59 +343,8 @@
}
}
-AsyncTcpListenSocket::AsyncTcpListenSocket(std::unique_ptr<Socket> socket)
- : socket_(std::move(socket)) {
- RTC_DCHECK(socket_.get() != nullptr);
- socket_->SignalReadEvent.connect(this, &AsyncTcpListenSocket::OnReadEvent);
- if (socket_->Listen(kListenBacklog) < 0) {
- RTC_LOG(LS_ERROR) << "Listen() failed with error " << socket_->GetError();
- }
-}
-
-AsyncTcpListenSocket::State AsyncTcpListenSocket::GetState() const {
- switch (socket_->GetState()) {
- case Socket::CS_CLOSED:
- return State::kClosed;
- case Socket::CS_CONNECTING:
- return State::kBound;
- default:
- RTC_NOTREACHED();
- return State::kClosed;
- }
-}
-
-SocketAddress AsyncTcpListenSocket::GetLocalAddress() const {
- return socket_->GetLocalAddress();
-}
-
-int AsyncTcpListenSocket::GetOption(Socket::Option opt, int* value) {
- return socket_->GetOption(opt, value);
-}
-
-int AsyncTcpListenSocket::SetOption(Socket::Option opt, int value) {
- return socket_->SetOption(opt, value);
-}
-
-void AsyncTcpListenSocket::OnReadEvent(Socket* socket) {
- RTC_DCHECK(socket_.get() == socket);
-
- rtc::SocketAddress address;
- rtc::Socket* new_socket = socket->Accept(&address);
- if (!new_socket) {
- // TODO(stefan): Do something better like forwarding the error
- // to the user.
- RTC_LOG(LS_ERROR) << "TCP accept failed with error " << socket_->GetError();
- return;
- }
-
- HandleIncomingConnection(new_socket);
-
- // Prime a read event in case data is waiting.
- new_socket->SignalReadEvent(new_socket);
-}
-
-void AsyncTcpListenSocket::HandleIncomingConnection(Socket* socket) {
- SignalNewConnection(this, new AsyncTCPSocket(socket));
+void AsyncTCPSocket::HandleIncomingConnection(Socket* socket) {
+ SignalNewConnection(this, new AsyncTCPSocket(socket, false));
}
} // namespace rtc
diff --git a/rtc_base/async_tcp_socket.h b/rtc_base/async_tcp_socket.h
index 901e5cf..ddf9a43 100644
--- a/rtc_base/async_tcp_socket.h
+++ b/rtc_base/async_tcp_socket.h
@@ -28,7 +28,7 @@
// buffer them in user space.
class AsyncTCPSocketBase : public AsyncPacketSocket {
public:
- AsyncTCPSocketBase(Socket* socket, 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.
@@ -36,6 +36,8 @@
size_t cb,
const rtc::PacketOptions& options) override = 0;
virtual void ProcessInput(char* data, size_t* len) = 0;
+ // Signals incoming connection.
+ virtual void HandleIncomingConnection(Socket* socket) = 0;
SocketAddress GetLocalAddress() const override;
SocketAddress GetRemoteAddress() const override;
@@ -74,6 +76,7 @@
void OnCloseEvent(Socket* socket, int error);
std::unique_ptr<Socket> socket_;
+ bool listen_;
Buffer inbuf_;
Buffer outbuf_;
size_t max_insize_;
@@ -90,37 +93,19 @@
static AsyncTCPSocket* Create(Socket* socket,
const SocketAddress& bind_address,
const SocketAddress& remote_address);
- explicit AsyncTCPSocket(Socket* socket);
+ 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(Socket* socket) override;
private:
RTC_DISALLOW_COPY_AND_ASSIGN(AsyncTCPSocket);
};
-class AsyncTcpListenSocket : public AsyncListenSocket {
- public:
- explicit AsyncTcpListenSocket(std::unique_ptr<Socket> socket);
-
- State GetState() const override;
- SocketAddress GetLocalAddress() const override;
-
- int GetOption(Socket::Option opt, int* value) override;
- int SetOption(Socket::Option opt, int value) override;
-
- virtual void HandleIncomingConnection(rtc::Socket* socket);
-
- private:
- // Called by the underlying socket
- void OnReadEvent(Socket* socket);
-
- std::unique_ptr<Socket> socket_;
-};
-
} // namespace rtc
#endif // RTC_BASE_ASYNC_TCP_SOCKET_H_
diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc
index 2e41684..4b7a117 100644
--- a/rtc_base/nat_unittest.cc
+++ b/rtc_base/nat_unittest.cc
@@ -56,7 +56,7 @@
}
TestClient* CreateTCPTestClient(Socket* socket) {
- return new TestClient(std::make_unique<AsyncTCPSocket>(socket));
+ return new TestClient(std::make_unique<AsyncTCPSocket>(socket, false));
}
// Tests that when sending from internal_addr to external_addrs through the
diff --git a/rtc_base/test_echo_server.h b/rtc_base/test_echo_server.h
index a061ed0..6fdfc24 100644
--- a/rtc_base/test_echo_server.h
+++ b/rtc_base/test_echo_server.h
@@ -41,7 +41,7 @@
void OnAccept(Socket* socket) {
Socket* raw_socket = socket->Accept(nullptr);
if (raw_socket) {
- AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket);
+ AsyncTCPSocket* packet_socket = new AsyncTCPSocket(raw_socket, false);
packet_socket->SignalReadPacket.connect(this, &TestEchoServer::OnPacket);
packet_socket->SignalClose.connect(this, &TestEchoServer::OnClose);
client_sockets_.push_back(packet_socket);
