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 967 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());
     }
 }
 
+double lookupTimestamp(PassRefPtr<CallFrame> frame)
+{
+    double timestamp = 0;
+    bool ALLOW_UNUSED hasTimestamp = frame->asObject()->getNumber("timestamp", &timestamp);
+    ASSERT(hasTimestamp);
+    return timestamp;
+}
+
+static inline bool compareCallFrameTimestamps(PassRefPtr<CallFrame> frame1, PassRefPtr<CallFrame> frame2)
+{
+    return lookupTimestamp(frame1) > lookupTimestamp(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> > mergeStackTraces(PassRefPtr<Array<CallFrame> > trace1, PassRefPtr<Array<CallFrame> > trace2)
+{
+    Vector<RefPtr<CallFrame> > mergedFrames;
+    addFramesToVector(trace1, mergedFrames);
+    addFramesToVector(trace2, mergedFrames);
+    std::stable_sort(mergedFrames.begin(), mergedFrames.end(), compareCallFrameTimestamps);
+
+    RefPtr<Array<CallFrame> > ret = Array<CallFrame>::create();
+    for (size_t i = 0; i < mergedFrames.size(); ++i)
+        ret->addItem(mergedFrames[i]);
+    return ret;
+}
+
 PassRefPtr<Array<CallFrame> > InspectorDebuggerAgent::currentCallFrames()
 {
     if (!m_pausedScriptState || m_currentCallStack.isNull())
         return Array<TypeBuilder::Debugger::CallFrame>::create();
+    if (m_currentCallStack.isMixedLanguageStackTrace()) {
+        return mergeStackTraces(
+            m_injectedScriptManager->injectedScriptFor(m_currentCallStack.dartScriptState()).wrapCallFrames(m_currentCallStack, 0),
+            // 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.
+            m_injectedScriptManager->injectedScriptFor(m_currentCallStack.v8ScriptState()).wrapCallFrames(m_currentCallStack, m_pausedScriptState->isJavaScript() ? 0 : -1));
+    }
+
     InjectedScript& injectedScript = m_injectedScriptManager->injectedScriptFor(m_pausedScriptState.get());
     if (injectedScript.isEmpty()) {
         ASSERT_NOT_REACHED();
         return Array<CallFrame>::create();
     }
     return injectedScript.wrapCallFrames(m_currentCallStack, 0);
 }
 
 PassRefPtr<WebCore::TypeBuilder::Debugger::StackTrace> InspectorDebuggerAgent::currentAsyncStackTrace()
 {
@@ skipping 89 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 StackTrace& 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 117 matching lines @@
 {
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace WebCore