diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn
index bd0b57f..694823c 100644
--- a/rtc_base/BUILD.gn
+++ b/rtc_base/BUILD.gn
@@ -60,7 +60,6 @@
     "system:arch",
     "system:unused",
     "third_party/base64",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
   public_deps = []  # no-presubmit-check TODO(webrtc:8603)
@@ -463,7 +462,6 @@
       ":safe_conversions",
       ":timeutils",
       "../api/task_queue",
-      "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/strings",
     ]
     if (rtc_build_libevent) {
@@ -483,7 +481,6 @@
       ":checks",
       ":logging",
       "../api/task_queue",
-      "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/strings",
     ]
   }
@@ -506,7 +503,6 @@
       ":safe_conversions",
       ":timeutils",
       "../api/task_queue",
-      "//third_party/abseil-cpp/absl/memory",
       "//third_party/abseil-cpp/absl/strings",
     ]
   }
@@ -527,7 +523,6 @@
     ":safe_conversions",
     ":timeutils",
     "../api/task_queue",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/strings",
   ]
 }
@@ -1003,7 +998,6 @@
     ":rtc_base",
     ":rtc_base_tests_utils",
     ":timeutils",
-    "//third_party/abseil-cpp/absl/memory",
   ]
 }
 
@@ -1228,7 +1222,6 @@
       ":weak_ptr",
       "../test:test_main",
       "../test:test_support",
-      "//third_party/abseil-cpp/absl/memory",
     ]
   }
 
diff --git a/rtc_base/experiments/BUILD.gn b/rtc_base/experiments/BUILD.gn
index 0101fd8..bbb5345 100644
--- a/rtc_base/experiments/BUILD.gn
+++ b/rtc_base/experiments/BUILD.gn
@@ -58,7 +58,7 @@
     "../../rtc_base:logging",
     "../../rtc_base:safe_conversions",
     "../../rtc_base:stringutils",
-    "//third_party/abseil-cpp/absl/memory:memory",
+    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/strings:strings",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
@@ -166,7 +166,6 @@
     "../../api/transport:webrtc_key_value_config",
     "../../api/video_codecs:video_codecs_api",
     "../../system_wrappers:field_trial",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
diff --git a/rtc_base/fake_ssl_identity.cc b/rtc_base/fake_ssl_identity.cc
index 480922c..309708f 100644
--- a/rtc_base/fake_ssl_identity.cc
+++ b/rtc_base/fake_ssl_identity.cc
@@ -10,10 +10,10 @@
 
 #include "rtc_base/fake_ssl_identity.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/message_digest.h"
 
@@ -29,7 +29,7 @@
 FakeSSLCertificate::~FakeSSLCertificate() = default;
 
 std::unique_ptr<SSLCertificate> FakeSSLCertificate::Clone() const {
-  return absl::make_unique<FakeSSLCertificate>(*this);
+  return std::make_unique<FakeSSLCertificate>(*this);
 }
 
 std::string FakeSSLCertificate::ToPEMString() const {
@@ -77,13 +77,13 @@
   std::vector<std::unique_ptr<SSLCertificate>> certs;
   certs.reserve(pem_strings.size());
   for (const std::string& pem_string : pem_strings) {
-    certs.push_back(absl::make_unique<FakeSSLCertificate>(pem_string));
+    certs.push_back(std::make_unique<FakeSSLCertificate>(pem_string));
   }
-  cert_chain_ = absl::make_unique<SSLCertChain>(std::move(certs));
+  cert_chain_ = std::make_unique<SSLCertChain>(std::move(certs));
 }
 
 FakeSSLIdentity::FakeSSLIdentity(const FakeSSLCertificate& cert)
-    : cert_chain_(absl::make_unique<SSLCertChain>(cert.Clone())) {}
+    : cert_chain_(std::make_unique<SSLCertChain>(cert.Clone())) {}
 
 FakeSSLIdentity::FakeSSLIdentity(const FakeSSLIdentity& o)
     : cert_chain_(o.cert_chain_->Clone()) {}
