[V8] Report v8::AfterCompile and v8::CompileError to listener on pause

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 2463 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();
   // Create the execution state object.
-  Handle<GlobalObject> global(isolate_->global_object());
+  Handle<GlobalObject> global = in_debug_scope() ? Handle<GlobalObject>(debug_context()->global_object()) : Handle<GlobalObject>(isolate_->global_object());

[yurys, 2014/12/08 07:19:28]

This way we will create debugger objects in the user context. This is dangerous
since the user code can override almost everything and we may at some point end
up executing user code in the debugger context. Please make sure to enter
debugger context first if you need to create an object for the debugger.

[kozy, 2014/12/08 14:19:30]

Done.

   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()),
                             argc,
                             argv);
@@ skipping 126 matching lines @@
     return;
   }
 
   // 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;
+
+  if (in_debug_scope()) {
+    ProcessCompileEventInDebugScope(v8::CompileError, script);
+    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 40 matching lines @@
                     Handle<JSObject>::cast(event_data),
                     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()) {
+    ProcessCompileEventInDebugScope(v8::AfterCompile, script);
+    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 134 matching lines @@
                               event_data,
                               event_listener_data_ };
     Handle<JSReceiver> global(isolate_->global_proxy());
     Execution::TryCall(Handle<JSFunction>::cast(event_listener_),
                        global, arraysize(argv), argv);
   }
   in_debug_event_listener_ = previous;
 }
 
 
+void Debug::ProcessCompileEventInDebugScope(v8::DebugEvent event,
+                                            Handle<Script> script) {
+  if (event_listener_.is_null()) return;

[yurys, 2014/12/08 10:55:51]

I believe you can reenter debug context here if it is not on the top of the
stack. Also it should be possible to use SuppressDebug scope here.

[kozy, 2014/12/08 14:19:30]

Done.

+
+  Handle<Object> event_data;
+  // Bail out and don't call debugger if exception.
+  if (!MakeCompileEvent(script, event).ToHandle(&event_data)) return;
+
+  // Create the execution state.
+  Handle<Object> exec_state;
+  // Bail out and don't call debugger if exception.
+  if (!MakeExecutionState().ToHandle(&exec_state)) return;
+
+  CallEventCallback(event, exec_state, event_data, NULL);
+}
+
+
 Handle<Context> Debug::GetDebugContext() {
   DebugScope debug_scope(this);
   // The global handle may be destroyed soon after.  Return it reboxed.
   return handle(*debug_context(), isolate_);
 }
 
 
 void Debug::NotifyMessageHandler(v8::DebugEvent event,
                                  Handle<JSObject> exec_state,
                                  Handle<JSObject> event_data,
@@ skipping 584 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 } }  // namespace v8::internal