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

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 157 matching lines @@
 Response V8DebuggerAgentImpl::disable() {
   if (!enabled()) return Response::OK();
 
   m_state->setObject(DebuggerAgentState::javaScriptBreakpoints,
                      protocol::DictionaryValue::create());
   m_state->setInteger(DebuggerAgentState::pauseOnExceptionsState,
                       v8::debug::NoBreakOnException);
   m_state->setInteger(DebuggerAgentState::asyncCallStackDepth, 0);
 
   if (isPaused()) m_debugger->continueProgram();
+
+  {
+    v8::HandleScope scope(m_isolate);
+    for (const auto& it : m_idToBreakpoints) removeBreakpointImpl(it.first);
+  }
+
   m_debugger->disable();
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   m_blackboxedPositions.clear();
   m_blackboxPattern.reset();
   resetBlackboxedStateCache();
   m_scripts.clear();
-  m_breakpointIdToDebuggerBreakpointIds.clear();
+  m_idToBreakpoints.clear();
+  m_breakpointIdToSource.clear();
   m_debugger->setAsyncCallStackDepth(this, 0);
-  m_continueToLocationBreakpointId = String16();
+  m_continueToLocationBreakpoint.Reset();
   clearBreakDetails();
   m_scheduledDebuggerStep = NoStep;
   m_javaScriptPauseScheduled = false;
   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();
 }
