[inspector] added targetCallFrames for continueToLocation

src/inspector/v8-debugger-agent-impl.cc

 // Copyright 2015 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-agent-impl.h"
 
 #include <algorithm>
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/injected-script.h"
@@ skipping 229 matching lines @@
   if (isPaused()) m_debugger->continueProgram(m_session->contextGroupId());
   m_debugger->disable();
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   m_blackboxedPositions.clear();
   m_blackboxPattern.reset();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
   m_debugger->setAsyncCallStackDepth(this, 0);
-  m_continueToLocationBreakpointId = String16();
+  clearContinueToLocation();
   clearBreakDetails();
   m_skipAllPauses = false;
   m_state->setBoolean(DebuggerAgentState::skipAllPauses, false);
   m_state->remove(DebuggerAgentState::blackboxPattern);
   m_enabled = false;
   m_state->setBoolean(DebuggerAgentState::debuggerEnabled, false);
   return Response::OK();
 }
 
 void V8DebuggerAgentImpl::restore() {
@@ skipping 216 matching lines @@
             .build();
     if (v8Locations[i].type() != v8::debug::kCommonBreakLocation) {
       breakLocation->setType(breakLocationType(v8Locations[i].type()));
     }
     (*locations)->addItem(std::move(breakLocation));
   }
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::continueToLocation(
-    std::unique_ptr<protocol::Debugger::Location> location) {
+    std::unique_ptr<protocol::Debugger::Location> location,
+    Maybe<String16> strategy) {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
-  if (!m_continueToLocationBreakpointId.isEmpty()) {
-    m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
-    m_continueToLocationBreakpointId = "";
-  }
+  if (!isPaused()) return Response::Error(kDebuggerNotPaused);
+  clearContinueToLocation();
 
   ScriptBreakpoint breakpoint(location->getScriptId(),
                               location->getLineNumber(),
                               location->getColumnNumber(0), String16());
 
   m_continueToLocationBreakpointId = m_debugger->setBreakpoint(
       breakpoint, &breakpoint.line_number, &breakpoint.column_number);
+  if (m_continueToLocationBreakpointId.isEmpty()) {
+    return Response::Error("Location can't be resolved");
+  }
+  m_continueToLocationStrategy = strategy.fromMaybe(
+      protocol::Debugger::ContinueToLocation::StrategyEnum::Default);
+  if (m_continueToLocationStrategy !=
+      protocol::Debugger::ContinueToLocation::StrategyEnum::Default) {
+    m_continueToLocationStack = m_debugger->captureStackTrace(true);
+    if (m_continueToLocationStack) {
+      m_continueToLocationStrategy =
+          protocol::Debugger::ContinueToLocation::StrategyEnum::Default;
+    }
+  }
   // TODO(kozyatinskiy): Return actual line and column number.
   return resume();
 }
 
+void V8DebuggerAgentImpl::clearContinueToLocation() {
+  if (m_continueToLocationBreakpointId.isEmpty()) return;
+  m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
+  m_continueToLocationBreakpointId = String16();
+  m_continueToLocationStrategy = String16();
+  m_continueToLocationStack.reset();
+}
+
 bool V8DebuggerAgentImpl::isFunctionBlackboxed(const String16& scriptId,
                                                const v8::debug::Location& start,
                                                const v8::debug::Location& end) {
   ScriptsMap::iterator it = m_scripts.find(scriptId);
   if (it == m_scripts.end()) {
     // Unknown scripts are blackboxed.
     return true;
   }
   if (m_blackboxPattern) {
     const String16& scriptSourceURL = it->second->sourceURL();
@@ skipping 623 matching lines @@
     if (!hasHint) {
       hint = breakpointHint(*scriptRef, breakpoint);
       if (!hint.isEmpty())
         breakpointObject->setString(DebuggerAgentState::hint, hint);
     }
     if (location)
       m_frontend.breakpointResolved(cookie.first, std::move(location));
   }
 }
 
+bool V8DebuggerAgentImpl::shouldIgnoreContinueToLocation(
+    const String16& breakpointId) {
+  if (breakpointId != m_continueToLocationBreakpointId) return false;
+  if (m_continueToLocationStrategy ==
+      protocol::Debugger::ContinueToLocation::StrategyEnum::Default) {
+    return false;
+  }
+  std::unique_ptr<V8StackTraceImpl> currentStack =
+      m_debugger->captureStackTrace(true);
+  if (m_continueToLocationStrategy ==
+      protocol::Debugger::ContinueToLocation::StrategyEnum::InCurrentFrame) {
+    return !m_continueToLocationStack->isEqualIgnoringTopFrame(
+        currentStack.get());
+  }
+  return false;
+}
+
 void V8DebuggerAgentImpl::didPause(int contextId,
                                    v8::Local<v8::Value> exception,
                                    const std::vector<String16>& hitBreakpoints,
                                    bool isPromiseRejection, bool isUncaught,
                                    bool isOOMBreak) {
   JavaScriptCallFrames frames = m_debugger->currentCallFrames();
   m_pausedCallFrames.swap(frames);
   v8::HandleScope handles(m_isolate);
 
   std::vector<BreakReason> hitReasons;
@@ skipping 70 matching lines @@
     breakAuxData->setArray("reasons", std::move(reasons));
   }
 
   std::unique_ptr<Array<CallFrame>> protocolCallFrames;
   Response response = currentCallFrames(&protocolCallFrames);
   if (!response.isSuccess()) protocolCallFrames = Array<CallFrame>::create();
   m_frontend.paused(std::move(protocolCallFrames), breakReason,
                     std::move(breakAuxData), std::move(hitBreakpointIds),
                     currentAsyncStackTrace());
 
-  if (!m_continueToLocationBreakpointId.isEmpty()) {
-    m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
-    m_continueToLocationBreakpointId = "";
-  }
+  clearContinueToLocation();
 }
 
 void V8DebuggerAgentImpl::didContinue() {
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   clearBreakDetails();
   m_frontend.resumed();
 }
 
 void V8DebuggerAgentImpl::breakProgram(
@@ skipping 39 matching lines @@
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_blackboxedPositions.clear();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector