Clean up PlatformThread.

webrtc/modules/audio_processing/audio_processing_impl_locking_unittest.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 426 matching lines @@
 
   // Tests whether all the required render and capture side calls have been
   // done.
   bool TestDone() {
     return frame_counters_.BothCountersExceedeThreshold(
         test_config_.min_number_of_calls);
   }
 
   // Start the threads used in the test.
   void StartThreads() {
-    ASSERT_TRUE(render_thread_->Start());
-    render_thread_->SetPriority(kRealtimePriority);
-    ASSERT_TRUE(capture_thread_->Start());
-    capture_thread_->SetPriority(kRealtimePriority);
-    ASSERT_TRUE(stats_thread_->Start());
-    stats_thread_->SetPriority(kNormalPriority);
+    render_thread_.Start();
+    render_thread_.SetPriority(rtc::kRealtimePriority);
+    capture_thread_.Start();
+    capture_thread_.SetPriority(rtc::kRealtimePriority);
+    stats_thread_.Start();
+    stats_thread_.SetPriority(rtc::kNormalPriority);
   }
 
   // Event handler for the test.
   const rtc::scoped_ptr<EventWrapper> test_complete_;
 
   // Thread related variables.
-  rtc::scoped_ptr<PlatformThread> render_thread_;
-  rtc::scoped_ptr<PlatformThread> capture_thread_;
-  rtc::scoped_ptr<PlatformThread> stats_thread_;
+  rtc::PlatformThread render_thread_;
+  rtc::PlatformThread capture_thread_;
+  rtc::PlatformThread stats_thread_;
   mutable test::Random rand_gen_;
 
   rtc::scoped_ptr<AudioProcessing> apm_;
   TestConfig test_config_;
   FrameCounters frame_counters_;
   CaptureSideCalledChecker capture_call_checker_;
   RenderProcessor render_thread_state_;
   CaptureProcessor capture_thread_state_;
   StatsProcessor stats_thread_state_;
 };
 
 AudioProcessingImplLockTest::AudioProcessingImplLockTest()
     : test_complete_(EventWrapper::Create()),
-      render_thread_(PlatformThread::CreateThread(RenderProcessorThreadFunc,
-                                                  this,
-                                                  "render")),
-      capture_thread_(PlatformThread::CreateThread(CaptureProcessorThreadFunc,
-                                                   this,
-                                                   "capture")),
-      stats_thread_(PlatformThread::CreateThread(StatsProcessorThreadFunc,
-                                                 this,
-                                                 "stats")),
+      render_thread_(RenderProcessorThreadFunc, this, "render"),
+      capture_thread_(CaptureProcessorThreadFunc, this, "capture"),
+      stats_thread_(StatsProcessorThreadFunc, this, "stats"),
       rand_gen_(42U),
       apm_(AudioProcessingImpl::Create()),
       render_thread_state_(kMaxFrameSize,
                            &rand_gen_,
                            &frame_counters_,
                            &capture_call_checker_,
                            this,
                            &test_config_,
                            apm_.get()),
       capture_thread_state_(kMaxFrameSize,
@@ skipping 52 matching lines @@
 
     config.Set<DelayAgnostic>(
         new DelayAgnostic(test_config_.aec_type ==
                           AecType::BasicWebRtcAecSettingsWithDelayAgnosticAec));
 
     apm_->SetExtraOptions(config);
   }
 }
 
 void AudioProcessingImplLockTest::TearDown() {
-  render_thread_->Stop();
-  capture_thread_->Stop();
-  stats_thread_->Stop();
+  render_thread_.Stop();
+  capture_thread_.Stop();
+  stats_thread_.Stop();
 }
 
 StatsProcessor::StatsProcessor(test::Random* rand_gen,
                                TestConfig* test_config,
                                AudioProcessing* apm)
     : rand_gen_(rand_gen), test_config_(test_config), apm_(apm) {}
 
 // Implements the callback functionality for the statistics
 // collection thread.
 bool StatsProcessor::Process() {
@@ skipping 539 matching lines @@
     DISABLED_AudioProcessingImplLockExtensive,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateExtensiveTestConfigs()));
 
 INSTANTIATE_TEST_CASE_P(
     DISABLED_AudioProcessingImplLockBrief,
     AudioProcessingImplLockTest,
     ::testing::ValuesIn(TestConfig::GenerateBriefTestConfigs()));
 
 }  // namespace webrtc