Support merged Dart-JS callstacks

Source/bindings/dart/DartScriptDebugServer.cpp

 /*
  * Copyright (C) 2014 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 443 matching lines @@
             return it->value;
     }
     return "";
 }
 
 DartScriptDebugServer::DartScriptDebugServer()
     : m_pauseOnExceptionState(DontPauseOnExceptions)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
     , m_executionState(0)
+    , m_isPaused(false)
     , m_pausedIsolate(0)
     , m_pausedPage(0)
     , m_clientMessageLoop(0)
     , m_nextPageId(1)
 {
 }
 
 DartScriptDebugServer::~DartScriptDebugServer()
 {
     for (DebugDataMap::iterator it = m_pageIdToDebugDataMap.begin(); it != m_pageIdToDebugDataMap.end(); ++it)
@@ skipping 152 matching lines @@
         return;
 
     // FIXME: determine if this method needs to be implemented for Dart.
 }
 
 void DartScriptDebugServer::continueProgram()
 {
     if (isPaused())
         quitMessageLoopOnPause();
     m_executionState = 0;
+    m_isPaused = false;
     m_pausedIsolate = 0;
 }
 
 void DartScriptDebugServer::stepIntoStatement()
 {
     ASSERT(isPaused());
     Dart_SetStepInto();
     continueProgram();
 }
 
 void DartScriptDebugServer::stepOverStatement()
 {
     ASSERT(isPaused());
     Dart_SetStepOver();
     continueProgram();
 }
 
 void DartScriptDebugServer::stepOutOfFunction()
 {
     ASSERT(isPaused());
     Dart_SetStepOut();
     continueProgram();
 }
 
-bool DartScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, StackTrace* newCallFrames, RefPtr<JSONObject>* result)
+bool DartScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorData, StackTraces* newCallFrames, RefPtr<JSONObject>* result)
 {
     *error = "Dart does not support live editing source code yet.";
     return false;
 }
 
 bool DartScriptDebugServer::executeSkipPauseRequest(ScriptDebugListener::SkipPauseRequest request, Dart_StackTrace stackTrace)
 {
     switch (request) {
     case ScriptDebugListener::NoSkip:
         return false;
     case ScriptDebugListener::Continue:
         return true;
     case ScriptDebugListener::StepInto:
     case ScriptDebugListener::StepOut:
         break;
     }
     ASSERT(0);
     // FIXMEDART: actually do something jacobr JACOBR
     return true;
 }
 
 int DartScriptDebugServer::frameCount()
 {
     ASSERT(isPaused());
     intptr_t length = 0;
     Dart_StackTraceLength(m_executionState, &length);
     return length;
 }
 
-StackTrace DartScriptDebugServer::currentCallFrames()
+StackTraces DartScriptDebugServer::currentCallFrames()
 {
-    return StackTrace(m_executionState);
+    if (!m_executionState) {
+        if (!Dart_CurrentIsolate())
+            return StackTraces();
+        ASSERT(!m_isPaused);
+        // We are not paused at a Dart breakpoint but there may be Dart frames
+        // on the call stack.
+
+        Dart_Handle ALLOW_UNUSED result = Dart_GetStackTrace(&m_executionState);
+        ASSERT(!Dart_IsError(result));
+        if (!m_executionState)
+            return StackTraces();
+        intptr_t length = 0;
+        Dart_StackTraceLength(m_executionState, &length);
+        if (!length) {
+            ASSERT_NOT_REACHED();
+            m_executionState = 0;
+            return StackTraces();
+        }
+    }
+    return StackTraces(StackTrace(m_executionState), DartUtilities::currentScriptState());
 }
 
-StackTrace DartScriptDebugServer::currentCallFramesForAsyncStack()
+StackTraces DartScriptDebugServer::currentCallFramesForAsyncStack()
 {
     // FIXMEDART: implement propertly. These are the regular not Async call frames.
-    return StackTrace(m_executionState);
+    return currentCallFrames();
 }
 
 bool DartScriptDebugServer::isPaused()
 {
-    return !!m_executionState;
+    return m_isPaused;
 }
 
 void DartScriptDebugServer::clearCompiledScripts()
 {
     // FIXMEDART: is this meaningful for Dart?
     // Currently tracking what scripts have been compiled is handled by a
     // different class.
 }
 
 void DartScriptDebugServer::setPreprocessorSource(const String& preprocessorSource)
@@ skipping 240 matching lines @@
 
 DartPageDebug* DartScriptDebugServer::lookupPageDebugForCurrentIsolate()
 {
     Page* page = DartUtilities::domWindowForCurrentIsolate()->document()->page();
     return lookupPageDebug(page);
 }
 
 void DartScriptDebugServer::handleProgramBreak(Dart_Isolate isolate, Dart_StackTrace stackTrace, intptr_t dartBreakpointId, Dart_Handle exception, const Dart_CodeLocation& location)
 {
     ASSERT(isolate == Dart_CurrentIsolate());
+
     // Don't allow nested breaks.
     if (isAnyScriptPaused())
         return;
 
     DartPageDebug* pageDebug = lookupPageDebugForCurrentIsolate();
     if (!pageDebug)
         return;
     ScriptDebugListener* listener = pageDebug->listener();
 
     if (!listener)
         return;
 
     // Required as some Dart code executes outside of a valid V8 scope when
     // the program is paused due to interrupting a Dart isolate.
     V8Scope v8Scope(DartDOMData::current());
 
     Vector<String> breakpointIds;
     breakpointIds.append(pageDebug->lookupBreakpointId(dartBreakpointId));
     m_executionState = stackTrace;
+    m_isPaused = true;
     m_pausedIsolate = isolate;
     DartScriptState* scriptState = DartUtilities::currentScriptState();
-    ScriptDebugListener::SkipPauseRequest result = listener->didPause(scriptState, currentCallFrames(), exception ? DartUtilities::dartToScriptValue(exception) : ScriptValue(), breakpointIds);
+    ScriptDebugListener::SkipPauseRequest result = listener->didPause(scriptState, exception ? DartUtilities::dartToScriptValue(exception) : ScriptValue(), breakpointIds);
 
     if (result == ScriptDebugListener::NoSkip) {
         m_runningNestedMessageLoop = true;
         runMessageLoopOnPause(isolate);
         m_runningNestedMessageLoop = false;
     }
     if (result == ScriptDebugListener::StepInto) {
         Dart_SetStepInto();
     } else if (result == ScriptDebugListener::StepOut) {
         Dart_SetStepOut();
@@ skipping 158 matching lines @@
 }
 
 void UnifiedScriptDebugServer::setPauseOnExceptionsState(ScriptDebugServer::PauseOnExceptionsState pauseOnExceptionsState)
 {
     m_dart->setPauseOnExceptionsState(pauseOnExceptionsState);
     m_v8->setPauseOnExceptionsState(pauseOnExceptionsState);
 }
 
 void UnifiedScriptDebugServer::setPauseOnNextStatement(bool pause)
 {
-    if (isPaused()) {
+    if (isPaused())
         return;
-    }
     m_v8->setPauseOnNextStatement(pause);
     m_dart->setPauseOnNextStatement(pause);
 }
 
 bool UnifiedScriptDebugServer::canBreakProgram()
 {
     return m_v8->canBreakProgram() || m_dart->canBreakProgram();
 }
 
 void UnifiedScriptDebugServer::breakProgram()
@@ skipping 39 matching lines @@
     // FIXMEDART: find a cleaner solution.
     return sourceID.startsWith(String("{\"dartScript"));
 }
 
 bool UnifiedScriptDebugServer::isDartBreakpointId(const String& breakpointId)
 {
     // FIXMEDART: find a cleaner solution.
     return breakpointId.startsWith(String("{\"dartBreakpoint"));
 }
 
-bool UnifiedScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorBuilder, StackTrace* newCallFrames, RefPtr<JSONObject>* result)
+bool UnifiedScriptDebugServer::setScriptSource(const String& sourceID, const String& newContent, bool preview, String* error, RefPtr<TypeBuilder::Debugger::SetScriptSourceError>& errorBuilder, StackTraces* newCallFrames, RefPtr<JSONObject>* result)
 {
     if (isDartSourceID(sourceID))
         return m_dart->setScriptSource(sourceID, newContent, preview, error, errorBuilder, newCallFrames, result);
     return m_v8->setScriptSource(sourceID, newContent, preview, error, errorBuilder, newCallFrames, result);
 }
 
 int UnifiedScriptDebugServer::frameCount()
 {
     // FIXMEDART: Implement cases where both JS and Dart are paused correctly.
     if (m_v8->isPaused()) {
         return m_v8->frameCount();
     }
     return m_dart->frameCount();
 }
 
-
-StackTrace UnifiedScriptDebugServer::currentCallFrames()
+StackTraces UnifiedScriptDebugServer::currentCallFrames()
 {
-    // FIXMEDART: we need to figure out how to interleave stack traces where possible.
-    StackTrace v8StackTrace = m_v8->currentCallFrames();
-    if (!v8StackTrace.isNull())
-        return v8StackTrace;
-    return m_dart->currentCallFrames();
+    StackTraces traces = m_v8->currentCallFrames();
+    traces.add(m_dart->currentCallFrames());
+    return traces;
 }
 
-StackTrace UnifiedScriptDebugServer::currentCallFramesForAsyncStack()
+StackTraces UnifiedScriptDebugServer::currentCallFramesForAsyncStack()
 {
-    // FIXMEDART: we need to figure out how to interleave stack traces where possible.
-    StackTrace v8StackTrace = m_v8->currentCallFramesForAsyncStack();
-    if (!v8StackTrace.isNull())
-        return v8StackTrace;
-    return m_dart->currentCallFramesForAsyncStack();
+    StackTraces traces = m_v8->currentCallFramesForAsyncStack();
+    traces.add(m_dart->currentCallFramesForAsyncStack());
+    return traces;
 }
 
-
 bool UnifiedScriptDebugServer::isPaused()
 {
     return m_v8->isPaused() || m_dart->isPaused();
 }
 
 bool UnifiedScriptDebugServer::runningNestedMessageLoop()
 {
     return m_dart->runningNestedMessageLoop() || m_v8->runningNestedMessageLoop();
 }
 
@@ skipping 64 matching lines @@
     MessageQueue<ScriptDebugServer::Task>& tasks = debugTaskQueue();
     tasks.append(task);
     // The first VM interrupt method triggered will drain the task queue.
     // FIXMEDART: refactor the V8 code to have an interruptAndRunAllTasks
     // method.
     PageScriptDebugServer::interruptAndRun(adoptPtr(new DrainQueueTask(&tasks)));
     DartScriptDebugServer::interruptAndRunAllTasks();
 }
 
 }