[Isolates]...

src/debug.h

 // Copyright 2006-2008 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 762 matching lines @@
     // Make sure that debugger is loaded and enter the debugger context.
     load_failed_ = !Debug::Load();
     if (!load_failed_) {
       // NOTE the member variable save which saves the previous context before
       // this change.
       Top::set_context(*Debug::debug_context());
     }
   }
 
   ~EnterDebugger() {
+    // TODO(isolates): Check to see if this is the same isolate as in the
+    //                 constructor.
+    Isolate* isolate = Isolate::Current();
+
     // Restore to the previous break state.
     Debug::SetBreak(break_frame_id_, break_id_);
 
     // Check for leaving the debugger.
     if (prev_ == NULL) {
       // Clear mirror cache when leaving the debugger. Skip this if there is a
       // pending exception as clearing the mirror cache calls back into
       // JavaScript. This can happen if the v8::Debug::Call is used in which
       // case the exception should end up in the calling code.
       if (!Top::has_pending_exception()) {
         // Try to avoid any pending debug break breaking in the clear mirror
         // cache JavaScript code.
-        if (StackGuard::IsDebugBreak()) {
+        if (isolate->stack_guard()->IsDebugBreak()) {
           Debug::set_interrupts_pending(DEBUGBREAK);
-          StackGuard::Continue(DEBUGBREAK);
+          isolate->stack_guard()->Continue(DEBUGBREAK);
         }
         Debug::ClearMirrorCache();
       }
 
       // Request preemption and debug break when leaving the last debugger entry
       // if any of these where recorded while debugging.
       if (Debug::is_interrupt_pending(PREEMPT)) {
         // This re-scheduling of preemption is to avoid starvation in some
         // debugging scenarios.
         Debug::clear_interrupt_pending(PREEMPT);
-        StackGuard::Preempt();
+        isolate->stack_guard()->Preempt();
       }
       if (Debug::is_interrupt_pending(DEBUGBREAK)) {
         Debug::clear_interrupt_pending(DEBUGBREAK);
-        StackGuard::DebugBreak();
+        isolate->stack_guard()->DebugBreak();
       }
 
       // If there are commands in the queue when leaving the debugger request
       // that these commands are processed.
       if (Debugger::HasCommands()) {
-        StackGuard::DebugCommand();
+        isolate->stack_guard()->DebugCommand();
       }
 
       // If leaving the debugger with the debugger no longer active unload it.
       if (!Debugger::IsDebuggerActive()) {
         Debugger::UnloadDebugger();
       }
     }
 
     // Leaving this debugger entry.
     Debug::set_debugger_entry(prev_);
@@ skipping 98 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MessageDispatchHelperThread);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 #endif  // V8_DEBUG_H_