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;
+    frame->asObject()->getNumber("timestamp", &timestamp);
+    return timestamp;

[vsm, 2014/08/13 14:26:45]

Assert this is > 0 to ensure it's actually set?

[Jacob, 2014/08/13 21:36:16]

Done. Assert that timestamp exists. Even though the field is "optional" in the
protocol we are assuming it is always set before we sort.

+}
+
+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 228 matching lines @@
 {
     m_scripts.clear();
     m_breakpointIdToDebugServerBreakpointIds.clear();
     m_asyncCallStackTracker.clear();
     if (m_frontend)
         m_frontend->globalObjectCleared();
 }
 
 } // namespace WebCore