Use absl::make_unique and absl::WrapUnique directly
Instead of going through our wrappers in ptr_util.h.
This CL was generated by the following script:
git grep -l ptr_util | xargs perl -pi -e 's,#include "rtc_base/ptr_util.h",#include "absl/memory/memory.h",'
git grep -l MakeUnique | xargs perl -pi -e 's,\b(rtc::)?MakeUnique\b,absl::make_unique,g'
git grep -l WrapUnique | xargs perl -pi -e 's,\b(rtc::)?WrapUnique\b,absl::WrapUnique,g'
git checkout -- rtc_base/ptr_util{.h,_unittest.cc}
git cl format
Followed by manually adding dependencies on
//third_party/abseil-cpp/absl/memory until `gn check` stopped
complaining.
Bug: webrtc:9473
Change-Id: I89ccd363f070479b8c431eb2c3d404a46eaacc1c
Reviewed-on: https://webrtc-review.googlesource.com/86600
Commit-Queue: Karl Wiberg <kwiberg@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23850}diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index 716d0b2..533eed8 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -533,6 +533,7 @@
deps = [
":macromagic",
":ptr_util",
+ "//third_party/abseil-cpp/absl/memory",
]
}
@@ -727,6 +728,7 @@
":stringutils",
"..:webrtc_common",
"../api:array_view",
+ "//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
public_deps = [
@@ -1036,6 +1038,7 @@
"../test:field_trial",
"../test:test_support",
"system:fallthrough",
+ "//third_party/abseil-cpp/absl/memory",
]
public_deps = [
"//testing/gtest",
@@ -1100,6 +1103,7 @@
"../test:fileutils",
"../test:test_support",
"//testing/gtest",
+ "//third_party/abseil-cpp/absl/memory",
]
if (is_win) {
sources += [ "win32socketserver_unittest.cc" ]
@@ -1178,6 +1182,7 @@
"../test:fileutils",
"../test:test_support",
"memory:unittests",
+ "//third_party/abseil-cpp/absl/memory",
]
}
@@ -1303,6 +1308,7 @@
"../api:array_view",
"../test:fileutils",
"../test:test_support",
+ "//third_party/abseil-cpp/absl/memory",
"//third_party/abseil-cpp/absl/types:optional",
]
public_deps = [
diff --git a/rtc_base/fakesslidentity.cc b/rtc_base/fakesslidentity.cc
index 825c89b..80a3e78 100644
--- a/rtc_base/fakesslidentity.cc
+++ b/rtc_base/fakesslidentity.cc
@@ -14,9 +14,9 @@
#include <string>
#include <utility>
+#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
#include "rtc_base/messagedigest.h"
-#include "rtc_base/ptr_util.h"
namespace rtc {
@@ -77,13 +77,13 @@
FakeSSLIdentity::FakeSSLIdentity(const std::vector<std::string>& pem_strings) {
std::vector<std::unique_ptr<SSLCertificate>> certs;
for (const std::string& pem_string : pem_strings) {
- certs.push_back(MakeUnique<FakeSSLCertificate>(pem_string));
+ certs.push_back(absl::make_unique<FakeSSLCertificate>(pem_string));
}
- cert_chain_ = MakeUnique<SSLCertChain>(std::move(certs));
+ cert_chain_ = absl::make_unique<SSLCertChain>(std::move(certs));
}
FakeSSLIdentity::FakeSSLIdentity(const FakeSSLCertificate& cert)
- : cert_chain_(MakeUnique<SSLCertChain>(&cert)) {}
+ : cert_chain_(absl::make_unique<SSLCertChain>(&cert)) {}
FakeSSLIdentity::FakeSSLIdentity(const FakeSSLIdentity& o)
: cert_chain_(o.cert_chain_->UniqueCopy()) {}
diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc
index e860f52..ee94427 100644
--- a/rtc_base/nat_unittest.cc
+++ b/rtc_base/nat_unittest.cc
@@ -12,6 +12,7 @@
#include <memory>
#include <string>
+#include "absl/memory/memory.h"
#include "rtc_base/asynctcpsocket.h"
#include "rtc_base/gunit.h"
#include "rtc_base/logging.h"
@@ -20,7 +21,6 @@
#include "rtc_base/nethelpers.h"
#include "rtc_base/network.h"
#include "rtc_base/physicalsocketserver.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/testclient.h"
#include "rtc_base/virtualsocketserver.h"
@@ -37,11 +37,11 @@
TestClient* CreateTestClient(SocketFactory* factory,
const SocketAddress& local_addr) {
return new TestClient(
- WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
+ absl::WrapUnique(AsyncUDPSocket::Create(factory, local_addr)));
}
TestClient* CreateTCPTestClient(AsyncSocket* socket) {
- return new TestClient(MakeUnique<AsyncTCPSocket>(socket, false));
+ return new TestClient(absl::make_unique<AsyncTCPSocket>(socket, false));
}
// Tests that when sending from internal_addr to external_addrs through the
diff --git a/rtc_base/openssladapter.cc b/rtc_base/openssladapter.cc
index 9d6c7d1..05de6d0 100644
--- a/rtc_base/openssladapter.cc
+++ b/rtc_base/openssladapter.cc
@@ -988,7 +988,8 @@
return nullptr;
}
// The OpenSSLSessionCache will upref the ssl_ctx.
- ssl_session_cache_ = MakeUnique<OpenSSLSessionCache>(ssl_mode_, ssl_ctx);
+ ssl_session_cache_ =
+ absl::make_unique<OpenSSLSessionCache>(ssl_mode_, ssl_ctx);
SSL_CTX_free(ssl_ctx);
}
return new OpenSSLAdapter(socket, ssl_session_cache_.get(),
diff --git a/rtc_base/openssladapter.h b/rtc_base/openssladapter.h
index 986f0f8..50a7c08 100644
--- a/rtc_base/openssladapter.h
+++ b/rtc_base/openssladapter.h
@@ -18,13 +18,13 @@
#include <string>
#include <vector>
+#include "absl/memory/memory.h"
#include "rtc_base/buffer.h"
#include "rtc_base/messagehandler.h"
#include "rtc_base/messagequeue.h"
#include "rtc_base/opensslcertificate.h"
#include "rtc_base/opensslidentity.h"
#include "rtc_base/opensslsessioncache.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/ssladapter.h"
namespace rtc {
diff --git a/rtc_base/openssladapter_unittest.cc b/rtc_base/openssladapter_unittest.cc
index d6f34b0..4db00e5 100644
--- a/rtc_base/openssladapter_unittest.cc
+++ b/rtc_base/openssladapter_unittest.cc
@@ -12,10 +12,10 @@
#include <string>
#include <vector>
+#include "absl/memory/memory.h"
#include "rtc_base/asyncsocket.h"
#include "rtc_base/gunit.h"
#include "rtc_base/openssladapter.h"
-#include "rtc_base/ptr_util.h"
#include "test/gmock.h"
namespace rtc {
diff --git a/rtc_base/opensslcertificate.cc b/rtc_base/opensslcertificate.cc
index bdcf694..15fc3038 100644
--- a/rtc_base/opensslcertificate.cc
+++ b/rtc_base/opensslcertificate.cc
@@ -26,6 +26,7 @@
#include <openssl/pem.h>
#include <openssl/rsa.h>
+#include "absl/memory/memory.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/checks.h"
#include "rtc_base/helpers.h"
@@ -35,7 +36,6 @@
#include "rtc_base/openssldigest.h"
#include "rtc_base/opensslidentity.h"
#include "rtc_base/opensslutility.h"
-#include "rtc_base/ptr_util.h"
#ifdef WEBRTC_BUILT_IN_SSL_ROOT_CERTIFICATES
#include "rtc_base/sslroots.h"
#endif
diff --git a/rtc_base/opensslidentity.cc b/rtc_base/opensslidentity.cc
index 8ae4dbe..a8c6919 100644
--- a/rtc_base/opensslidentity.cc
+++ b/rtc_base/opensslidentity.cc
@@ -26,6 +26,7 @@
#include <openssl/pem.h>
#include <openssl/rsa.h>
+#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
#include "rtc_base/helpers.h"
#include "rtc_base/logging.h"
@@ -33,7 +34,6 @@
#include "rtc_base/openssl.h"
#include "rtc_base/openssldigest.h"
#include "rtc_base/opensslutility.h"
-#include "rtc_base/ptr_util.h"
namespace rtc {
@@ -303,7 +303,7 @@
}
return new OpenSSLIdentity(std::move(key_pair),
- MakeUnique<SSLCertChain>(std::move(certs)));
+ absl::make_unique<SSLCertChain>(std::move(certs)));
}
const OpenSSLCertificate& OpenSSLIdentity::certificate() const {
@@ -315,8 +315,8 @@
}
OpenSSLIdentity* OpenSSLIdentity::GetReference() const {
- return new OpenSSLIdentity(WrapUnique(key_pair_->GetReference()),
- WrapUnique(cert_chain_->Copy()));
+ return new OpenSSLIdentity(absl::WrapUnique(key_pair_->GetReference()),
+ absl::WrapUnique(cert_chain_->Copy()));
}
bool OpenSSLIdentity::ConfigureIdentity(SSL_CTX* ctx) {
diff --git a/rtc_base/signalthread.cc b/rtc_base/signalthread.cc
index 4ab1b5c..58f8761 100644
--- a/rtc_base/signalthread.cc
+++ b/rtc_base/signalthread.cc
@@ -10,8 +10,8 @@
#include "rtc_base/signalthread.h"
+#include "absl/memory/memory.h"
#include "rtc_base/checks.h"
-#include "rtc_base/ptr_util.h"
namespace rtc {
@@ -123,7 +123,7 @@
}
SignalThread::Worker::Worker(SignalThread* parent)
- : Thread(MakeUnique<NullSocketServer>(), /*do_init=*/false),
+ : Thread(absl::make_unique<NullSocketServer>(), /*do_init=*/false),
parent_(parent) {
DoInit();
}
diff --git a/rtc_base/socket_unittest.cc b/rtc_base/socket_unittest.cc
index 01ef014..cbc5eb5 100644
--- a/rtc_base/socket_unittest.cc
+++ b/rtc_base/socket_unittest.cc
@@ -12,12 +12,12 @@
#include "rtc_base/socket_unittest.h"
+#include "absl/memory/memory.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/asyncudpsocket.h"
#include "rtc_base/buffer.h"
#include "rtc_base/gunit.h"
#include "rtc_base/nethelpers.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/socketserver.h"
#include "rtc_base/testclient.h"
#include "rtc_base/testutils.h"
@@ -905,9 +905,9 @@
// Test send/receive behavior.
std::unique_ptr<TestClient> client1(
- new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, addr1))));
+ new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, addr1))));
std::unique_ptr<TestClient> client2(
- new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+ new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
SocketAddress addr2;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -920,7 +920,7 @@
// TODO: figure out what the intent is here
for (int i = 0; i < 10; ++i) {
client2.reset(
- new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+ new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
SocketAddress addr4;
EXPECT_EQ(3, client2->SendTo("foo", 3, addr1));
@@ -947,7 +947,7 @@
// Test send
std::unique_ptr<TestClient> client(
- new TestClient(WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
+ new TestClient(absl::WrapUnique(AsyncUDPSocket::Create(ss_, empty))));
int test_packet_size = 1200;
std::unique_ptr<char[]> test_packet(new char[test_packet_size]);
// Init the test packet just to avoid memcheck warning.
diff --git a/rtc_base/ssladapter_unittest.cc b/rtc_base/ssladapter_unittest.cc
index 0fdb1bc..ec532b1 100644
--- a/rtc_base/ssladapter_unittest.cc
+++ b/rtc_base/ssladapter_unittest.cc
@@ -12,9 +12,9 @@
#include <string>
#include <utility>
+#include "absl/memory/memory.h"
#include "rtc_base/gunit.h"
#include "rtc_base/ipaddress.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/socketstream.h"
#include "rtc_base/ssladapter.h"
#include "rtc_base/sslidentity.h"
@@ -322,7 +322,7 @@
}
void SetMockCertVerifier(bool return_value) {
- auto mock_verifier = rtc::MakeUnique<MockCertVerifier>();
+ auto mock_verifier = absl::make_unique<MockCertVerifier>();
EXPECT_CALL(*mock_verifier, Verify(_)).WillRepeatedly(Return(return_value));
cert_verifier_ =
std::unique_ptr<rtc::SSLCertificateVerifier>(std::move(mock_verifier));
diff --git a/rtc_base/sslcertificate.cc b/rtc_base/sslcertificate.cc
index fcbd102..d99da60 100644
--- a/rtc_base/sslcertificate.cc
+++ b/rtc_base/sslcertificate.cc
@@ -14,11 +14,11 @@
#include <string>
#include <utility>
+#include "absl/memory/memory.h"
#include "rtc_base/base64.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/opensslcertificate.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/sslfingerprint.h"
namespace rtc {
@@ -66,13 +66,13 @@
std::string der_base64;
Base64::EncodeFromArray(der_buffer.data(), der_buffer.size(), &der_base64);
- return rtc::MakeUnique<SSLCertificateStats>(std::move(fingerprint),
- std::move(digest_algorithm),
- std::move(der_base64), nullptr);
+ return absl::make_unique<SSLCertificateStats>(std::move(fingerprint),
+ std::move(digest_algorithm),
+ std::move(der_base64), nullptr);
}
std::unique_ptr<SSLCertificate> SSLCertificate::GetUniqueReference() const {
- return WrapUnique(GetReference());
+ return absl::WrapUnique(GetReference());
}
//////////////////////////////////////////////////////////////////////
@@ -113,7 +113,7 @@
}
std::unique_ptr<SSLCertChain> SSLCertChain::UniqueCopy() const {
- return WrapUnique(Copy());
+ return absl::WrapUnique(Copy());
}
std::unique_ptr<SSLCertificateStats> SSLCertChain::GetStats() const {
diff --git a/rtc_base/sslidentity.cc b/rtc_base/sslidentity.cc
index ca4cd1c..94944f9 100644
--- a/rtc_base/sslidentity.cc
+++ b/rtc_base/sslidentity.cc
@@ -15,11 +15,11 @@
#include <string>
#include <utility>
+#include "absl/memory/memory.h"
#include "rtc_base/base64.h"
#include "rtc_base/checks.h"
#include "rtc_base/logging.h"
#include "rtc_base/opensslidentity.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/sslfingerprint.h"
namespace rtc {
diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h
index 41d6a10..b8b307c 100644
--- a/rtc_base/task_queue.h
+++ b/rtc_base/task_queue.h
@@ -15,8 +15,8 @@
#include <type_traits>
#include <utility>
+#include "absl/memory/memory.h"
#include "rtc_base/constructormagic.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/scoped_ref_ptr.h"
#include "rtc_base/thread_annotations.h"
@@ -79,13 +79,14 @@
// based parameters.
template <class Closure>
static std::unique_ptr<QueuedTask> NewClosure(Closure&& closure) {
- return rtc::MakeUnique<ClosureTask<Closure>>(std::forward<Closure>(closure));
+ return absl::make_unique<ClosureTask<Closure>>(
+ std::forward<Closure>(closure));
}
template <class Closure, class Cleanup>
static std::unique_ptr<QueuedTask> NewClosure(Closure&& closure,
Cleanup&& cleanup) {
- return rtc::MakeUnique<ClosureTaskWithCleanup<Closure, Cleanup>>(
+ return absl::make_unique<ClosureTaskWithCleanup<Closure, Cleanup>>(
std::forward<Closure>(closure), std::forward<Cleanup>(cleanup));
}
diff --git a/rtc_base/testclient.cc b/rtc_base/testclient.cc
index 1df7c08..7c151c7 100644
--- a/rtc_base/testclient.cc
+++ b/rtc_base/testclient.cc
@@ -10,8 +10,8 @@
#include "rtc_base/testclient.h"
+#include "absl/memory/memory.h"
#include "rtc_base/gunit.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/thread.h"
#include "rtc_base/timeutils.h"
@@ -146,7 +146,8 @@
const SocketAddress& remote_addr,
const PacketTime& packet_time) {
CritScope cs(&crit_);
- packets_.push_back(MakeUnique<Packet>(remote_addr, buf, size, packet_time));
+ packets_.push_back(
+ absl::make_unique<Packet>(remote_addr, buf, size, packet_time));
}
void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
diff --git a/rtc_base/testclient_unittest.cc b/rtc_base/testclient_unittest.cc
index dda1dae..b3a6c80 100644
--- a/rtc_base/testclient_unittest.cc
+++ b/rtc_base/testclient_unittest.cc
@@ -9,10 +9,10 @@
*/
#include "rtc_base/testclient.h"
+#include "absl/memory/memory.h"
#include "rtc_base/gunit.h"
#include "rtc_base/nethelpers.h"
#include "rtc_base/physicalsocketserver.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/testechoserver.h"
#include "rtc_base/thread.h"
@@ -36,7 +36,7 @@
main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_DGRAM);
socket->Bind(loopback);
- TestClient client(MakeUnique<AsyncUDPSocket>(socket));
+ TestClient client(absl::make_unique<AsyncUDPSocket>(socket));
SocketAddress addr = client.address(), from;
EXPECT_EQ(3, client.SendTo("foo", 3, addr));
EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
@@ -50,8 +50,8 @@
AsyncSocket* socket =
main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_STREAM);
- std::unique_ptr<AsyncTCPSocket> tcp_socket =
- WrapUnique(AsyncTCPSocket::Create(socket, loopback, server.address()));
+ std::unique_ptr<AsyncTCPSocket> tcp_socket = absl::WrapUnique(
+ AsyncTCPSocket::Create(socket, loopback, server.address()));
ASSERT_TRUE(tcp_socket != nullptr);
TestClient client(std::move(tcp_socket));
diff --git a/rtc_base/virtualsocket_unittest.cc b/rtc_base/virtualsocket_unittest.cc
index 34b227e..d2bff54 100644
--- a/rtc_base/virtualsocket_unittest.cc
+++ b/rtc_base/virtualsocket_unittest.cc
@@ -16,11 +16,11 @@
#include <memory>
+#include "absl/memory/memory.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/fakeclock.h"
#include "rtc_base/gunit.h"
#include "rtc_base/logging.h"
-#include "rtc_base/ptr_util.h"
#include "rtc_base/testclient.h"
#include "rtc_base/testutils.h"
#include "rtc_base/thread.h"
@@ -40,7 +40,7 @@
struct Sender : public MessageHandler {
Sender(Thread* th, AsyncSocket* s, uint32_t rt)
: thread(th),
- socket(MakeUnique<AsyncUDPSocket>(s)),
+ socket(absl::make_unique<AsyncUDPSocket>(s)),
done(false),
rate(rt),
count(0) {
@@ -86,7 +86,7 @@
struct Receiver : public MessageHandler, public sigslot::has_slots<> {
Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
: thread(th),
- socket(MakeUnique<AsyncUDPSocket>(s)),
+ socket(absl::make_unique<AsyncUDPSocket>(s)),
bandwidth(bw),
done(false),
count(0),
@@ -184,8 +184,8 @@
socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
SocketAddress client1_any_addr = socket->GetLocalAddress();
EXPECT_TRUE(client1_any_addr.IsAnyIP());
- auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
- &fake_clock_);
+ auto client1 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
// Create client2 bound to the default route.
AsyncSocket* socket2 =
@@ -193,8 +193,8 @@
socket2->Bind(SocketAddress(default_route, 0));
SocketAddress client2_addr = socket2->GetLocalAddress();
EXPECT_FALSE(client2_addr.IsAnyIP());
- auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
- &fake_clock_);
+ auto client2 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
// Client1 sends to client2, client2 should see the default route as
// client1's address.
@@ -217,12 +217,12 @@
// Make sure VSS didn't switch families on us.
EXPECT_EQ(server_addr.family(), initial_addr.family());
- auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
- &fake_clock_);
+ auto client1 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
AsyncSocket* socket2 =
ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
- auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
- &fake_clock_);
+ auto client2 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
SocketAddress client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -235,8 +235,8 @@
SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
for (int i = 0; i < 10; i++) {
- client2 = MakeUnique<TestClient>(
- WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
+ client2 = absl::make_unique<TestClient>(
+ absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
SocketAddress next_client2_addr;
EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -261,15 +261,15 @@
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<AsyncSocket> client =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_TRUE(client->GetLocalAddress().IsNil());
// Create server
- std::unique_ptr<AsyncSocket> server =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> server = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_NE(0, server->Listen(5)); // Bind required
EXPECT_EQ(0, server->Bind(initial_addr));
@@ -302,7 +302,8 @@
// Server has pending connection
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
- std::unique_ptr<Socket> accepted = WrapUnique(server->Accept(&accept_addr));
+ std::unique_ptr<Socket> accepted =
+ absl::WrapUnique(server->Accept(&accept_addr));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(accept_addr, kEmptyAddr);
EXPECT_EQ(accepted->GetRemoteAddress(), accept_addr);
@@ -329,13 +330,13 @@
EmptySocketAddressWithFamily(initial_addr.family());
// Create client
- std::unique_ptr<AsyncSocket> client =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
// Create server
- std::unique_ptr<AsyncSocket> server =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> server = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
EXPECT_EQ(0, server->Bind(initial_addr));
EXPECT_EQ(server->GetLocalAddress().family(), initial_addr.family());
@@ -448,14 +449,14 @@
const SocketAddress kEmptyAddr;
// Create clients
- std::unique_ptr<AsyncSocket> a =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> a = absl::WrapUnique(
+ ss_.CreateAsyncSocket(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 =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> b = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -498,14 +499,14 @@
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<AsyncSocket> a =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> a = absl::WrapUnique(
+ ss_.CreateAsyncSocket(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 =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> b = absl::WrapUnique(
+ ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
sink.Monitor(b.get());
b->Bind(initial_addr);
EXPECT_EQ(b->GetLocalAddress().family(), initial_addr.family());
@@ -620,10 +621,10 @@
const SocketAddress kEmptyAddr;
// Connect two sockets
- std::unique_ptr<AsyncSocket> a =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
- std::unique_ptr<AsyncSocket> b =
- WrapUnique(ss_.CreateAsyncSocket(initial_addr.family(), SOCK_STREAM));
+ 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));
a->Bind(initial_addr);
EXPECT_EQ(a->GetLocalAddress().family(), initial_addr.family());
@@ -771,8 +772,8 @@
const SocketAddress kEmptyAddr;
// Client gets a IPv4 address
- std::unique_ptr<AsyncSocket> client =
- WrapUnique(ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> client = absl::WrapUnique(
+ ss_.CreateAsyncSocket(client_addr.family(), SOCK_STREAM));
sink.Monitor(client.get());
EXPECT_EQ(client->GetState(), AsyncSocket::CS_CLOSED);
EXPECT_EQ(client->GetLocalAddress(), kEmptyAddr);
@@ -780,8 +781,8 @@
// Server gets a non-mapped non-any IPv6 address.
// IPv4 sockets should not be able to connect to this.
- std::unique_ptr<AsyncSocket> server =
- WrapUnique(ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM));
+ std::unique_ptr<AsyncSocket> server = absl::WrapUnique(
+ ss_.CreateAsyncSocket(server_addr.family(), SOCK_STREAM));
sink.Monitor(server.get());
server->Bind(server_addr);
server->Listen(5);
@@ -791,7 +792,7 @@
ss_.ProcessMessagesUntilIdle();
EXPECT_TRUE(sink.Check(server.get(), SSE_READ));
std::unique_ptr<Socket> accepted =
- WrapUnique(server->Accept(&accept_address));
+ absl::WrapUnique(server->Accept(&accept_address));
EXPECT_TRUE(nullptr != accepted);
EXPECT_NE(kEmptyAddr, accept_address);
ss_.ProcessMessagesUntilIdle();
@@ -820,13 +821,13 @@
AsyncSocket* socket = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM);
socket->Bind(server_addr);
SocketAddress bound_server_addr = socket->GetLocalAddress();
- auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
- &fake_clock_);
+ auto client1 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
AsyncSocket* socket2 = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM);
socket2->Bind(client_addr);
- auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
- &fake_clock_);
+ auto client2 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
SocketAddress client2_addr;
if (shouldSucceed) {
@@ -1027,12 +1028,12 @@
TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
AsyncSocket* socket1 =
ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
- std::unique_ptr<AsyncSocket> socket2 =
- WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
+ std::unique_ptr<AsyncSocket> socket2 = absl::WrapUnique(
+ ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
socket1->Bind(kIPv4AnyAddress);
socket2->Bind(kIPv4AnyAddress);
- auto client1 =
- MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1), &fake_clock_);
+ auto client1 = absl::make_unique<TestClient>(
+ absl::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
ss_.SetSendingBlocked(true);
EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
@@ -1050,10 +1051,10 @@
ss_.set_recv_buffer_capacity(kBufferSize);
StreamSink sink;
- std::unique_ptr<AsyncSocket> socket1 =
- WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
- std::unique_ptr<AsyncSocket> socket2 =
- WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_STREAM));
+ 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));
sink.Monitor(socket1.get());
sink.Monitor(socket2.get());
socket1->Bind(kIPv4AnyAddress);
diff --git a/rtc_base/weak_ptr_unittest.cc b/rtc_base/weak_ptr_unittest.cc
index 6b0b452..9541718 100644
--- a/rtc_base/weak_ptr_unittest.cc
+++ b/rtc_base/weak_ptr_unittest.cc
@@ -225,7 +225,7 @@
// Test that it is OK to create a WeakPtr on one thread, but use it on
// another. This tests that we do not trip runtime checks that ensure that a
// WeakPtr is not used by multiple threads.
- auto target = rtc::MakeUnique<TargetWithFactory>();
+ auto target = absl::make_unique<TargetWithFactory>();
// Create weak ptr on main thread
WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
rtc::TaskQueue queue("queue");
