[inspector] added targetCallFrames for continueToLocation

src/inspector/v8-stack-trace-impl.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-stack-trace-impl.h"
 
 #include <algorithm>
 
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/wasm-translation.h"
@@ skipping 108 matching lines @@
     const {
   return protocol::Runtime::CallFrame::create()
       .setFunctionName(m_functionName)
       .setScriptId(m_scriptId)
       .setUrl(m_sourceURL)
       .setLineNumber(m_lineNumber)
       .setColumnNumber(m_columnNumber)
       .build();
 }
 
+bool StackFrame::isEqual(StackFrame* frame) const {
+  if (scriptId() != frame->scriptId()) return false;

[dgozman, 2017/05/16 20:19:25]

return m_scriptId == frame->m_scriptId && ....;

[kozy, 2017/05/16 21:18:48]

Done.

+  if (lineNumber() != frame->lineNumber()) return false;
+  if (columnNumber() != frame->columnNumber()) return false;
+  return true;
+}
+
 // static
 void V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(
     v8::Isolate* isolate, bool capture) {
   isolate->SetCaptureStackTraceForUncaughtExceptions(
       capture, V8StackTraceImpl::maxCallStackSizeToCapture);
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(
     V8Debugger* debugger, int contextGroupId,
@@ skipping 95 matching lines @@
     stackTrace.append(':');
     stackTrace.append(String16::fromInteger(frame.lineNumber() + 1));
     stackTrace.append(':');
     stackTrace.append(String16::fromInteger(frame.columnNumber() + 1));
     stackTrace.append(')');
   }
   String16 string = stackTrace.toString();
   return StringBufferImpl::adopt(string);
 }
 
+bool V8StackTraceImpl::isEqualIgnoringTopFrame(
+    V8StackTraceImpl* stackTrace) const {
+  StackFrameIterator current(this);
+  StackFrameIterator target(stackTrace);
+
+  current.next();
+  target.next();
+  while (!current.done() && !target.done()) {
+    if (!current.frame()->isEqual(target.frame())) {
+      return false;
+    }
+    current.next();
+    target.next();
+  }
+  return current.done() == target.done();
+}
+
+V8StackTraceImpl::StackFrameIterator::StackFrameIterator(
+    const V8StackTraceImpl* stackTrace)
+    : m_currentIt(stackTrace->m_frames.begin()),
+      m_currentEnd(stackTrace->m_frames.end()),
+      m_parent(stackTrace->m_asyncParent.lock().get()) {}
+
+void V8StackTraceImpl::StackFrameIterator::next() {
+  if (m_currentIt == m_currentEnd) return;
+  ++m_currentIt;
+  while (m_currentIt == m_currentEnd && m_parent) {
+    const std::vector<std::shared_ptr<StackFrame>>& frames = m_parent->frames();
+    m_currentIt = frames.begin();
+    if (m_parent->description() == "async function") ++m_currentIt;
+    m_currentEnd = frames.end();
+    m_parent = m_parent->parent().lock().get();
+  }
+}
+
+bool V8StackTraceImpl::StackFrameIterator::done() {
+  return m_currentIt == m_currentEnd;
+}
+
+StackFrame* V8StackTraceImpl::StackFrameIterator::frame() {
+  return m_currentIt->get();
+}
+
 // static
 std::shared_ptr<AsyncStackTrace> AsyncStackTrace::capture(
     V8Debugger* debugger, int contextGroupId, const String16& description,
     int maxStackSize) {
   DCHECK(debugger);
 
   v8::Isolate* isolate = debugger->isolate();
   v8::HandleScope handleScope(isolate);
 
   std::vector<std::shared_ptr<StackFrame>> frames;
@@ skipping 57 matching lines @@
   return m_asyncParent;
 }
 
 std::weak_ptr<AsyncStackTrace> AsyncStackTrace::creation() const {
   return m_asyncCreation;
 }
 
 bool AsyncStackTrace::isEmpty() const { return m_frames.empty(); }
 
 }  // namespace v8_inspector