[inspector] Make pausing on console.assert work with multiple sessions

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 345 matching lines @@
   v8::debug::BreakRightNow(m_isolate);
 }
 
 void V8Debugger::continueProgram(int targetContextGroupId) {
   if (m_pausedContextGroupId != targetContextGroupId) return;
   if (isPaused()) m_inspector->client()->quitMessageLoopOnPause();
   m_pausedContext.Clear();
   m_executionState.Clear();
 }
 
+void V8Debugger::breakProgramOnAssert(int targetContextGroupId) {
+  if (!enabled()) return;
+  if (m_pauseOnExceptionsState == v8::debug::NoBreakOnException) return;
+  // Don't allow nested breaks.
+  if (isPaused()) return;
+  if (!canBreakProgram()) return;
+  DCHECK(targetContextGroupId);
+  m_targetContextGroupId = targetContextGroupId;
+  m_scheduledAssertBreak = true;
+  v8::debug::BreakRightNow(m_isolate);
+}
+
 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(targetContextGroupId);
 }
 
 void V8Debugger::stepOverStatement(int targetContextGroupId) {
@@ skipping 216 matching lines @@
   }
   m_targetContextGroupId = 0;
   if (m_stepIntoAsyncCallback) {
     m_stepIntoAsyncCallback->sendFailure(
         Response::Error("No async tasks were scheduled before pause."));
     m_stepIntoAsyncCallback.reset();
   }
   m_breakRequested = false;
 
   bool scheduledOOMBreak = m_scheduledOOMBreak;
+  bool scheduledAssertBreak = m_scheduledAssertBreak;
   auto agentCheck = [&scheduledOOMBreak](V8DebuggerAgentImpl* agent) {
     return agent->enabled() && (scheduledOOMBreak || !agent->skipAllPauses());
   };
 
   bool hasAgents = false;
   m_inspector->forEachSession(
       contextGroupId,
       [&agentCheck, &hasAgents](V8InspectorSessionImpl* session) {
         if (agentCheck(session->debuggerAgent())) hasAgents = true;
       });
@@ skipping 17 matching lines @@
   }
   clearContinueToLocation();
 
   DCHECK(contextGroupId);
   m_pausedContext = pausedContext;
   m_executionState = executionState;
   m_pausedContextGroupId = contextGroupId;
 
   m_inspector->forEachSession(
       contextGroupId, [&agentCheck, &pausedContext, &exception, &breakpointIds,
-                       &isPromiseRejection, &isUncaught,
-                       &scheduledOOMBreak](V8InspectorSessionImpl* session) {
+                       &isPromiseRejection, &isUncaught, &scheduledOOMBreak,
+                       &scheduledAssertBreak](V8InspectorSessionImpl* session) {
         if (agentCheck(session->debuggerAgent())) {
           session->debuggerAgent()->didPause(
               InspectedContext::contextId(pausedContext), exception,
-              breakpointIds, isPromiseRejection, isUncaught, scheduledOOMBreak);
+              breakpointIds, isPromiseRejection, isUncaught, scheduledOOMBreak,
+              scheduledAssertBreak);
         }
       });
   {
     v8::Context::Scope scope(pausedContext);
     v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
     CHECK(!context.IsEmpty() &&
           context != v8::debug::GetDebugContext(m_isolate));
     m_inspector->client()->runMessageLoopOnPause(contextGroupId);
     m_pausedContextGroupId = 0;
   }
   m_inspector->forEachSession(contextGroupId,
                               [](V8InspectorSessionImpl* session) {
                                 if (session->debuggerAgent()->enabled())
                                   session->debuggerAgent()->didContinue();
                               });
 
   if (m_scheduledOOMBreak) m_isolate->RestoreOriginalHeapLimit();
   m_scheduledOOMBreak = false;
+  m_scheduledAssertBreak = 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;
   v8::Local<v8::Context> context = thisPtr->m_isolate->GetEnteredContext();
   DCHECK(!context.IsEmpty());
@@ skipping 520 matching lines @@
   fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
   fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
   fprintf(stdout, "Created async tasks: %zu\n",
           m_asyncTaskCreationStacks.size());
   fprintf(stdout, "Async tasks with parent: %zu\n", m_parentTask.size());
   fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
   fprintf(stdout, "\n");
 }
 
 }  // namespace v8_inspector