[inspector] move continueToLocation implementation to debugger

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 176 matching lines @@
   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();
+  clearContinueToLocation();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
   m_taskWithScheduledBreak = nullptr;
   m_wasmTranslation.Clear();
   v8::debug::SetDebugDelegate(m_isolate, nullptr);
   v8::debug::SetOutOfMemoryCallback(m_isolate, nullptr, nullptr);
   m_isolate->RestoreOriginalHeapLimit();
 }
 
@@ skipping 197 matching lines @@
   DCHECK(!m_executionState.IsEmpty());
   DCHECK(targetContextGroupId);
   if (m_stepIntoAsyncCallback) {
     m_stepIntoAsyncCallback->sendFailure(Response::Error(
         "Current scheduled step into async was overriden with new one."));
   }
   m_targetContextGroupId = targetContextGroupId;
   m_stepIntoAsyncCallback = std::move(callback);
 }
 
+Response V8Debugger::continueToLocation(
+    int targetContextGroupId,
+    std::unique_ptr<protocol::Debugger::Location> location) {
+  DCHECK(isPaused());
+  DCHECK(!m_executionState.IsEmpty());
+  DCHECK(targetContextGroupId);
+  m_targetContextGroupId = targetContextGroupId;
+  ScriptBreakpoint breakpoint(location->getScriptId(),
+                              location->getLineNumber(),
+                              location->getColumnNumber(0), String16());
+  int lineNumber = 0;
+  int columnNumber = 0;
+  m_continueToLocationBreakpointId =
+      setBreakpoint(breakpoint, &lineNumber, &columnNumber);
+  if (!m_continueToLocationBreakpointId.isEmpty()) {
+    continueProgram(targetContextGroupId);
+    // TODO(kozyatinskiy): Return actual line and column number.
+    return Response::OK();
+  } else {
+    return Response::Error("Cannot continue to specified location");
+  }
+}
+
+void V8Debugger::clearContinueToLocation() {
+  if (m_continueToLocationBreakpointId.length()) {
+    removeBreakpoint(m_continueToLocationBreakpointId);
+    m_continueToLocationBreakpointId = String16();
+  }
+}
+
 Response V8Debugger::setScriptSource(
     const String16& sourceID, v8::Local<v8::String> newSource, bool dryRun,
     Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails,
     JavaScriptCallFrames* newCallFrames, Maybe<bool>* stackChanged,
     bool* compileError) {
   class EnableLiveEditScope {
    public:
     explicit EnableLiveEditScope(v8::Isolate* isolate) : m_isolate(isolate) {
       v8::debug::SetLiveEditEnabled(m_isolate, true);
       inLiveEditScope = true;
@@ skipping 136 matching lines @@
   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()));
     }
   }
+  clearContinueToLocation();
 
   m_pausedContext = pausedContext;
   m_executionState = executionState;
   m_pausedContextGroupId = contextGroupId;
   agent->didPause(InspectedContext::contextId(pausedContext), exception,
                   breakpointIds, isPromiseRejection, isUncaught,
                   m_scheduledOOMBreak);
   int groupId = m_inspector->contextGroupId(pausedContext);
   DCHECK(groupId);
   {
@@ skipping 512 matching lines @@
   fprintf(stdout, "Async stacks count: %d\n", m_asyncStacksCount);
   fprintf(stdout, "Scheduled async tasks: %zu\n", m_asyncTaskStacks.size());
   fprintf(stdout, "Created async tasks: %zu\n",
           m_asyncTaskCreationStacks.size());
   fprintf(stdout, "Async tasks with parent: %zu\n", m_parentTask.size());
   fprintf(stdout, "Recurring async tasks: %zu\n", m_recurringTasks.size());
   fprintf(stdout, "\n");
 }
 
 }  // namespace v8_inspector