[inspector] don't make v8::debug::Call for breakProgram.

src/debug/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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 797 matching lines @@
        node = node->next()) {
     ClearBreakPoints(node->debug_info());
   }
   // Remove all debug info.
   while (debug_info_list_ != NULL) {
     RemoveDebugInfoAndClearFromShared(debug_info_list_->debug_info());
   }
 }
 
 void Debug::FloodWithOneShot(Handle<SharedFunctionInfo> shared) {
-  if (!shared->IsSubjectToDebugging() || IsBlackboxed(shared)) return;
+  if (IsBlackboxed(shared)) return;
   // Make sure the function is compiled and has set up the debug info.
   if (!EnsureDebugInfo(shared)) return;
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   // Flood the function with break points.
   if (debug_info->HasDebugCode()) {
     for (CodeBreakIterator it(debug_info); !it.Done(); it.Next()) {
       it.SetDebugBreak();
     }
   }
   if (debug_info->HasDebugBytecodeArray()) {
@@ skipping 124 matching lines @@
 
       if (found_handler) {
         // We found the handler. If we are stepping next or out, we need to
         // iterate until we found the suitable target frame to break in.
         if ((last_step_action() == StepNext || last_step_action() == StepOut) &&
             current_frame_count > thread_local_.target_frame_count_) {
           continue;
         }
         Handle<SharedFunctionInfo> info(
             summaries[i].AsJavaScript().function()->shared());
-        if (!info->IsSubjectToDebugging() || IsBlackboxed(info)) continue;

[dgozman, 2017/03/09 23:04:01]

Let's do a separate patch for this.

[kozy, 2017/03/10 03:14:54]

Done.

+        if (IsBlackboxed(info)) continue;
         FloodWithOneShot(info);
         return;
       }
     }
   }
 }
 
 
 void Debug::PrepareStep(StepAction step_action) {
   HandleScope scope(isolate_);
@@ skipping 74 matching lines @@
         HandleScope scope(isolate_);
         List<Handle<SharedFunctionInfo>> infos;
         frame->GetFunctions(&infos);
         for (; !infos.is_empty(); current_frame_count--) {
           Handle<SharedFunctionInfo> info = infos.RemoveLast();
           if (in_current_frame) {
             // We want to skip out, so skip the current frame.
             in_current_frame = false;
             continue;
           }
-          if (!info->IsSubjectToDebugging() || IsBlackboxed(info)) continue;
+          if (IsBlackboxed(info)) continue;
           FloodWithOneShot(info);
           thread_local_.target_frame_count_ = current_frame_count;
           return;
         }
       }
       break;
     }
     case StepNext:
       thread_local_.target_frame_count_ = current_frame_count;
     // Fall through.
@@ skipping 656 matching lines @@
   Handle<Context> context = isolate->debug()->debugger_entry()->GetContext();
   // Isolate::context() may have been NULL when "script collected" event
   // occured.
   if (context.is_null()) return v8::Local<v8::Context>();
   Handle<Context> native_context(context->native_context());
   return v8::Utils::ToLocal(native_context);
 }
 }  // anonymous namespace
 
 bool Debug::IsExceptionBlackboxed(bool uncaught) {
-  JavaScriptFrameIterator it(isolate_);
-  if (it.done()) return false;
-  // Uncaught exception is blackboxed if all current frames are blackboxed,
-  // caught exception if top frame is blackboxed.
-  bool is_top_frame_blackboxed = IsFrameBlackboxed(it.frame());
+  bool is_top_frame_blackboxed = IsTopFrameBlackboxed();
   if (!uncaught || !is_top_frame_blackboxed) return is_top_frame_blackboxed;
   return AllFramesOnStackAreBlackboxed();
 }
 
 bool Debug::IsFrameBlackboxed(JavaScriptFrame* frame) {
   HandleScope scope(isolate_);
-  if (!frame->HasInlinedFrames()) {

[dgozman, 2017/03/09 23:04:00]

Together with this.

[kozy, 2017/03/10 03:14:54]

Done.

-    Handle<SharedFunctionInfo> shared(frame->function()->shared(), isolate_);
-    return IsBlackboxed(shared);
-  }
   List<Handle<SharedFunctionInfo>> infos;
   frame->GetFunctions(&infos);
-  for (const auto& info : infos)
+  for (const auto& info : infos) {
     if (!IsBlackboxed(info)) return false;
+  }
   return true;
 }
 
