Simplify test-debug/ProcessDebugMessagesThreaded and add debug output.

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 6553 matching lines @@
   v8::Debug::ProcessDebugMessages();
   // At least two messages should come
   CHECK_GE(counting_message_handler_counter, 2);
 
   // Get rid of the debug message handler.
   v8::Debug::SetMessageHandler(NULL);
   CheckDebuggerUnloaded();
 }
 
 
+class SendCommandThread;
+static SendCommandThread* send_command_thread_ = NULL;
+
+
 class SendCommandThread : public v8::base::Thread {
  public:
   explicit SendCommandThread(v8::Isolate* isolate)
       : Thread(Options("SendCommandThread")),
         semaphore_(0),
         isolate_(isolate) {}
 
-  class ClientDataImpl : public v8::Debug::ClientData {
-   public:
-    explicit ClientDataImpl(v8::base::Semaphore* semaphore)
-        : semaphore_(semaphore) {}
-    v8::base::Semaphore* semaphore() { return semaphore_; }
-
-   private:
-    v8::base::Semaphore* semaphore_;
-  };
-
   static void CountingAndSignallingMessageHandler(
       const v8::Debug::Message& message) {
     if (message.IsResponse()) {
       counting_message_handler_counter++;
-      ClientDataImpl* data =
-          reinterpret_cast<ClientDataImpl*>(message.GetClientData());
-      v8::base::Semaphore* semaphore = data->semaphore();
-      semaphore->Signal();
+      send_command_thread_->semaphore_.Signal();
     }
   }
 
   virtual void Run() {
     semaphore_.Wait();
     const int kBufferSize = 1000;
     uint16_t buffer[kBufferSize];
     const char* scripts_command =
       "{\"seq\":0,"
        "\"type\":\"request\","
        "\"command\":\"scripts\"}";
     int length = AsciiToUtf16(scripts_command, buffer);
     // Send scripts command.
 
-    for (int i = 0; i < 100; i++) {
+    for (int i = 0; i < 20; i++) {
+      v8::base::ElapsedTimer timer;
+      timer.Start();
       CHECK_EQ(i, counting_message_handler_counter);
       // Queue debug message.
-      v8::Debug::SendCommand(isolate_, buffer, length,
-                             new ClientDataImpl(&semaphore_));
+      v8::Debug::SendCommand(isolate_, buffer, length);
       // Wait for the message handler to pick up the response.
       semaphore_.Wait();
+      i::PrintF("iteration %d took %f ms\n", i,
+                timer.Elapsed().InMillisecondsF());
     }
 
     v8::V8::TerminateExecution(isolate_);
   }
 
   void StartSending() { semaphore_.Signal(); }
 
  private:
   v8::base::Semaphore semaphore_;
   v8::Isolate* isolate_;
 };
 
 
-static SendCommandThread* send_command_thread_ = NULL;
-
 static void StartSendingCommands(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   send_command_thread_->StartSending();
 }
 
 
 TEST(ProcessDebugMessagesThreaded) {
   DebugLocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   counting_message_handler_counter = 0;
 
   v8::Debug::SetMessageHandler(
       SendCommandThread::CountingAndSignallingMessageHandler);
   send_command_thread_ = new SendCommandThread(isolate);
   send_command_thread_->Start();
 
   v8::Handle<v8::FunctionTemplate> start =
       v8::FunctionTemplate::New(isolate, StartSendingCommands);
   env->Global()->Set(v8_str("start"), start->GetFunction());
 
   CompileRun("start(); while (true) { }");
 
-  CHECK_EQ(100, counting_message_handler_counter);
+  CHECK_EQ(20, counting_message_handler_counter);
 
   v8::Debug::SetMessageHandler(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 struct BacktraceData {
   static int frame_counter;
   static void MessageHandler(const v8::Debug::Message& message) {
     char print_buffer[1000];
@@ skipping 792 matching lines @@
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Debug::SetDebugEventListener(DebugBreakTriggerTerminate);
   TerminationThread terminator(isolate);
   terminator.Start();
   v8::TryCatch try_catch;
   v8::Debug::DebugBreak(isolate);
   CompileRun("while (true);");
   CHECK(try_catch.HasTerminated());
 }