Fixed test memory leaks

src/debug.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 1719 matching lines @@
     if (data.is_null()) {
       data = Factory::undefined_value();
     }
     event_listener_data_ = Handle<Object>::cast(GlobalHandles::Create(*data));
   }
 
   UpdateActiveDebugger();
 }
 
 
+void Debugger::TearDown() {
+  if (message_thread_ != NULL)
+    message_thread_->Stop();

[Søren Thygesen Gjesse, 2009/03/26 10:50:09]

Please add { }'s

Why don't you have to delete message_thread_ here to avoid leaking?

[Christian Plesner Hansen, 2009/03/27 00:24:26]

Done.

Technically it's not a leak as long as there's a static variable pointing to it.
 But yes, it might as well be deleted.

+}
+
+
 void Debugger::SetMessageHandler(v8::DebugMessageHandler handler, void* data) {
   message_handler_ = handler;
   message_handler_data_ = data;
   if (!message_thread_) {
     message_thread_ = new DebugMessageThread();
     message_thread_->Start();
   }
   UpdateActiveDebugger();
 }
 
@@ skipping 95 matching lines @@
     agent_->Join();
     delete agent_;
     agent_ = NULL;
   }
 }
 
 
 DebugMessageThread::DebugMessageThread()
     : host_running_(true),
       command_queue_(kQueueInitialSize),
-      message_queue_(kQueueInitialSize) {
+      message_queue_(kQueueInitialSize),
+      keep_running_(true) {
   command_received_ = OS::CreateSemaphore(0);
   message_received_ = OS::CreateSemaphore(0);
 }
 
-// Does not free resources held by DebugMessageThread
-// because this cannot be done thread-safely.
+// Should only be done after the thread is done running.
 DebugMessageThread::~DebugMessageThread() {
+  delete command_received_;
+  delete message_received_;
 }
 
+void DebugMessageThread::Stop() {
+  keep_running_ = false;
+  SendMessage(Vector<uint16_t>(NULL, 0));
+  Join();
+}
 
 // Puts an event coming from V8 on the queue.  Creates
 // a copy of the JSON formatted event string managed by the V8.
 // Called by the V8 thread.
 // The new copy of the event string is destroyed in Run().
 void DebugMessageThread::SendMessage(Vector<uint16_t> message) {
   Vector<uint16_t> message_copy = message.Clone();
   Logger::DebugTag("Put message on event message_queue.");
   message_queue_.Put(message_copy);
   message_received_->Signal();
@@ skipping 27 matching lines @@
   } else {
     PrintLn(try_catch.Exception());
     return false;
   }
   return true;
 }
 
 
 void DebugMessageThread::Run() {
   // Sends debug events to an installed debugger message callback.
-  while (true) {
+  while (keep_running_) {
     // Wait and Get are paired so that semaphore count equals queue length.
     message_received_->Wait();
     Logger::DebugTag("Get message from event message_queue.");
     Vector<uint16_t> message = message_queue_.Get();
     if (message.length() > 0) {
       Debugger::SendMessage(message);
     }
   }
 }
 
@@ skipping 258 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal