Version 3.28.71.3 (merged r23081)

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 4830 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::base::Thread {
  public:
   MessageQueueDebuggerThread()
-      : Thread("MessageQueueDebuggerThread") { }
+      : Thread(Options("MessageQueueDebuggerThread")) {}
   void Run();
 };
 
 
 static void MessageHandler(const v8::Debug::Message& message) {
   v8::Handle<v8::String> json = message.GetJSON();
   v8::String::Utf8Value utf8(json);
   if (IsBreakEventMessage(*utf8)) {
     // Lets test script wait until break occurs to send commands.
     // Signals when a break is reported.
@@ skipping 235 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::base::Thread {
  public:
-  V8Thread() : Thread("V8Thread") { }
+  V8Thread() : Thread(Options("V8Thread")) {}
   void Run();
 };
 
 class DebuggerThread : public v8::base::Thread {
  public:
-  DebuggerThread() : Thread("DebuggerThread") { }
+  DebuggerThread() : Thread(Options("DebuggerThread")) {}
   void Run();
 };
 
 
 static void ThreadedAtBarrier1(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   threaded_debugging_barriers.barrier_1.Wait();
 }
 
 
@@ skipping 85 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::base::Thread {
  public:
-  BreakpointsV8Thread() : Thread("BreakpointsV8Thread") { }
+  BreakpointsV8Thread() : Thread(Options("BreakpointsV8Thread")) {}
   void Run();
 };
 
 class BreakpointsDebuggerThread : public v8::base::Thread {
  public:
   explicit BreakpointsDebuggerThread(bool global_evaluate)
-      : Thread("BreakpointsDebuggerThread"),
+      : Thread(Options("BreakpointsDebuggerThread")),
         global_evaluate_(global_evaluate) {}
   void Run();
 
  private:
   bool global_evaluate_;
 };
 
 
 Barriers* breakpoints_barriers;
 int break_event_breakpoint_id;
@@ skipping 1281 matching lines @@
 
   // Get rid of the debug message handler.
   v8::Debug::SetMessageHandler(NULL);
   CheckDebuggerUnloaded();
 }
 
 
 class SendCommandThread : public v8::base::Thread {
  public:
   explicit SendCommandThread(v8::Isolate* isolate)
-      : Thread("SendCommandThread"),
+      : Thread(Options("SendCommandThread")),
         semaphore_(0),
-        isolate_(isolate) { }
+        isolate_(isolate) {}
 
   static void ProcessDebugMessages(v8::Isolate* isolate, void* data) {
     v8::Debug::ProcessDebugMessages();
     reinterpret_cast<v8::base::Semaphore*>(data)->Signal();
   }
 
   virtual void Run() {
     semaphore_.Wait();
     const int kBufferSize = 1000;
     uint16_t buffer[kBufferSize];
@@ skipping 831 matching lines @@
   if (event_details.GetEvent() != v8::Break || terminate_already_fired) return;
   terminate_requested_semaphore.Signal();
   // Wait for at most 2 seconds for the terminate request.
   CHECK(terminate_fired_semaphore.WaitFor(v8::base::TimeDelta::FromSeconds(2)));
   terminate_already_fired = true;
 }
 
 
 class TerminationThread : public v8::base::Thread {
  public:
-  explicit TerminationThread(v8::Isolate* isolate) : Thread("terminator"),
-                                                     isolate_(isolate) { }
+  explicit TerminationThread(v8::Isolate* isolate)
+      : Thread(Options("terminator")), isolate_(isolate) {}
 
   virtual void Run() {
     terminate_requested_semaphore.Wait();
     v8::V8::TerminateExecution(isolate_);
     terminate_fired_semaphore.Signal();
   }
 
  private:
   v8::Isolate* isolate_;
 };
 
 
 TEST(DebugBreakOffThreadTerminate) {
   DebugLocalContext env;
   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());
 }