[inspector] changed a way of preserving stepping between tasks

src/inspector/v8-debugger-agent-impl.cc

 // Copyright 2015 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-agent-impl.h"
 
 #include <algorithm>
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/injected-script.h"
@@ skipping 180 matching lines @@
 V8DebuggerAgentImpl::V8DebuggerAgentImpl(
     V8InspectorSessionImpl* session, protocol::FrontendChannel* frontendChannel,
     protocol::DictionaryValue* state)
     : m_inspector(session->inspector()),
       m_debugger(m_inspector->debugger()),
       m_session(session),
       m_enabled(false),
       m_state(state),
       m_frontend(frontendChannel),
       m_isolate(m_inspector->isolate()),
-      m_scheduledDebuggerStep(NoStep),
-      m_javaScriptPauseScheduled(false),
-      m_recursionLevelForStepOut(0) {
-}
+      m_javaScriptPauseScheduled(false) {}
 
 V8DebuggerAgentImpl::~V8DebuggerAgentImpl() {}
 
 void V8DebuggerAgentImpl::enableImpl() {
   m_enabled = true;
   m_state->setBoolean(DebuggerAgentState::debuggerEnabled, true);
   m_debugger->enable();
 
   std::vector<std::unique_ptr<V8DebuggerScript>> compiledScripts;
   m_debugger->getCompiledScripts(m_session->contextGroupId(), compiledScripts);
@@ skipping 31 matching lines @@
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   m_blackboxedPositions.clear();
   m_blackboxPattern.reset();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
   m_debugger->setAsyncCallStackDepth(this, 0);
   m_continueToLocationBreakpointId = String16();
   clearBreakDetails();
-  m_scheduledDebuggerStep = NoStep;
   m_javaScriptPauseScheduled = false;
   m_skipAllPauses = false;
   m_state->setBoolean(DebuggerAgentState::skipAllPauses, false);
   m_state->remove(DebuggerAgentState::blackboxPattern);
   m_enabled = false;
   m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
   return Response::OK();
 }
 
 void V8DebuggerAgentImpl::restore() {
@@ skipping 414 matching lines @@
 }
 
 void V8DebuggerAgentImpl::clearBreakDetails() {
   std::vector<BreakReason> emptyBreakReason;
   m_breakReason.swap(emptyBreakReason);
 }
 
 void V8DebuggerAgentImpl::schedulePauseOnNextStatement(
     const String16& breakReason,
     std::unique_ptr<protocol::DictionaryValue> data) {
-  if (!enabled() || m_scheduledDebuggerStep == StepInto ||
-      m_javaScriptPauseScheduled || isPaused() ||
+  if (!enabled() || m_javaScriptPauseScheduled || isPaused() ||
       !m_debugger->breakpointsActivated())
     return;
-  if (m_breakReason.empty()) m_debugger->setPauseOnNextStatement(true);
+  if (m_breakReason.empty()) {
+    m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
+  }
   pushBreakDetails(breakReason, std::move(data));
 }
 
-void V8DebuggerAgentImpl::schedulePauseOnNextStatementIfSteppingInto() {
-  DCHECK(enabled());
-  if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled ||
-      isPaused())
-    return;
-  m_debugger->setPauseOnNextStatement(true);
-}
-
 void V8DebuggerAgentImpl::cancelPauseOnNextStatement() {
   if (m_javaScriptPauseScheduled || isPaused()) return;
   popBreakDetails();
-  if (m_breakReason.empty()) m_debugger->setPauseOnNextStatement(false);
+  if (m_breakReason.empty())
+    m_debugger->setPauseOnNextStatement(false, m_session->contextGroupId());
 }
 
 Response V8DebuggerAgentImpl::pause() {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
   if (m_javaScriptPauseScheduled || isPaused()) return Response::OK();
   clearBreakDetails();
   m_javaScriptPauseScheduled = true;
-  m_scheduledDebuggerStep = NoStep;
-  m_debugger->setPauseOnNextStatement(true);
+  m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::resume() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
-  m_scheduledDebuggerStep = NoStep;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
   m_debugger->continueProgram();
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::stepOver() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
   // StepOver at function return point should fallback to StepInto.
   JavaScriptCallFrame* frame =
       !m_pausedCallFrames.empty() ? m_pausedCallFrames[0].get() : nullptr;
   if (frame && frame->isAtReturn()) return stepInto();
-  m_scheduledDebuggerStep = StepOver;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
-  m_debugger->stepOverStatement();
+  m_debugger->stepOverStatement(m_session->contextGroupId());
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::stepInto() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
-  m_scheduledDebuggerStep = StepInto;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
-  m_debugger->stepIntoStatement();
+  m_debugger->stepIntoStatement(m_session->contextGroupId());
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::stepOut() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
-  m_scheduledDebuggerStep = StepOut;
-  m_recursionLevelForStepOut = 1;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
-  m_debugger->stepOutOfFunction();
+  m_debugger->stepOutOfFunction(m_session->contextGroupId());
   return Response::OK();
 }
 
 void V8DebuggerAgentImpl::scheduleStepIntoAsync(
     std::unique_ptr<ScheduleStepIntoAsyncCallback> callback) {
   if (!isPaused()) {
     callback->sendFailure(Response::Error(kDebuggerNotPaused));
     return;
   }
   if (m_stepIntoAsyncCallback) {
     m_stepIntoAsyncCallback->sendFailure(Response::Error(
         "Current scheduled step into async was overriden with new one."));
   }
   m_stepIntoAsyncCallback = std::move(callback);
 }
 
 bool V8DebuggerAgentImpl::shouldBreakInScheduledAsyncTask() {
   if (!m_stepIntoAsyncCallback) return false;
   m_stepIntoAsyncCallback->sendSuccess();
   m_stepIntoAsyncCallback.reset();
-  m_scheduledDebuggerStep = NoStep;
-  v8::debug::ClearStepping(m_isolate);
   return true;
 }
 
 Response V8DebuggerAgentImpl::setPauseOnExceptions(
     const String16& stringPauseState) {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
   v8::debug::ExceptionBreakState pauseState;
   if (stringPauseState == "none") {
     pauseState = v8::debug::NoBreakOnException;
   } else if (stringPauseState == "all") {
@@ skipping 151 matching lines @@
       continue;
     return Response::Error(
         "Input positions array is not sorted or contains duplicate values.");
   }
 
   m_blackboxedPositions[scriptId] = positions;
   it->second->resetBlackboxedStateCache();
   return Response::OK();
 }
 
