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