[inspector] move changeBreakpointState from debugger-script to native

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 37 matching lines @@
 }
 
 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),
       m_ignoreScriptParsedEventsCounter(0),
-      m_maxAsyncCallStackDepth(0) {}
+      m_maxAsyncCallStackDepth(0),
+      m_pauseOnExceptionsState(DontPauseOnExceptions) {}
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(m_isolate);
   v8::Debug::SetDebugEventListener(m_isolate, &V8Debugger::v8DebugEventCallback,
                                    v8::External::New(m_isolate, this));
   m_debuggerContext.Reset(m_isolate, v8::Debug::GetDebugContext(m_isolate));
+  v8::Debug::ChangeBreakOnException(m_isolate, v8::NoBreakOnException);
+  m_pauseOnExceptionsState = DontPauseOnExceptions;
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
@@ skipping 165 matching lines @@
                                                     "setBreakpointsActivated"))
               .ToLocalChecked());
   v8::Debug::Call(debuggerContext(), setBreakpointsActivated, info)
       .ToLocalChecked();
 
   m_breakpointsActivated = activated;
 }
 
 V8Debugger::PauseOnExceptionsState V8Debugger::getPauseOnExceptionsState() {
   DCHECK(enabled());
-  v8::HandleScope scope(m_isolate);
-  v8::Local<v8::Context> context = debuggerContext();
-  v8::Context::Scope contextScope(context);
-
-  v8::Local<v8::Value> argv[] = {v8::Undefined(m_isolate)};
-  v8::Local<v8::Value> result =
-      callDebuggerMethod("pauseOnExceptionsState", 0, argv).ToLocalChecked();
-  return static_cast<V8Debugger::PauseOnExceptionsState>(
-      result->Int32Value(context).FromJust());
+  return m_pauseOnExceptionsState;
 }
 
 void V8Debugger::setPauseOnExceptionsState(
     PauseOnExceptionsState pauseOnExceptionsState) {
   DCHECK(enabled());
-  v8::HandleScope scope(m_isolate);
-  v8::Context::Scope contextScope(debuggerContext());
-
-  v8::Local<v8::Value> argv[] = {
-      v8::Int32::New(m_isolate, pauseOnExceptionsState)};
-  callDebuggerMethod("setPauseOnExceptionsState", 1, argv);
+  if (m_pauseOnExceptionsState == pauseOnExceptionsState) return;
+  if (pauseOnExceptionsState == DontPauseOnExceptions)
+    v8::Debug::ChangeBreakOnException(m_isolate, v8::NoBreakOnException);
+  else if (pauseOnExceptionsState == PauseOnUncaughtExceptions)
+    v8::Debug::ChangeBreakOnException(m_isolate, v8::BreakOnUncaughtException);
+  else
+    v8::Debug::ChangeBreakOnException(m_isolate, v8::BreakOnAnyException);
+  m_pauseOnExceptionsState = pauseOnExceptionsState;
 }
 
 void V8Debugger::setPauseOnNextStatement(bool pause) {
   if (m_runningNestedMessageLoop) return;
   if (pause)
     v8::Debug::DebugBreak(m_isolate);
   else
     v8::Debug::CancelDebugBreak(m_isolate);
 }
 
@@ skipping 709 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