Clean up PlatformThread.

webrtc/system_wrappers/source/critical_section_unittest.cc

 /*
  *  Copyright (c) 2012 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 60 matching lines @@
 bool LockUnlockThenStopRunFunction(void* obj) {
   ProtectedCount* the_count = static_cast<ProtectedCount*>(obj);
   the_count->Increment();
   return false;
 }
 
 TEST_F(CritSectTest, ThreadWakesOnce) NO_THREAD_SAFETY_ANALYSIS {
   CriticalSectionWrapper* crit_sect =
       CriticalSectionWrapper::CreateCriticalSection();
   ProtectedCount count(crit_sect);
-  rtc::scoped_ptr<PlatformThread> thread = PlatformThread::CreateThread(
+  rtc::PlatformThread thread(
       &LockUnlockThenStopRunFunction, &count, "ThreadWakesOnce");
   crit_sect->Enter();
-  ASSERT_TRUE(thread->Start());
+  thread.Start();
   SwitchProcess();
   // The critical section is of reentrant mode, so this should not release
   // the lock, even though count.Count() locks and unlocks the critical section
   // again.
   // Thus, the thread should not be able to increment the count
   ASSERT_EQ(0, count.Count());
   crit_sect->Leave();  // This frees the thread to act.
   EXPECT_TRUE(WaitForCount(1, &count));
-  EXPECT_TRUE(thread->Stop());
+  thread.Stop();
   delete crit_sect;
 }
 
 bool LockUnlockRunFunction(void* obj) {
   ProtectedCount* the_count = static_cast<ProtectedCount*>(obj);
   the_count->Increment();
   SwitchProcess();
   return true;
 }
 
 TEST_F(CritSectTest, ThreadWakesTwice) NO_THREAD_SAFETY_ANALYSIS {
   CriticalSectionWrapper* crit_sect =
       CriticalSectionWrapper::CreateCriticalSection();
   ProtectedCount count(crit_sect);
-  rtc::scoped_ptr<PlatformThread> thread = PlatformThread::CreateThread(
+  rtc::PlatformThread thread(
       &LockUnlockRunFunction, &count, "ThreadWakesTwice");
   crit_sect->Enter();  // Make sure counter stays 0 until we wait for it.
-  ASSERT_TRUE(thread->Start());
+  thread.Start();
   crit_sect->Leave();
 
   // The thread is capable of grabbing the lock multiple times,
   // incrementing counter once each time.
   // It's possible for the count to be incremented by more than 2.
   EXPECT_TRUE(WaitForCount(2, &count));
   EXPECT_LE(2, count.Count());
 
   // The thread does not increment while lock is held.
   crit_sect->Enter();
   int count_before = count.Count();
   for (int i = 0; i < 10; i++) {
     SwitchProcess();
   }
   EXPECT_EQ(count_before, count.Count());
   crit_sect->Leave();
 
   SwitchProcess();
   EXPECT_TRUE(WaitForCount(count_before + 1, &count));
-  EXPECT_TRUE(thread->Stop());
+  thread.Stop();
   delete crit_sect;
 }
 
 }  // anonymous namespace
 
 }  // namespace webrtc