Do not force interrupt in test-debug/ProcessDebugMessagesThreaded.

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 6513 matching lines @@
 }
 
 
 class SendCommandThread : public v8::base::Thread {
  public:
   explicit SendCommandThread(v8::Isolate* isolate)
       : Thread(Options("SendCommandThread")),
         semaphore_(0),
         isolate_(isolate) {}
 
-  static void ProcessDebugMessages(v8::Isolate* isolate, void* data) {
-    v8::Debug::ProcessDebugMessages();
-    reinterpret_cast<v8::base::Semaphore*>(data)->Signal();
+  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();
+    }
   }
 
   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++) {
       CHECK_EQ(i, counting_message_handler_counter);
       // Queue debug message.
-      v8::Debug::SendCommand(isolate_, buffer, length);
-      // Synchronize with the main thread to force message processing.
-      isolate_->RequestInterrupt(ProcessDebugMessages, &semaphore_);
+      v8::Debug::SendCommand(isolate_, buffer, length,
+                             new ClientDataImpl(&semaphore_));
+      // Wait for the message handler to pick up the response.
       semaphore_.Wait();
     }
 
     v8::V8::TerminateExecution(isolate_);
   }
 
-  void StartSending() {
-    semaphore_.Signal();
-  }
+  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(CountingMessageHandler);
+  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);
@@ skipping 802 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());
 }