diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index b24584c473..fa16bb796d 100644
--- a/audio/BUILD.gn
+++ b/audio/BUILD.gn
@@ -102,6 +102,7 @@ if (rtc_include_tests) {
     deps = [
       ":audio",
       "../api:simulated_network_api",
+      "../api/task_queue",
       "../call:fake_network",
       "../call:simulated_network",
       "../system_wrappers",
diff --git a/audio/test/audio_bwe_integration_test.cc b/audio/test/audio_bwe_integration_test.cc
index ac8eb338ef..eed7acb8de 100644
--- a/audio/test/audio_bwe_integration_test.cc
+++ b/audio/test/audio_bwe_integration_test.cc
@@ -58,10 +58,10 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
   send_audio_device_ = send_audio_device;
 }
 
-test::PacketTransport* AudioBweTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+std::unique_ptr<test::PacketTransport> AudioBweTest::CreateSendTransport(
+    TaskQueueBase* task_queue,
     Call* sender_call) {
-  return new test::PacketTransport(
+  return std::make_unique<test::PacketTransport>(
       task_queue, sender_call, this, test::PacketTransport::kSender,
       test::CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
@@ -69,9 +69,9 @@ test::PacketTransport* AudioBweTest::CreateSendTransport(
           std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
-test::PacketTransport* AudioBweTest::CreateReceiveTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
-  return new test::PacketTransport(
+std::unique_ptr<test::PacketTransport> AudioBweTest::CreateReceiveTransport(
+    TaskQueueBase* task_queue) {
+  return std::make_unique<test::PacketTransport>(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       test::CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
diff --git a/audio/test/audio_bwe_integration_test.h b/audio/test/audio_bwe_integration_test.h
index 78e783a2a4..613efcc1dd 100644
--- a/audio/test/audio_bwe_integration_test.h
+++ b/audio/test/audio_bwe_integration_test.h
@@ -13,9 +13,9 @@
 #include <memory>
 #include <string>
 
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "test/call_test.h"
-#include "test/single_threaded_task_queue.h"
 
 namespace webrtc {
 namespace test {
@@ -39,11 +39,11 @@ class AudioBweTest : public test::EndToEndTest {
       TestAudioDeviceModule* send_audio_device,
       TestAudioDeviceModule* recv_audio_device) override;
 
-  test::PacketTransport* CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
-  test::PacketTransport* CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
+  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue) override;
 
   void PerformTest() override;
 
diff --git a/audio/test/audio_end_to_end_test.cc b/audio/test/audio_end_to_end_test.cc
index 40d1226546..896b0f2dae 100644
--- a/audio/test/audio_end_to_end_test.cc
+++ b/audio/test/audio_end_to_end_test.cc
@@ -13,6 +13,7 @@
 #include <algorithm>
 #include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
 #include "system_wrappers/include/sleep.h"
@@ -62,10 +63,10 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
   send_audio_device_ = send_audio_device;
 }
 
-test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+std::unique_ptr<test::PacketTransport> AudioEndToEndTest::CreateSendTransport(
+    TaskQueueBase* task_queue,
     Call* sender_call) {
-  return new test::PacketTransport(
+  return std::make_unique<test::PacketTransport>(
       task_queue, sender_call, this, test::PacketTransport::kSender,
       test::CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
@@ -73,9 +74,9 @@ test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
           std::make_unique<SimulatedNetwork>(GetNetworkPipeConfig())));
 }
 
-test::PacketTransport* AudioEndToEndTest::CreateReceiveTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
-  return new test::PacketTransport(
+std::unique_ptr<test::PacketTransport>
+AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) {
+  return std::make_unique<test::PacketTransport>(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       test::CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
diff --git a/audio/test/audio_end_to_end_test.h b/audio/test/audio_end_to_end_test.h
index b729c75ace..c47cb47076 100644
--- a/audio/test/audio_end_to_end_test.h
+++ b/audio/test/audio_end_to_end_test.h
@@ -14,6 +14,7 @@
 #include <string>
 #include <vector>
 
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "test/call_test.h"
 
@@ -42,11 +43,11 @@ class AudioEndToEndTest : public test::EndToEndTest {
       TestAudioDeviceModule* send_audio_device,
       TestAudioDeviceModule* recv_audio_device) override;
 
-  test::PacketTransport* CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
-  test::PacketTransport* CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
+  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue) override;
 
   void ModifyAudioConfigs(
       AudioSendStream::Config* send_config,
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index 5bdc6c13fa..41e61dc77d 100644
--- a/call/call_perf_tests.cc
+++ b/call/call_perf_tests.cc
@@ -15,6 +15,7 @@
 
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/rtc_event_log/rtc_event_log.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/video_bitrate_allocation.h"
@@ -376,10 +377,10 @@ void CallPerfTest::TestCaptureNtpTime(
           rtp_start_timestamp_(0) {}
 
    private:
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
@@ -387,10 +388,9 @@ void CallPerfTest::TestCaptureNtpTime(
               std::make_unique<SimulatedNetwork>(net_config_)));
     }
 
-    test::PacketTransport* CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
-        override {
-      return new test::PacketTransport(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+        TaskQueueBase* task_queue) override {
+      return std::make_unique<test::PacketTransport>(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
@@ -885,26 +885,25 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
       return pipe_config;
     }
 
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       auto network =
           std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
       send_simulated_network_ = network.get();
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           test::CallTest::payload_type_map_,
           std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
                                             std::move(network)));
     }
 
-    test::PacketTransport* CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
-        override {
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+        TaskQueueBase* task_queue) override {
       auto network =
           std::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
       receive_simulated_network_ = network.get();
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           test::CallTest::payload_type_map_,
           std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
diff --git a/call/rampup_tests.cc b/call/rampup_tests.cc
index 841f4d6189..2485aa8e63 100644
--- a/call/rampup_tests.cc
+++ b/call/rampup_tests.cc
@@ -16,6 +16,7 @@
 #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"
+#include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "call/fake_network_pipe.h"
 #include "rtc_base/checks.h"
@@ -116,17 +117,18 @@ void RampUpTester::OnVideoStreamsCreated(
   send_stream_ = send_stream;
 }
 
-test::PacketTransport* RampUpTester::CreateSendTransport(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+std::unique_ptr<test::PacketTransport> RampUpTester::CreateSendTransport(
+    TaskQueueBase* task_queue,
     Call* sender_call) {
   auto network = std::make_unique<SimulatedNetwork>(forward_transport_config_);
   send_simulated_network_ = network.get();
-  send_transport_ = new test::PacketTransport(
+  auto send_transport = std::make_unique<test::PacketTransport>(
       task_queue, sender_call, this, test::PacketTransport::kSender,
       test::CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
                                         std::move(network)));
-  return send_transport_;
+  send_transport_ = send_transport.get();
+  return send_transport;
 }
 
 size_t RampUpTester::GetNumVideoStreams() const {
diff --git a/call/rampup_tests.h b/call/rampup_tests.h
index 2204927b14..34e174014e 100644
--- a/call/rampup_tests.h
+++ b/call/rampup_tests.h
@@ -12,11 +12,13 @@
 #define CALL_RAMPUP_TESTS_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "api/rtc_event_log/rtc_event_log.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "call/call.h"
 #include "call/simulated_network.h"
@@ -87,8 +89,8 @@ class RampUpTester : public test::EndToEndTest {
   void OnVideoStreamsCreated(
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams) override;
-  test::PacketTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
diff --git a/test/call_test.cc b/test/call_test.cc
index 557c84264d..30369a638c 100644
--- a/test/call_test.cc
+++ b/test/call_test.cc
@@ -16,6 +16,7 @@
 #include "api/audio_codecs/builtin_audio_decoder_factory.h"
 #include "api/audio_codecs/builtin_audio_encoder_factory.h"
 #include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video_codecs/video_encoder_config.h"
 #include "call/fake_network_pipe.h"
@@ -133,9 +134,9 @@ void CallTest::RunBaseTest(BaseTest* test) {
       CreateReceiverCall(recv_config);
     }
     test->OnCallsCreated(sender_call_.get(), receiver_call_.get());
-    receive_transport_.reset(test->CreateReceiveTransport(&task_queue_));
-    send_transport_.reset(
-        test->CreateSendTransport(&task_queue_, sender_call_.get()));
+    receive_transport_ = test->CreateReceiveTransport(&task_queue_);
+    send_transport_ =
+        test->CreateSendTransport(&task_queue_, sender_call_.get());
 
     if (test->ShouldCreateReceivers()) {
       send_transport_->SetReceiver(receiver_call_->Receiver());
@@ -776,10 +777,10 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
 
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
 
-test::PacketTransport* BaseTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport(
+    TaskQueueBase* task_queue,
     Call* sender_call) {
-  return new PacketTransport(
+  return std::make_unique<PacketTransport>(
       task_queue, sender_call, this, test::PacketTransport::kSender,
       CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
@@ -787,9 +788,9 @@ test::PacketTransport* BaseTest::CreateSendTransport(
           std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())));
 }
 
-test::PacketTransport* BaseTest::CreateReceiveTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
-  return new PacketTransport(
+std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport(
+    TaskQueueBase* task_queue) {
+  return std::make_unique<PacketTransport>(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(
diff --git a/test/call_test.h b/test/call_test.h
index b1990a74f2..234741bafb 100644
--- a/test/call_test.h
+++ b/test/call_test.h
@@ -17,6 +17,7 @@
 
 #include "absl/types/optional.h"
 #include "api/rtc_event_log/rtc_event_log.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "api/test/video/function_video_decoder_factory.h"
 #include "api/test/video/function_video_encoder_factory.h"
@@ -260,11 +261,11 @@ class BaseTest : public RtpRtcpObserver {
 
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
 
-  virtual test::PacketTransport* CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call);
-  virtual test::PacketTransport* CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
+  virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue);
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h
index 956eb00d64..b6b521d6b6 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -85,7 +85,7 @@ class PacketTransport : public test::DirectTransport {
  public:
   enum TransportType { kReceiver, kSender };
 
-  PacketTransport(DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  PacketTransport(TaskQueueBase* task_queue,
                   Call* send_call,
                   RtpRtcpObserver* observer,
                   TransportType transport_type,
diff --git a/video/BUILD.gn b/video/BUILD.gn
index dfb1e5a1ce..4cb3d6dda6 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -570,6 +570,7 @@ if (rtc_include_tests) {
       "../api:simulated_network_api",
       "../api/crypto:options",
       "../api/rtc_event_log",
+      "../api/task_queue",
       "../api/task_queue:default_task_queue_factory",
       "../api/test/video:function_video_factory",
       "../api/units:data_rate",
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index b56ac7913b..a8a16233eb 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/video/end_to_end_tests/bandwidth_tests.cc
@@ -10,6 +10,7 @@
 
 #include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/video_bitrate_allocation.h"
@@ -170,16 +171,16 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
 
     ~BweObserver() {}
 
-    test::PacketTransport* CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
-        override {
-      receive_transport_ = new test::PacketTransport(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+        TaskQueueBase* task_queue) override {
+      auto receive_transport = std::make_unique<test::PacketTransport>(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
               Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                              BuiltInNetworkBehaviorConfig())));
-      return receive_transport_;
+      receive_transport_ = receive_transport.get();
+      return receive_transport;
     }
 
     void ModifySenderBitrateConfig(
diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc
index bdaa492ffa..b29fca367d 100644
--- a/video/end_to_end_tests/extended_reports_tests.cc
+++ b/video/end_to_end_tests/extended_reports_tests.cc
@@ -18,6 +18,7 @@
 
 #include "absl/types/optional.h"
 #include "api/rtp_headers.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/video_codecs/sdp_video_format.h"
 #include "api/video_codecs/video_encoder_config.h"
@@ -158,13 +159,13 @@ class RtcpXrObserver : public test::EndToEndTest {
     return enable_zero_target_bitrate_ ? 2 : 1;
   }
 
-  test::PacketTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) {
     auto network =
         std::make_unique<SimulatedNetwork>(forward_transport_config_);
     send_simulated_network_ = network.get();
-    return new test::PacketTransport(
+    return std::make_unique<test::PacketTransport>(
         task_queue, sender_call, this, test::PacketTransport::kSender,
         test::CallTest::payload_type_map_,
         std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
diff --git a/video/end_to_end_tests/fec_tests.cc b/video/end_to_end_tests/fec_tests.cc
index e08fc88ef4..801f91cba5 100644
--- a/video/end_to_end_tests/fec_tests.cc
+++ b/video/end_to_end_tests/fec_tests.cc
@@ -10,6 +10,7 @@
 
 #include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/test/video/function_video_encoder_factory.h"
 #include "call/fake_network_pipe.h"
@@ -246,14 +247,14 @@ class FlexfecRenderObserver : public test::EndToEndTest,
     return SEND_PACKET;
   }
 
-  test::PacketTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
     BuiltInNetworkBehaviorConfig config;
     config.queue_delay_ms = kNetworkDelayMs;
-    return new test::PacketTransport(
+    return std::make_unique<test::PacketTransport>(
         task_queue, sender_call, this, test::PacketTransport::kSender,
         test::CallTest::payload_type_map_,
         std::make_unique<FakeNetworkPipe>(
@@ -431,15 +432,15 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
       return SEND_PACKET;
     }
 
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
       // Configure some network delay.
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
       config.queue_delay_ms = kNetworkDelayMs;
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc
index 97b0cb9ffa..a515b0fa08 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/video/end_to_end_tests/multi_stream_tester.cc
@@ -17,6 +17,7 @@
 #include "absl/memory/memory.h"
 #include "api/rtc_event_log/rtc_event_log.h"
 #include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/test/video/function_video_encoder_factory.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
@@ -66,10 +67,9 @@ void MultiStreamTester::RunTest() {
   task_queue_->SendTask([&]() {
     sender_call = absl::WrapUnique(Call::Create(config));
     receiver_call = absl::WrapUnique(Call::Create(config));
-    sender_transport =
-        absl::WrapUnique(CreateSendTransport(task_queue_, sender_call.get()));
-    receiver_transport = absl::WrapUnique(
-        CreateReceiveTransport(task_queue_, receiver_call.get()));
+    sender_transport = CreateSendTransport(task_queue_, sender_call.get());
+    receiver_transport =
+        CreateReceiveTransport(task_queue_, receiver_call.get());
 
     sender_transport->SetReceiver(receiver_call->Receiver());
     receiver_transport->SetReceiver(sender_call->Receiver());
@@ -151,10 +151,10 @@ void MultiStreamTester::UpdateReceiveConfig(
     size_t stream_index,
     VideoReceiveStream::Config* receive_config) {}
 
-test::DirectTransport* MultiStreamTester::CreateSendTransport(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
+    TaskQueueBase* task_queue,
     Call* sender_call) {
-  return new test::DirectTransport(
+  return std::make_unique<test::DirectTransport>(
       task_queue,
       std::make_unique<FakeNetworkPipe>(
           Clock::GetRealTimeClock(),
@@ -162,10 +162,10 @@ test::DirectTransport* MultiStreamTester::CreateSendTransport(
       sender_call, payload_type_map_);
 }
 
-test::DirectTransport* MultiStreamTester::CreateReceiveTransport(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
-    Call* receiver_call) {
-  return new test::DirectTransport(
+std::unique_ptr<test::DirectTransport>
+MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
+                                          Call* receiver_call) {
+  return std::make_unique<test::DirectTransport>(
       task_queue,
       std::make_unique<FakeNetworkPipe>(
           Clock::GetRealTimeClock(),
diff --git a/video/end_to_end_tests/multi_stream_tester.h b/video/end_to_end_tests/multi_stream_tester.h
index 45871085a6..c5f538fec9 100644
--- a/video/end_to_end_tests/multi_stream_tester.h
+++ b/video/end_to_end_tests/multi_stream_tester.h
@@ -12,7 +12,9 @@
 #define VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_
 
 #include <map>
+#include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "call/call.h"
 #include "test/direct_transport.h"
 #include "test/frame_generator_capturer.h"
@@ -51,11 +53,11 @@ class MultiStreamTester {
                                 test::FrameGeneratorCapturer** frame_generator);
   virtual void UpdateReceiveConfig(size_t stream_index,
                                    VideoReceiveStream::Config* receive_config);
-  virtual test::DirectTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  virtual std::unique_ptr<test::DirectTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call);
-  virtual test::DirectTransport* CreateReceiveTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
+      TaskQueueBase* task_queue,
       Call* receiver_call);
 
   test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc
index 402db913a4..02e06d14f0 100644
--- a/video/end_to_end_tests/probing_tests.cc
+++ b/video/end_to_end_tests/probing_tests.cc
@@ -10,6 +10,7 @@
 
 #include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
@@ -220,13 +221,13 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
       send_stream_ = send_stream;
     }
 
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       auto network =
           std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig());
       send_simulated_network_ = network.get();
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           CallTest::payload_type_map_,
           std::make_unique<FakeNetworkPipe>(Clock::GetRealTimeClock(),
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index a75b9eb7f8..b3f905b079 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/video/end_to_end_tests/retransmission_tests.cc
@@ -11,6 +11,7 @@
 #include <memory>
 
 #include "absl/algorithm/container.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/test/video/function_video_encoder_factory.h"
 #include "call/fake_network_pipe.h"
@@ -137,16 +138,15 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
     size_t GetNumVideoStreams() const override { return 0; }
     size_t GetNumAudioStreams() const override { return 1; }
 
-    test::PacketTransport* CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
-        override {
-      test::PacketTransport* receive_transport = new test::PacketTransport(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
+        TaskQueueBase* task_queue) override {
+      auto receive_transport = std::make_unique<test::PacketTransport>(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
               Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
                                              BuiltInNetworkBehaviorConfig())));
-      receive_transport_ = receive_transport;
+      receive_transport_ = receive_transport.get();
       return receive_transport;
     }
 
diff --git a/video/end_to_end_tests/stats_tests.cc b/video/end_to_end_tests/stats_tests.cc
index 2a8d903ab2..73f94b27db 100644
--- a/video/end_to_end_tests/stats_tests.cc
+++ b/video/end_to_end_tests/stats_tests.cc
@@ -11,6 +11,7 @@
 #include <memory>
 
 #include "absl/algorithm/container.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/test/video/function_video_encoder_factory.h"
 #include "call/fake_network_pipe.h"
@@ -232,12 +233,12 @@ TEST_F(StatsEndToEndTest, GetStats) {
       return true;
     }
 
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       BuiltInNetworkBehaviorConfig network_config;
       network_config.loss_percent = 5;
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(
@@ -530,9 +531,9 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
     CreateSenderCall(send_config);
     CreateReceiverCall(recv_config);
 
-    receive_transport_.reset(test.CreateReceiveTransport(&task_queue_));
-    send_transport_.reset(
-        test.CreateSendTransport(&task_queue_, sender_call_.get()));
+    receive_transport_ = test.CreateReceiveTransport(&task_queue_);
+    send_transport_ =
+        test.CreateSendTransport(&task_queue_, sender_call_.get());
     send_transport_->SetReceiver(receiver_call_->Receiver());
     receive_transport_->SetReceiver(sender_call_->Receiver());
 
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 1cefb167c1..2ea092b296 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/video/end_to_end_tests/transport_feedback_tests.cc
@@ -10,6 +10,7 @@
 
 #include <memory>
 
+#include "api/task_queue/task_queue_base.h"
 #include "call/call.h"
 #include "call/fake_network_pipe.h"
 #include "call/simulated_network.h"
@@ -39,7 +40,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        TaskQueueBase* task_queue,
         Call* sender_call,
         const uint32_t& first_media_ssrc,
         const std::map<uint32_t, uint32_t>& ssrc_map,
@@ -217,18 +218,19 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
       receive_config->renderer = &fake_renderer_;
     }
 
-    test::DirectTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::DirectTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       std::map<uint8_t, MediaType> payload_type_map =
           MultiStreamTester::payload_type_map_;
       RTC_DCHECK(payload_type_map.find(kSendRtxPayloadType) ==
                  payload_type_map.end());
       payload_type_map[kSendRtxPayloadType] = MediaType::VIDEO;
-      observer_ = new RtpExtensionHeaderObserver(
+      auto observer = std::make_unique<RtpExtensionHeaderObserver>(
           task_queue, sender_call, first_media_ssrc_, rtx_to_media_ssrcs_,
           payload_type_map);
-      return observer_;
+      observer_ = observer.get();
+      return observer;
     }
 
    private:
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index e1927312a3..db98dc0416 100644
--- a/video/video_quality_test.cc
+++ b/video/video_quality_test.cc
@@ -21,6 +21,7 @@
 #include "api/fec_controller_override.h"
 #include "api/rtc_event_log_output_file.h"
 #include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/transport/media/media_transport_config.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video_codecs/video_encoder.h"
diff --git a/video/video_quality_test.h b/video/video_quality_test.h
index 711e343942..c28769267d 100644
--- a/video/video_quality_test.h
+++ b/video/video_quality_test.h
@@ -17,6 +17,7 @@
 
 #include "api/fec_controller.h"
 #include "api/rtc_event_log/rtc_event_log_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/task_queue/task_queue_factory.h"
 #include "api/test/video_quality_test_fixture.h"
 #include "api/video/video_bitrate_allocator_factory.h"
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index ae56f9b8e1..e1e0bdb167 100644
--- a/video/video_send_stream_tests.cc
+++ b/video/video_send_stream_tests.cc
@@ -13,6 +13,7 @@
 
 #include "absl/algorithm/container.h"
 #include "api/task_queue/default_task_queue_factory.h"
+#include "api/task_queue/task_queue_base.h"
 #include "api/test/simulated_network.h"
 #include "api/video/builtin_video_bitrate_allocator_factory.h"
 #include "api/video/encoded_image.h"
@@ -554,8 +555,8 @@ class UlpfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  test::PacketTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Configure some network delay.
@@ -563,7 +564,7 @@ class UlpfecObserver : public test::EndToEndTest {
     BuiltInNetworkBehaviorConfig config;
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
-    return new test::PacketTransport(
+    return std::make_unique<test::PacketTransport>(
         task_queue, sender_call, this, test::PacketTransport::kSender,
         VideoSendStreamTest::payload_type_map_,
         std::make_unique<FakeNetworkPipe>(
@@ -751,8 +752,8 @@ class FlexfecObserver : public test::EndToEndTest {
     return SEND_PACKET;
   }
 
-  test::PacketTransport* CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
+      TaskQueueBase* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Therefore we need some network delay.
@@ -760,7 +761,7 @@ class FlexfecObserver : public test::EndToEndTest {
     BuiltInNetworkBehaviorConfig config;
     config.loss_percent = 5;
     config.queue_delay_ms = kNetworkDelayMs;
-    return new test::PacketTransport(
+    return std::make_unique<test::PacketTransport>(
         task_queue, sender_call, this, test::PacketTransport::kSender,
         VideoSendStreamTest::payload_type_map_,
         std::make_unique<FakeNetworkPipe>(
@@ -1531,15 +1532,15 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
       return SEND_PACKET;
     }
 
-    test::PacketTransport* CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
+        TaskQueueBase* task_queue,
         Call* sender_call) override {
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
       config.loss_percent = 10;
       config.link_capacity_kbps = kCapacityKbps;
       config.queue_delay_ms = kNetworkDelayMs;
-      return new test::PacketTransport(
+      return std::make_unique<test::PacketTransport>(
           task_queue, sender_call, this, test::PacketTransport::kSender,
           payload_type_map_,
           std::make_unique<FakeNetworkPipe>(