[inspector] gracefully handle stack overflows in the inspector.

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/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
 #include "src/inspector/string-util.h"
@@ skipping 26 matching lines @@
     const char* functionName, int argc, v8::Local<v8::Value> argv[]) {
   v8::MicrotasksScope microtasks(m_isolate,
                                  v8::MicrotasksScope::kDoNotRunMicrotasks);
   DCHECK(m_isolate->InContext());
   v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
   v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
   v8::Local<v8::Function> function = v8::Local<v8::Function>::Cast(
       debuggerScript
           ->Get(context, toV8StringInternalized(m_isolate, functionName))
           .ToLocalChecked());
+  v8::TryCatch try_catch;
   return function->Call(context, debuggerScript, argc, argv);
 }
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
     : m_isolate(isolate),
       m_inspector(inspector),
       m_lastContextId(0),
       m_enableCount(0),
       m_breakpointsActivated(true),
       m_runningNestedMessageLoop(false),
@@ skipping 373 matching lines @@
 JavaScriptCallFrames V8Debugger::currentCallFrames(int limit) {
   if (!m_isolate->InContext()) return JavaScriptCallFrames();
   v8::Local<v8::Value> currentCallFramesV8;
   if (m_executionState.IsEmpty()) {
     v8::Local<v8::Function> currentCallFramesFunction =
         v8::Local<v8::Function>::Cast(
             m_debuggerScript.Get(m_isolate)
                 ->Get(debuggerContext(),
                       toV8StringInternalized(m_isolate, "currentCallFrames"))
                 .ToLocalChecked());
-    currentCallFramesV8 =
-        v8::DebugInterface::Call(debuggerContext(), currentCallFramesFunction,
-                                 v8::Integer::New(m_isolate, limit))
-            .ToLocalChecked();
+    if (!v8::DebugInterface::Call(debuggerContext(), currentCallFramesFunction,
+                                  v8::Integer::New(m_isolate, limit))
+             .ToLocal(&currentCallFramesV8))
+      return JavaScriptCallFrames();
   } else {
     v8::Local<v8::Value> argv[] = {m_executionState,
                                    v8::Integer::New(m_isolate, limit)};
-    currentCallFramesV8 =
-        callDebuggerMethod("currentCallFrames", arraysize(argv), argv)
-            .ToLocalChecked();
+    if (!callDebuggerMethod("currentCallFrames", arraysize(argv), argv)
+             .ToLocal(&currentCallFramesV8))
+      return JavaScriptCallFrames();
   }
   DCHECK(!currentCallFramesV8.IsEmpty());
   if (!currentCallFramesV8->IsArray()) return JavaScriptCallFrames();
   v8::Local<v8::Array> callFramesArray = currentCallFramesV8.As<v8::Array>();
   JavaScriptCallFrames callFrames;
   for (uint32_t i = 0; i < callFramesArray->Length(); ++i) {
     v8::Local<v8::Value> callFrameValue;
     if (!callFramesArray->Get(debuggerContext(), i).ToLocal(&callFrameValue))
       return JavaScriptCallFrames();
     if (!callFrameValue->IsObject()) return JavaScriptCallFrames();
@@ skipping 150 matching lines @@
         callInternalGetterFunction(eventData, "promise");
     bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
     v8::Local<v8::Value> uncaught =
         callInternalGetterFunction(eventData, "uncaught");
     bool isUncaught = uncaught->BooleanValue(context).FromJust();
     handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
                        exception, v8::Local<v8::Array>(), isPromiseRejection,
                        isUncaught);
   } else if (event == v8::Break) {
     v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
-    v8::Local<v8::Value> hitBreakpoints =
-        callDebuggerMethod("getBreakpointNumbers", 1, argv).ToLocalChecked();
+    v8::Local<v8::Value> hitBreakpoints;
+    if (!callDebuggerMethod("getBreakpointNumbers", 1, argv)
+             .ToLocal(&hitBreakpoints))
+      return;
     DCHECK(hitBreakpoints->IsArray());
     handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
                        v8::Local<v8::Value>(), hitBreakpoints.As<v8::Array>());
   }
 }
 
 void V8Debugger::handleV8AsyncTaskEvent(v8::Local<v8::Context> context,
                                         v8::Local<v8::Object> executionState,
                                         v8::Local<v8::Object> eventData) {
   if (!m_maxAsyncCallStackDepth) return;
@@ skipping 140 matching lines @@
   return properties;
 }
 
 v8::Local<v8::Value> V8Debugger::collectionEntries(
     v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
   if (!enabled()) {
     UNREACHABLE();
     return v8::Undefined(m_isolate);
   }
   v8::Local<v8::Value> argv[] = {object};
-  v8::Local<v8::Value> entriesValue =
-      callDebuggerMethod("getCollectionEntries", 1, argv).ToLocalChecked();
-  if (!entriesValue->IsArray()) return v8::Undefined(m_isolate);
+  v8::Local<v8::Value> entriesValue;
+  if (!callDebuggerMethod("getCollectionEntries", 1, argv)
+           .ToLocal(&entriesValue) ||
+      !entriesValue->IsArray())
+    return v8::Undefined(m_isolate);
 
   v8::Local<v8::Array> entries = entriesValue.As<v8::Array>();
   v8::Local<v8::Array> copiedArray =
       v8::Array::New(m_isolate, entries->Length());
   if (!copiedArray->SetPrototype(context, v8::Null(m_isolate)).FromMaybe(false))
     return v8::Undefined(m_isolate);
   for (uint32_t i = 0; i < entries->Length(); ++i) {
     v8::Local<v8::Value> item;
     if (!entries->Get(debuggerContext(), i).ToLocal(&item))
       return v8::Undefined(m_isolate);
@@ skipping 12 matching lines @@
   return copiedArray;
 }
 
 v8::Local<v8::Value> V8Debugger::generatorObjectLocation(
     v8::Local<v8::Context> context, v8::Local<v8::Object> object) {
   if (!enabled()) {
     UNREACHABLE();
     return v8::Null(m_isolate);
   }
   v8::Local<v8::Value> argv[] = {object};
-  v8::Local<v8::Value> location =
-      callDebuggerMethod("getGeneratorObjectLocation", 1, argv)
-          .ToLocalChecked();
+  v8::Local<v8::Value> location;
   v8::Local<v8::Value> copied;
-  if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
+  if (!callDebuggerMethod("getGeneratorObjectLocation", 1, argv)
+           .ToLocal(&location) ||
+      !copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
                                     location)
            .ToLocal(&copied) ||
       !copied->IsObject())
     return v8::Null(m_isolate);
   if (!markAsInternal(context, v8::Local<v8::Object>::Cast(copied),
                       V8InternalValueType::kLocation))
     return v8::Null(m_isolate);
   return copied;
 }
 
@@ skipping 151 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector