Propagate task queue to create test::DirectTransport by TaskQueueBase interface

actual task queue implementation for these tests is intentionally unchanged for now.

while at it, change return type of created transports to unique_ptr to note passing ownership.

Bug: webrtc:10933
Change-Id: I324597b503e647c471f43511340eb9c07ba03ee8
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/154743
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29335}

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",

audio/test/audio_bwe_integration_test.cc

@@ -58,10 +58,10 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
   send_audio_device_ = send_audio_device;
 }
 
-test::PacketTransport* AudioBweTest::CreateSendTransport(
+std::unique_ptr<test::PacketTransport> AudioBweTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    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(
+std::unique_ptr<test::PacketTransport> AudioBweTest::CreateReceiveTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
+    TaskQueueBase* task_queue) {
-  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>(

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
-  test::PacketTransport* CreateReceiveTransport(
+  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
+      TaskQueueBase* task_queue) override;
 
   void PerformTest() override;
 

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(
+std::unique_ptr<test::PacketTransport> AudioEndToEndTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    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(
+std::unique_ptr<test::PacketTransport>
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
+AudioEndToEndTest::CreateReceiveTransport(TaskQueueBase* task_queue) {
-  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>(

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
-  test::PacketTransport* CreateReceiveTransport(
+  std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
+      TaskQueueBase* task_queue) override;
 
   void ModifyAudioConfigs(
       AudioSendStream::Config* send_config,

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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        TaskQueueBase* task_queue) override {
-        override {
+      return std::make_unique<test::PacketTransport>(
-      return new 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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        TaskQueueBase* task_queue) override {
-        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(),

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(
+std::unique_ptr<test::PacketTransport> RampUpTester::CreateSendTransport(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    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 {

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* sender_call) override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,

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_));
+    receive_transport_ = test->CreateReceiveTransport(&task_queue_);
-    send_transport_.reset(
+    send_transport_ =
-        test->CreateSendTransport(&task_queue_, sender_call_.get()));
+        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(
+std::unique_ptr<PacketTransport> BaseTest::CreateSendTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    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(
+std::unique_ptr<PacketTransport> BaseTest::CreateReceiveTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
+    TaskQueueBase* task_queue) {
-  return new PacketTransport(
+  return std::make_unique<PacketTransport>(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       CallTest::payload_type_map_,
       std::make_unique<FakeNetworkPipe>(

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(
+  virtual std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* sender_call);
-  virtual test::PacketTransport* CreateReceiveTransport(
+  virtual std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
+      TaskQueueBase* task_queue);
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,

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,

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",

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(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        TaskQueueBase* task_queue) override {
-        override {
+      auto receive_transport = std::make_unique<test::PacketTransport>(
-      receive_transport_ = new 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(

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      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(),

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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>(

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 =
+    sender_transport = CreateSendTransport(task_queue_, sender_call.get());
-        absl::WrapUnique(CreateSendTransport(task_queue_, sender_call.get()));
+    receiver_transport =
-    receiver_transport = absl::WrapUnique(
+        CreateReceiveTransport(task_queue_, receiver_call.get());
-        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(
+std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    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(
+std::unique_ptr<test::DirectTransport>
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+MultiStreamTester::CreateReceiveTransport(TaskQueueBase* task_queue,
                                           Call* receiver_call) {
-  return new test::DirectTransport(
+  return std::make_unique<test::DirectTransport>(
       task_queue,
       std::make_unique<FakeNetworkPipe>(
           Clock::GetRealTimeClock(),

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(
+  virtual std::unique_ptr<test::DirectTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* sender_call);
-  virtual test::DirectTransport* CreateReceiveTransport(
+  virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       Call* receiver_call);
 
   test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;

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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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(),

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(
+    std::unique_ptr<test::PacketTransport> CreateReceiveTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        TaskQueueBase* task_queue) override {
-        override {
+      auto receive_transport = std::make_unique<test::PacketTransport>(
-      test::PacketTransport* receive_transport = new 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;
     }
 

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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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_));
+    receive_transport_ = test.CreateReceiveTransport(&task_queue_);
-    send_transport_.reset(
+    send_transport_ =
-        test.CreateSendTransport(&task_queue_, sender_call_.get()));
+        test.CreateSendTransport(&task_queue_, sender_call_.get());
     send_transport_->SetReceiver(receiver_call_->Receiver());
     receive_transport_->SetReceiver(sender_call_->Receiver());
 

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(
+    std::unique_ptr<test::DirectTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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:

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"

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"

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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      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(
+  std::unique_ptr<test::PacketTransport> CreateSendTransport(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      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(
+    std::unique_ptr<test::PacketTransport> CreateSendTransport(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+        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>(