Deprecate SingleThreadedTaskQueueForTesting class.

This class doesn't strictly follow rtc::TaskQueue semantics,
which makes it surprising and hard to use correctly.
Please use TaskQueueForTest instead.

This CL follows usual deprecation process:

1/ Rename.
% for i in `git ls-files` ; sed -i "s:SingleThreadedTaskQueueForTesting:DEPRECATED_SingleThreadedTaskQueueForTesting:" $i

2/ Annotate old name for downstream users and accidental new uses.

Bug: webrtc:10933
Change-Id: I80b4ee5a48df1f63f63a43ed0efdb50eb7fb156a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/150788
Reviewed-by: Elad Alon <eladalon@webrtc.org>
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Tommi <tommi@webrtc.org>
Commit-Queue: Yves Gerey <yvesg@google.com>
Cr-Commit-Position: refs/heads/master@{#29045}

audio/test/audio_bwe_integration_test.cc

@@ -58,7 +58,7 @@ void AudioBweTest::OnFakeAudioDevicesCreated(
 }
 
 test::PacketTransport* AudioBweTest::CreateSendTransport(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
   return new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
@@ -69,7 +69,7 @@ test::PacketTransport* AudioBweTest::CreateSendTransport(
 }
 
 test::PacketTransport* AudioBweTest::CreateReceiveTransport(
-    SingleThreadedTaskQueueForTesting* task_queue) {
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
   return new test::PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       test::CallTest::payload_type_map_,

audio/test/audio_bwe_integration_test.h

@@ -40,10 +40,10 @@ class AudioBweTest : public test::EndToEndTest {
       TestAudioDeviceModule* recv_audio_device) override;
 
   test::PacketTransport* CreateSendTransport(
-      SingleThreadedTaskQueueForTesting* task_queue,
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override;
   test::PacketTransport* CreateReceiveTransport(
-      SingleThreadedTaskQueueForTesting* task_queue) override;
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
 
   void PerformTest() override;
 

audio/test/audio_end_to_end_test.cc

@@ -63,7 +63,7 @@ void AudioEndToEndTest::OnFakeAudioDevicesCreated(
 }
 
 test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
   return new test::PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
@@ -74,7 +74,7 @@ test::PacketTransport* AudioEndToEndTest::CreateSendTransport(
 }
 
 test::PacketTransport* AudioEndToEndTest::CreateReceiveTransport(
-    SingleThreadedTaskQueueForTesting* task_queue) {
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
   return new test::PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       test::CallTest::payload_type_map_,

audio/test/audio_end_to_end_test.h

@@ -43,10 +43,10 @@ class AudioEndToEndTest : public test::EndToEndTest {
       TestAudioDeviceModule* recv_audio_device) override;
 
   test::PacketTransport* CreateSendTransport(
-      SingleThreadedTaskQueueForTesting* task_queue,
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override;
   test::PacketTransport* CreateReceiveTransport(
-      SingleThreadedTaskQueueForTesting* task_queue) override;
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) override;
 
   void ModifyAudioConfigs(
       AudioSendStream::Config* send_config,

call/call_perf_tests.cc

@@ -378,7 +378,7 @@ void CallPerfTest::TestCaptureNtpTime(
 
    private:
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       return new test::PacketTransport(
           task_queue, sender_call, this, test::PacketTransport::kSender,
@@ -389,7 +389,8 @@ void CallPerfTest::TestCaptureNtpTime(
     }
 
     test::PacketTransport* CreateReceiveTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue) override {
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        override {
       return new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
@@ -868,7 +869,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
         int min_bwe,
         int start_bwe,
         int max_bwe,
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(),
           test_bitrate_from_(test_bitrate_from),
           test_bitrate_to_(test_bitrate_to),
@@ -886,7 +887,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     }
 
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       auto network =
           absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
@@ -899,7 +900,8 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     }
 
     test::PacketTransport* CreateReceiveTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue) override {
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        override {
       auto network =
           absl::make_unique<SimulatedNetwork>(GetFakeNetworkPipeConfig());
       receive_simulated_network_ = network.get();
@@ -982,7 +984,7 @@ void CallPerfTest::TestMinAudioVideoBitrate(int test_bitrate_from,
     SimulatedNetwork* send_simulated_network_;
     SimulatedNetwork* receive_simulated_network_;
     Call* sender_call_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
   } test(test_bitrate_from, test_bitrate_to, test_bitrate_step, min_bwe,
          start_bwe, max_bwe, &task_queue_);
 

call/rampup_tests.cc

@@ -53,7 +53,8 @@ std::vector<uint32_t> GenerateSsrcs(size_t num_streams, uint32_t ssrc_offset) {
 }
 }  // namespace
 
-RampUpTester::RampUpTester(size_t num_video_streams,
+RampUpTester::RampUpTester(
+    size_t num_video_streams,
     size_t num_audio_streams,
     size_t num_flexfec_streams,
     unsigned int start_bitrate_bps,
@@ -62,7 +63,7 @@ RampUpTester::RampUpTester(size_t num_video_streams,
     bool rtx,
     bool red,
     bool report_perf_stats,
-                           test::SingleThreadedTaskQueueForTesting* task_queue)
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
     : EndToEndTest(test::CallTest::kLongTimeoutMs),
       clock_(Clock::GetRealTimeClock()),
       num_video_streams_(num_video_streams),
@@ -94,7 +95,8 @@ RampUpTester::~RampUpTester() {
   // Special case for WebRTC-QuickPerfTest/Enabled/
   task_queue_->SendTask([this]() {
     if (pending_task_ !=
-        static_cast<test::SingleThreadedTaskQueueForTesting::TaskId>(-1)) {
+        static_cast<test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>(
+            -1)) {
       task_queue_->CancelTask(pending_task_);
       pending_task_ = -1;
     }
@@ -116,7 +118,7 @@ void RampUpTester::OnVideoStreamsCreated(
 }
 
 test::PacketTransport* RampUpTester::CreateSendTransport(
-    test::SingleThreadedTaskQueueForTesting* task_queue,
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
   auto network = absl::make_unique<SimulatedNetwork>(forward_transport_config_);
   send_simulated_network_ = network.get();
@@ -380,7 +382,8 @@ void RampUpTester::TriggerTestDone() {
   // Corner case for field_trials=WebRTC-QuickPerfTest/Enabled/
   task_queue_->SendTask([this]() {
     if (pending_task_ !=
-        static_cast<test::SingleThreadedTaskQueueForTesting::TaskId>(-1)) {
+        static_cast<test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>(
+            -1)) {
       task_queue_->CancelTask(pending_task_);
       pending_task_ = -1;
     }
@@ -453,7 +456,7 @@ RampUpDownUpTester::RampUpDownUpTester(
     bool red,
     const std::vector<int>& loss_rates,
     bool report_perf_stats,
-    test::SingleThreadedTaskQueueForTesting* task_queue)
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
     : RampUpTester(num_video_streams,
                    num_audio_streams,
                    num_flexfec_streams,

call/rampup_tests.h

@@ -43,7 +43,7 @@ class RampUpTester : public test::EndToEndTest {
                bool rtx,
                bool red,
                bool report_perf_stats,
-               test::SingleThreadedTaskQueueForTesting* task_queue);
+               test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
   ~RampUpTester() override;
 
   size_t GetNumVideoStreams() const override;
@@ -88,7 +88,7 @@ class RampUpTester : public test::EndToEndTest {
       VideoSendStream* send_stream,
       const std::vector<VideoReceiveStream*>& receive_streams) override;
   test::PacketTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override;
   void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,
@@ -127,13 +127,14 @@ class RampUpTester : public test::EndToEndTest {
   // Must be called from the |task_queue_|.
   int64_t GetIntervalForNextPoll();
 
-  test::SingleThreadedTaskQueueForTesting* const task_queue_;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
-  test::SingleThreadedTaskQueueForTesting::TaskId pending_task_ = -1;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId pending_task_ = -1;
 };
 
 class RampUpDownUpTester : public RampUpTester {
  public:
-  RampUpDownUpTester(size_t num_video_streams,
+  RampUpDownUpTester(
+      size_t num_video_streams,
       size_t num_audio_streams,
       size_t num_flexfec_streams,
       unsigned int start_bitrate_bps,
@@ -142,7 +143,7 @@ class RampUpDownUpTester : public RampUpTester {
       bool red,
       const std::vector<int>& loss_rates,
       bool report_perf_stats,
-                     test::SingleThreadedTaskQueueForTesting* task_queue);
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
   ~RampUpDownUpTester() override;
 
  protected:

test/BUILD.gn

@@ -626,6 +626,7 @@ rtc_source_set("single_threaded_task_queue") {
   ]
   deps = [
     "../rtc_base:checks",
+    "../rtc_base:deprecation",
     "../rtc_base:rtc_base_approved",
     "//third_party/abseil-cpp/absl/memory",
   ]

test/call_test.cc

@@ -778,7 +778,7 @@ void BaseTest::ModifyReceiverBitrateConfig(BitrateConstraints* bitrate_config) {
 void BaseTest::OnCallsCreated(Call* sender_call, Call* receiver_call) {}
 
 test::PacketTransport* BaseTest::CreateSendTransport(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
   return new PacketTransport(
       task_queue, sender_call, this, test::PacketTransport::kSender,
@@ -789,7 +789,7 @@ test::PacketTransport* BaseTest::CreateSendTransport(
 }
 
 test::PacketTransport* BaseTest::CreateReceiveTransport(
-    SingleThreadedTaskQueueForTesting* task_queue) {
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue) {
   return new PacketTransport(
       task_queue, nullptr, this, test::PacketTransport::kReceiver,
       CallTest::payload_type_map_,

test/call_test.h

@@ -220,7 +220,7 @@ class CallTest : public ::testing::Test {
   rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
   test::FakeVideoRenderer fake_renderer_;
 
-  SingleThreadedTaskQueueForTesting task_queue_;
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue_;
 
  private:
   absl::optional<RtpExtension> GetRtpExtensionByUri(
@@ -261,10 +261,10 @@ class BaseTest : public RtpRtcpObserver {
   virtual void OnCallsCreated(Call* sender_call, Call* receiver_call);
 
   virtual test::PacketTransport* CreateSendTransport(
-      SingleThreadedTaskQueueForTesting* task_queue,
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call);
   virtual test::PacketTransport* CreateReceiveTransport(
-      SingleThreadedTaskQueueForTesting* task_queue);
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
 
   virtual void ModifyVideoConfigs(
       VideoSendStream::Config* send_config,

test/direct_transport.cc

@@ -37,7 +37,7 @@ MediaType Demuxer::GetMediaType(const uint8_t* packet_data,
 }
 
 DirectTransport::DirectTransport(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
     Call* send_call,
     const std::map<uint8_t, MediaType>& payload_type_map)

test/direct_transport.h

@@ -39,7 +39,7 @@ class Demuxer {
 // same task-queue - the one that's passed in via the constructor.
 class DirectTransport : public Transport {
  public:
-  DirectTransport(SingleThreadedTaskQueueForTesting* task_queue,
+  DirectTransport(DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
                   std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
                   Call* send_call,
                   const std::map<uint8_t, MediaType>& payload_type_map);
@@ -65,11 +65,11 @@ class DirectTransport : public Transport {
 
   Call* const send_call_;
 
-  SingleThreadedTaskQueueForTesting* const task_queue_;
+  DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
 
   rtc::CriticalSection process_lock_;
-  absl::optional<SingleThreadedTaskQueueForTesting::TaskId> next_process_task_
+  absl::optional<DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId>
-      RTC_GUARDED_BY(&process_lock_);
+      next_process_task_ RTC_GUARDED_BY(&process_lock_);
 
   const Demuxer demuxer_;
   const std::unique_ptr<SimulatedPacketReceiverInterface> fake_network_;

test/layer_filtering_transport.cc

@@ -30,7 +30,7 @@ namespace webrtc {
 namespace test {
 
 LayerFilteringTransport::LayerFilteringTransport(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* 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(
-    SingleThreadedTaskQueueForTesting* task_queue,
+    DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
     Call* send_call,
     uint8_t vp8_video_payload_type,

test/layer_filtering_transport.h

@@ -30,7 +30,7 @@ namespace test {
 class LayerFilteringTransport : public test::DirectTransport {
  public:
   LayerFilteringTransport(
-      SingleThreadedTaskQueueForTesting* task_queue,
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
       Call* send_call,
       uint8_t vp8_video_payload_type,
@@ -41,7 +41,7 @@ class LayerFilteringTransport : public test::DirectTransport {
       uint32_t ssrc_to_filter_min,
       uint32_t ssrc_to_filter_max);
   LayerFilteringTransport(
-      SingleThreadedTaskQueueForTesting* task_queue,
+      DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       std::unique_ptr<SimulatedPacketReceiverInterface> pipe,
       Call* send_call,
       uint8_t vp8_video_payload_type,

test/rtp_rtcp_observer.h

@@ -33,7 +33,7 @@ namespace webrtc {
 namespace test {
 
 class PacketTransport;
-class SingleThreadedTaskQueueForTesting;
+class DEPRECATED_SingleThreadedTaskQueueForTesting;
 
 class RtpRtcpObserver {
  public:
@@ -85,7 +85,7 @@ class PacketTransport : public test::DirectTransport {
  public:
   enum TransportType { kReceiver, kSender };
 
-  PacketTransport(SingleThreadedTaskQueueForTesting* task_queue,
+  PacketTransport(DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
                   Call* send_call,
                   RtpRtcpObserver* observer,
                   TransportType transport_type,

test/run_loop.cc

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

test/run_loop.h

@@ -16,7 +16,8 @@ namespace webrtc {
 namespace test {
 
 // Blocks until the user presses enter.
-void PressEnterToContinue(SingleThreadedTaskQueueForTesting& task_queue);
+void PressEnterToContinue(
+    DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue);
 
 }  // namespace test
 }  // namespace webrtc

test/single_threaded_task_queue.cc

@@ -20,33 +20,36 @@
 namespace webrtc {
 namespace test {
 
-SingleThreadedTaskQueueForTesting::QueuedTask::QueuedTask(
+DEPRECATED_SingleThreadedTaskQueueForTesting::QueuedTask::QueuedTask(
-    SingleThreadedTaskQueueForTesting::TaskId task_id,
+    DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId task_id,
     int64_t earliest_execution_time,
-    SingleThreadedTaskQueueForTesting::Task task)
+    DEPRECATED_SingleThreadedTaskQueueForTesting::Task task)
     : task_id(task_id),
       earliest_execution_time(earliest_execution_time),
       task(task) {}
 
-SingleThreadedTaskQueueForTesting::QueuedTask::~QueuedTask() = default;
+DEPRECATED_SingleThreadedTaskQueueForTesting::QueuedTask::~QueuedTask() =
+    default;
 
-SingleThreadedTaskQueueForTesting::SingleThreadedTaskQueueForTesting(
+DEPRECATED_SingleThreadedTaskQueueForTesting::
-    const char* name)
+    DEPRECATED_SingleThreadedTaskQueueForTesting(const char* name)
     : thread_(Run, this, name), running_(true), next_task_id_(0) {
   thread_.Start();
 }
 
-SingleThreadedTaskQueueForTesting::~SingleThreadedTaskQueueForTesting() {
+DEPRECATED_SingleThreadedTaskQueueForTesting::
+    ~DEPRECATED_SingleThreadedTaskQueueForTesting() {
   Stop();
 }
 
-SingleThreadedTaskQueueForTesting::TaskId
+DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
-SingleThreadedTaskQueueForTesting::PostTask(Task task) {
+DEPRECATED_SingleThreadedTaskQueueForTesting::PostTask(Task task) {
   return PostDelayedTask(task, 0);
 }
 
-SingleThreadedTaskQueueForTesting::TaskId
+DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
-SingleThreadedTaskQueueForTesting::PostDelayedTask(Task task,
+DEPRECATED_SingleThreadedTaskQueueForTesting::PostDelayedTask(
+    Task task,
     int64_t delay_ms) {
   int64_t earliest_exec_time = rtc::TimeAfter(delay_ms);
 
@@ -75,7 +78,7 @@ SingleThreadedTaskQueueForTesting::PostDelayedTask(Task task,
   return id;
 }
 
-void SingleThreadedTaskQueueForTesting::SendTask(Task task) {
+void DEPRECATED_SingleThreadedTaskQueueForTesting::SendTask(Task task) {
   RTC_DCHECK(!IsCurrent());
   rtc::Event done;
   if (PostTask([&task, &done]() {
@@ -88,7 +91,7 @@ void SingleThreadedTaskQueueForTesting::SendTask(Task task) {
   RTC_CHECK(done.Wait(30000, 10000));
 }
 
-bool SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
+bool DEPRECATED_SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
   rtc::CritScope lock(&cs_);
   for (auto it = tasks_.begin(); it != tasks_.end(); it++) {
     if ((*it)->task_id == task_id) {
@@ -99,23 +102,23 @@ bool SingleThreadedTaskQueueForTesting::CancelTask(TaskId task_id) {
   return false;
 }
 
-bool SingleThreadedTaskQueueForTesting::IsCurrent() {
+bool DEPRECATED_SingleThreadedTaskQueueForTesting::IsCurrent() {
   return rtc::IsThreadRefEqual(thread_.GetThreadRef(), rtc::CurrentThreadRef());
 }
 
-bool SingleThreadedTaskQueueForTesting::IsRunning() {
+bool DEPRECATED_SingleThreadedTaskQueueForTesting::IsRunning() {
   RTC_DCHECK_RUN_ON(&owner_thread_checker_);
   // We could check the |running_| flag here, but this is equivalent for the
   // purposes of this function.
   return thread_.IsRunning();
 }
 
-bool SingleThreadedTaskQueueForTesting::HasPendingTasks() const {
+bool DEPRECATED_SingleThreadedTaskQueueForTesting::HasPendingTasks() const {
   rtc::CritScope lock(&cs_);
   return !tasks_.empty();
 }
 
-void SingleThreadedTaskQueueForTesting::Stop() {
+void DEPRECATED_SingleThreadedTaskQueueForTesting::Stop() {
   RTC_DCHECK_RUN_ON(&owner_thread_checker_);
   if (!thread_.IsRunning())
     return;
@@ -129,11 +132,11 @@ void SingleThreadedTaskQueueForTesting::Stop() {
   thread_.Stop();
 }
 
-void SingleThreadedTaskQueueForTesting::Run(void* obj) {
+void DEPRECATED_SingleThreadedTaskQueueForTesting::Run(void* obj) {
-  static_cast<SingleThreadedTaskQueueForTesting*>(obj)->RunLoop();
+  static_cast<DEPRECATED_SingleThreadedTaskQueueForTesting*>(obj)->RunLoop();
 }
 
-void SingleThreadedTaskQueueForTesting::RunLoop() {
+void DEPRECATED_SingleThreadedTaskQueueForTesting::RunLoop() {
   while (true) {
     std::unique_ptr<QueuedTask> queued_task;
 

test/single_threaded_task_queue.h

@@ -15,6 +15,7 @@
 #include <memory>
 
 #include "rtc_base/critical_section.h"
+#include "rtc_base/deprecation.h"
 #include "rtc_base/event.h"
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/thread_checker.h"
@@ -22,20 +23,24 @@
 namespace webrtc {
 namespace test {
 
+// DEPRECATED. This class doesn't striclty follow rtc::TaskQueue semantics,
+// which makes it surprising and hard to use correctly.
+// Please use TaskQueueForTest instead.
+
 // This class gives capabilities similar to rtc::TaskQueue, but ensures
 // everything happens on the same thread. This is intended to make the
 // threading model of unit-tests (specifically end-to-end tests) more closely
 // resemble that of real WebRTC, thereby allowing us to replace some critical
 // sections by thread-checkers.
 // This task is NOT tuned for performance, but rather for simplicity.
-class SingleThreadedTaskQueueForTesting {
+class DEPRECATED_SingleThreadedTaskQueueForTesting {
  public:
   using Task = std::function<void()>;
   using TaskId = size_t;
   constexpr static TaskId kInvalidTaskId = static_cast<TaskId>(-1);
 
-  explicit SingleThreadedTaskQueueForTesting(const char* name);
+  explicit DEPRECATED_SingleThreadedTaskQueueForTesting(const char* name);
-  ~SingleThreadedTaskQueueForTesting();
+  ~DEPRECATED_SingleThreadedTaskQueueForTesting();
 
   // Sends one task to the task-queue, and returns a handle by which the
   // task can be cancelled.
@@ -102,6 +107,10 @@ class SingleThreadedTaskQueueForTesting {
   rtc::Event wake_up_;
 };
 
+// Warn if new usage.
+typedef DEPRECATED_SingleThreadedTaskQueueForTesting RTC_DEPRECATED
+    SingleThreadedTaskQueueForTesting;
+
 }  // namespace test
 }  // namespace webrtc
 

test/single_threaded_task_queue_unittest.cc

@@ -23,18 +23,19 @@ namespace test {
 
 namespace {
 
-using TaskId = SingleThreadedTaskQueueForTesting::TaskId;
+using TaskId = DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId;
 
 // Test should not rely on the object under test not being faulty. If the task
 // queue ever blocks forever, we want the tests to fail, rather than hang.
 constexpr int kMaxWaitTimeMs = 10000;
 
-TEST(SingleThreadedTaskQueueForTestingTest, SanityConstructionDestruction) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     SanityConstructionDestruction) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> executed(false);
   rtc::Event done;
@@ -48,9 +49,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedTasks) {
   EXPECT_TRUE(executed.load());
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest,
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
      PostMultipleTasksFromSameExternalThread) {
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   constexpr size_t kCount = 3;
   std::atomic<bool> executed[kCount];
@@ -91,8 +92,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
   }
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, PostToTaskQueueFromOwnThread) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     PostToTaskQueueFromOwnThread) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> executed(false);
   rtc::Event done;
@@ -112,8 +114,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, PostToTaskQueueFromOwnThread) {
   EXPECT_TRUE(executed.load());
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     TasksExecutedInSequence) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   // The first task would perform:
   // accumulator = 10 * accumulator + i
@@ -146,8 +149,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, TasksExecutedInSequence) {
   EXPECT_EQ(accumulator, expected_value);
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedDelayedTask) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     ExecutesPostedDelayedTask) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> executed(false);
   rtc::Event done;
@@ -166,8 +170,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExecutesPostedDelayedTask) {
   EXPECT_TRUE(executed.load());
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, DoesNotExecuteDelayedTaskTooSoon) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     DoesNotExecuteDelayedTaskTooSoon) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> executed(false);
 
@@ -182,9 +187,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, DoesNotExecuteDelayedTaskTooSoon) {
   EXPECT_FALSE(executed.load());
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest,
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
      TaskWithLesserDelayPostedAfterFirstDelayedTaskExectuedBeforeFirst) {
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> earlier_executed(false);
   constexpr int64_t earlier_delay_ms = 500;
@@ -216,9 +221,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
   ASSERT_TRUE(later_executed);
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest,
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
      TaskWithGreaterDelayPostedAfterFirstDelayedTaskExectuedAfterFirst) {
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> earlier_executed(false);
   constexpr int64_t earlier_delay_ms = 500;
@@ -250,8 +255,9 @@ TEST(SingleThreadedTaskQueueForTestingTest,
   ASSERT_TRUE(later_executed);
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     ExternalThreadCancelsTask) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   rtc::Event done;
 
@@ -276,8 +282,9 @@ TEST(SingleThreadedTaskQueueForTestingTest, ExternalThreadCancelsTask) {
 // In this test, we'll set off a chain where the first task cancels the second
 // task, then a third task runs (showing that we really cancelled the task,
 // rather than just halted the task-queue).
-TEST(SingleThreadedTaskQueueForTestingTest, InternalThreadCancelsTask) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+     InternalThreadCancelsTask) {
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   rtc::Event done;
 
@@ -308,8 +315,8 @@ TEST(SingleThreadedTaskQueueForTestingTest, InternalThreadCancelsTask) {
   ASSERT_TRUE(done.Wait(kMaxWaitTimeMs));
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest, SendTask) {
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest, SendTask) {
-  SingleThreadedTaskQueueForTesting task_queue("task_queue");
+  DEPRECATED_SingleThreadedTaskQueueForTesting task_queue("task_queue");
 
   std::atomic<bool> executed(false);
 
@@ -324,10 +331,11 @@ TEST(SingleThreadedTaskQueueForTestingTest, SendTask) {
   EXPECT_TRUE(executed);
 }
 
-TEST(SingleThreadedTaskQueueForTestingTest,
+TEST(DEPRECATED_SingleThreadedTaskQueueForTestingTest,
      DestructTaskQueueWhileTasksPending) {
   auto task_queue =
-      absl::make_unique<SingleThreadedTaskQueueForTesting>("task_queue");
+      absl::make_unique<DEPRECATED_SingleThreadedTaskQueueForTesting>(
+          "task_queue");
 
   std::atomic<size_t> counter(0);
 

test/win/run_loop_win.cc

@@ -17,7 +17,8 @@
 namespace webrtc {
 namespace test {
 
-void PressEnterToContinue(SingleThreadedTaskQueueForTesting& task_queue) {
+void PressEnterToContinue(
+    DEPRECATED_SingleThreadedTaskQueueForTesting& task_queue) {
   puts(">> Press ENTER to continue...");
 
   while (!_kbhit() || _getch() != '\r') {

video/end_to_end_tests/bandwidth_tests.cc

@@ -79,8 +79,9 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
 
 class BandwidthStatsTest : public test::EndToEndTest {
  public:
-  BandwidthStatsTest(bool send_side_bwe,
+  BandwidthStatsTest(
-                     test::SingleThreadedTaskQueueForTesting* task_queue)
+      bool send_side_bwe,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
       : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
         sender_call_(nullptr),
         receiver_call_(nullptr),
@@ -135,7 +136,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
   Call* receiver_call_;
   bool has_seen_pacer_delay_;
   const bool send_side_bwe_;
-  test::SingleThreadedTaskQueueForTesting* const task_queue_;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
 };
 
 TEST_F(BandwidthEndToEndTest, VerifySendSideBweStats) {
@@ -156,7 +157,8 @@ TEST_F(BandwidthEndToEndTest, VerifyRecvSideBweStats) {
 TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
   class BweObserver : public test::EndToEndTest {
    public:
-    explicit BweObserver(test::SingleThreadedTaskQueueForTesting* task_queue)
+    explicit BweObserver(
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           sender_call_(nullptr),
           clock_(Clock::GetRealTimeClock()),
@@ -170,7 +172,8 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
     ~BweObserver() {}
 
     test::PacketTransport* CreateReceiveTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue) override {
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        override {
       receive_transport_ = new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
@@ -267,8 +270,9 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
     test::PacketTransport* receive_transport_;
     TestState state_;
     RateLimiter retransmission_rate_limiter_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
-    test::SingleThreadedTaskQueueForTesting::TaskId pending_task_ = ~0;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId pending_task_ =
+        ~0;
   } test(&task_queue_);
 
   RunBaseTest(&test);
@@ -285,7 +289,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
                                public test::FakeEncoder {
    public:
     explicit EncoderRateStatsTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -360,7 +364,7 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
     }
 
    private:
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* send_stream_;
     test::VideoEncoderProxyFactory encoder_factory_;

video/end_to_end_tests/extended_reports_tests.cc

@@ -160,7 +160,7 @@ class RtcpXrObserver : public test::EndToEndTest {
   }
 
   test::PacketTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) {
     auto network =
         absl::make_unique<SimulatedNetwork>(forward_transport_config_);

video/end_to_end_tests/fec_tests.cc

@@ -246,7 +246,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
   }
 
   test::PacketTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     const int kNetworkDelayMs = 100;
@@ -431,7 +431,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
     }
 
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
       // Configure some network delay.

video/end_to_end_tests/multi_stream_tester.cc

@@ -30,7 +30,7 @@
 namespace webrtc {
 
 MultiStreamTester::MultiStreamTester(
-    test::SingleThreadedTaskQueueForTesting* task_queue)
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
     : task_queue_(task_queue) {
   // TODO(sprang): Cleanup when msvc supports explicit initializers for array.
   codec_settings[0] = {1, 640, 480};
@@ -152,7 +152,7 @@ void MultiStreamTester::UpdateReceiveConfig(
     VideoReceiveStream::Config* receive_config) {}
 
 test::DirectTransport* MultiStreamTester::CreateSendTransport(
-    test::SingleThreadedTaskQueueForTesting* task_queue,
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* sender_call) {
   return new test::DirectTransport(
       task_queue,
@@ -163,7 +163,7 @@ test::DirectTransport* MultiStreamTester::CreateSendTransport(
 }
 
 test::DirectTransport* MultiStreamTester::CreateReceiveTransport(
-    test::SingleThreadedTaskQueueForTesting* task_queue,
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
     Call* receiver_call) {
   return new test::DirectTransport(
       task_queue,

video/end_to_end_tests/multi_stream_tester.h

@@ -34,7 +34,7 @@ class MultiStreamTester {
   } codec_settings[kNumStreams];
 
   explicit MultiStreamTester(
-      test::SingleThreadedTaskQueueForTesting* task_queue);
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
 
   virtual ~MultiStreamTester();
 
@@ -52,13 +52,13 @@ class MultiStreamTester {
   virtual void UpdateReceiveConfig(size_t stream_index,
                                    VideoReceiveStream::Config* receive_config);
   virtual test::DirectTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call);
   virtual test::DirectTransport* CreateReceiveTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* receiver_call);
 
-  test::SingleThreadedTaskQueueForTesting* const task_queue_;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
 };
 }  // namespace webrtc
 #endif  // VIDEO_END_TO_END_TESTS_MULTI_STREAM_TESTER_H_

video/end_to_end_tests/multi_stream_tests.cc

@@ -63,7 +63,8 @@ TEST_F(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
 
   class Tester : public MultiStreamTester {
    public:
-    explicit Tester(test::SingleThreadedTaskQueueForTesting* task_queue)
+    explicit Tester(
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : MultiStreamTester(task_queue) {}
     virtual ~Tester() {}
 

video/end_to_end_tests/network_state_tests.cc

@@ -156,7 +156,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
   class NetworkStateTest : public test::EndToEndTest, public test::FakeEncoder {
    public:
     explicit NetworkStateTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -333,7 +333,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
       }
     }
 
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::CriticalSection test_crit_;
     rtc::Event encoded_frames_;
     rtc::Event packet_event_;

video/end_to_end_tests/probing_tests.cc

@@ -68,7 +68,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
    public:
     explicit InitialProbingTest(
         bool* success,
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : ProbingTest(300000), success_(success), task_queue_(task_queue) {
       *success_ = false;
     }
@@ -94,7 +94,7 @@ TEST_F(ProbingEndToEndTest, InitialProbing) {
    private:
     const int kTimeoutMs = 1000;
     bool* const success_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
   };
 
   bool success = false;
@@ -122,7 +122,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
   class TriggerMidCallProbingTest : public ProbingTest {
    public:
     TriggerMidCallProbingTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         bool* success)
         : ProbingTest(300000), success_(success), task_queue_(task_queue) {}
 
@@ -176,7 +176,7 @@ TEST_F(ProbingEndToEndTest, TriggerMidCallProbing) {
    private:
     const int kTimeoutMs = 5000;
     bool* const success_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
   };
 
   bool success = false;
@@ -201,7 +201,8 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
 
   class ReconfigureTest : public ProbingTest {
    public:
-    ReconfigureTest(test::SingleThreadedTaskQueueForTesting* task_queue,
+    ReconfigureTest(
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         bool* success)
         : ProbingTest(50000), task_queue_(task_queue), success_(success) {}
 
@@ -219,7 +220,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
     }
 
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       auto network =
           absl::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig());
@@ -305,7 +306,7 @@ TEST_F(ProbingEndToEndTest, ProbeOnVideoEncoderReconfiguration) {
     const int kTimeoutMs = 10000;
     const int kRampUpMaxDurationMs = 500;
 
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     bool* const success_;
     SimulatedNetwork* send_simulated_network_;
     VideoSendStream* send_stream_;

video/end_to_end_tests/retransmission_tests.cc

@@ -137,7 +137,8 @@ TEST_F(RetransmissionEndToEndTest, ReceivesNackAndRetransmitsAudio) {
     size_t GetNumAudioStreams() const override { return 1; }
 
     test::PacketTransport* CreateReceiveTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue) override {
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
+        override {
       test::PacketTransport* receive_transport = new test::PacketTransport(
           task_queue, nullptr, this, test::PacketTransport::kReceiver,
           payload_type_map_,
@@ -201,7 +202,7 @@ TEST_F(RetransmissionEndToEndTest,
   class KeyframeRequestObserver : public test::EndToEndTest {
    public:
     explicit KeyframeRequestObserver(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
 
     void OnVideoStreamsCreated(
@@ -233,7 +234,7 @@ TEST_F(RetransmissionEndToEndTest,
     Clock* clock_;
     VideoSendStream* send_stream_;
     VideoReceiveStream* receive_stream_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
   } test(&task_queue_);
 
   RunBaseTest(&test);

video/end_to_end_tests/stats_tests.cc

@@ -232,7 +232,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
     }
 
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       BuiltInNetworkBehaviorConfig network_config;
       network_config.loss_percent = 5;

video/end_to_end_tests/transport_feedback_tests.cc

@@ -38,7 +38,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call,
         const uint32_t& first_media_ssrc,
         const std::map<uint32_t, uint32_t>& ssrc_map,
@@ -164,7 +164,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
   class TransportSequenceNumberTester : public MultiStreamTester {
    public:
     explicit TransportSequenceNumberTester(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : MultiStreamTester(task_queue),
           first_media_ssrc_(0),
           observer_(nullptr) {}
@@ -217,7 +217,7 @@ TEST_F(TransportFeedbackEndToEndTest, AssignsTransportSequenceNumbers) {
     }
 
     test::DirectTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       std::map<uint8_t, MediaType> payload_type_map =
           MultiStreamTester::payload_type_map_;

video/video_analyzer.cc

@@ -66,7 +66,7 @@ VideoAnalyzer::VideoAnalyzer(
     bool is_quick_test_enabled,
     Clock* clock,
     std::string rtp_dump_name,
-    test::SingleThreadedTaskQueueForTesting* task_queue)
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
     : transport_(transport),
       receiver_(nullptr),
       call_(nullptr),

video/video_analyzer.h

@@ -45,7 +45,7 @@ class VideoAnalyzer : public PacketReceiver,
                 bool is_quick_test_enabled,
                 Clock* clock,
                 std::string rtp_dump_name,
-                test::SingleThreadedTaskQueueForTesting* task_queue);
+                test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue);
   ~VideoAnalyzer();
 
   virtual void SetReceiver(PacketReceiver* receiver);
@@ -286,14 +286,14 @@ class VideoAnalyzer : public PacketReceiver,
   std::deque<FrameComparison> comparisons_ RTC_GUARDED_BY(comparison_lock_);
   bool quit_ RTC_GUARDED_BY(comparison_lock_);
   rtc::Event done_;
-  test::SingleThreadedTaskQueueForTesting::TaskId stats_polling_task_id_
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting::TaskId
-      RTC_GUARDED_BY(comparison_lock_);
+      stats_polling_task_id_ RTC_GUARDED_BY(comparison_lock_);
   bool stop_stats_poller_ RTC_GUARDED_BY(comparison_lock_);
 
   std::unique_ptr<test::RtpFileWriter> rtp_file_writer_;
   Clock* const clock_;
   const int64_t start_ms_;
-  test::SingleThreadedTaskQueueForTesting* task_queue_;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue_;
 };
 
 }  // namespace webrtc

video/video_send_stream_tests.cc

@@ -556,7 +556,7 @@ class UlpfecObserver : public test::EndToEndTest {
   }
 
   test::PacketTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Configure some network delay.
@@ -753,7 +753,7 @@ class FlexfecObserver : public test::EndToEndTest {
   }
 
   test::PacketTransport* CreateSendTransport(
-      test::SingleThreadedTaskQueueForTesting* task_queue,
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
       Call* sender_call) override {
     // At low RTT (< kLowRttNackMs) -> NACK only, no FEC.
     // Therefore we need some network delay.
@@ -1533,7 +1533,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
     }
 
     test::PacketTransport* CreateSendTransport(
-        test::SingleThreadedTaskQueueForTesting* task_queue,
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue,
         Call* sender_call) override {
       const int kNetworkDelayMs = 50;
       BuiltInNetworkBehaviorConfig config;
@@ -1674,7 +1674,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
   class ChangingNetworkRouteTest : public test::EndToEndTest {
    public:
     explicit ChangingNetworkRouteTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           task_queue_(task_queue),
           call_(nullptr) {
@@ -1769,7 +1769,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
    private:
     webrtc::SequenceChecker module_process_thread_;
     webrtc::SequenceChecker task_queue_thread_;
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     Call* call_ RTC_GUARDED_BY(task_queue_thread_);
   } test(&task_queue_);
 
@@ -1780,7 +1780,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
   class ChangingTransportOverheadTest : public test::EndToEndTest {
    public:
     explicit ChangingTransportOverheadTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           task_queue_(task_queue),
           call_(nullptr),
@@ -1831,7 +1831,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
     }
 
    private:
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     Call* call_;
     rtc::CriticalSection lock_;
     int packets_sent_ RTC_GUARDED_BY(lock_);
@@ -1854,9 +1854,10 @@ class MaxPaddingSetTest : public test::SendTest {
   static const uint32_t kActualEncodeBitrateBps = 40000;
   static const uint32_t kMinPacketsToSend = 50;
 
-  MaxPaddingSetTest(bool test_switch_content_type,
+  MaxPaddingSetTest(
+      bool test_switch_content_type,
       T* stream_reset_fun,
-                    test::SingleThreadedTaskQueueForTesting* task_queue)
+      test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
       : SendTest(test::CallTest::kDefaultTimeoutMs),
         running_without_padding_(test_switch_content_type),
         stream_resetter_(stream_reset_fun),
@@ -1959,7 +1960,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::SingleThreadedTaskQueueForTesting* const task_queue_;
+  test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
 };
 
 TEST_F(VideoSendStreamTest, RespectsMinTransmitBitrate) {
@@ -2322,7 +2323,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
   class EncoderStateObserver : public test::SendTest, public VideoEncoder {
    public:
     explicit EncoderStateObserver(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : SendTest(kDefaultTimeoutMs),
           task_queue_(task_queue),
           stream_(nullptr),
@@ -2425,7 +2426,7 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
       EXPECT_TRUE(Wait()) << "Timed out while waiting for Encode.";
     }
 
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::CriticalSection crit_;
     VideoSendStream* stream_;
     bool initialized_ RTC_GUARDED_BY(crit_);
@@ -2782,7 +2783,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
                                           public test::FakeEncoder {
    public:
     explicit EncoderBitrateThresholdObserver(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : SendTest(kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -2946,7 +2947,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
       EXPECT_EQ(1, num_encoder_initializations_);
     }
 
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     rtc::Event create_rate_allocator_event_;
     rtc::Event init_encode_event_;
     rtc::Event bitrate_changed_event_;
@@ -3623,7 +3624,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
                                           public test::FakeEncoder {
    public:
     explicit RemoveOverheadFromBandwidthTest(
-        test::SingleThreadedTaskQueueForTesting* task_queue)
+        test::DEPRECATED_SingleThreadedTaskQueueForTesting* task_queue)
         : EndToEndTest(test::CallTest::kDefaultTimeoutMs),
           FakeEncoder(Clock::GetRealTimeClock()),
           task_queue_(task_queue),
@@ -3688,7 +3689,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
     }
 
    private:
-    test::SingleThreadedTaskQueueForTesting* const task_queue_;
+    test::DEPRECATED_SingleThreadedTaskQueueForTesting* const task_queue_;
     test::VideoEncoderProxyFactory encoder_factory_;
     Call* call_;
     rtc::CriticalSection crit_;