DevTools: Support asynchronous call stacks on backend.

Source/bindings/v8/ScriptDebugServer.cpp

 /*
  * Copyright (c) 2010-2011 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 183 matching lines @@
         templ->SetCallHandler(&ScriptDebugServer::breakProgramCallback, v8::External::New(this));
         m_breakProgramCallbackTemplate.set(m_isolate, templ);
     }
 
     m_pausedContext = m_isolate->GetCurrentContext();
     v8::Handle<v8::Function> breakProgramFunction = m_breakProgramCallbackTemplate.newLocal(m_isolate)->GetFunction();
     v8::Debug::Call(breakProgramFunction);
     m_pausedContext.Clear();
 }
 
+bool ScriptDebugServer::requestAsyncCallFrames()
+{
+    if (isPaused()) {
+        ScriptDebugListener* listener = getDebugListenerForContext(m_pausedContext);
+        ASSERT(listener);
+        if (!listener)
+            return false;
+        listener->didRequestAsyncCallFrames(currentCallFrame());
+        return true;
+    }
+
+    v8::HandleScope scope(m_isolate);

[loislo, 2013/11/20 01:39:18]

it is not clear for me why do you need this async part.
If I understand things properly the debugger agent will get a call when the code

will setTimeout so you will be able to catch the stack the same way as timeline
does that.

[aandrey, 2013/11/20 15:20:02]

There are two kind of stacks: console stack (Console.CallFrame in protocol.json)
and debugger stack (Debugger.CallFrame).

Timeline catches the console stack, while I need the debugger stack.

+    if (m_asyncCallFramesCallbackTemplate.isEmpty()) {
+        v8::Handle<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
+        templ->SetCallHandler(&ScriptDebugServer::asyncCallFramesCallback, v8::External::New(this));
+        m_asyncCallFramesCallbackTemplate.set(m_isolate, templ);
+    }
+
+    v8::Handle<v8::Function> asyncCallFramesFunction = m_asyncCallFramesCallbackTemplate.newLocal(m_isolate)->GetFunction();
+    v8::Debug::Call(asyncCallFramesFunction);
+    return true;
+}
+
 void ScriptDebugServer::continueProgram()
 {
     if (isPaused())
         quitMessageLoopOnPause();
     m_executionState.clear();
 }
 
 void ScriptDebugServer::stepIntoStatement()
 {
     ASSERT(isPaused());
@@ skipping 114 matching lines @@
 
     ASSERT(!currentCallFrameV8.IsEmpty());
     if (!currentCallFrameV8->IsObject())
         return PassRefPtr<JavaScriptCallFrame>();
     return JavaScriptCallFrame::create(v8::Debug::GetDebugContext(), v8::Handle<v8::Object>::Cast(currentCallFrameV8));
 }
 
 ScriptValue ScriptDebugServer::currentCallFrame()
 {
     ASSERT(isPaused());
+    return currentCallFrame(m_executionState.newLocal(m_isolate), m_pausedContext);
+}
+
+ScriptValue ScriptDebugServer::currentCallFrame(v8::Handle<v8::Object> executionState, v8::Handle<v8::Context> pausedContext)
+{
     v8::HandleScope handleScope(m_isolate);
-    RefPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames(m_executionState.newLocal(m_isolate), -1);
+    RefPtr<JavaScriptCallFrame> currentCallFrame = wrapCallFrames(executionState, -1);
     if (!currentCallFrame)
         return ScriptValue(v8::Null(m_isolate), m_isolate);
-    v8::Context::Scope contextScope(m_pausedContext);
-    return ScriptValue(toV8(currentCallFrame.release(), v8::Handle<v8::Object>(), m_pausedContext->GetIsolate()), m_pausedContext->GetIsolate());
+    v8::Context::Scope contextScope(pausedContext);
+    return ScriptValue(toV8(currentCallFrame.release(), v8::Handle<v8::Object>(), pausedContext->GetIsolate()), pausedContext->GetIsolate());
 }
 
 void ScriptDebugServer::interruptAndRun(PassOwnPtr<Task> task, v8::Isolate* isolate)
 {
     v8::Debug::DebugBreakForCommand(new ClientDataImpl(task), isolate);
 }
 
 void ScriptDebugServer::runPendingTasks()
 {
     v8::Debug::ProcessDebugMessages();
 }
 
 static ScriptDebugServer* toScriptDebugServer(v8::Handle<v8::Value> data)
 {
     void* p = v8::Handle<v8::External>::Cast(data)->Value();
     return static_cast<ScriptDebugServer*>(p);
 }
 
+void ScriptDebugServer::asyncCallFramesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ASSERT(2 == info.Length());
+    ScriptDebugServer* thisPtr = toScriptDebugServer(info.Data());
+    thisPtr->handleAsyncCallFrames(v8::Handle<v8::Object>::Cast(info[0]));
+}
+
+void ScriptDebugServer::handleAsyncCallFrames(v8::Handle<v8::Object> executionState)
+{
+    if (m_isolate->GetCurrentContext().IsEmpty())
+        return;
+    ScriptDebugListener* listener = getDebugListenerForContext(m_isolate->GetCurrentContext());
+    if (!listener)
+        return;
+    if (isPaused())
+        listener->didRequestAsyncCallFrames(currentCallFrame());
+    else
+        listener->didRequestAsyncCallFrames(currentCallFrame(executionState, m_isolate->GetCurrentContext()));
+}
+
 void ScriptDebugServer::breakProgramCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     ASSERT(2 == info.Length());
-
     ScriptDebugServer* thisPtr = toScriptDebugServer(info.Data());
     v8::Handle<v8::Value> exception;
     v8::Handle<v8::Array> hitBreakpoints;
     thisPtr->handleProgramBreak(v8::Handle<v8::Object>::Cast(info[0]), exception, hitBreakpoints);
 }
 
 void ScriptDebugServer::handleProgramBreak(v8::Handle<v8::Object> executionState, v8::Handle<v8::Value> exception, v8::Handle<v8::Array> hitBreakpointNumbers)
 {
     // Don't allow nested breaks.
     if (isPaused())
@@ skipping 240 matching lines @@
 {
     return PassOwnPtr<ScriptSourceCode>();
 }
 
 String ScriptDebugServer::preprocessEventListener(Frame*, const String& source, const String& url, const String& functionName)
 {
     return source;
 }
 
 } // namespace WebCore