Clean up PlatformThread.

webrtc/modules/audio_coding/acm2/audio_coding_module_unittest_oldapi.cc

 /*
  *  Copyright (c) 2014 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 439 matching lines @@
 
 // A multi-threaded test for ACM. This base class is using the PCM16b 16 kHz
 // codec, while the derive class AcmIsacMtTest is using iSAC.
 class AudioCodingModuleMtTestOldApi : public AudioCodingModuleTestOldApi {
  protected:
   static const int kNumPackets = 500;
   static const int kNumPullCalls = 500;
 
   AudioCodingModuleMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
-        send_thread_(PlatformThread::CreateThread(CbSendThread, this, "send")),
-        insert_packet_thread_(PlatformThread::CreateThread(CbInsertPacketThread,
-                                                           this,
-                                                           "insert_packet")),
-        pull_audio_thread_(PlatformThread::CreateThread(CbPullAudioThread,
-                                                        this,
-                                                        "pull_audio")),
+        send_thread_(CbSendThread, this, "send"),
+        insert_packet_thread_(CbInsertPacketThread, this, "insert_packet"),
+        pull_audio_thread_(CbPullAudioThread, this, "pull_audio"),
         test_complete_(EventWrapper::Create()),
         send_count_(0),
         insert_packet_count_(0),
         pull_audio_count_(0),
         crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
         next_insert_packet_time_ms_(0),
         fake_clock_(new SimulatedClock(0)) {
     clock_ = fake_clock_.get();
   }
 
   void SetUp() {
     AudioCodingModuleTestOldApi::SetUp();
     RegisterCodec();  // Must be called before the threads start below.
     StartThreads();
   }
 
   void StartThreads() {
-    ASSERT_TRUE(send_thread_->Start());
-    send_thread_->SetPriority(kRealtimePriority);
-    ASSERT_TRUE(insert_packet_thread_->Start());
-    insert_packet_thread_->SetPriority(kRealtimePriority);
-    ASSERT_TRUE(pull_audio_thread_->Start());
-    pull_audio_thread_->SetPriority(kRealtimePriority);
+    send_thread_.Start();
+    send_thread_.SetPriority(rtc::kRealtimePriority);
+    insert_packet_thread_.Start();
+    insert_packet_thread_.SetPriority(rtc::kRealtimePriority);
+    pull_audio_thread_.Start();
+    pull_audio_thread_.SetPriority(rtc::kRealtimePriority);
   }
 
   void TearDown() {
     AudioCodingModuleTestOldApi::TearDown();
-    pull_audio_thread_->Stop();
-    send_thread_->Stop();
-    insert_packet_thread_->Stop();
+    pull_audio_thread_.Stop();
+    send_thread_.Stop();
+    insert_packet_thread_.Stop();
   }
 
   EventTypeWrapper RunTest() {
     return test_complete_->Wait(10 * 60 * 1000);  // 10 minutes' timeout.
   }
 
   virtual bool TestDone() {
     if (packet_cb_.num_calls() > kNumPackets) {
       CriticalSectionScoped lock(crit_sect_.get());
       if (pull_audio_count_ > kNumPullCalls) {
@@ skipping 59 matching lines @@
         return true;
       }
       ++pull_audio_count_;
     }
     // Now we're not holding the crit sect when calling ACM.
     PullAudio();
     fake_clock_->AdvanceTimeMilliseconds(10);
     return true;
   }
 
-  rtc::scoped_ptr<PlatformThread> send_thread_;
-  rtc::scoped_ptr<PlatformThread> insert_packet_thread_;
-  rtc::scoped_ptr<PlatformThread> pull_audio_thread_;
+  rtc::PlatformThread send_thread_;
+  rtc::PlatformThread insert_packet_thread_;
+  rtc::PlatformThread pull_audio_thread_;
   const rtc::scoped_ptr<EventWrapper> test_complete_;
   int send_count_;
   int insert_packet_count_;
   int pull_audio_count_ GUARDED_BY(crit_sect_);
   const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
 };
 
 TEST_F(AudioCodingModuleMtTestOldApi, DISABLED_ON_IOS(DoTest)) {
@@ skipping 106 matching lines @@
 
 class AcmReRegisterIsacMtTestOldApi : public AudioCodingModuleTestOldApi {
  protected:
   static const int kRegisterAfterNumPackets = 5;
   static const int kNumPackets = 10;
   static const int kPacketSizeMs = 30;
   static const int kPacketSizeSamples = kPacketSizeMs * 16;
 
   AcmReRegisterIsacMtTestOldApi()
       : AudioCodingModuleTestOldApi(),
-        receive_thread_(
-            PlatformThread::CreateThread(CbReceiveThread, this, "receive")),
-        codec_registration_thread_(
-            PlatformThread::CreateThread(CbCodecRegistrationThread,
-                                         this,
-                                         "codec_registration")),
+        receive_thread_(CbReceiveThread, this, "receive"),
+        codec_registration_thread_(CbCodecRegistrationThread,
+                                   this,
+                                   "codec_registration"),
         test_complete_(EventWrapper::Create()),
         crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
         codec_registered_(false),
         receive_packet_count_(0),
         next_insert_packet_time_ms_(0),
         fake_clock_(new SimulatedClock(0)) {
     AudioEncoderIsac::Config config;
     config.payload_type = kPayloadType;
     isac_encoder_.reset(new AudioEncoderIsac(config));
     clock_ = fake_clock_.get();
@@ skipping 15 matching lines @@
     AudioCodingModule::Codec("ISAC", &codec_, kSampleRateHz, 1);
     codec_.pltype = kPayloadType;
 
     // Register iSAC codec in ACM, effectively unregistering the PCM16B codec
     // registered in AudioCodingModuleTestOldApi::SetUp();
     // Only register the decoder for now. The encoder is registered later.
     ASSERT_EQ(0, acm_->RegisterReceiveCodec(codec_));
   }
 
   void StartThreads() {
-    ASSERT_TRUE(receive_thread_->Start());
-    receive_thread_->SetPriority(kRealtimePriority);
-    ASSERT_TRUE(codec_registration_thread_->Start());
-    codec_registration_thread_->SetPriority(kRealtimePriority);
+    receive_thread_.Start();
+    receive_thread_.SetPriority(rtc::kRealtimePriority);
+    codec_registration_thread_.Start();
+    codec_registration_thread_.SetPriority(rtc::kRealtimePriority);
   }
 
   void TearDown() {
     AudioCodingModuleTestOldApi::TearDown();
-    receive_thread_->Stop();
-    codec_registration_thread_->Stop();
+    receive_thread_.Stop();
+    codec_registration_thread_.Stop();
   }
 
   EventTypeWrapper RunTest() {
     return test_complete_->Wait(10 * 60 * 1000);  // 10 minutes' timeout.
   }
 
   static bool CbReceiveThread(void* context) {
     return reinterpret_cast<AcmReRegisterIsacMtTestOldApi*>(context)
         ->CbReceiveImpl();
   }
@@ skipping 58 matching lines @@
       // Register the iSAC encoder.
       EXPECT_EQ(0, acm_->RegisterSendCodec(codec_));
       codec_registered_ = true;
     }
     if (codec_registered_ && receive_packet_count_ > kNumPackets) {
       test_complete_->Set();
     }
     return true;
   }
 
-  rtc::scoped_ptr<PlatformThread> receive_thread_;
-  rtc::scoped_ptr<PlatformThread> codec_registration_thread_;
+  rtc::PlatformThread receive_thread_;
+  rtc::PlatformThread codec_registration_thread_;
   const rtc::scoped_ptr<EventWrapper> test_complete_;
   const rtc::scoped_ptr<CriticalSectionWrapper> crit_sect_;
   bool codec_registered_ GUARDED_BY(crit_sect_);
   int receive_packet_count_ GUARDED_BY(crit_sect_);
   int64_t next_insert_packet_time_ms_ GUARDED_BY(crit_sect_);
   rtc::scoped_ptr<AudioEncoderIsac> isac_encoder_;
   rtc::scoped_ptr<SimulatedClock> fake_clock_;
   test::AudioLoop audio_loop_;
 };
 
@@ skipping 922 matching lines @@
   Run(16000, 8000, 1000);
 }
 
 TEST_F(AcmSwitchingOutputFrequencyOldApi, Toggle8KhzTo16Khz) {
   Run(8000, 16000, 1000);
 }
 
 #endif
 
 }  // namespace webrtc