+bool Debug::IsTopFrameBlackboxed() {
+  StackTraceFrameIterator it(isolate_);
+  return !it.done() ? IsFrameBlackboxed(it.javascript_frame()) : true;
+}
+
 void Debug::OnException(Handle<Object> exception, Handle<Object> promise) {
   // We cannot generate debug events when JS execution is disallowed.
   // TODO(5530): Reenable debug events within DisallowJSScopes once relevant
   // code (MakeExceptionEvent and ProcessDebugEvent) have been moved to C++.
   if (!AllowJavascriptExecution::IsAllowed(isolate_)) return;
 
   Isolate::CatchType catch_type = isolate_->PredictExceptionCatcher();
 
   // Don't notify listener of exceptions that are internal to a desugaring.
   if (catch_type == Isolate::CAUGHT_BY_DESUGARING) return;
@@ skipping 196 matching lines @@
 
 namespace {
 debug::Location GetDebugLocation(Handle<Script> script, int source_position) {
   Script::PositionInfo info;
   Script::GetPositionInfo(script, source_position, &info, Script::WITH_OFFSET);
   return debug::Location(info.line, info.column);
 }
 }  // namespace
 
 bool Debug::IsBlackboxed(Handle<SharedFunctionInfo> shared) {
-  if (!debug_delegate_) return false;
+  if (!debug_delegate_) return !shared->IsSubjectToDebugging();
   if (!shared->computed_debug_is_blackboxed()) {
-    bool is_blackboxed = false;
-    if (shared->script()->IsScript()) {
+    bool is_blackboxed = !shared->IsSubjectToDebugging();
+    if (!is_blackboxed) {
       SuppressDebug while_processing(this);
       HandleScope handle_scope(isolate_);
       PostponeInterruptsScope no_interrupts(isolate_);
       DisableBreak no_recursive_break(this);
       Handle<Script> script(Script::cast(shared->script()));
-      if (script->type() == i::Script::TYPE_NORMAL) {
-        debug::Location start =
-            GetDebugLocation(script, shared->start_position());
-        debug::Location end = GetDebugLocation(script, shared->end_position());
-        is_blackboxed = debug_delegate_->IsFunctionBlackboxed(
-            ToApiHandle<debug::Script>(script), start, end);
-      }
+      debug::Location start =
+          GetDebugLocation(script, shared->start_position());
+      debug::Location end = GetDebugLocation(script, shared->end_position());
+      is_blackboxed = debug_delegate_->IsFunctionBlackboxed(
+          ToApiHandle<debug::Script>(script), start, end);
     }
     shared->set_debug_is_blackboxed(is_blackboxed);
     shared->set_computed_debug_is_blackboxed(true);
   }
   return shared->debug_is_blackboxed();
 }
 
 bool Debug::AllFramesOnStackAreBlackboxed() {
   HandleScope scope(isolate_);
   for (StackTraceFrameIterator it(isolate_); !it.done(); it.Advance()) {
-    if (!it.is_javascript()) continue;
     if (!IsFrameBlackboxed(it.javascript_frame())) return false;
   }
   return true;
 }
 
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id,
                              int parent_id) {
   if (in_debug_scope() || ignore_events()) return;
   if (!debug_delegate_) return;
   SuppressDebug while_processing(this);
   DebugScope debug_scope(isolate_->debug());
   if (debug_scope.failed()) return;
   HandleScope scope(isolate_);
   PostponeInterruptsScope no_interrupts(isolate_);
   DisableBreak no_recursive_break(this);
   bool created_by_user = false;
   if (type == debug::kDebugPromiseCreated) {
     JavaScriptFrameIterator it(isolate_);
     // We need to skip top frame which contains instrumentation.
     it.Advance();
     created_by_user =
         !it.done() &&
-        it.frame()->function()->shared()->IsSubjectToDebugging() &&
         !IsFrameBlackboxed(it.frame());
   }
   debug_delegate_->PromiseEventOccurred(
       Utils::ToLocal(debug_scope.GetContext()), type, id, parent_id,
       created_by_user);
 }
 
 void Debug::ProcessCompileEvent(v8::DebugEvent event, Handle<Script> script) {
   if (ignore_events()) return;
   if (script->type() != i::Script::TYPE_NORMAL &&
@@ skipping 91 matching lines @@
 
   Handle<Object> argv[] = { exec_state, data };
   return Execution::Call(
       isolate_,
       fun,
       Handle<Object>(debug_context()->global_proxy(), isolate_),
       arraysize(argv),
       argv);
 }
 
-
-void Debug::HandleDebugBreak() {
+void Debug::HandleDebugBreak(IgnoreBreakMode ignore_break_mode) {
   // Initialize LiveEdit.
   LiveEdit::InitializeThreadLocal(this);
   // Ignore debug break during bootstrapping.
   if (isolate_->bootstrapper()->IsActive()) return;
   // Just continue if breaks are disabled.
   if (break_disabled()) return;
   // Ignore debug break if debugger is not active.
   if (!is_active()) return;
 
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) return;
 
   { JavaScriptFrameIterator it(isolate_);
     DCHECK(!it.done());
     Object* fun = it.frame()->function();
     if (fun && fun->IsJSFunction()) {
       HandleScope scope(isolate_);
       // Don't stop in builtin and blackboxed functions.
       Handle<SharedFunctionInfo> shared(JSFunction::cast(fun)->shared(),
                                         isolate_);
-      if (!shared->IsSubjectToDebugging() || IsBlackboxed(shared)) {
+      bool ignore_break = ignore_break_mode == kTopFrameBlackboxed
+                              ? IsFrameBlackboxed(it.frame())
+                              : AllFramesOnStackAreBlackboxed();
+      if (ignore_break) {
         // Inspector uses pause on next statement for asynchronous breakpoints.
         // When breakpoint is fired we try to break on first not blackboxed
         // statement. To achieve this goal we need to deoptimize current
         // function and don't clear requested DebugBreak even if it's blackboxed
         // to be able to break on not blackboxed function call.
         // TODO(yangguo): introduce break_on_function_entry since current
         // implementation is slow.
-        Deoptimizer::DeoptimizeFunction(JSFunction::cast(fun));
+        if (isolate_->stack_guard()->CheckDebugBreak()) {
+          Deoptimizer::DeoptimizeFunction(JSFunction::cast(fun));
+        }
         return;
       }
       JSGlobalObject* global =
           JSFunction::cast(fun)->context()->global_object();
       // Don't stop in debugger functions.
       if (IsDebugGlobal(global)) return;
       // Don't stop if the break location is muted.
       if (IsMutedAtCurrentLocation(it.frame())) return;
     }
   }
@@ skipping 277 matching lines @@
     isolate_->Throw(*isolate_->factory()->NewEvalError(
         MessageTemplate::kNoSideEffectDebugEvaluate));
   }
   isolate_->set_needs_side_effect_check(old_needs_side_effect_check_);
   isolate_->debug()->UpdateHookOnFunctionCall();
   isolate_->debug()->side_effect_check_failed_ = false;
 }
 
 }  // namespace internal
 }  // namespace v8