diff --git a/audio/BUILD.gn b/audio/BUILD.gn
index 5bb7b8ce61..bfda54292f 100644
--- a/audio/BUILD.gn
+++ b/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",
diff --git a/call/call_perf_tests.cc b/call/call_perf_tests.cc
index f6d6f787e0..34a1045d28 100644
--- a/call/call_perf_tests.cc
+++ b/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_);
 
diff --git a/test/BUILD.gn b/test/BUILD.gn
index f47936f332..c0646d3b15 100644
--- a/test/BUILD.gn
+++ b/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",
diff --git a/test/direct_transport.cc b/test/direct_transport.cc
index 0d626de692..84273b0830 100644
--- a/test/direct_transport.cc
+++ b/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 {
diff --git a/test/direct_transport.h b/test/direct_transport.h
index e011664c34..e0b2251eea 100644
--- a/test/direct_transport.h
+++ b/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 {
 
diff --git a/test/layer_filtering_transport.cc b/test/layer_filtering_transport.cc
index 6edf3b2358..b400a6dfa9 100644
--- a/test/layer_filtering_transport.cc
+++ b/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,
diff --git a/test/layer_filtering_transport.h b/test/layer_filtering_transport.h
index 8a682378dc..5703da8ea1 100644
--- a/test/layer_filtering_transport.h
+++ b/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,
diff --git a/test/rtp_rtcp_observer.h b/test/rtp_rtcp_observer.h
index b6b521d6b6..6996a69e48 100644
--- a/test/rtp_rtcp_observer.h
+++ b/test/rtp_rtcp_observer.h
@@ -33,7 +33,6 @@ namespace webrtc {
 namespace test {
 
 class PacketTransport;
-class DEPRECATED_SingleThreadedTaskQueueForTesting;
 
 class RtpRtcpObserver {
  public:
diff --git a/test/run_loop.cc b/test/run_loop.cc
index 0f69e25ff1..1fc200f929 100644
--- a/test/run_loop.cc
+++ b/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))
     ;
diff --git a/test/run_loop.h b/test/run_loop.h
index 41525d8def..414e72c65b 100644
--- a/test/run_loop.h
+++ b/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
diff --git a/test/win/run_loop_win.cc b/test/win/run_loop_win.cc
index 93bd90da06..95de16bf24 100644
--- a/test/win/run_loop_win.cc
+++ b/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);
diff --git a/video/end_to_end_tests/bandwidth_tests.cc b/video/end_to_end_tests/bandwidth_tests.cc
index 03ac8b2403..440a128ad4 100644
--- a/video/end_to_end_tests/bandwidth_tests.cc
+++ b/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_;
diff --git a/video/end_to_end_tests/extended_reports_tests.cc b/video/end_to_end_tests/extended_reports_tests.cc
index b29fca367d..f4938c943b 100644
--- a/video/end_to_end_tests/extended_reports_tests.cc
+++ b/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 {
diff --git a/video/end_to_end_tests/multi_stream_tester.cc b/video/end_to_end_tests/multi_stream_tester.cc
index 33f67e6d60..104b9d4609 100644
--- a/video/end_to_end_tests/multi_stream_tester.cc
+++ b/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};
diff --git a/video/end_to_end_tests/multi_stream_tester.h b/video/end_to_end_tests/multi_stream_tester.h
index c5f538fec9..845442e39a 100644
--- a/video/end_to_end_tests/multi_stream_tester.h
+++ b/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_
diff --git a/video/end_to_end_tests/multi_stream_tests.cc b/video/end_to_end_tests/multi_stream_tests.cc
index 404a558360..6d2a04e817 100644
--- a/video/end_to_end_tests/multi_stream_tests.cc
+++ b/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() {}
 
diff --git a/video/end_to_end_tests/network_state_tests.cc b/video/end_to_end_tests/network_state_tests.cc
index a81aa5f5fd..a2b1beb16e 100644
--- a/video/end_to_end_tests/network_state_tests.cc
+++ b/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_;
diff --git a/video/end_to_end_tests/probing_tests.cc b/video/end_to_end_tests/probing_tests.cc
index abdff44b00..1885829131 100644
--- a/video/end_to_end_tests/probing_tests.cc
+++ b/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_;
diff --git a/video/end_to_end_tests/retransmission_tests.cc b/video/end_to_end_tests/retransmission_tests.cc
index 266b719ee7..1058db685b 100644
--- a/video/end_to_end_tests/retransmission_tests.cc
+++ b/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);
diff --git a/video/end_to_end_tests/transport_feedback_tests.cc b/video/end_to_end_tests/transport_feedback_tests.cc
index 0d55fbfbe1..8e59ea84de 100644
--- a/video/end_to_end_tests/transport_feedback_tests.cc
+++ b/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) {}
diff --git a/video/video_analyzer.h b/video/video_analyzer.h
index be771f423c..1069abf1ce 100644
--- a/video/video_analyzer.h
+++ b/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"
diff --git a/video/video_quality_test.cc b/video/video_quality_test.cc
index 47f407d77c..091c1f3d2b 100644
--- a/video/video_quality_test.cc
+++ b/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();
diff --git a/video/video_send_stream_tests.cc b/video/video_send_stream_tests.cc
index 8df54e7d90..554c1ffbb0 100644
--- a/video/video_send_stream_tests.cc
+++ b/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_;