Refactored the logic for entering the debugger into one abstraction EnterDebu...

src/debug.cc

 // 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 613 matching lines @@
   // Get the top-most JavaScript frame.
   JavaScriptFrameIterator it;
   JavaScriptFrame* frame = it.frame();
 
   // Just continue if breaks are disabled or debugger cannot be loaded.
   if (disable_break() || !Load()) {
     SetAfterBreakTarget(frame);
     return Heap::undefined_value();
   }
 
-  SaveBreakFrame save;
-  EnterDebuggerContext enter;
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter()) {
+    return Heap::undefined_value();
+  }
 
   // Postpone interrupt during breakpoint processing.
   PostponeInterruptsScope postpone;
 
   // Get the debug info (create it if it does not exist).
   Handle<SharedFunctionInfo> shared =
       Handle<SharedFunctionInfo>(JSFunction::cast(frame->function())->shared());
   Handle<DebugInfo> debug_info = GetDebugInfo(shared);
 
   // Find the break point where execution has stopped.
@@ skipping 762 matching lines @@
   // Bail out if exception breaks are not active
   if (uncaught) {
     // Uncaught exceptions are reported by either flags.
     if (!(Debug::break_on_uncaught_exception() ||
           Debug::break_on_exception())) return;
   } else {
     // Caught exceptions are reported is activated.
     if (!Debug::break_on_exception()) return;
   }
 
-  // Enter the debugger.  Bail out if the debugger cannot be loaded.
-  if (!Debug::Load()) return;
-  SaveBreakFrame save;
-  EnterDebuggerContext enter;
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter()) return;
 
   // Clear all current stepping setup.
   Debug::ClearStepping();
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   Handle<Object> event_data;
   if (!caught_exception) {
     event_data = MakeExceptionEvent(exec_state, exception, uncaught,
                                     &caught_exception);
@@ skipping 40 matching lines @@
 
 
 void Debugger::OnBeforeCompile(Handle<Script> script) {
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!EventActive(v8::BeforeCompile)) return;
 
-  // Enter the debugger.  Bail out if the debugger cannot be loaded.
-  if (!Debug::Load()) return;
-  SaveBreakFrame save;
-  EnterDebuggerContext enter;
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter()) return;
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeCompileEvent(script,
                                                Factory::undefined_value(),
                                                &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
   // Process debug event
   ProcessDebugEvent(v8::BeforeCompile, event_data);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script, Handle<JSFunction> fun) {
   HandleScope scope;
 
   // No compile events while compiling natives.
   if (compiling_natives()) return;
 
   // No more to do if not debugging.
   if (!debugger_active()) return;
 
-  // Enter the debugger.  Bail out if the debugger cannot be loaded.
-  if (!Debug::Load()) return;
-  SaveBreakFrame save;
-  EnterDebuggerContext enter;
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter()) return;
 
   // If debugging there might be script break points registered for this
   // script. Make sure that these break points are set.
 
   // Get the function UpdateScriptBreakPoints (defined in debug-delay.js).
   Handle<Object> update_script_break_points =
       Handle<Object>(Debug::debug_context()->global()->GetProperty(
           *Factory::LookupAsciiSymbol("UpdateScriptBreakPoints")));
   if (!update_script_break_points->IsJSFunction()) {
     return;
@@ skipping 34 matching lines @@
 
 void Debugger::OnNewFunction(Handle<JSFunction> function) {
   return;
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!Debugger::EventActive(v8::NewFunction)) return;
 
-  // Enter the debugger.  Bail out if the debugger cannot be loaded.
-  if (!Debug::Load()) return;
-  SaveBreakFrame save;
-  EnterDebuggerContext enter;
+  // Enter the debugger.
+  EnterDebugger debugger;
+  if (debugger.FailedToEnter()) return;
 
   // Create the event object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeNewFunctionEvent(function, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event.
   ProcessDebugEvent(v8::NewFunction, event_data);
@@ skipping 381 matching lines @@
 }
 
 
 void LockingMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 
 } }  // namespace v8::internal