[inspector] introduced stepIntoAsync for chained callbacks

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 176 matching lines @@
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
+  m_tasksWithScheduledBreak.clear();
   m_wasmTranslation.Clear();
   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,
@@ skipping 142 matching lines @@
   v8::Local<v8::Function> breakFunction;
   if (!v8::Function::New(m_isolate->GetCurrentContext(),
                          &V8Debugger::breakProgramCallback,
                          v8::External::New(m_isolate, this), 0,
                          v8::ConstructorBehavior::kThrow)
            .ToLocal(&breakFunction))
     return;
   v8::debug::Call(debuggerContext(), breakFunction).ToLocalChecked();
 }
 
-void V8Debugger::continueProgram() {
-  if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
+void V8Debugger::continueProgramImpl() {
+  if (!isPaused()) return;
+  m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
+void V8Debugger::continueProgram() {
+  if (!isPaused()) return;
+  v8::debug::ClearStepping(m_isolate);
+  continueProgramImpl();
+}
+
 void V8Debugger::stepIntoStatement() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   v8::debug::PrepareStep(m_isolate, v8::debug::StepIn);
-  continueProgram();
+  continueProgramImpl();
 }
 
 void V8Debugger::stepOverStatement() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   v8::debug::PrepareStep(m_isolate, v8::debug::StepNext);
-  continueProgram();
+  continueProgramImpl();
 }
 
 void V8Debugger::stepOutOfFunction() {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
-  continueProgram();
+  continueProgramImpl();
+}
+
+Response V8Debugger::stepIntoScheduledCallback() {
+  DCHECK(isPaused());
+  DCHECK(!m_executionState.IsEmpty());
+
+  if (!stepIntoScheduledCallbackAvailable()) {
+    return Response::Error("No scheduled callback for stepInto available.");
+  }
+  m_tasksWithScheduledBreak.insert(m_createdPromiseTask);
+  v8::debug::ClearStepping(m_isolate);
+  continueProgramImpl();
+  return Response::OK();
+}
+
+bool V8Debugger::stepIntoScheduledCallbackAvailable() {
+  return m_createdPromiseTask;
 }
 
 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) {
@@ skipping 224 matching lines @@
 
 bool V8Debugger::IsFunctionBlackboxed(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->isFunctionBlackboxed(String16::fromInteger(script->Id()), start,
                                      end);
 }
 
-void V8Debugger::PromiseEventOccurred(v8::debug::PromiseDebugActionType type,
-                                      int id, int parentId) {
-  if (!m_maxAsyncCallStackDepth) return;
+void V8Debugger::PromiseEventOccurred(v8::Local<v8::Context> context,
+                                      v8::debug::PromiseDebugActionType type,
+                                      int id, int parentId, bool breakable) {
   // 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);
+  void* parentPtr =
+      parentId ? reinterpret_cast<void*>(parentId * 2 + 1) : nullptr;
+  if ((breakable && type == v8::debug::kDebugPromiseCreated) ||
+      type == v8::debug::kDebugWillHandle ||
+      type == v8::debug::kDebugDidHandle ||
+      type == v8::debug::kDebugPromiseCollected) {
+    steppingOnPromiseEvent(context, type, ptr, parentPtr);
+  }
+  if (!m_maxAsyncCallStackDepth) return;
   switch (type) {
     case v8::debug::kDebugPromiseCreated:
-      asyncTaskCreated(
-          ptr, parentId ? reinterpret_cast<void*>(parentId * 2 + 1) : nullptr);
+      asyncTaskCreated(ptr, parentPtr);
       break;
     case v8::debug::kDebugEnqueueAsyncFunction:
       asyncTaskScheduled("async function", ptr, true);
       break;
     case v8::debug::kDebugEnqueuePromiseResolve:
       asyncTaskScheduled("Promise.resolve", ptr, true);
       break;
     case v8::debug::kDebugEnqueuePromiseReject:
       asyncTaskScheduled("Promise.reject", ptr, true);
       break;
     case v8::debug::kDebugPromiseCollected:
       asyncTaskCanceled(ptr);
       break;
     case v8::debug::kDebugWillHandle:
       asyncTaskStarted(ptr);
       break;
     case v8::debug::kDebugDidHandle:
       asyncTaskFinished(ptr);
       break;
   }
 }
 
+void V8Debugger::steppingOnPromiseEvent(v8::Local<v8::Context> context,
+                                        v8::debug::PromiseDebugActionType type,
+                                        void* task, void* parentPtr) {
+  if (type == v8::debug::kDebugPromiseCollected) {
+    m_tasksWithScheduledBreak.erase(task);
+    return;
+  }
+  DCHECK(!context.IsEmpty());
+  v8::Context::Scope contextScope(context);
+  V8DebuggerAgentImpl* agent =
+      m_inspector->enabledDebuggerAgentForGroup(currentContextGroupId());
+  if (!agent) return;
+  if (type == v8::debug::kDebugPromiseCreated) {
+    if (!parentPtr) return;
+    m_createdPromiseTask = task;
+    agent->breakProgramIfSteppingInto(
+        protocol::Debugger::Paused::ReasonEnum::Other, nullptr);
+    m_createdPromiseTask = nullptr;
+    return;
+  }
+  if (m_tasksWithScheduledBreak.find(task) == m_tasksWithScheduledBreak.end()) {
+    return;
+  }
+  if (type == v8::debug::kDebugWillHandle) {
+    agent->schedulePauseOnNextStatement(
+        protocol::Debugger::Paused::ReasonEnum::Other, nullptr);
+  } else {
+    agent->cancelPauseOnNextStatement();
+  }
+}
+
 V8StackTraceImpl* V8Debugger::currentAsyncCallChain() {
   if (!m_currentStacks.size()) return nullptr;
   return m_currentStacks.back().get();
 }
 
 void V8Debugger::compileDebuggerScript() {
   if (!m_debuggerScript.IsEmpty()) {
     UNREACHABLE();
     return;
   }
@@ skipping 124 matching lines @@
       createDataProperty(context, properties, properties->Length(),
                          toV8StringInternalized(m_isolate, "[[Scopes]]"));
       createDataProperty(context, properties, properties->Length(), scopes);
     }
   }
   return properties;
 }
 
 std::unique_ptr<V8StackTraceImpl> V8Debugger::createStackTrace(
     v8::Local<v8::StackTrace> stackTrace) {
-  int contextGroupId =
-      m_isolate->InContext()
-          ? m_inspector->contextGroupId(m_isolate->GetCurrentContext())
-          : 0;
-  return V8StackTraceImpl::create(this, contextGroupId, stackTrace,
+  return V8StackTraceImpl::create(this, currentContextGroupId(), stackTrace,
                                   V8StackTraceImpl::maxCallStackSizeToCapture);
 }
 
 void V8Debugger::setAsyncCallStackDepth(V8DebuggerAgentImpl* agent, int depth) {
   if (depth <= 0)
     m_maxAsyncCallStackDepthMap.erase(agent);
   else
     m_maxAsyncCallStackDepthMap[agent] = depth;
 
   int maxAsyncCallStackDepth = 0;
@@ skipping 16 matching lines @@
   if (static_cast<int>(m_idToTask.size()) > m_maxAsyncCallStacks) {
     void* taskToRemove = m_idToTask.begin()->second;
     asyncTaskCanceled(taskToRemove);
   }
 }
 
 void V8Debugger::asyncTaskCreated(void* task, void* parentTask) {
   if (!m_maxAsyncCallStackDepth) return;
   if (parentTask) m_parentTask[task] = parentTask;
   v8::HandleScope scope(m_isolate);
-  // We don't need to pass context group id here because we gets this callback
+  // We don't need to pass context group id here because we get this callback
   // from V8 for promise events only.
   // Passing one as maxStackSize forces no async chain for the new stack and
   // allows us to not grow exponentially.
   std::unique_ptr<V8StackTraceImpl> creationStack =
       V8StackTraceImpl::capture(this, 0, 1, String16());
   if (creationStack && !creationStack->isEmpty()) {
     m_asyncTaskCreationStacks[task] = std::move(creationStack);
     registerAsyncTaskIfNeeded(task);
   }
 }
 
 void V8Debugger::asyncTaskScheduled(const StringView& taskName, void* task,
                                     bool recurring) {
   if (!m_maxAsyncCallStackDepth) return;
   asyncTaskScheduled(toString16(taskName), task, recurring);
 }
 
 void V8Debugger::asyncTaskScheduled(const String16& taskName, void* task,
                                     bool recurring) {
   if (!m_maxAsyncCallStackDepth) return;
   v8::HandleScope scope(m_isolate);
-  int contextGroupId =
-      m_isolate->InContext()
-          ? m_inspector->contextGroupId(m_isolate->GetCurrentContext())
-          : 0;
   std::unique_ptr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(
-      this, contextGroupId, V8StackTraceImpl::maxCallStackSizeToCapture,
-      taskName);
+      this, currentContextGroupId(),
+      V8StackTraceImpl::maxCallStackSizeToCapture, taskName);
   if (chain) {
     m_asyncTaskStacks[task] = std::move(chain);
     if (recurring) m_recurringTasks.insert(task);
     registerAsyncTaskIfNeeded(task);
   }
 }
 
 void V8Debugger::asyncTaskCanceled(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   m_asyncTaskStacks.erase(task);
@@ skipping 62 matching lines @@
 void V8Debugger::unmuteScriptParsedEvents() {
   --m_ignoreScriptParsedEventsCounter;
   DCHECK_GE(m_ignoreScriptParsedEventsCounter, 0);
 }
 
 std::unique_ptr<V8StackTraceImpl> V8Debugger::captureStackTrace(
     bool fullStack) {
   if (!m_isolate->InContext()) return nullptr;
 
   v8::HandleScope handles(m_isolate);
-  int contextGroupId =
-      m_inspector->contextGroupId(m_isolate->GetCurrentContext());
+  int contextGroupId = currentContextGroupId();
   if (!contextGroupId) return nullptr;
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
+int V8Debugger::currentContextGroupId() {
+  if (!m_isolate->InContext()) return 0;
+  return m_inspector->contextGroupId(m_isolate->GetCurrentContext());
+}
+
 }  // namespace v8_inspector