[inspector] migrate set/remove BreakPoint to debug-interface.h

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 172 matching lines @@
                                     this);
   m_debuggerContext.Reset(m_isolate, v8::debug::GetDebugContext(m_isolate));
   v8::debug::ChangeBreakOnException(m_isolate, v8::debug::NoBreakOnException);
   m_pauseOnExceptionsState = v8::debug::NoBreakOnException;
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
-  clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
   m_wasmTranslation.Clear();
   v8::debug::SetDebugDelegate(m_isolate, nullptr);
   v8::debug::SetOutOfMemoryCallback(m_isolate, nullptr, nullptr);
   m_isolate->RestoreOriginalHeapLimit();
 }
 
 bool V8Debugger::enabled() const { return !m_debuggerScript.IsEmpty(); }
 
 void V8Debugger::getCompiledScripts(
     int contextGroupId,
     std::vector<std::unique_ptr<V8DebuggerScript>>& result) {
   v8::HandleScope scope(m_isolate);
   v8::PersistentValueVector<v8::debug::Script> scripts(m_isolate);
   v8::debug::GetLoadedScripts(m_isolate, scripts);
   for (size_t i = 0; i < scripts.Size(); ++i) {
     v8::Local<v8::debug::Script> script = scripts.Get(i);
     if (!script->WasCompiled()) continue;
     v8::Local<v8::Value> contextData;
     if (!script->ContextData().ToLocal(&contextData) || !contextData->IsInt32())
       continue;
     int contextId = static_cast<int>(contextData.As<v8::Int32>()->Value());
     if (m_inspector->contextGroupId(contextId) != contextGroupId) continue;
     result.push_back(V8DebuggerScript::Create(m_isolate, script, false));
   }
 }
 
-String16 V8Debugger::setBreakpoint(const ScriptBreakpoint& breakpoint,
-                                   int* actualLineNumber,
-                                   int* actualColumnNumber) {
-  v8::HandleScope scope(m_isolate);
-  v8::Local<v8::Context> context = debuggerContext();
-  v8::Context::Scope contextScope(context);
-
-  v8::Local<v8::Object> info = v8::Object::New(m_isolate);
-  bool success = false;
-  success = info->Set(context, toV8StringInternalized(m_isolate, "sourceID"),
-                      toV8String(m_isolate, breakpoint.script_id))
-                .FromMaybe(false);
-  DCHECK(success);
-  success = info->Set(context, toV8StringInternalized(m_isolate, "lineNumber"),
-                      v8::Integer::New(m_isolate, breakpoint.line_number))
-                .FromMaybe(false);
-  DCHECK(success);
-  success =
-      info->Set(context, toV8StringInternalized(m_isolate, "columnNumber"),
-                v8::Integer::New(m_isolate, breakpoint.column_number))
-          .FromMaybe(false);
-  DCHECK(success);
-  success = info->Set(context, toV8StringInternalized(m_isolate, "condition"),
-                      toV8String(m_isolate, breakpoint.condition))
-                .FromMaybe(false);
-  DCHECK(success);
-  USE(success);
-
-  v8::Local<v8::Function> setBreakpointFunction = v8::Local<v8::Function>::Cast(
-      m_debuggerScript.Get(m_isolate)
-          ->Get(context, toV8StringInternalized(m_isolate, "setBreakpoint"))
-          .ToLocalChecked());
-  v8::Local<v8::Value> breakpointId =
-      v8::debug::Call(debuggerContext(), setBreakpointFunction, info)
-          .ToLocalChecked();
-  if (!breakpointId->IsString()) return "";
-  *actualLineNumber =
-      info->Get(context, toV8StringInternalized(m_isolate, "lineNumber"))
-          .ToLocalChecked()
-          ->Int32Value(context)
-          .FromJust();
-  *actualColumnNumber =
-      info->Get(context, toV8StringInternalized(m_isolate, "columnNumber"))
-          .ToLocalChecked()
-          ->Int32Value(context)
-          .FromJust();
-  return toProtocolString(breakpointId.As<v8::String>());
-}
-
-void V8Debugger::removeBreakpoint(const String16& breakpointId) {
-  v8::HandleScope scope(m_isolate);
-  v8::Local<v8::Context> context = debuggerContext();
-  v8::Context::Scope contextScope(context);
-
-  v8::Local<v8::Object> info = v8::Object::New(m_isolate);
-  bool success = false;
-  success =
-      info->Set(context, toV8StringInternalized(m_isolate, "breakpointId"),
-                toV8String(m_isolate, breakpointId))
-          .FromMaybe(false);
-  DCHECK(success);
-  USE(success);
-
-  v8::Local<v8::Function> removeBreakpointFunction =
-      v8::Local<v8::Function>::Cast(
-          m_debuggerScript.Get(m_isolate)
-              ->Get(context,
-                    toV8StringInternalized(m_isolate, "removeBreakpoint"))
-              .ToLocalChecked());
-  v8::debug::Call(debuggerContext(), removeBreakpointFunction, info)
-      .ToLocalChecked();
-}
-
-void V8Debugger::clearBreakpoints() {
-  v8::HandleScope scope(m_isolate);
-  v8::Local<v8::Context> context = debuggerContext();
-  v8::Context::Scope contextScope(context);
-
-  v8::Local<v8::Function> clearBreakpoints = v8::Local<v8::Function>::Cast(
-      m_debuggerScript.Get(m_isolate)
-          ->Get(context, toV8StringInternalized(m_isolate, "clearBreakpoints"))
-          .ToLocalChecked());
-  v8::debug::Call(debuggerContext(), clearBreakpoints).ToLocalChecked();
-}
-
 void V8Debugger::setBreakpointsActivated(bool activated) {
   if (!enabled()) {
     UNREACHABLE();
     return;
   }
   v8::debug::SetBreakPointsActive(m_isolate, activated);
   m_breakpointsActivated = activated;
 }
 
 v8::debug::ExceptionBreakState V8Debugger::getPauseOnExceptionsState() {
@@ skipping 192 matching lines @@
 }
 
 void V8Debugger::breakProgramCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   DCHECK_EQ(info.Length(), 2);
   V8Debugger* thisPtr = toV8Debugger(info.Data());
   if (!thisPtr->enabled()) return;
   v8::Local<v8::Context> pausedContext =
       thisPtr->m_isolate->GetCurrentContext();
   v8::Local<v8::Value> exception;
