Andrew Zambazos
1533 lines
70 KiB
JavaScript
1533 lines
70 KiB
JavaScript
/*
|
|
* Copyright (C) 2013, 2015 Apple 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:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
|
|
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
|
|
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
|
|
* THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
WI.DebuggerSidebarPanel = class DebuggerSidebarPanel extends WI.NavigationSidebarPanel
|
|
{
|
|
constructor()
|
|
{
|
|
super("debugger", WI.UIString("Debugger"), true);
|
|
|
|
WI.Frame.addEventListener(WI.Frame.Event.MainResourceDidChange, this._mainResourceDidChange, this);
|
|
WI.Frame.addEventListener(WI.Frame.Event.ResourceWasAdded, this._resourceAdded, this);
|
|
WI.Target.addEventListener(WI.Target.Event.ResourceAdded, this._resourceAdded, this);
|
|
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointAdded, this._breakpointAdded, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointAdded, this._breakpointAdded, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.EventBreakpointAdded, this._breakpointAdded, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.URLBreakpointAdded, this._breakpointAdded, this);
|
|
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointRemoved, this._breakpointRemoved, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, this._breakpointRemoved, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.EventBreakpointRemoved, this._breakpointRemoved, this);
|
|
WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.URLBreakpointRemoved, this._breakpointRemoved, this);
|
|
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointsEnabledDidChange, this._breakpointsEnabledDidChange, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.ScriptAdded, this._scriptAdded, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.ScriptRemoved, this._scriptRemoved, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.ScriptsCleared, this._scriptsCleared, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, this._debuggerDidPause, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Resumed, this._debuggerDidResume, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.CallFramesDidChange, this._debuggerCallFramesDidChange, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.ActiveCallFrameDidChange, this._debuggerActiveCallFrameDidChange, this);
|
|
WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.WaitingToPause, this._debuggerWaitingToPause, this);
|
|
|
|
WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DOMNodeChanged, this._handleDOMBreakpointDOMNodeChanged, this);
|
|
|
|
WI.timelineManager.addEventListener(WI.TimelineManager.Event.CapturingStateChanged, this._handleTimelineCapturingStateChanged, this);
|
|
|
|
WI.auditManager.addEventListener(WI.AuditManager.Event.TestScheduled, this._handleAuditManagerTestScheduled, this);
|
|
WI.auditManager.addEventListener(WI.AuditManager.Event.TestCompleted, this._handleAuditManagerTestCompleted, this);
|
|
|
|
WI.targetManager.addEventListener(WI.TargetManager.Event.TargetAdded, this._targetAdded, this);
|
|
WI.targetManager.addEventListener(WI.TargetManager.Event.TargetRemoved, this._targetRemoved, this);
|
|
|
|
this._timelineRecordingWarningElement = document.createElement("div");
|
|
this._timelineRecordingWarningElement.classList.add("warning-banner");
|
|
this._timelineRecordingWarningElement.append(WI.UIString("Debugger disabled during Timeline recording"), document.createElement("br"));
|
|
let timelineStopRecordingLink = this._timelineRecordingWarningElement.appendChild(document.createElement("a"));
|
|
timelineStopRecordingLink.textContent = WI.UIString("Stop recording");
|
|
timelineStopRecordingLink.addEventListener("click", () => { WI.timelineManager.stopCapturing(); });
|
|
|
|
this._auditTestWarningElement = document.createElement("div");
|
|
this._auditTestWarningElement.classList.add("warning-banner");
|
|
this._auditTestWarningElement.append(WI.UIString("Debugger disabled during Audit"), document.createElement("br"));
|
|
let auditStopRecordingLink = this._auditTestWarningElement.appendChild(document.createElement("a"));
|
|
auditStopRecordingLink.textContent = WI.UIString("Stop Audit");
|
|
auditStopRecordingLink.addEventListener("click", () => { WI.auditManager.stop(); });
|
|
|
|
this._breakpointsDisabledWarningElement = document.createElement("div");
|
|
this._breakpointsDisabledWarningElement.classList.add("warning-banner");
|
|
this._breakpointsDisabledWarningElement.append(WI.UIString("Breakpoints disabled"), document.createElement("br"));
|
|
let enableBreakpointsLink = this._breakpointsDisabledWarningElement.appendChild(document.createElement("a"));
|
|
enableBreakpointsLink.textContent = WI.UIString("Enable breakpoints");
|
|
enableBreakpointsLink.addEventListener("click", () => { WI.debuggerToggleBreakpoints(); });
|
|
|
|
this._navigationBar = new WI.NavigationBar;
|
|
this.addSubview(this._navigationBar);
|
|
|
|
var breakpointsImage = {src: "Images/Breakpoints.svg", width: 15, height: 15};
|
|
var pauseImage = {src: "Images/Pause.svg", width: 15, height: 15};
|
|
var resumeImage = {src: "Images/Resume.svg", width: 15, height: 15};
|
|
var stepOverImage = {src: "Images/StepOver.svg", width: 15, height: 15};
|
|
var stepIntoImage = {src: "Images/StepInto.svg", width: 15, height: 15};
|
|
var stepOutImage = {src: "Images/StepOut.svg", width: 15, height: 15};
|
|
|
|
var toolTip = WI.UIString("Enable all breakpoints (%s)").format(WI.toggleBreakpointsKeyboardShortcut.displayName);
|
|
var altToolTip = WI.UIString("Disable all breakpoints (%s)").format(WI.toggleBreakpointsKeyboardShortcut.displayName);
|
|
|
|
this._debuggerBreakpointsButtonItem = new WI.ActivateButtonNavigationItem("debugger-breakpoints", toolTip, altToolTip, breakpointsImage.src, breakpointsImage.width, breakpointsImage.height);
|
|
this._debuggerBreakpointsButtonItem.activated = WI.debuggerManager.breakpointsEnabled;
|
|
this._debuggerBreakpointsButtonItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, WI.debuggerToggleBreakpoints, this);
|
|
this._navigationBar.addNavigationItem(this._debuggerBreakpointsButtonItem);
|
|
|
|
toolTip = WI.UIString("Pause script execution (%s or %s)").format(WI.pauseOrResumeKeyboardShortcut.displayName, WI.pauseOrResumeAlternateKeyboardShortcut.displayName);
|
|
altToolTip = WI.UIString("Continue script execution (%s or %s)").format(WI.pauseOrResumeKeyboardShortcut.displayName, WI.pauseOrResumeAlternateKeyboardShortcut.displayName);
|
|
|
|
this._debuggerPauseResumeButtonItem = new WI.ToggleButtonNavigationItem("debugger-pause-resume", toolTip, altToolTip, pauseImage.src, resumeImage.src, pauseImage.width, pauseImage.height);
|
|
this._debuggerPauseResumeButtonItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, WI.debuggerPauseResumeToggle, this);
|
|
this._navigationBar.addNavigationItem(this._debuggerPauseResumeButtonItem);
|
|
|
|
this._debuggerStepOverButtonItem = new WI.ButtonNavigationItem("debugger-step-over", WI.UIString("Step over (%s or %s)").format(WI.stepOverKeyboardShortcut.displayName, WI.stepOverAlternateKeyboardShortcut.displayName), stepOverImage.src, stepOverImage.width, stepOverImage.height);
|
|
this._debuggerStepOverButtonItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, WI.debuggerStepOver, this);
|
|
this._debuggerStepOverButtonItem.enabled = false;
|
|
this._navigationBar.addNavigationItem(this._debuggerStepOverButtonItem);
|
|
|
|
this._debuggerStepIntoButtonItem = new WI.ButtonNavigationItem("debugger-step-into", WI.UIString("Step into (%s or %s)").format(WI.stepIntoKeyboardShortcut.displayName, WI.stepIntoAlternateKeyboardShortcut.displayName), stepIntoImage.src, stepIntoImage.width, stepIntoImage.height);
|
|
this._debuggerStepIntoButtonItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, WI.debuggerStepInto, this);
|
|
this._debuggerStepIntoButtonItem.enabled = false;
|
|
this._navigationBar.addNavigationItem(this._debuggerStepIntoButtonItem);
|
|
|
|
this._debuggerStepOutButtonItem = new WI.ButtonNavigationItem("debugger-step-out", WI.UIString("Step out (%s or %s)").format(WI.stepOutKeyboardShortcut.displayName, WI.stepOutAlternateKeyboardShortcut.displayName), stepOutImage.src, stepOutImage.width, stepOutImage.height);
|
|
this._debuggerStepOutButtonItem.addEventListener(WI.ButtonNavigationItem.Event.Clicked, WI.debuggerStepOut, this);
|
|
this._debuggerStepOutButtonItem.enabled = false;
|
|
this._navigationBar.addNavigationItem(this._debuggerStepOutButtonItem);
|
|
|
|
function showResourcesWithIssuesOnlyFilterFunction(treeElement)
|
|
{
|
|
// Issues are only shown in the scripts tree outline.
|
|
if (treeElement.treeOutline !== this._scriptsContentTreeOutline)
|
|
return true;
|
|
|
|
// Keep issues.
|
|
if (treeElement instanceof WI.IssueTreeElement)
|
|
return true;
|
|
|
|
// Keep resources with issues.
|
|
if (treeElement.hasChildren) {
|
|
for (let child of treeElement.children) {
|
|
if (child instanceof WI.IssueTreeElement)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
this.filterBar.addFilterBarButton("debugger-show-resources-with-issues-only", showResourcesWithIssuesOnlyFilterFunction.bind(this), false, WI.UIString("Only show resources with issues"), WI.UIString("Show all resources"), "Images/Errors.svg", 15, 15);
|
|
|
|
this._breakpointsContentTreeOutline = this.contentTreeOutline;
|
|
|
|
let breakpointsRow = new WI.DetailsSectionRow;
|
|
breakpointsRow.element.appendChild(this._breakpointsContentTreeOutline.element);
|
|
|
|
let breakpointNavigationBarWrapper = document.createElement("div");
|
|
|
|
let breakpointNavigationBar = new WI.NavigationBar;
|
|
breakpointNavigationBarWrapper.appendChild(breakpointNavigationBar.element);
|
|
|
|
this._createBreakpointButton = new WI.ButtonNavigationItem("create-breakpoint", WI.UIString("Create Breakpoint"), "Images/Plus13.svg", 13, 13);
|
|
this._createBreakpointButton.element.addEventListener("mousedown", this._handleCreateBreakpointMouseDown.bind(this));
|
|
breakpointNavigationBar.addNavigationItem(this._createBreakpointButton);
|
|
|
|
let breakpointsGroup = new WI.DetailsSectionGroup([breakpointsRow]);
|
|
this._breakpointsSection = new WI.DetailsSection("breakpoints", WI.UIString("Breakpoints"), [breakpointsGroup], breakpointNavigationBarWrapper);
|
|
this.contentView.element.appendChild(this._breakpointsSection.element);
|
|
|
|
this._breakpointsContentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementAdded, this._handleBreakpointElementAddedOrRemoved, this);
|
|
this._breakpointsContentTreeOutline.addEventListener(WI.TreeOutline.Event.ElementRemoved, this._handleBreakpointElementAddedOrRemoved, this);
|
|
this._breakpointsContentTreeOutline.addEventListener(WI.TreeOutline.Event.SelectionDidChange, this._treeSelectionDidChange, this);
|
|
this._breakpointsContentTreeOutline.ondelete = this._breakpointTreeOutlineDeleteTreeElement.bind(this);
|
|
this._breakpointsContentTreeOutline.populateContextMenu = function(contextMenu, event, treeElement) {
|
|
this._breakpointTreeOutlineContextMenuTreeElement(contextMenu, event, treeElement);
|
|
|
|
WI.TreeOutline.prototype.populateContextMenu(contextMenu, event, treeElement);
|
|
}.bind(this);
|
|
|
|
this._scriptsContentTreeOutline = this.createContentTreeOutline();
|
|
this._scriptsContentTreeOutline.addEventListener(WI.TreeOutline.Event.SelectionDidChange, this._treeSelectionDidChange, this);
|
|
this._scriptsContentTreeOutline.includeSourceMapResourceChildren = true;
|
|
|
|
let scriptsRow = new WI.DetailsSectionRow;
|
|
scriptsRow.element.appendChild(this._scriptsContentTreeOutline.element);
|
|
|
|
let scriptsGroup = new WI.DetailsSectionGroup([scriptsRow]);
|
|
this._scriptsSection = new WI.DetailsSection("scripts", WI.UIString("Sources"), [scriptsGroup]);
|
|
this.contentView.element.appendChild(this._scriptsSection.element);
|
|
|
|
this._callStackTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
this._callStackTreeOutline.addEventListener(WI.TreeOutline.Event.SelectionDidChange, this._treeSelectionDidChange, this);
|
|
|
|
this._callStackRow = new WI.DetailsSectionRow;
|
|
this._callStackRow.element.appendChild(this._callStackTreeOutline.element);
|
|
|
|
this._callStackGroup = new WI.DetailsSectionGroup([this._callStackRow]);
|
|
this._callStackSection = new WI.DetailsSection("call-stack", WI.UIString("Call Stack"), [this._callStackGroup]);
|
|
|
|
this._mainTargetTreeElement = null;
|
|
this._activeCallFrameTreeElement = null;
|
|
|
|
this._pauseReasonTreeOutline = null;
|
|
|
|
this._pauseReasonLinkContainerElement = document.createElement("span");
|
|
this._pauseReasonTextRow = new WI.DetailsSectionTextRow;
|
|
this._pauseReasonGroup = new WI.DetailsSectionGroup([this._pauseReasonTextRow]);
|
|
this._pauseReasonSection = new WI.DetailsSection("paused-reason", WI.UIString("Pause Reason"), [this._pauseReasonGroup], this._pauseReasonLinkContainerElement);
|
|
|
|
WI.Breakpoint.addEventListener(WI.Breakpoint.Event.DisplayLocationDidChange, this._handleDebuggerObjectDisplayLocationDidChange, this);
|
|
WI.IssueMessage.addEventListener(WI.IssueMessage.Event.DisplayLocationDidChange, this._handleDebuggerObjectDisplayLocationDidChange, this);
|
|
WI.consoleManager.addEventListener(WI.ConsoleManager.Event.IssueAdded, this._handleIssueAdded, this);
|
|
WI.consoleManager.addEventListener(WI.ConsoleManager.Event.Cleared, this._handleIssuesCleared, this);
|
|
|
|
WI.debuggerManager.addBreakpoint(WI.debuggerManager.allExceptionsBreakpoint);
|
|
WI.debuggerManager.addBreakpoint(WI.debuggerManager.uncaughtExceptionsBreakpoint);
|
|
|
|
// COMPATIBILITY (iOS 10): DebuggerAgent.setPauseOnAssertions did not exist yet.
|
|
if (InspectorBackend.domains.Debugger.setPauseOnAssertions && WI.settings.showAssertionFailuresBreakpoint.value)
|
|
WI.debuggerManager.addBreakpoint(WI.debuggerManager.assertionFailuresBreakpoint);
|
|
|
|
for (let target of WI.targets)
|
|
this._addTarget(target);
|
|
this._updateCallStackTreeOutline();
|
|
|
|
if (WI.networkManager.mainFrame)
|
|
this._addResourcesRecursivelyForFrame(WI.networkManager.mainFrame);
|
|
|
|
for (let script of WI.debuggerManager.knownNonResourceScripts)
|
|
this._addScript(script);
|
|
|
|
if (WI.domDebuggerManager.supported) {
|
|
if (WI.settings.showAllRequestsBreakpoint.value)
|
|
WI.domDebuggerManager.addURLBreakpoint(WI.domDebuggerManager.allRequestsBreakpoint);
|
|
|
|
for (let eventBreakpoint of WI.domDebuggerManager.eventBreakpoints)
|
|
this._addBreakpoint(eventBreakpoint);
|
|
|
|
for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
|
|
this._addBreakpoint(domBreakpoint);
|
|
|
|
for (let eventListenerBreakpoint of WI.domManager.eventListenerBreakpoints)
|
|
this._addBreakpoint(eventListenerBreakpoint);
|
|
|
|
for (let urlBreakpoints of WI.domDebuggerManager.urlBreakpoints)
|
|
this._addBreakpoint(urlBreakpoints);
|
|
}
|
|
|
|
if (WI.debuggerManager.paused)
|
|
this._debuggerDidPause(null);
|
|
|
|
if (WI.debuggerManager.breakpointsDisabledTemporarily) {
|
|
this._handleTimelineCapturingStateChanged();
|
|
|
|
if (WI.auditManager.runningState === WI.AuditManager.RunningState.Active || WI.auditManager.runningState === WI.AuditManager.RunningState.Stopping)
|
|
this._handleAuditManagerTestScheduled();
|
|
}
|
|
|
|
this._updateBreakpointsDisabledBanner();
|
|
}
|
|
|
|
// Public
|
|
|
|
get minimumWidth()
|
|
{
|
|
return this._navigationBar.minimumWidth;
|
|
}
|
|
|
|
closed()
|
|
{
|
|
super.closed();
|
|
|
|
WI.Frame.removeEventListener(null, null, this);
|
|
WI.Target.removeEventListener(null, null, this);
|
|
WI.debuggerManager.removeEventListener(null, null, this);
|
|
WI.domDebuggerManager.removeEventListener(null, null, this);
|
|
WI.DOMBreakpoint.removeEventListener(null, null, this);
|
|
WI.timelineManager.removeEventListener(null, null, this);
|
|
WI.targetManager.removeEventListener(null, null, this);
|
|
WI.Breakpoint.removeEventListener(null, null, this);
|
|
WI.IssueMessage.removeEventListener(null, null, this);
|
|
}
|
|
|
|
showDefaultContentView()
|
|
{
|
|
if (WI.networkManager.mainFrame) {
|
|
let mainTreeElement = this._scriptsContentTreeOutline.findTreeElement(WI.networkManager.mainFrame.mainResource);
|
|
if (mainTreeElement && this.showDefaultContentViewForTreeElement(mainTreeElement))
|
|
return;
|
|
}
|
|
|
|
let currentTreeElement = this._scriptsContentTreeOutline.children[0];
|
|
while (currentTreeElement && !currentTreeElement.root) {
|
|
if (currentTreeElement instanceof WI.ResourceTreeElement || currentTreeElement instanceof WI.ScriptTreeElement) {
|
|
if (this.showDefaultContentViewForTreeElement(currentTreeElement))
|
|
return;
|
|
}
|
|
|
|
currentTreeElement = currentTreeElement.traverseNextTreeElement(false, null, true);
|
|
}
|
|
}
|
|
|
|
treeElementForRepresentedObject(representedObject)
|
|
{
|
|
// The main resource is used as the representedObject instead of Frame in our tree.
|
|
if (representedObject instanceof WI.Frame)
|
|
representedObject = representedObject.mainResource;
|
|
|
|
let treeElement = this._breakpointsContentTreeOutline.findTreeElement(representedObject);
|
|
if (!treeElement)
|
|
treeElement = this._scriptsContentTreeOutline.findTreeElement(representedObject);
|
|
|
|
if (treeElement)
|
|
return treeElement;
|
|
|
|
// Only special case Script objects.
|
|
if (!(representedObject instanceof WI.Script)) {
|
|
console.error("Didn't find a TreeElement for representedObject", representedObject);
|
|
return null;
|
|
}
|
|
|
|
// If the Script has a URL we should have found it earlier.
|
|
if (representedObject.url) {
|
|
console.error("Didn't find a ScriptTreeElement for a Script with a URL.");
|
|
return null;
|
|
}
|
|
|
|
// Since the Script does not have a URL we consider it an 'anonymous' script. These scripts happen from calls to
|
|
// window.eval() or browser features like Auto Fill and Reader. They are not normally added to the sidebar, but since
|
|
// we have a ScriptContentView asking for the tree element we will make a ScriptTreeElement on demand and add it.
|
|
|
|
return this._addScript(representedObject);
|
|
}
|
|
|
|
createContentTreeOutline(options = {})
|
|
{
|
|
let treeOutline = super.createContentTreeOutline(options)
|
|
|
|
treeOutline.addEventListener(WI.TreeOutline.Event.ElementRevealed, (event) => {
|
|
let treeElement = event.data.element;
|
|
let detailsSections = [this._pauseReasonSection, this._callStackSection, this._breakpointsSection, this._scriptsSection];
|
|
let detailsSection = detailsSections.find((detailsSection) => detailsSection.element.contains(treeElement.listItemElement));
|
|
if (!detailsSection)
|
|
return;
|
|
|
|
// Revealing a TreeElement at the scroll container's topmost edge with
|
|
// scrollIntoViewIfNeeded may result in the element being covered by the
|
|
// DetailsSection header, which uses sticky positioning. Detect this case,
|
|
// and adjust the sidebar content's scroll position to compensate.
|
|
let offset = detailsSection.headerElement.totalOffsetBottom - treeElement.listItemElement.totalOffsetTop;
|
|
if (offset > 0)
|
|
this.scrollElement.scrollBy(0, -offset);
|
|
});
|
|
|
|
return treeOutline;
|
|
}
|
|
|
|
// Protected
|
|
|
|
saveStateToCookie(cookie)
|
|
{
|
|
console.assert(cookie);
|
|
|
|
var selectedTreeElement = this._breakpointsContentTreeOutline.selectedTreeElement;
|
|
if (!selectedTreeElement) {
|
|
super.saveStateToCookie(cookie);
|
|
return;
|
|
}
|
|
|
|
var representedObject = selectedTreeElement.representedObject;
|
|
|
|
if (representedObject === WI.debuggerManager.allExceptionsBreakpoint) {
|
|
cookie[WI.DebuggerSidebarPanel.SelectedAllExceptionsCookieKey] = true;
|
|
return;
|
|
}
|
|
|
|
if (representedObject === WI.debuggerManager.uncaughtExceptionsBreakpoint) {
|
|
cookie[WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey] = true;
|
|
return;
|
|
}
|
|
|
|
if (representedObject === WI.debuggerManager.assertionFailuresBreakpoint) {
|
|
cookie[WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey] = true;
|
|
return;
|
|
}
|
|
|
|
if (representedObject === WI.domDebuggerManager.allRequestsBreakpoint) {
|
|
cookie[WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey] = true;
|
|
return;
|
|
}
|
|
|
|
super.saveStateToCookie(cookie);
|
|
}
|
|
|
|
restoreStateFromCookie(cookie, relaxedMatchDelay)
|
|
{
|
|
console.assert(cookie);
|
|
|
|
function revealAndSelect(treeOutline, breakpoint) {
|
|
let treeElement = treeOutline.findTreeElement(breakpoint);
|
|
if (!treeElement)
|
|
return;
|
|
|
|
treeElement.revealAndSelect();
|
|
}
|
|
|
|
// Eagerly resolve the special breakpoints; otherwise, use the default behavior.
|
|
if (cookie[WI.DebuggerSidebarPanel.SelectedAllExceptionsCookieKey])
|
|
revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.allExceptionsBreakpoint);
|
|
else if (cookie[WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey])
|
|
revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.uncaughtExceptionsBreakpoint);
|
|
else if (cookie[WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey])
|
|
revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.assertionFailuresBreakpoint);
|
|
else if (cookie[WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey])
|
|
revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allRequestsBreakpoint);
|
|
else
|
|
super.restoreStateFromCookie(cookie, relaxedMatchDelay);
|
|
}
|
|
|
|
// Popover delegate
|
|
|
|
willDismissPopover(popover)
|
|
{
|
|
let breakpoint = popover.breakpoint;
|
|
if (!breakpoint)
|
|
return;
|
|
|
|
if (breakpoint instanceof WI.EventBreakpoint)
|
|
WI.domDebuggerManager.addEventBreakpoint(breakpoint);
|
|
else if (breakpoint instanceof WI.URLBreakpoint)
|
|
WI.domDebuggerManager.addURLBreakpoint(breakpoint);
|
|
}
|
|
|
|
// Private
|
|
|
|
_debuggerWaitingToPause(event)
|
|
{
|
|
this._debuggerPauseResumeButtonItem.enabled = false;
|
|
}
|
|
|
|
_debuggerDidPause(event)
|
|
{
|
|
this.contentView.element.insertBefore(this._callStackSection.element, this.contentView.element.firstChild);
|
|
|
|
if (this._updatePauseReason())
|
|
this.contentView.element.insertBefore(this._pauseReasonSection.element, this.contentView.element.firstChild);
|
|
|
|
this._debuggerPauseResumeButtonItem.enabled = true;
|
|
this._debuggerPauseResumeButtonItem.toggled = true;
|
|
this._debuggerStepOverButtonItem.enabled = true;
|
|
this._debuggerStepIntoButtonItem.enabled = true;
|
|
this._debuggerStepOutButtonItem.enabled = true;
|
|
|
|
this.element.classList.add(WI.DebuggerSidebarPanel.DebuggerPausedStyleClassName);
|
|
}
|
|
|
|
_debuggerDidResume(event)
|
|
{
|
|
this._callStackSection.element.remove();
|
|
|
|
this._pauseReasonSection.element.remove();
|
|
|
|
this._debuggerPauseResumeButtonItem.enabled = true;
|
|
this._debuggerPauseResumeButtonItem.toggled = false;
|
|
this._debuggerStepOverButtonItem.enabled = false;
|
|
this._debuggerStepIntoButtonItem.enabled = false;
|
|
this._debuggerStepOutButtonItem.enabled = false;
|
|
|
|
this.element.classList.remove(WI.DebuggerSidebarPanel.DebuggerPausedStyleClassName);
|
|
}
|
|
|
|
_breakpointsEnabledDidChange(event)
|
|
{
|
|
this._debuggerBreakpointsButtonItem.activated = WI.debuggerManager.breakpointsEnabled;
|
|
|
|
this._updateBreakpointsDisabledBanner();
|
|
}
|
|
|
|
_addBreakpoint(breakpoint)
|
|
{
|
|
let constructor = WI.BreakpointTreeElement;
|
|
let options = {};
|
|
let parentTreeElement = this._breakpointsContentTreeOutline;
|
|
|
|
let getDOMNodeTreeElement = (domNode) => {
|
|
console.assert(domNode, "Missing DOMNode for identifier", breakpoint.domNodeIdentifier);
|
|
if (!domNode)
|
|
return null;
|
|
|
|
let domNodeTreeElement = this._breakpointsContentTreeOutline.findTreeElement(domNode);
|
|
if (!domNodeTreeElement) {
|
|
domNodeTreeElement = new WI.DOMNodeTreeElement(domNode);
|
|
this._addTreeElement(domNodeTreeElement, parentTreeElement);
|
|
}
|
|
return domNodeTreeElement;
|
|
};
|
|
|
|
if (breakpoint === WI.debuggerManager.allExceptionsBreakpoint) {
|
|
options.className = WI.DebuggerSidebarPanel.ExceptionIconStyleClassName;
|
|
options.title = WI.repeatedUIString.allExceptions();
|
|
} else if (breakpoint === WI.debuggerManager.uncaughtExceptionsBreakpoint) {
|
|
options.className = WI.DebuggerSidebarPanel.ExceptionIconStyleClassName;
|
|
options.title = WI.repeatedUIString.uncaughtExceptions();
|
|
} else if (breakpoint === WI.debuggerManager.assertionFailuresBreakpoint) {
|
|
options.className = WI.DebuggerSidebarPanel.AssertionIconStyleClassName;
|
|
options.title = WI.repeatedUIString.assertionFailures();
|
|
} else if (breakpoint instanceof WI.DOMBreakpoint) {
|
|
if (!breakpoint.domNodeIdentifier)
|
|
return null;
|
|
|
|
constructor = WI.DOMBreakpointTreeElement;
|
|
|
|
let domNode = WI.domManager.nodeForId(breakpoint.domNodeIdentifier);
|
|
parentTreeElement = getDOMNodeTreeElement(domNode);
|
|
} else if (breakpoint instanceof WI.EventBreakpoint) {
|
|
constructor = WI.EventBreakpointTreeElement;
|
|
|
|
if (breakpoint.eventListener) {
|
|
let eventTargetTreeElement = null;
|
|
if (breakpoint.eventListener.onWindow) {
|
|
if (!DebuggerSidebarPanel.__windowEventTargetRepresentedObject)
|
|
DebuggerSidebarPanel.__windowEventTargetRepresentedObject = {__window: true};
|
|
|
|
eventTargetTreeElement = this._breakpointsContentTreeOutline.findTreeElement(DebuggerSidebarPanel.__windowEventTargetRepresentedObject);
|
|
if (!eventTargetTreeElement) {
|
|
const subtitle = null;
|
|
eventTargetTreeElement = new WI.GeneralTreeElement(["event-target-window"], WI.unlocalizedString("window"), subtitle, DebuggerSidebarPanel.__windowEventTargetRepresentedObject);
|
|
this._addTreeElement(eventTargetTreeElement, parentTreeElement);
|
|
}
|
|
} else if (breakpoint.eventListener.node)
|
|
eventTargetTreeElement = getDOMNodeTreeElement(breakpoint.eventListener.node);
|
|
if (eventTargetTreeElement)
|
|
parentTreeElement = eventTargetTreeElement;
|
|
}
|
|
} else if (breakpoint instanceof WI.URLBreakpoint) {
|
|
constructor = WI.URLBreakpointTreeElement;
|
|
|
|
if (breakpoint === WI.domDebuggerManager.allRequestsBreakpoint)
|
|
options.title = WI.repeatedUIString.allRequests();
|
|
} else {
|
|
let sourceCode = breakpoint.sourceCodeLocation && breakpoint.sourceCodeLocation.displaySourceCode;
|
|
if (!sourceCode)
|
|
return null;
|
|
|
|
if (this._breakpointsContentTreeOutline.findTreeElement(breakpoint))
|
|
return null;
|
|
|
|
parentTreeElement = this._addTreeElementForSourceCodeToTreeOutline(sourceCode, this._breakpointsContentTreeOutline);
|
|
|
|
// Mark disabled breakpoints as resolved if there is source code loaded with that URL.
|
|
// This gives the illusion the breakpoint was resolved, but since we don't send disabled
|
|
// breakpoints to the backend we don't know for sure. If the user enables the breakpoint
|
|
// it will be resolved properly.
|
|
if (breakpoint.disabled)
|
|
breakpoint.resolved = true;
|
|
}
|
|
|
|
let breakpointTreeElement = new constructor(breakpoint, options);
|
|
this._addTreeElement(breakpointTreeElement, parentTreeElement);
|
|
if (parentTreeElement.children.length === 1)
|
|
parentTreeElement.expand();
|
|
return breakpointTreeElement;
|
|
}
|
|
|
|
_removeBreakpoint(breakpoint)
|
|
{
|
|
if (this._pauseReasonTreeOutline) {
|
|
let pauseReasonBreakpointTreeElement = this._pauseReasonTreeOutline.getCachedTreeElement(breakpoint);
|
|
if (pauseReasonBreakpointTreeElement)
|
|
pauseReasonBreakpointTreeElement.status = null;
|
|
}
|
|
|
|
let breakpointTreeElement = this._breakpointsContentTreeOutline.getCachedTreeElement(breakpoint);
|
|
if (!breakpointTreeElement)
|
|
return;
|
|
|
|
this._removeDebuggerTreeElement(breakpointTreeElement);
|
|
}
|
|
|
|
_addBreakpointsForSourceCode(sourceCode)
|
|
{
|
|
for (let breakpoint of WI.debuggerManager.breakpointsForSourceCode(sourceCode))
|
|
this._addBreakpoint(breakpoint, sourceCode);
|
|
}
|
|
|
|
_addIssuesForSourceCode(sourceCode)
|
|
{
|
|
var issues = WI.consoleManager.issuesForSourceCode(sourceCode);
|
|
for (var issue of issues)
|
|
this._addIssue(issue);
|
|
}
|
|
|
|
_addTreeElementForSourceCodeToTreeOutline(sourceCode, treeOutline)
|
|
{
|
|
let treeElement = treeOutline.getCachedTreeElement(sourceCode);
|
|
if (!treeElement) {
|
|
if (sourceCode instanceof WI.SourceMapResource)
|
|
treeElement = new WI.SourceMapResourceTreeElement(sourceCode);
|
|
else if (sourceCode instanceof WI.Resource)
|
|
treeElement = new WI.ResourceTreeElement(sourceCode);
|
|
else if (sourceCode instanceof WI.Script)
|
|
treeElement = new WI.ScriptTreeElement(sourceCode);
|
|
}
|
|
|
|
if (!treeElement) {
|
|
console.error("Unknown sourceCode instance", sourceCode);
|
|
return null;
|
|
}
|
|
|
|
if (!treeElement.parent) {
|
|
treeElement.hasChildren = false;
|
|
treeElement.expand();
|
|
|
|
this._addTreeElement(treeElement, treeOutline);
|
|
}
|
|
|
|
return treeElement;
|
|
}
|
|
|
|
_addResourcesRecursivelyForFrame(frame)
|
|
{
|
|
this._addResource(frame.mainResource);
|
|
|
|
for (let resource of frame.resourceCollection)
|
|
this._addResource(resource);
|
|
|
|
for (let childFrame of frame.childFrameCollection)
|
|
this._addResourcesRecursivelyForFrame(childFrame);
|
|
}
|
|
|
|
_resourceAdded(event)
|
|
{
|
|
this._addResource(event.data.resource);
|
|
}
|
|
|
|
_addResource(resource)
|
|
{
|
|
if (![WI.Resource.Type.Document, WI.Resource.Type.Script].includes(resource.type))
|
|
return;
|
|
|
|
let treeElement = this._addTreeElementForSourceCodeToTreeOutline(resource, this._scriptsContentTreeOutline);
|
|
this._addBreakpointsForSourceCode(resource);
|
|
this._addIssuesForSourceCode(resource);
|
|
|
|
if (this.parentSidebar && !this.contentBrowser.currentContentView)
|
|
this.showDefaultContentViewForTreeElement(treeElement);
|
|
}
|
|
|
|
_mainResourceDidChange(event)
|
|
{
|
|
if (event.target.isMainFrame()) {
|
|
// Aggressively prune resources now so the old resources are removed before
|
|
// the new main resource is added below. This avoids a visual flash when the
|
|
// prune normally happens on a later event loop cycle.
|
|
this.pruneStaleResourceTreeElements();
|
|
this.contentBrowser.contentViewContainer.closeAllContentViews();
|
|
|
|
for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
|
|
this._removeBreakpoint(domBreakpoint);
|
|
}
|
|
|
|
if (!event.data.oldMainResource) {
|
|
var resource = event.target.mainResource;
|
|
this._addTreeElementForSourceCodeToTreeOutline(resource, this._scriptsContentTreeOutline);
|
|
this._addBreakpointsForSourceCode(resource);
|
|
this._addIssuesForSourceCode(resource);
|
|
}
|
|
}
|
|
|
|
_handleTimelineCapturingStateChanged(event)
|
|
{
|
|
this._updateTemporarilyDisabledBreakpointsButtons();
|
|
|
|
switch (WI.timelineManager.capturingState) {
|
|
case WI.TimelineManager.CapturingState.Starting:
|
|
this.contentView.element.insertBefore(this._timelineRecordingWarningElement, this.contentView.element.firstChild);
|
|
break;
|
|
|
|
case WI.TimelineManager.CapturingState.Inactive:
|
|
this._timelineRecordingWarningElement.remove();
|
|
break;
|
|
}
|
|
|
|
this._updateBreakpointsDisabledBanner();
|
|
}
|
|
|
|
_handleAuditManagerTestScheduled(event)
|
|
{
|
|
this._updateTemporarilyDisabledBreakpointsButtons();
|
|
|
|
this.contentView.element.insertBefore(this._auditTestWarningElement, this.contentView.element.firstChild);
|
|
this._updateBreakpointsDisabledBanner();
|
|
}
|
|
|
|
_handleAuditManagerTestCompleted(event)
|
|
{
|
|
this._updateTemporarilyDisabledBreakpointsButtons();
|
|
|
|
this._auditTestWarningElement.remove();
|
|
this._updateBreakpointsDisabledBanner();
|
|
}
|
|
|
|
_updateTemporarilyDisabledBreakpointsButtons()
|
|
{
|
|
let breakpointsDisabledTemporarily = WI.debuggerManager.breakpointsDisabledTemporarily;
|
|
this._debuggerBreakpointsButtonItem.enabled = !breakpointsDisabledTemporarily;
|
|
this._debuggerPauseResumeButtonItem.enabled = !breakpointsDisabledTemporarily;
|
|
}
|
|
|
|
_updateBreakpointsDisabledBanner()
|
|
{
|
|
let breakpointsEnabled = WI.debuggerManager.breakpointsEnabled;
|
|
let timelineWarningShowing = !!this._timelineRecordingWarningElement.parentElement;
|
|
let auditWarningShowing = !!this._auditTestWarningElement.parentElement;
|
|
|
|
if (!breakpointsEnabled && !timelineWarningShowing && !auditWarningShowing)
|
|
this.contentView.element.insertBefore(this._breakpointsDisabledWarningElement, this.contentView.element.firstChild);
|
|
else
|
|
this._breakpointsDisabledWarningElement.remove();
|
|
}
|
|
|
|
_scriptAdded(event)
|
|
{
|
|
this._addScript(event.data.script);
|
|
}
|
|
|
|
_addScript(script)
|
|
{
|
|
// COMPATIBILITY(iOS 9): Backends could send the frontend built-in code, filter out JSC internals.
|
|
if (!script.url && !script.sourceURL)
|
|
return null;
|
|
|
|
// In general, do not show dynamically added script elements.
|
|
if (script.dynamicallyAddedScriptElement && !script.sourceURL)
|
|
return null;
|
|
|
|
// Don't add breakpoints if the script is represented by a Resource. They were
|
|
// already added by _resourceAdded.
|
|
if (script.resource)
|
|
return null;
|
|
|
|
let treeElement = this._addTreeElementForSourceCodeToTreeOutline(script, this._scriptsContentTreeOutline);
|
|
this._addBreakpointsForSourceCode(script);
|
|
this._addIssuesForSourceCode(script);
|
|
|
|
if (this.parentSidebar && !this.contentBrowser.currentContentView)
|
|
this.showDefaultContentViewForTreeElement(treeElement);
|
|
|
|
return treeElement;
|
|
}
|
|
|
|
_scriptRemoved(event)
|
|
{
|
|
function removeScript(script, treeOutline)
|
|
{
|
|
let scriptTreeElement = treeOutline.getCachedTreeElement(script);
|
|
if (scriptTreeElement)
|
|
scriptTreeElement.parent.removeChild(scriptTreeElement);
|
|
}
|
|
|
|
let script = event.data.script;
|
|
removeScript(script, this._breakpointsContentTreeOutline);
|
|
removeScript(script, this._scriptsContentTreeOutline);
|
|
}
|
|
|
|
_scriptsCleared(event)
|
|
{
|
|
for (var i = this._breakpointsContentTreeOutline.children.length - 1; i >= 0; --i) {
|
|
var treeElement = this._breakpointsContentTreeOutline.children[i];
|
|
if (!(treeElement instanceof WI.ScriptTreeElement))
|
|
continue;
|
|
|
|
this._breakpointsContentTreeOutline.removeChildAtIndex(i, true, true);
|
|
}
|
|
|
|
this._scriptsContentTreeOutline.removeChildren();
|
|
|
|
this._addResourcesRecursivelyForFrame(WI.networkManager.mainFrame);
|
|
}
|
|
|
|
_breakpointAdded(event)
|
|
{
|
|
var breakpoint = event.data.breakpoint;
|
|
this._addBreakpoint(breakpoint);
|
|
}
|
|
|
|
_breakpointRemoved(event)
|
|
{
|
|
var breakpoint = event.data.breakpoint;
|
|
this._removeBreakpoint(breakpoint);
|
|
}
|
|
|
|
_findThreadTreeElementForTarget(target)
|
|
{
|
|
for (let child of this._callStackTreeOutline.children) {
|
|
if (child.target === target)
|
|
return child;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
_targetAdded(event)
|
|
{
|
|
this._addTarget(event.data.target);
|
|
}
|
|
|
|
_addTarget(target)
|
|
{
|
|
let treeElement = new WI.ThreadTreeElement(target);
|
|
this._callStackTreeOutline.appendChild(treeElement);
|
|
|
|
// FIXME: When WI.mainTarget changes?
|
|
if (target === WI.mainTarget)
|
|
this._mainTargetTreeElement = treeElement;
|
|
|
|
this._updateCallStackTreeOutline();
|
|
}
|
|
|
|
_targetRemoved(event)
|
|
{
|
|
let target = event.data.target;
|
|
let treeElement = this._findThreadTreeElementForTarget(target);
|
|
this._callStackTreeOutline.removeChild(treeElement);
|
|
|
|
this._updateCallStackTreeOutline();
|
|
}
|
|
|
|
_updateCallStackTreeOutline()
|
|
{
|
|
let singleThreadShowing = WI.targets.length <= 1;
|
|
this._callStackTreeOutline.element.classList.toggle("single-thread", singleThreadShowing);
|
|
if (this._mainTargetTreeElement)
|
|
this._mainTargetTreeElement.selectable = !singleThreadShowing;
|
|
}
|
|
|
|
_handleDebuggerObjectDisplayLocationDidChange(event)
|
|
{
|
|
var debuggerObject = event.target;
|
|
|
|
if (event.data.oldDisplaySourceCode === debuggerObject.sourceCodeLocation.displaySourceCode)
|
|
return;
|
|
|
|
// A known debugger object (breakpoint, issueMessage, etc.) moved between resources. Remove
|
|
// the old tree element and create a new tree element with the updated file.
|
|
|
|
let wasSelected = false;
|
|
let oldDebuggerTreeElement = this._breakpointsContentTreeOutline.getCachedTreeElement(debuggerObject);
|
|
if (oldDebuggerTreeElement)
|
|
wasSelected = oldDebuggerTreeElement.selected;
|
|
|
|
let newDebuggerTreeElement = null;
|
|
if (debuggerObject instanceof WI.Breakpoint)
|
|
newDebuggerTreeElement = this._addBreakpoint(debuggerObject);
|
|
else if (debuggerObject instanceof WI.IssueMessage)
|
|
newDebuggerTreeElement = this._addIssue(debuggerObject);
|
|
if (!newDebuggerTreeElement)
|
|
return;
|
|
|
|
if (oldDebuggerTreeElement)
|
|
this._removeDebuggerTreeElement(oldDebuggerTreeElement);
|
|
|
|
if (wasSelected)
|
|
newDebuggerTreeElement.revealAndSelect(true, false, true);
|
|
}
|
|
|
|
_removeDebuggerTreeElement(debuggerTreeElement)
|
|
{
|
|
// If this is a BreakpointTreeElement being deleted because of a cause
|
|
// outside of the TreeOutline then deselect if it is selected to avoid
|
|
// TreeOutline selection changes causing unexpected ContentView changes.
|
|
if (!debuggerTreeElement.__deletedViaDeleteKeyboardShortcut)
|
|
debuggerTreeElement.deselect();
|
|
|
|
let parentTreeElement = debuggerTreeElement.parent;
|
|
parentTreeElement.removeChild(debuggerTreeElement);
|
|
|
|
if (parentTreeElement.children.length || parentTreeElement === this._breakpointsContentTreeOutline)
|
|
return;
|
|
|
|
parentTreeElement.treeOutline.removeChild(parentTreeElement);
|
|
}
|
|
|
|
_debuggerCallFramesDidChange(event)
|
|
{
|
|
let target = event.data.target;
|
|
let treeElement = this._findThreadTreeElementForTarget(target);
|
|
treeElement.refresh();
|
|
|
|
let activeCallFrameTreeElement = this._callStackTreeOutline.findTreeElement(WI.debuggerManager.activeCallFrame);
|
|
if (activeCallFrameTreeElement)
|
|
activeCallFrameTreeElement.reveal();
|
|
}
|
|
|
|
_debuggerActiveCallFrameDidChange()
|
|
{
|
|
if (this._activeCallFrameTreeElement) {
|
|
this._activeCallFrameTreeElement.isActiveCallFrame = false;
|
|
this._activeCallFrameTreeElement = null;
|
|
}
|
|
|
|
if (!WI.debuggerManager.activeCallFrame)
|
|
return;
|
|
|
|
this._activeCallFrameTreeElement = this._callStackTreeOutline.findTreeElement(WI.debuggerManager.activeCallFrame);
|
|
if (this._activeCallFrameTreeElement)
|
|
this._activeCallFrameTreeElement.isActiveCallFrame = true;
|
|
}
|
|
|
|
_breakpointsBeneathTreeElement(treeElement)
|
|
{
|
|
console.assert(treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement);
|
|
if (!(treeElement instanceof WI.ResourceTreeElement) && !(treeElement instanceof WI.ScriptTreeElement))
|
|
return [];
|
|
|
|
var breakpoints = [];
|
|
var breakpointTreeElements = treeElement.children;
|
|
for (var i = 0; i < breakpointTreeElements.length; ++i) {
|
|
console.assert(breakpointTreeElements[i] instanceof WI.BreakpointTreeElement);
|
|
console.assert(breakpointTreeElements[i].breakpoint);
|
|
var breakpoint = breakpointTreeElements[i].breakpoint;
|
|
if (breakpoint)
|
|
breakpoints.push(breakpoint);
|
|
}
|
|
|
|
return breakpoints;
|
|
}
|
|
|
|
_removeAllBreakpoints(breakpoints)
|
|
{
|
|
for (var i = 0; i < breakpoints.length; ++i) {
|
|
var breakpoint = breakpoints[i];
|
|
if (WI.debuggerManager.isBreakpointRemovable(breakpoint))
|
|
WI.debuggerManager.removeBreakpoint(breakpoint);
|
|
}
|
|
}
|
|
|
|
_toggleAllBreakpoints(breakpoints, disabled)
|
|
{
|
|
for (var i = 0; i < breakpoints.length; ++i)
|
|
breakpoints[i].disabled = disabled;
|
|
}
|
|
|
|
_breakpointTreeOutlineDeleteTreeElement(treeElement)
|
|
{
|
|
console.assert(treeElement.selected);
|
|
|
|
if (treeElement.representedObject === DebuggerSidebarPanel.__windowEventTargetRepresentedObject) {
|
|
let eventBreakpointsOnWindow = WI.domManager.eventListenerBreakpoints.filter((eventBreakpoint) => eventBreakpoint.eventListener.onWindow);
|
|
for (let eventBreakpoint of eventBreakpointsOnWindow)
|
|
WI.domManager.removeBreakpointForEventListener(eventBreakpoint.eventListener);
|
|
return true;
|
|
}
|
|
|
|
console.assert(treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement);
|
|
if (!(treeElement instanceof WI.ResourceTreeElement) && !(treeElement instanceof WI.ScriptTreeElement))
|
|
return false;
|
|
|
|
var wasTopResourceTreeElement = treeElement.previousSibling === this._assertionsBreakpointTreeElement || treeElement.previousSibling === this._allUncaughtExceptionsBreakpointTreeElement;
|
|
var nextSibling = treeElement.nextSibling;
|
|
|
|
var breakpoints = this._breakpointsBeneathTreeElement(treeElement);
|
|
this._removeAllBreakpoints(breakpoints);
|
|
|
|
if (wasTopResourceTreeElement && nextSibling)
|
|
nextSibling.select(true, true);
|
|
|
|
return true;
|
|
}
|
|
|
|
_breakpointTreeOutlineContextMenuTreeElement(contextMenu, event, treeElement)
|
|
{
|
|
// This check is necessary since the context menu is created by the TreeOutline, meaning
|
|
// that any child could be the target of the context menu event.
|
|
if (!(treeElement instanceof WI.ResourceTreeElement) && !(treeElement instanceof WI.ScriptTreeElement))
|
|
return;
|
|
|
|
let breakpoints = this._breakpointsBeneathTreeElement(treeElement);
|
|
let shouldDisable = breakpoints.some((breakpoint) => !breakpoint.disabled);
|
|
|
|
let removeAllResourceBreakpoints = () => {
|
|
this._removeAllBreakpoints(breakpoints);
|
|
};
|
|
|
|
let toggleAllResourceBreakpoints = () => {
|
|
this._toggleAllBreakpoints(breakpoints, shouldDisable);
|
|
};
|
|
|
|
if (shouldDisable)
|
|
contextMenu.appendItem(WI.UIString("Disable Breakpoints"), toggleAllResourceBreakpoints);
|
|
else
|
|
contextMenu.appendItem(WI.UIString("Enable Breakpoints"), toggleAllResourceBreakpoints);
|
|
contextMenu.appendItem(WI.UIString("Delete Breakpoints"), removeAllResourceBreakpoints);
|
|
}
|
|
|
|
_treeSelectionDidChange(event)
|
|
{
|
|
if (!this.selected)
|
|
return;
|
|
|
|
let treeElement = event.target.selectedTreeElement;
|
|
if (!treeElement)
|
|
return;
|
|
|
|
if (treeElement instanceof WI.DOMNodeTreeElement
|
|
|| treeElement instanceof WI.DOMBreakpointTreeElement
|
|
|| treeElement instanceof WI.EventBreakpointTreeElement
|
|
|| treeElement instanceof WI.URLBreakpointTreeElement)
|
|
return;
|
|
|
|
if (treeElement.representedObject === DebuggerSidebarPanel.__windowEventTargetRepresentedObject)
|
|
return;
|
|
|
|
const options = {
|
|
ignoreNetworkTab: true,
|
|
ignoreSearchTab: true,
|
|
};
|
|
|
|
if (treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement) {
|
|
WI.showSourceCode(treeElement.representedObject, options);
|
|
return;
|
|
}
|
|
|
|
if (treeElement instanceof WI.CallFrameTreeElement) {
|
|
let callFrame = treeElement.callFrame;
|
|
if (callFrame.id)
|
|
WI.debuggerManager.activeCallFrame = callFrame;
|
|
|
|
if (callFrame.sourceCodeLocation)
|
|
WI.showSourceCodeLocation(callFrame.sourceCodeLocation, options);
|
|
|
|
return;
|
|
}
|
|
|
|
if (treeElement instanceof WI.IssueTreeElement) {
|
|
WI.showSourceCodeLocation(treeElement.issueMessage.sourceCodeLocation, options);
|
|
return;
|
|
}
|
|
|
|
if (!(treeElement instanceof WI.BreakpointTreeElement))
|
|
return;
|
|
|
|
let breakpoint = treeElement.breakpoint;
|
|
if (treeElement.treeOutline === this._pauseReasonTreeOutline) {
|
|
WI.showSourceCodeLocation(breakpoint.sourceCodeLocation, options);
|
|
return;
|
|
}
|
|
|
|
if (!treeElement.parent.representedObject)
|
|
return;
|
|
|
|
console.assert(treeElement.parent.representedObject instanceof WI.SourceCode);
|
|
if (!(treeElement.parent.representedObject instanceof WI.SourceCode))
|
|
return;
|
|
|
|
WI.showSourceCodeLocation(breakpoint.sourceCodeLocation, options);
|
|
}
|
|
|
|
_addTreeElement(treeElement, parentTreeElement)
|
|
{
|
|
if (!parentTreeElement)
|
|
parentTreeElement = this._breakpointsContentTreeOutline;
|
|
|
|
let comparator = (a, b) => {
|
|
const rankFunctions = [
|
|
(treeElement) => treeElement.representedObject === WI.debuggerManager.allExceptionsBreakpoint,
|
|
(treeElement) => treeElement.representedObject === WI.debuggerManager.uncaughtExceptionsBreakpoint,
|
|
(treeElement) => treeElement.representedObject === WI.debuggerManager.assertionFailuresBreakpoint,
|
|
(treeElement) => treeElement instanceof WI.BreakpointTreeElement || treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement,
|
|
(treeElement) => treeElement instanceof WI.EventBreakpointTreeElement,
|
|
(treeElement) => treeElement instanceof WI.DOMNodeTreeElement,
|
|
(treeElement) => treeElement.representedObject === DebuggerSidebarPanel.__windowEventTargetRepresentedObject,
|
|
(treeElement) => treeElement instanceof WI.DOMBreakpointTreeElement,
|
|
(treeElement) => treeElement.representedObject === WI.domDebuggerManager.allRequestsBreakpoint,
|
|
(treeElement) => treeElement instanceof WI.URLBreakpointTreeElement,
|
|
];
|
|
|
|
let aRank = rankFunctions.findIndex((rankFunction) => rankFunction(a));
|
|
let bRank = rankFunctions.findIndex((rankFunction) => rankFunction(b));
|
|
if (aRank >= 0 && bRank >= 0) {
|
|
if (aRank < bRank)
|
|
return -1;
|
|
if (bRank < aRank)
|
|
return 1;
|
|
}
|
|
|
|
if (a instanceof WI.BreakpointTreeElement && b instanceof WI.BreakpointTreeElement)
|
|
return this._compareBreakpointTreeElements(a, b);
|
|
|
|
return a.mainTitle.extendedLocaleCompare(b.mainTitle) || a.subtitle.extendedLocaleCompare(b.subtitle);
|
|
};
|
|
|
|
parentTreeElement.insertChild(treeElement, insertionIndexForObjectInListSortedByFunction(treeElement, parentTreeElement.children, comparator));
|
|
}
|
|
|
|
_compareBreakpointTreeElements(a, b)
|
|
{
|
|
if (!a.representedObject || !b.representedObject)
|
|
return 0;
|
|
|
|
let aLocation = a.representedObject.sourceCodeLocation;
|
|
let bLocation = b.representedObject.sourceCodeLocation;
|
|
if (!aLocation || !bLocation)
|
|
return 0;
|
|
|
|
var comparisonResult = aLocation.displayLineNumber - bLocation.displayLineNumber;
|
|
if (comparisonResult !== 0)
|
|
return comparisonResult;
|
|
|
|
return aLocation.displayColumnNumber - bLocation.displayColumnNumber;
|
|
}
|
|
|
|
_updatePauseReason()
|
|
{
|
|
this._pauseReasonTreeOutline = null;
|
|
|
|
this._updatePauseReasonGotoArrow();
|
|
return this._updatePauseReasonSection();
|
|
}
|
|
|
|
_updatePauseReasonSection()
|
|
{
|
|
let target = WI.debuggerManager.activeCallFrame.target;
|
|
let targetData = WI.debuggerManager.dataForTarget(target);
|
|
let {pauseReason, pauseData} = targetData;
|
|
|
|
switch (pauseReason) {
|
|
case WI.DebuggerManager.PauseReason.AnimationFrame:
|
|
console.assert(pauseData, "Expected data with an animation frame, but found none.");
|
|
if (!pauseData)
|
|
return false;
|
|
|
|
var eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.AnimationFrame, pauseData.eventName);
|
|
console.assert(eventBreakpoint, "Expected AnimationFrame breakpoint for event name.", pauseData.eventName);
|
|
if (!eventBreakpoint)
|
|
return false;
|
|
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
|
|
var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(eventBreakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: WI.UIString("%s Fired").format(pauseData.eventName),
|
|
});
|
|
this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
|
|
|
|
var eventBreakpointRow = new WI.DetailsSectionRow;
|
|
eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
this._pauseReasonGroup.rows = [eventBreakpointRow];
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.Assertion:
|
|
// FIXME: We should include the assertion condition string.
|
|
console.assert(pauseData, "Expected data with an assertion, but found none.");
|
|
if (pauseData && pauseData.message) {
|
|
this._pauseReasonTextRow.text = WI.UIString("Assertion with message: %s").format(pauseData.message);
|
|
return true;
|
|
}
|
|
|
|
this._pauseReasonTextRow.text = WI.UIString("Assertion Failed");
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.Breakpoint:
|
|
console.assert(pauseData, "Expected breakpoint identifier, but found none.");
|
|
if (pauseData && pauseData.breakpointId) {
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
this._pauseReasonTreeOutline.addEventListener(WI.TreeOutline.Event.SelectionDidChange, this._treeSelectionDidChange, this);
|
|
|
|
let breakpoint = WI.debuggerManager.breakpointForIdentifier(pauseData.breakpointId);
|
|
let breakpointTreeElement = new WI.BreakpointTreeElement(breakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: WI.UIString("Triggered Breakpoint"),
|
|
});
|
|
let breakpointDetailsSection = new WI.DetailsSectionRow;
|
|
this._pauseReasonTreeOutline.appendChild(breakpointTreeElement);
|
|
breakpointDetailsSection.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
this._pauseReasonGroup.rows = [breakpointDetailsSection];
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case WI.DebuggerManager.PauseReason.CSPViolation:
|
|
console.assert(pauseData, "Expected data with a CSP Violation, but found none.");
|
|
if (pauseData) {
|
|
// COMPATIBILITY (iOS 8): 'directive' was 'directiveText'.
|
|
this._pauseReasonTextRow.text = WI.UIString("Content Security Policy violation of directive: %s").format(pauseData.directive || pauseData.directiveText);
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case WI.DebuggerManager.PauseReason.DebuggerStatement:
|
|
this._pauseReasonTextRow.text = WI.UIString("Debugger Statement");
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.DOM:
|
|
console.assert(WI.domDebuggerManager.supported);
|
|
console.assert(pauseData, "Expected DOM breakpoint data, but found none.");
|
|
if (pauseData && pauseData.nodeId) {
|
|
let domNode = WI.domManager.nodeForId(pauseData.nodeId);
|
|
let domBreakpoints = WI.domDebuggerManager.domBreakpointsForNode(domNode);
|
|
let domBreakpoint;
|
|
for (let breakpoint of domBreakpoints) {
|
|
if (breakpoint.type === pauseData.type) {
|
|
domBreakpoint = breakpoint;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!domBreakpoint)
|
|
return;
|
|
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
|
|
let type = WI.DOMBreakpointTreeElement.displayNameForType(domBreakpoint.type);
|
|
let domBreakpointTreeElement = new WI.DOMBreakpointTreeElement(domBreakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: type,
|
|
});
|
|
let domBreakpointRow = new WI.DetailsSectionRow;
|
|
this._pauseReasonTreeOutline.appendChild(domBreakpointTreeElement);
|
|
domBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
let ownerElementRow = new WI.DetailsSectionSimpleRow(WI.UIString("Element"), WI.linkifyNodeReference(domNode));
|
|
this._pauseReasonGroup.rows = [domBreakpointRow, ownerElementRow];
|
|
|
|
if (domBreakpoint.type !== WI.DOMBreakpoint.Type.SubtreeModified)
|
|
return true;
|
|
|
|
console.assert(pauseData.targetNode);
|
|
|
|
let remoteObject = WI.RemoteObject.fromPayload(pauseData.targetNode, target);
|
|
remoteObject.pushNodeToFrontend((nodeId) => {
|
|
if (!nodeId)
|
|
return;
|
|
|
|
let node = WI.domManager.nodeForId(nodeId);
|
|
console.assert(node, "Missing node for id.", nodeId);
|
|
if (!node)
|
|
return;
|
|
|
|
let fragment = document.createDocumentFragment();
|
|
let description = pauseData.insertion ? WI.UIString("Child added to ") : WI.UIString("Removed descendant ");
|
|
fragment.append(description, WI.linkifyNodeReference(node));
|
|
|
|
let targetDescriptionRow = new WI.DetailsSectionSimpleRow(WI.UIString("Details"), fragment);
|
|
targetDescriptionRow.element.classList.add("target-description");
|
|
|
|
this._pauseReasonGroup.rows = this._pauseReasonGroup.rows.concat(targetDescriptionRow);
|
|
});
|
|
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case WI.DebuggerManager.PauseReason.EventListener:
|
|
console.assert(pauseData, "Expected data with an event listener, but found none.");
|
|
if (!pauseData)
|
|
return false;
|
|
|
|
var eventBreakpoint = null;
|
|
if (pauseData.eventListenerId)
|
|
eventBreakpoint = WI.domManager.breakpointForEventListenerId(pauseData.eventListenerId);
|
|
if (!eventBreakpoint)
|
|
eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Listener, pauseData.eventName);
|
|
|
|
console.assert(eventBreakpoint, "Expected Event Listener breakpoint for event name.", pauseData.eventName);
|
|
if (!eventBreakpoint)
|
|
return false;
|
|
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
|
|
var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(eventBreakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: WI.UIString("\u201C%s\u201D Event Fired").format(pauseData.eventName),
|
|
});
|
|
this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
|
|
|
|
var eventBreakpointRow = new WI.DetailsSectionRow;
|
|
eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
var rows = [eventBreakpointRow];
|
|
|
|
var eventListener = eventBreakpoint.eventListener;
|
|
if (eventListener) {
|
|
console.assert(eventListener.eventListenerId === pauseData.eventListenerId);
|
|
|
|
let value = null;
|
|
if (eventListener.onWindow)
|
|
value = WI.unlocalizedString("window");
|
|
else if (eventListener.node)
|
|
value = WI.linkifyNodeReference(eventListener.node);
|
|
if (value)
|
|
rows.push(new WI.DetailsSectionSimpleRow(WI.UIString("Target"), value));
|
|
}
|
|
|
|
this._pauseReasonGroup.rows = rows;
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.Exception:
|
|
console.assert(pauseData, "Expected data with an exception, but found none.");
|
|
if (pauseData) {
|
|
// FIXME: We should improve the appearance of thrown objects. This works well for exception strings.
|
|
var data = WI.RemoteObject.fromPayload(pauseData, target);
|
|
this._pauseReasonTextRow.text = WI.UIString("Exception with thrown value: %s").format(data.description);
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case WI.DebuggerManager.PauseReason.PauseOnNextStatement:
|
|
this._pauseReasonTextRow.text = WI.UIString("Immediate Pause Requested");
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.Timer:
|
|
console.assert(pauseData, "Expected data with a timer, but found none.");
|
|
if (!pauseData)
|
|
return false;
|
|
|
|
var eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Timer, pauseData.eventName);
|
|
console.assert(eventBreakpoint, "Expected Timer breakpoint for event name.", pauseData.eventName);
|
|
if (!eventBreakpoint)
|
|
return false;
|
|
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
|
|
var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(eventBreakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: WI.UIString("%s Fired").format(pauseData.eventName),
|
|
});
|
|
this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
|
|
|
|
var eventBreakpointRow = new WI.DetailsSectionRow;
|
|
eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
this._pauseReasonGroup.rows = [eventBreakpointRow];
|
|
return true;
|
|
|
|
case WI.DebuggerManager.PauseReason.Fetch:
|
|
case WI.DebuggerManager.PauseReason.XHR:
|
|
console.assert(WI.domDebuggerManager.supported);
|
|
console.assert(pauseData, "Expected URL breakpoint data, but found none.");
|
|
if (pauseData) {
|
|
if (pauseData.breakpointURL) {
|
|
let urlBreakpoint = WI.domDebuggerManager.urlBreakpointForURL(pauseData.breakpointURL);
|
|
console.assert(urlBreakpoint, "Expected URL breakpoint for URL.", pauseData.breakpointURL);
|
|
|
|
this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
|
|
|
|
let urlBreakpointTreeElement = new WI.URLBreakpointTreeElement(urlBreakpoint, {
|
|
className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
|
|
title: WI.DOMDebuggerManager.supportsURLBreakpoints() ? WI.UIString("Triggered URL Breakpoint") : WI.UIString("Triggered XHR Breakpoint"),
|
|
});
|
|
let urlBreakpointRow = new WI.DetailsSectionRow;
|
|
this._pauseReasonTreeOutline.appendChild(urlBreakpointTreeElement);
|
|
urlBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
|
|
|
|
this._pauseReasonTextRow.text = pauseData.url;
|
|
this._pauseReasonGroup.rows = [urlBreakpointRow, this._pauseReasonTextRow];
|
|
} else {
|
|
console.assert(pauseData.breakpointURL === "", "Should be the All Requests breakpoint which has an empty URL");
|
|
this._pauseReasonTextRow.text = WI.UIString("Requesting: %s").format(pauseData.url);
|
|
this._pauseReasonGroup.rows = [this._pauseReasonTextRow];
|
|
}
|
|
this._pauseReasonTextRow.element.title = pauseData.url;
|
|
return true;
|
|
}
|
|
break;
|
|
|
|
case WI.DebuggerManager.PauseReason.Other:
|
|
console.error("Paused for unknown reason. We should always have a reason.");
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
_updatePauseReasonGotoArrow()
|
|
{
|
|
this._pauseReasonLinkContainerElement.removeChildren();
|
|
|
|
var activeCallFrame = WI.debuggerManager.activeCallFrame;
|
|
if (!activeCallFrame)
|
|
return;
|
|
|
|
var sourceCodeLocation = activeCallFrame.sourceCodeLocation;
|
|
if (!sourceCodeLocation)
|
|
return;
|
|
|
|
const options = {
|
|
useGoToArrowButton: true,
|
|
ignoreNetworkTab: true,
|
|
ignoreSearchTab: true,
|
|
};
|
|
let linkElement = WI.createSourceCodeLocationLink(sourceCodeLocation, options);
|
|
this._pauseReasonLinkContainerElement.appendChild(linkElement);
|
|
}
|
|
|
|
_addIssue(issueMessage)
|
|
{
|
|
let issueTreeElement = this._scriptsContentTreeOutline.findTreeElement(issueMessage);
|
|
if (issueTreeElement)
|
|
return issueTreeElement;
|
|
|
|
let parentTreeElement = this._addTreeElementForSourceCodeToTreeOutline(issueMessage.sourceCodeLocation.sourceCode, this._scriptsContentTreeOutline);
|
|
if (!parentTreeElement)
|
|
return null;
|
|
|
|
issueTreeElement = new WI.IssueTreeElement(issueMessage);
|
|
|
|
parentTreeElement.insertChild(issueTreeElement, insertionIndexForObjectInListSortedByFunction(issueTreeElement, parentTreeElement.children, this._compareBreakpointTreeElements));
|
|
if (parentTreeElement.children.length === 1)
|
|
parentTreeElement.expand();
|
|
|
|
return issueTreeElement;
|
|
}
|
|
|
|
_handleDOMBreakpointDOMNodeChanged(event)
|
|
{
|
|
let breakpoint = event.target;
|
|
if (breakpoint.domNodeIdentifier)
|
|
this._addBreakpoint(breakpoint);
|
|
else
|
|
this._removeBreakpoint(breakpoint);
|
|
}
|
|
|
|
_handleIssueAdded(event)
|
|
{
|
|
var issue = event.data.issue;
|
|
|
|
// We only want to show issues originating from JavaScript source code.
|
|
if (!issue.sourceCodeLocation || !issue.sourceCodeLocation.sourceCode || (issue.source !== "javascript" && issue.source !== "console-api"))
|
|
return;
|
|
|
|
this._addIssue(issue);
|
|
}
|
|
|
|
_handleIssuesCleared(event)
|
|
{
|
|
let currentTreeElement = this._scriptsContentTreeOutline.children[0];
|
|
let issueTreeElements = [];
|
|
|
|
while (currentTreeElement && !currentTreeElement.root) {
|
|
if (currentTreeElement instanceof WI.IssueTreeElement)
|
|
issueTreeElements.push(currentTreeElement);
|
|
currentTreeElement = currentTreeElement.traverseNextTreeElement(false, null, true);
|
|
}
|
|
|
|
issueTreeElements.forEach((treeElement) => treeElement.parent.removeChild(treeElement));
|
|
}
|
|
|
|
_handleBreakpointElementAddedOrRemoved(event)
|
|
{
|
|
let treeElement = event.data.element;
|
|
|
|
let setting = null;
|
|
if (treeElement.breakpoint === WI.debuggerManager.assertionFailuresBreakpoint)
|
|
setting = WI.settings.showAssertionFailuresBreakpoint;
|
|
else if (treeElement.representedObject === WI.domDebuggerManager.allRequestsBreakpoint)
|
|
setting = WI.settings.showAllRequestsBreakpoint;
|
|
|
|
if (setting)
|
|
setting.value = !!treeElement.parent;
|
|
}
|
|
|
|
_handleCreateBreakpointMouseDown(event)
|
|
{
|
|
if (this._ignoreCreateBreakpointMouseDown)
|
|
return;
|
|
|
|
this._ignoreCreateBreakpointMouseDown = true;
|
|
|
|
let contextMenu = WI.ContextMenu.createFromEvent(event);
|
|
contextMenu.addBeforeShowCallback(() => {
|
|
this._ignoreCreateBreakpointMouseDown = false;
|
|
});
|
|
|
|
// COMPATIBILITY (iOS 10): DebuggerAgent.setPauseOnAssertions did not exist yet.
|
|
if (InspectorBackend.domains.Debugger.setPauseOnAssertions) {
|
|
let assertionFailuresBreakpointShown = WI.settings.showAssertionFailuresBreakpoint.value;
|
|
|
|
contextMenu.appendCheckboxItem(WI.repeatedUIString.assertionFailures(), () => {
|
|
if (assertionFailuresBreakpointShown)
|
|
WI.debuggerManager.removeBreakpoint(WI.debuggerManager.assertionFailuresBreakpoint);
|
|
else {
|
|
WI.debuggerManager.assertionFailuresBreakpoint.disabled = false;
|
|
WI.debuggerManager.addBreakpoint(WI.debuggerManager.assertionFailuresBreakpoint);
|
|
}
|
|
}, assertionFailuresBreakpointShown);
|
|
}
|
|
|
|
if (WI.domDebuggerManager.supported) {
|
|
contextMenu.appendSeparator();
|
|
|
|
contextMenu.appendItem(WI.UIString("Event Breakpoint\u2026"), () => {
|
|
let popover = new WI.EventBreakpointPopover(this);
|
|
popover.show(this._createBreakpointButton.element, [WI.RectEdge.MAX_Y, WI.RectEdge.MIN_Y, WI.RectEdge.MAX_X]);
|
|
});
|
|
|
|
contextMenu.appendSeparator();
|
|
|
|
let allRequestsBreakpointShown = WI.settings.showAllRequestsBreakpoint.value;
|
|
|
|
contextMenu.appendCheckboxItem(WI.repeatedUIString.allRequests(), () => {
|
|
if (allRequestsBreakpointShown)
|
|
WI.domDebuggerManager.removeURLBreakpoint(WI.domDebuggerManager.allRequestsBreakpoint);
|
|
else {
|
|
WI.domDebuggerManager.allRequestsBreakpoint.disabled = false;
|
|
WI.domDebuggerManager.addURLBreakpoint(WI.domDebuggerManager.allRequestsBreakpoint);
|
|
}
|
|
}, allRequestsBreakpointShown);
|
|
|
|
contextMenu.appendItem(WI.DOMDebuggerManager.supportsURLBreakpoints() ? WI.UIString("URL Breakpoint\u2026") : WI.UIString("XHR Breakpoint\u2026"), () => {
|
|
let popover = new WI.URLBreakpointPopover(this);
|
|
popover.show(this._createBreakpointButton.element, [WI.RectEdge.MAX_Y, WI.RectEdge.MIN_Y, WI.RectEdge.MAX_X]);
|
|
});
|
|
}
|
|
|
|
contextMenu.show();
|
|
}
|
|
};
|
|
|
|
WI.DebuggerSidebarPanel.DebuggerPausedStyleClassName = "paused";
|
|
WI.DebuggerSidebarPanel.ExceptionIconStyleClassName = "breakpoint-exception-icon";
|
|
WI.DebuggerSidebarPanel.AssertionIconStyleClassName = "breakpoint-assertion-icon";
|
|
WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName = "breakpoint-paused-icon";
|
|
|
|
WI.DebuggerSidebarPanel.SelectedAllExceptionsCookieKey = "debugger-sidebar-panel-all-exceptions-breakpoint";
|
|
WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey = "debugger-sidebar-panel-uncaught-exceptions-breakpoint";
|
|
WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey = "debugger-sidebar-panel-assertion-failures-breakpoint";
|
|
WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey = "debugger-sidebar-panel-all-requests-breakpoint";
|