-void V8DebuggerAgentImpl::willExecuteScript(int scriptId) {
-  changeJavaScriptRecursionLevel(+1);
-  if (m_scheduledDebuggerStep != StepInto) return;
-  schedulePauseOnNextStatementIfSteppingInto();
-}
-
-void V8DebuggerAgentImpl::didExecuteScript() {
-  changeJavaScriptRecursionLevel(-1);
-}
-
-void V8DebuggerAgentImpl::changeJavaScriptRecursionLevel(int step) {
-  if (m_javaScriptPauseScheduled && !m_skipAllPauses && !isPaused()) {
-    // Do not ever loose user's pause request until we have actually paused.
-    m_debugger->setPauseOnNextStatement(true);
-  }
-  if (m_scheduledDebuggerStep == StepOut) {
-    m_recursionLevelForStepOut += step;
-    if (!m_recursionLevelForStepOut) {
-      // When StepOut crosses a task boundary (i.e. js -> c++) from where it was
-      // requested,
-      // switch stepping to step into a next JS task, as if we exited to a
-      // blackboxed framework.
-      m_scheduledDebuggerStep = StepInto;
-    }
-  }
-}
-
 Response V8DebuggerAgentImpl::currentCallFrames(
     std::unique_ptr<Array<CallFrame>>* result) {
   if (!isPaused()) {
     *result = Array<CallFrame>::create();
     return Response::OK();
   }
   v8::HandleScope handles(m_isolate);
   v8::Local<v8::Context> debuggerContext =
       v8::debug::GetDebugContext(m_isolate);
   v8::Context::Scope contextScope(debuggerContext);
@@ skipping 288 matching lines @@
         Response::Error("No async tasks were scheduled before pause."));
     m_stepIntoAsyncCallback.reset();
   }
 
   std::unique_ptr<Array<CallFrame>> protocolCallFrames;
   Response response = currentCallFrames(&protocolCallFrames);
   if (!response.isSuccess()) protocolCallFrames = Array<CallFrame>::create();
   m_frontend.paused(std::move(protocolCallFrames), breakReason,
                     std::move(breakAuxData), std::move(hitBreakpointIds),
                     currentAsyncStackTrace());
-  m_scheduledDebuggerStep = NoStep;
   m_javaScriptPauseScheduled = false;
 
   if (!m_continueToLocationBreakpointId.isEmpty()) {
     m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
     m_continueToLocationBreakpointId = "";
   }
 }
 
 void V8DebuggerAgentImpl::didContinue() {
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   clearBreakDetails();
   m_frontend.resumed();
 }
 
 void V8DebuggerAgentImpl::breakProgram(
     const String16& breakReason,
     std::unique_ptr<protocol::DictionaryValue> data) {
   if (!enabled() || !m_debugger->canBreakProgram() || m_skipAllPauses) return;
   std::vector<BreakReason> currentScheduledReason;
   currentScheduledReason.swap(m_breakReason);
   pushBreakDetails(breakReason, std::move(data));
-  m_scheduledDebuggerStep = NoStep;
   m_debugger->breakProgram();
   popBreakDetails();
   m_breakReason.swap(currentScheduledReason);
   if (!m_breakReason.empty()) {
-    m_debugger->setPauseOnNextStatement(true);
+    m_debugger->setPauseOnNextStatement(true, m_session->contextGroupId());
   }
 }
 
 void V8DebuggerAgentImpl::breakProgramOnException(
     const String16& breakReason,
     std::unique_ptr<protocol::DictionaryValue> data) {
   if (!enabled() ||
       m_debugger->getPauseOnExceptionsState() == v8::debug::NoBreakOnException)
     return;
   breakProgram(breakReason, std::move(data));
@@ skipping 11 matching lines @@
 void V8DebuggerAgentImpl::removeBreakpointAt(const String16& scriptId,
                                              int lineNumber, int columnNumber,
                                              BreakpointSource source) {
   removeBreakpointImpl(generateBreakpointId(
       ScriptBreakpoint(scriptId, lineNumber, columnNumber, String16()),
       source));
 }
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
-  m_scheduledDebuggerStep = NoStep;
   m_blackboxedPositions.clear();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector