DevTools: Show asynchronous call stacks on frontend.

Source/devtools/front_end/DebuggerModel.js

 /*
  * Copyright (C) 2010 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 18 matching lines @@
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
  */
 WebInspector.DebuggerModel = function()
 {
     InspectorBackend.registerDebuggerDispatcher(new WebInspector.DebuggerDispatcher(this));
 
+    /** @type {?WebInspector.DebuggerPausedDetails} */
     this._debuggerPausedDetails = null;
-    /**
-     * @type {!Object.<string, !WebInspector.Script>}
-     */
+    /** @type {!Object.<string, !WebInspector.Script>} */
     this._scripts = {};
     /** @type {!Object.<!string, !Array.<!WebInspector.Script>>} */
     this._scriptsBySourceURL = {};
 
     this._canSetScriptSource = false;
     this._breakpointsActive = true;
 
     WebInspector.settings.pauseOnExceptionStateString = WebInspector.settings.createSetting("pauseOnExceptionStateString", WebInspector.DebuggerModel.PauseOnExceptionsState.DontPauseOnExceptions);
     WebInspector.settings.pauseOnExceptionStateString.addChangeListener(this._pauseOnExceptionStateChanged, this);
 
+    WebInspector.settings.enableAsyncStackTraces.addChangeListener(this._asyncStackTracesStateChanged, this);
+    WebInspector.settings.maxAsyncStackTraceDepth.addChangeListener(this._asyncStackTracesStateChanged, this);
+
     this.enableDebugger();
 
     WebInspector.DebuggerModel.applySkipStackFrameSettings();
 }
 
 // Keep these in sync with WebCore::ScriptDebugServer
 WebInspector.DebuggerModel.PauseOnExceptionsState = {
     DontPauseOnExceptions : "none",
     PauseOnAllExceptions : "all",
     PauseOnUncaughtExceptions: "uncaught"
@@ skipping 97 matching lines @@
      */
     canSetScriptSource: function()
     {
         return this._canSetScriptSource;
     },
 
     _debuggerWasEnabled: function()
     {
         this._debuggerEnabled = true;
         this._pauseOnExceptionStateChanged();
+        this._asyncStackTracesStateChanged();
         this.dispatchEventToListeners(WebInspector.DebuggerModel.Events.DebuggerWasEnabled);
     },
 
     _pauseOnExceptionStateChanged: function()
     {
         DebuggerAgent.setPauseOnExceptions(WebInspector.settings.pauseOnExceptionStateString.get());
     },
 
+    _asyncStackTracesStateChanged: function()
+    {
+        var enabled = WebInspector.settings.enableAsyncStackTraces.get();
+        var depth = enabled ? Number(WebInspector.settings.maxAsyncStackTraceDepth.get()) : 0;
+        DebuggerAgent.setAsyncCallStackDepth(depth);
+    },
+
     _debuggerWasDisabled: function()
     {
         this._debuggerEnabled = false;
         this.dispatchEventToListeners(WebInspector.DebuggerModel.Events.DebuggerWasDisabled);
     },
 
     /**
      * @param {!WebInspector.DebuggerModel.Location} rawLocation
      */
     continueToLocation: function(rawLocation)
@@ skipping 249 matching lines @@
             this.setSelectedCallFrame(null);
             DebuggerAgent.setOverlayMessage();
         }
     },
 
     /**
      * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
      * @param {string} reason
      * @param {Object|undefined} auxData
      * @param {!Array.<string>} breakpointIds
-     * @param {DebuggerAgent.StackTrace=} asyncStackTrace
+     * @param {!DebuggerAgent.StackTrace=} asyncStackTrace
      */
     _pausedScript: function(callFrames, reason, auxData, breakpointIds, asyncStackTrace)
     {
         if (this._pendingStepIntoLocation) {
             var requestedLocation = this._pendingStepIntoLocation;
             delete this._pendingStepIntoLocation;
 
             if (callFrames.length > 0) {
                 var topLocation = callFrames[0].location;
                 if (topLocation.lineNumber == requestedLocation.lineNumber && topLocation.columnNumber == requestedLocation.columnNumber && topLocation.scriptId == requestedLocation.scriptId) {
                     this.stepInto();
                     return;
                 }
             }
         }
 
-        this._setDebuggerPausedDetails(new WebInspector.DebuggerPausedDetails(this, callFrames, reason, auxData, breakpointIds, asyncStackTrace));
+        this._setDebuggerPausedDetails(new WebInspector.DebuggerPausedDetails(callFrames, reason, auxData, breakpointIds, asyncStackTrace));
     },
 
     _resumedScript: function()
     {
         this._setDebuggerPausedDetails(null);
         this.dispatchEventToListeners(WebInspector.DebuggerModel.Events.DebuggerResumed);
     },
 
     /**
      * @param {DebuggerAgent.ScriptId} scriptId
@@ skipping 205 matching lines @@
         if (!script)
             return null;
         return script.rawLocationToUILocation(rawLocation.lineNumber, rawLocation.columnNumber);
     },
 
     /**
      * Handles notification from JavaScript VM about updated stack (liveedit or frame restart action).
      * @this {WebInspector.DebuggerModel}
      * @param {!Array.<!DebuggerAgent.CallFrame>=} newCallFrames
      * @param {Object=} details
-     * @param {DebuggerAgent.StackTrace=} asyncStackTrace
+     * @param {!DebuggerAgent.StackTrace=} asyncStackTrace
      */
     callStackModified: function(newCallFrames, details, asyncStackTrace)
     {
         // FIXME: declare this property in protocol and in JavaScript.
         if (details && details["stack_update_needs_step_in"])
             this.stepInto();
         else if (newCallFrames && newCallFrames.length)
             this._pausedScript(newCallFrames, this._debuggerPausedDetails.reason, this._debuggerPausedDetails.auxData, this._debuggerPausedDetails.breakpointIds, asyncStackTrace);
     },
 