diff --git a/rtc_base/nat_unittest.cc b/rtc_base/nat_unittest.cc
index 374e68c..959a4e2 100644
--- a/rtc_base/nat_unittest.cc
+++ b/rtc_base/nat_unittest.cc
@@ -56,7 +56,7 @@
 }
 
 TestClient* CreateTCPTestClient(AsyncSocket* socket) {
-  return new TestClient(absl::make_unique<AsyncTCPSocket>(socket, false));
+  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/openssl_adapter.cc b/rtc_base/openssl_adapter.cc
index 2c93118..d0c1278 100644
--- a/rtc_base/openssl_adapter.cc
+++ b/rtc_base/openssl_adapter.cc
@@ -18,7 +18,8 @@
 #include <string.h>
 #include <time.h>
 
-#include "absl/memory/memory.h"
+#include <memory>
+
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
 #include "rtc_base/logging.h"
@@ -943,7 +944,7 @@
     }
     // The OpenSSLSessionCache will upref the ssl_ctx.
     ssl_session_cache_ =
-        absl::make_unique<OpenSSLSessionCache>(ssl_mode_, ssl_ctx);
+        std::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/openssl_certificate.cc b/rtc_base/openssl_certificate.cc
index c22e5fb..9459f76 100644
--- a/rtc_base/openssl_certificate.cc
+++ b/rtc_base/openssl_certificate.cc
@@ -20,7 +20,8 @@
 #include <openssl/pem.h>
 #include <time.h>
 
-#include "absl/memory/memory.h"
+#include <memory>
+
 #include "rtc_base/checks.h"
 #include "rtc_base/helpers.h"
 #include "rtc_base/logging.h"
@@ -138,7 +139,7 @@
 #if !defined(NDEBUG)
   PrintCert(x509);
 #endif
-  auto ret = absl::make_unique<OpenSSLCertificate>(x509);
+  auto ret = std::make_unique<OpenSSLCertificate>(x509);
   X509_free(x509);
   return ret;
 }
@@ -158,7 +159,7 @@
   if (!x509) {
     return nullptr;
   }
-  auto ret = absl::make_unique<OpenSSLCertificate>(x509);
+  auto ret = std::make_unique<OpenSSLCertificate>(x509);
   X509_free(x509);
   return ret;
 }
@@ -238,7 +239,7 @@
 }
 
 std::unique_ptr<SSLCertificate> OpenSSLCertificate::Clone() const {
-  return absl::make_unique<OpenSSLCertificate>(x509_);
+  return std::make_unique<OpenSSLCertificate>(x509_);
 }
 
 std::string OpenSSLCertificate::ToPEMString() const {
diff --git a/rtc_base/openssl_identity.cc b/rtc_base/openssl_identity.cc
index 81357a8..8d12c07 100644
--- a/rtc_base/openssl_identity.cc
+++ b/rtc_base/openssl_identity.cc
@@ -301,7 +301,7 @@
   }
 
   return new OpenSSLIdentity(std::move(key_pair),
-                             absl::make_unique<SSLCertChain>(std::move(certs)));
+                             std::make_unique<SSLCertChain>(std::move(certs)));
 }
 
 const OpenSSLCertificate& OpenSSLIdentity::certificate() const {
diff --git a/rtc_base/openssl_stream_adapter.cc b/rtc_base/openssl_stream_adapter.cc
index db236d9..7e7fae3 100644
--- a/rtc_base/openssl_stream_adapter.cc
+++ b/rtc_base/openssl_stream_adapter.cc
@@ -25,7 +25,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/safe_conversions.h"
@@ -1075,7 +1074,7 @@
   // Record the peer's certificate.
   X509* cert = X509_STORE_CTX_get0_cert(store);
   stream->peer_cert_chain_.reset(
-      new SSLCertChain(absl::make_unique<OpenSSLCertificate>(cert)));
+      new SSLCertChain(std::make_unique<OpenSSLCertificate>(cert)));
 #endif
 
   // If the peer certificate digest isn't known yet, we'll wait to verify
diff --git a/rtc_base/proxy_server.cc b/rtc_base/proxy_server.cc
index ec76782..a7e8bf5 100644
--- a/rtc_base/proxy_server.cc
+++ b/rtc_base/proxy_server.cc
@@ -12,7 +12,7 @@
 
 #include <stddef.h>
 
-#include "absl/memory/memory.h"
+#include <memory>
 #include "rtc_base/checks.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/socket_factory.h"
@@ -51,7 +51,7 @@
   if (ext_socket) {
     ext_socket->Bind(ext_ip_);
     bindings_.emplace_back(
-        absl::make_unique<ProxyBinding>(wrapped_socket, ext_socket));
+        std::make_unique<ProxyBinding>(wrapped_socket, ext_socket));
   } else {
     RTC_LOG(LS_ERROR)
         << "Unable to create external socket on proxy accept event";
diff --git a/rtc_base/rate_statistics.cc b/rtc_base/rate_statistics.cc
index bb506aa..b393dc8 100644
--- a/rtc_base/rate_statistics.cc
+++ b/rtc_base/rate_statistics.cc
@@ -11,8 +11,8 @@
 #include "rtc_base/rate_statistics.h"
 
 #include <algorithm>
+#include <memory>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 
 namespace webrtc {
@@ -35,7 +35,7 @@
       scale_(other.scale_),
       max_window_size_ms_(other.max_window_size_ms_),
       current_window_size_ms_(other.current_window_size_ms_) {
-  buckets_ = absl::make_unique<Bucket[]>(other.max_window_size_ms_);
+  buckets_ = std::make_unique<Bucket[]>(other.max_window_size_ms_);
   std::copy(other.buckets_.get(),
             other.buckets_.get() + other.max_window_size_ms_, buckets_.get());
 }
diff --git a/rtc_base/signal_thread.cc b/rtc_base/signal_thread.cc
index 84613db..e100fbe 100644
--- a/rtc_base/signal_thread.cc
+++ b/rtc_base/signal_thread.cc
@@ -12,7 +12,6 @@
 
 #include <memory>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/location.h"
 #include "rtc_base/null_socket_server.h"
@@ -128,7 +127,7 @@
 }
 
 SignalThread::Worker::Worker(SignalThread* parent)
-    : Thread(absl::make_unique<NullSocketServer>(), /*do_init=*/false),
+    : Thread(std::make_unique<NullSocketServer>(), /*do_init=*/false),
       parent_(parent) {
   DoInit();
 }
diff --git a/rtc_base/signal_thread_unittest.cc b/rtc_base/signal_thread_unittest.cc
index 9375b50..1476186 100644
--- a/rtc_base/signal_thread_unittest.cc
+++ b/rtc_base/signal_thread_unittest.cc
@@ -12,7 +12,6 @@
 
 #include <memory>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/constructor_magic.h"
 #include "rtc_base/critical_section.h"
 #include "rtc_base/gunit.h"
@@ -133,7 +132,7 @@
 class OwnerThread : public Thread, public sigslot::has_slots<> {
  public:
   explicit OwnerThread(SignalThreadTest* harness)
-      : Thread(absl::make_unique<NullSocketServer>()),
+      : Thread(std::make_unique<NullSocketServer>()),
         harness_(harness),
         has_run_(false) {}
 
diff --git a/rtc_base/ssl_adapter_unittest.cc b/rtc_base/ssl_adapter_unittest.cc
index d723bf1..3fa1221 100644
--- a/rtc_base/ssl_adapter_unittest.cc
+++ b/rtc_base/ssl_adapter_unittest.cc
@@ -12,7 +12,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/ip_address.h"
 #include "rtc_base/message_digest.h"
@@ -323,7 +322,7 @@
   }
 
   void SetMockCertVerifier(bool return_value) {
-    auto mock_verifier = absl::make_unique<MockCertVerifier>();
+    auto mock_verifier = std::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/ssl_certificate.cc b/rtc_base/ssl_certificate.cc
index 657561a..db9097b 100644
--- a/rtc_base/ssl_certificate.cc
+++ b/rtc_base/ssl_certificate.cc
@@ -10,11 +10,11 @@
 
 #include "rtc_base/ssl_certificate.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 
 #include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
 #include "rtc_base/checks.h"
 #include "rtc_base/openssl_certificate.h"
 #include "rtc_base/ssl_fingerprint.h"
@@ -65,9 +65,9 @@
   std::string der_base64;
   Base64::EncodeFromArray(der_buffer.data(), der_buffer.size(), &der_base64);
 
-  return absl::make_unique<SSLCertificateStats>(std::move(fingerprint),
-                                                std::move(digest_algorithm),
-                                                std::move(der_base64), nullptr);
+  return std::make_unique<SSLCertificateStats>(std::move(fingerprint),
+                                               std::move(digest_algorithm),
+                                               std::move(der_base64), nullptr);
 }
 
 //////////////////////////////////////////////////////////////////////
@@ -93,7 +93,7 @@
       certs_, new_certs.begin(),
       [](const std::unique_ptr<SSLCertificate>& cert)
           -> std::unique_ptr<SSLCertificate> { return cert->Clone(); });
