[inspector] added Debugger.getPossibleBreakpoints method

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 362 matching lines @@
   const std::vector<String16>& ids = debuggerBreakpointIdsIterator->second;
   for (size_t i = 0; i < ids.size(); ++i) {
     const String16& debuggerBreakpointId = ids[i];
 
     m_debugger->removeBreakpoint(debuggerBreakpointId);
     m_serverBreakpoints.erase(debuggerBreakpointId);
   }
   m_breakpointIdToDebuggerBreakpointIds.erase(breakpointId);
 }
 
+void V8DebuggerAgentImpl::getPossibleBreakpoints(
+    ErrorString* errorString,
+    std::unique_ptr<protocol::Debugger::Location> start,
+    const Maybe<protocol::Debugger::Location>& end,
+    std::unique_ptr<protocol::Array<protocol::Debugger::Location>>* locations) {
+  String16 scriptId = start->getScriptId();
+
+  if (start->getLineNumber() < 0 || start->getColumnNumber(0) < 0) {
+    *errorString = "start.lineNumber and start.columnNumber should be >= 0";
+    return;
+  }
+
+  v8::DebugInterface::Location v8Start(start->getLineNumber(),
+                                       start->getColumnNumber(0));
+  v8::DebugInterface::Location v8End;
+  if (end.isJust()) {
+    if (end.fromJust()->getScriptId() != scriptId) {
+      *errorString = "Locations should contain the same scriptId";
+      return;
+    }
+    int line = end.fromJust()->getLineNumber();
+    int column = end.fromJust()->getColumnNumber(0);
+    if (line < 0 || column < 0) {
+      *errorString = "end.lineNumber and end.columnNumber should be >= 0";
+      return;
+    }
+    v8End = v8::DebugInterface::Location(line, column);
+  }
+  auto it = m_scripts.find(scriptId);
+  if (it == m_scripts.end()) {
+    *errorString = "Script not found";
+    return;
+  }
+
+  std::vector<v8::DebugInterface::Location> v8Locations;
+  if (!it->second->getPossibleBreakpoints(v8Start, v8End, &v8Locations)) {
+    *errorString = "Internal error";
+    return;
+  }
+
+  *locations = protocol::Array<protocol::Debugger::Location>::create();
+  for (size_t i = 0; i < v8Locations.size(); ++i) {
+    (*locations)
+        ->addItem(protocol::Debugger::Location::create()
+                      .setScriptId(scriptId)
+                      .setLineNumber(v8Locations[i].GetLineNumber())
+                      .setColumnNumber(v8Locations[i].GetColumnNumber())
+                      .build());
+  }
+}
+
 void V8DebuggerAgentImpl::continueToLocation(
     ErrorString* errorString,
     std::unique_ptr<protocol::Debugger::Location> location) {
   if (!checkEnabled(errorString)) return;
   if (!m_continueToLocationBreakpointId.isEmpty()) {
     m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
     m_continueToLocationBreakpointId = "";
   }
 
   String16 scriptId;
@@ skipping 147 matching lines @@
   if (!checkEnabled(errorString)) return;
 
   v8::HandleScope handles(m_isolate);
   v8::Local<v8::String> newSource = toV8String(m_isolate, newContent);
   if (!m_debugger->setScriptSource(scriptId, newSource, dryRun.fromMaybe(false),
                                    errorString, optOutCompileError,
                                    &m_pausedCallFrames, stackChanged))
     return;
 
   ScriptsMap::iterator it = m_scripts.find(scriptId);
-  if (it != m_scripts.end()) it->second->setSource(m_isolate, newSource);
+  if (it != m_scripts.end()) it->second->setSource(newSource);
 
   std::unique_ptr<Array<CallFrame>> callFrames = currentCallFrames(errorString);
   if (!callFrames) return;
   *newCallFrames = std::move(callFrames);
   *asyncStackTrace = currentAsyncStackTrace();
 }
 
 void V8DebuggerAgentImpl::restartFrame(
     ErrorString* errorString, const String16& callFrameId,
     std::unique_ptr<Array<CallFrame>>* newCallFrames,
@@ skipping 681 matching lines @@
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_scheduledDebuggerStep = NoStep;
   m_scripts.clear();
   m_blackboxedPositions.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector