Attachment 373308 Details for Bug 199332 – Patch

[patch] Patch

bug-199332-20190702000917.patch (text/plain), 27.80 KB, created by Devin Rousso on 2019-07-02 00:09:18 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Devin Rousso

Created: 2019-07-02 00:09:18 PDT

Size: 27.80 KB

patch

obsolete

>diff --git a/Source/WebInspectorUI/ChangeLog b/Source/WebInspectorUI/ChangeLog
>index 915cc2e7361997beadd4d59d0c8eb1df4acfce81..22cd1263f4660b782cf5c750905bb1b6e25f3335 100644
>--- a/Source/WebInspectorUI/ChangeLog
>+++ b/Source/WebInspectorUI/ChangeLog
>@@ -1,3 +1,60 @@
>+2019-07-02  Devin Rousso  <drousso@apple.com>
>+
>+        Web Inspector: DOM Debugger: descendant breakpoints should be able to be enabled/disabled/deleted from a collapsed parent
>+        https://bugs.webkit.org/show_bug.cgi?id=199332
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * UserInterface/Controllers/DOMDebuggerManager.js:
>+        (WI.DOMDebuggerManager.prototype.get domBreakpoints):
>+        (WI.DOMDebuggerManager.prototype.domBreakpointsForNode):
>+        (WI.DOMDebuggerManager.prototype.domBreakpointsInSubtree): Added.
>+        (WI.DOMDebuggerManager.prototype.removeDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._detachDOMBreakpoint):
>+        (WI.DOMDebuggerManager.prototype._detachBreakpointsForFrame):
>+        (WI.DOMDebuggerManager.prototype._speculativelyResolveDOMBreakpointsForURL):
>+        (WI.DOMDebuggerManager.prototype._resolveDOMBreakpoint):
>+        Provide a way of getting a "summary" array of `DOMBreakpoint`s for all descendant nodes.
>+        Rework the data structure for holding `DOMBreakpoint`s to use a `Multimap` so no duplicates
>+        can be added (it uses a `Set` instead of an `Array`).
>+
>+        * UserInterface/Views/DOMTreeElement.js:
>+        (WI.DOMTreeElement):
>+        (WI.DOMTreeElement.prototype.get hasBreakpoint):
>+        (WI.DOMTreeElement.prototype.set breakpointStatus):
>+        (WI.DOMTreeElement.prototype.bindRevealDescendantBreakpointsMenuItemHandler): Added.
>+        (WI.DOMTreeElement.prototype._subtreeBreakpointChanged): Added.
>+        (WI.DOMTreeElement.prototype._updateBreakpointStatus):
>+        (WI.DOMTreeElement.prototype._statusImageContextmenu):
>+        (WI.DOMTreeElement.prototype.subtreeBreakpointCountDidChange): Deleted.
>+        * UserInterface/Views/DOMTreeOutline.js:
>+        (WI.DOMTreeOutline.prototype.populateContextMenu):
>+        * UserInterface/Views/ContextMenuUtilities.js:
>+        (WI.appendContextMenuItemsForDOMNode):
>+        (WI.appendContextMenuItemsForDOMNodeBreakpoints):
>+        Keep track of the actual descendant `DOMNodeTreeElement` that have breakpoints, rather than
>+        just a count, so that the "Reveal Descendant Breakpoints" action is able to access them.
>+        Change "Reveal Descendant Breakpoints" to reveal and select all descendant breakpoints
>+        instead of just the first one.
>+        Drive-by: don't remove specific (event) listener breakpoints when invoking the
>+                  "Delete Descendant Breakpoints" action, as that's not obvious from the UI.
>+
>+        * UserInterface/Controllers/BreakpointPopoverController.js:
>+        (WI.BreakpointPopoverController.prototype.appendContextMenuItems):
>+        * UserInterface/Views/DOMBreakpointTreeElement.js:
>+        (WI.DOMBreakpointTreeElement.prototype.populateContextMenu):
>+        * UserInterface/Views/DOMNodeTreeElement.js:
>+        (WI.DOMNodeTreeElement.prototype.populateContextMenu):
>+        * UserInterface/Views/EventBreakpointTreeElement.js:
>+        (WI.EventBreakpointTreeElement.prototype.populateContextMenu):
>+        * UserInterface/Views/URLBreakpointTreeElement.js:
>+        (WI.URLBreakpointTreeElement.prototype.populateContextMenu):
>+        Remove the separator before "Delete Breakpoint" so all breakpoint actions are in the same section.
>+
>+        * Localizations/en.lproj/localizedStrings.js:
>+        * UserInterface/Base/Multimap.js:
>+        (Multimap.prototype.get size): Added.
>+
> 2019-06-27  Beth Dakin  <bdakin@apple.com>
> 
>         Upstream use of MACCATALYST
>diff --git a/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js b/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js
>index 29c1ebdb9abe7509fb5346ca2040964d8c2fa589..e3ac42c7af6c05766606269d67b2c2686c54dc99 100644
>--- a/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js
>+++ b/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js
>@@ -323,6 +323,7 @@ localizedStrings["Default"] = "Default";
> localizedStrings["Delete"] = "Delete";
> localizedStrings["Delete Breakpoint"] = "Delete Breakpoint";
> localizedStrings["Delete Breakpoints"] = "Delete Breakpoints";
>+localizedStrings["Delete Descendant Breakpoints"] = "Delete Descendant Breakpoints";
> localizedStrings["Demo Audit"] = "Demo Audit";
> localizedStrings["Detach into separate window"] = "Detach into separate window";
> localizedStrings["Detached"] = "Detached";
>@@ -332,6 +333,7 @@ localizedStrings["Diagnoses common accessibility problems affecting screen reade
> localizedStrings["Dimensions"] = "Dimensions";
> localizedStrings["Disable Breakpoint"] = "Disable Breakpoint";
> localizedStrings["Disable Breakpoints"] = "Disable Breakpoints";
>+localizedStrings["Disable Descendant Breakpoints"] = "Disable Descendant Breakpoints";
> localizedStrings["Disable Event Listener"] = "Disable Event Listener";
> localizedStrings["Disable ICE Candidate Restrictions"] = "Disable ICE Candidate Restrictions";
> localizedStrings["Disable Program"] = "Disable Program";
>@@ -403,6 +405,7 @@ localizedStrings["Elements"] = "Elements";
> localizedStrings["Emulate User Gesture"] = "Emulate User Gesture";
> localizedStrings["Enable Breakpoint"] = "Enable Breakpoint";
> localizedStrings["Enable Breakpoints"] = "Enable Breakpoints";
>+localizedStrings["Enable Descendant Breakpoints"] = "Enable Descendant Breakpoints";
> localizedStrings["Enable Event Listener"] = "Enable Event Listener";
> localizedStrings["Enable Layers Tab"] = "Enable Layers Tab";
> localizedStrings["Enable New Tab Bar"] = "Enable New Tab Bar";
>@@ -881,7 +884,7 @@ localizedStrings["Return string must be one of %s"] = "Return string must be one
> localizedStrings["Return type for anonymous function"] = "Return type for anonymous function";
> localizedStrings["Return type for function: %s"] = "Return type for function: %s";
> localizedStrings["Return value is not an object, string, or boolean"] = "Return value is not an object, string, or boolean";
>-localizedStrings["Reveal Breakpoint"] = "Reveal Breakpoint";
>+localizedStrings["Reveal Descendant Breakpoints"] = "Reveal Descendant Breakpoints";
> /* Open Elements tab and select this node in DOM tree */
> localizedStrings["Reveal in DOM Tree"] = "Reveal in DOM Tree";
> localizedStrings["Reveal in Debugger Tab"] = "Reveal in Debugger Tab";
>diff --git a/Source/WebInspectorUI/UserInterface/Base/Multimap.js b/Source/WebInspectorUI/UserInterface/Base/Multimap.js
>index 500eac0d39bcaa82a955166468bb5893210b6d0f..3d69eb028d795a32c1707282edcb9d3645df0d40 100644
>--- a/Source/WebInspectorUI/UserInterface/Base/Multimap.js
>+++ b/Source/WebInspectorUI/UserInterface/Base/Multimap.js
>@@ -35,6 +35,11 @@ class Multimap
> 
>     // Public
> 
>+    get size()
>+    {
>+        return this._map.size;
>+    }
>+
>     has(key, value)
>     {
>         let valueSet = this._map.get(key);
>diff --git a/Source/WebInspectorUI/UserInterface/Controllers/BreakpointPopoverController.js b/Source/WebInspectorUI/UserInterface/Controllers/BreakpointPopoverController.js
>index 0230507ec7198c5be070e29181a315b2b3d036e6..a23fef432f36dbcb696f303e651f09e1c2fb1f17 100644
>--- a/Source/WebInspectorUI/UserInterface/Controllers/BreakpointPopoverController.js
>+++ b/Source/WebInspectorUI/UserInterface/Controllers/BreakpointPopoverController.js
>@@ -88,10 +88,8 @@ WI.BreakpointPopoverController = class BreakpointPopoverController extends WI.Ob
>         if (!breakpoint.autoContinue && !breakpoint.disabled && breakpoint.actions.length)
>             contextMenu.appendItem(WI.UIString("Set to Automatically Continue"), toggleAutoContinue);
> 
>-        if (WI.debuggerManager.isBreakpointRemovable(breakpoint)) {
>-            contextMenu.appendSeparator();
>+        if (WI.debuggerManager.isBreakpointRemovable(breakpoint))
>             contextMenu.appendItem(WI.UIString("Delete Breakpoint"), removeBreakpoint);
>-        }
> 
>         if (breakpoint._sourceCodeLocation.hasMappedLocation()) {
>             contextMenu.appendSeparator();
>diff --git a/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js b/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>index 69ce6d199e23a9554019edab4dbbea6f9792d319..dd88a635943d9b47e938638392788244180d078a 100644
>--- a/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>+++ b/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js
>@@ -146,10 +146,8 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         while (frames.length) {
>             let frame = frames.shift();
>             let domBreakpointNodeIdentifierMap = this._domBreakpointFrameIdentifierMap.get(frame.id);
>-            if (domBreakpointNodeIdentifierMap) {
>-                for (let breakpoints of domBreakpointNodeIdentifierMap.values())
>-                    resolvedBreakpoints = resolvedBreakpoints.concat(breakpoints);
>-            }
>+            if (domBreakpointNodeIdentifierMap)
>+                resolvedBreakpoints = resolvedBreakpoints.concat(Array.from(domBreakpointNodeIdentifierMap.values()));
> 
>             frames.push(...frame.childFrameCollection);
>         }
>@@ -178,7 +176,26 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>             return [];
> 
>         let breakpoints = domBreakpointNodeIdentifierMap.get(node.id);
>-        return breakpoints ? breakpoints.slice() : [];
>+        return breakpoints ? Array.from(breakpoints) : [];
>+    }
>+
>+    domBreakpointsInSubtree(node)
>+    {
>+        console.assert(node instanceof WI.DOMNode);
>+
>+        let breakpoints = [];
>+
>+        if (node.children) {
>+            let children = Array.from(node.children);
>+            while (children.length) {
>+                let child = children.pop();
>+                if (child.children)
>+                    children = children.concat(child.children);
>+                breakpoints = breakpoints.concat(this.domBreakpointsForNode(child));
>+            }
>+        }
>+
>+        return breakpoints;
>     }
> 
>     addDOMBreakpoint(breakpoint)
>@@ -215,11 +232,6 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>             return;
>         }
> 
>-        let nodeIdentifier = breakpoint.domNodeIdentifier;
>-        console.assert(nodeIdentifier, "Cannot remove unresolved DOM breakpoint.");
>-        if (!nodeIdentifier)
>-            return;
>-
>         this._detachDOMBreakpoint(breakpoint);
> 
>         this._domBreakpointURLMap.delete(breakpoint.url);
>@@ -227,7 +239,7 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         if (!breakpoint.disabled) {
>             // We should get the target associated with the nodeIdentifier of this breakpoint.
>             let target = WI.assumingMainTarget();
>-            target.DOMDebuggerAgent.removeDOMBreakpoint(nodeIdentifier, breakpoint.type);
>+            target.DOMDebuggerAgent.removeDOMBreakpoint(breakpoint.domNodeIdentifier, breakpoint.type);
>         }
> 
>         this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, {breakpoint});
>@@ -406,17 +418,7 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         if (!domBreakpointNodeIdentifierMap)
>             return;
> 
>-        let breakpoints = domBreakpointNodeIdentifierMap.get(nodeIdentifier);
>-        console.assert(breakpoints, "Missing DOM breakpoints for node.", node);
>-        if (!breakpoints)
>-            return;
>-
>-        breakpoints.remove(breakpoint, true);
>-
>-        if (breakpoints.length)
>-            return;
>-
>-        domBreakpointNodeIdentifierMap.delete(nodeIdentifier);
>+        domBreakpointNodeIdentifierMap.delete(nodeIdentifier, breakpoint);
> 
>         if (!domBreakpointNodeIdentifierMap.size)
>             this._domBreakpointFrameIdentifierMap.delete(frameIdentifier);
>@@ -430,10 +432,8 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
> 
>         this._domBreakpointFrameIdentifierMap.delete(frame.id);
> 
>-        for (let breakpoints of domBreakpointNodeIdentifierMap.values()) {
>-            for (let breakpoint of breakpoints)
>-                breakpoint.domNodeIdentifier = null;
>-        }
>+        for (let breakpoint of domBreakpointNodeIdentifierMap.values())
>+            breakpoint.domNodeIdentifier = null;
>     }
> 
>     _speculativelyResolveDOMBreakpointsForURL(url)
>@@ -447,6 +447,14 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>                 continue;
> 
>             WI.domManager.pushNodeByPathToFrontend(breakpoint.path, (nodeIdentifier) => {
>+                if (breakpoint.domNodeIdentifier) {
>+                    // This breakpoint may have been resolved by a node being inserted before this
>+                    // callback is invoked.  If so, the `nodeIdentifier` should match, so don't try
>+                    // to resolve it again as it would've already been resolved.
>+                    console.assert(breakpoint.domNodeIdentifier === nodeIdentifier);
>+                    return;
>+                }
>+
>                 if (nodeIdentifier)
>                     this._resolveDOMBreakpoint(breakpoint, nodeIdentifier);
>             });
>@@ -463,15 +471,11 @@ WI.DOMDebuggerManager = class DOMDebuggerManager extends WI.Object
>         let frameIdentifier = node.frame.id;
>         let domBreakpointNodeIdentifierMap = this._domBreakpointFrameIdentifierMap.get(frameIdentifier);
>         if (!domBreakpointNodeIdentifierMap) {
>-            domBreakpointNodeIdentifierMap = new Map;
>+            domBreakpointNodeIdentifierMap = new Multimap;
>             this._domBreakpointFrameIdentifierMap.set(frameIdentifier, domBreakpointNodeIdentifierMap);
>         }
> 
>-        let breakpoints = domBreakpointNodeIdentifierMap.get(nodeIdentifier);
>-        if (breakpoints)
>-            breakpoints.push(breakpoint);
>-        else
>-            domBreakpointNodeIdentifierMap.set(nodeIdentifier, [breakpoint]);
>+        domBreakpointNodeIdentifierMap.add(nodeIdentifier, breakpoint);
> 
>         breakpoint.domNodeIdentifier = nodeIdentifier;
> 
>diff --git a/Source/WebInspectorUI/UserInterface/Views/ContextMenuUtilities.js b/Source/WebInspectorUI/UserInterface/Views/ContextMenuUtilities.js
>index 3e395c515a364b3fa1054429a30e69914e24021a..5c27e2bef517a3f985ed2224d59d48a1b14ab1f5 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/ContextMenuUtilities.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/ContextMenuUtilities.js
>@@ -224,7 +224,7 @@ WI.appendContextMenuItemsForDOMNode = function(contextMenu, domNode, options = {
>     if (WI.domDebuggerManager.supported && isElement && !domNode.isPseudoElement() && attached) {
>         contextMenu.appendSeparator();
> 
>-        WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, domNode);
>+        WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, domNode, options);
>     }
> 
>     contextMenu.appendSeparator();
>@@ -284,43 +284,64 @@ WI.appendContextMenuItemsForDOMNode = function(contextMenu, domNode, options = {
>     contextMenu.appendSeparator();
> };
> 
>-WI.appendContextMenuItemsForDOMNodeBreakpoints = function(contextMenu, domNode, {allowEditing} = {})
>+WI.appendContextMenuItemsForDOMNodeBreakpoints = function(contextMenu, domNode, options = {})
> {
>     if (contextMenu.__domBreakpointItemsAdded)
>         return;
> 
>     contextMenu.__domBreakpointItemsAdded = true;
> 
>-    let subMenu = contextMenu.appendSubMenuItem(WI.UIString("Break on"));
>-
>     let breakpoints = WI.domDebuggerManager.domBreakpointsForNode(domNode);
>-    let keyValuePairs = breakpoints.map((breakpoint) => [breakpoint.type, breakpoint]);
>-    let breakpointsByType = new Map(keyValuePairs);
>+
>+    contextMenu.appendSeparator();
>+
>+    let subMenu = contextMenu.appendSubMenuItem(WI.UIString("Break on"));
> 
>     for (let type of Object.values(WI.DOMBreakpoint.Type)) {
>         let label = WI.DOMBreakpointTreeElement.displayNameForType(type);
>-        let breakpoint = breakpointsByType.get(type);
>+        let breakpoint = breakpoints.find((breakpoint) => breakpoint.type === type);
> 
>         subMenu.appendCheckboxItem(label, function() {
>             if (breakpoint)
>                 WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
>             else
>                 WI.domDebuggerManager.addDOMBreakpoint(new WI.DOMBreakpoint(domNode, type));
>-        }, !!breakpoint, false);
>+        }, !!breakpoint);
>     }
> 
>-    if (allowEditing) {
>-        contextMenu.appendSeparator();
>+    contextMenu.appendSeparator();
> 
>+    if (breakpoints.length) {
>         let shouldEnable = breakpoints.some((breakpoint) => breakpoint.disabled);
>-        let label = shouldEnable ? WI.UIString("Enable Breakpoints") : WI.UIString("Disable Breakpoints");
>-        contextMenu.appendItem(label, () => {
>-            breakpoints.forEach((breakpoint) => breakpoint.disabled = !shouldEnable);
>+        contextMenu.appendItem(shouldEnable ? WI.UIString("Enable Breakpoint") : WI.UIString("Disable Breakpoint"), () => {
>+            for (let breakpoint of breakpoints)
>+                breakpoint.disabled = !shouldEnable;
>         });
> 
>-        contextMenu.appendItem(WI.UIString("Delete Breakpoints"), function() {
>-            WI.domDebuggerManager.removeDOMBreakpointsForNode(domNode);
>-            WI.domManager.removeEventListenerBreakpointsForNode(domNode);
>+        contextMenu.appendItem(WI.UIString("Delete Breakpoint"), () => {
>+            for (let breakpoint of breakpoints)
>+                WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
>         });
>+
>+        contextMenu.appendSeparator();
>+    }
>+
>+    let subtreeBreakpoints = WI.domDebuggerManager.domBreakpointsInSubtree(domNode);
>+    if (subtreeBreakpoints.length) {
>+        if (options.revealDescendantBreakpointsMenuItemHandler)
>+            contextMenu.appendItem(WI.UIString("Reveal Descendant Breakpoints"), options.revealDescendantBreakpointsMenuItemHandler);
>+
>+        let subtreeShouldEnable = subtreeBreakpoints.some((breakpoint) => breakpoint.disabled);
>+        contextMenu.appendItem(subtreeShouldEnable ? WI.UIString("Enable Descendant Breakpoints") : WI.UIString("Disable Descendant Breakpoints"), () => {
>+            for (let subtreeBreakpoint of subtreeBreakpoints)
>+                subtreeBreakpoint.disabled = !subtreeShouldEnable;
>+        });
>+
>+        contextMenu.appendItem(WI.UIString("Delete Descendant Breakpoints"), () => {
>+            for (let subtreeBreakpoint of subtreeBreakpoints)
>+                WI.domDebuggerManager.removeDOMBreakpoint(subtreeBreakpoint);
>+        });
>+
>+        contextMenu.appendSeparator();
>     }
> };
>diff --git a/Source/WebInspectorUI/UserInterface/Views/DOMBreakpointTreeElement.js b/Source/WebInspectorUI/UserInterface/Views/DOMBreakpointTreeElement.js
>index 991d716db5afaca58f3588348a58db83491fc946..c0cc5a1a7bd3f6c6fb9f4ad69658d45ce662a1e7 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/DOMBreakpointTreeElement.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/DOMBreakpointTreeElement.js
>@@ -126,7 +126,6 @@ WI.DOMBreakpointTreeElement = class DOMBreakpointTreeElement extends WI.GeneralT
>         let label = breakpoint.disabled ? WI.UIString("Enable Breakpoint") : WI.UIString("Disable Breakpoint");
>         contextMenu.appendItem(label, this._toggleBreakpoint.bind(this));
> 
>-        contextMenu.appendSeparator();
>         contextMenu.appendItem(WI.UIString("Delete Breakpoint"), function() {
>             WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
>         });
>diff --git a/Source/WebInspectorUI/UserInterface/Views/DOMNodeTreeElement.js b/Source/WebInspectorUI/UserInterface/Views/DOMNodeTreeElement.js
>index adaff3faae8f2b826912b19b19f1882e8c537de2..bf0d97993f0ab31fc1d3f822e7b87817c5288a24 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/DOMNodeTreeElement.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/DOMNodeTreeElement.js
>@@ -55,9 +55,7 @@ WI.DOMNodeTreeElement = class DOMNodeTreeElement extends WI.GeneralTreeElement
>     {
>         contextMenu.appendSeparator();
> 
>-        WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, this.representedObject, {
>-            allowEditing: true,
>-        });
>+        WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, this.representedObject);
> 
>         contextMenu.appendSeparator();
> 
>diff --git a/Source/WebInspectorUI/UserInterface/Views/DOMTreeElement.js b/Source/WebInspectorUI/UserInterface/Views/DOMTreeElement.js
>index 9b1b3b61caad291d5dd3a3759699c0bf00fb2761..5f20a68f30ec2393cdac98f499e4fe4e67f0cf67 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/DOMTreeElement.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/DOMTreeElement.js
>@@ -45,7 +45,7 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
>         this._animatingHighlight = false;
>         this._shouldHighlightAfterReveal = false;
>         this._boundHighlightAnimationEnd = this._highlightAnimationEnd.bind(this);
>-        this._subtreeBreakpointCount = 0;
>+        this._subtreeBreakpointTreeElements = null;
> 
>         this._showGoToArrow = false;
>         this._highlightedAttributes = new Set;
>@@ -76,7 +76,7 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
> 
>     get hasBreakpoint()
>     {
>-        return this._breakpointStatus !== WI.DOMTreeElement.BreakpointStatus.None || this._subtreeBreakpointCount > 0;
>+        return this._breakpointStatus !== WI.DOMTreeElement.BreakpointStatus.None || (this._subtreeBreakpointTreeElements && this._subtreeBreakpointTreeElements.size);
>     }
> 
>     get breakpointStatus()
>@@ -103,11 +103,23 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
> 
>         let parentElement = this.parent;
>         while (parentElement && !parentElement.root) {
>-            parentElement.subtreeBreakpointCountDidChange(increment);
>+            parentElement._subtreeBreakpointChanged(this);
>             parentElement = parentElement.parent;
>         }
>     }
> 
>+    bindRevealDescendantBreakpointsMenuItemHandler()
>+    {
>+        if (!this._subtreeBreakpointTreeElements || !this._subtreeBreakpointTreeElements.size)
>+            return null;
>+
>+        let subtreeBreakpointTreeElements = Array.from(this._subtreeBreakpointTreeElements);
>+        return () => {
>+            for (let subtreeBreakpointTreeElement of subtreeBreakpointTreeElements)
>+                subtreeBreakpointTreeElement.reveal();
>+        };
>+    }
>+
>     get closeTagTreeElement() { return this._closeTagTreeElement; }
> 
>     revealAndHighlight()
>@@ -119,12 +131,6 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
>         this.reveal();
>     }
> 
>-    subtreeBreakpointCountDidChange(increment)
>-    {
>-        this._subtreeBreakpointCount += increment;
>-        this._updateBreakpointStatus();
>-    }
>-
>     isCloseTag()
>     {
>         return this._elementCloseTag;
>@@ -1872,6 +1878,21 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
>             event.preventDefault();
>     }
> 
>+    _subtreeBreakpointChanged(treeElement)
>+    {
>+        if (treeElement.hasBreakpoint) {
>+            if (!this._subtreeBreakpointTreeElements)
>+                this._subtreeBreakpointTreeElements = new Set;
>+            this._subtreeBreakpointTreeElements.add(treeElement);
>+        } else {
>+            this._subtreeBreakpointTreeElements.delete(treeElement);
>+            if (!this._subtreeBreakpointTreeElements.size)
>+                this._subtreeBreakpointTreeElements = null;
>+        }
>+
>+        this._updateBreakpointStatus();
>+    }
>+
>     _updateBreakpointStatus()
>     {
>         let listItemElement = this.listItemElement;
>@@ -1879,7 +1900,7 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
>             return;
> 
>         let hasBreakpoint = this._breakpointStatus !== WI.DOMTreeElement.BreakpointStatus.None;
>-        let hasSubtreeBreakpoints = !!this._subtreeBreakpointCount;
>+        let hasSubtreeBreakpoints = this._subtreeBreakpointTreeElements && this._subtreeBreakpointTreeElements.size;
> 
>         if (!hasBreakpoint && !hasSubtreeBreakpoints) {
>             if (this._statusImageElement)
>@@ -1921,26 +1942,13 @@ WI.DOMTreeElement = class DOMTreeElement extends WI.TreeElement
> 
>     _statusImageContextmenu(event)
>     {
>-        let hasBreakpoint = this._breakpointStatus !== WI.DOMTreeElement.BreakpointStatus.None;
>-        let hasSubtreeBreakpoints = !!this._subtreeBreakpointCount;
>-        if (!hasBreakpoint && !hasSubtreeBreakpoints)
>+        if (!this.hasBreakpoint)
>             return;
> 
>         let contextMenu = WI.ContextMenu.createFromEvent(event);
>-        if (hasBreakpoint) {
>-            WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, this.representedObject, {
>-                allowEditing: true,
>-            });
>-            return;
>-        }
> 
>-        contextMenu.appendItem(WI.UIString("Reveal Breakpoint"), () => {
>-            let breakpointTreeElement = this.selfOrDescendant((treeElement) => treeElement.breakpointStatus && treeElement.breakpointStatus !== WI.DOMTreeElement.BreakpointStatus.None);
>-            console.assert(breakpointTreeElement, "Missing breakpoint descendant.", this);
>-            if (!breakpointTreeElement)
>-                return;
>-
>-            breakpointTreeElement.revealAndHighlight();
>+        WI.appendContextMenuItemsForDOMNodeBreakpoints(contextMenu, this.representedObject, {
>+            revealDescendantBreakpointsMenuItemHandler: this.bindRevealDescendantBreakpointsMenuItemHandler(),
>         });
>     }
> 
>diff --git a/Source/WebInspectorUI/UserInterface/Views/DOMTreeOutline.js b/Source/WebInspectorUI/UserInterface/Views/DOMTreeOutline.js
>index 404075d7b9e1fb5e558c74b4f183612a4878d543..0ddb0d9102b60215f88956698b271c5833b8501d 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/DOMTreeOutline.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/DOMTreeOutline.js
>@@ -289,6 +289,10 @@ WI.DOMTreeOutline = class DOMTreeOutline extends WI.TreeOutline
>             excludeRevealElement: this._excludeRevealElementContextMenu,
>             copySubMenu: subMenus.copy,
>         };
>+
>+        if (treeElement.bindRevealDescendantBreakpointsMenuItemHandler)
>+            options.revealDescendantBreakpointsMenuItemHandler = treeElement.bindRevealDescendantBreakpointsMenuItemHandler();
>+
>         WI.appendContextMenuItemsForDOMNode(contextMenu, treeElement.representedObject, options);
> 
>         super.populateContextMenu(contextMenu, event, treeElement);
>diff --git a/Source/WebInspectorUI/UserInterface/Views/EventBreakpointTreeElement.js b/Source/WebInspectorUI/UserInterface/Views/EventBreakpointTreeElement.js
>index 04ddda2308af4203ea3c1a23d961ae34dab1c057..726803d8e32f2c784b6ed351354b339ea5e5bff1 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/EventBreakpointTreeElement.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/EventBreakpointTreeElement.js
>@@ -114,8 +114,6 @@ WI.EventBreakpointTreeElement = class EventBreakpointTreeElement extends WI.Gene
>         let label = breakpoint.disabled ? WI.UIString("Enable Breakpoint") : WI.UIString("Disable Breakpoint");
>         contextMenu.appendItem(label, this._toggleBreakpoint.bind(this));
> 
>-        contextMenu.appendSeparator();
>-
>         contextMenu.appendItem(WI.UIString("Delete Breakpoint"), () => {
>             if (breakpoint.eventListener)
>                 WI.domManager.removeBreakpointForEventListener(breakpoint.eventListener);
>diff --git a/Source/WebInspectorUI/UserInterface/Views/URLBreakpointTreeElement.js b/Source/WebInspectorUI/UserInterface/Views/URLBreakpointTreeElement.js
>index 05b1808e3729bae4f95f9db42298e99806f80947..5413c32b8818e3557518e6c7f4631783f099e758 100644
>--- a/Source/WebInspectorUI/UserInterface/Views/URLBreakpointTreeElement.js
>+++ b/Source/WebInspectorUI/UserInterface/Views/URLBreakpointTreeElement.js
>@@ -114,8 +114,6 @@ WI.URLBreakpointTreeElement = class URLBreakpointTreeElement extends WI.GeneralT
>         let label = breakpoint.disabled ? WI.UIString("Enable Breakpoint") : WI.UIString("Disable Breakpoint");
>         contextMenu.appendItem(label, this._toggleBreakpoint.bind(this));
> 
>-        contextMenu.appendSeparator();
>-
>         contextMenu.appendItem(WI.UIString("Delete Breakpoint"), () => {
>             WI.domDebuggerManager.removeURLBreakpoint(breakpoint);
>         });

Actions: View | Formatted Diff | Diff

Attachments on bug 199332: 373161 | 373308