[inspector] unconditionally pause on OOM

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 1106 matching lines @@
     std::unique_ptr<protocol::Debugger::Location> location =
         resolveBreakpoint(cookie.first, breakpoint, UserBreakpointSource);
     if (location)
       m_frontend.breakpointResolved(cookie.first, std::move(location));
   }
 }
 
 V8DebuggerAgentImpl::SkipPauseRequest V8DebuggerAgentImpl::didPause(
     v8::Local<v8::Context> context, v8::Local<v8::Value> exception,
     const std::vector<String16>& hitBreakpoints, bool isPromiseRejection,
-    bool isUncaught) {
+    bool isUncaught, bool isOOMBreak) {
   JavaScriptCallFrames callFrames = m_debugger->currentCallFrames(1);
   JavaScriptCallFrame* topCallFrame =
       !callFrames.empty() ? callFrames.begin()->get() : nullptr;
 
   V8DebuggerAgentImpl::SkipPauseRequest result;
-  if (m_skipAllPauses)
+  if (isOOMBreak)
+    result = RequestNoSkip;
+  else if (m_skipAllPauses)
     result = RequestContinue;
   else if (!hitBreakpoints.empty())
     result = RequestNoSkip;  // Don't skip explicit breakpoints even if set in
                              // frameworks.
   else if (!exception.IsEmpty())
     result = shouldSkipExceptionPause(topCallFrame);
   else if (m_scheduledDebuggerStep != NoStep || m_javaScriptPauseScheduled ||
            m_pausingOnNativeEvent)
     result = shouldSkipStepPause(topCallFrame);
   else
     result = RequestNoSkip;
 
   m_skipNextDebuggerStepOut = false;
   if (result != RequestNoSkip) return result;
   // Skip pauses inside V8 internal scripts and on syntax errors.
   if (!topCallFrame) return RequestContinue;
 
   DCHECK(m_pausedContext.IsEmpty());
   JavaScriptCallFrames frames = m_debugger->currentCallFrames();
   m_pausedCallFrames.swap(frames);
   m_pausedContext.Reset(m_isolate, context);
   v8::HandleScope handles(m_isolate);
 
-  if (!exception.IsEmpty()) {
+  if (isOOMBreak) {
+    m_breakReason = protocol::Debugger::Paused::ReasonEnum::OOM;
+    m_breakAuxData = nullptr;
+  } else if (!exception.IsEmpty()) {
     InjectedScript* injectedScript = nullptr;
     m_session->findInjectedScript(InspectedContext::contextId(context),
                                   injectedScript);
     if (injectedScript) {
       m_breakReason =
           isPromiseRejection
               ? protocol::Debugger::Paused::ReasonEnum::PromiseRejection
               : protocol::Debugger::Paused::ReasonEnum::Exception;
       std::unique_ptr<protocol::Runtime::RemoteObject> obj;
       injectedScript->wrapObject(exception, kBacktraceObjectGroup, false, false,
@@ skipping 100 matching lines @@
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_scheduledDebuggerStep = NoStep;
   m_scripts.clear();
   m_blackboxedPositions.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector