[V8] Send AfterCompile and CompileError messages in debug scope

src/debug.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
@@ skipping 2406 matching lines @@
     int offset = static_cast<int>(
         it.frame()->pc() - code->instruction_start());
     script->set_eval_from_instructions_offset(Smi::FromInt(offset));
   }
 }
 
 
 MaybeHandle<Object> Debug::MakeJSObject(const char* constructor_name,
                                         int argc,
                                         Handle<Object> argv[]) {
-  AssertDebugContext();
+  if (in_debug_scope()) {
+    Handle<GlobalObject> debug_global(debug_context()->global_object());
+    Factory* factory = isolate_->factory();
+    Handle<JSFunction> constructor =
+      Handle<JSFunction>::cast(Object::GetProperty(
+          debug_global, factory->InternalizeUtf8String(constructor_name)).ToHandleChecked());
+    PostponeInterruptsScope no_interrupts(isolate_);
+    return Execution::TryCall(constructor,
+                              handle(debug_context()->global_proxy()),
+                              argc,
+                              argv);
+  }
+
   // Create the execution state object.
   Handle<GlobalObject> global(isolate_->global_object());
   Handle<Object> constructor = Object::GetProperty(
       isolate_, global, constructor_name).ToHandleChecked();
   DCHECK(constructor->IsJSFunction());
   if (!constructor->IsJSFunction()) return MaybeHandle<Object>();
   // We do not handle interrupts here.  In particular, termination interrupts.
   PostponeInterruptsScope no_interrupts(isolate_);
   return Execution::TryCall(Handle<JSFunction>::cast(constructor),
                             handle(debug_context()->global_proxy()),
@@ skipping 129 matching lines @@
   }
 
   // Process debug event.
   ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
 void Debug::OnCompileError(Handle<Script> script) {
   // No more to do if not debugging.
-  if (in_debug_scope() || ignore_events()) return;
+  if (ignore_events()) return;
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   // Create the compile state object.
   Handle<Object> event_data;
   // Bail out and don't call debugger if exception.
   if (!MakeCompileEvent(script, v8::CompileError).ToHandle(&event_data)) return;
 
@@ skipping 41 matching lines @@
                     true);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debug::OnAfterCompile(Handle<Script> script) {
   // Add the newly compiled script to the script cache.
   if (script_cache_ != NULL) script_cache_->Add(script);
 
   // No more to do if not debugging.
-  if (in_debug_scope() || ignore_events()) return;
+  if (ignore_events()) return;
+  if (in_debug_scope()) {
+    // Create the compile state object.
+    Handle<Object> event_data;
+    // Bail out and don't call debugger if exception.
+    if (!MakeCompileEvent(script, v8::AfterCompile).ToHandle(&event_data)) return;
+
+    // Process debug event.
+    ProcessDebugEvent(v8::AfterCompile, Handle<JSObject>::cast(event_data), true);
+    return;
+  }
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
   if (debug_scope.failed()) 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-debugger.js).
   Handle<String> update_script_break_points_string =
@@ skipping 172 matching lines @@
     case v8::NewFunction:
       break;
     default:
       UNREACHABLE();
   }
 
   // The debug command interrupt flag might have been set when the command was
   // added. It should be enough to clear the flag only once while we are in the
   // debugger.
   DCHECK(in_debug_scope());
-  isolate_->stack_guard()->ClearDebugCommand();
+  if (!(in_debug_scope() && (event == v8::AfterCompile || event == v8::CompileError)))
+    isolate_->stack_guard()->ClearDebugCommand();
 
   // Notify the debugger that a debug event has occurred unless auto continue is
   // active in which case no event is send.
   if (sendEventMessage) {
     MessageImpl message = MessageImpl::NewEvent(
         event,
         auto_continue,
         Handle<JSObject>::cast(exec_state),
         Handle<JSObject>::cast(event_data));
     InvokeMessageHandler(message);
   }
 
   // If auto continue don't make the event cause a break, but process messages
   // in the queue if any. For script collected events don't even process
   // messages in the queue as the execution state might not be what is expected
   // by the client.
   if (auto_continue && !has_commands()) return;
+  if (in_debug_scope() && (event == v8::AfterCompile || event == v8::CompileError)) return;
 
   // DebugCommandProcessor goes here.
   bool running = auto_continue;
 
   Handle<Object> cmd_processor_ctor = Object::GetProperty(
       isolate_, exec_state, "debugCommandProcessor").ToHandleChecked();
   Handle<Object> ctor_args[] = { isolate_->factory()->ToBoolean(running) };
   Handle<Object> cmd_processor = Execution::Call(
       isolate_, cmd_processor_ctor, exec_state, 1, ctor_args).ToHandleChecked();
   Handle<JSFunction> process_debug_request = Handle<JSFunction>::cast(
@@ skipping 525 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal