[inspector] implemented blackboxing inside v8

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 845 matching lines @@
     // step in at call sites.
     Deoptimizer::DeoptimizeFunction(*function);
     return;
   }
   // Make sure the function is compiled and has set up the debug info.
   Handle<SharedFunctionInfo> shared(function->shared());
   if (!EnsureDebugInfo(shared, function)) {
     // Return if we failed to retrieve the debug info.
     return;
   }
+  if (shared->debug_is_blackboxed()) return;

[Yang, 2017/01/19 13:55:35]

Do we need to ensure debug info if it's blackboxed?
Also, we definitely need to deopt the function. Otherwise we could assume the
wrong black box state for inlined functions. I'd just put this on the same line
as the IsSubjectToDebugging check above.

[kozy, 2017/01/19 16:08:38]

Done.

 
   // Flood the function with break points.
   Handle<DebugInfo> debug_info(shared->GetDebugInfo());
   if (debug_info->HasDebugCode()) {
     for (CodeBreakIterator it(debug_info, type); !it.Done(); it.Next()) {
       it.SetDebugBreak();
     }
   }
   if (debug_info->HasDebugBytecodeArray()) {
     for (BytecodeArrayBreakIterator it(debug_info, type); !it.Done();
@@ skipping 86 matching lines @@
   if (last_step_action() == StepNext || last_step_action() == StepOut) {
     while (!it.done()) {
       Address current_fp = it.frame()->UnpaddedFP();
       if (current_fp >= thread_local_.target_fp_) break;
       it.Advance();
     }
   }
 
   // Find the closest Javascript frame we can flood with one-shots.
   while (!it.done() &&
-         !it.frame()->function()->shared()->IsSubjectToDebugging()) {
+         (!it.frame()->function()->shared()->IsSubjectToDebugging() ||
+          it.frame()->function()->shared()->debug_is_blackboxed())) {
     it.Advance();
   }
 
   if (it.done()) return;  // No suitable Javascript catch handler.
 
   FloodWithOneShot(Handle<JSFunction>(it.frame()->function()));
 }
 
 
 void Debug::PrepareStep(StepAction step_action) {
@@ skipping 53 matching lines @@
   clear_suspended_generator();
 
   switch (step_action) {
     case StepNone:
       UNREACHABLE();
       break;
     case StepOut:
       // Advance to caller frame.
       frames_it.Advance();
       // Skip native and extension functions on the stack.
-      while (!frames_it.done() &&
-             !frames_it.frame()->function()->shared()->IsSubjectToDebugging()) {
+      while (
+          !frames_it.done() &&
+          (!frames_it.frame()->function()->shared()->IsSubjectToDebugging() ||
+           frames_it.frame()->function()->shared()->debug_is_blackboxed())) {
         // Builtin functions are not subject to stepping, but need to be
         // deoptimized to include checks for step-in at call sites.
         Deoptimizer::DeoptimizeFunction(frames_it.frame()->function());
         frames_it.Advance();
       }
       if (!frames_it.done()) {
         // Fill the caller function to return to with one-shot break points.
         Handle<JSFunction> caller_function(frames_it.frame()->function());
         FloodWithOneShot(caller_function);
         thread_local_.target_fp_ = frames_it.frame()->UnpaddedFP();
@@ skipping 691 matching lines @@
   // Bail out if exception breaks are not active
   if (uncaught) {
     // Uncaught exceptions are reported by either flags.
     if (!(break_on_uncaught_exception_ || break_on_exception_)) return;
   } else {
     // Caught exceptions are reported is activated.
     if (!break_on_exception_) return;
   }
 
   {
+    JavaScriptFrameIterator it(isolate_);
+    // Check whether the top frame is blackboxed.
+    if (!it.done() && it.frame()->function()->shared()->debug_is_blackboxed())

[Yang, 2017/01/19 13:55:35]

please add {} around if-statement body if we have a line break. We usually have
this in the v8 code base. Also below.

[kozy, 2017/01/19 16:08:38]

Done.

+      return;
     // Check whether the break location is muted.
-    JavaScriptFrameIterator it(isolate_);
     if (!it.done() && IsMutedAtCurrentLocation(it.frame())) return;

[Yang, 2017/01/19 13:55:35]

can we merge these two redundant checks?

[kozy, 2017/01/19 16:08:38]

Done.

   }
 
   DebugScope debug_scope(this);
   if (debug_scope.failed()) return;
 
   if (debug_event_listener_) {
     HandleScope scope(isolate_);
 
     // Create the execution state.
     Handle<Object> exec_state;
@@ skipping 118 matching lines @@
   // Since we holding promise when at least one microtask is scheduled (inside
   // PromiseReactionJobInfo), we can send cancel event in weak callback.
   GlobalHandles::MakeWeak(
       global_handle.location(),
       new CollectedCallbackData(global_handle.location(), async_id->value(),
                                 this, isolate_),
       &ResetPromiseHandle, v8::WeakCallbackType::kParameter);
   return async_id->value();
 }
 
+void Debug::SetIsBlackboxedCallback(debug::IsBlackboxedCallback callback,
+                                    void* data) {
+  is_blackboxed_callback_ = callback;
+  is_blackboxed_callback_data_ = data;
+}
+
+namespace {
+debug::Location GetDebugLocation(Handle<Script> script, int source_position) {
+  Script::InitLineEnds(script);
+  int line = Script::GetLineNumber(script, source_position);
+  int column = Script::GetColumnNumber(script, source_position);
+  return debug::Location(line, column);
+}
+}  // namespace
+
+void Debug::OnNewSharedFunctionInfo(Handle<SharedFunctionInfo> shared) {
+  if (!is_blackboxed_callback_) return;
+  Handle<Script> script(Script::cast(shared->script()));
+  if (script->type() != i::Script::TYPE_NORMAL) return;
+
+  debug::Location start = GetDebugLocation(script, shared->start_position());
+  debug::Location end = GetDebugLocation(script, shared->end_position());
+
+  bool is_blackboxed =
+      is_blackboxed_callback_(ToApiHandle<debug::Script>(script), start, end,
+                              is_blackboxed_callback_data_);
+  shared->set_debug_is_blackboxed(is_blackboxed);
+}
+
 void Debug::OnAsyncTaskEvent(debug::PromiseDebugActionType type, int id) {
   if (in_debug_scope() || ignore_events()) return;
 
   if (debug_event_listener_) {
     debug_event_listener_->PromiseEventOccurred(type, id);
     if (!non_inspector_listener_exists()) return;
   }
 
   HandleScope scope(isolate_);
   DebugScope debug_scope(this);
@@ skipping 362 matching lines @@
 
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) return;
 
   { JavaScriptFrameIterator it(isolate_);
     DCHECK(!it.done());
     Object* fun = it.frame()->function();
     if (fun && fun->IsJSFunction()) {
       // Don't stop in builtin functions.
       if (!JSFunction::cast(fun)->shared()->IsSubjectToDebugging()) return;
+      if (isolate_->stack_guard()->CheckDebugBreak() &&
+          JSFunction::cast(fun)->shared()->debug_is_blackboxed())
+        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;
     }
   }
 
   // Collect the break state before clearing the flags.
@@ skipping 377 matching lines @@
   logger_->DebugEvent("Put", message.text());
 }
 
 void LockingCommandMessageQueue::Clear() {
   base::LockGuard<base::Mutex> lock_guard(&mutex_);
   queue_.Clear();
 }
 
 }  // namespace internal
 }  // namespace v8