Fix uncaught exception bug from liveEditScriptSource

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 29 matching lines @@
   int contextGroupId = inspector->contextGroupId(contextId);
   if (!contextGroupId) return nullptr;
   return inspector->enabledDebuggerAgentForGroup(contextGroupId);
 }
 
 }  // namespace
 
 static bool inLiveEditScope = false;
 
 v8::MaybeLocal<v8::Value> V8Debugger::callDebuggerMethod(
-    const char* functionName, int argc, v8::Local<v8::Value> argv[]) {
+    const char* functionName, int argc, v8::Local<v8::Value> argv[],
+    bool catchExceptions) {
   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(m_isolate);
+  if (catchExceptions) {
+    v8::TryCatch try_catch(m_isolate);
+    return function->Call(context, debuggerScript, argc, argv);
+  }
   return function->Call(context, debuggerScript, argc, argv);
 }
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
     : m_isolate(isolate),
       m_inspector(inspector),
       m_enableCount(0),
       m_breakpointsActivated(true),
       m_runningNestedMessageLoop(false),
       m_ignoreScriptParsedEventsCounter(0),
@@ skipping 267 matching lines @@
 
   v8::Local<v8::Value> argv[] = {toV8String(m_isolate, sourceID), newSource,
                                  v8Boolean(dryRun, m_isolate)};
 
   v8::Local<v8::Value> v8result;
   {
     EnableLiveEditScope enableLiveEditScope(m_isolate);
     v8::TryCatch tryCatch(m_isolate);
     tryCatch.SetVerbose(false);
     v8::MaybeLocal<v8::Value> maybeResult =
-        callDebuggerMethod("liveEditScriptSource", 3, argv);
+        callDebuggerMethod("liveEditScriptSource", 3, argv, false);
     if (tryCatch.HasCaught()) {
       v8::Local<v8::Message> message = tryCatch.Message();
       if (!message.IsEmpty())
         return Response::Error(toProtocolStringWithTypeCheck(message->Get()));
       else
         return Response::InternalError();
     }
     v8result = maybeResult.ToLocalChecked();
   }
   DCHECK(!v8result.IsEmpty());
@@ skipping 56 matching lines @@
                 ->Get(debuggerContext(),
                       toV8StringInternalized(m_isolate, "currentCallFrames"))
                 .ToLocalChecked());
     if (!v8::debug::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)};
-    if (!callDebuggerMethod("currentCallFrames", arraysize(argv), argv)
+    if (!callDebuggerMethod("currentCallFrames", arraysize(argv), argv, true)
              .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))
@@ skipping 93 matching lines @@
         V8DebuggerScript::Create(m_isolate, script, inLiveEditScope),
         !has_compile_error);
   }
 }
 
 void V8Debugger::BreakProgramRequested(v8::Local<v8::Context> pausedContext,
                                        v8::Local<v8::Object> execState,
                                        v8::Local<v8::Value> breakPointsHit) {
   v8::Local<v8::Value> argv[] = {breakPointsHit};
   v8::Local<v8::Value> hitBreakpoints;
-  if (!callDebuggerMethod("getBreakpointNumbers", 1, argv)
+  if (!callDebuggerMethod("getBreakpointNumbers", 1, argv, true)
            .ToLocal(&hitBreakpoints)) {
     return;
   }
   DCHECK(hitBreakpoints->IsArray());
   handleProgramBreak(pausedContext, execState, v8::Local<v8::Value>(),
                      hitBreakpoints.As<v8::Array>());
 }
 
 void V8Debugger::ExceptionThrown(v8::Local<v8::Context> pausedContext,
                                  v8::Local<v8::Object> execState,
@@ skipping 91 matching lines @@
   const char* debuggerMethod = nullptr;
   switch (kind) {
     case FUNCTION:
       debuggerMethod = "getFunctionScopes";
       break;
     case GENERATOR:
       debuggerMethod = "getGeneratorScopes";
       break;
   }
 
-  if (!callDebuggerMethod(debuggerMethod, 1, argv).ToLocal(&scopesValue))
+  if (!callDebuggerMethod(debuggerMethod, 1, argv, true).ToLocal(&scopesValue))
     return v8::MaybeLocal<v8::Value>();
   v8::Local<v8::Value> copied;
   if (!copyValueFromDebuggerContext(m_isolate, debuggerContext(), context,
                                     scopesValue)
            .ToLocal(&copied) ||
       !copied->IsArray())
     return v8::MaybeLocal<v8::Value>();
   if (!markAsInternal(context, v8::Local<v8::Array>::Cast(copied),
                       V8InternalValueType::kScopeList))
     return v8::MaybeLocal<v8::Value>();
@@ skipping 76 matching lines @@
 }
 
 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;
-  if (!callDebuggerMethod("getCollectionEntries", 1, argv)
+  if (!callDebuggerMethod("getCollectionEntries", 1, argv, true)
            .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) {
@@ skipping 17 matching lines @@
 
 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;
   v8::Local<v8::Value> copied;
-  if (!callDebuggerMethod("getGeneratorObjectLocation", 1, argv)
+  if (!callDebuggerMethod("getGeneratorObjectLocation", 1, argv, true)
            .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 165 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