[inspector] support setTimeout in Debugger.scheduleStepIntoAsync method

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 317 matching lines @@
   m_pauseOnExceptionsState = pauseOnExceptionsState;
 }
 
 void V8Debugger::setPauseOnNextStatement(bool pause, int targetContextGroupId) {
   if (isPaused()) return;
   DCHECK(targetContextGroupId);
   if (!pause && m_targetContextGroupId &&
       m_targetContextGroupId != targetContextGroupId) {
     return;
   }
+  DCHECK(m_targetContextGroupId == targetContextGroupId ||
+         !m_targetContextGroupId);
   m_targetContextGroupId = targetContextGroupId;
+  m_breakRequested = pause;
   if (pause)
     v8::debug::DebugBreak(m_isolate);
   else
     v8::debug::CancelDebugBreak(m_isolate);
 }
 
 bool V8Debugger::canBreakProgram() {
   if (!m_breakpointsActivated) return false;
   return !v8::debug::AllFramesOnStackAreBlackboxed(m_isolate);
 }
 
 void V8Debugger::breakProgram() {
   // Don't allow nested breaks.
   if (isPaused()) return;
   if (!canBreakProgram()) return;
   v8::debug::BreakRightNow(m_isolate);
 }
 
 void V8Debugger::continueProgram() {
   if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
 void V8Debugger::stepIntoStatement(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   DCHECK(targetContextGroupId);
+  DCHECK(m_targetContextGroupId == targetContextGroupId ||
+         !m_targetContextGroupId);

[dgozman, 2017/03/28 23:20:50]

Merge with previous DCHECK and simplify it :-)

[kozy, 2017/03/28 23:49:49]

this dcheck is redundant so removed.

   m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepIn);
   continueProgram();
 }
 
 void V8Debugger::stepOverStatement(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   DCHECK(targetContextGroupId);
+  DCHECK(m_targetContextGroupId == targetContextGroupId ||

[dgozman, 2017/03/28 23:20:50]

everywhere

[kozy, 2017/03/28 23:49:49]

Done.

+         !m_targetContextGroupId);
   m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepNext);
   continueProgram();
 }
 
 void V8Debugger::stepOutOfFunction(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
   DCHECK(targetContextGroupId);
+  DCHECK(m_targetContextGroupId == targetContextGroupId ||
+         !m_targetContextGroupId);
   m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
   continueProgram();
 }
 
