[inspector] introduced stepIntoAsync for chained callbacks

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 596 matching lines @@
     const String16& breakReason,
     std::unique_ptr<protocol::DictionaryValue> data) {
   if (!enabled() || m_scheduledDebuggerStep == StepInto ||
       m_javaScriptPauseScheduled || isPaused() ||
       !m_debugger->breakpointsActivated())
     return;
   if (m_breakReason.empty()) m_debugger->setPauseOnNextStatement(true);
   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);
 }
 
 Response V8DebuggerAgentImpl::pause() {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
   if (m_javaScriptPauseScheduled || isPaused()) return Response::OK();
   clearBreakDetails();
@@ skipping 24 matching lines @@
 }
 
 Response V8DebuggerAgentImpl::stepInto() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
   m_scheduledDebuggerStep = StepInto;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
   m_debugger->stepIntoStatement();
   return Response::OK();
 }
 
+Response V8DebuggerAgentImpl::stepIntoAsync() {
+  if (!isPaused()) return Response::Error(kDebuggerNotPaused);
+  m_scheduledDebuggerStep = NoStep;
+  m_session->releaseObjectGroup(kBacktraceObjectGroup);
+  return m_debugger->stepIntoScheduledCallback();
+}
+
 Response V8DebuggerAgentImpl::stepOut() {
   if (!isPaused()) return Response::Error(kDebuggerNotPaused);
   m_scheduledDebuggerStep = StepOut;
   m_recursionLevelForStepOut = 1;
   m_session->releaseObjectGroup(kBacktraceObjectGroup);
   m_debugger->stepOutOfFunction();
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::setPauseOnExceptions(
@@ skipping 159 matching lines @@
         "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();
+  if (m_scheduledDebuggerStep != StepInto || m_javaScriptPauseScheduled ||
+      isPaused()) {
+    return;
+  }
+  m_debugger->setPauseOnNextStatement(true);
 }
 
 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);
@@ skipping 291 matching lines @@
           protocol::DictionaryValue::create();
       reason->setString("reason", hitReasons[i].first);
       if (hitReasons[i].second)
         reason->setObject("auxData", std::move(hitReasons[i].second));
       reasons->pushValue(std::move(reason));
     }
     breakAuxData = protocol::DictionaryValue::create();
     breakAuxData->setArray("reasons", std::move(reasons));
   }
 
+  if (m_debugger->stepIntoScheduledCallbackAvailable()) {
+    if (!breakAuxData) breakAuxData = protocol::DictionaryValue::create();
+    breakAuxData->setBoolean("stepIntoAsyncAvailable", true);
+  }
+
   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()) {
@@ skipping 15 matching lines @@
   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);
 }
 
+void V8DebuggerAgentImpl::breakProgramIfSteppingInto(
+    const String16& breakReason,
+    std::unique_ptr<protocol::DictionaryValue> data) {
+  if (m_scheduledDebuggerStep != StepInto) return;
+  breakProgram(breakReason, std::move(data));
+}
+
 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));
 }
 
 void V8DebuggerAgentImpl::setBreakpointAt(const String16& scriptId,
@@ skipping 16 matching lines @@
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_scheduledDebuggerStep = NoStep;
   m_blackboxedPositions.clear();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector