[inspector] Introduce translation of wasm frames

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 "src/inspector/string-util.h"
+#include "src/inspector/v8-debugger-agent-impl.h"
 #include "src/inspector/v8-debugger.h"
 #include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/v8-profiler-agent-impl.h"
 
 #include "include/v8-debug.h"
 #include "include/v8-profiler.h"
 #include "include/v8-version.h"
 
 namespace v8_inspector {
 
 namespace {
 
 static const v8::StackTrace::StackTraceOptions stackTraceOptions =
     static_cast<v8::StackTrace::StackTraceOptions>(
         v8::StackTrace::kLineNumber | v8::StackTrace::kColumnOffset |
         v8::StackTrace::kScriptId | v8::StackTrace::kScriptNameOrSourceURL |
         v8::StackTrace::kFunctionName);
 
-V8StackTraceImpl::Frame toFrame(v8::Local<v8::StackFrame> frame) {
+V8StackTraceImpl::Frame toFrame(V8DebuggerAgentImpl* agent,
+                                v8::Local<v8::StackFrame> frame) {
   String16 scriptId = String16::fromInteger(frame->GetScriptId());
   String16 sourceName;
   v8::Local<v8::String> sourceNameValue(frame->GetScriptNameOrSourceURL());
   if (!sourceNameValue.IsEmpty())
     sourceName = toProtocolString(sourceNameValue);
 
   String16 functionName;
   v8::Local<v8::String> functionNameValue(frame->GetFunctionName());
   if (!functionNameValue.IsEmpty())
     functionName = toProtocolString(functionNameValue);
 
-  int sourceLineNumber = frame->GetLineNumber();
-  int sourceColumn = frame->GetColumn();
+  int sourceLineNumber = frame->GetLineNumber() - 1;
+  int sourceColumn = frame->GetColumn() - 1;
+  if (agent)
+    agent->wasmTranslation()->TranslateProtocolLocationToWasmScriptLocation(

[dgozman, 2016/11/16 19:00:10]

This is a wrong place for translation - it could be executed when debugger is
not enabled yet (e.g. when exception occurs, and we open DevTools later).
Instead, we should translate directly before sending this over protocol.

[Clemens Hammacher, 2016/11/16 20:31:30]

Not sure if this is fixed with the switch from debugger agent to debugger. At
least I am not seeing a path which leads to V8StackTraceImpl::Create without a
debugger being in place.

[dgozman, 2016/11/16 22:01:27]

We can translate here when debugger is disabled, and no translation would
happen. Later on, with enabled debugging, incorrect stack trace would be sent to
client. Let's just move this code to buildInspectorObjectImpl().

[Clemens Hammacher, 2016/11/16 22:43:31]

As discussed in chat: We postpone this, as it seems to require larger changes in
the API.

+        &scriptId, &sourceLineNumber, &sourceColumn);
   return V8StackTraceImpl::Frame(functionName, scriptId, sourceName,
-                                 sourceLineNumber, sourceColumn);
+                                 sourceLineNumber + 1, sourceColumn + 1);
 }
 
-void toFramesVector(v8::Local<v8::StackTrace> stackTrace,
+void toFramesVector(V8DebuggerAgentImpl* agent,
+                    v8::Local<v8::StackTrace> stackTrace,
                     std::vector<V8StackTraceImpl::Frame>& frames,
                     size_t maxStackSize, v8::Isolate* isolate) {
   DCHECK(isolate->InContext());
   int frameCount = stackTrace->GetFrameCount();
   if (frameCount > static_cast<int>(maxStackSize))
     frameCount = static_cast<int>(maxStackSize);
   for (int i = 0; i < frameCount; i++) {
     v8::Local<v8::StackFrame> stackFrame = stackTrace->GetFrame(i);
-    frames.push_back(toFrame(stackFrame));
+    frames.push_back(toFrame(agent, stackFrame));
   }
 }
 
 }  //  namespace
 
 V8StackTraceImpl::Frame::Frame()
     : m_functionName("undefined"),
       m_scriptId(""),
       m_scriptName("undefined"),
       m_lineNumber(0),
@@ skipping 41 matching lines @@
 }
 
 // static
 std::unique_ptr<V8StackTraceImpl> V8StackTraceImpl::create(
     V8Debugger* debugger, int contextGroupId,
     v8::Local<v8::StackTrace> stackTrace, size_t maxStackSize,
     const String16& description) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope scope(isolate);
   std::vector<V8StackTraceImpl::Frame> frames;
+  V8DebuggerAgentImpl* agent =
+      debugger
+          ? debugger->inspector()->enabledDebuggerAgentForGroup(contextGroupId)
+          : nullptr;
   if (!stackTrace.IsEmpty())
-    toFramesVector(stackTrace, frames, maxStackSize, isolate);
+    toFramesVector(agent, stackTrace, frames, maxStackSize, isolate);
 
   int maxAsyncCallChainDepth = 1;
   V8StackTraceImpl* asyncCallChain = nullptr;
   if (debugger && maxStackSize > 1) {
     asyncCallChain = debugger->currentAsyncCallChain();
     maxAsyncCallChainDepth = debugger->maxAsyncCallChainDepth();
   }
   // Do not accidentally append async call chain from another group. This should
   // not
   // happen if we have proper instrumentation, but let's double-check to be
@@ skipping 145 matching lines @@
     stackTrace.append(String16::fromInteger(frame.lineNumber()));
     stackTrace.append(':');
     stackTrace.append(String16::fromInteger(frame.columnNumber()));
     stackTrace.append(')');
   }
   String16 string = stackTrace.toString();
   return StringBufferImpl::adopt(string);
 }
 
 }  // namespace v8_inspector