Revert "Replacing rtc::Thread with task queue for TestAudioDeviceModule."

This reverts commit 1b871d07532c25d2f27e4db192cb9ce2229b1cee.

Reason for revert: Breaks webrtc downstream projects.

Original change's description:
> Replacing rtc::Thread with task queue for TestAudioDeviceModule.
> 
> This prepares for running it in simulated time.
> 
> TBR=henrika@webrtc.org
> 
> Bug: webrtc:10465
> Change-Id: I9b29b8af9aeba7f0c8209ca77294a63d8068ff1a
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/126481
> Reviewed-by: Sebastian Jansson <srte@webrtc.org>
> Reviewed-by: Oskar Sundbom <ossu@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#27083}

TBR=henrika@webrtc.org,ossu@webrtc.org,srte@webrtc.org

Change-Id: I16d7c2a46d38c9aaf82cc3ab7bd7b9c5e10f5a5e
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:10465
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/127341
Reviewed-by: Seth Hampson <shampson@webrtc.org>
Commit-Queue: Seth Hampson <shampson@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27086}

modules/audio_device/BUILD.gn

@@ -203,8 +203,6 @@ rtc_source_set("audio_device_impl") {
     ":audio_device_generic",
     "../../api:array_view",
     "../../api:scoped_refptr",
-    "../../api/task_queue:global_task_queue_factory",
-    "../../api/task_queue:task_queue",
     "../../common_audio",
     "../../common_audio:common_audio_c",
     "../../rtc_base:checks",
@@ -214,7 +212,6 @@ rtc_source_set("audio_device_impl") {
     "../../rtc_base:rtc_task_queue",
     "../../rtc_base/system:arch",
     "../../rtc_base/system:file_wrapper",
-    "../../rtc_base/task_utils:repeating_task",
     "../../system_wrappers",
     "../../system_wrappers:metrics",
     "../utility",

modules/audio_device/include/test_audio_device.cc

@@ -18,7 +18,6 @@
 
 #include "absl/memory/memory.h"
 #include "api/array_view.h"
-#include "api/task_queue/global_task_queue_factory.h"
 #include "common_audio/wav_file.h"
 #include "modules/audio_device/include/audio_device_default.h"
 #include "modules/audio_device/include/test_audio_device.h"
@@ -31,8 +30,7 @@
 #include "rtc_base/platform_thread.h"
 #include "rtc_base/random.h"
 #include "rtc_base/ref_counted_object.h"
-#include "rtc_base/task_queue.h"
+#include "rtc_base/thread.h"
-#include "rtc_base/task_utils/repeating_task.h"
 #include "rtc_base/thread_annotations.h"
 #include "rtc_base/time_utils.h"
 
@@ -55,17 +53,16 @@ class TestAudioDeviceModuleImpl
   // |renderer| is an object that receives audio data that would have been
   // played out. Can be nullptr if this device is never used for playing.
   // Use one of the Create... functions to get these instances.
-  TestAudioDeviceModuleImpl(TaskQueueFactory* task_queue_factory,
+  TestAudioDeviceModuleImpl(std::unique_ptr<Capturer> capturer,
-                            std::unique_ptr<Capturer> capturer,
                             std::unique_ptr<Renderer> renderer,
                             float speed = 1)
-      : task_queue_factory_(task_queue_factory),
+      : capturer_(std::move(capturer)),
-        capturer_(std::move(capturer)),
         renderer_(std::move(renderer)),
         process_interval_us_(kFrameLengthUs / speed),
         audio_callback_(nullptr),
         rendering_(false),
-        capturing_(false) {
+        capturing_(false),
+        stop_thread_(false) {
     auto good_sample_rate = [](int sr) {
       return sr == 8000 || sr == 16000 || sr == 32000 || sr == 44100 ||
              sr == 48000;
@@ -85,17 +82,20 @@ class TestAudioDeviceModuleImpl
   ~TestAudioDeviceModuleImpl() override {
     StopPlayout();
     StopRecording();
+    if (thread_) {
+      {
+        rtc::CritScope cs(&lock_);
+        stop_thread_ = true;
+      }
+      thread_->Stop();
+    }
   }
 
   int32_t Init() override {
-    task_queue_ =
+    thread_ = absl::make_unique<rtc::PlatformThread>(
-        absl::make_unique<rtc::TaskQueue>(task_queue_factory_->CreateTaskQueue(
+        TestAudioDeviceModuleImpl::Run, this, "TestAudioDeviceModuleImpl",
-            "TestAudioDeviceModuleImpl", TaskQueueFactory::Priority::NORMAL));
+        rtc::kHighPriority);
-
+    thread_->Start();
-    RepeatingTaskHandle::Start(task_queue_->Get(), [this]() {
-      ProcessAudio();
-      return TimeDelta::us(process_interval_us_);
-    });
     return 0;
   }
 
@@ -156,41 +156,71 @@ class TestAudioDeviceModuleImpl
 
  private:
   void ProcessAudio() {
-    rtc::CritScope cs(&lock_);
+    int64_t time_us = rtc::TimeMicros();
-    if (capturing_) {
+    bool logged_once = false;
-      // Capture 10ms of audio. 2 bytes per sample.
+    for (;;) {
-      const bool keep_capturing = capturer_->Capture(&recording_buffer_);
+      {
-      uint32_t new_mic_level = 0;
+        rtc::CritScope cs(&lock_);
-      if (recording_buffer_.size() > 0) {
+        if (stop_thread_) {
-        audio_callback_->RecordedDataIsAvailable(
+          return;
-            recording_buffer_.data(),
+        }
-            recording_buffer_.size() / capturer_->NumChannels(),
+        if (capturing_) {
-            2 * capturer_->NumChannels(), capturer_->NumChannels(),
+          // Capture 10ms of audio. 2 bytes per sample.
-            capturer_->SamplingFrequency(), 0, 0, 0, false, new_mic_level);
+          const bool keep_capturing = capturer_->Capture(&recording_buffer_);
+          uint32_t new_mic_level = 0;
+          if (recording_buffer_.size() > 0) {
+            audio_callback_->RecordedDataIsAvailable(
+                recording_buffer_.data(),
+                recording_buffer_.size() / capturer_->NumChannels(),
+                2 * capturer_->NumChannels(), capturer_->NumChannels(),
+                capturer_->SamplingFrequency(), 0, 0, 0, false, new_mic_level);
+          }
+          if (!keep_capturing) {
+            capturing_ = false;
+            done_capturing_.Set();
+          }
+        }
+        if (rendering_) {
+          size_t samples_out = 0;
+          int64_t elapsed_time_ms = -1;
+          int64_t ntp_time_ms = -1;
+          const int sampling_frequency = renderer_->SamplingFrequency();
+          audio_callback_->NeedMorePlayData(
+              SamplesPerFrame(sampling_frequency), 2 * renderer_->NumChannels(),
+              renderer_->NumChannels(), sampling_frequency,
+              playout_buffer_.data(), samples_out, &elapsed_time_ms,
+              &ntp_time_ms);
+          const bool keep_rendering =
+              renderer_->Render(rtc::ArrayView<const int16_t>(
+                  playout_buffer_.data(), samples_out));
+          if (!keep_rendering) {
+            rendering_ = false;
+            done_rendering_.Set();
+          }
+        }
       }
-      if (!keep_capturing) {
+      time_us += process_interval_us_;
-        capturing_ = false;
+
-        done_capturing_.Set();
+      int64_t time_left_us = time_us - rtc::TimeMicros();
-      }
+      if (time_left_us < 0) {
-    }
+        if (!logged_once) {
-    if (rendering_) {
+          RTC_LOG(LS_ERROR) << "ProcessAudio is too slow";
-      size_t samples_out = 0;
+          logged_once = true;
-      int64_t elapsed_time_ms = -1;
+        }
-      int64_t ntp_time_ms = -1;
+      } else {
-      const int sampling_frequency = renderer_->SamplingFrequency();
+        while (time_left_us > 1000) {
-      audio_callback_->NeedMorePlayData(
+          if (rtc::Thread::SleepMs(time_left_us / 1000))
-          SamplesPerFrame(sampling_frequency), 2 * renderer_->NumChannels(),
+            break;
-          renderer_->NumChannels(), sampling_frequency, playout_buffer_.data(),
+          time_left_us = time_us - rtc::TimeMicros();
-          samples_out, &elapsed_time_ms, &ntp_time_ms);
+        }
-      const bool keep_rendering = renderer_->Render(
-          rtc::ArrayView<const int16_t>(playout_buffer_.data(), samples_out));
-      if (!keep_rendering) {
-        rendering_ = false;
-        done_rendering_.Set();
       }
     }
   }
-  TaskQueueFactory* const task_queue_factory_;
+
+  static void Run(void* obj) {
+    static_cast<TestAudioDeviceModuleImpl*>(obj)->ProcessAudio();
+  }
+
   const std::unique_ptr<Capturer> capturer_ RTC_GUARDED_BY(lock_);
   const std::unique_ptr<Renderer> renderer_ RTC_GUARDED_BY(lock_);
   const int64_t process_interval_us_;
@@ -204,7 +234,9 @@ class TestAudioDeviceModuleImpl
 
   std::vector<int16_t> playout_buffer_ RTC_GUARDED_BY(lock_);
   rtc::BufferT<int16_t> recording_buffer_ RTC_GUARDED_BY(lock_);
-  std::unique_ptr<rtc::TaskQueue> task_queue_;
+
+  std::unique_ptr<rtc::PlatformThread> thread_;
+  bool stop_thread_ RTC_GUARDED_BY(lock_);
 };
 
 // A fake capturer that generates pulses with random samples between
@@ -462,19 +494,8 @@ TestAudioDeviceModule::CreateTestAudioDeviceModule(
     std::unique_ptr<Capturer> capturer,
     std::unique_ptr<Renderer> renderer,
     float speed) {
-  return CreateTestAudioDeviceModule(&GlobalTaskQueueFactory(),
-                                     std::move(capturer), std::move(renderer),
-                                     speed);
-}
-
-rtc::scoped_refptr<TestAudioDeviceModule>
-TestAudioDeviceModule::CreateTestAudioDeviceModule(
-    TaskQueueFactory* task_queue_factory,
-    std::unique_ptr<TestAudioDeviceModule::Capturer> capturer,
-    std::unique_ptr<TestAudioDeviceModule::Renderer> renderer,
-    float speed) {
   return new rtc::RefCountedObject<TestAudioDeviceModuleImpl>(
-      task_queue_factory, std::move(capturer), std::move(renderer), speed);
+      std::move(capturer), std::move(renderer), speed);
 }
 
 std::unique_ptr<TestAudioDeviceModule::PulsedNoiseCapturer>

modules/audio_device/include/test_audio_device.h

@@ -17,7 +17,6 @@
 
 #include "api/array_view.h"
 #include "api/scoped_refptr.h"
-#include "api/task_queue/task_queue_factory.h"
 #include "modules/audio_device/include/audio_device.h"
 #include "modules/audio_device/include/audio_device_defines.h"
 #include "rtc_base/buffer.h"
@@ -83,11 +82,6 @@ class TestAudioDeviceModule : public AudioDeviceModule {
       std::unique_ptr<Capturer> capturer,
       std::unique_ptr<Renderer> renderer,
       float speed = 1);
-  static rtc::scoped_refptr<TestAudioDeviceModule> CreateTestAudioDeviceModule(
-      TaskQueueFactory* task_queue_factory,
-      std::unique_ptr<Capturer> capturer,
-      std::unique_ptr<Renderer> renderer,
-      float speed = 1);
 
   // Returns a Capturer instance that generates a signal of |num_channels|
   // channels where every second frame is zero and every second frame is evenly