[inspector] [wasm] Implement GetPossibleBreakpoints

src/inspector/v8-debugger-script.cc

 // Copyright 2014 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-script.h"
 
 #include "src/inspector/string-util.h"
+#include "src/inspector/wasm-translation.h"
 
 namespace v8_inspector {
 
 namespace {
 
 const char hexDigits[17] = "0123456789ABCDEF";
 
 void appendUnsignedAsHex(uint64_t number, String16Builder* destination) {
   for (size_t i = 0; i < 8; ++i) {
     UChar c = hexDigits[number & 0xF];
@@ skipping 43 matching lines @@
   }
 
   for (size_t i = 0; i < hashesSize; ++i)
     hashes[i] = (hashes[i] + zi[i] * (prime[i] - 1)) % prime[i];
 
   String16Builder hash;
   for (size_t i = 0; i < hashesSize; ++i) appendUnsignedAsHex(hashes[i], &hash);
   return hash.toString();
 }
 
+void TranslateProtocolLocationToV8Location(WasmTranslation* wasmTranslation,
+                                           v8::DebugInterface::Location* loc,
+                                           const String16& scriptId,
+                                           const String16& expectedV8ScriptId) {
+  if (loc->IsEmpty()) return;
+  int lineNumber = loc->GetLineNumber();
+  int columnNumber = loc->GetColumnNumber();
+  String16 translatedScriptId = scriptId;
+  wasmTranslation->TranslateProtocolLocationToWasmScriptLocation(
+      &translatedScriptId, &lineNumber, &columnNumber);
+  DCHECK_EQ(expectedV8ScriptId.utf8(), translatedScriptId.utf8());
+  *loc = v8::DebugInterface::Location(lineNumber, columnNumber);
+}
+
+void TranslateV8LocationToProtocolLocation(
+    WasmTranslation* wasmTranslation, v8::DebugInterface::Location* loc,
+    const String16& scriptId, const String16& expectedProtocolScriptId) {
+  int lineNumber = loc->GetLineNumber();
+  int columnNumber = loc->GetColumnNumber();
+  String16 translatedScriptId = scriptId;
+  // This call should never trigger a new fake script to be created, so passing
+  // -1 as contextGroupId is fine. A DCHECK in the wasm translation will fail
+  // whenever this contextGroupId is used to find the corrensponding debugger
+  // agent.
+  wasmTranslation->TranslateWasmScriptLocationToProtocolLocation(
+      &translatedScriptId, &lineNumber, &columnNumber, -1);
+  DCHECK_EQ(expectedProtocolScriptId.utf8(), translatedScriptId.utf8());
+  *loc = v8::DebugInterface::Location(lineNumber, columnNumber);
+}
+
 class ActualScript : public V8DebuggerScript {
   friend class V8DebuggerScript;
 
  public:
   ActualScript(v8::Local<v8::DebugInterface::Script> script, String16 url)
       : V8DebuggerScript(script->GetIsolate(),
                          String16::fromInteger(script->Id()), std::move(url)) {}
 
   bool isLiveEdit() const override { return m_isLiveEdit; }
 
@@ skipping 35 matching lines @@
   v8::Global<v8::String> m_sourceObj;
   String16 m_executionContextAuxData;
   bool m_isLiveEdit = false;
   v8::Global<v8::DebugInterface::Script> m_script;
 };
 
 class WasmVirtualScript : public V8DebuggerScript {
   friend class V8DebuggerScript;
 
  public:
-  WasmVirtualScript(v8::Local<v8::DebugInterface::Script> script, String16 id,
-                    String16 url, String16 source)
+  WasmVirtualScript(v8::Local<v8::DebugInterface::Script> script,
+                    WasmTranslation* translation, String16 id, String16 url,
+                    String16 source)
       : V8DebuggerScript(script->GetIsolate(), std::move(id), std::move(url)),
-        m_script(script->GetIsolate(), script) {
+        m_script(script->GetIsolate(), script),
+        m_wasmTranslation(translation) {
     m_source = std::move(source);
   }
 
   const String16& sourceMappingURL() const override { return emptyString(); }
   const String16& executionContextAuxData() const override {
     return emptyString();
   }
   bool isLiveEdit() const override { return false; }
 
   bool getPossibleBreakpoints(
       const v8::DebugInterface::Location& start,
       const v8::DebugInterface::Location& end,
       std::vector<v8::DebugInterface::Location>* locations) override {
-    // TODO(clemensh): Returning false produces the protocol error "Internal
-    // error". Implement and fix expected output of
-    // wasm-get-breakable-locations.js.
-    return false;
+    v8::HandleScope scope(m_isolate);
+    v8::Local<v8::DebugInterface::Script> script = m_script.Get(m_isolate);
+    String16 v8ScriptId = String16::fromInteger(script->Id());
+
+    v8::DebugInterface::Location translatedStart = start;
+    TranslateProtocolLocationToV8Location(m_wasmTranslation, &translatedStart,
+                                          scriptId(), v8ScriptId);
+
+    v8::DebugInterface::Location translatedEnd = end;
+    TranslateProtocolLocationToV8Location(m_wasmTranslation, &translatedEnd,
+                                          scriptId(), v8ScriptId);
+    if (translatedEnd.IsEmpty()) {
+      // Stop before the start of the next function.
+      translatedEnd =
+          v8::DebugInterface::Location(translatedStart.GetLineNumber() + 1, 0);
+    }
+
+    bool success = script->GetPossibleBreakpoints(translatedStart,
+                                                  translatedEnd, locations);
+    for (v8::DebugInterface::Location& loc : *locations) {
+      TranslateV8LocationToProtocolLocation(m_wasmTranslation, &loc, v8ScriptId,
+                                            scriptId());
+    }
+    return success;
   }
 
  private:
   static const String16& emptyString() {
     static const String16 singleEmptyString;
     return singleEmptyString;
   }
 
   v8::Global<v8::DebugInterface::Script> m_script;
+  WasmTranslation* m_wasmTranslation;
 };
 
 }  // namespace
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::Create(
     v8::Isolate* isolate, v8::Local<v8::DebugInterface::Script> scriptObj,
     bool isLiveEdit) {
   String16 url;
   String16 sourceUrl;
   v8::Local<v8::String> tmp;
@@ skipping 51 matching lines @@
       script->m_endLine++;
       script->m_endColumn = 0;
     }
   }
 
   script->m_script.Reset(script->m_isolate, scriptObj);
   return std::move(script);
 }
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::CreateWasm(
-    v8::Local<v8::DebugInterface::Script> script, String16 id, String16 url,
+    v8::Local<v8::DebugInterface::Script> script,
+    WasmTranslation* wasmTranslation, String16 id, String16 url,
     String16 source) {
   int num_lines = 0;
   int last_newline = -1;
   size_t next_newline = source.find('\n', last_newline + 1);
   while (next_newline != String16::kNotFound) {
     last_newline = static_cast<int>(next_newline);
     next_newline = source.find('\n', last_newline + 1);
     ++num_lines;
   }
   int m_endLine = num_lines;
   int m_endColumn = static_cast<int>(source.length()) - last_newline - 1;
-  return std::unique_ptr<WasmVirtualScript>(new WasmVirtualScript(
-      script, std::move(id), std::move(url), std::move(source)));
+  return std::unique_ptr<WasmVirtualScript>(
+      new WasmVirtualScript(script, wasmTranslation, std::move(id),
+                            std::move(url), std::move(source)));
 }
 
 V8DebuggerScript::~V8DebuggerScript() {}
 
 const String16& V8DebuggerScript::sourceURL() const {
   return m_sourceURL.isEmpty() ? m_url : m_sourceURL;
 }
 
 const String16& V8DebuggerScript::hash(v8::Isolate* isolate) const {
   if (m_hash.isEmpty()) m_hash = calculateHash(source(isolate));
   DCHECK(!m_hash.isEmpty());
   return m_hash;
 }
 
 void V8DebuggerScript::setSourceURL(const String16& sourceURL) {
   m_sourceURL = sourceURL;
 }
 
 V8DebuggerScript::V8DebuggerScript(v8::Isolate* isolate, String16 id,
                                    String16 url)
     : m_id(std::move(id)), m_url(std::move(url)), m_isolate(isolate) {}
 
 }  // namespace v8_inspector