[inspector] changed a way of preserving stepping between tasks

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 310 matching lines @@
 }
 
 void V8Debugger::setPauseOnExceptionsState(
     v8::debug::ExceptionBreakState pauseOnExceptionsState) {
   DCHECK(enabled());
   if (m_pauseOnExceptionsState == pauseOnExceptionsState) return;
   v8::debug::ChangeBreakOnException(m_isolate, pauseOnExceptionsState);
   m_pauseOnExceptionsState = pauseOnExceptionsState;
 }
 
-void V8Debugger::setPauseOnNextStatement(bool pause) {
+void V8Debugger::setPauseOnNextStatement(bool pause, int targetContextGroupId) {
   if (isPaused()) return;
+  DCHECK(targetContextGroupId);
+  if (!pause && m_targetContextGroupId &&
+      m_targetContextGroupId != targetContextGroupId) {
+    return;
+  }
+  m_targetContextGroupId = targetContextGroupId;
   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() {
+void V8Debugger::stepIntoStatement(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
+  DCHECK(targetContextGroupId);
+  m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepIn);
   continueProgram();
 }
 
-void V8Debugger::stepOverStatement() {
+void V8Debugger::stepOverStatement(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
+  DCHECK(targetContextGroupId);
+  m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepNext);
   continueProgram();
 }
 
-void V8Debugger::stepOutOfFunction() {
+void V8Debugger::stepOutOfFunction(int targetContextGroupId) {
   DCHECK(isPaused());
   DCHECK(!m_executionState.IsEmpty());
+  DCHECK(targetContextGroupId);
+  m_targetContextGroupId = targetContextGroupId;
   v8::debug::PrepareStep(m_isolate, v8::debug::StepOut);
   continueProgram();
 }
 
 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 {
@@ skipping 113 matching lines @@
 }
 
 void V8Debugger::handleProgramBreak(v8::Local<v8::Context> pausedContext,
                                     v8::Local<v8::Object> executionState,
                                     v8::Local<v8::Value> exception,
                                     v8::Local<v8::Array> hitBreakpointNumbers,
                                     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;
   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 25 matching lines @@
   if (m_scheduledOOMBreak) m_isolate->RestoreOriginalHeapLimit();
   m_scheduledOOMBreak = false;
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
 void V8Debugger::v8OOMCallback(void* data) {
   V8Debugger* thisPtr = static_cast<V8Debugger*>(data);
   thisPtr->m_isolate->IncreaseHeapLimitForDebugging();
   thisPtr->m_scheduledOOMBreak = true;
-  thisPtr->setPauseOnNextStatement(true);
+  v8::Local<v8::Context> context = thisPtr->m_isolate->GetEnteredContext();
+  DCHECK(!context.IsEmpty());
+  thisPtr->setPauseOnNextStatement(
+      true, thisPtr->m_inspector->contextGroupId(context));
 }
 
 void V8Debugger::ScriptCompiled(v8::Local<v8::debug::Script> script,
                                 bool has_compile_error) {
   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(
@@ skipping 90 matching lines @@
   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()) {
       m_taskWithScheduledBreak = task;
+      v8::debug::ClearStepping(m_isolate);
     }
     return;
   }
   if (!isScheduledTask) return;
   if (type == v8::debug::kDebugWillHandle) {
     agent->schedulePauseOnNextStatement(
         protocol::Debugger::Paused::ReasonEnum::Other, nullptr);
     return;
   }
   DCHECK(type == v8::debug::kDebugDidHandle);
@@ skipping 299 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