@@ skipping 116 matching lines @@
 Response V8DebuggerAgentImpl::setBreakpoint(
     std::unique_ptr<protocol::Debugger::Location> location,
     Maybe<String16> optionalCondition, String16* outBreakpointId,
     std::unique_ptr<protocol::Debugger::Location>* actualLocation) {
   ScriptBreakpoint breakpoint(
       location->getScriptId(), location->getLineNumber(),
       location->getColumnNumber(0), optionalCondition.fromMaybe(String16()));
 
   String16 breakpointId =
       generateBreakpointId(breakpoint, UserBreakpointSource);
-  if (m_breakpointIdToDebuggerBreakpointIds.find(breakpointId) !=
-      m_breakpointIdToDebuggerBreakpointIds.end()) {
+  if (m_idToBreakpoints.find(breakpointId) != m_idToBreakpoints.end()) {
     return Response::Error("Breakpoint at specified location already exists.");
   }
   *actualLocation =
       resolveBreakpoint(breakpointId, breakpoint, UserBreakpointSource);
   if (!*actualLocation) return Response::Error("Could not resolve breakpoint");
   *outBreakpointId = breakpointId;
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::removeBreakpoint(const String16& breakpointId) {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
   protocol::DictionaryValue* breakpointsCookie =
       m_state->getObject(DebuggerAgentState::javaScriptBreakpoints);
   if (breakpointsCookie) breakpointsCookie->remove(breakpointId);
   removeBreakpointImpl(breakpointId);
   return Response::OK();
 }
 
 void V8DebuggerAgentImpl::removeBreakpointImpl(const String16& breakpointId) {
   DCHECK(enabled());
-  BreakpointIdToDebuggerBreakpointIdsMap::iterator
-      debuggerBreakpointIdsIterator =
-          m_breakpointIdToDebuggerBreakpointIds.find(breakpointId);
-  if (debuggerBreakpointIdsIterator ==
-      m_breakpointIdToDebuggerBreakpointIds.end())
-    return;
-  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);
+  auto it = m_idToBreakpoints.find(breakpointId);
+  if (it == m_idToBreakpoints.end()) return;
+  v8::HandleScope scope(m_isolate);
+  for (const auto& breakpoint : it->second) {
+    v8::debug::ClearBreakPoint(m_isolate, breakpoint.Get(m_isolate));
   }
-  m_breakpointIdToDebuggerBreakpointIds.erase(breakpointId);
+  m_breakpointIdToSource.erase(it->first);
+  m_idToBreakpoints.erase(it);
 }
 
 Response V8DebuggerAgentImpl::getPossibleBreakpoints(
     std::unique_ptr<protocol::Debugger::Location> start,
     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)
     return Response::Error(
@@ skipping 27 matching lines @@
                       .setLineNumber(v8Locations[i].GetLineNumber())
                       .setColumnNumber(v8Locations[i].GetColumnNumber())
                       .build());
   }
   return Response::OK();
 }
 
 Response V8DebuggerAgentImpl::continueToLocation(
     std::unique_ptr<protocol::Debugger::Location> location) {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
-  if (!m_continueToLocationBreakpointId.isEmpty()) {
-    m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
-    m_continueToLocationBreakpointId = "";
+  ScriptsMap::iterator it = m_scripts.find(location->getScriptId());
+  if (it == m_scripts.end()) {
+    return Response::Error("No script with given id found");
   }
 
-  ScriptBreakpoint breakpoint(location->getScriptId(),
-                              location->getLineNumber(),
-                              location->getColumnNumber(0), String16());
+  v8::HandleScope handle_scope(m_isolate);
 
-  m_continueToLocationBreakpointId = m_debugger->setBreakpoint(
-      breakpoint, &breakpoint.line_number, &breakpoint.column_number);
+  if (!m_continueToLocationBreakpoint.IsEmpty()) {
+    v8::debug::ClearBreakPoint(m_isolate,
+                               m_continueToLocationBreakpoint.Get(m_isolate));
+    m_continueToLocationBreakpoint.Reset();
+  }
+
+  v8::debug::Location position(location->getLineNumber(),
+                               location->getColumnNumber(0));
+  v8::Local<v8::debug::BreakPoint> breakPoint = v8::debug::BreakPoint::New(
+      m_isolate, v8::Undefined(m_isolate), v8::Undefined(m_isolate));
+
+  v8::debug::Location result = it->second->setBreakpoint(position, breakPoint);
+  if (result.IsEmpty()) return Response::Error("Could not resolve breakpoint");
+  m_continueToLocationBreakpoint.Reset(m_isolate, breakPoint);
   // TODO(kozyatinskiy): Return actual line and column number.
   return resume();
 }
 
 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.
@@ skipping 39 matching lines @@
   if (breakpoint.line_number < scriptIterator->second->startLine() ||
       scriptIterator->second->endLine() < breakpoint.line_number)
     return nullptr;
 
   // Translate from protocol location to v8 location for the debugger.
   ScriptBreakpoint translatedBreakpoint = breakpoint;
   m_debugger->wasmTranslation()->TranslateProtocolLocationToWasmScriptLocation(
       &translatedBreakpoint.script_id, &translatedBreakpoint.line_number,
       &translatedBreakpoint.column_number);
 
-  int actualLineNumber;
-  int actualColumnNumber;
-  String16 debuggerBreakpointId = m_debugger->setBreakpoint(
-      translatedBreakpoint, &actualLineNumber, &actualColumnNumber);
-  if (debuggerBreakpointId.isEmpty()) return nullptr;
+  v8::Local<v8::Value> condition = v8::Undefined(m_isolate);
+  if (!breakpoint.condition.isEmpty())
+    condition = toV8String(m_isolate, breakpoint.condition);
+  v8::Local<v8::Value> v8BreakpointId = toV8String(m_isolate, breakpointId);
+  v8::Local<v8::debug::BreakPoint> breakPoint =
+      v8::debug::BreakPoint::New(m_isolate, condition, v8BreakpointId);
+  v8::debug::Location position(translatedBreakpoint.line_number,
+                               translatedBreakpoint.column_number);
+  v8::debug::Location result =
+      scriptIterator->second->setBreakpoint(position, breakPoint);
+  if (result.IsEmpty()) return nullptr;
+
+  int actualLineNumber = result.GetLineNumber();
+  int actualColumnNumber = result.GetColumnNumber();
 
   // Translate back from v8 location to protocol location for the return value.
   m_debugger->wasmTranslation()->TranslateWasmScriptLocationToProtocolLocation(
       &translatedBreakpoint.script_id, &actualLineNumber, &actualColumnNumber);
 
-  m_serverBreakpoints[debuggerBreakpointId] =
-      std::make_pair(breakpointId, source);
   CHECK(!breakpointId.isEmpty());
-
-  m_breakpointIdToDebuggerBreakpointIds[breakpointId].push_back(
-      debuggerBreakpointId);
+  m_idToBreakpoints[breakpointId].emplace_back(m_isolate, breakPoint);
+  m_breakpointIdToSource[breakpointId] = source;
   return buildProtocolLocation(translatedBreakpoint.script_id, actualLineNumber,
                                actualColumnNumber);
 }
 
 Response V8DebuggerAgentImpl::searchInContent(
     const String16& scriptId, const String16& query,
     Maybe<bool> optionalCaseSensitive, Maybe<bool> optionalIsRegex,
     std::unique_ptr<Array<protocol::Debugger::SearchMatch>>* results) {
   v8::HandleScope handles(m_isolate);
   ScriptsMap::iterator it = m_scripts.find(scriptId);
@@ skipping 565 matching lines @@
                                  &breakpoint.column_number);
     breakpointObject->getString(DebuggerAgentState::condition,
                                 &breakpoint.condition);
     std::unique_ptr<protocol::Debugger::Location> location =
         resolveBreakpoint(cookie.first, breakpoint, UserBreakpointSource);
     if (location)
       m_frontend.breakpointResolved(cookie.first, std::move(location));
   }
 }
 
-void V8DebuggerAgentImpl::didPause(int contextId,
-                                   v8::Local<v8::Value> exception,
-                                   const std::vector<String16>& hitBreakpoints,
-                                   bool isPromiseRejection, bool isUncaught,
-                                   bool isOOMBreak) {
+void V8DebuggerAgentImpl::didPause(
+    int contextId, v8::Local<v8::Value> exception,
+    const v8::PersistentValueVector<v8::debug::BreakPoint>& 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;
 
   if (isOOMBreak) {
     hitReasons.push_back(
         std::make_pair(protocol::Debugger::Paused::ReasonEnum::OOM, nullptr));
   } else if (!exception.IsEmpty()) {
@@ skipping 15 matching lines @@
         breakAuxData = nullptr;
       }
       hitReasons.push_back(
           std::make_pair(breakReason, std::move(breakAuxData)));
     }
   }
 
   std::unique_ptr<Array<String16>> hitBreakpointIds = Array<String16>::create();
 
   bool hasDebugCommandBreakpointReason = false;
-  for (const auto& point : hitBreakpoints) {
-    DebugServerBreakpointToBreakpointIdAndSourceMap::iterator
-        breakpointIterator = m_serverBreakpoints.find(point);
-    if (breakpointIterator != m_serverBreakpoints.end()) {
-      const String16& localId = breakpointIterator->second.first;
-      hitBreakpointIds->addItem(localId);
-
-      BreakpointSource source = breakpointIterator->second.second;
-      if (!hasDebugCommandBreakpointReason &&
-          source == DebugCommandBreakpointSource) {
-        hasDebugCommandBreakpointReason = true;
-        hitReasons.push_back(std::make_pair(
-            protocol::Debugger::Paused::ReasonEnum::DebugCommand, nullptr));
-      }
+  for (size_t i = 0; i < hitBreakpoints.Size(); ++i) {
+    String16 id = toProtocolStringWithTypeCheck(hitBreakpoints.Get(i)->Data());
+    if (id.isEmpty()) continue;
+    auto it = m_breakpointIdToSource.find(id);
+    if (it == m_breakpointIdToSource.end()) continue;
+    hitBreakpointIds->addItem(it->first);
+    if (!hasDebugCommandBreakpointReason &&
+        it->second == DebugCommandBreakpointSource) {
+      hasDebugCommandBreakpointReason = true;
+      hitReasons.push_back(std::make_pair(
+          protocol::Debugger::Paused::ReasonEnum::DebugCommand, nullptr));
     }
   }
 
   for (size_t i = 0; i < m_breakReason.size(); ++i) {
     hitReasons.push_back(std::move(m_breakReason[i]));
   }
   clearBreakDetails();
 
   String16 breakReason = protocol::Debugger::Paused::ReasonEnum::Other;
   std::unique_ptr<protocol::DictionaryValue> breakAuxData;
   if (hitReasons.size() == 1) {
     breakReason = hitReasons[0].first;
     breakAuxData = std::move(hitReasons[0].second);
   } else if (hitReasons.size() > 1) {
     breakReason = protocol::Debugger::Paused::ReasonEnum::Ambiguous;
     std::unique_ptr<protocol::ListValue> reasons =
         protocol::ListValue::create();
     for (size_t i = 0; i < hitReasons.size(); ++i) {
       std::unique_ptr<protocol::DictionaryValue> reason =
           protocol::DictionaryValue::create();
       reason->setString("reason", hitReasons[i].first);
-      if (hitReasons[i].second)
+      if (hitReasons[i].second) {
         reason->setObject("auxData", std::move(hitReasons[i].second));
+      }
       reasons->pushValue(std::move(reason));
     }
     breakAuxData = protocol::DictionaryValue::create();
     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());
   m_scheduledDebuggerStep = NoStep;
   m_javaScriptPauseScheduled = false;
 
-  if (!m_continueToLocationBreakpointId.isEmpty()) {
-    m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
-    m_continueToLocationBreakpointId = "";
+  if (!m_continueToLocationBreakpoint.IsEmpty()) {
+    v8::debug::ClearBreakPoint(m_isolate,
+                               m_continueToLocationBreakpoint.Get(m_isolate));
+    m_continueToLocationBreakpoint.Reset();
   }
 }
 
 void V8DebuggerAgentImpl::didContinue() {
   JavaScriptCallFrames emptyCallFrames;
   m_pausedCallFrames.swap(emptyCallFrames);
   clearBreakDetails();
   m_frontend.resumed();
 }
 
@@ skipping 35 matching lines @@
       ScriptBreakpoint(scriptId, lineNumber, columnNumber, String16()),
       source));
 }
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_scheduledDebuggerStep = NoStep;
   m_blackboxedPositions.clear();
   resetBlackboxedStateCache();
   m_scripts.clear();
-  m_breakpointIdToDebuggerBreakpointIds.clear();
+  m_idToBreakpoints.clear();
+  m_breakpointIdToSource.clear();
 }
 
 }  // namespace v8_inspector