Cleanup Semaphore class.

test/cctest/test-debug.cc

 // Copyright 2012 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 4661 matching lines @@
 // be used once.
 class ThreadBarrier {
  public:
   explicit ThreadBarrier(int num_threads);
   ~ThreadBarrier();
   void Wait();
  private:
   int num_threads_;
   int num_blocked_;
   v8::internal::Mutex lock_;
-  v8::internal::Semaphore* sem_;
+  v8::internal::Semaphore sem_;
   bool invalid_;
 };
 
 ThreadBarrier::ThreadBarrier(int num_threads)
-    : num_threads_(num_threads), num_blocked_(0) {
-  sem_ = OS::CreateSemaphore(0);
+    : num_threads_(num_threads), num_blocked_(0), sem_(0) {
   invalid_ = false;  // A barrier may only be used once.  Then it is invalid.
 }
 
 
 // Do not call, due to race condition with Wait().
 // Could be resolved with Pthread condition variables.
 ThreadBarrier::~ThreadBarrier() {
-  delete sem_;
 }
 
 
 void ThreadBarrier::Wait() {
   lock_.Lock();
   CHECK(!invalid_);
   if (num_blocked_ == num_threads_ - 1) {
     // Signal and unblock all waiting threads.
     for (int i = 0; i < num_threads_ - 1; ++i) {
-      sem_->Signal();
+      sem_.Signal();
     }
     invalid_ = true;
     printf("BARRIER\n\n");
     fflush(stdout);
     lock_.Unlock();
   } else {  // Wait for the semaphore.
     ++num_blocked_;
     lock_.Unlock();  // Potential race condition with destructor because
-    sem_->Wait();  // these two lines are not atomic.
+    sem_.Wait();  // these two lines are not atomic.
   }
 }
 
 
 // A set containing enough barriers and semaphores for any of the tests.
 class Barriers {
  public:
   Barriers();
   void Initialize();
   ThreadBarrier barrier_1;
   ThreadBarrier barrier_2;
   ThreadBarrier barrier_3;
   ThreadBarrier barrier_4;
   ThreadBarrier barrier_5;
   v8::internal::Semaphore* semaphore_1;
   v8::internal::Semaphore* semaphore_2;
 };
 
 Barriers::Barriers() : barrier_1(2), barrier_2(2),
     barrier_3(2), barrier_4(2), barrier_5(2) {}
 
 void Barriers::Initialize() {
-  semaphore_1 = OS::CreateSemaphore(0);
-  semaphore_2 = OS::CreateSemaphore(0);
+  semaphore_1 = new v8::internal::Semaphore(0);
+  semaphore_2 = new v8::internal::Semaphore(0);
 }
 
 
 // We match parts of the message to decide if it is a break message.
 bool IsBreakEventMessage(char *message) {
   const char* type_event = "\"type\":\"event\"";
   const char* event_break = "\"event\":\"break\"";
   // Does the message contain both type:event and event:break?
   return strstr(message, type_event) != NULL &&
          strstr(message, event_break) != NULL;
@@ skipping 1233 matching lines @@
 }
 
 
 class DebuggerAgentProtocolServerThread : public i::Thread {
  public:
   explicit DebuggerAgentProtocolServerThread(int port)
       : Thread("DebuggerAgentProtocolServerThread"),
         port_(port),
         server_(NULL),
         client_(NULL),
-        listening_(OS::CreateSemaphore(0)) {
+        listening_(0) {
   }
   ~DebuggerAgentProtocolServerThread() {
     // Close both sockets.
     delete client_;
     delete server_;
-    delete listening_;
   }
 
   void Run();
-  void WaitForListening() { listening_->Wait(); }
+  void WaitForListening() { listening_.Wait(); }
   char* body() { return *body_; }
 
  private:
   int port_;
   i::SmartArrayPointer<char> body_;
   i::Socket* server_;  // Server socket used for bind/accept.
   i::Socket* client_;  // Single client connection used by the test.
-  i::Semaphore* listening_;  // Signalled when the server is in listen mode.
+  i::Semaphore listening_;  // Signalled when the server is in listen mode.
 };
 
 
 void DebuggerAgentProtocolServerThread::Run() {
   bool ok;
 
   // Create the server socket and bind it to the requested port.
   server_ = i::OS::CreateSocket();
   CHECK(server_ != NULL);
   ok = server_->Bind(port_);
   CHECK(ok);
 
   // Listen for new connections.
   ok = server_->Listen(1);
   CHECK(ok);
-  listening_->Signal();
+  listening_.Signal();
 
   // Accept a connection.
   client_ = server_->Accept();
   CHECK(client_ != NULL);
 
   // Receive a debugger agent protocol message.
   i::DebuggerAgentUtil::ReceiveMessage(client_);
 }
 
 
@@ skipping 1512 matching lines @@
 TEST(LiveEditDisabled) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Debug::SetLiveEditEnabled(false);
   CompileRun("%LiveEditCompareStrings('', '')");
 }
 
 
 #endif  // ENABLE_DEBUGGER_SUPPORT