-  return absl::make_unique<SSLCertChain>(std::move(new_certs));
+  return std::make_unique<SSLCertChain>(std::move(new_certs));
 }
 
 std::unique_ptr<SSLCertificateStats> SSLCertChain::GetStats() const {
diff --git a/rtc_base/ssl_fingerprint.cc b/rtc_base/ssl_fingerprint.cc
index c607810..5b261e0 100644
--- a/rtc_base/ssl_fingerprint.cc
+++ b/rtc_base/ssl_fingerprint.cc
@@ -12,10 +12,10 @@
 
 #include <ctype.h>
 #include <cstdint>
+#include <memory>
 #include <string>
 
 #include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/message_digest.h"
 #include "rtc_base/rtc_certificate.h"
@@ -46,7 +46,7 @@
   if (!ret) {
     return nullptr;
   }
-  return absl::make_unique<SSLFingerprint>(
+  return std::make_unique<SSLFingerprint>(
       algorithm, ArrayView<const uint8_t>(digest_val, digest_len));
 }
 
@@ -71,7 +71,7 @@
   if (!value_len)
     return nullptr;
 
-  return absl::make_unique<SSLFingerprint>(
+  return std::make_unique<SSLFingerprint>(
       algorithm,
       ArrayView<const uint8_t>(reinterpret_cast<uint8_t*>(value), value_len));
 }
diff --git a/rtc_base/synchronization/BUILD.gn b/rtc_base/synchronization/BUILD.gn
index d510790..061d8a2 100644
--- a/rtc_base/synchronization/BUILD.gn
+++ b/rtc_base/synchronization/BUILD.gn
@@ -89,7 +89,6 @@
       "../../api:function_view",
       "../../test:test_main",
       "../../test:test_support",
-      "//third_party/abseil-cpp/absl/memory",
     ]
   }
 }
diff --git a/rtc_base/synchronization/sequence_checker_unittest.cc b/rtc_base/synchronization/sequence_checker_unittest.cc
index ccdf6bc..00b847c 100644
--- a/rtc_base/synchronization/sequence_checker_unittest.cc
+++ b/rtc_base/synchronization/sequence_checker_unittest.cc
@@ -13,7 +13,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "api/function_view.h"
 #include "rtc_base/event.h"
 #include "rtc_base/platform_thread.h"
