Use std::make_unique instead of absl::make_unique.

WebRTC is now using C++14 so there is no need to use the Abseil version
of std::make_unique.

This CL has been created with the following steps:

git grep -l absl::make_unique | sort | uniq > /tmp/make_unique.txt
git grep -l absl::WrapUnique | sort | uniq > /tmp/wrap_unique.txt
git grep -l "#include <memory>" | sort | uniq > /tmp/memory.txt

diff --new-line-format="" --unchanged-line-format="" \
  /tmp/make_unique.txt /tmp/wrap_unique.txt | sort | \
  uniq > /tmp/only_make_unique.txt
diff --new-line-format="" --unchanged-line-format="" \
  /tmp/only_make_unique.txt /tmp/memory.txt | \
  xargs grep -l "absl/memory" > /tmp/add-memory.txt

git grep -l "\babsl::make_unique\b" | \
  xargs sed -i "s/\babsl::make_unique\b/std::make_unique/g"

git checkout PRESUBMIT.py abseil-in-webrtc.md

cat /tmp/add-memory.txt | \
  xargs sed -i \
  's/#include "absl\/memory\/memory.h"/#include <memory>/g'
git cl format
# Manual fix order of the new inserted #include <memory>

cat /tmp/only_make_unique | xargs grep -l "#include <memory>" | \
  xargs sed -i '/#include "absl\/memory\/memory.h"/d'

git ls-files | grep BUILD.gn | \
  xargs sed -i '/\/\/third_party\/abseil-cpp\/absl\/memory/d'

python tools_webrtc/gn_check_autofix.py \
  -m tryserver.webrtc -b linux_rel

# Repead the gn_check_autofix step for other platforms

git ls-files | grep BUILD.gn | \
  xargs sed -i 's/absl\/memory:memory/absl\/memory/g'
git cl format

Bug: webrtc:10945
Change-Id: I3fe28ea80f4dd3ba3cf28effd151d5e1f19aff89
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/153221
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Alessio Bazzica <alessiob@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29209}
diff --git a/call/BUILD.gn b/call/BUILD.gn
index 6c2141b..8769efc 100644
--- a/call/BUILD.gn
+++ b/call/BUILD.gn
@@ -117,7 +117,6 @@
     "../modules/rtp_rtcp:rtp_rtcp_format",
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -170,7 +169,6 @@
     "../system_wrappers:field_trial",
     "//third_party/abseil-cpp/absl/algorithm:container",
     "//third_party/abseil-cpp/absl/container:inlined_vector",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
     "//third_party/abseil-cpp/absl/types:variant",
   ]
@@ -269,7 +267,6 @@
     "../system_wrappers:field_trial",
     "../system_wrappers:metrics",
     "../video",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -317,7 +314,6 @@
     "../rtc_base:checks",
     "../rtc_base:rtc_base_approved",
     "../rtc_base/synchronization:sequence_checker",
-    "//third_party/abseil-cpp/absl/memory",
     "//third_party/abseil-cpp/absl/types:optional",
   ]
 }
@@ -349,7 +345,6 @@
     "../rtc_base:rtc_base_approved",
     "../rtc_base/synchronization:sequence_checker",
     "../system_wrappers",
-    "//third_party/abseil-cpp/absl/memory",
   ]
 }
 
@@ -475,7 +470,6 @@
       "../video",
       "//testing/gtest",
       "//third_party/abseil-cpp/absl/flags:flag",
-      "//third_party/abseil-cpp/absl/memory",
     ]
   }
 
@@ -537,7 +531,6 @@
       "../test:test_support",
       "//testing/gtest",
       "//third_party/abseil-cpp/absl/algorithm:container",
-      "//third_party/abseil-cpp/absl/memory",
     ]
   }
 }
diff --git a/call/bitrate_estimator_tests.cc b/call/bitrate_estimator_tests.cc
index 803e1f9..8fa3a57 100644
--- a/call/bitrate_estimator_tests.cc
+++ b/call/bitrate_estimator_tests.cc
@@ -12,7 +12,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/memory/memory.h"
 #include "call/call.h"
 #include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