-  v8::Local<v8::Array> hitBreakpoints;
+  v8::PersistentValueVector<v8::debug::BreakPoint> hitBreakpoints(
+      thisPtr->m_isolate);
   thisPtr->handleProgramBreak(pausedContext,
                               v8::Local<v8::Object>::Cast(info[0]), exception,
                               hitBreakpoints);
 }
 
-void V8Debugger::handleProgramBreak(v8::Local<v8::Context> pausedContext,
-                                    v8::Local<v8::Object> executionState,
-                                    v8::Local<v8::Value> exception,
-                                    v8::Local<v8::Array> hitBreakpointNumbers,
-                                    bool isPromiseRejection, bool isUncaught) {
+void V8Debugger::handleProgramBreak(
+    v8::Local<v8::Context> pausedContext, v8::Local<v8::Object> executionState,
+    v8::Local<v8::Value> exception,
+    const v8::PersistentValueVector<v8::debug::BreakPoint>& hitBreakPoints,
+    bool isPromiseRejection, bool isUncaught) {
   // Don't allow nested breaks.
   if (isPaused()) return;
 
   V8DebuggerAgentImpl* agent = m_inspector->enabledDebuggerAgentForGroup(
       m_inspector->contextGroupId(pausedContext));
   if (!agent || (agent->skipAllPauses() && !m_scheduledOOMBreak)) return;
 
-  std::vector<String16> breakpointIds;
-  if (!hitBreakpointNumbers.IsEmpty()) {
-    breakpointIds.reserve(hitBreakpointNumbers->Length());
-    for (uint32_t i = 0; i < hitBreakpointNumbers->Length(); i++) {
-      v8::Local<v8::Value> hitBreakpointNumber =
-          hitBreakpointNumbers->Get(debuggerContext(), i).ToLocalChecked();
-      DCHECK(hitBreakpointNumber->IsInt32());
-      breakpointIds.push_back(String16::fromInteger(
-          hitBreakpointNumber->Int32Value(debuggerContext()).FromJust()));
-    }
-  }
-
   m_pausedContext = pausedContext;
   m_executionState = executionState;
   m_runningNestedMessageLoop = true;
   agent->didPause(InspectedContext::contextId(pausedContext), exception,
-                  breakpointIds, isPromiseRejection, isUncaught,
+                  hitBreakPoints, isPromiseRejection, isUncaught,
                   m_scheduledOOMBreak);
   int groupId = m_inspector->contextGroupId(pausedContext);
   DCHECK(groupId);
   {
     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(groupId);
     m_runningNestedMessageLoop = false;
@@ skipping 23 matching lines @@
   } else if (m_ignoreScriptParsedEventsCounter == 0) {
     agent->didParseSource(
         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, true)
-           .ToLocal(&hitBreakpoints)) {
+  v8::PersistentValueVector<v8::debug::BreakPoint> breakPoints(m_isolate);
+  if (!breakPointsHit->IsArray()) {
+    handleProgramBreak(pausedContext, execState, v8::Local<v8::Value>(),
+                       breakPoints);
     return;
   }
-  DCHECK(hitBreakpoints->IsArray());
+  v8::Local<v8::Array> breakPointsHitArray =
+      v8::Local<v8::Array>::Cast(breakPointsHit);
+  for (uint32_t i = 0; i < breakPointsHitArray->Length(); ++i) {
+    v8::Local<v8::Value> item;
+    if (!breakPointsHitArray->Get(pausedContext, i).ToLocal(&item)) continue;
+    v8::Local<v8::debug::BreakPoint> breakPoint;
+    if (!v8::debug::BreakPoint::Cast(m_isolate, item).ToLocal(&breakPoint)) {
+      continue;
+    }
+    breakPoints.Append(breakPoint);
+  }
   handleProgramBreak(pausedContext, execState, v8::Local<v8::Value>(),
-                     hitBreakpoints.As<v8::Array>());
+                     breakPoints);
 }
 
 void V8Debugger::ExceptionThrown(v8::Local<v8::Context> pausedContext,
                                  v8::Local<v8::Object> execState,
                                  v8::Local<v8::Value> exception,
                                  v8::Local<v8::Value> promise,
                                  bool isUncaught) {
   bool isPromiseRejection = promise->IsPromise();
-  handleProgramBreak(pausedContext, execState, exception,
-                     v8::Local<v8::Array>(), isPromiseRejection, isUncaught);
+  v8::PersistentValueVector<v8::debug::BreakPoint> hitBreakpoints(m_isolate);
+  handleProgramBreak(pausedContext, execState, exception, hitBreakpoints,
+                     isPromiseRejection, isUncaught);
 }
 
 bool V8Debugger::IsFunctionBlackboxed(v8::Local<v8::debug::Script> script,
                                       const v8::debug::Location& start,
                                       const v8::debug::Location& end) {
   V8DebuggerAgentImpl* agent = agentForScript(m_inspector, script);
   if (!agent) return false;
   return agent->isFunctionBlackboxed(String16::fromInteger(script->Id()), start,
                                      end);
 }
@@ skipping 333 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