@@ -67,7 +66,7 @@
 }
 
 TEST(SequenceCheckerTest, DestructorAllowedOnDifferentThread) {
-  auto sequence_checker = absl::make_unique<SequenceChecker>();
+  auto sequence_checker = std::make_unique<SequenceChecker>();
   RunOnDifferentThread([&] {
     // Verify that the destructor doesn't assert when called on a different
     // thread.
diff --git a/rtc_base/task_queue.h b/rtc_base/task_queue.h
index 2f7c44d..86d3597 100644
--- a/rtc_base/task_queue.h
+++ b/rtc_base/task_queue.h
@@ -62,7 +62,7 @@
 //       int count_ = 0;
 //     };
 //     ...
-//     queue_.PostDelayedTask(absl::make_unique<TimerTask>(), 1000);
+//     queue_.PostDelayedTask(std::make_unique<TimerTask>(), 1000);
 //
 // For more examples, see task_queue_unittests.cc.
 //
diff --git a/rtc_base/task_queue_gcd.cc b/rtc_base/task_queue_gcd.cc
index 35c7221..cb516cc 100644
--- a/rtc_base/task_queue_gcd.cc
+++ b/rtc_base/task_queue_gcd.cc
@@ -17,7 +17,8 @@
 #include <dispatch/dispatch.h>
 #include <string.h>
 
-#include "absl/memory/memory.h"
+#include <memory>
+
 #include "absl/strings/string_view.h"
 #include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
@@ -146,7 +147,7 @@
 }  // namespace
 
 std::unique_ptr<TaskQueueFactory> CreateTaskQueueGcdFactory() {
-  return absl::make_unique<TaskQueueGcdFactory>();
+  return std::make_unique<TaskQueueGcdFactory>();
 }
 
 }  // namespace webrtc
diff --git a/rtc_base/task_queue_libevent.cc b/rtc_base/task_queue_libevent.cc
index df10efd..7638869 100644
--- a/rtc_base/task_queue_libevent.cc
+++ b/rtc_base/task_queue_libevent.cc
@@ -23,7 +23,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
@@ -240,7 +239,7 @@
                   rtc::dchecked_cast<int>(milliseconds % 1000) * 1000};
     event_add(&timer->ev, &tv);
   } else {
-    PostTask(absl::make_unique<SetTimerTask>(std::move(task), milliseconds));
+    PostTask(std::make_unique<SetTimerTask>(std::move(task), milliseconds));
   }
 }
 
@@ -315,7 +314,7 @@
 }  // namespace
 
 std::unique_ptr<TaskQueueFactory> CreateTaskQueueLibeventFactory() {
-  return absl::make_unique<TaskQueueLibeventFactory>();
+  return std::make_unique<TaskQueueLibeventFactory>();
 }
 
 }  // namespace webrtc
diff --git a/rtc_base/task_queue_stdlib.cc b/rtc_base/task_queue_stdlib.cc
index 415c14d..7052f7c 100644
--- a/rtc_base/task_queue_stdlib.cc
+++ b/rtc_base/task_queue_stdlib.cc
@@ -14,10 +14,10 @@
 
 #include <algorithm>
 #include <map>
+#include <memory>
 #include <queue>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
@@ -295,7 +295,7 @@
 }  // namespace
 
 std::unique_ptr<TaskQueueFactory> CreateTaskQueueStdlibFactory() {
-  return absl::make_unique<TaskQueueStdlibFactory>();
+  return std::make_unique<TaskQueueStdlibFactory>();
 }
 
 }  // namespace webrtc
diff --git a/rtc_base/task_queue_win.cc b/rtc_base/task_queue_win.cc
index 696eda3..dd825d2 100644
--- a/rtc_base/task_queue_win.cc
+++ b/rtc_base/task_queue_win.cc
@@ -24,10 +24,10 @@
 #include <string.h>
 
 #include <algorithm>
+#include <memory>
 #include <queue>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "absl/strings/string_view.h"
 #include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
@@ -406,7 +406,7 @@
 }  // namespace
 
 std::unique_ptr<TaskQueueFactory> CreateTaskQueueWinFactory() {
-  return absl::make_unique<TaskQueueWinFactory>();
+  return std::make_unique<TaskQueueWinFactory>();
 }
 
 }  // namespace webrtc
