src/third_party/WebKit/Source/devtools/front_end/sources/CallStackSidebarPane.js

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 /**
  27  * @constructor
  28  * @extends {WebInspector.SidebarPane}
  29  */
  30 WebInspector.CallStackSidebarPane = function()
  31 {
  32     WebInspector.SidebarPane.call(this, WebInspector.UIString("Call Stack"));
  33     this.bodyElement.addEventListener("keydown", this._keyDown.bind(this), true);
  34     this.bodyElement.tabIndex = 0;
  35
  36     var asyncCheckbox = this.titleElement.appendChild(WebInspector.SettingsUI.createSettingCheckbox(WebInspector.UIString("Async"), WebInspector.settings.enableAsyncStackTraces, true, undefined, WebInspector.UIString("Capture async stack traces")));
  37     asyncCheckbox.classList.add("scripts-callstack-async");
  38     asyncCheckbox.addEventListener("click", consumeEvent, false);
  39     WebInspector.settings.enableAsyncStackTraces.addChangeListener(this._asyncStackTracesStateChanged, this);
  40     WebInspector.settings.skipStackFramesPattern.addChangeListener(this._blackboxingStateChanged, this);
  41 }
  42
  43 WebInspector.CallStackSidebarPane.Events = {
  44     CallFrameSelected: "CallFrameSelected"
  45 }
  46
  47 WebInspector.CallStackSidebarPane.prototype = {
  48     /**
  49      * @param {?WebInspector.DebuggerPausedDetails} details
  50      */
  51     update: function(details)
  52     {
  53         this.bodyElement.removeChildren();
  54
  55         if (!details) {
  56             var infoElement = this.bodyElement.createChild("div", "info");
  57             infoElement.textContent = WebInspector.UIString("Not Paused");
  58             return;
  59         }
  60
  61         this._target = details.target();
  62         var callFrames = details.callFrames;
  63         var asyncStackTrace = details.asyncStackTrace;
  64
  65         delete this._statusMessageElement;
  66         delete this._hiddenPlacardsMessageElement;
  67         /** @type {!Array.<!WebInspector.CallStackSidebarPane.Placard>} */
  68         this.placards = [];
  69         this._hiddenPlacards = 0;
  70
  71         this._appendSidebarPlacards(callFrames);
  72         var topStackHidden = (this._hiddenPlacards === this.placards.length);
  73
  74         while (asyncStackTrace) {
  75             var title = WebInspector.asyncStackTraceLabel(asyncStackTrace.description);
  76             var asyncPlacard = new WebInspector.Placard(title, "");
  77             asyncPlacard.element.addEventListener("click", this._selectNextVisiblePlacard.bind(this, this.placards.length, false), false);
  78             asyncPlacard.element.addEventListener("contextmenu", this._asyncPlacardContextMenu.bind(this, this.placards.length), true);
  79             asyncPlacard.element.classList.add("placard-label");
  80             this.bodyElement.appendChild(asyncPlacard.element);
  81             this._appendSidebarPlacards(asyncStackTrace.callFrames, asyncPlacard);
  82             asyncStackTrace = asyncStackTrace.asyncStackTrace;
  83         }
  84
  85         if (topStackHidden)
  86             this._revealHiddenPlacards();
  87         if (this._hiddenPlacards) {
  88             var element = document.createElementWithClass("div", "hidden-placards-message");
  89             if (this._hiddenPlacards === 1)
  90                 element.textContent = WebInspector.UIString("1 stack frame is hidden (black-boxed).");
  91             else
  92                 element.textContent = WebInspector.UIString("%d stack frames are hidden (black-boxed).", this._hiddenPlacards);
  93             element.createTextChild(" ");
  94             var showAllLink = element.createChild("span", "node-link");
  95             showAllLink.textContent = WebInspector.UIString("Show");
  96             showAllLink.addEventListener("click", this._revealHiddenPlacards.bind(this), false);
  97             this.bodyElement.insertBefore(element, this.bodyElement.firstChild);
  98             this._hiddenPlacardsMessageElement = element;
  99         }
 100     },
 101
 102     /**
 103      * @param {!Array.<!WebInspector.DebuggerModel.CallFrame>} callFrames
 104      * @param {!WebInspector.Placard=} asyncPlacard
 105      */
 106     _appendSidebarPlacards: function(callFrames, asyncPlacard)
 107     {
 108         var allPlacardsHidden = true;
 109         for (var i = 0, n = callFrames.length; i < n; ++i) {
 110             var callFrame = callFrames[i];
 111             var placard = new WebInspector.CallStackSidebarPane.Placard(callFrame, asyncPlacard);
 112             placard.element.addEventListener("click", this._placardSelected.bind(this, placard), false);
 113             placard.element.addEventListener("contextmenu", this._placardContextMenu.bind(this, placard), true);
 114             this.placards.push(placard);
 115             this.bodyElement.appendChild(placard.element);
 116
 117             if (WebInspector.BlackboxSupport.isBlackboxed(callFrame.script.sourceURL, callFrame.script.isContentScript())) {
 118                 placard.setHidden(true);
 119                 placard.element.classList.add("dimmed");
 120                 ++this._hiddenPlacards;
 121             } else {
 122                 allPlacardsHidden = false;
 123             }
 124         }
 125         if (allPlacardsHidden && asyncPlacard)
 126             asyncPlacard.setHidden(true);
 127     },
 128
 129     _revealHiddenPlacards: function()
 130     {
 131         if (!this._hiddenPlacards)
 132             return;
 133         this._hiddenPlacards = 0;
 134         for (var i = 0; i < this.placards.length; ++i) {
 135             var placard = this.placards[i];
 136             placard.setHidden(false);
 137             if (placard._asyncPlacard)
 138                 placard._asyncPlacard.setHidden(false);
 139         }
 140         if (this._hiddenPlacardsMessageElement) {
 141             this._hiddenPlacardsMessageElement.remove();
 142             delete this._hiddenPlacardsMessageElement;
 143         }
 144     },
 145
 146     /**
 147      * @param {!WebInspector.CallStackSidebarPane.Placard} placard
 148      * @param {!Event} event
 149      */
 150     _placardContextMenu: function(placard, event)
 151     {
 152         var contextMenu = new WebInspector.ContextMenu(event);
 153
 154         if (!placard._callFrame.isAsync())
 155             contextMenu.appendItem(WebInspector.UIString(WebInspector.useLowerCaseMenuTitles() ? "Restart frame" : "Restart Frame"), this._restartFrame.bind(this, placard));
 156
 157         contextMenu.appendItem(WebInspector.UIString(WebInspector.useLowerCaseMenuTitles() ? "Copy stack trace" : "Copy Stack Trace"), this._copyStackTrace.bind(this));
 158
 159         var script = placard._callFrame.script;
 160         if (!script.isSnippet()) {
 161             contextMenu.appendSeparator();
 162             this.appendBlackboxURLContextMenuItems(contextMenu, script.sourceURL, script.isContentScript());
 163         }
 164
 165         contextMenu.show();
 166     },
 167
 168     /**
 169      * @param {number} index
 170      * @param {!Event} event
 171      */
 172     _asyncPlacardContextMenu: function(index, event)
 173     {
 174         for (; index < this.placards.length; ++index) {
 175             var placard = this.placards[index];
 176             if (!placard.isHidden()) {
 177                 this._placardContextMenu(placard, event);
 178                 break;
 179             }
 180         }
 181     },
 182
 183     /**
 184      * @param {!WebInspector.ContextMenu} contextMenu
 185      * @param {string} url
 186      * @param {boolean} isContentScript
 187      */
 188     appendBlackboxURLContextMenuItems: function(contextMenu, url, isContentScript)
 189     {
 190         var blackboxed = WebInspector.BlackboxSupport.isBlackboxed(url, isContentScript);
 191         if (blackboxed) {
 192             contextMenu.appendItem(WebInspector.UIString(WebInspector.useLowerCaseMenuTitles() ? "Stop blackboxing" : "Stop Blackboxing"), this._handleContextMenuBlackboxURL.bind(this, url, isContentScript, false));
 193         } else {
 194             if (WebInspector.BlackboxSupport.canBlackboxURL(url))
 195                 contextMenu.appendItem(WebInspector.UIString(WebInspector.useLowerCaseMenuTitles() ? "Blackbox script" : "Blackbox Script"), this._handleContextMenuBlackboxURL.bind(this, url, false, true));
 196             if (isContentScript)
 197                 contextMenu.appendItem(WebInspector.UIString(WebInspector.useLowerCaseMenuTitles() ? "Blackbox all content scripts" : "Blackbox All Content Scripts"), this._handleContextMenuBlackboxURL.bind(this, url, true, true));
 198         }
 199     },
 200
 201     /**
 202      * @param {string} url
 203      * @param {boolean} isContentScript
 204      * @param {boolean} blackbox
 205      */
 206     _handleContextMenuBlackboxURL: function(url, isContentScript, blackbox)
 207     {
 208         if (blackbox) {
 209             if (isContentScript)
 210                 WebInspector.settings.skipContentScripts.set(true);
 211             else
 212                 WebInspector.BlackboxSupport.blackboxURL(url);
 213         } else {
 214             WebInspector.BlackboxSupport.unblackbox(url, isContentScript);
 215         }
 216     },
 217
 218     _blackboxingStateChanged: function()
 219     {
 220         if (!this._target)
 221             return;
 222         var details = this._target.debuggerModel.debuggerPausedDetails();
 223         if (!details)
 224             return;
 225         this.update(details);
 226         var selectedCallFrame = this._target.debuggerModel.selectedCallFrame();
 227         if (selectedCallFrame)
 228             this.setSelectedCallFrame(selectedCallFrame);
 229     },
 230
 231     /**
 232      * @param {!WebInspector.CallStackSidebarPane.Placard} placard
 233      */
 234     _restartFrame: function(placard)
 235     {
 236         placard._callFrame.restart();
 237     },
 238
 239     _asyncStackTracesStateChanged: function()
 240     {
 241         var enabled = WebInspector.settings.enableAsyncStackTraces.get();
 242         if (!enabled && this.placards)
 243             this._removeAsyncPlacards();
 244     },
 245
 246     _removeAsyncPlacards: function()
 247     {
 248         var shouldSelectTopFrame = false;
 249         var lastSyncPlacardIndex = -1;
 250         for (var i = 0; i < this.placards.length; ++i) {
 251             var placard = this.placards[i];
 252             if (placard._asyncPlacard) {
 253                 if (placard.selected)
 254                     shouldSelectTopFrame = true;
 255                 placard._asyncPlacard.element.remove();
 256                 placard.element.remove();
 257             } else {
 258                 lastSyncPlacardIndex = i;
 259             }
 260         }
 261         this.placards.length = lastSyncPlacardIndex + 1;
 262         if (shouldSelectTopFrame)
 263             this._selectNextVisiblePlacard(0);
 264     },
 265
 266     /**
 267      * @param {!WebInspector.DebuggerModel.CallFrame} x
 268      */
 269     setSelectedCallFrame: function(x)
 270     {
 271         for (var i = 0; i < this.placards.length; ++i) {
 272             var placard = this.placards[i];
 273             placard.selected = (placard._callFrame === x);
 274             if (placard.selected && placard.isHidden())
 275                 this._revealHiddenPlacards();
 276         }
 277     },
 278
 279     /**
 280      * @return {boolean}
 281      */
 282     _selectNextCallFrameOnStack: function()
 283     {
 284         var index = this._selectedCallFrameIndex();
 285         if (index === -1)
 286             return false;
 287         return this._selectNextVisiblePlacard(index + 1);
 288     },
 289
 290     /**
 291      * @return {boolean}
 292      */
 293     _selectPreviousCallFrameOnStack: function()
 294     {
 295         var index = this._selectedCallFrameIndex();
 296         if (index === -1)
 297             return false;
 298         return this._selectNextVisiblePlacard(index - 1, true);
 299     },
 300
 301     /**
 302      * @param {number} index
 303      * @param {boolean=} backward
 304      * @return {boolean}
 305      */
 306     _selectNextVisiblePlacard: function(index, backward)
 307     {
 308         while (0 <= index && index < this.placards.length) {
 309             var placard = this.placards[index];
 310             if (!placard.isHidden()) {
 311                 this._placardSelected(placard);
 312                 return true;
 313             }
 314             index += backward ? -1 : 1;
 315         }
 316         return false;
 317     },
 318
 319     /**
 320      * @return {number}
 321      */
 322     _selectedCallFrameIndex: function()
 323     {
 324         var selectedCallFrame = this._target.debuggerModel.selectedCallFrame();
 325         if (!selectedCallFrame)
 326             return -1;
 327         for (var i = 0; i < this.placards.length; ++i) {
 328             var placard = this.placards[i];
 329             if (placard._callFrame === selectedCallFrame)
 330                 return i;
 331         }
 332         return -1;
 333     },
 334
 335     /**
 336      * @param {!WebInspector.CallStackSidebarPane.Placard} placard
 337      */
 338     _placardSelected: function(placard)
 339     {
 340         placard.element.scrollIntoViewIfNeeded();
 341         this.dispatchEventToListeners(WebInspector.CallStackSidebarPane.Events.CallFrameSelected, placard._callFrame);
 342     },
 343
 344     _copyStackTrace: function()
 345     {
 346         var text = "";
 347         var lastPlacard = null;
 348         for (var i = 0; i < this.placards.length; ++i) {
 349             var placard = this.placards[i];
 350             if (placard.isHidden())
 351                 continue;
 352             if (lastPlacard && placard._asyncPlacard !== lastPlacard._asyncPlacard)
 353                 text += placard._asyncPlacard.title + "\n";
 354             text += placard.title + " (" + placard.subtitle + ")\n";
 355             lastPlacard = placard;
 356         }
 357         InspectorFrontendHost.copyText(text);
 358     },
 359
 360     /**
 361      * @param {function(!Array.<!WebInspector.KeyboardShortcut.Descriptor>, function(!Event=):boolean)} registerShortcutDelegate
 362      */
 363     registerShortcuts: function(registerShortcutDelegate)
 364     {
 365         registerShortcutDelegate(WebInspector.ShortcutsScreen.SourcesPanelShortcuts.NextCallFrame, this._selectNextCallFrameOnStack.bind(this));
 366         registerShortcutDelegate(WebInspector.ShortcutsScreen.SourcesPanelShortcuts.PrevCallFrame, this._selectPreviousCallFrameOnStack.bind(this));
 367     },
 368
 369     /**
 370      * @param {!Element|string} status
 371      */
 372     setStatus: function(status)
 373     {
 374         if (!this._statusMessageElement)
 375             this._statusMessageElement = this.bodyElement.createChild("div", "info");
 376         if (typeof status === "string") {
 377             this._statusMessageElement.textContent = status;
 378         } else {
 379             this._statusMessageElement.removeChildren();
 380             this._statusMessageElement.appendChild(status);
 381         }
 382     },
 383
 384     _keyDown: function(event)
 385     {
 386         if (event.altKey || event.shiftKey || event.metaKey || event.ctrlKey)
 387             return;
 388         if (event.keyIdentifier === "Up" && this._selectPreviousCallFrameOnStack() || event.keyIdentifier === "Down" && this._selectNextCallFrameOnStack())
 389             event.consume(true);
 390     },
 391
 392     __proto__: WebInspector.SidebarPane.prototype
 393 }
 394
 395 /**
 396  * @constructor
 397  * @extends {WebInspector.Placard}
 398  * @param {!WebInspector.DebuggerModel.CallFrame} callFrame
 399  * @param {!WebInspector.Placard=} asyncPlacard
 400  */
 401 WebInspector.CallStackSidebarPane.Placard = function(callFrame, asyncPlacard)
 402 {
 403     WebInspector.Placard.call(this, callFrame.functionName || WebInspector.UIString("(anonymous function)"), "");
 404     WebInspector.debuggerWorkspaceBinding.createCallFrameLiveLocation(callFrame, this._update.bind(this));
 405     this._callFrame = callFrame;
 406     this._asyncPlacard = asyncPlacard;
 407 }
 408
 409 WebInspector.CallStackSidebarPane.Placard.prototype = {
 410     /**
 411      * @param {!WebInspector.UILocation} uiLocation
 412      */
 413     _update: function(uiLocation)
 414     {
 415         var text = uiLocation.linkText();
 416         this.subtitle = text.trimMiddle(30);
 417         this.subtitleElement.title = text;
 418     },
 419
 420     __proto__: WebInspector.Placard.prototype
 421 }