1 files changed, 19 insertions, 32 deletions

diff --git a/modules/audio_processing/audio_processing_performance_unittest.cc b/modules/audio_processing/audio_processing_performance_unittest.cc
index 86ff0e8bfe..9585850296 100644
--- a/modules/audio_processing/audio_processing_performance_unittest.cc
+++ b/modules/audio_processing/audio_processing_performance_unittest.cc
@@ -391,15 +391,7 @@ class TimedThreadApiProcessor {
 class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
  public:
   CallSimulator()
-      : render_thread_(new rtc::PlatformThread(RenderProcessorThreadFunc,
-                                               this,
-                                               "render",
-                                               rtc::kRealtimePriority)),
-        capture_thread_(new rtc::PlatformThread(CaptureProcessorThreadFunc,
-                                                this,
-                                                "capture",
-                                                rtc::kRealtimePriority)),
-        rand_gen_(42U),
+      : rand_gen_(42U),
         simulation_config_(static_cast<SimulationConfig>(GetParam())) {}
 
   // Run the call simulation with a timeout.
@@ -434,13 +426,10 @@ class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
   static const int kMinNumFramesToProcess = 150;
   static const int32_t kTestTimeout = 3 * 10 * kMinNumFramesToProcess;
 
-  // ::testing::TestWithParam<> implementation.
-  void TearDown() override { StopThreads(); }
-
   // Stop all running threads.
   void StopThreads() {
-    render_thread_->Stop();
-    capture_thread_->Stop();
+    render_thread_.Finalize();
+    capture_thread_.Finalize();
   }
 
   // Simulator and APM setup.
@@ -531,32 +520,28 @@ class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
         kMinNumFramesToProcess, kCaptureInputFloatLevel, num_capture_channels));
   }
 
-  // Thread callback for the render thread.
-  static void RenderProcessorThreadFunc(void* context) {
-    CallSimulator* call_simulator = reinterpret_cast<CallSimulator*>(context);
-    while (call_simulator->render_thread_state_->Process()) {
-    }
-  }
-
-  // Thread callback for the capture thread.
-  static void CaptureProcessorThreadFunc(void* context) {
-    CallSimulator* call_simulator = reinterpret_cast<CallSimulator*>(context);
-    while (call_simulator->capture_thread_state_->Process()) {
-    }
-  }
-
   // Start the threads used in the test.
   void StartThreads() {
-    ASSERT_NO_FATAL_FAILURE(render_thread_->Start());
-    ASSERT_NO_FATAL_FAILURE(capture_thread_->Start());
+    const auto attributes =
+        rtc::ThreadAttributes().SetPriority(rtc::ThreadPriority::kRealtime);
+    render_thread_ = rtc::PlatformThread::SpawnJoinable(
+        [this] {
+          while (render_thread_state_->Process()) {
+          }
+        },
+        "render", attributes);
+    capture_thread_ = rtc::PlatformThread::SpawnJoinable(
+        [this] {
+          while (capture_thread_state_->Process()) {
+          }
+        },
+        "capture", attributes);
   }
 
   // Event handler for the test.
   rtc::Event test_complete_;
 
   // Thread related variables.
-  std::unique_ptr<rtc::PlatformThread> render_thread_;
-  std::unique_ptr<rtc::PlatformThread> capture_thread_;
   Random rand_gen_;
 
   std::unique_ptr<AudioProcessing> apm_;
@@ -565,6 +550,8 @@ class CallSimulator : public ::testing::TestWithParam<SimulationConfig> {
   LockedFlag capture_call_checker_;
   std::unique_ptr<TimedThreadApiProcessor> render_thread_state_;
   std::unique_ptr<TimedThreadApiProcessor> capture_thread_state_;
+  rtc::PlatformThread render_thread_;
+  rtc::PlatformThread capture_thread_;
 };
 
 // Implements the callback functionality for the threads.