[Isolates] Fix debugger and termination APIs callable from other threads.

src/api.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 4273 matching lines @@
   // execution right away.  Otherwise, ask the thread manager to
   // terminate the thread with the given id if any.
   if (thread_id == isolate->thread_id()) {
     isolate->stack_guard()->TerminateExecution();
   } else {
     isolate->thread_manager()->TerminateExecution(thread_id);
   }
 }
 
 
-void V8::TerminateExecution() {
-  if (!i::Isolate::Current()->IsInitialized()) return;
-  i::Isolate::Current()->stack_guard()->TerminateExecution();
+void V8::TerminateExecution(Isolate* isolate) {
+  // If no isolate is supplied, use the default isolate.
+  if (isolate != NULL) {
+    reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->TerminateExecution();
+  } else {
+    i::Isolate::GetDefaultIsolateStackGuard()->TerminateExecution();
+  }
 }
 
 
 bool V8::IsExecutionTerminating() {
   if (!i::Isolate::Current()->IsInitialized()) return false;
   if (i::Isolate::Current()->has_scheduled_exception()) {
     return i::Isolate::Current()->scheduled_exception() ==
         HEAP->termination_exception();
   }
   return false;
@@ skipping 244 matching lines @@
 bool Debug::SetDebugEventListener(v8::Handle<v8::Object> that,
                                   Handle<Value> data) {
   ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false);
   ENTER_V8;
   i::Isolate::Current()->debugger()->SetEventListener(Utils::OpenHandle(*that),
                                                       Utils::OpenHandle(*data));
   return true;
 }
 
 
-void Debug::DebugBreak() {
-  if (!i::Isolate::Current()->IsInitialized()) return;
-  i::Isolate::Current()->stack_guard()->DebugBreak();
+void Debug::DebugBreak(Isolate* isolate) {
+  // If no isolate is supplied, use the default isolate.
+  if (isolate != NULL) {
+    reinterpret_cast<i::Isolate*>(isolate)->stack_guard()->DebugBreak();
+  } else {
+    i::Isolate::GetDefaultIsolateStackGuard()->DebugBreak();
+  }
 }
 
 
-void Debug::CancelDebugBreak() {
-  i::Isolate::Current()->stack_guard()->Continue(i::DEBUGBREAK);
+void Debug::CancelDebugBreak(Isolate* isolate) {
+  // If no isolate is supplied, use the default isolate.
+  if (isolate != NULL) {
+    i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
+    internal_isolate->stack_guard()->Continue(i::DEBUGBREAK);
+  } else {
+    i::Isolate::GetDefaultIsolateStackGuard()->Continue(i::DEBUGBREAK);
+  }
 }
 
 
-void Debug::DebugBreakForCommand(ClientData* data) {
-  if (!i::Isolate::Current()->IsInitialized()) return;
-  i::Isolate::Current()->debugger()->EnqueueDebugCommand(data);
+void Debug::DebugBreakForCommand(ClientData* data, Isolate* isolate) {
+  // If no isolate is supplied, use the default isolate.
+  if (isolate != NULL) {
+    i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
+    internal_isolate->debugger()->EnqueueDebugCommand(data);
+  } else {
+    i::Isolate::GetDefaultIsolateDebugger()->EnqueueDebugCommand(data);
+  }
 }
 
 
 static void MessageHandlerWrapper(const v8::Debug::Message& message) {
   i::Isolate* isolate = i::Isolate::Current();
   if (isolate->message_handler()) {
     v8::String::Value json(message.GetJSON());
     (isolate->message_handler())(*json, json.length(), message.GetClientData());
   }
 }
@@ skipping 681 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* thread_local =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   thread_local->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal