[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;
+  wasmTranslation->TranslateWasmScriptLocationToProtocolLocation(
+      &translatedScriptId, &lineNumber, &columnNumber);
+  DCHECK_EQ(expectedProtocolScriptId.utf8(), translatedScriptId.utf8());
+  *loc = v8::DebugInterface::Location(lineNumber, columnNumber);
+}
+
 class ActualScript : public V8DebuggerScript {
   friend class V8DebuggerScript;
 
  public:
   ActualScript(v8::Isolate* isolate,
                v8::Local<v8::DebugInterface::Script> script, bool isLiveEdit)
       : V8DebuggerScript(isolate, String16::fromInteger(script->Id()),
                          GetNameOrSourceUrl(script)),
         m_isLiveEdit(isLiveEdit) {
     v8::Local<v8::String> tmp;
@@ skipping 95 matching lines @@
   bool m_isLiveEdit = false;
   v8::Global<v8::DebugInterface::Script> m_script;
 };
 
 class WasmVirtualScript : public V8DebuggerScript {
   friend class V8DebuggerScript;
 
  public:
   WasmVirtualScript(v8::Isolate* isolate,
                     v8::Local<v8::DebugInterface::WasmScript> script,
-                    String16 id, String16 url, String16 source)
+                    WasmTranslation* translation, String16 id, String16 url,
+                    String16 source)
       : V8DebuggerScript(isolate, std::move(id), std::move(url)),
-        m_script(isolate, script) {
+        m_script(isolate, script),
+        m_wasmTranslation(translation) {
     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;
     }
     m_endLine = num_lines;
     m_endColumn = static_cast<int>(source.length()) - last_newline - 1;
     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; }
   void setSourceMappingURL(const String16&) override {}
 
   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::WasmScript> m_script;
+  WasmTranslation* m_wasmTranslation;
 };
 
 }  // namespace
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::Create(
     v8::Isolate* isolate, v8::Local<v8::DebugInterface::Script> scriptObj,
     bool isLiveEdit) {
   return std::unique_ptr<ActualScript>(
       new ActualScript(isolate, scriptObj, isLiveEdit));
 }
 
 std::unique_ptr<V8DebuggerScript> V8DebuggerScript::CreateWasm(
     v8::Isolate* isolate,
-    v8::Local<v8::DebugInterface::WasmScript> underlyingScript, String16 id,
-    String16 url, String16 source) {
+    v8::Local<v8::DebugInterface::WasmScript> underlyingScript,
+    WasmTranslation* translation, String16 id, String16 url, String16 source) {
   return std::unique_ptr<WasmVirtualScript>(
-      new WasmVirtualScript(isolate, underlyingScript, std::move(id),
-                            std::move(url), std::move(source)));
+      new WasmVirtualScript(isolate, underlyingScript, translation,
+                            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