diff --git a/rtc_base/task_utils/BUILD.gn b/rtc_base/task_utils/BUILD.gn
index 7a466a1..7eca496 100644
--- a/rtc_base/task_utils/BUILD.gn
+++ b/rtc_base/task_utils/BUILD.gn
@@ -32,7 +32,6 @@
   ]
   deps = [
     "../../api/task_queue",
-    "//third_party/abseil-cpp/absl/memory",
   ]
 }
 
@@ -48,7 +47,6 @@
       "..:rtc_task_queue",
       "..:task_queue_for_test",
       "../../test:test_support",
-      "//third_party/abseil-cpp/absl/memory",
     ]
   }
 
diff --git a/rtc_base/task_utils/repeating_task.cc b/rtc_base/task_utils/repeating_task.cc
index 1705918..aeeb7c0 100644
--- a/rtc_base/task_utils/repeating_task.cc
+++ b/rtc_base/task_utils/repeating_task.cc
@@ -10,6 +10,7 @@
 
 #include "rtc_base/task_utils/repeating_task.h"
 
+#include "absl/memory/memory.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/task_utils/to_queued_task.h"
 #include "rtc_base/time_utils.h"
diff --git a/rtc_base/task_utils/repeating_task.h b/rtc_base/task_utils/repeating_task.h
index 8549049..1545d6f 100644
--- a/rtc_base/task_utils/repeating_task.h
+++ b/rtc_base/task_utils/repeating_task.h
@@ -11,10 +11,10 @@
 #ifndef RTC_BASE_TASK_UTILS_REPEATING_TASK_H_
 #define RTC_BASE_TASK_UTILS_REPEATING_TASK_H_
 
+#include <memory>
 #include <type_traits>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "api/task_queue/queued_task.h"
 #include "api/task_queue/task_queue_base.h"
 #include "api/units/time_delta.h"
@@ -93,7 +93,7 @@
   template <class Closure>
   static RepeatingTaskHandle Start(TaskQueueBase* task_queue,
                                    Closure&& closure) {
-    auto repeating_task = absl::make_unique<
+    auto repeating_task = std::make_unique<
         webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
         task_queue, TimeDelta::Zero(), std::forward<Closure>(closure));
     auto* repeating_task_ptr = repeating_task.get();
@@ -107,7 +107,7 @@
   static RepeatingTaskHandle DelayedStart(TaskQueueBase* task_queue,
                                           TimeDelta first_delay,
                                           Closure&& closure) {
-    auto repeating_task = absl::make_unique<
+    auto repeating_task = std::make_unique<
         webrtc_repeating_task_impl::RepeatingTaskImpl<Closure>>(
         task_queue, first_delay, std::forward<Closure>(closure));
     auto* repeating_task_ptr = repeating_task.get();
diff --git a/rtc_base/task_utils/repeating_task_unittest.cc b/rtc_base/task_utils/repeating_task_unittest.cc
index 471914c..2532098 100644
--- a/rtc_base/task_utils/repeating_task_unittest.cc
+++ b/rtc_base/task_utils/repeating_task_unittest.cc
@@ -15,7 +15,6 @@
 #include <memory>
 #include <thread>  // Not allowed in production per Chromium style guide.
 
-#include "absl/memory/memory.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/gmock.h"
@@ -219,7 +218,7 @@
     }
   };
   TaskQueueForTest task_queue("queue");
-  auto object = absl::make_unique<ObjectOnTaskQueue>();
+  auto object = std::make_unique<ObjectOnTaskQueue>();
   // Create and start the periodic task.
   RepeatingTaskHandle handle;
   object->StartPeriodicTask(&handle, task_queue.Get());
