DevTools: Support XHR async call stacks in the debugger.

LayoutTests/http/tests/inspector/debugger-test.js

 var initialize_DebuggerTest = function() {
 
 InspectorTest.startDebuggerTest = function(callback, quiet)
 {
     if (quiet !== undefined)
         InspectorTest._quiet = quiet;
     WebInspector.showPanel("sources");
 
     if (WebInspector.debuggerModel.debuggerEnabled())
         startTest();
@@ skipping 65 matching lines @@
     InspectorTest.evaluateInConsole("setTimeout(testFunction, 0)");
     InspectorTest.addResult("Set timer for test function.");
 };
 
 InspectorTest.runTestFunctionAndWaitUntilPaused = function(callback)
 {
     InspectorTest.runTestFunction();
     InspectorTest.waitUntilPaused(callback);
 };
 
+InspectorTest.runAsyncCallStacksTest = function(totalDebuggerStatements, maxAsyncCallStackDepth)
+{
+    InspectorTest.setQuiet(true);
+    InspectorTest.startDebuggerTest(step1);
+
+    function step1()
+    {
+        DebuggerAgent.setAsyncCallStackDepth(maxAsyncCallStackDepth, step2);
+    }
+
+    function step2()
+    {
+        InspectorTest.runTestFunctionAndWaitUntilPaused(didPaused);
+    }
+
+    var step = 0;
+    var callStacksOutput = [];
+    function didPaused(callFrames, reason, breakpointIds, asyncStackTrace)
+    {
+        ++step;
+        callStacksOutput.push(InspectorTest.captureStackTraceIntoString(callFrames, asyncStackTrace) + "\n");
+        if (step < totalDebuggerStatements) {
+            InspectorTest.resumeExecution(InspectorTest.waitUntilPaused.bind(InspectorTest, didPaused));
+        } else {
+            InspectorTest.addResult("Captured call stacks in no particular order:");
+            callStacksOutput.sort();
+            InspectorTest.addResults(callStacksOutput);
+            InspectorTest.completeDebuggerTest();
+        }
+    }
+};
+
 InspectorTest.waitUntilPausedNextTime = function(callback)
 {
     InspectorTest._waitUntilPausedCallback = InspectorTest.safeWrap(callback);
 };
 
 InspectorTest.waitUntilPaused = function(callback)
 {
     callback = InspectorTest.safeWrap(callback);
 
     if (InspectorTest._pausedScriptArguments)
@@ skipping 19 matching lines @@
 
 InspectorTest.resumeExecution = function(callback)
 {
     if (WebInspector.panels.sources.paused)
         WebInspector.panels.sources._togglePause();
     InspectorTest.waitUntilResumed(callback);
 };
 
 InspectorTest.captureStackTrace = function(callFrames, asyncStackTrace, options)
 {
+    InspectorTest.addResult(InspectorTest.captureStackTraceIntoString(callFrames, asyncStackTrace, options));
+};
+
+InspectorTest.captureStackTraceIntoString = function(callFrames, asyncStackTrace, options)

[yurys, 2013/12/23 12:40:31]

Consider making it private.

[aandrey, 2013/12/23 13:01:29]

I call it directly from the new test.

+{
+    var results = [];
     options = options || {};
 
     function printCallFrames(callFrames)
     {
         for (var i = 0; i < callFrames.length; i++) {
             var frame = callFrames[i];
             var script = WebInspector.debuggerModel.scriptForId(frame.location.scriptId);
             var url;
             var lineNumber;
             if (script) {
                 url = WebInspector.displayNameForURL(script.sourceURL);
                 lineNumber = frame.location.lineNumber + 1;
             } else {
                 url = "(internal script)";
                 lineNumber = "(line number)";
             }
             var s = "    " + i + ") " + frame.functionName + " (" + url + (options.dropLineNumbers ? "" : ":" + lineNumber) + ")";
-            InspectorTest.addResult(s);
+            results.push(s);
             if (options.printReturnValue && frame.returnValue)
-                InspectorTest.addResult("       <return>: " + frame.returnValue.description);
+                results.push("       <return>: " + frame.returnValue.description);
         }
     }
 
-    InspectorTest.addResult("Call stack:");
+    results.push("Call stack:");
     printCallFrames(callFrames);
 
     while (asyncStackTrace) {
-        InspectorTest.addResult("    [" + (asyncStackTrace.description || "Async Call") + "]");
+        results.push("    [" + (asyncStackTrace.description || "Async Call") + "]");
         printCallFrames(asyncStackTrace.callFrames);
-        if (asyncStackTrace.callFrames[0].functionName === "testFunction")
+        if (asyncStackTrace.callFrames.peekLast().functionName === "testFunction")
             break;
         asyncStackTrace = asyncStackTrace.asyncStackTrace;
     }
+    return results.join("\n");
 };
 
 InspectorTest.dumpSourceFrameContents = function(sourceFrame)
 {
     InspectorTest.addResult("==Source frame contents start==");
     var textEditor = sourceFrame._textEditor;
     for (var i = 0; i < textEditor.linesCount; ++i)
         InspectorTest.addResult(textEditor.line(i));
     InspectorTest.addResult("==Source frame contents end==");
 };
@@ skipping 171 matching lines @@
 
 InspectorTest.checkUILocation = function(uiSourceCode, lineNumber, columnNumber, location)
 {
     InspectorTest.assertEquals(uiSourceCode, location.uiSourceCode, "Incorrect uiSourceCode, expected '" + (uiSourceCode ? uiSourceCode.originURL() : null) + "'," +
                                                                     " but got '" + (location.uiSourceCode ? location.uiSourceCode.originURL() : null) + "'");
     InspectorTest.assertEquals(lineNumber, location.lineNumber, "Incorrect lineNumber, expected '" + lineNumber + "', but got '" + location.lineNumber + "'");
     InspectorTest.assertEquals(columnNumber, location.columnNumber, "Incorrect columnNumber, expected '" + columnNumber + "', but got '" + location.columnNumber + "'");
 };
 
 };