[inspector] implemented blackboxing inside v8

src/inspector/v8-debugger.cc

 // Copyright 2016 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/inspector/v8-debugger.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/inspected-context.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
@@ skipping 53 matching lines @@
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(m_isolate);
   v8::debug::SetDebugEventListener(m_isolate, this);
   v8::debug::SetOutOfMemoryCallback(m_isolate, &V8Debugger::v8OOMCallback,
                                     this);
+  v8::debug::SetIsBlackboxedCallback(m_isolate,
+                                     &V8Debugger::v8IsBlackboxedCallback, this);
   m_debuggerContext.Reset(m_isolate, v8::debug::GetDebugContext(m_isolate));
   v8::debug::ChangeBreakOnException(m_isolate, v8::debug::NoBreakOnException);
   m_pauseOnExceptionsState = v8::debug::NoBreakOnException;
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
   m_wasmTranslation.Clear();
   v8::debug::SetDebugEventListener(m_isolate, nullptr);
+  v8::debug::SetIsBlackboxedCallback(m_isolate, nullptr, nullptr);
   v8::debug::SetOutOfMemoryCallback(m_isolate, nullptr, nullptr);
   m_isolate->RestoreOriginalHeapLimit();
 }
 
 bool V8Debugger::enabled() const { return !m_debuggerScript.IsEmpty(); }
 
 void V8Debugger::getCompiledScripts(
     int contextGroupId,
     std::vector<std::unique_ptr<V8DebuggerScript>>& result) {
   v8::HandleScope scope(m_isolate);
@@ skipping 137 matching lines @@
 void V8Debugger::setPauseOnNextStatement(bool pause) {
   if (m_runningNestedMessageLoop) return;
   if (pause)
     v8::debug::DebugBreak(m_isolate);
   else
     v8::debug::CancelDebugBreak(m_isolate);
 }
 
 bool V8Debugger::canBreakProgram() {
   if (!m_breakpointsActivated) return false;
-  return m_isolate->InContext();
+  return v8::debug::HasUserFrameOnStack(m_isolate);
+}
+
+bool V8Debugger::hasUserFrameOnStack() {
+  return v8::debug::HasUserFrameOnStack(m_isolate);
 }
 
 void V8Debugger::breakProgram() {
   if (isPaused()) {
     DCHECK(!m_runningNestedMessageLoop);
     v8::Local<v8::Value> exception;
     v8::Local<v8::Array> hitBreakpoints;
     handleProgramBreak(m_pausedContext, m_executionState, exception,
                        hitBreakpoints);
     return;
@@ skipping 32 matching lines @@
   continueProgram();
 }
 
 void V8Debugger::stepOutOfFunction() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
   continueProgram();
 }
 
-void V8Debugger::clearStepping() {
-  DCHECK(enabled());
-  v8::debug::ClearStepping(m_isolate);
-}
-
 Response V8Debugger::setScriptSource(
     const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
     JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged,
     bool* compileError) {
   class EnableLiveEditScope {
    public:
     explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
       v8::debug::SetLiveEditEnabled(m_isolate, true);
       inLiveEditScope = true;
@@ skipping 159 matching lines @@
       v8::Local<v8::Value> hitBreakpointNumber =
           hitBreakpointNumbers->Get(debuggerContext(), i).ToLocalChecked();
       DCHECK(hitBreakpointNumber->IsInt32());
       breakpointIds.push_back(String16::fromInteger(
           hitBreakpointNumber->Int32Value(debuggerContext()).FromJust()));
     }
   }
 
   m_pausedContext = pausedContext;
   m_executionState = executionState;
-  V8DebuggerAgentImpl::SkipPauseRequest result =
+  bool result =

[dgozman, 2017/01/19 21:49:14]

result -> shouldPause

[kozy, 2017/01/20 02:32:37]

Done.

       agent->didPause(pausedContext, exception, breakpointIds,
                       isPromiseRejection, isUncaught, m_scheduledOOMBreak);
-  if (result == V8DebuggerAgentImpl::RequestNoSkip) {
+  if (result) {
     m_runningNestedMessageLoop = true;
     int groupId = m_inspector->contextGroupId(pausedContext);
     DCHECK(groupId);
     v8::Context::Scope scope(pausedContext);
     v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
     CHECK(!context.IsEmpty() &&
           context != v8::debug::GetDebugContext(m_isolate));
     m_inspector->client()->runMessageLoopOnPause(groupId);
     // The agent may have been removed in the nested loop.
     agent = m_inspector->enabledDebuggerAgentForGroup(
         m_inspector->contextGroupId(pausedContext));
     if (agent) agent->didContinue();
     m_runningNestedMessageLoop = false;
   }
   if (m_scheduledOOMBreak) m_isolate->RestoreOriginalHeapLimit();
   m_scheduledOOMBreak = false;
   m_pausedContext.Clear();
   m_executionState.Clear();
-
-  if (result == V8DebuggerAgentImpl::RequestStepFrame) {
-    v8::debug::PrepareStep(m_isolate, v8::debug::StepFrame);
-  } else if (result == V8DebuggerAgentImpl::RequestStepInto) {
-    v8::debug::PrepareStep(m_isolate, v8::debug::StepIn);
-  } else if (result == V8DebuggerAgentImpl::RequestStepOut) {
-    v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
-  }
 }
 
 void V8Debugger::v8OOMCallback(void* data) {
   V8Debugger* thisPtr = static_cast<V8Debugger*>(data);
   thisPtr->m_isolate->IncreaseHeapLimitForDebugging();
   thisPtr->m_scheduledOOMBreak = true;
   thisPtr->setPauseOnNextStatement(true);
 }
 
 void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
@@ skipping 64 matching lines @@
       break;
     case v8::debug::kDebugWillHandle:
       asyncTaskStarted(ptr);
       break;
     case v8::debug::kDebugDidHandle:
       asyncTaskFinished(ptr);
       break;
   }
 }
 
+bool V8Debugger::v8IsBlackboxedCallback(v8::Local<v8::debug::Script> script,
+                                        const v8::debug::Location& start,
+                                        const v8::debug::Location& end,
+                                        void* data) {
+  V8Debugger* debugger = static_cast<V8Debugger*>(data);
+  v8::Local<v8::Value> contextData;
+  if (!script->ContextData().ToLocal(&contextData) || !contextData->IsInt32())
+    return false;
+  int contextId = static_cast<int>(contextData.As<v8::Int32>()->Value());
+  V8DebuggerAgentImpl* agent =
+      debugger->m_inspector->enabledDebuggerAgentForGroup(contextId);

[dgozman, 2017/01/19 21:49:15]

again?

[kozy, 2017/01/20 02:32:37]

extracted to not repeat again.

+  if (!agent) return false;
+  return agent->isBlackboxed(String16::fromInteger(script->Id()), start, end);

[dgozman, 2017/01/19 21:49:15]

Converting to string here is unfortunate.

[kozy, 2017/01/20 02:32:37]

Acknowledged.

+}
+
 V8StackTraceImpl* V8Debugger::currentAsyncCallChain() {
   if (!m_currentStacks.size()) return nullptr;
   return m_currentStacks.back().get();
 }
 
 void V8Debugger::compileDebuggerScript() {
   if (!m_debuggerScript.IsEmpty()) {
     UNREACHABLE();
     return;
   }
@@ skipping 355 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector