Cleanup Mutex and related classes.

test/cctest/test-platform-linux.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 34 matching lines @@
 
 static const int kLockCounterLimit = 50;
 static int busy_lock_counter = 0;
 
 
 static void LoopIncrement(Mutex* mutex, int rem) {
   while (true) {
     int count = 0;
     int last_count = -1;
     do {
-      CHECK_EQ(0, mutex->Lock());
+      LockGuard<Mutex> lock_guard(mutex);
       count = busy_lock_counter;
-      CHECK_EQ(0, mutex->Unlock());
       yield();
     } while (count % 2 == rem && count < kLockCounterLimit);
     if (count >= kLockCounterLimit) break;
-    CHECK_EQ(0, mutex->Lock());
+    LockGuard<Mutex> lock_guard(mutex);
     CHECK_EQ(count, busy_lock_counter);
     CHECK(last_count == -1 || count == last_count + 1);
     busy_lock_counter++;
     last_count = count;
-    CHECK_EQ(0, mutex->Unlock());
     yield();
   }
 }
 
 
 static void* RunTestBusyLock(void* arg) {
   LoopIncrement(static_cast<Mutex*>(arg), 0);
   return 0;
 }
 
 
 // Runs two threads that repeatedly acquire the lock and conditionally
 // increment a variable.
 TEST(BusyLock) {
   pthread_t other;
-  Mutex* mutex = OS::CreateMutex();
+  Mutex mutex;
   int thread_created = pthread_create(&other,
                                       NULL,
                                       &RunTestBusyLock,
-                                      mutex);
+                                      &mutex);
   CHECK_EQ(0, thread_created);
-  LoopIncrement(mutex, 1);
+  LoopIncrement(&mutex, 1);
   pthread_join(other, NULL);
-  delete mutex;
 }
 
 
 TEST(VirtualMemory) {
   OS::SetUp();
   VirtualMemory* vm = new VirtualMemory(1 * MB);
   CHECK(vm->IsReserved());
   void* block_addr = vm->address();
   size_t block_size = 4 * KB;
   CHECK(vm->Commit(block_addr, block_size, false));
   // Check whether we can write to memory.
   int* addr = static_cast<int*>(block_addr);
   addr[KB-1] = 2;
   CHECK(vm->Uncommit(block_addr, block_size));
   delete vm;
 }
 
 
 TEST(GetCurrentProcessId) {
   OS::SetUp();
   CHECK_EQ(static_cast<int>(getpid()), OS::GetCurrentProcessId());
 }