[inspector] Introduce translation of wasm frames

src/inspector/v8-debugger.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-debugger.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
 #include "src/inspector/string-util.h"
@@ skipping 38 matching lines @@
 
 V8Debugger::V8Debugger(v8::Isolate* isolate, V8InspectorImpl* inspector)
     : m_isolate(isolate),
       m_inspector(inspector),
       m_lastContextId(0),
       m_enableCount(0),
       m_breakpointsActivated(true),
       m_runningNestedMessageLoop(false),
       m_ignoreScriptParsedEventsCounter(0),
       m_maxAsyncCallStackDepth(0),
-      m_pauseOnExceptionsState(v8::DebugInterface::NoBreakOnException) {}
+      m_pauseOnExceptionsState(v8::DebugInterface::NoBreakOnException),
+      m_wasmTranslation(isolate, this) {}
 
 V8Debugger::~V8Debugger() {}
 
 void V8Debugger::enable() {
   if (m_enableCount++) return;
   DCHECK(!enabled());
   v8::HandleScope scope(m_isolate);
   v8::DebugInterface::SetDebugEventListener(m_isolate,
                                             &V8Debugger::v8DebugEventCallback,
                                             v8::External::New(m_isolate, this));
   m_debuggerContext.Reset(m_isolate,
                           v8::DebugInterface::GetDebugContext(m_isolate));
   v8::DebugInterface::ChangeBreakOnException(
       m_isolate, v8::DebugInterface::NoBreakOnException);
   m_pauseOnExceptionsState = v8::DebugInterface::NoBreakOnException;
   compileDebuggerScript();
 }
 
 void V8Debugger::disable() {
   if (--m_enableCount) return;
   DCHECK(enabled());
   clearBreakpoints();
   m_debuggerScript.Reset();
   m_debuggerContext.Reset();
   allAsyncTasksCanceled();
+  m_wasmTranslation.Clear();
   v8::DebugInterface::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8Debugger::enabled() const { return !m_debuggerScript.IsEmpty(); }
 
 // static
 int V8Debugger::contextId(v8::Local<v8::Context> context) {
   v8::Local<v8::Value> data =
       context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
   if (data.IsEmpty() || !data->IsString()) return 0;
@@ skipping 472 matching lines @@
 
   if (event == v8::AsyncTaskEvent) {
     v8::HandleScope scope(m_isolate);
     handleV8AsyncTaskEvent(eventContext, eventDetails.GetExecutionState(),
                            eventDetails.GetEventData());
     return;
   }
 
   V8DebuggerAgentImpl* agent =
       m_inspector->enabledDebuggerAgentForGroup(getGroupId(eventContext));
-  if (agent) {
-    v8::HandleScope scope(m_isolate);
-    if (m_ignoreScriptParsedEventsCounter == 0 &&
-        (event == v8::AfterCompile || event == v8::CompileError)) {
-      v8::Local<v8::Context> context = debuggerContext();
-      v8::Context::Scope contextScope(context);
+  if (!agent) return;
+
+  v8::HandleScope scope(m_isolate);
+  if (event == v8::AfterCompile || event == v8::CompileError) {
+    v8::Context::Scope contextScope(debuggerContext());
+    // Determine if the script is a wasm script.
+    v8::Local<v8::Value> scriptMirror =
+        callInternalGetterFunction(eventDetails.GetEventData(), "script");
+    DCHECK(scriptMirror->IsObject());
+    v8::Local<v8::Value> scriptWrapper =
+        callInternalGetterFunction(scriptMirror.As<v8::Object>(), "value");
+    DCHECK(scriptWrapper->IsObject());
+    v8::Local<v8::DebugInterface::Script> script =
+        v8::DebugInterface::Script::Wrap(m_isolate,
+                                         scriptWrapper.As<v8::Object>())
+            .ToLocalChecked();
+    if (script->IsWasm()) {
+      m_wasmTranslation.AddScript(scriptWrapper.As<v8::Object>());
+    } else if (m_ignoreScriptParsedEventsCounter == 0) {
       v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
       v8::Local<v8::Value> value =
           callDebuggerMethod("getAfterCompileScript", 1, argv).ToLocalChecked();
       if (value->IsNull()) return;
       DCHECK(value->IsObject());
       v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(value);
       v8::Local<v8::DebugInterface::Script> script;
       if (!v8::DebugInterface::Script::Wrap(m_isolate, scriptObject)
                .ToLocal(&script))
         return;
       agent->didParseSource(
           wrapUnique(new V8DebuggerScript(m_isolate, script, inLiveEditScope)),
           event == v8::AfterCompile);
-    } else if (event == v8::Exception) {
-      v8::Local<v8::Context> context = debuggerContext();
-      v8::Local<v8::Object> eventData = eventDetails.GetEventData();
-      v8::Local<v8::Value> exception =
-          callInternalGetterFunction(eventData, "exception");
-      v8::Local<v8::Value> promise =
-          callInternalGetterFunction(eventData, "promise");
-      bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
-      v8::Local<v8::Value> uncaught =
-          callInternalGetterFunction(eventData, "uncaught");
-      bool isUncaught = uncaught->BooleanValue(context).FromJust();
-      handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
-                         exception, v8::Local<v8::Array>(), isPromiseRejection,
-                         isUncaught);
-    } else if (event == v8::Break) {
-      v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
-      v8::Local<v8::Value> hitBreakpoints =
-          callDebuggerMethod("getBreakpointNumbers", 1, argv).ToLocalChecked();
-      DCHECK(hitBreakpoints->IsArray());
-      handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
-                         v8::Local<v8::Value>(),
-                         hitBreakpoints.As<v8::Array>());
     }
+  } else if (event == v8::Exception) {
+    v8::Local<v8::Context> context = debuggerContext();
+    v8::Local<v8::Object> eventData = eventDetails.GetEventData();
+    v8::Local<v8::Value> exception =
+        callInternalGetterFunction(eventData, "exception");
+    v8::Local<v8::Value> promise =
+        callInternalGetterFunction(eventData, "promise");
+    bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
+    v8::Local<v8::Value> uncaught =
+        callInternalGetterFunction(eventData, "uncaught");
+    bool isUncaught = uncaught->BooleanValue(context).FromJust();
+    handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
+                       exception, v8::Local<v8::Array>(), isPromiseRejection,
+                       isUncaught);
+  } else if (event == v8::Break) {
+    v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
+    v8::Local<v8::Value> hitBreakpoints =
+        callDebuggerMethod("getBreakpointNumbers", 1, argv).ToLocalChecked();
+    DCHECK(hitBreakpoints->IsArray());
+    handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
+                       v8::Local<v8::Value>(), hitBreakpoints.As<v8::Array>());
   }
 }
 
 void V8Debugger::handleV8AsyncTaskEvent(v8::Local<v8::Context> context,
                                         v8::Local<v8::Object> executionState,
                                         v8::Local<v8::Object> eventData) {
   if (!m_maxAsyncCallStackDepth) return;
 
   String16 type = toProtocolStringWithTypeCheck(
       callInternalGetterFunction(eventData, "type"));
@@ skipping 348 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector