[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 50 matching lines @@
       m_maxAsyncCallStackDepth(0),
       m_pauseOnExceptionsState(v8::debug::NoBreakOnException),
       m_wasmTranslation(isolate) {}
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(m_isolate);
-  v8::debug::SetDebugEventListener(m_isolate, this);
+  v8::debug::SetDebugDelegate(m_isolate, this);
   v8::debug::SetOutOfMemoryCallback(m_isolate, &V8Debugger::v8OOMCallback,
                                     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::SetDebugDelegate(m_isolate, 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::HasNonBlackboxedFrameOnStack(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 shouldPause =
       agent->didPause(pausedContext, exception, breakpointIds,
                       isPromiseRejection, isUncaught, m_scheduledOOMBreak);
-  if (result == V8DebuggerAgentImpl::RequestNoSkip) {
+  if (shouldPause) {
     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);
 }
 
+namespace {

[dgozman, 2017/01/24 00:12:08]

nit: put all helpers in the namespace at the top.

[kozy, 2017/01/24 01:11:52]

Done.

+V8DebuggerAgentImpl* agentForScript(V8InspectorImpl* inspector,
+                                    v8::Local<v8::debug::Script> script) {
+  v8::Local<v8::Value> contextData;
+  if (!script->ContextData().ToLocal(&contextData) || !contextData->IsInt32()) {
+    return nullptr;
+  }
+  int contextId = static_cast<int>(contextData.As<v8::Int32>()->Value());
+  int contextGroupId = inspector->contextGroupId(contextId);
+  if (!contextGroupId) return nullptr;
+  return inspector->enabledDebuggerAgentForGroup(contextGroupId);
+}
+}  // namespace
+
 void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
                                 bool has_compile_error) {
-  v8::Local<v8::Value> contextData;
-  if (!script->ContextData().ToLocal(&contextData) || !contextData->IsInt32()) {
-    return;
-  }
-  int contextId = static_cast<int>(contextData.As<v8::Int32>()->Value());
-  int contextGroupId = m_inspector->contextGroupId(contextId);
-  if (!contextGroupId) return;
-  V8DebuggerAgentImpl* agent =
-      m_inspector->enabledDebuggerAgentForGroup(contextGroupId);
+  V8DebuggerAgentImpl* agent = agentForScript(m_inspector, script);
   if (!agent) return;
   if (script->IsWasm()) {
     m_wasmTranslation.AddScript(script.As<v8::debug::WasmScript>(), agent);
   } else if (m_ignoreScriptParsedEventsCounter == 0) {
     agent->didParseSource(
         V8DebuggerScript::Create(m_isolate, script, inLiveEditScope),
         !has_compile_error);
   }
 }
 
@@ skipping 12 matching lines @@
 }
 
 void V8Debugger::ExceptionThrown(v8::Local<v8::Context> pausedContext,
                                  v8::Local<v8::Object> execState,
                                  v8::Local<v8::Value> exception,
                                  bool isPromiseRejection, bool isUncaught) {
   handleProgramBreak(pausedContext, execState, exception,
                      v8::Local<v8::Array>(), isPromiseRejection, isUncaught);
 }
 
+bool V8Debugger::IsBlackboxed(v8::Local<v8::debug::Script> script,
+                              const v8::debug::Location& start,
+                              const v8::debug::Location& end) {
+  V8DebuggerAgentImpl* agent = agentForScript(m_inspector, script);
+  if (!agent) return false;
+  return agent->isBlackboxed(String16::fromInteger(script->Id()), start, end);
+}
+
 void V8Debugger::PromiseEventOccurred(v8::debug::PromiseDebugActionType type,
                                       int id) {
   if (!m_maxAsyncCallStackDepth) return;
   // Async task events from Promises are given misaligned pointers to prevent
   // from overlapping with other Blink task identifiers. There is a single
   // namespace of such ids, managed by src/js/promise.js.
   void* ptr = reinterpret_cast<void*>(id * 2 + 1);
   switch (type) {
     case v8::debug::kDebugEnqueueAsyncFunction:
       asyncTaskScheduled("async function", ptr, true);
@@ skipping 387 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