Use v8::internal threading support in samples/shell.cc.

test/cctest/test-debug.cc

 // Copyright 2010 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 4703 matching lines @@
  * response messages to the debugger.  Fills queues and makes
  * them grow.
  */
 Barriers message_queue_barriers;
 
 // This is the debugger thread, that executes no v8 calls except
 // placing JSON debugger commands in the queue.
 class MessageQueueDebuggerThread : public v8::internal::Thread {
  public:
   explicit MessageQueueDebuggerThread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "MessageQueueDebuggerThread") { }
   void Run();
 };
 
 static void MessageHandler(const uint16_t* message, int length,
                            v8::Debug::ClientData* client_data) {
   static char print_buffer[1000];
   Utf16ToAscii(message, length, print_buffer);
   if (IsBreakEventMessage(print_buffer)) {
     // Lets test script wait until break occurs to send commands.
     // Signals when a break is reported.
@@ skipping 230 matching lines @@
 /* This test interrupts a running infinite loop that is
  * occupying the v8 thread by a break command from the
  * debugger thread.  It then changes the value of a
  * global object, to make the loop terminate.
  */
 
 Barriers threaded_debugging_barriers;
 
 class V8Thread : public v8::internal::Thread {
  public:
-  explicit V8Thread(v8::internal::Isolate* isolate) : Thread(isolate) { }
+  explicit V8Thread(v8::internal::Isolate* isolate)
+      : Thread(isolate, "V8Thread") { }
   void Run();
 };
 
 class DebuggerThread : public v8::internal::Thread {
  public:
-  explicit DebuggerThread(v8::internal::Isolate* isolate) : Thread(isolate) { }
+  explicit DebuggerThread(v8::internal::Isolate* isolate)
+      : Thread(isolate, "DebuggerThread") { }
   void Run();
 };
 
 
 static v8::Handle<v8::Value> ThreadedAtBarrier1(const v8::Arguments& args) {
   threaded_debugging_barriers.barrier_1.Wait();
   return v8::Undefined();
 }
 
 
@@ skipping 79 matching lines @@
 /* Test RecursiveBreakpoints */
 /* In this test, the debugger evaluates a function with a breakpoint, after
  * hitting a breakpoint in another function.  We do this with both values
  * of the flag enabling recursive breakpoints, and verify that the second
  * breakpoint is hit when enabled, and missed when disabled.
  */
 
 class BreakpointsV8Thread : public v8::internal::Thread {
  public:
   explicit BreakpointsV8Thread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "BreakpointsV8Thread") { }
   void Run();
 };
 
 class BreakpointsDebuggerThread : public v8::internal::Thread {
  public:
   explicit BreakpointsDebuggerThread(v8::internal::Isolate* isolate,
                                      bool global_evaluate)
-      : Thread(isolate), global_evaluate_(global_evaluate) {}
+      : Thread(isolate, "BreakpointsDebuggerThread"),
+        global_evaluate_(global_evaluate) {}
   void Run();
 
  private:
   bool global_evaluate_;
 };
 
 
 Barriers* breakpoints_barriers;
 int break_event_breakpoint_id;
 int evaluate_int_result;
@@ skipping 540 matching lines @@
 
 
 /* Test DebuggerHostDispatch */
 /* In this test, the debugger waits for a command on a breakpoint
  * and is dispatching host commands while in the infinite loop.
  */
 
 class HostDispatchV8Thread : public v8::internal::Thread {
  public:
   explicit HostDispatchV8Thread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "HostDispatchV8Thread") { }
   void Run();
 };
 
 class HostDispatchDebuggerThread : public v8::internal::Thread {
  public:
   explicit HostDispatchDebuggerThread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "HostDispatchDebuggerThread") { }
   void Run();
 };
 
 Barriers* host_dispatch_barriers;
 
 static void HostDispatchMessageHandler(const v8::Debug::Message& message) {
   static char print_buffer[1000];
   v8::String::Value json(message.GetJSON());
   Utf16ToAscii(*json, json.length(), print_buffer);
 }
@@ skipping 78 matching lines @@
 
 /* Test DebugMessageDispatch */
 /* In this test, the V8 thread waits for a message from the debug thread.
  * The DebugMessageDispatchHandler is executed from the debugger thread
  * which signals the V8 thread to wake up.
  */
 
 class DebugMessageDispatchV8Thread : public v8::internal::Thread {
  public:
   explicit DebugMessageDispatchV8Thread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "DebugMessageDispatchV8Thread") { }
   void Run();
 };
 
 class DebugMessageDispatchDebuggerThread : public v8::internal::Thread {
  public:
   explicit DebugMessageDispatchDebuggerThread(v8::internal::Isolate* isolate)
-      : Thread(isolate) { }
+      : Thread(isolate, "DebugMessageDispatchDebuggerThread") { }
   void Run();
 };
 
 Barriers* debug_message_dispatch_barriers;
 
 
 static void DebugMessageHandler() {
   debug_message_dispatch_barriers->semaphore_1->Signal();
 }
 
@@ skipping 82 matching lines @@
   debugger->StartAgent("test", kPort3);
   debugger->StopAgent();
 
   delete server;
 }
 
 
 class DebuggerAgentProtocolServerThread : public i::Thread {
  public:
   explicit DebuggerAgentProtocolServerThread(i::Isolate* isolate, int port)
-      : Thread(isolate), port_(port), server_(NULL), client_(NULL),
+      : Thread(isolate, "DebuggerAgentProtocolServerThread"),
+        port_(port),
+        server_(NULL),
+        client_(NULL),
         listening_(OS::CreateSemaphore(0)) {
   }
   ~DebuggerAgentProtocolServerThread() {
     // Close both sockets.
     delete client_;
     delete server_;
     delete listening_;
   }
 
   void Run();
@@ skipping 1370 matching lines @@
   TestDebugBreakInLoop("for (;;) {", loop_bodies, "}");
   TestDebugBreakInLoop("for (;a == 1;) {", loop_bodies, "}");
 
   // Get rid of the debug event listener.
   v8::Debug::SetDebugEventListener(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 #endif  // ENABLE_DEBUGGER_SUPPORT