+void V8Debugger::scheduleStepIntoAsync(
+    std::unique_ptr<ScheduleStepIntoAsyncCallback> callback,
+    int targetContextGroupId) {
+  DCHECK(isPaused());
+  DCHECK(!m_executionState.IsEmpty());
+  DCHECK(targetContextGroupId);
+  if (m_stepIntoAsyncCallback) {
+    m_stepIntoAsyncCallback->sendFailure(Response::Error(
+        "Current scheduled step into async was overriden with new one."));
+  }
+  m_targetContextGroupId = targetContextGroupId;
+  m_stepIntoAsyncCallback = std::move(callback);
+}
+
 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 115 matching lines @@
                                     bool isPromiseRejection, bool isUncaught) {
   // Don't allow nested breaks.
   if (isPaused()) return;
 
   int contextGroupId = m_inspector->contextGroupId(pausedContext);
   if (m_targetContextGroupId && contextGroupId != m_targetContextGroupId) {
     v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
     return;
   }
   m_targetContextGroupId = 0;
+  if (m_stepIntoAsyncCallback) {
+    m_stepIntoAsyncCallback->sendFailure(
+        Response::Error("No async tasks were scheduled before pause."));
+    m_stepIntoAsyncCallback.reset();
+  }
   V8DebuggerAgentImpl* agent = m_inspector->enabledDebuggerAgentForGroup(
       m_inspector->contextGroupId(pausedContext));
   if (!agent || (agent->skipAllPauses() && !m_scheduledOOMBreak)) return;
 
   std::vector<String16> breakpointIds;
   if (!hitBreakpointNumbers.IsEmpty()) {
     breakpointIds.reserve(hitBreakpointNumbers->Length());
     for (uint32_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
       v8::Local<v8::Value> hitBreakpointNumber =
           hitBreakpointNumbers->Get(debuggerContext(), i).ToLocalChecked();
@@ skipping 91 matching lines @@
   // 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;
   handleAsyncTaskStepping(context, type, ptr, parentPtr, createdByUser);
   if (!m_maxAsyncCallStackDepth) return;
   switch (type) {
     case v8::debug::kDebugPromiseCreated:
-      asyncTaskCreated(ptr, parentPtr);
+      asyncTaskCreatedForStack(ptr, parentPtr);
       break;
     case v8::debug::kDebugEnqueueAsyncFunction:
-      asyncTaskScheduled("async function", ptr, true);
+      asyncTaskScheduledForStack("async function", ptr, true);
       break;
     case v8::debug::kDebugEnqueuePromiseResolve:
-      asyncTaskScheduled("Promise.resolve", ptr, true);
+      asyncTaskScheduledForStack("Promise.resolve", ptr, true);
       break;
     case v8::debug::kDebugEnqueuePromiseReject:
-      asyncTaskScheduled("Promise.reject", ptr, true);
+      asyncTaskScheduledForStack("Promise.reject", ptr, true);
       break;
     case v8::debug::kDebugPromiseCollected:
-      asyncTaskCanceled(ptr);
+      asyncTaskCanceledForStack(ptr);
       break;
     case v8::debug::kDebugWillHandle:
-      asyncTaskStarted(ptr);
+      asyncTaskStartedForStack(ptr);
       break;
     case v8::debug::kDebugDidHandle:
-      asyncTaskFinished(ptr);
+      asyncTaskFinishedForStack(ptr);
       break;
   }
 }
 
 void V8Debugger::handleAsyncTaskStepping(v8::Local<v8::Context> context,

[dgozman, 2017/03/28 23:20:50]

handlePromiseAsyncStepping

[kozy, 2017/03/28 23:49:50]

removed this method.

                                          v8::debug::PromiseDebugActionType type,
                                          void* task, void* parentTask,
                                          bool createdByUser) {
   if (type == v8::debug::kDebugEnqueueAsyncFunction ||
       type == v8::debug::kDebugEnqueuePromiseResolve ||
       type == v8::debug::kDebugEnqueuePromiseReject) {
     return;
   }
 
   bool isScheduledTask = task == m_taskWithScheduledBreak;
   if (type == v8::debug::kDebugPromiseCollected) {
     if (isScheduledTask) m_taskWithScheduledBreak = nullptr;
     return;
   }
   if (type == v8::debug::kDebugPromiseCreated && !parentTask) return;
 
   DCHECK(!context.IsEmpty());
   int contextGroupId = m_inspector->contextGroupId(context);
   V8DebuggerAgentImpl* agent =
       m_inspector->enabledDebuggerAgentForGroup(contextGroupId);
   if (!agent) return;
   if (createdByUser && type == v8::debug::kDebugPromiseCreated) {
-    if (agent->shouldBreakInScheduledAsyncTask()) {
+    if (contextGroupId == m_targetContextGroupId && m_stepIntoAsyncCallback) {
       m_taskWithScheduledBreak = task;
       v8::debug::ClearStepping(m_isolate);
+      m_stepIntoAsyncCallback->sendSuccess();
+      m_stepIntoAsyncCallback.reset();
     }
     return;
   }
   if (!isScheduledTask) return;
   if (type == v8::debug::kDebugWillHandle) {
-    agent->schedulePauseOnNextStatement(
-        protocol::Debugger::Paused::ReasonEnum::Other, nullptr);
+    if (!m_breakRequested) v8::debug::DebugBreak(m_isolate);
     return;
   }
   DCHECK(type == v8::debug::kDebugDidHandle);
-  agent->cancelPauseOnNextStatement();
+  if (!m_breakRequested) v8::debug::CancelDebugBreak(m_isolate);
   m_taskWithScheduledBreak = nullptr;
 }
 
 V8StackTraceImpl* V8Debugger::currentAsyncCallChain() {
   if (!m_currentStacks.size()) return nullptr;
   return m_currentStacks.back().get();
 }
 
 void V8Debugger::compileDebuggerScript() {
   if (!m_debuggerScript.IsEmpty()) {
@@ skipping 156 matching lines @@
 }
 
 void V8Debugger::registerAsyncTaskIfNeeded(void* task) {
   if (m_taskToId.find(task) != m_taskToId.end()) return;
 
   int id = ++m_lastTaskId;
   m_taskToId[task] = id;
   m_idToTask[id] = task;
   if (static_cast<int>(m_idToTask.size()) > m_maxAsyncCallStacks) {
     void* taskToRemove = m_idToTask.begin()->second;
-    asyncTaskCanceled(taskToRemove);
+    asyncTaskCanceledForStack(taskToRemove);
   }
 }
 
-void V8Debugger::asyncTaskCreated(void* task, void* parentTask) {
+void V8Debugger::asyncTaskCreatedForStack(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 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);
+  asyncTaskScheduledForStack(toString16(taskName), task, recurring);
+  if (currentContextGroupId() == m_targetContextGroupId &&
+      m_stepIntoAsyncCallback) {
+    m_taskWithScheduledBreak = task;
+    v8::debug::ClearStepping(m_isolate);
+    m_stepIntoAsyncCallback->sendSuccess();
+    m_stepIntoAsyncCallback.reset();
+  }
 }
 
-void V8Debugger::asyncTaskScheduled(const String16& taskName, void* task,
-                                    bool recurring) {
+void V8Debugger::asyncTaskCanceled(void* task) {
+  asyncTaskCanceledForStack(task);
+  if (task == m_taskWithScheduledBreak) {
+    m_taskWithScheduledBreak = nullptr;
+  }
+}
+
+void V8Debugger::asyncTaskStarted(void* task) {
+  asyncTaskStartedForStack(task);
+  if (task == m_taskWithScheduledBreak) {
+    if (!m_breakRequested) v8::debug::DebugBreak(m_isolate);
+  }
+}
+
+void V8Debugger::asyncTaskFinished(void* task) {
+  asyncTaskFinishedForStack(task);
+  if (task == m_taskWithScheduledBreak) {
+    if (!m_breakRequested) v8::debug::CancelDebugBreak(m_isolate);
+  }
+}
+
+void V8Debugger::asyncTaskScheduledForStack(const String16& taskName,
+                                            void* task, bool recurring) {
   if (!m_maxAsyncCallStackDepth) return;
   v8::HandleScope scope(m_isolate);
   std::unique_ptr<V8StackTraceImpl> chain = V8StackTraceImpl::capture(
       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) {
+void V8Debugger::asyncTaskCanceledForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   m_asyncTaskStacks.erase(task);
   m_recurringTasks.erase(task);
   m_parentTask.erase(task);
   m_asyncTaskCreationStacks.erase(task);
   auto it = m_taskToId.find(task);
   if (it == m_taskToId.end()) return;
   m_idToTask.erase(it->second);
   m_taskToId.erase(it);
 }
 
-void V8Debugger::asyncTaskStarted(void* task) {
+void V8Debugger::asyncTaskStartedForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   m_currentTasks.push_back(task);
   auto parentIt = m_parentTask.find(task);
   AsyncTaskToStackTrace::iterator stackIt = m_asyncTaskStacks.find(
       parentIt == m_parentTask.end() ? task : parentIt->second);
   // Needs to support following order of events:
   // - asyncTaskScheduled
   //   <-- attached here -->
   // - asyncTaskStarted
   // - asyncTaskCanceled <-- canceled before finished
   //   <-- async stack requested here -->
   // - asyncTaskFinished
   std::unique_ptr<V8StackTraceImpl> stack;
   if (stackIt != m_asyncTaskStacks.end() && stackIt->second)
     stack = stackIt->second->cloneImpl();
   auto itCreation = m_asyncTaskCreationStacks.find(task);
   if (stack && itCreation != m_asyncTaskCreationStacks.end()) {
     stack->setCreation(itCreation->second->cloneImpl());
   }
   m_currentStacks.push_back(std::move(stack));
 }
 
-void V8Debugger::asyncTaskFinished(void* task) {
+void V8Debugger::asyncTaskFinishedForStack(void* task) {
   if (!m_maxAsyncCallStackDepth) return;
   // We could start instrumenting half way and the stack is empty.
   if (!m_currentStacks.size()) return;
 
   DCHECK(m_currentTasks.back() == task);
   m_currentTasks.pop_back();
 
   m_currentStacks.pop_back();
   if (m_recurringTasks.find(task) == m_recurringTasks.end()) {
-    asyncTaskCanceled(task);
+    asyncTaskCanceledForStack(task);
   }
 }
 
 void V8Debugger::allAsyncTasksCanceled() {
   m_asyncTaskStacks.clear();
   m_recurringTasks.clear();
   m_currentStacks.clear();
   m_currentTasks.clear();
   m_parentTask.clear();
   m_asyncTaskCreationStacks.clear();
@@ skipping 26 matching lines @@
 
   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