Support merged Dart-JS callstacks

Source/core/inspector/InspectorDebuggerAgent.cpp

 /*
  * Copyright (C) 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 29 matching lines @@
 #include "core/fetch/Resource.h"
 #include "core/inspector/ContentSearchUtils.h"
 #include "core/inspector/InjectedScriptManager.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/inspector/ScriptArguments.h"
 #include "core/inspector/ScriptCallFrame.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "platform/JSONValues.h"
+#include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 using WebCore::TypeBuilder::Array;
 using WebCore::TypeBuilder::Debugger::BreakpointId;
 using WebCore::TypeBuilder::Debugger::CallFrame;
 using WebCore::TypeBuilder::Debugger::ExceptionDetails;
 using WebCore::TypeBuilder::Debugger::FunctionDetails;
 using WebCore::TypeBuilder::Debugger::ScriptId;
 using WebCore::TypeBuilder::Debugger::StackTrace;
 using WebCore::TypeBuilder::Runtime::RemoteObject;
@@ skipping 386 matching lines @@
     if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
-    injectedScript.getStepInPositions(errorString, m_currentCallStack, callFrameId, positions);
+    injectedScript.getStepInPositions(errorString, m_currentCallStack.lookup(injectedScript.scriptState()), callFrameId, positions);
 }
 
 void InspectorDebuggerAgent::getBacktrace(ErrorString* errorString, RefPtr<Array<CallFrame> >& callFrames, WTF::RefPtr<WebCore::TypeBuilder::Debugger::StackTrace>& asyncStackTrace)
 {
     if (!assertPaused(errorString))
         return;
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     callFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
@@ skipping 137 matching lines @@
     if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
-    injectedScript.restartFrame(errorString, m_currentCallStack, callFrameId, &result);
+    injectedScript.restartFrame(errorString, m_currentCallStack.lookup(injectedScript.scriptState()), callFrameId, &result);
     m_currentCallStack = scriptDebugServer().currentCallFrames();
     newCallFrames = currentCallFrames();
     asyncStackTrace = currentAsyncStackTrace();
 }
 
 void InspectorDebuggerAgent::getScriptSource(ErrorString* error, const String& scriptId, String* scriptSource)
 {
     ScriptsMap::iterator it = m_scripts.find(scriptId);
     if (it != m_scripts.end())
         *scriptSource = it->value.source;
@@ skipping 201 matching lines @@
 
 void InspectorDebuggerAgent::setPauseOnExceptionsImpl(ErrorString* errorString, int pauseState)
 {
     scriptDebugServer().setPauseOnExceptionsState(static_cast<ScriptDebugServer::PauseOnExceptionsState>(pauseState));
     if (scriptDebugServer().pauseOnExceptionsState() != pauseState)
         *errorString = "Internal error. Could not change pause on exceptions state";
     else
         m_state->setLong(DebuggerAgentState::pauseOnExceptionsState, pauseState);
 }
 
-void InspectorDebuggerAgent::collectAsyncCallStacks(Vector<StackTrace>& asyncCallStacks)
+void InspectorDebuggerAgent::collectAsyncCallStacks(Vector<StackTrace>& asyncCallStacks, ScriptState* scriptState)
 {
     const AsyncCallStackTracker::AsyncCallChain* asyncChain = m_asyncCallStackTracker.isEnabled() ? m_asyncCallStackTracker.currentAsyncCallChain() : 0;
     if (asyncChain) {
         const AsyncCallStackTracker::AsyncCallStackVector& callStacks = asyncChain->callStacks();
         asyncCallStacks.resize(callStacks.size());
         AsyncCallStackTracker::AsyncCallStackVector::const_iterator it = callStacks.begin();
         for (size_t i = 0; it != callStacks.end(); ++it, ++i)
-            asyncCallStacks[i] = (*it)->callFrames();
+            asyncCallStacks[i] = (*it)->callFrames().lookup(scriptState);
     }
 }
 
 void InspectorDebuggerAgent::evaluateOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, const String* const objectGroup, const bool* const includeCommandLineAPI, const bool* const doNotPauseOnExceptionsAndMuteConsole, const bool* const returnByValue, const bool* generatePreview, RefPtr<RemoteObject>& result, TypeBuilder::OptOutput<bool>* wasThrown)
 {
     if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (doNotPauseOnExceptionsAndMuteConsole ? *doNotPauseOnExceptionsAndMuteConsole : false) {
         if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
             scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
         muteConsole();
     }
 
     Vector<StackTrace> asyncCallStacks;
-    collectAsyncCallStacks(asyncCallStacks);
-    injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", includeCommandLineAPI ? *includeCommandLineAPI : false, returnByValue ? *returnByValue : false, generatePreview ? *generatePreview : false, &result, wasThrown);
+    collectAsyncCallStacks(asyncCallStacks, injectedScript.scriptState());
+    injectedScript.evaluateOnCallFrame(errorString, m_currentCallStack.lookup(injectedScript.scriptState()), asyncCallStacks, callFrameId, expression, objectGroup ? *objectGroup : "", includeCommandLineAPI ? *includeCommandLineAPI : false, returnByValue ? *returnByValue : false, generatePreview ? *generatePreview : false, &result, wasThrown);
 
     if (doNotPauseOnExceptionsAndMuteConsole ? *doNotPauseOnExceptionsAndMuteConsole : false) {
         unmuteConsole();
         if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
             scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
     }
 }
 
 void InspectorDebuggerAgent::getCompletionsOnCallFrame(ErrorString* errorString, const String& callFrameId, const String& expression, RefPtr<TypeBuilder::Array<String> >& result)
 {
     if (!isPaused() || m_currentCallStack.isNull()) {
         *errorString = "Attempt to access callframe when debugger is not on pause";
         return;
     }
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptForObjectId(callFrameId);
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
 
     ScriptDebugServer::PauseOnExceptionsState previousPauseOnExceptionsState = scriptDebugServer().pauseOnExceptionsState();
     if (previousPauseOnExceptionsState != ScriptDebugServer::DontPauseOnExceptions)
         scriptDebugServer().setPauseOnExceptionsState(ScriptDebugServer::DontPauseOnExceptions);
     muteConsole();
 
     Vector<StackTrace> asyncCallStacks;
-    collectAsyncCallStacks(asyncCallStacks);
-    injectedScript.getCompletionsOnCallFrame(errorString, m_currentCallStack, asyncCallStacks, callFrameId, expression, &result);
+    collectAsyncCallStacks(asyncCallStacks, injectedScript.scriptState());
+    injectedScript.getCompletionsOnCallFrame(errorString, m_currentCallStack.lookup(injectedScript.scriptState()), asyncCallStacks, callFrameId, expression, &result);
 
     unmuteConsole();
     if (scriptDebugServer().pauseOnExceptionsState() != previousPauseOnExceptionsState)
         scriptDebugServer().setPauseOnExceptionsState(previousPauseOnExceptionsState);
 }
 
 void InspectorDebuggerAgent::compileScript(ErrorString* errorString, const String& expression, const String& sourceURL, const int* executionContextId, TypeBuilder::OptOutput<ScriptId>* scriptId, RefPtr<ExceptionDetails>& exceptionDetails)
 {
     InjectedScript& injectedScript = injectedScriptForEval(errorString, executionContextId);
     if (injectedScript.isEmpty()) {
@@ skipping 86 matching lines @@
         if (injectedScript->isEmpty()) {
             *errorString = "Function object id cannot be resolved";
             return;
         }
     } else {
         *errorString = "Either call frame or function object must be specified";
         return;
     }
     String newValueString = newValue->toJSONString();
     ASSERT(injectedScript);
-    injectedScript->setVariableValue(errorString, m_currentCallStack, callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
+    injectedScript->setVariableValue(errorString, m_currentCallStack.lookup(injectedScript->scriptState()), callFrameId, functionObjectId, scopeNumber, variableName, newValueString);
 }
 
 void InspectorDebuggerAgent::skipStackFrames(ErrorString* errorString, const String* pattern)
 {
     OwnPtr<ScriptRegexp> compiled;
     String patternValue = pattern ? *pattern : "";
     if (!patternValue.isEmpty()) {
         compiled = compileSkipCallFramePattern(patternValue);
         if (!compiled) {
             *errorString = "Invalid regular expression";
@@ skipping 12 matching lines @@
 
 void InspectorDebuggerAgent::scriptExecutionBlockedByCSP(const String& directiveText)
 {
     if (scriptDebugServer().pauseOnExceptionsState() != ScriptDebugServer::DontPauseOnExceptions) {
         RefPtr<JSONObject> directive = JSONObject::create();
         directive->setString("directiveText", directiveText);
         breakProgram(InspectorFrontend::Debugger::Reason::CSPViolation, directive.release());
     }
 }
 
+uint32_t lookupFramePointerHigh(PassRefPtr<CallFrame> frame)
+{
+    double framePointerHigh = 0;
+    bool ALLOW_UNUSED hasFramePointerHigh = frame->asObject()->getNumber("framePointerHigh", &framePointerHigh);
+    ASSERT(hasFramePointerHigh);
+    return static_cast<uint32_t>(framePointerHigh);
+}
+
+uint32_t lookupFramePointerLow(PassRefPtr<CallFrame> frame)
+{
+    double framePointerLow = 0;
+    bool ALLOW_UNUSED hasFramePointerLow = frame->asObject()->getNumber("framePointerLow", &framePointerLow);
+    ASSERT(hasFramePointerLow);
+    return static_cast<uint32_t>(framePointerLow);
+}
+
+static inline bool compareCallFramePointers(RefPtr<CallFrame> frame1, RefPtr<CallFrame> frame2)
+{
+    uint32_t highFrame1 = lookupFramePointerHigh(frame1);
+    uint32_t highFrame2 = lookupFramePointerHigh(frame2);
+    if (highFrame1 != highFrame2)
+        return highFrame1 < highFrame2;
+
+    return lookupFramePointerLow(frame1) < lookupFramePointerLow(frame2);
+}
+
+void addFramesToVector(PassRefPtr<Array<CallFrame> > trace, Vector<RefPtr<CallFrame> > & v)
+{
+    RefPtr<JSONArray> traceArray = trace->asArray();
+    for (JSONArray::iterator it = traceArray->begin(); it != traceArray->end(); ++it) {
+        v.append(CallFrame::runtimeCast(*it));
+    }
+}
+
 PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::currentCallFrames()
 {
+    return callFrames(m_currentCallStack, 0);
+}
+
+PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::callFrames(StackTraces stackTraces, int asyncOrdinal)
+{
     if (!m_pausedScriptState || m_currentCallStack.isNull())
         return Array<TypeBuilder::Debugger::CallFrame>::create();
-    InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
-    if (injectedScript.isEmpty()) {
-        ASSERT_NOT_REACHED();
-        return Array<CallFrame>::create();
+
+    Vector<RefPtr<CallFrame> > mergedFrames;
+    for (StackTraces::iterator it = m_currentCallStack.begin(); it != m_currentCallStack.end(); ++it) {
+        ScriptState* scriptState = it->key;
+        StackTrace& stackTrace = it->value;
+        // FIXMEDART: passing in -1 as hack to force AsyncStack mode
+        // evaluation as V8 cannot handle regular evaluation of a call
+        // frame if not stopped at a v8 breakpoint due to an assert
+        // in the V8 code base that should probably be removed.
+        // Async call frame evaluation works almost as well as regular
+        // call frame evaluation with the only difference being that
+        // local variable modifications have no impact.
+        if (asyncOrdinal == 0 && m_pausedScriptState != scriptState) {
+            asyncOrdinal = -1;
+        }
+        addFramesToVector(m_injectedScriptManager->injectedScriptFor(scriptState).wrapCallFrames(stackTrace, asyncOrdinal), mergedFrames);
     }
-    return injectedScript.wrapCallFrames(m_currentCallStack, 0);
+    std::stable_sort(mergedFrames.begin(), mergedFrames.end(), compareCallFramePointers);
+
+    RefPtr<Array<CallFrame> > ret = Array<CallFrame>::create();
+    for (size_t i = 0; i < mergedFrames.size(); ++i)
+        ret->addItem(mergedFrames[i]);
+    return ret;
 }
 
 PassRefPtr<WebCore::TypeBuilder::Debugger::StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
 {
     if (!m_pausedScriptState || !m_asyncCallStackTracker.isEnabled())
         return nullptr;
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
     if (injectedScript.isEmpty()) {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
     const AsyncCallStackTracker::AsyncCallChain* chain = m_asyncCallStackTracker.currentAsyncCallChain();
     if (!chain)
         return nullptr;
     const AsyncCallStackTracker::AsyncCallStackVector& callStacks = chain->callStacks();
     if (callStacks.isEmpty())
         return nullptr;
     RefPtr<WebCore::TypeBuilder::Debugger::StackTrace> result;
     int asyncOrdinal = callStacks.size();
     for (AsyncCallStackTracker::AsyncCallStackVector::const_reverse_iterator it = callStacks.rbegin(); it != callStacks.rend(); ++it) {
         RefPtr<WebCore::TypeBuilder::Debugger::StackTrace> next = WebCore::TypeBuilder::Debugger::StackTrace::create()
-            .setCallFrames(injectedScript.wrapCallFrames((*it)->callFrames(), asyncOrdinal--))
+            .setCallFrames(callFrames((*it)->callFrames(), asyncOrdinal--))
             .release();
         next->setDescription((*it)->description());
         if (result)
             next->setAsyncStackTrace(result.release());
         result.swap(next);
     }
     return result.release();
 }
 
 String InspectorDebuggerAgent::sourceMapURLForScript(const Script& script)
@@ skipping 61 matching lines @@
         if (location)
             m_frontend->breakpointResolved(it->key, location);
     }
 }
 
 void InspectorDebuggerAgent::failedToParseSource(const String& url, const String& data, int firstLine, int errorLine, const String& errorMessage)
 {
     m_frontend->scriptFailedToParse(url, data, firstLine, errorLine, errorMessage);
 }
 
-ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::didPause(ScriptState* scriptState, const StackTrace& callFrames, const ScriptValue& exception, const Vector<String>& hitBreakpoints)
+ScriptDebugListener::SkipPauseRequest InspectorDebuggerAgent::didPause(ScriptState* scriptState, const ScriptValue& exception, const Vector<String>& hitBreakpoints)
 {
+    const StackTraces& callFrames = scriptDebugServer().currentCallFrames();
     ScriptDebugListener::SkipPauseRequest result;
     if (m_javaScriptPauseScheduled)
         result = ScriptDebugListener::NoSkip; // Don't skip explicit pause requests from front-end.
     else if (m_skipAllPauses)
         result = ScriptDebugListener::Continue;
     else if (!hitBreakpoints.isEmpty())
         result = ScriptDebugListener::NoSkip; // Don't skip explicit breakpoints even if set in frameworks.
     else if (!exception.isEmpty())
         result = shouldSkipExceptionPause();
     else if (m_debuggerStepScheduled || m_pausingOnNativeEvent)
@@ skipping 42 matching lines @@
         m_continueToLocationBreakpointId = "";
     }
     if (m_listener)
         m_listener->didPause();
     return result;
 }
 
 void InspectorDebuggerAgent::didContinue()
 {
     m_pausedScriptState = nullptr;
-    m_currentCallStack = StackTrace();
+    m_currentCallStack = StackTraces();
     clearBreakDetails();
     m_frontend->resumed();
 }
 
 bool InspectorDebuggerAgent::canBreakProgram()
 {
     return scriptDebugServer().canBreakProgram();
 }
 
 void InspectorDebuggerAgent::breakProgram(InspectorFrontend::Debugger::Reason::Enum breakReason, PassRefPtr<JSONObject> data)
 {
     if (m_skipAllPauses)
         return;
     m_breakReason = breakReason;
     m_breakAuxData = data;
     m_debuggerStepScheduled = false;
     m_pausingOnNativeEvent = false;
     scriptDebugServer().breakProgram();
 }
 
 void InspectorDebuggerAgent::clear()
 {
     m_pausedScriptState = nullptr;
-    m_currentCallStack = StackTrace();
+    m_currentCallStack = StackTraces();
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     m_continueToLocationBreakpointId = String();
     clearBreakDetails();
     m_javaScriptPauseScheduled = false;
     m_debuggerStepScheduled = false;
     m_pausingOnNativeEvent = false;
     ErrorString error;
     setOverlayMessage(&error, 0);
@@ skipping 30 matching lines @@
 {
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace WebCore