Use deprecated SingleThreadedTaskQueueForTesting as regular task queue

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

audio/BUILD.gn

@@ -273,7 +273,6 @@ if (rtc_include_tests) {
       "../system_wrappers",
       "../test:field_trial",
       "../test:fileutils",
-      "../test:single_threaded_task_queue",
       "../test:test_common",
       "../test:test_main",
       "../test:test_support",

call/call_perf_tests.cc

@@ -44,7 +44,6 @@
 #include "test/null_transport.h"
 #include "test/rtp_header_parser.h"
 #include "test/rtp_rtcp_observer.h"
-#include "test/single_threaded_task_queue.h"
 #include "test/testsupport/file_utils.h"
 #include "test/testsupport/perf_test.h"
 #include "test/video_encoder_proxy_factory.h"
@@ -862,14 +861,13 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
 
   class MinVideoAndAudioBitrateTester : public test::EndToEndTest {
    public:
-    MinVideoAndAudioBitrateTester(
-        int test_bitrate_from,
-        int test_bitrate_to,
-        int test_bitrate_step,
-        int min_bwe,
-        int start_bwe,
-        int max_bwe,
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    MinVideoAndAudioBitrateTester(int test_bitrate_from,
+                                  int test_bitrate_to,
+                                  int test_bitrate_step,
+                                  int min_bwe,
+                                  int start_bwe,
+                                  int max_bwe,
+                                  TaskQueueBase* task_queue)
         : EndToEndTest(),
           test_bitrate_from_(test_bitrate_from),
           test_bitrate_to_(test_bitrate_to),
@@ -984,7 +982,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     SimulatedNetwork* send_simulated_network_;
     SimulatedNetwork* receive_simulated_network_;
     Call* sender_call_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
   } test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe,
          start_bwe, max_bwe, &task_queue_);
 

test/BUILD.gn

@@ -623,7 +623,6 @@ rtc_library("direct_transport") {
     "//third_party/abseil-cpp/absl/memory",
   ]
   public_deps = [  # no-presubmit-check TODO(webrtc:8603)
-    ":single_threaded_task_queue",
     "../call:fake_network",
   ]
 }
@@ -749,6 +748,7 @@ rtc_library("test_common") {
     ":fake_video_codecs",
     ":fileutils",
     ":rtp_test_utils",
+    ":single_threaded_task_queue",
     ":test_support",
     ":video_test_common",
     "../api:rtp_headers",

test/direct_transport.cc

@@ -17,7 +17,6 @@
 #include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/time_utils.h"
 #include "test/rtp_header_parser.h"
-#include "test/single_threaded_task_queue.h"
 
 namespace webrtc {
 namespace test {

test/direct_transport.h

@@ -20,7 +20,6 @@
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/thread_annotations.h"
-#include "test/single_threaded_task_queue.h"
 
 namespace webrtc {
 

test/layer_filtering_transport.cc

@@ -30,7 +30,7 @@ namespace webrtc {
 namespace test {
 
 LayerFilteringTransport::LayerFilteringTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    TaskQueueBase* task_queue,
     std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
     Call* send_call,
     uint8_t vp8_video_payload_type,
@@ -50,7 +50,7 @@ LayerFilteringTransport::LayerFilteringTransport(
       ssrc_to_filter_max_(ssrc_to_filter_max) {}
 
 LayerFilteringTransport::LayerFilteringTransport(
-    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+    TaskQueueBase* task_queue,
     std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
     Call* send_call,
     uint8_t vp8_video_payload_type,

test/layer_filtering_transport.h

@@ -21,7 +21,6 @@
 #include "call/call.h"
 #include "call/simulated_packet_receiver.h"
 #include "test/direct_transport.h"
-#include "test/single_threaded_task_queue.h"
 
 namespace webrtc {
 
@@ -30,7 +29,7 @@ namespace test {
 class LayerFilteringTransport : public test::DirectTransport {
  public:
   LayerFilteringTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
       Call* send_call,
       uint8_t vp8_video_payload_type,
@@ -41,7 +40,7 @@ class LayerFilteringTransport : public test::DirectTransport {
       uint32_t ssrc_to_filter_min,
       uint32_t ssrc_to_filter_max);
   LayerFilteringTransport(
-      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
+      TaskQueueBase* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
       Call* send_call,
       uint8_t vp8_video_payload_type,

test/rtp_rtcp_observer.h

@@ -33,7 +33,6 @@ namespace webrtc {
 namespace test {
 
 class PacketTransport;
-class DEPRECATED_SingleThreadedTaskQueueForTesting;
 
 class RtpRtcpObserver {
  public:

test/run_loop.cc

@@ -14,7 +14,7 @@
 namespace webrtc {
 namespace test {
 
-void PressEnterToContinue(DEPRECATED_SingleThreadedTaskQueueForTesting&) {
+void PressEnterToContinue(TaskQueueBase* /*task_queue*/) {
   puts(">> Press ENTER to continue...");
   while (getc(stdin) != '\n' && !feof(stdin))
     ;

test/run_loop.h

@@ -10,14 +10,13 @@
 #ifndef TEST_RUN_LOOP_H_
 #define TEST_RUN_LOOP_H_
 
-#include "test/single_threaded_task_queue.h"
+#include "api/task_queue/task_queue_base.h"
 
 namespace webrtc {
 namespace test {
 
 // Blocks until the user presses enter.
-void PressEnterToContinue(
-    DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue);
+void PressEnterToContinue(TaskQueueBase* task_queue);
 
 }  // namespace test
 }  // namespace webrtc

test/win/run_loop_win.cc

@@ -18,13 +18,12 @@
 namespace webrtc {
 namespace test {
 
-void PressEnterToContinue(
-    DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue) {
+void PressEnterToContinue(TaskQueueBase* task_queue) {
   puts(">> Press ENTER to continue...");
 
   while (!_kbhit() || _getch() != '\r') {
     // Drive the message loop for the thread running the task_queue
-    SendTask(RTC_FROM_HERE, &task_queue, [&]() {
+    SendTask(RTC_FROM_HERE, task_queue, [&]() {
       MSG msg;
       if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
         TranslateMessage(&msg);

video/end_to_end_tests/bandwidth_tests.cc

@@ -19,6 +19,7 @@
 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "rtc_base/rate_limiter.h"
 #include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/to_queued_task.h"
 #include "system_wrappers/include/sleep.h"
 #include "test/call_test.h"
 #include "test/fake_encoder.h"
@@ -81,9 +82,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
 
 class BandwidthStatsTest : public test::EndToEndTest {
  public:
-  BandwidthStatsTest(
-      bool send_side_bwe,
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+  BandwidthStatsTest(bool send_side_bwe, TaskQueueBase* task_queue)
       : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
         sender_call_(nullptr),
         receiver_call_(nullptr),
@@ -107,7 +106,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
   Action OnSendRtp(const uint8_t* packet, size_t length) override {
     // Stats need to be fetched on the thread where the caller objects were
     // constructed.
-    task_queue_->PostTask([this]() {
+    task_queue_->PostTask(ToQueuedTask([this]() {
       Call::Stats sender_stats = sender_call_->GetStats();
       if (!has_seen_pacer_delay_)
         has_seen_pacer_delay_ = sender_stats.pacer_delay_ms > 0;
@@ -117,7 +116,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
         if (send_side_bwe_ || receiver_stats.recv_bandwidth_bps > 0)
           observation_complete_.Set();
       }
-    });
+    }));
 
     return SEND_PACKET;
   }
@@ -137,7 +136,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
   Call* receiver_call_;
   bool has_seen_pacer_delay_;
   const bool send_side_bwe_;
-  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+  TaskQueueBase* const task_queue_;
 };
 
 TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
@@ -158,8 +157,7 @@ TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
 TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
   class BweObserver : public test::EndToEndTest {
    public:
-    explicit BweObserver(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit BweObserver(TaskQueueBase* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           sender_call_(nullptr),
           clock_(Clock::GetRealTimeClock()),
@@ -214,11 +212,10 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
     void OnCallsCreated(Call* sender_call, Call* receiver_call) override {
       RTC_DCHECK(sender_call);
       sender_call_ = sender_call;
-      pending_task_ = task_queue_->PostTask([this]() { PollStats(); });
+      task_queue_->PostTask(ToQueuedTask([this]() { PollStats(); }));
     }
 
     void PollStats() {
-      pending_task_ = ~0;  // for debugging purposes indicate no pending task.
       Call::Stats stats = sender_call_->GetStats();
       switch (state_) {
         case kWaitForFirstRampUp:
@@ -251,8 +248,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
           break;
       }
 
-      pending_task_ =
-          task_queue_->PostDelayedTask([this]() { PollStats(); }, 1000);
+      task_queue_->PostDelayedTask(ToQueuedTask([this] { PollStats(); }), 1000);
     }
 
     void PerformTest() override {
@@ -271,9 +267,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
     test::PacketTransport* receive_transport_;
     TestState state_;
     RateLimiter retransmission_rate_limiter_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId pending_task_ =
-        ~0;
+    TaskQueueBase* const task_queue_;
   } test(&task_queue_);
 
   RunBaseTest(&test);
@@ -289,8 +283,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
   class EncoderRateStatsTest : public test::EndToEndTest,
                                public test::FakeEncoder {
    public:
-    explicit EncoderRateStatsTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit EncoderRateStatsTest(TaskQueueBase* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -365,7 +358,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
     }
 
    private:
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* send_stream_;
     test::VideoEncoderProxyFactory encoder_factory_;

video/end_to_end_tests/extended_reports_tests.cc

@@ -40,7 +40,6 @@
 #include "test/gtest.h"
 #include "test/rtcp_packet_parser.h"
 #include "test/rtp_rtcp_observer.h"
-#include "test/single_threaded_task_queue.h"
 
 namespace webrtc {
 namespace {

video/end_to_end_tests/multi_stream_tester.cc

@@ -31,8 +31,7 @@
 
 namespace webrtc {
 
-MultiStreamTester::MultiStreamTester(
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+MultiStreamTester::MultiStreamTester(TaskQueueBase* task_queue)
     : task_queue_(task_queue) {
   // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
   codec_settings[0] = {1, 640, 480};

video/end_to_end_tests/multi_stream_tester.h

@@ -35,8 +35,7 @@ class MultiStreamTester {
     int height;
   } codec_settings[kNumStreams];
 
-  explicit MultiStreamTester(
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
+  explicit MultiStreamTester(TaskQueueBase* task_queue);
 
   virtual ~MultiStreamTester();
 
@@ -60,7 +59,7 @@ class MultiStreamTester {
       TaskQueueBase* task_queue,
       Call* receiver_call);
 
-  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+  TaskQueueBase* const task_queue_;
 };
 }  // namespace webrtc
 #endif  // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_

video/end_to_end_tests/multi_stream_tests.cc

@@ -24,7 +24,6 @@
 #include "test/call_test.h"
 #include "test/frame_generator_capturer.h"
 #include "test/gtest.h"
-#include "test/single_threaded_task_queue.h"
 #include "video/end_to_end_tests/multi_stream_tester.h"
 
 namespace webrtc {
@@ -63,8 +62,7 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
 
   class Tester : public MultiStreamTester {
    public:
-    explicit Tester(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit Tester(TaskQueueBase* task_queue)
         : MultiStreamTester(task_queue) {}
     virtual ~Tester() {}
 

video/end_to_end_tests/network_state_tests.cc

@@ -161,8 +161,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
   static const int kNumAcceptedDowntimeRtcp = 1;
   class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
    public:
-    explicit NetworkStateTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit NetworkStateTest(TaskQueueBase* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -339,7 +338,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
       }
     }
 
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     rtc::CriticalSection test_crit_;
     rtc::Event encoded_frames_;
     rtc::Event packet_event_;

video/end_to_end_tests/probing_tests.cc

@@ -69,9 +69,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
 
   class InitialProbingTest : public ProbingTest {
    public:
-    explicit InitialProbingTest(
-        bool* success,
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit InitialProbingTest(bool* success, TaskQueueBase* task_queue)
         : ProbingTest(300000), success_(success), task_queue_(task_queue) {
       *success_ = false;
     }
@@ -97,7 +95,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
    private:
     const int kTimeoutMs = 1000;
     bool* const success_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
   };
 
   bool success = false;
@@ -124,9 +122,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
 
   class TriggerMidCallProbingTest : public ProbingTest {
    public:
-    TriggerMidCallProbingTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
-        bool* success)
+    TriggerMidCallProbingTest(TaskQueueBase* task_queue, bool* success)
         : ProbingTest(300000), success_(success), task_queue_(task_queue) {}
 
     void PerformTest() override {
@@ -179,7 +175,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
    private:
     const int kTimeoutMs = 5000;
     bool* const success_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
   };
 
   bool success = false;
@@ -204,9 +200,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
 
   class ReconfigureTest : public ProbingTest {
    public:
-    ReconfigureTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
-        bool* success)
+    ReconfigureTest(TaskQueueBase* task_queue, bool* success)
         : ProbingTest(50000), task_queue_(task_queue), success_(success) {}
 
     void ModifyVideoConfigs(
@@ -309,7 +303,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
     const int kTimeoutMs = 10000;
     const int kRampUpMaxDurationMs = 500;
 
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     bool* const success_;
     SimulatedNetwork* send_simulated_network_;
     VideoSendStream* send_stream_;

video/end_to_end_tests/retransmission_tests.cc

@@ -203,8 +203,7 @@ TEST_F(RetransmissionEndToEndTest,
        StopSendingKeyframeRequestsForInactiveStream) {
   class KeyframeRequestObserver : public test::EndToEndTest {
    public:
-    explicit KeyframeRequestObserver(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit KeyframeRequestObserver(TaskQueueBase* task_queue)
         : clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
 
     void OnVideoStreamsCreated(
@@ -236,7 +235,7 @@ TEST_F(RetransmissionEndToEndTest,
     Clock* clock_;
     VideoSendStream* send_stream_;
     VideoReceiveStream* receive_stream_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
   } test(&task_queue_);
 
   RunBaseTest(&test);

video/end_to_end_tests/transport_feedback_tests.cc

@@ -166,8 +166,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
 
   class TransportSequenceNumberTester : public MultiStreamTester {
    public:
-    explicit TransportSequenceNumberTester(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit TransportSequenceNumberTester(TaskQueueBase* task_queue)
         : MultiStreamTester(task_queue),
           first_media_ssrc_(0),
           observer_(nullptr) {}

video/video_analyzer.h

@@ -18,7 +18,9 @@
 
 #include "api/task_queue/task_queue_base.h"
 #include "api/video/video_source_interface.h"
+#include "rtc_base/event.h"
 #include "rtc_base/numerics/running_statistics.h"
+#include "rtc_base/platform_thread.h"
 #include "rtc_base/time_utils.h"
 #include "test/layer_filtering_transport.h"
 #include "test/rtp_file_writer.h"

video/video_quality_test.cc

@@ -1564,7 +1564,7 @@ void VideoQualityTest::RunWithRenderers(const Params& params) {
     Start();
   });
 
-  test::PressEnterToContinue(task_queue_);
+  test::PressEnterToContinue(&task_queue_);
 
   SendTask(RTC_FROM_HERE, &task_queue_, [&]() {
     Stop();

video/video_send_stream_tests.cc

@@ -38,6 +38,7 @@
 #include "rtc_base/rate_limiter.h"
 #include "rtc_base/synchronization/sequence_checker.h"
 #include "rtc_base/task_queue_for_test.h"
+#include "rtc_base/task_utils/to_queued_task.h"
 #include "rtc_base/time_utils.h"
 #include "rtc_base/unique_id_generator.h"
 #include "system_wrappers/include/sleep.h"
@@ -1692,8 +1693,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
   static const uint8_t kExtensionId = kTransportSequenceNumberExtensionId;
   class ChangingNetworkRouteTest : public test::EndToEndTest {
    public:
-    explicit ChangingNetworkRouteTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit ChangingNetworkRouteTest(TaskQueueBase* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           task_queue_(task_queue),
           call_(nullptr) {
@@ -1735,14 +1735,14 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
 
     Action OnSendRtp(const uint8_t* packet, size_t length) override {
       RTC_DCHECK_RUN_ON(&module_process_thread_);
-      task_queue_->PostTask([this]() {
+      task_queue_->PostTask(ToQueuedTask([this]() {
         RTC_DCHECK_RUN_ON(&task_queue_thread_);
         if (!call_)
           return;
         Call::Stats stats = call_->GetStats();
         if (stats.send_bandwidth_bps > kStartBitrateBps)
           observation_complete_.Set();
-      });
+      }));
       return SEND_PACKET;
     }
 
@@ -1791,7 +1791,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
    private:
     webrtc::SequenceChecker module_process_thread_;
     webrtc::SequenceChecker task_queue_thread_;
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     Call* call_ RTC_GUARDED_BY(task_queue_thread_);
   } test(&task_queue_);
 
@@ -1801,8 +1801,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
 TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
   class ChangingTransportOverheadTest : public test::EndToEndTest {
    public:
-    explicit ChangingTransportOverheadTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit ChangingTransportOverheadTest(TaskQueueBase* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           task_queue_(task_queue),
           call_(nullptr),
@@ -1853,7 +1852,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
     }
 
    private:
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     Call* call_;
     rtc::CriticalSection lock_;
     int packets_sent_ RTC_GUARDED_BY(lock_);
@@ -1876,10 +1875,9 @@ class MaxPaddingSetTest : public test::SendTest {
   static const uint32_t kActualEncodeBitrateBps = 40000;
   static const uint32_t kMinPacketsToSend = 50;
 
-  MaxPaddingSetTest(
-      bool test_switch_content_type,
-      T* stream_reset_fun,
-      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+  MaxPaddingSetTest(bool test_switch_content_type,
+                    T* stream_reset_fun,
+                    TaskQueueBase* task_queue)
       : SendTest(test::CallTest::kDefaultTimeoutMs),
         running_without_padding_(test_switch_content_type),
         stream_resetter_(stream_reset_fun),
@@ -1922,7 +1920,7 @@ class MaxPaddingSetTest : public test::SendTest {
     // Check the stats on the correct thread and signal the 'complete' flag
     // once we detect that we're done.
 
-    task_queue_->PostTask([this]() {
+    task_queue_->PostTask(ToQueuedTask([this]() {
       RTC_DCHECK_RUN_ON(&task_queue_thread_);
       // In case we get a callback during teardown.
       // When this happens, OnStreamsStopped() has been called already,
@@ -1957,7 +1955,7 @@ class MaxPaddingSetTest : public test::SendTest {
           observation_complete_.Set();
         }
       }
-    });
+    }));
 
     return SEND_PACKET;
   }
@@ -1982,7 +1980,7 @@ class MaxPaddingSetTest : public test::SendTest {
   uint32_t packets_sent_ RTC_GUARDED_BY(task_queue_thread_) = 0;
   bool running_without_padding_ RTC_GUARDED_BY(task_queue_thread_);
   T* const stream_resetter_;
-  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+  TaskQueueBase* const task_queue_;
 };
 
 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) {
@@ -2353,8 +2351,7 @@ VideoFrame CreateVideoFrame(int width, int height, uint8_t data) {
 TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
   class EncoderStateObserver : public test::SendTest, public VideoEncoder {
    public:
-    explicit EncoderStateObserver(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit EncoderStateObserver(TaskQueueBase* task_queue)
         : SendTest(kDefaultTimeoutMs),
           task_queue_(task_queue),
           stream_(nullptr),
@@ -2458,7 +2455,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
     }
 
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* stream_;
     bool initialized_ RTC_GUARDED_BY(crit_);
@@ -2814,8 +2811,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
                                           public VideoBitrateAllocatorFactory,
                                           public test::FakeEncoder {
    public:
-    explicit EncoderBitrateThresholdObserver(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit EncoderBitrateThresholdObserver(TaskQueueBase* task_queue)
         : SendTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -2979,7 +2975,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
       EXPECT_EQ(1, num_encoder_initializations_);
     }
 
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     rtc::Event create_rate_allocator_event_;
     rtc::Event init_encode_event_;
     rtc::Event bitrate_changed_event_;
@@ -3655,8 +3651,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
   class RemoveOverheadFromBandwidthTest : public test::EndToEndTest,
                                           public test::FakeEncoder {
    public:
-    explicit RemoveOverheadFromBandwidthTest(
-        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+    explicit RemoveOverheadFromBandwidthTest(TaskQueueBase* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -3721,7 +3716,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
     }
 
    private:
-    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
+    TaskQueueBase* const task_queue_;
     test::VideoEncoderProxyFactory encoder_factory_;
     Call* call_;
     rtc::CriticalSection crit_;