@@ -108,15 +107,15 @@
 
       send_transport_.reset(new test::DirectTransport(
           &task_queue_,
-          absl::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+          std::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                              BuiltInNetworkBehaviorConfig())),
           sender_call_.get(), payload_type_map_));
       send_transport_->SetReceiver(receiver_call_->Receiver());
       receive_transport_.reset(new test::DirectTransport(
           &task_queue_,
-          absl::make_unique<FakeNetworkPipe>(
-              Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
+          std::make_unique<FakeNetworkPipe>(
+              Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                              BuiltInNetworkBehaviorConfig())),
           receiver_call_.get(), payload_type_map_));
       receive_transport_->SetReceiver(sender_call_->Receiver());
@@ -171,14 +170,14 @@
           send_stream_(nullptr),
           frame_generator_capturer_(),
           decoder_factory_(
-              []() { return absl::make_unique<test::FakeDecoder>(); }) {
+              []() { return std::make_unique<test::FakeDecoder>(); }) {
       test_->GetVideoSendConfig()->rtp.ssrcs[0]++;
       send_stream_ = test_->sender_call_->CreateVideoSendStream(
           test_->GetVideoSendConfig()->Copy(),
           test_->GetVideoEncoderConfig()->Copy());
       RTC_DCHECK_EQ(1, test_->GetVideoEncoderConfig()->number_of_streams);
       frame_generator_capturer_ =
-          absl::make_unique<test::FrameGeneratorCapturer>(
+          std::make_unique<test::FrameGeneratorCapturer>(
               test->clock_,
               test::FrameGenerator::CreateSquareGenerator(
                   kDefaultWidth, kDefaultHeight, absl::nullopt, absl::nullopt),
diff --git a/call/call.cc b/call/call.cc
index 3964171..940c1a3 100644
--- a/call/call.cc
+++ b/call/call.cc
@@ -19,7 +19,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/types/optional.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/transport/network_control.h"
@@ -112,7 +111,7 @@
 
 std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const VideoReceiveStream::Config& config) {
-  auto rtclog_config = absl::make_unique<rtclog::StreamConfig>();
+  auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
   rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
   rtclog_config->local_ssrc = config.rtp.local_ssrc;
   rtclog_config->rtx_ssrc = config.rtp.rtx_ssrc;
@@ -131,7 +130,7 @@
 std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const VideoSendStream::Config& config,
     size_t ssrc_index) {
-  auto rtclog_config = absl::make_unique<rtclog::StreamConfig>();
+  auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
   rtclog_config->local_ssrc = config.rtp.ssrcs[ssrc_index];
   if (ssrc_index < config.rtp.rtx.ssrcs.size()) {
     rtclog_config->rtx_ssrc = config.rtp.rtx.ssrcs[ssrc_index];
@@ -147,7 +146,7 @@
 
 std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
     const AudioReceiveStream::Config& config) {
-  auto rtclog_config = absl::make_unique<rtclog::StreamConfig>();
+  auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
   rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
   rtclog_config->local_ssrc = config.rtp.local_ssrc;
   rtclog_config->rtp_extensions = config.rtp.extensions;
@@ -416,7 +415,7 @@
   RTC_DCHECK(config.task_queue_factory);
   return new internal::Call(
       clock, config,
-      absl::make_unique<RtpTransportControllerSend>(
+      std::make_unique<RtpTransportControllerSend>(
           clock, config.event_log, config.network_state_predictor_factory,
           config.network_controller_factory, config.bitrate_config,
           std::move(pacer_thread), config.task_queue_factory),
@@ -684,7 +683,7 @@
   TRACE_EVENT0("webrtc", "Call::CreateAudioReceiveStream");
   RTC_DCHECK_RUN_ON(&configuration_sequence_checker_);
   RegisterRateObserver();
-  event_log_->Log(absl::make_unique<RtcEventAudioReceiveStreamConfig>(
+  event_log_->Log(std::make_unique<RtcEventAudioReceiveStreamConfig>(
       CreateRtcLogStreamConfig(config)));
   AudioReceiveStream* receive_stream = new AudioReceiveStream(
       clock_, &audio_receiver_controller_, transport_send_ptr_->packet_router(),
@@ -748,7 +747,7 @@
   video_send_delay_stats_->AddSsrcs(config);
   for (size_t ssrc_index = 0; ssrc_index < config.rtp.ssrcs.size();
        ++ssrc_index) {
-    event_log_->Log(absl::make_unique<RtcEventVideoSendStreamConfig>(
+    event_log_->Log(std::make_unique<RtcEventVideoSendStreamConfig>(
         CreateRtcLogStreamConfig(config, ssrc_index)));
   }
 
@@ -786,7 +785,7 @@
   std::unique_ptr<FecController> fec_controller =
       config_.fec_controller_factory
           ? config_.fec_controller_factory->CreateFecController()
-          : absl::make_unique<FecControllerDefault>(clock_);
+          : std::make_unique<FecControllerDefault>(clock_);
   return CreateVideoSendStream(std::move(config), std::move(encoder_config),
                                std::move(fec_controller));
 }
@@ -862,7 +861,7 @@
   }
   receive_stream->SignalNetworkState(video_network_state_);
   UpdateAggregateNetworkState();
-  event_log_->Log(absl::make_unique<RtcEventVideoReceiveStreamConfig>(
+  event_log_->Log(std::make_unique<RtcEventVideoReceiveStreamConfig>(
       CreateRtcLogStreamConfig(config)));
   return receive_stream;
 }
@@ -1222,7 +1221,7 @@
   }
 
   if (rtcp_delivered) {
-    event_log_->Log(absl::make_unique<RtcEventRtcpPacketIncoming>(
+    event_log_->Log(std::make_unique<RtcEventRtcpPacketIncoming>(
         rtc::MakeArrayView(packet, length)));
   }
 
@@ -1284,7 +1283,7 @@
       received_bytes_per_second_counter_.Add(length);
       received_audio_bytes_per_second_counter_.Add(length);
       event_log_->Log(
-          absl::make_unique<RtcEventRtpPacketIncoming>(parsed_packet));
+          std::make_unique<RtcEventRtpPacketIncoming>(parsed_packet));
       const int64_t arrival_time_ms = parsed_packet.arrival_time_ms();
       if (!first_received_rtp_audio_ms_) {
         first_received_rtp_audio_ms_.emplace(arrival_time_ms);
@@ -1298,7 +1297,7 @@
       received_bytes_per_second_counter_.Add(length);
       received_video_bytes_per_second_counter_.Add(length);
       event_log_->Log(
-          absl::make_unique<RtcEventRtpPacketIncoming>(parsed_packet));
+          std::make_unique<RtcEventRtpPacketIncoming>(parsed_packet));
       const int64_t arrival_time_ms = parsed_packet.arrival_time_ms();
       if (!first_received_rtp_video_ms_) {
         first_received_rtp_video_ms_.emplace(arrival_time_ms);
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 1a9b5e5..5bdc6c1 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -13,7 +13,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/memory/memory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/test/simulated_network.h"
@@ -217,28 +216,28 @@
                    return pair.second == MediaType::VIDEO;
                  });
 
-    audio_send_transport = absl::make_unique<test::PacketTransport>(
+    audio_send_transport = std::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
         test::PacketTransport::kSender, audio_pt_map,
-        absl::make_unique<FakeNetworkPipe>(
+        std::make_unique<FakeNetworkPipe>(
             Clock::GetRealTimeClock(),
-            absl::make_unique<SimulatedNetwork>(audio_net_config)));
+            std::make_unique<SimulatedNetwork>(audio_net_config)));
     audio_send_transport->SetReceiver(receiver_call_->Receiver());
 
-    video_send_transport = absl::make_unique<test::PacketTransport>(
+    video_send_transport = std::make_unique<test::PacketTransport>(
         &task_queue_, sender_call_.get(), &observer,
         test::PacketTransport::kSender, video_pt_map,
-        absl::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
-                                           BuiltInNetworkBehaviorConfig())));
+        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                          std::make_unique<SimulatedNetwork>(
+                                              BuiltInNetworkBehaviorConfig())));
     video_send_transport->SetReceiver(receiver_call_->Receiver());
 
-    receive_transport = absl::make_unique<test::PacketTransport>(
+    receive_transport = std::make_unique<test::PacketTransport>(
         &task_queue_, receiver_call_.get(), &observer,
         test::PacketTransport::kReceiver, payload_type_map_,
-        absl::make_unique<FakeNetworkPipe>(
-            Clock::GetRealTimeClock(), absl::make_unique<SimulatedNetwork>(
-                                           BuiltInNetworkBehaviorConfig())));
+        std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                          std::make_unique<SimulatedNetwork>(
+                                              BuiltInNetworkBehaviorConfig())));
     receive_transport->SetReceiver(sender_call_->Receiver());
 
     CreateSendConfig(1, 0, 0, video_send_transport.get());
@@ -283,7 +282,7 @@
     }
     EXPECT_EQ(1u, video_receive_streams_.size());
     observer.set_receive_stream(video_receive_streams_[0]);
-    drifting_clock = absl::make_unique<DriftingClock>(clock_, video_ntp_speed);
+    drifting_clock = std::make_unique<DriftingClock>(clock_, video_ntp_speed);
     CreateFrameGeneratorCapturerWithDrift(drifting_clock.get(), video_rtp_speed,
                                           kDefaultFramerate, kDefaultWidth,
                                           kDefaultHeight);
@@ -383,9 +382,9 @@
       return new test::PacketTransport(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           payload_type_map_,
-          absl::make_unique<FakeNetworkPipe>(
+          std::make_unique<FakeNetworkPipe>(
               Clock::GetRealTimeClock(),
-              absl::make_unique<SimulatedNetwork>(net_config_)));
+              std::make_unique<SimulatedNetwork>(net_config_)));
     }
 
     test::PacketTransport* CreateReceiveTransport(
@@ -394,9 +393,9 @@
       return new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
-          absl::make_unique<FakeNetworkPipe>(
+          std::make_unique<FakeNetworkPipe>(
               Clock::GetRealTimeClock(),
-              absl::make_unique<SimulatedNetwork>(net_config_)));
+              std::make_unique<SimulatedNetwork>(net_config_)));
     }
 
     void OnFrame(const VideoFrame& video_frame) override {
@@ -890,26 +889,26 @@
         test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       auto network =
-          absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
+          std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
       send_simulated_network_ = network.get();
       return new test::PacketTransport(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           test::CallTest::payload_type_map_,
-          absl::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                             std::move(network)));
+          std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                            std::move(network)));
     }
 
     test::PacketTransport* CreateReceiveTransport(
         test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         override {
       auto network =
-          absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
+          std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
       receive_simulated_network_ = network.get();
       return new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           test::CallTest::payload_type_map_,
-          absl::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                             std::move(network)));
+          std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                            std::move(network)));
     }
 
     void PerformTest() override {
diff --git a/call/degraded_call.cc b/call/degraded_call.cc
index 5de50fd..9c8d2be 100644
--- a/call/degraded_call.cc
+++ b/call/degraded_call.cc
@@ -10,9 +10,9 @@
 
 #include "call/degraded_call.h"
 
+#include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/location.h"
 
 namespace webrtc {
@@ -137,16 +137,16 @@
       send_simulated_network_(nullptr),
       receive_config_(receive_config) {
   if (receive_config_) {
-    auto network = absl::make_unique<SimulatedNetwork>(*receive_config_);
+    auto network = std::make_unique<SimulatedNetwork>(*receive_config_);
     receive_simulated_network_ = network.get();
     receive_pipe_ =
-        absl::make_unique<webrtc::FakeNetworkPipe>(clock_, std::move(network));
+        std::make_unique<webrtc::FakeNetworkPipe>(clock_, std::move(network));
     receive_pipe_->SetReceiver(call_->Receiver());
   }
   if (send_config_) {
-    auto network = absl::make_unique<SimulatedNetwork>(*send_config_);
+    auto network = std::make_unique<SimulatedNetwork>(*send_config_);
     send_simulated_network_ = network.get();
-    send_pipe_ = absl::make_unique<FakeNetworkPipeOnTaskQueue>(
+    send_pipe_ = std::make_unique<FakeNetworkPipeOnTaskQueue>(
         task_queue_factory_, clock_, std::move(network));
   }
 }
@@ -156,7 +156,7 @@
 AudioSendStream* DegradedCall::CreateAudioSendStream(
     const AudioSendStream::Config& config) {
   if (send_config_) {
-    auto transport_adapter = absl::make_unique<FakeNetworkPipeTransportAdapter>(
+    auto transport_adapter = std::make_unique<FakeNetworkPipeTransportAdapter>(
         send_pipe_.get(), call_.get(), clock_, config.send_transport);
     AudioSendStream::Config degrade_config = config;
     degrade_config.send_transport = transport_adapter.get();
@@ -190,7 +190,7 @@
     VideoEncoderConfig encoder_config) {
   std::unique_ptr<FakeNetworkPipeTransportAdapter> transport_adapter;
   if (send_config_) {
-    transport_adapter = absl::make_unique<FakeNetworkPipeTransportAdapter>(
+    transport_adapter = std::make_unique<FakeNetworkPipeTransportAdapter>(
         send_pipe_.get(), call_.get(), clock_, config.send_transport);
     config.send_transport = transport_adapter.get();
   }
@@ -208,7 +208,7 @@
     std::unique_ptr<FecController> fec_controller) {
   std::unique_ptr<FakeNetworkPipeTransportAdapter> transport_adapter;
   if (send_config_) {
-    transport_adapter = absl::make_unique<FakeNetworkPipeTransportAdapter>(
+    transport_adapter = std::make_unique<FakeNetworkPipeTransportAdapter>(
         send_pipe_.get(), call_.get(), clock_, config.send_transport);
     config.send_transport = transport_adapter.get();
   }
diff --git a/call/fake_network_pipe_unittest.cc b/call/fake_network_pipe_unittest.cc
index da84470..9c4a3bf 100644
--- a/call/fake_network_pipe_unittest.cc
+++ b/call/fake_network_pipe_unittest.cc
@@ -13,7 +13,6 @@
 #include <memory>
 #include <utility>
 
-#include "absl/memory/memory.h"
 #include "call/simulated_network.h"
 #include "system_wrappers/include/clock.h"
 #include "test/gmock.h"
@@ -74,7 +73,7 @@
   config.queue_length_packets = 20;
   config.link_capacity_kbps = 80;
   MockReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
@@ -115,7 +114,7 @@
   config.queue_delay_ms = 100;
   config.link_capacity_kbps = 80;
   MockReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
@@ -150,7 +149,7 @@
   config.queue_length_packets = 2;
   config.link_capacity_kbps = 80;
   MockReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
@@ -175,7 +174,7 @@
   config.queue_delay_ms = 20;
   config.link_capacity_kbps = 80;
   MockReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
@@ -370,7 +369,7 @@
   config.loss_percent = kLossPercent;
   config.avg_burst_loss_length = kAvgBurstLength;
   ReorderTestReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
@@ -403,7 +402,7 @@
   BuiltInNetworkBehaviorConfig config;
   config.link_capacity_kbps = 800;
   MockReceiver receiver;
-  auto simulated_network = absl::make_unique<SimulatedNetwork>(config);
+  auto simulated_network = std::make_unique<SimulatedNetwork>(config);
   std::unique_ptr<FakeNetworkPipe> pipe(new FakeNetworkPipe(
       &fake_clock_, std::move(simulated_network), &receiver));
 
diff --git a/call/flexfec_receive_stream_unittest.cc b/call/flexfec_receive_stream_unittest.cc
index 45f4589..5e8ee47 100644
--- a/call/flexfec_receive_stream_unittest.cc
+++ b/call/flexfec_receive_stream_unittest.cc
@@ -14,7 +14,6 @@
 #include <memory>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "api/array_view.h"
 #include "api/call/transport.h"
 #include "api/rtp_headers.h"
@@ -89,7 +88,7 @@
   FlexfecReceiveStreamTest()
       : config_(CreateDefaultConfig(&rtcp_send_transport_)) {
     EXPECT_CALL(process_thread_, RegisterModule(_, _)).Times(1);
-    receive_stream_ = absl::make_unique<FlexfecReceiveStreamImpl>(
+    receive_stream_ = std::make_unique<FlexfecReceiveStreamImpl>(
         Clock::GetRealTimeClock(), &rtp_stream_receiver_controller_, config_,
         &recovered_packet_receiver_, &rtt_stats_, &process_thread_);
   }
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index b3f2063..841f4d6 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -13,7 +13,6 @@
 #include <memory>
 
 #include "absl/flags/flag.h"
-#include "absl/memory/memory.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
 #include "api/rtc_event_log_output_file.h"
 #include "api/task_queue/default_task_queue_factory.h"
@@ -120,13 +119,13 @@
 test::PacketTransport* RampUpTester::CreateSendTransport(
     test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
-  auto network = absl::make_unique<SimulatedNetwork>(forward_transport_config_);
+  auto network = std::make_unique<SimulatedNetwork>(forward_transport_config_);
   send_simulated_network_ = network.get();
   send_transport_ = new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
       test::CallTest::payload_type_map_,
-      absl::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
-                                         std::move(network)));
+      std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
+                                        std::move(network)));
   return send_transport_;
 }
 
@@ -641,11 +640,11 @@
           RtcEventLog::EncodingType::Legacy);
       bool event_log_started =
           send_event_log_->StartLogging(
-              absl::make_unique<RtcEventLogOutputFile>(
+              std::make_unique<RtcEventLogOutputFile>(
                   dump_name + ".send.rtc.dat", RtcEventLog::kUnlimitedOutput),
               RtcEventLog::kImmediateOutput) &&
           recv_event_log_->StartLogging(
-              absl::make_unique<RtcEventLogOutputFile>(
+              std::make_unique<RtcEventLogOutputFile>(
                   dump_name + ".recv.rtc.dat", RtcEventLog::kUnlimitedOutput),
               RtcEventLog::kImmediateOutput);
       RTC_DCHECK(event_log_started);
diff --git a/call/receive_time_calculator.cc b/call/receive_time_calculator.cc
index 200d594..0675de0 100644
--- a/call/receive_time_calculator.cc
+++ b/call/receive_time_calculator.cc
@@ -10,10 +10,10 @@
 
 #include "call/receive_time_calculator.h"
 
+#include <memory>
 #include <string>
 #include <type_traits>
 
-#include "absl/memory/memory.h"
 #include "rtc_base/experiments/field_trial_parser.h"
 #include "rtc_base/numerics/safe_minmax.h"
 #include "system_wrappers/include/field_trial.h"
@@ -47,7 +47,7 @@
 ReceiveTimeCalculator::CreateFromFieldTrial() {
   if (!IsEnabled(kBweReceiveTimeCorrection))
     return nullptr;
-  return absl::make_unique<ReceiveTimeCalculator>();
+  return std::make_unique<ReceiveTimeCalculator>();
 }
 
 int64_t ReceiveTimeCalculator::ReconcileReceiveTimes(int64_t packet_time_us,
diff --git a/call/rtp_demuxer_unittest.cc b/call/rtp_demuxer_unittest.cc
index 0a08c869..86b458a 100644
--- a/call/rtp_demuxer_unittest.cc
+++ b/call/rtp_demuxer_unittest.cc
@@ -14,7 +14,6 @@
 #include <set>
 #include <string>
 
-#include "absl/memory/memory.h"
 #include "call/ssrc_binding_observer.h"
 #include "call/test/mock_rtp_packet_sink_interface.h"
 #include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
@@ -134,7 +133,7 @@
   std::unique_ptr<RtpPacketReceived> CreatePacket(
       uint32_t ssrc,
       RtpPacketReceived::ExtensionManager* extension_manager) {
-    auto packet = absl::make_unique<RtpPacketReceived>(extension_manager);
+    auto packet = std::make_unique<RtpPacketReceived>(extension_manager);
     packet->SetSsrc(ssrc);
     packet->SetSequenceNumber(next_sequence_number_++);
     return packet;
diff --git a/call/rtp_stream_receiver_controller.cc b/call/rtp_stream_receiver_controller.cc
index 3fae021..0fc8b26 100644
--- a/call/rtp_stream_receiver_controller.cc
+++ b/call/rtp_stream_receiver_controller.cc
@@ -10,7 +10,8 @@
 
 #include "call/rtp_stream_receiver_controller.h"
 
-#include "absl/memory/memory.h"
+#include <memory>
+
 #include "rtc_base/logging.h"
 
 namespace webrtc {
@@ -46,7 +47,7 @@
 std::unique_ptr<RtpStreamReceiverInterface>
 RtpStreamReceiverController::CreateReceiver(uint32_t ssrc,
                                             RtpPacketSinkInterface* sink) {
-  return absl::make_unique<Receiver>(this, ssrc, sink);
+  return std::make_unique<Receiver>(this, ssrc, sink);
 }
 
 bool RtpStreamReceiverController::OnRtpPacket(const RtpPacketReceived& packet) {
diff --git a/call/rtp_transport_controller_send.cc b/call/rtp_transport_controller_send.cc
index 82b345c..41954b9 100644
--- a/call/rtp_transport_controller_send.cc
+++ b/call/rtp_transport_controller_send.cc
@@ -9,10 +9,10 @@
  */
 #include "call/rtp_transport_controller_send.h"
 
+#include <memory>
 #include <utility>
 #include <vector>
 
-#include "absl/memory/memory.h"
 #include "absl/types/optional.h"
 #include "api/transport/goog_cc_factory.h"
 #include "api/transport/network_types.h"
@@ -72,7 +72,7 @@
       observer_(nullptr),
       controller_factory_override_(controller_factory),
       controller_factory_fallback_(
-          absl::make_unique<GoogCcNetworkControllerFactory>(predictor_factory)),
+          std::make_unique<GoogCcNetworkControllerFactory>(predictor_factory)),
       process_interval_(controller_factory_fallback_->GetProcessInterval()),
       last_report_block_time_(Timestamp::ms(clock_->TimeInMilliseconds())),
       reset_feedback_on_route_change_(
@@ -112,7 +112,7 @@
     RtcEventLog* event_log,
     std::unique_ptr<FecController> fec_controller,
     const RtpSenderFrameEncryptionConfig& frame_encryption_config) {
-  video_rtp_senders_.push_back(absl::make_unique<RtpVideoSender>(
+  video_rtp_senders_.push_back(std::make_unique<RtpVideoSender>(
       clock_, suspended_ssrcs, states, rtp_config, rtcp_report_interval_ms,
       send_transport, observers,
       // TODO(holmer): Remove this circular dependency by injecting
@@ -265,7 +265,7 @@
     transport_overhead_bytes_per_packet_ = network_route.packet_overhead;
 
     if (event_log_) {
-      event_log_->Log(absl::make_unique<RtcEventRouteChange>(
+      event_log_->Log(std::make_unique<RtcEventRouteChange>(
           network_route.connected, network_route.packet_overhead));
     }
     NetworkRouteChange msg;
@@ -490,7 +490,7 @@
 
   if (!network_available_ || !observer_)
     return;
-  control_handler_ = absl::make_unique<CongestionControlHandler>();
+  control_handler_ = std::make_unique<CongestionControlHandler>();
 
   initial_config_.constraints.at_time =
       Timestamp::ms(clock_->TimeInMilliseconds());
diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc
index 420c442..a88cc2c 100644
--- a/call/rtp_video_sender.cc
+++ b/call/rtp_video_sender.cc
@@ -16,7 +16,6 @@
 #include <utility>
 
 #include "absl/algorithm/container.h"
-#include "absl/memory/memory.h"
 #include "api/array_view.h"
 #include "api/transport/field_trial_based_config.h"
 #include "call/rtp_transport_controller_send_interface.h"
@@ -118,7 +117,7 @@
                                     *configuration.local_media_ssrc) !=
                               flexfec_protected_ssrcs.end();
     configuration.flexfec_sender = enable_flexfec ? flexfec_sender : nullptr;
-    auto playout_delay_oracle = absl::make_unique<PlayoutDelayOracle>();
+    auto playout_delay_oracle = std::make_unique<PlayoutDelayOracle>();
 
     configuration.ack_observer = playout_delay_oracle.get();
     if (rtp_config.rtx.ssrcs.size() > i) {
@@ -130,7 +129,7 @@
     rtp_rtcp->SetSendingMediaStatus(false);
     rtp_rtcp->SetRTCPStatus(RtcpMode::kCompound);
 
-    auto sender_video = absl::make_unique<RTPSenderVideo>(
+    auto sender_video = std::make_unique<RTPSenderVideo>(
         configuration.clock, rtp_rtcp->RtpSender(),
         configuration.flexfec_sender, playout_delay_oracle.get(),
         frame_encryptor, crypto_options.sframe.require_frame_encryption,
@@ -192,7 +191,7 @@
   }
 
   RTC_DCHECK_EQ(1U, rtp.flexfec.protected_media_ssrcs.size());
-  return absl::make_unique<FlexfecSender>(
+  return std::make_unique<FlexfecSender>(
       rtp.flexfec.payload_type, rtp.flexfec.ssrc,
       rtp.flexfec.protected_media_ssrcs[0], rtp.mid, rtp.extensions,
       RTPSender::FecExtensionSizes(), rtp_state, clock);
diff --git a/call/rtp_video_sender_unittest.cc b/call/rtp_video_sender_unittest.cc
index 1fb24ab..17ee9c6 100644
--- a/call/rtp_video_sender_unittest.cc
+++ b/call/rtp_video_sender_unittest.cc
@@ -13,7 +13,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/memory/memory.h"
 #include "api/task_queue/default_task_queue_factory.h"
 #include "call/rtp_transport_controller_send.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
@@ -137,7 +136,7 @@
                      VideoEncoderConfig::ContentType::kRealtimeVideo),
         retransmission_rate_limiter_(&clock_, kRetransmitWindowSizeMs) {
     std::map<uint32_t, RtpState> suspended_ssrcs;
-    router_ = absl::make_unique<RtpVideoSender>(
+    router_ = std::make_unique<RtpVideoSender>(
         &clock_, suspended_ssrcs, suspended_payload_states, config_.rtp,
         config_.rtcp_report_interval_ms, &transport_,
         CreateObservers(&call_stats_, &encoder_feedback_, &stats_proxy_,
@@ -145,7 +144,7 @@
                         frame_count_observer, &stats_proxy_, &stats_proxy_,
                         &send_delay_stats_),
         &transport_controller_, &event_log_, &retransmission_rate_limiter_,
-        absl::make_unique<FecControllerDefault>(&clock_), nullptr,
+        std::make_unique<FecControllerDefault>(&clock_), nullptr,
         CryptoOptions{});
   }
   RtpVideoSenderTestFixture(