diff --git a/rtc_base/task_utils/to_queued_task.h b/rtc_base/task_utils/to_queued_task.h
index 5088af9..ab5e2c9 100644
--- a/rtc_base/task_utils/to_queued_task.h
+++ b/rtc_base/task_utils/to_queued_task.h
@@ -15,7 +15,6 @@
 #include <type_traits>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "api/task_queue/queued_task.h"
 
 namespace webrtc {
@@ -57,13 +56,13 @@
 // based parameters.
 template <typename Closure>
 std::unique_ptr<QueuedTask> ToQueuedTask(Closure&& closure) {
-  return absl::make_unique<webrtc_new_closure_impl::ClosureTask<Closure>>(
+  return std::make_unique<webrtc_new_closure_impl::ClosureTask<Closure>>(
       std::forward<Closure>(closure));
 }
 
 template <typename Closure, typename Cleanup>
 std::unique_ptr<QueuedTask> ToQueuedTask(Closure&& closure, Cleanup&& cleanup) {
-  return absl::make_unique<
+  return std::make_unique<
       webrtc_new_closure_impl::ClosureTaskWithCleanup<Closure, Cleanup>>(
       std::forward<Closure>(closure), std::forward<Cleanup>(cleanup));
 }
diff --git a/rtc_base/test_client.cc b/rtc_base/test_client.cc
index e287201..e5aa9d7 100644
--- a/rtc_base/test_client.cc
+++ b/rtc_base/test_client.cc
@@ -12,9 +12,9 @@
 
 #include <string.h>
 
+#include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/gunit.h"
 #include "rtc_base/thread.h"
 #include "rtc_base/time_utils.h"
@@ -151,7 +151,7 @@
                           const int64_t& packet_time_us) {
   CritScope cs(&crit_);
   packets_.push_back(
-      absl::make_unique<Packet>(remote_addr, buf, size, packet_time_us));
+      std::make_unique<Packet>(remote_addr, buf, size, packet_time_us));
 }
 
 void TestClient::OnReadyToSend(AsyncPacketSocket* socket) {
diff --git a/rtc_base/test_client_unittest.cc b/rtc_base/test_client_unittest.cc
index 382aaaf..af8a4a7 100644
--- a/rtc_base/test_client_unittest.cc
+++ b/rtc_base/test_client_unittest.cc
@@ -44,7 +44,7 @@
       main->socketserver()->CreateAsyncSocket(loopback.family(), SOCK_DGRAM);
   socket->Bind(loopback);
 
-  TestClient client(absl::make_unique<AsyncUDPSocket>(socket));
+  TestClient client(std::make_unique<AsyncUDPSocket>(socket));
   SocketAddress addr = client.address(), from;
   EXPECT_EQ(3, client.SendTo("foo", 3, addr));
   EXPECT_TRUE(client.CheckNextPacket("foo", 3, &from));
diff --git a/rtc_base/thread_unittest.cc b/rtc_base/thread_unittest.cc
index 56af8a5..0e5026d 100644
--- a/rtc_base/thread_unittest.cc
+++ b/rtc_base/thread_unittest.cc
@@ -12,7 +12,6 @@
 
 #include <memory>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/async_invoker.h"
 #include "rtc_base/async_udp_socket.h"
 #include "rtc_base/event.h"
@@ -518,7 +517,7 @@
   bool reentrant_functor_run = false;
 
   Thread* main = Thread::Current();
-  Thread thread(absl::make_unique<NullSocketServer>());
+  Thread thread(std::make_unique<NullSocketServer>());
   thread.Start();
   {
     AsyncInvoker invoker;
diff --git a/rtc_base/virtual_socket_unittest.cc b/rtc_base/virtual_socket_unittest.cc
index 94def0d..8115c23 100644
--- a/rtc_base/virtual_socket_unittest.cc
+++ b/rtc_base/virtual_socket_unittest.cc
@@ -57,7 +57,7 @@
 struct Sender : public MessageHandler {
   Sender(Thread* th, AsyncSocket* s, uint32_t rt)
       : thread(th),
-        socket(absl::make_unique<AsyncUDPSocket>(s)),
+        socket(std::make_unique<AsyncUDPSocket>(s)),
         done(false),
         rate(rt),
         count(0) {
@@ -103,7 +103,7 @@
 struct Receiver : public MessageHandler, public sigslot::has_slots<> {
   Receiver(Thread* th, AsyncSocket* s, uint32_t bw)
       : thread(th),
-        socket(absl::make_unique<AsyncUDPSocket>(s)),
+        socket(std::make_unique<AsyncUDPSocket>(s)),
         bandwidth(bw),
         done(false),
         count(0),
@@ -201,8 +201,8 @@
     socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
     SocketAddress client1_any_addr = socket->GetLocalAddress();
     EXPECT_TRUE(client1_any_addr.IsAnyIP());
-    auto client1 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+    auto client1 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
 
     // Create client2 bound to the default route.
     AsyncSocket* socket2 =
@@ -210,8 +210,8 @@
     socket2->Bind(SocketAddress(default_route, 0));
     SocketAddress client2_addr = socket2->GetLocalAddress();
     EXPECT_FALSE(client2_addr.IsAnyIP());
-    auto client2 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+    auto client2 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
 
     // Client1 sends to client2, client2 should see the default route as
     // client1's address.
@@ -234,12 +234,12 @@
     // Make sure VSS didn't switch families on us.
     EXPECT_EQ(server_addr.family(), initial_addr.family());
 
-    auto client1 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+    auto client1 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
     AsyncSocket* socket2 =
         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
-    auto client2 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+    auto client2 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
 
     SocketAddress client2_addr;
     EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
@@ -252,7 +252,7 @@
 
     SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
     for (int i = 0; i < 10; i++) {
-      client2 = absl::make_unique<TestClient>(
+      client2 = std::make_unique<TestClient>(
           absl::WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
 
       SocketAddress next_client2_addr;
@@ -838,13 +838,13 @@
     AsyncSocket* socket = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM);
     socket->Bind(server_addr);
     SocketAddress bound_server_addr = socket->GetLocalAddress();
-    auto client1 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
+    auto client1 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket), &fake_clock_);
 
     AsyncSocket* socket2 = ss_.CreateAsyncSocket(AF_INET, SOCK_DGRAM);
     socket2->Bind(client_addr);
-    auto client2 = absl::make_unique<TestClient>(
-        absl::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
+    auto client2 = std::make_unique<TestClient>(
+        std::make_unique<AsyncUDPSocket>(socket2), &fake_clock_);
     SocketAddress client2_addr;
 
     if (shouldSucceed) {
@@ -1049,8 +1049,8 @@
       ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
   socket1->Bind(kIPv4AnyAddress);
   socket2->Bind(kIPv4AnyAddress);
-  auto client1 = absl::make_unique<TestClient>(
-      absl::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
+  auto client1 = std::make_unique<TestClient>(
+      std::make_unique<AsyncUDPSocket>(socket1), &fake_clock_);
 
   ss_.SetSendingBlocked(true);
   EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
diff --git a/rtc_base/weak_ptr_unittest.cc b/rtc_base/weak_ptr_unittest.cc
index 3906fe7..9e22312 100644
--- a/rtc_base/weak_ptr_unittest.cc
+++ b/rtc_base/weak_ptr_unittest.cc
@@ -13,7 +13,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/event.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "test/gtest.h"
@@ -205,7 +204,7 @@
 std::unique_ptr<T> NewObjectCreatedOnTaskQueue() {
   std::unique_ptr<T> obj;
   webrtc::TaskQueueForTest queue("NewObjectCreatedOnTaskQueue");
-  queue.SendTask([&] { obj = absl::make_unique<T>(); });
+  queue.SendTask([&] { obj = std::make_unique<T>(); });
   return obj;
 }
 
@@ -223,7 +222,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 = absl::make_unique<TargetWithFactory>();
+  auto target = std::make_unique<TargetWithFactory>();
   // Create weak ptr on main thread
   WeakPtr<Target> weak_ptr = target->factory.GetWeakPtr();
   webrtc::TaskQueueForTest queue("queue");