@@ skipping 24 matching lines @@
 {
     this._debuggerModel = debuggerModel;
 }
 
 WebInspector.DebuggerDispatcher.prototype = {
     /**
      * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
      * @param {string} reason
      * @param {Object=} auxData
      * @param {!Array.<string>=} breakpointIds
-     * @param {DebuggerAgent.StackTrace=} asyncStackTrace
+     * @param {!DebuggerAgent.StackTrace=} asyncStackTrace
      */
     paused: function(callFrames, reason, auxData, breakpointIds, asyncStackTrace)
     {
         this._debuggerModel._pausedScript(callFrames, reason, auxData, breakpointIds || [], asyncStackTrace);
     },
 
     resumed: function()
     {
         this._debuggerModel._resumedScript();
     },
@@ skipping 37 matching lines @@
     breakpointResolved: function(breakpointId, location)
     {
         this._debuggerModel._breakpointResolved(breakpointId, location);
     }
 }
 
 /**
  * @constructor
  * @param {!WebInspector.Script} script
  * @param {!DebuggerAgent.CallFrame} payload
+ * @param {boolean=} isAsync
  */
-WebInspector.DebuggerModel.CallFrame = function(script, payload)
+WebInspector.DebuggerModel.CallFrame = function(script, payload, isAsync)
 {
     this._script = script;
     this._payload = payload;
+    /** @type {!Array.<!WebInspector.Script.Location>} */
     this._locations = [];
+    this._isAsync = isAsync;
+}
+
+/**
+ * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
+ * @param {boolean=} isAsync
+ * @return {!Array.<!WebInspector.DebuggerModel.CallFrame>}
+ */
+WebInspector.DebuggerModel.CallFrame.fromPayloadArray = function(callFrames, isAsync)
+{
+    var result = [];
+    for (var i = 0; i < callFrames.length; ++i) {
+        var callFrame = callFrames[i];
+        var script = WebInspector.debuggerModel.scriptForId(callFrame.location.scriptId);
+        if (script)

[yurys, 2013/12/06 12:36:54]

Why do we hide such frames?

[aandrey, 2013/12/06 16:09:24]

Not sure. This is how it was before, I didn't change this behavior.

+            result.push(new WebInspector.DebuggerModel.CallFrame(script, callFrame, isAsync));
+    }
+    return result;
 }
 
 WebInspector.DebuggerModel.CallFrame.prototype = {
     /**
      * @return {!WebInspector.Script}
      */
     get script()
     {
         return this._script;
     },
@@ skipping 49 matching lines @@
     /**
      * @return {!WebInspector.DebuggerModel.Location}
      */
     get location()
     {
         var rawLocation = /** @type {!WebInspector.DebuggerModel.Location} */ (this._payload.location);
         return rawLocation;
     },
 
     /**
+     * @return {boolean}
+     */
+    isAsync: function()
+    {
+        return !!this._isAsync;
+    },
+
+    /**
      * @param {string} code
      * @param {string} objectGroup
      * @param {boolean} includeCommandLineAPI
      * @param {boolean} doNotPauseOnExceptionsAndMuteConsole
      * @param {boolean} returnByValue
      * @param {boolean} generatePreview
      * @param {function(?RuntimeAgent.RemoteObject, boolean=)=} callback
      */
     evaluate: function(code, objectGroup, includeCommandLineAPI, doNotPauseOnExceptionsAndMuteConsole, returnByValue, generatePreview, callback)
     {
@@ skipping 18 matching lines @@
     /**
      * @param {function(?Protocol.Error=)=} callback
      */
     restart: function(callback)
     {
         /**
          * @this {WebInspector.DebuggerModel.CallFrame}
          * @param {?Protocol.Error} error
          * @param {!Array.<!DebuggerAgent.CallFrame>=} callFrames
          * @param {Object=} details
-         * @param {DebuggerAgent.StackTrace=} asyncStackTrace
+         * @param {!DebuggerAgent.StackTrace=} asyncStackTrace
          */
         function protocolCallback(error, callFrames, details, asyncStackTrace)
         {
             if (!error)
                 WebInspector.debuggerModel.callStackModified(callFrames, details, asyncStackTrace);
             if (callback)
                 callback(error);
         }
         DebuggerAgent.restartFrame(this._payload.callFrameId, protocolCallback);
     },
 
     /**
      * @param {function(!Array.<!DebuggerAgent.Location>)} callback
      */
     getStepIntoLocations: function(callback)
     {
         if (this._stepInLocations) {
             callback(this._stepInLocations.slice(0));
             return;
         }
         /**
          * @param {?string} error
          * @param {!Array.<!DebuggerAgent.Location>=} stepInPositions
          */
-        function getStepInPositionsCallback(error, stepInPositions) {
-            if (error) {
+        function getStepInPositionsCallback(error, stepInPositions)
+        {
+            if (error)
                 return;
-            }
             this._stepInLocations = stepInPositions;
             callback(this._stepInLocations.slice(0));
         }
         DebuggerAgent.getStepInPositions(this.id, getStepInPositionsCallback.bind(this));
     },
 
     /**
      * @param {function(!WebInspector.UILocation):(boolean|undefined)} updateDelegate
      */
     createLiveLocation: function(updateDelegate)
     {
         var location = this._script.createLiveLocation(this.location, updateDelegate);
         this._locations.push(location);
         return location;
     },
 
-    dispose: function(updateDelegate)
+    dispose: function()
     {
         for (var i = 0; i < this._locations.length; ++i)
             this._locations[i].dispose();
         this._locations = [];
     }
 }
 
 /**
  * @constructor
- * @param {WebInspector.DebuggerModel} model
+ * @param {!Array.<!WebInspector.DebuggerModel.CallFrame>} callFrames
+ * @param {?WebInspector.DebuggerModel.StackTrace} asyncStackTrace
+ */
+WebInspector.DebuggerModel.StackTrace = function(callFrames, asyncStackTrace)
+{
+    this._callFrames = callFrames;
+    this._asyncStackTrace = asyncStackTrace;
+}
+
+/**
+ * @param {!DebuggerAgent.StackTrace=} payload
+ * @param {boolean=} isAsync
+ * @return {?WebInspector.DebuggerModel.StackTrace}
+ */
+WebInspector.DebuggerModel.StackTrace.fromPayload = function(payload, isAsync)
+{
+    if (!payload)
+        return null;
+    var callFrames = WebInspector.DebuggerModel.CallFrame.fromPayloadArray(payload.callFrames, isAsync);
+    if (!callFrames.length)
+        return null;
+    var asyncStackTrace = WebInspector.DebuggerModel.StackTrace.fromPayload(payload.asyncStackTrace, true);
+    return new WebInspector.DebuggerModel.StackTrace(callFrames, asyncStackTrace);
+}
+
+WebInspector.DebuggerModel.StackTrace.prototype = {
+    /**
+     * @return {!Array.<!WebInspector.DebuggerModel.CallFrame>}
+     */
+    get callFrames()

[yurys, 2013/12/06 12:36:54]

style: please use functions.

[aandrey, 2013/12/06 16:09:24]

renamed _callFrames -> callFrames

+    {
+        return this._callFrames;
+    },
+
+    /**
+     * @return {?WebInspector.DebuggerModel.StackTrace}
+     */
+    get asyncStackTrace()
+    {
+        return this._asyncStackTrace;
+    },
+
+    dispose: function()
+    {
+        for (var i = 0; i < this._callFrames.length; ++i)
+            this._callFrames[i].dispose();
+        if (this._asyncStackTrace)
+            this._asyncStackTrace.dispose();
+    }
+}
+
+/**
+ * @constructor
  * @param {!Array.<!DebuggerAgent.CallFrame>} callFrames
  * @param {string} reason
  * @param {Object|undefined} auxData
  * @param {!Array.<string>} breakpointIds
- * @param {DebuggerAgent.StackTrace=} asyncStackTrace
+ * @param {!DebuggerAgent.StackTrace=} asyncStackTrace
  */
-WebInspector.DebuggerPausedDetails = function(model, callFrames, reason, auxData, breakpointIds, asyncStackTrace)
+WebInspector.DebuggerPausedDetails = function(callFrames, reason, auxData, breakpointIds, asyncStackTrace)
 {
-    this.callFrames = [];
-    for (var i = 0; i < callFrames.length; ++i) {
-        var callFrame = callFrames[i];
-        var script = model.scriptForId(callFrame.location.scriptId);
-        if (script)
-            this.callFrames.push(new WebInspector.DebuggerModel.CallFrame(script, callFrame));
-    }
+    this.callFrames = WebInspector.DebuggerModel.CallFrame.fromPayloadArray(callFrames);
     this.reason = reason;
     this.auxData = auxData;
     this.breakpointIds = breakpointIds;
-    this.asyncStackTrace = asyncStackTrace;
+    this.asyncStackTrace = WebInspector.DebuggerModel.StackTrace.fromPayload(asyncStackTrace, true);
 }
 
 WebInspector.DebuggerPausedDetails.prototype = {
     dispose: function()
     {
-        for (var i = 0; i < this.callFrames.length; ++i) {
-            var callFrame = this.callFrames[i];
-            callFrame.dispose();
-        }
+        for (var i = 0; i < this.callFrames.length; ++i)
+            this.callFrames[i].dispose();
+        if (this.asyncStackTrace)
+            this.asyncStackTrace.dispose();
     }
 }
 
 /**
  * @type {?WebInspector.DebuggerModel}
  */
 WebInspector.debuggerModel = null;