Changeset 248201 in webkit


Ignore:
Timestamp:
Aug 3, 2019 12:00:01 PM (5 years ago)
Author:
Devin Rousso
Message:

Web Inspector: DOM: add a special breakpoint for "All Events"
​https://bugs.webkit.org/show_bug.cgi?id=200285

Reviewed by Joseph Pecoraro.

Source/JavaScriptCore:

Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
that would pause for any DOM event, regardless of the event's name. This is useful for
situations where the event name isn't known, or where one simply wants to pause on the next
entry to the event loop.

Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
event breakpoints into special breakpoints that can be added/removed via the create
breakpoint context menu. This simplifies the process for setting these breakpoints, and also
makes them more discoverable (most people wouldn't consider them to be "events").

  • inspector/protocol/Debugger.json:
    • Rename the EventListener pause reason to Listener.
    • Split the Timer pause reason into Interval and Timeout.
  • inspector/protocol/DOMDebugger.json:
    • Split the timer type into interval and timeout.
    • Make eventName optional for addEventBreakpoint/removeEventBreakpoint. When omitted, the corresponding breakpoint that is added/removed is treated as a global breakpoint that applies to all events of that type (e.g. a global listener breakpoint would pause for any event that is fired).

Source/WebCore:

Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
that would pause for any DOM event, regardless of the event's name. This is useful for
situations where the event name isn't known, or where one simply want's to pause on the next
entry to the event loop.

Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
event breakpoints into special breakpoints that can be added/removed via the create
breakpoint context menu. This simplifies the process for setting these breakpoints, and also
makes them more discoverable (most people wouldn't consider them to be "events").

Tests: inspector/dom/breakpoint-for-event-listener.html

inspector/dom-debugger/event-animation-frame-breakpoints.html
inspector/dom-debugger/event-breakpoint-with-navigation.html
inspector/dom-debugger/event-interval-breakpoints.html
inspector/dom-debugger/event-listener-breakpoints.html
inspector/dom-debugger/event-timeout-breakpoints.html

  • inspector/agents/InspectorDOMDebuggerAgent.h:
  • inspector/agents/InspectorDOMDebuggerAgent.cpp:

(WebCore::InspectorDOMDebuggerAgent::disable):
(WebCore::InspectorDOMDebuggerAgent::frameDocumentUpdated):
(WebCore::InspectorDOMDebuggerAgent::setEventBreakpoint):
(WebCore::InspectorDOMDebuggerAgent::removeEventBreakpoint):
(WebCore::InspectorDOMDebuggerAgent::willHandleEvent):
(WebCore::InspectorDOMDebuggerAgent::willFireTimer):
(WebCore::InspectorDOMDebuggerAgent::willFireAnimationFrame):
(WebCore::InspectorDOMDebuggerAgent::discardBindings): Deleted.
Make eventName optional for addEventBreakpoint/removeEventBreakpoint. When omitted,
the corresponding breakpoint that is added/removed is treated as a global breakpoint that
applies to all events of that type (e.g. a global listener breakpoint would pause for any
event that is fired).

Source/WebInspectorUI:

Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
that would pause for any DOM event, regardless of the event's name. This is useful for
situations where the event name isn't known, or where one simply want's to pause on the next
entry to the event loop.

Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
event breakpoints into special breakpoints that can be added/removed via the create
breakpoint context menu. This simplifies the process for setting these breakpoints, and also
makes them more discoverable (most people wouldn't consider them to be "events").

  • UserInterface/Models/EventBreakpoint.js:

(WI.EventBreakpoint):
(WI.EventBreakpoint.deserialize):
(WI.EventBreakpoint.prototype.saveIdentityToCookie):
(WI.EventBreakpoint.prototype.toJSON):

  • UserInterface/Controllers/DebuggerManager.js:

(WI.DebuggerManager.prototype._pauseReasonFromPayload):

  • UserInterface/Controllers/DOMDebuggerManager.js:

(WI.DOMDebuggerManager):
(WI.DOMDebuggerManager.prototype.initializeTarget):
(WI.DOMDebuggerManager.supportsDOMBreakpoints): Added.
(WI.DOMDebuggerManager.supportsEventBreakpoints):
(WI.DOMDebuggerManager.supportsEventListenerBreakpoints): Added.
(WI.DOMDebuggerManager.supportsURLBreakpoints):
(WI.DOMDebuggerManager.supportsXHRBreakpoints): Added.
(WI.DOMDebuggerManager.supportsAllListenersBreakpoint): Added.
(WI.DOMDebuggerManager.prototype.get allAnimationFramesBreakpoint): Added.
(WI.DOMDebuggerManager.prototype.get allIntervalsBreakpoint): Added.
(WI.DOMDebuggerManager.prototype.get allListenersBreakpoint): Added.
(WI.DOMDebuggerManager.prototype.get allTimeoutsBreakpoint): Added.
(WI.DOMDebuggerManager.prototype.get listenerBreakpoints): Added.
(WI.DOMDebuggerManager.prototype.isBreakpointSpecial):
(WI.DOMDebuggerManager.prototype.listenerBreakpointForEventName): Added.
(WI.DOMDebuggerManager.prototype.addEventBreakpoint):
(WI.DOMDebuggerManager.prototype.removeEventBreakpoint):
(WI.DOMDebuggerManager.prototype.addURLBreakpoint):
(WI.DOMDebuggerManager.prototype._resolveDOMBreakpoint):
(WI.DOMDebuggerManager.prototype._updateDOMBreakpoint):
(WI.DOMDebuggerManager.prototype._updateEventBreakpoint):
(WI.DOMDebuggerManager.prototype._updateURLBreakpoint):
(WI.DOMDebuggerManager.prototype._handleDOMBreakpointDisabledStateChanged):
(WI.DOMDebuggerManager.prototype._handleEventBreakpointDisabledStateChanged):
(WI.DOMDebuggerManager.prototype._handleURLBreakpointDisabledStateChanged):
(WI.DOMDebuggerManager.prototype.get eventBreakpoints): Deleted.
(WI.DOMDebuggerManager.prototype.eventBreakpointForTypeAndEventName): Deleted.
Add additional target compatibility checks.

  • UserInterface/Views/EventBreakpointPopover.js:

(WI.EventBreakpointPopover.prototype.show):
(WI.EventBreakpointPopover.prototype.dismiss):
(WI.EventBreakpointPopover.prototype._handleTypeSelectChange): Deleted.

  • UserInterface/Views/EventBreakpointPopover.css:

(.popover .event-breakpoint-content > input): Added.
(.popover .event-breakpoint-content > input::placeholder): Added.
(.popover .event-breakpoint-content > .event-type): Deleted.
(.popover .event-breakpoint-content > .event-type > input): Deleted.
(.popover .event-breakpoint-content > .event-type > input::placeholder): Deleted.

  • UserInterface/Views/EventBreakpointTreeElement.css:

(.breakpoint.event.breakpoint-for-interval:not(.breakpoint-paused-icon) .icon): Added.
(.breakpoint.event.breakpoint-for-timeout:not(.breakpoint-paused-icon) .icon): Added.
(.breakpoint.event.breakpoint-for-timer:not(.breakpoint-paused-icon) .icon): Deleted.

  • UserInterface/Views/DebuggerSidebarPanel.js:

(WI.DebuggerSidebarPanel):
(WI.DebuggerSidebarPanel.prototype.saveStateToCookie):
(WI.DebuggerSidebarPanel.prototype.restoreStateFromCookie):
(WI.DebuggerSidebarPanel.prototype._addBreakpoint):
(WI.DebuggerSidebarPanel.prototype._addTreeElement):
(WI.DebuggerSidebarPanel.prototype._updatePauseReasonSection):
(WI.DebuggerSidebarPanel.prototype._handleBreakpointElementAddedOrRemoved):
(WI.DebuggerSidebarPanel.prototype._populateCreateBreakpointContextMenu.addToggleForSpecialEventBreakpoint): Added.
(WI.DebuggerSidebarPanel.prototype._populateCreateBreakpointContextMenu):

  • UserInterface/Views/SourcesNavigationSidebarPanel.js:

(WI.SourcesNavigationSidebarPanel):
(WI.SourcesNavigationSidebarPanel.prototype._insertDebuggerTreeElement):
(WI.SourcesNavigationSidebarPanel.prototype._addBreakpoint):
(WI.SourcesNavigationSidebarPanel.prototype._updatePauseReasonSection):
(WI.SourcesNavigationSidebarPanel.prototype._handleBreakpointElementAddedOrRemoved):
(WI.SourcesNavigationSidebarPanel.prototype._populateCreateBreakpointContextMenu.addToggleForSpecialEventBreakpoint): Added.
(WI.SourcesNavigationSidebarPanel.prototype._populateCreateBreakpointContextMenu):
Add create breakpoint context menu items (also sort the breakpoints in this order):

  • "All Animation Frames" => [A] All Animation Frames
  • "All Timeouts" => [T] All Timeouts
  • "All Intervals" => [I] All Intervals
  • "All Events" => [E] All Events
  • UserInterface/Controllers/JavaScriptRuntimeCompletionProvider.js:

(WI.JavaScriptRuntimeCompletionProvider.completionControllerCompletionsNeeded.receivedPropertyNames):

  • UserInterface/Base/Setting.js:
  • UserInterface/Images/EventBreakpointInterval.svg: Added.
  • UserInterface/Images/EventBreakpointTimeout.svg: Renamed from Source/WebInspectorUI/UserInterface/Images/EventBreakpointTimer.svg.
  • Localizations/en.lproj/localizedStrings.js:

LayoutTests:

  • inspector/dom/breakpoint-for-event-listener.html:
  • inspector/dom/breakpoint-for-event-listener-expected.txt:
  • inspector/dom-debugger/event-animation-frame-breakpoints.html:
  • inspector/dom-debugger/event-animation-frame-breakpoints-expected.txt:
  • inspector/dom-debugger/event-breakpoint-with-navigation.html:
  • inspector/dom-debugger/event-breakpoint-with-navigation-expected.txt:
  • inspector/dom-debugger/event-interval-breakpoints.html: Added.
  • inspector/dom-debugger/event-interval-breakpoints-expected.txt: Added.
  • inspector/dom-debugger/event-listener-breakpoints.html:
  • inspector/dom-debugger/event-listener-breakpoints-expected.txt:
  • inspector/dom-debugger/event-timeout-breakpoints.html: Added.
  • inspector/dom-debugger/event-timeout-breakpoints-expected.txt: Added.
  • inspector/dom-debugger/resources/event-breakpoint-utilities.js:

(TestPage.registerInitializer.InspectorTest.EventBreakpoint.teardown):
(TestPage.registerInitializer.InspectorTest.EventBreakpoint.failOnPause):
(TestPage.registerInitializer.InspectorTest.EventBreakpoint.createBreakpoint): Added.
(TestPage.registerInitializer.InspectorTest.EventBreakpoint.addBreakpoint):
(TestPage.registerInitializer.InspectorTest.EventBreakpoint.removeBreakpoint):
(TestPage.registerInitializer.InspectorTest.EventBreakpoint.disableBreakpoint):

  • inspector/dom-debugger/event-timer-breakpoints.html: Removed.
  • inspector/dom-debugger/event-timer-breakpoints-expected.txt: Removed.
Location:
trunk
Files:
5 added
2 deleted
28 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r248197 r248201  
     12019-08-03  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: DOM: add a special breakpoint for "All Events"
     4        https://bugs.webkit.org/show_bug.cgi?id=200285
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        * inspector/dom/breakpoint-for-event-listener.html:
     9        * inspector/dom/breakpoint-for-event-listener-expected.txt:
     10
     11        * inspector/dom-debugger/event-animation-frame-breakpoints.html:
     12        * inspector/dom-debugger/event-animation-frame-breakpoints-expected.txt:
     13        * inspector/dom-debugger/event-breakpoint-with-navigation.html:
     14        * inspector/dom-debugger/event-breakpoint-with-navigation-expected.txt:
     15        * inspector/dom-debugger/event-interval-breakpoints.html: Added.
     16        * inspector/dom-debugger/event-interval-breakpoints-expected.txt: Added.
     17        * inspector/dom-debugger/event-listener-breakpoints.html:
     18        * inspector/dom-debugger/event-listener-breakpoints-expected.txt:
     19        * inspector/dom-debugger/event-timeout-breakpoints.html: Added.
     20        * inspector/dom-debugger/event-timeout-breakpoints-expected.txt: Added.
     21
     22        * inspector/dom-debugger/resources/event-breakpoint-utilities.js:
     23        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.teardown):
     24        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.failOnPause):
     25        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.createBreakpoint): Added.
     26        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.addBreakpoint):
     27        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.removeBreakpoint):
     28        (TestPage.registerInitializer.InspectorTest.EventBreakpoint.disableBreakpoint):
     29
     30        * inspector/dom-debugger/event-timer-breakpoints.html: Removed.
     31        * inspector/dom-debugger/event-timer-breakpoints-expected.txt: Removed.
     32
    1332019-08-03  Devin Rousso  <drousso@apple.com>
    234

  • trunk/LayoutTests/inspector/dom-debugger/event-animation-frame-breakpoints-expected.txt

    r235248 r248201  
    33
    44== Running test suite: DOMDebugger.Event.AnimationFrame
    5 -- Running test case: DOMDebugger.Event.AnimationFrame.AddBreakpoint "requestAnimationFrame"
    6 Adding "requestAnimationFrame" Event Breakpoint...
     5-- Running test case: DOMDebugger.Event.AnimationFrame.AddBreakpoint
     6Adding "animation-frame" Event Breakpoint...
    77Firing "requestAnimationFrame" on window...
    88PASS: Should pause before event handler is run.
    … …  
    1515-- Running test teardown.
    1616
    17 -- Running test case: DOMDebugger.Event.AnimationFrame.AddDisabledBreakpoint "requestAnimationFrame"
    18 Adding "requestAnimationFrame" Event Breakpoint...
    19 Disabling "requestAnimationFrame" Event Breakpoint...
     17-- Running test case: DOMDebugger.Event.AnimationFrame.AddDisabledBreakpoint
     18Adding "animation-frame" Event Breakpoint...
     19Disabling "animation-frame" Event Breakpoint...
    2020Firing "requestAnimationFrame" on window...
    2121PASS: Should not pause for disabled breakpoint.
    2222-- Running test teardown.
    2323
    24 -- Running test case: DOMDebugger.Event.AnimationFrame.RemoveBreakpoint "requestAnimationFrame"
    25 Adding "requestAnimationFrame" Event Breakpoint...
    26 Removing "requestAnimationFrame" Event Breakpoint...
     24-- Running test case: DOMDebugger.Event.AnimationFrame.RemoveBreakpoint
     25Adding "animation-frame" Event Breakpoint...
     26Removing "animation-frame" Event Breakpoint...
    2727Firing "requestAnimationFrame" on window...
    2828PASS: Should not pause for removed breakpoint.
    2929-- Running test teardown.
    3030
    31 -- Running test case: DOMDebugger.Event.AnimationFrame.RemoveDisabledBreakpoint "requestAnimationFrame"
    32 Adding "requestAnimationFrame" Event Breakpoint...
    33 Disabling "requestAnimationFrame" Event Breakpoint...
    34 Removing "requestAnimationFrame" Event Breakpoint...
     31-- Running test case: DOMDebugger.Event.AnimationFrame.RemoveDisabledBreakpoint
     32Adding "animation-frame" Event Breakpoint...
     33Disabling "animation-frame" Event Breakpoint...
     34Removing "animation-frame" Event Breakpoint...
    3535Firing "requestAnimationFrame" on window...
    3636PASS: Should not pause for removed disabled breakpoint.

  • trunk/LayoutTests/inspector/dom-debugger/event-animation-frame-breakpoints.html

    r235248 r248201  
    1616
    1717function test() {
     18    const eventName = "requestAnimationFrame";
     19
    1820    let suite = InspectorTest.createAsyncSuite("DOMDebugger.Event.AnimationFrame");
    1921
    20     function addTestCasesForEventName(eventName) {
    21         suite.addTestCase({
    22             name: `DOMDebugger.Event.AnimationFrame.AddBreakpoint "${eventName}"`,
    23             description: "Check that the debugger pauses for enabled breakpoints.",
    24             test(resolve, reject) {
    25                 let paused = false;
     22    suite.addTestCase({
     23        name: `DOMDebugger.Event.AnimationFrame.AddBreakpoint`,
     24        description: "Check that the debugger pauses for enabled breakpoints.",
     25        test(resolve, reject) {
     26            let paused = false;
    2627
    27                 let listener = WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
    28                     paused = true;
     28            let listener = WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
     29                paused = true;
    2930
    30                     InspectorTest.pass("Should pause before event handler is run.");
    31                     logActiveStackTrace();
     31                InspectorTest.pass("Should pause before event handler is run.");
     32                logActiveStackTrace();
    3233
    33                     WI.debuggerManager.resume()
    34                     .catch(reject);
    35                 });
     34                WI.debuggerManager.resume()
     35                .catch(reject);
     36            });
    3637
    37                 InspectorTest.singleFireEventListener(`TestPage-${eventName}`, (event) => {
    38                     if (!paused) {
    39                         WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
     38            InspectorTest.singleFireEventListener(`TestPage-${eventName}`, (event) => {
     39                if (!paused) {
     40                    WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
    4041
    41                         InspectorTest.fail("Should pause before event handler is run.");
    42                     }
     42                    InspectorTest.fail("Should pause before event handler is run.");
     43                }
    4344
    44                     resolve();
    45                 });
     45                resolve();
     46            });
    4647
    47                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.AnimationFrame, eventName)
    48                 .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
    49                 .catch(reject);
    50             },
    51             teardown: InspectorTest.EventBreakpoint.teardown,
    52         });
     48            InspectorTest.EventBreakpoint.addBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint)
     49            .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
     50            .catch(reject);
     51        },
     52        teardown: InspectorTest.EventBreakpoint.teardown,
     53    });
    5354
    54         suite.addTestCase({
    55             name: `DOMDebugger.Event.AnimationFrame.AddDisabledBreakpoint "${eventName}"`,
    56             description: "Check that debugger does not pause for disabled breakpoints.",
    57             test(resolve, reject) {
    58                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for disabled breakpoint.");
     55    suite.addTestCase({
     56        name: `DOMDebugger.Event.AnimationFrame.AddDisabledBreakpoint`,
     57        description: "Check that debugger does not pause for disabled breakpoints.",
     58        test(resolve, reject) {
     59            InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for disabled breakpoint.");
    5960
    60                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.AnimationFrame, eventName)
    61                 .then(InspectorTest.EventBreakpoint.disableBreakpoint)
    62                 .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
    63                 .catch(reject);
    64             },
    65             teardown: InspectorTest.EventBreakpoint.teardown,
    66         });
     61            InspectorTest.EventBreakpoint.addBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint)
     62            .then(InspectorTest.EventBreakpoint.disableBreakpoint)
     63            .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
     64            .catch(reject);
     65        },
     66        teardown: InspectorTest.EventBreakpoint.teardown,
     67    });
    6768
    68         suite.addTestCase({
    69             name: `DOMDebugger.Event.AnimationFrame.RemoveBreakpoint "${eventName}"`,
    70             description: "Check that debugger does not pause for removed breakpoint.",
    71             test(resolve, reject) {
    72                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for removed breakpoint.");
     69    suite.addTestCase({
     70        name: `DOMDebugger.Event.AnimationFrame.RemoveBreakpoint`,
     71        description: "Check that debugger does not pause for removed breakpoint.",
     72        test(resolve, reject) {
     73            InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for removed breakpoint.");
    7374
    74                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.AnimationFrame, eventName)
    75                 .then(InspectorTest.EventBreakpoint.removeBreakpoint)
    76                 .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
    77                 .catch(reject);
    78             },
    79             teardown: InspectorTest.EventBreakpoint.teardown,
    80         });
     75            InspectorTest.EventBreakpoint.addBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint)
     76            .then(InspectorTest.EventBreakpoint.removeBreakpoint)
     77            .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
     78            .catch(reject);
     79        },
     80        teardown: InspectorTest.EventBreakpoint.teardown,
     81    });
    8182
    82         suite.addTestCase({
    83             name: `DOMDebugger.Event.AnimationFrame.RemoveDisabledBreakpoint "${eventName}"`,
    84             description: "Check that a disabled breakpoint can be removed.",
    85             test(resolve, reject) {
    86                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for removed disabled breakpoint.");
     83    suite.addTestCase({
     84        name: `DOMDebugger.Event.AnimationFrame.RemoveDisabledBreakpoint`,
     85        description: "Check that a disabled breakpoint can be removed.",
     86        test(resolve, reject) {
     87            InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.AnimationFrame, eventName, "Should not pause for removed disabled breakpoint.");
    8788
    88                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.AnimationFrame, eventName)
    89                 .then(InspectorTest.EventBreakpoint.disableBreakpoint)
    90                 .then(InspectorTest.EventBreakpoint.removeBreakpoint)
    91                 .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
    92                 .catch(reject);
    93             },
    94             teardown: InspectorTest.EventBreakpoint.teardown,
    95         });
    96     }
    97 
    98     addTestCasesForEventName("requestAnimationFrame");
     89            InspectorTest.EventBreakpoint.addBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint)
     90            .then(InspectorTest.EventBreakpoint.disableBreakpoint)
     91            .then(InspectorTest.EventBreakpoint.removeBreakpoint)
     92            .then(InspectorTest.EventBreakpoint.awaitEvent("window", eventName))
     93            .catch(reject);
     94        },
     95        teardown: InspectorTest.EventBreakpoint.teardown,
     96    });
    9997
    10098    suite.runTestCasesAndFinish();

  • trunk/LayoutTests/inspector/dom-debugger/event-breakpoint-with-navigation-expected.txt

    r234974 r248201  
    66Adding "load" Event Breakpoint...
    77Reloading WebInspector...
    8 PASS: Pause reason should be EventListener.
     8PASS: Pause reason should be Listener.
    99PASS: Pause data eventName should be "load".
    1010-- Running test teardown.

  • trunk/LayoutTests/inspector/dom-debugger/event-breakpoint-with-navigation.html

    r235248 r248201  
    33<head>
    44<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
     5<script src="resources/event-breakpoint-utilities.js"></script>
    56<script>
    67function handleLoad(event) {
    … …  
    2324
    2425                let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
    25                 InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.EventListener, "Pause reason should be EventListener.");
     26                InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.Listener, "Pause reason should be Listener.");
    2627                InspectorTest.expectEqual(targetData.pauseData.eventName, "load", "Pause data eventName should be \"load\".");
    2728
    … …  
    4546            InspectorTest.log("Adding \"load\" Event Breakpoint...");
    4647
    47             let breakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Listener, "load");
     48            let breakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Listener, {eventName: "load"});
    4849
    4950            WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.EventBreakpointAdded)
    … …  
    5960            WI.domDebuggerManager.addEventBreakpoint(breakpoint);
    6061        },
    61         teardown(resolve, reject) {
    62             let breakpoints = WI.domDebuggerManager.eventBreakpoints;
    63             for (let breakpoint of breakpoints)
    64                 WI.domDebuggerManager.removeEventBreakpoint(breakpoint);
    65 
    66             resolve();
    67         },
     62        teardown: InspectorTest.EventBreakpoint.teardown,
    6863    });
    6964

  • trunk/LayoutTests/inspector/dom-debugger/event-listener-breakpoints-expected.txt

    r242588 r248201  
    44== Running test suite: DOMDebugger.Event.Listener
    55-- Running test case: DOMDebugger.Event.Listener.AddBreakpoint "click"
    6 Adding "click" Event Breakpoint...
     6Creating "click" Event Breakpoint...
     7Adding "listener:click" Event Breakpoint...
    78Firing "click" on body...
    89PASS: Should pause before event handler is run.
    … …  
    1415
    1516-- Running test case: DOMDebugger.Event.Listener.AddDisabledBreakpoint "click"
    16 Adding "click" Event Breakpoint...
    17 Disabling "click" Event Breakpoint...
     17Creating "click" Event Breakpoint...
     18Adding "listener:click" Event Breakpoint...
     19Disabling "listener:click" Event Breakpoint...
    1820Firing "click" on body...
    1921PASS: Should not pause for disabled breakpoint.
    … …  
    2123
    2224-- Running test case: DOMDebugger.Event.Listener.RemoveBreakpoint "click"
    23 Adding "click" Event Breakpoint...
    24 Removing "click" Event Breakpoint...
     25Creating "click" Event Breakpoint...
     26Adding "listener:click" Event Breakpoint...
     27Removing "listener:click" Event Breakpoint...
    2528Firing "click" on body...
    2629PASS: Should not pause for removed breakpoint.
    … …  
    2831
    2932-- Running test case: DOMDebugger.Event.Listener.RemoveDisabledBreakpoint "click"
    30 Adding "click" Event Breakpoint...
    31 Disabling "click" Event Breakpoint...
    32 Removing "click" Event Breakpoint...
     33Creating "click" Event Breakpoint...
     34Adding "listener:click" Event Breakpoint...
     35Disabling "listener:click" Event Breakpoint...
     36Removing "listener:click" Event Breakpoint...
    3337Firing "click" on body...
    3438PASS: Should not pause for removed disabled breakpoint.
    … …  
    3640
    3741-- Running test case: DOMDebugger.Event.Listener.AddBreakpoint "custom"
    38 Adding "custom" Event Breakpoint...
     42Creating "custom" Event Breakpoint...
     43Adding "listener:custom" Event Breakpoint...
    3944Firing "custom" on body...
    4045PASS: Should pause before event handler is run.
    … …  
    4651
    4752-- Running test case: DOMDebugger.Event.Listener.AddDisabledBreakpoint "custom"
    48 Adding "custom" Event Breakpoint...
    49 Disabling "custom" Event Breakpoint...
     53Creating "custom" Event Breakpoint...
     54Adding "listener:custom" Event Breakpoint...
     55Disabling "listener:custom" Event Breakpoint...
    5056Firing "custom" on body...
    5157PASS: Should not pause for disabled breakpoint.
    … …  
    5359
    5460-- Running test case: DOMDebugger.Event.Listener.RemoveBreakpoint "custom"
    55 Adding "custom" Event Breakpoint...
    56 Removing "custom" Event Breakpoint...
     61Creating "custom" Event Breakpoint...
     62Adding "listener:custom" Event Breakpoint...
     63Removing "listener:custom" Event Breakpoint...
    5764Firing "custom" on body...
    5865PASS: Should not pause for removed breakpoint.
    … …  
    6067
    6168-- Running test case: DOMDebugger.Event.Listener.RemoveDisabledBreakpoint "custom"
    62 Adding "custom" Event Breakpoint...
    63 Disabling "custom" Event Breakpoint...
    64 Removing "custom" Event Breakpoint...
     69Creating "custom" Event Breakpoint...
     70Adding "listener:custom" Event Breakpoint...
     71Disabling "listener:custom" Event Breakpoint...
     72Removing "listener:custom" Event Breakpoint...
    6573Firing "custom" on body...
    6674PASS: Should not pause for removed disabled breakpoint.
    6775-- Running test teardown.
    6876
     77-- Running test case: DOMDebugger.Event.Listener.AllEventsBreakpoint
     78Adding "listener" Event Breakpoint...
     79Firing "click" on body...
     80PASS: Should pause before event handler is run.
     81CALL STACK:
     820: [F] handleBody_click
     831: [F] trigger_click
     842: [P] Global Code
     85Firing "custom" on body...
     86PASS: Should pause before event handler is run.
     87CALL STACK:
     880: [F] handleBody_custom
     891: [F] trigger_custom
     902: [P] Global Code
     91PASS: Should have paused twice.
     92-- Running test teardown.
     93
    6994-- Running test case: DOMDebugger.Event.Listener.AddMultipleBreakpoints
    70 Adding "click" Event Breakpoint...
     95Creating "click" Event Breakpoint...
     96Adding "listener:click" Event Breakpoint...
    7197Firing "click" on div#x...
    7298PASS: Should pause before event handler is run.
    … …  
    84110
    85111-- Running test case: DOMDebugger.Event.Listener.DisableBetweenDispatches
    86 Adding "click" Event Breakpoint...
     112Creating "click" Event Breakpoint...
     113Adding "listener:click" Event Breakpoint...
    87114Firing "click" on div#x...
    88115PASS: Should pause before event handler is run.

  • trunk/LayoutTests/inspector/dom-debugger/event-listener-breakpoints.html

    r242588 r248201  
    5959                });
    6060
    61                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
     61                InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
    6262                .then(InspectorTest.EventBreakpoint.awaitEvent("body", eventName))
    6363                .catch(reject);
    … …  
    7070            description: "Check that debugger does not pause for disabled breakpoints.",
    7171            test(resolve, reject) {
    72                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.EventListener, eventName, "Should not pause for disabled breakpoint.");
    73 
    74                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
     72                InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.Listener, eventName, "Should not pause for disabled breakpoint.");
     73
     74                InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
    7575                .then(InspectorTest.EventBreakpoint.disableBreakpoint)
    7676                .then(InspectorTest.EventBreakpoint.awaitEvent("body", eventName))
    … …  
    8484            description: "Check that debugger does not pause for removed breakpoint.",
    8585            test(resolve, reject) {
    86                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.EventListener, eventName, "Should not pause for removed breakpoint.");
    87 
    88                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
     86                InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.Listener, eventName, "Should not pause for removed breakpoint.");
     87
     88                InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
    8989                .then(InspectorTest.EventBreakpoint.removeBreakpoint)
    9090                .then(InspectorTest.EventBreakpoint.awaitEvent("body", eventName))
    … …  
    9898            description: "Check that a disabled breakpoint can be removed.",
    9999            test(resolve, reject) {
    100                 InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.EventListener, eventName, "Should not pause for removed disabled breakpoint.");
    101 
    102                 InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
     100                InspectorTest.EventBreakpoint.failOnPause(resolve, reject, WI.DebuggerManager.PauseReason.Listener, eventName, "Should not pause for removed disabled breakpoint.");
     101
     102                InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, eventName)
    103103                .then(InspectorTest.EventBreakpoint.disableBreakpoint)
    104104                .then(InspectorTest.EventBreakpoint.removeBreakpoint)
    … …  
    112112    addTestCasesForEventName("click");
    113113    addTestCasesForEventName("custom");
     114
     115    suite.addTestCase({
     116        name: `DOMDebugger.Event.Listener.AllEventsBreakpoint`,
     117        description: "Check that the all events breakpoint pauses for every event.",
     118        test(resolve, reject) {
     119            let pauseCount = 0;
     120
     121            let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
     122                ++pauseCount;
     123
     124                InspectorTest.pass("Should pause before event handler is run.");
     125                logActiveStackTrace();
     126
     127                WI.debuggerManager.resume()
     128                .catch(reject);
     129            });
     130
     131            InspectorTest.EventBreakpoint.addBreakpoint(WI.domDebuggerManager.allListenersBreakpoint)
     132            .then(() => {
     133                InspectorTest.log("Firing \"click\" on body...");
     134                return InspectorTest.evaluateInPage(`trigger_click()`);
     135            })
     136            .then(() => {
     137                InspectorTest.log("Firing \"custom\" on body...");
     138                return InspectorTest.evaluateInPage(`trigger_custom()`);
     139            })
     140            .then(() => {
     141                InspectorTest.expectEqual(pauseCount, 2, "Should have paused twice.");
     142                InspectorTest.assert(!WI.debuggerManager.paused, "Should not be paused.");
     143
     144                WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
     145            })
     146            .then(resolve, reject);
     147        },
     148        teardown: InspectorTest.EventBreakpoint.teardown,
     149    });
    114150
    115151    suite.addTestCase({
    … …  
    138174            });
    139175
    140             InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, "click")
     176            InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, "click")
    141177            .then(() => {
    142178                InspectorTest.log("Firing \"click\" on div#x...");
    … …  
    176212            });
    177213
    178             InspectorTest.EventBreakpoint.addBreakpoint(WI.EventBreakpoint.Type.Listener, "click")
     214            InspectorTest.EventBreakpoint.createBreakpoint(WI.EventBreakpoint.Type.Listener, "click")
    179215            .then(() => {
    180216                InspectorTest.log("Firing \"click\" on div#x...");

  • trunk/LayoutTests/inspector/dom-debugger/resources/event-breakpoint-utilities.js

    r235248 r248201  
    33
    44    InspectorTest.EventBreakpoint.teardown = function(resolve, reject) {
    5         let breakpoints = WI.domDebuggerManager.eventBreakpoints;
    6         for (let breakpoint of breakpoints)
     5        WI.domDebuggerManager.removeEventBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint);
     6        WI.domDebuggerManager.removeEventBreakpoint(WI.domDebuggerManager.allIntervalsBreakpoint);
     7        WI.domDebuggerManager.removeEventBreakpoint(WI.domDebuggerManager.allListenersBreakpoint);
     8        WI.domDebuggerManager.removeEventBreakpoint(WI.domDebuggerManager.allTimeoutsBreakpoint);
     9
     10        for (let breakpoint of WI.domDebuggerManager.listenerBreakpoints)
    711            WI.domDebuggerManager.removeEventBreakpoint(breakpoint);
    812
    … …  
    1822            let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
    1923            InspectorTest.assert(targetData.pauseReason === pauseReason, `Pause reason should be "${pauseReason}".`);
    20             InspectorTest.assert(targetData.pauseData.eventName === eventName, `Pause data eventName should be "${eventName}".`);
     24            if (targetData.pauseData.eventName)
     25                InspectorTest.assert(targetData.pauseData.eventName === eventName, `Pause data eventName should be "${eventName}".`);
    2126
    2227            InspectorTest.fail(message);
    … …  
    3843    };
    3944
    40     InspectorTest.EventBreakpoint.addBreakpoint = function(type, eventName) {
    41         InspectorTest.log(`Adding "${eventName}" Event Breakpoint...`);
     45    InspectorTest.EventBreakpoint.createBreakpoint = function(type, eventName) {
     46        InspectorTest.log(`Creating "${eventName}" Event Breakpoint...`);
     47        return InspectorTest.EventBreakpoint.addBreakpoint(new WI.EventBreakpoint(type, {eventName}));
     48    };
    4249
     50    InspectorTest.EventBreakpoint.addBreakpoint = function(breakpoint) {
     51        InspectorTest.log(`Adding "${breakpoint.type + (breakpoint.eventName ? ":" + breakpoint.eventName : "")}" Event Breakpoint...`);
     52
     53        breakpoint.disabled = false;
    4354        return new Promise((resolve, reject) => {
    44             let breakpoint = new WI.EventBreakpoint(type, eventName);
    45 
    4655            WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.EventBreakpointAdded)
    4756            .then((event) => {
    48                 InspectorTest.assert(event.data.breakpoint.type === type, `Breakpoint should be for expected type "${type}".`);
    49                 InspectorTest.assert(event.data.breakpoint.eventName === eventName, `Breakpoint should be for expected event name "${eventName}".`);
     57                InspectorTest.assert(event.data.breakpoint === breakpoint, "Added Breakpoint should be expected object.");
    5058                InspectorTest.assert(!event.data.breakpoint.disabled, "Breakpoint should not be disabled initially.");
    5159                resolve(breakpoint);
    … …  
    5765
    5866    InspectorTest.EventBreakpoint.removeBreakpoint = function(breakpoint) {
    59         InspectorTest.log(`Removing "${breakpoint.eventName}" Event Breakpoint...`);
     67        InspectorTest.log(`Removing "${breakpoint.type + (breakpoint.eventName ? ":" + breakpoint.eventName : "")}" Event Breakpoint...`);
    6068
    6169        return new Promise((resolve, reject) => {
    … …  
    6371            .then((event) => {
    6472                InspectorTest.assert(event.data.breakpoint === breakpoint, "Removed Breakpoint should be expected object.");
    65                 InspectorTest.assert(!WI.domDebuggerManager.eventBreakpoints.includes(breakpoint), "Breakpoint should not be in the list of breakpoints.");
     73                InspectorTest.assert(!WI.domDebuggerManager.listenerBreakpoints.includes(breakpoint), "Breakpoint should not be in the list of breakpoints.");
    6674                resolve(breakpoint);
    6775            });
    … …  
    7280
    7381    InspectorTest.EventBreakpoint.disableBreakpoint = function(breakpoint) {
    74         InspectorTest.log(`Disabling "${breakpoint.eventName}" Event Breakpoint...`);
     82        InspectorTest.log(`Disabling "${breakpoint.type + (breakpoint.eventName ? ":" + breakpoint.eventName : "")}" Event Breakpoint...`);
    7583
    7684        breakpoint.disabled = true;

  • trunk/LayoutTests/inspector/dom/breakpoint-for-event-listener-expected.txt

    r235103 r248201  
    1010Clicking button1...
    1111PASS: Should pause before button1 event handler is run.
    12 PASS: Pause reason should be EventListener.
     12PASS: Pause reason should be Listener.
    1313PASS: Pause data eventName should be "click".
    1414

  • trunk/LayoutTests/inspector/dom/breakpoint-for-event-listener.html

    r236766 r248201  
    4747
    4848                let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
    49                 InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.EventListener, `Pause reason should be EventListener.`);
     49                InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.Listener, `Pause reason should be Listener.`);
    5050                InspectorTest.expectEqual(targetData.pauseData.eventName, "click", `Pause data eventName should be "click".`);
    5151
    … …  
    109109
    110110                let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
    111                 InspectorTest.assert(targetData.pauseReason, WI.DebuggerManager.PauseReason.EventListener, `Pause reason should be EventListener.`);
     111                InspectorTest.assert(targetData.pauseReason, WI.DebuggerManager.PauseReason.Listener, `Pause reason should be Listener.`);
    112112                InspectorTest.assert(targetData.pauseData.eventName, "click", `Pause data eventName should be "click".`);
    113113

  • trunk/Source/JavaScriptCore/ChangeLog

    r248195 r248201  
     12019-08-03  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: DOM: add a special breakpoint for "All Events"
     4        https://bugs.webkit.org/show_bug.cgi?id=200285
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
     9        that would pause for any DOM event, regardless of the event's name. This is useful for
     10        situations where the event name isn't known, or where one simply wants to pause on the next
     11        entry to the event loop.
     12
     13        Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
     14        event breakpoints into special breakpoints that can be added/removed via the create
     15        breakpoint context menu. This simplifies the process for setting these breakpoints, and also
     16        makes them more discoverable (most people wouldn't consider them to be "events").
     17
     18        * inspector/protocol/Debugger.json:
     19         - Rename the `EventListener` pause reason to `Listener`.
     20         - Split the `Timer` pause reason into `Interval` and `Timeout`.
     21
     22        * inspector/protocol/DOMDebugger.json:
     23         - Split the `timer` type into `interval` and `timeout`.
     24         - Make `eventName` optional for `addEventBreakpoint`/`removeEventBreakpoint`. When omitted,
     25           the corresponding breakpoint that is added/removed is treated as a global breakpoint that
     26           applies to all events of that type (e.g. a global `listener` breakpoint would pause for
     27           any event that is fired).
     28
    1292019-08-02  Keith Miller  <keith_miller@apple.com>
    230

  • trunk/Source/JavaScriptCore/inspector/protocol/DOMDebugger.json

    r239703 r248201  
    1313            "id": "EventBreakpointType",
    1414            "type": "string",
    15             "enum": ["animation-frame", "listener", "timer"],
     15            "enum": ["animation-frame", "interval", "listener", "timeout"],
    1616            "description": "Event breakpoint type."
    1717        }
    … …  
    3939            "parameters": [
    4040                { "name": "breakpointType", "$ref": "EventBreakpointType" },
    41                 { "name": "eventName", "type": "string", "description": "The name of the event to stop on." }
     41                { "name": "eventName", "type": "string", "optional": true, "description": "The name of the specific event to stop on." }
    4242            ]
    4343        },
    … …  
    4747            "parameters": [
    4848                { "name": "breakpointType", "$ref": "EventBreakpointType" },
    49                 { "name": "eventName", "type": "string", "description": "The name of the event to stop on." }
     49                { "name": "eventName", "type": "string", "optional": true, "description": "The name of the specific event to stop on." }
    5050            ]
    5151        },

  • trunk/Source/JavaScriptCore/inspector/protocol/Debugger.json

    r248097 r248201  
    335335            "parameters": [
    336336                { "name": "callFrames", "type": "array", "items": { "$ref": "CallFrame" }, "description": "Call stack the virtual machine stopped on." },
    337                 { "name": "reason", "type": "string", "enum": ["XHR", "Fetch", "DOM", "AnimationFrame", "EventListener", "Timer", "exception", "assert", "CSPViolation", "DebuggerStatement", "Breakpoint", "PauseOnNextStatement", "other"], "description": "Pause reason." },
     337                { "name": "reason", "type": "string", "enum": ["XHR", "Fetch", "DOM", "AnimationFrame", "Interval", "Listener", "Timeout", "exception", "assert", "CSPViolation", "DebuggerStatement", "Breakpoint", "PauseOnNextStatement", "other"], "description": "Pause reason." },
    338338                { "name": "data", "type": "object", "optional": true, "description": "Object containing break-specific auxiliary properties." },
    339339                { "name": "asyncStackTrace", "$ref": "Console.StackTrace", "optional": true, "description": "Linked list of asynchronous StackTraces." }

  • trunk/Source/WebCore/ChangeLog

    r248200 r248201  
     12019-08-03  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: DOM: add a special breakpoint for "All Events"
     4        https://bugs.webkit.org/show_bug.cgi?id=200285
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
     9        that would pause for any DOM event, regardless of the event's name. This is useful for
     10        situations where the event name isn't known, or where one simply want's to pause on the next
     11        entry to the event loop.
     12
     13        Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
     14        event breakpoints into special breakpoints that can be added/removed via the create
     15        breakpoint context menu. This simplifies the process for setting these breakpoints, and also
     16        makes them more discoverable (most people wouldn't consider them to be "events").
     17
     18        Tests: inspector/dom/breakpoint-for-event-listener.html
     19               inspector/dom-debugger/event-animation-frame-breakpoints.html
     20               inspector/dom-debugger/event-breakpoint-with-navigation.html
     21               inspector/dom-debugger/event-interval-breakpoints.html
     22               inspector/dom-debugger/event-listener-breakpoints.html
     23               inspector/dom-debugger/event-timeout-breakpoints.html
     24
     25        * inspector/agents/InspectorDOMDebuggerAgent.h:
     26        * inspector/agents/InspectorDOMDebuggerAgent.cpp:
     27        (WebCore::InspectorDOMDebuggerAgent::disable):
     28        (WebCore::InspectorDOMDebuggerAgent::frameDocumentUpdated):
     29        (WebCore::InspectorDOMDebuggerAgent::setEventBreakpoint):
     30        (WebCore::InspectorDOMDebuggerAgent::removeEventBreakpoint):
     31        (WebCore::InspectorDOMDebuggerAgent::willHandleEvent):
     32        (WebCore::InspectorDOMDebuggerAgent::willFireTimer):
     33        (WebCore::InspectorDOMDebuggerAgent::willFireAnimationFrame):
     34        (WebCore::InspectorDOMDebuggerAgent::discardBindings): Deleted.
     35        Make `eventName` optional for `addEventBreakpoint`/`removeEventBreakpoint`. When omitted,
     36        the corresponding breakpoint that is added/removed is treated as a global breakpoint that
     37        applies to all events of that type (e.g. a global `listener` breakpoint would pause for any
     38        event that is fired).
     39
    1402019-08-03  Zalan Bujtas  <zalan@apple.com>
    241

  • trunk/Source/WebCore/inspector/agents/InspectorDOMDebuggerAgent.cpp

    r244269 r248201  
    9595{
    9696    m_instrumentingAgents.setInspectorDOMDebuggerAgent(nullptr);
    97     discardBindings();
    98     m_eventBreakpoints.clear();
     97    m_domBreakpoints.clear();
     98    m_listenerBreakpoints.clear();
    9999    m_urlBreakpoints.clear();
     100    m_pauseOnAllAnimationFramesEnabled = false;
     101    m_pauseOnAllIntervalsEnabled = false;
     102    m_pauseOnAllListenersEnabled = false;
     103    m_pauseOnAllTimeoutsEnabled = false;
    100104    m_pauseOnAllURLsEnabled = false;
    101105}
    … …  
    121125        return;
    122126
    123     discardBindings();
    124 }
    125 
    126 void InspectorDOMDebuggerAgent::discardBindings()
    127 {
    128127    m_domBreakpoints.clear();
    129128}
    130129
    131 void InspectorDOMDebuggerAgent::setEventBreakpoint(ErrorString& error, const String& breakpointTypeString, const String& eventName)
     130void InspectorDOMDebuggerAgent::setEventBreakpoint(ErrorString& errorString, const String& breakpointTypeString, const String* eventName)
    132131{
    133132    if (breakpointTypeString.isEmpty()) {
    134         error = "Event breakpoint type is empty"_s;
     133        errorString = "Event breakpoint type is empty"_s;
    135134        return;
    136135    }
    … …  
    138137    auto breakpointType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::DOMDebugger::EventBreakpointType>(breakpointTypeString);
    139138    if (!breakpointType) {
    140         error = makeString("Unknown event breakpoint type: "_s, breakpointTypeString);
    141         return;
    142     }
    143 
    144     if (eventName.isEmpty()) {
    145         error = "Event name is empty"_s;
    146         return;
    147     }
    148 
    149     m_eventBreakpoints.add(std::make_pair(*breakpointType, eventName));
    150 }
    151 
    152 void InspectorDOMDebuggerAgent::removeEventBreakpoint(ErrorString& error, const String& breakpointTypeString, const String& eventName)
     139        errorString = makeString("Unknown event breakpoint type: "_s, breakpointTypeString);
     140        return;
     141    }
     142
     143    if (eventName && !eventName->isEmpty()) {
     144        if (breakpointType.value() == Inspector::Protocol::DOMDebugger::EventBreakpointType::Listener) {
     145            if (!m_listenerBreakpoints.add(*eventName))
     146                errorString = "Breakpoint with eventName already exists"_s;
     147            return;
     148        }
     149
     150        errorString = "Unexpected eventName argument"_s;
     151        return;
     152    }
     153
     154    switch (breakpointType.value()) {
     155    case Inspector::Protocol::DOMDebugger::EventBreakpointType::AnimationFrame:
     156        if (m_pauseOnAllAnimationFramesEnabled)
     157            errorString = "Already have breakpoint for all animation frames"_s;
     158        m_pauseOnAllAnimationFramesEnabled = true;
     159        break;
     160
     161    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Interval:
     162        if (m_pauseOnAllIntervalsEnabled)
     163            errorString = "Already have breakpoint for all intervals"_s;
     164        m_pauseOnAllIntervalsEnabled = true;
     165        break;
     166
     167    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Listener:
     168        if (m_pauseOnAllListenersEnabled)
     169            errorString = "Already have breakpoint for all listeners"_s;
     170        m_pauseOnAllListenersEnabled = true;
     171        break;
     172
     173    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Timeout:
     174        if (m_pauseOnAllTimeoutsEnabled)
     175            errorString = "Already have breakpoint for all timeouts"_s;
     176        m_pauseOnAllTimeoutsEnabled = true;
     177        break;
     178    }
     179}
     180
     181void InspectorDOMDebuggerAgent::removeEventBreakpoint(ErrorString& errorString, const String& breakpointTypeString, const String* eventName)
    153182{
    154183    if (breakpointTypeString.isEmpty()) {
    155         error = "Event breakpoint type is empty"_s;
     184        errorString = "Event breakpoint type is empty"_s;
    156185        return;
    157186    }
    … …  
    159188    auto breakpointType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::DOMDebugger::EventBreakpointType>(breakpointTypeString);
    160189    if (!breakpointType) {
    161         error = makeString("Unknown event breakpoint type: "_s, breakpointTypeString);
    162         return;
    163     }
    164 
    165     if (eventName.isEmpty()) {
    166         error = "Event name is empty"_s;
    167         return;
    168     }
    169 
    170     m_eventBreakpoints.remove(std::make_pair(*breakpointType, eventName));
     190        errorString = makeString("Unknown event breakpoint type: "_s, breakpointTypeString);
     191        return;
     192    }
     193
     194    if (eventName && !eventName->isEmpty()) {
     195        if (breakpointType.value() == Inspector::Protocol::DOMDebugger::EventBreakpointType::Listener) {
     196            if (!m_listenerBreakpoints.remove(*eventName))
     197                errorString = "Missing breakpoint for eventName"_s;
     198            return;
     199        }
     200
     201        errorString = "Unexpected eventName argument"_s;
     202        return;
     203    }
     204
     205    switch (breakpointType.value()) {
     206    case Inspector::Protocol::DOMDebugger::EventBreakpointType::AnimationFrame:
     207        if (!m_pauseOnAllAnimationFramesEnabled)
     208            errorString = "Missing breakpoint for all animation frames"_s;
     209        m_pauseOnAllAnimationFramesEnabled = false;
     210        break;
     211
     212    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Interval:
     213        if (!m_pauseOnAllIntervalsEnabled)
     214            errorString = "Missing breakpoint for all intervals"_s;
     215        m_pauseOnAllIntervalsEnabled = false;
     216        break;
     217
     218    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Listener:
     219        if (!m_pauseOnAllListenersEnabled)
     220            errorString = "Missing breakpoint for all listeners"_s;
     221        m_pauseOnAllListenersEnabled = false;
     222        break;
     223
     224    case Inspector::Protocol::DOMDebugger::EventBreakpointType::Timeout:
     225        if (!m_pauseOnAllTimeoutsEnabled)
     226            errorString = "Missing breakpoint for all timeouts"_s;
     227        m_pauseOnAllTimeoutsEnabled = false;
     228        break;
     229    }
    171230}
    172231
    … …  
    409468    auto* domAgent = m_instrumentingAgents.inspectorDOMAgent();
    410469
    411     bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || m_eventBreakpoints.contains(std::make_pair(Inspector::Protocol::DOMDebugger::EventBreakpointType::Listener, event.type()));
    412 
     470    bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || m_pauseOnAllListenersEnabled || m_listenerBreakpoints.contains(event.type());
    413471    if (!shouldPause && domAgent)
    414472        shouldPause = domAgent->hasBreakpointForEventListener(*event.currentTarget(), event.type(), registeredEventListener.callback(), registeredEventListener.useCapture());
    415 
    416473    if (!shouldPause)
    417474        return;
    … …  
    425482    }
    426483
    427     m_debuggerAgent->schedulePauseOnNextStatement(Inspector::DebuggerFrontendDispatcher::Reason::EventListener, WTFMove(eventData));
     484    m_debuggerAgent->schedulePauseOnNextStatement(Inspector::DebuggerFrontendDispatcher::Reason::Listener, WTFMove(eventData));
    428485}
    429486
    … …  
    438495        return;
    439496
    440     String eventName = oneShot ? "setTimeout"_s : "setInterval"_s;
    441     bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || m_eventBreakpoints.contains(std::make_pair(Inspector::Protocol::DOMDebugger::EventBreakpointType::Timer, eventName));
     497    bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || (oneShot ? m_pauseOnAllTimeoutsEnabled : m_pauseOnAllIntervalsEnabled);
    442498    if (!shouldPause)
    443499        return;
    444500
    445     Ref<JSON::Object> eventData = JSON::Object::create();
    446     eventData->setString("eventName"_s, eventName);
    447     m_debuggerAgent->schedulePauseOnNextStatement(Inspector::DebuggerFrontendDispatcher::Reason::Timer, WTFMove(eventData));
     501    auto breakReason = oneShot ? Inspector::DebuggerFrontendDispatcher::Reason::Timeout : Inspector::DebuggerFrontendDispatcher::Reason::Interval;
     502    m_debuggerAgent->schedulePauseOnNextStatement(breakReason, nullptr);
    448503}
    449504
    … …  
    453508        return;
    454509
    455     String eventName = "requestAnimationFrame"_s;
    456     bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || m_eventBreakpoints.contains(std::make_pair(Inspector::Protocol::DOMDebugger::EventBreakpointType::AnimationFrame, eventName));
     510    bool shouldPause = m_debuggerAgent->pauseOnNextStatementEnabled() || m_pauseOnAllAnimationFramesEnabled;
    457511    if (!shouldPause)
    458512        return;
    459513
    460     Ref<JSON::Object> eventData = JSON::Object::create();
    461     eventData->setString("eventName"_s, eventName);
    462     m_debuggerAgent->schedulePauseOnNextStatement(Inspector::DebuggerFrontendDispatcher::Reason::AnimationFrame, WTFMove(eventData));
     514    m_debuggerAgent->schedulePauseOnNextStatement(Inspector::DebuggerFrontendDispatcher::Reason::AnimationFrame, nullptr);
    463515}
    464516

  • trunk/Source/WebCore/inspector/agents/InspectorDOMDebuggerAgent.h

    r244269 r248201  
    6363    void setURLBreakpoint(ErrorString&, const String& url, const bool* optionalIsRegex) final;
    6464    void removeURLBreakpoint(ErrorString&, const String& url) final;
    65     void setEventBreakpoint(ErrorString&, const String& breakpointType, const String& eventName) final;
    66     void removeEventBreakpoint(ErrorString&, const String& breakpointType, const String& eventName) final;
     65    void setEventBreakpoint(ErrorString&, const String& breakpointType, const String* eventName) final;
     66    void removeEventBreakpoint(ErrorString&, const String& breakpointType, const String* eventName) final;
    6767    void setDOMBreakpoint(ErrorString&, int nodeId, const String& type) final;
    6868    void removeDOMBreakpoint(ErrorString&, int nodeId, const String& type) final;
    … …  
    100100    void updateSubtreeBreakpoints(Node*, uint32_t rootMask, bool set);
    101101    bool hasBreakpoint(Node*, int type);
    102     void discardBindings();
    103102
    104103    RefPtr<Inspector::DOMDebuggerBackendDispatcher> m_backendDispatcher;
    … …  
    108107
    109108    HashMap<Node*, uint32_t> m_domBreakpoints;
    110 
    111     using EventBreakpointType = Inspector::Protocol::DOMDebugger::EventBreakpointType;
    112     HashSet<std::pair<EventBreakpointType, String>,
    113         WTF::PairHash<EventBreakpointType, String>,
    114         WTF::PairHashTraits<WTF::StrongEnumHashTraits<EventBreakpointType>, WTF::HashTraits<String>>
    115     > m_eventBreakpoints;
     109    HashSet<String> m_listenerBreakpoints;
    116110
    117111    enum class URLBreakpointType { RegularExpression, Text };
    118112    HashMap<String, URLBreakpointType> m_urlBreakpoints;
     113
     114    bool m_pauseOnAllAnimationFramesEnabled { false };
     115    bool m_pauseOnAllIntervalsEnabled { false };
     116    bool m_pauseOnAllListenersEnabled { false };
     117    bool m_pauseOnAllTimeoutsEnabled { false };
    119118    bool m_pauseOnAllURLsEnabled { false };
    120119};

  • trunk/Source/WebInspectorUI/ChangeLog

    r248198 r248201  
     12019-08-03  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: DOM: add a special breakpoint for "All Events"
     4        https://bugs.webkit.org/show_bug.cgi?id=200285
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        Similar to the existing "All Requests" breakpoint, there should be a way to set a breakpoint
     9        that would pause for any DOM event, regardless of the event's name. This is useful for
     10        situations where the event name isn't known, or where one simply want's to pause on the next
     11        entry to the event loop.
     12
     13        Along these lines, make the "requestAnimationFrame", "setTimeout", and "setInterval"
     14        event breakpoints into special breakpoints that can be added/removed via the create
     15        breakpoint context menu. This simplifies the process for setting these breakpoints, and also
     16        makes them more discoverable (most people wouldn't consider them to be "events").
     17
     18        * UserInterface/Models/EventBreakpoint.js:
     19        (WI.EventBreakpoint):
     20        (WI.EventBreakpoint.deserialize):
     21        (WI.EventBreakpoint.prototype.saveIdentityToCookie):
     22        (WI.EventBreakpoint.prototype.toJSON):
     23
     24        * UserInterface/Controllers/DebuggerManager.js:
     25        (WI.DebuggerManager.prototype._pauseReasonFromPayload):
     26
     27        * UserInterface/Controllers/DOMDebuggerManager.js:
     28        (WI.DOMDebuggerManager):
     29        (WI.DOMDebuggerManager.prototype.initializeTarget):
     30        (WI.DOMDebuggerManager.supportsDOMBreakpoints): Added.
     31        (WI.DOMDebuggerManager.supportsEventBreakpoints):
     32        (WI.DOMDebuggerManager.supportsEventListenerBreakpoints): Added.
     33        (WI.DOMDebuggerManager.supportsURLBreakpoints):
     34        (WI.DOMDebuggerManager.supportsXHRBreakpoints): Added.
     35        (WI.DOMDebuggerManager.supportsAllListenersBreakpoint): Added.
     36        (WI.DOMDebuggerManager.prototype.get allAnimationFramesBreakpoint): Added.
     37        (WI.DOMDebuggerManager.prototype.get allIntervalsBreakpoint): Added.
     38        (WI.DOMDebuggerManager.prototype.get allListenersBreakpoint): Added.
     39        (WI.DOMDebuggerManager.prototype.get allTimeoutsBreakpoint): Added.
     40        (WI.DOMDebuggerManager.prototype.get listenerBreakpoints): Added.
     41        (WI.DOMDebuggerManager.prototype.isBreakpointSpecial):
     42        (WI.DOMDebuggerManager.prototype.listenerBreakpointForEventName): Added.
     43        (WI.DOMDebuggerManager.prototype.addEventBreakpoint):
     44        (WI.DOMDebuggerManager.prototype.removeEventBreakpoint):
     45        (WI.DOMDebuggerManager.prototype.addURLBreakpoint):
     46        (WI.DOMDebuggerManager.prototype._resolveDOMBreakpoint):
     47        (WI.DOMDebuggerManager.prototype._updateDOMBreakpoint):
     48        (WI.DOMDebuggerManager.prototype._updateEventBreakpoint):
     49        (WI.DOMDebuggerManager.prototype._updateURLBreakpoint):
     50        (WI.DOMDebuggerManager.prototype._handleDOMBreakpointDisabledStateChanged):
     51        (WI.DOMDebuggerManager.prototype._handleEventBreakpointDisabledStateChanged):
     52        (WI.DOMDebuggerManager.prototype._handleURLBreakpointDisabledStateChanged):
     53        (WI.DOMDebuggerManager.prototype.get eventBreakpoints): Deleted.
     54        (WI.DOMDebuggerManager.prototype.eventBreakpointForTypeAndEventName): Deleted.
     55        Add additional target compatibility checks.
     56
     57        * UserInterface/Views/EventBreakpointPopover.js:
     58        (WI.EventBreakpointPopover.prototype.show):
     59        (WI.EventBreakpointPopover.prototype.dismiss):
     60        (WI.EventBreakpointPopover.prototype._handleTypeSelectChange): Deleted.
     61        * UserInterface/Views/EventBreakpointPopover.css:
     62        (.popover .event-breakpoint-content > input): Added.
     63        (.popover .event-breakpoint-content > input::placeholder): Added.
     64        (.popover .event-breakpoint-content > .event-type): Deleted.
     65        (.popover .event-breakpoint-content > .event-type > input): Deleted.
     66        (.popover .event-breakpoint-content > .event-type > input::placeholder): Deleted.
     67
     68        * UserInterface/Views/EventBreakpointTreeElement.css:
     69        (.breakpoint.event.breakpoint-for-interval:not(.breakpoint-paused-icon) .icon): Added.
     70        (.breakpoint.event.breakpoint-for-timeout:not(.breakpoint-paused-icon) .icon): Added.
     71        (.breakpoint.event.breakpoint-for-timer:not(.breakpoint-paused-icon) .icon): Deleted.
     72
     73        * UserInterface/Views/DebuggerSidebarPanel.js:
     74        (WI.DebuggerSidebarPanel):
     75        (WI.DebuggerSidebarPanel.prototype.saveStateToCookie):
     76        (WI.DebuggerSidebarPanel.prototype.restoreStateFromCookie):
     77        (WI.DebuggerSidebarPanel.prototype._addBreakpoint):
     78        (WI.DebuggerSidebarPanel.prototype._addTreeElement):
     79        (WI.DebuggerSidebarPanel.prototype._updatePauseReasonSection):
     80        (WI.DebuggerSidebarPanel.prototype._handleBreakpointElementAddedOrRemoved):
     81        (WI.DebuggerSidebarPanel.prototype._populateCreateBreakpointContextMenu.addToggleForSpecialEventBreakpoint): Added.
     82        (WI.DebuggerSidebarPanel.prototype._populateCreateBreakpointContextMenu):
     83        * UserInterface/Views/SourcesNavigationSidebarPanel.js:
     84        (WI.SourcesNavigationSidebarPanel):
     85        (WI.SourcesNavigationSidebarPanel.prototype._insertDebuggerTreeElement):
     86        (WI.SourcesNavigationSidebarPanel.prototype._addBreakpoint):
     87        (WI.SourcesNavigationSidebarPanel.prototype._updatePauseReasonSection):
     88        (WI.SourcesNavigationSidebarPanel.prototype._handleBreakpointElementAddedOrRemoved):
     89        (WI.SourcesNavigationSidebarPanel.prototype._populateCreateBreakpointContextMenu.addToggleForSpecialEventBreakpoint): Added.
     90        (WI.SourcesNavigationSidebarPanel.prototype._populateCreateBreakpointContextMenu):
     91        Add create breakpoint context menu items (also sort the breakpoints in this order):
     92         - "All Animation Frames"  =>  [A] All Animation Frames
     93         - "All Timeouts"          =>  [T] All Timeouts
     94         - "All Intervals"         =>  [I] All Intervals
     95         - "All Events"            =>  [E] All Events
     96
     97        * UserInterface/Controllers/JavaScriptRuntimeCompletionProvider.js:
     98        (WI.JavaScriptRuntimeCompletionProvider.completionControllerCompletionsNeeded.receivedPropertyNames):
     99
     100        * UserInterface/Base/Setting.js:
     101        * UserInterface/Images/EventBreakpointInterval.svg: Added.
     102        * UserInterface/Images/EventBreakpointTimeout.svg: Renamed from Source/WebInspectorUI/UserInterface/Images/EventBreakpointTimer.svg.
     103        * Localizations/en.lproj/localizedStrings.js:
     104
    11052019-08-03  Devin Rousso  <drousso@apple.com>
    2106

  • trunk/Source/WebInspectorUI/Localizations/en.lproj/localizedStrings.js

    r248052 r248201  
    9898localizedStrings["Address"] = "Address";
    9999localizedStrings["All"] = "All";
     100localizedStrings["All Animation Frames"] = "All Animation Frames";
    100101localizedStrings["All Changes"] = "All Changes";
     102localizedStrings["All Events"] = "All Events";
    101103/* Break (pause) on all exceptions */
    102104localizedStrings["All Exceptions"] = "All Exceptions";
     105localizedStrings["All Intervals"] = "All Intervals";
    103106localizedStrings["All Layers"] = "All Layers";
    104107/* A submenu item of 'Break on' that breaks (pauses) before all network requests */
    … …  
    106109localizedStrings["All Resources"] = "All Resources";
    107110localizedStrings["All Storage"] = "All Storage";
     111localizedStrings["All Timeouts"] = "All Timeouts";
    108112localizedStrings["All items in \u0022%s\u0022 must be error objects"] = "All items in \u0022%s\u0022 must be error objects";
    109113localizedStrings["All items in \u0022%s\u0022 must be non-empty strings"] = "All items in \u0022%s\u0022 must be non-empty strings";
    … …  
    302306localizedStrings["DOM"] = "DOM";
    303307localizedStrings["DOM Content Loaded \u2014 %s"] = "DOM Content Loaded \u2014 %s";
    304 localizedStrings["DOM Event"] = "DOM Event";
    305308localizedStrings["DOM Events"] = "DOM Events";
    306309localizedStrings["DOM Nodes:"] = "DOM Nodes:";
    … …  
    12601263localizedStrings["popup"] = "popup";
    12611264localizedStrings["popup, toggle"] = "popup, toggle";
     1265localizedStrings["requestAnimationFrame Fired"] = "requestAnimationFrame Fired";
     1266localizedStrings["setInterval Fired"] = "setInterval Fired";
     1267localizedStrings["setTimeout Fired"] = "setTimeout Fired";
    12621268localizedStrings["space"] = "space";
    12631269localizedStrings["spaces"] = "spaces";

  • trunk/Source/WebInspectorUI/UserInterface/Base/Setting.js

    r246821 r248201  
    159159    selectedNetworkDetailContentViewIdentifier: new WI.Setting("network-detail-content-view-identifier", "preview"),
    160160    sourceMapsEnabled: new WI.Setting("source-maps-enabled", true),
     161    showAllAnimationFramesBreakpoint: new WI.Setting("show-all-animation-frames-breakpoint", false),
     162    showAllIntervalsBreakpoint: new WI.Setting("show-all-inteverals-breakpoint", false),
     163    showAllListenersBreakpoint: new WI.Setting("show-all-listeners-breakpoint", false),
    161164    showAllRequestsBreakpoint: new WI.Setting("show-all-requests-breakpoint", true),
     165    showAllTimeoutsBreakpoint: new WI.Setting("show-all-timeouts-breakpoint", false),
    162166    showAssertionFailuresBreakpoint: new WI.Setting("show-assertion-failures-breakpoint", true),
    163167    showCanvasPath: new WI.Setting("show-canvas-path", false),

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DOMDebuggerManager.js

    r248176 r248201  
    3333        this._domBreakpointFrameIdentifierMap = new Map;
    3434
    35         this._eventBreakpoints = [];
    36 
     35        this._listenerBreakpoints = [];
    3736        this._urlBreakpoints = [];
     37
     38        this._allAnimationFramesBreakpointEnabledSetting = new WI.Setting("break-on-all-animation-frames", false);
     39        this._allAnimationFramesBreakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.AnimationFrame, {
     40            disabled: !this._allAnimationFramesBreakpointEnabledSetting.value,
     41        });
     42
     43        this._allIntervalsBreakpointEnabledSetting = new WI.Setting("break-on-all-intervals", false);
     44        this._allIntervalsBreakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Interval, {
     45            disabled: !this._allIntervalsBreakpointEnabledSetting.value,
     46        });
     47
     48        this._allListenersBreakpointEnabledSetting = new WI.Setting("break-on-all-listeners", false);
     49        this._allListenersBreakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Listener, {
     50            disabled: !this._allListenersBreakpointEnabledSetting.value,
     51        });
     52
     53        this._allTimeoutsBreakpointEnabledSetting = new WI.Setting("break-on-all-timeouts", false);
     54        this._allTimeoutsBreakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Timeout, {
     55            disabled: !this._allTimeoutsBreakpointEnabledSetting.value,
     56        });
     57
    3858        this._allRequestsBreakpointEnabledSetting = new WI.Setting("break-on-all-requests", false);
    39 
    4059        this._allRequestsBreakpoint = new WI.URLBreakpoint(WI.URLBreakpoint.Type.Text, "", {
    4160            disabled: !this._allRequestsBreakpointEnabledSetting.value,
    … …  
    7998        };
    8099
    81         if (this.supported) {
     100        if (DOMDebuggerManager.supportsDOMBreakpoints()) {
    82101            loadBreakpoints(WI.DOMBreakpoint, WI.objectStores.domBreakpoints, ["dom-breakpoints"], (breakpoint) => {
    83102                this.addDOMBreakpoint(breakpoint);
    84103            });
    85 
     104        }
     105
     106        if (DOMDebuggerManager.supportsEventBreakpoints() || DOMDebuggerManager.supportsEventListenerBreakpoints()) {
    86107            loadBreakpoints(WI.EventBreakpoint, WI.objectStores.eventBreakpoints, ["event-breakpoints"], (breakpoint) => {
     108                // Migrate `requestAnimationFrame`, `setTimeout`, and `setInterval` global breakpoints.
     109                switch (breakpoint.type) {
     110                case WI.EventBreakpoint.Type.AnimationFrame:
     111                    this._allAnimationFramesBreakpoint.disabled = breakpoint.disabled;
     112                    if (!WI.settings.showAllAnimationFramesBreakpoint.value) {
     113                        WI.settings.showAllAnimationFramesBreakpoint.value = true;
     114                        this.addEventBreakpoint(this._allAnimationFramesBreakpoint);
     115                    }
     116                    WI.objectStores.eventBreakpoints.deleteObject(breakpoint);
     117                    return;
     118
     119                case WI.EventBreakpoint.Type.Timer:
     120                    switch (breakpoint.eventName) {
     121                    case "setTimeout":
     122                        this._allTimeoutsBreakpoint.disabled = breakpoint.disabled;
     123                        if (!WI.settings.showAllTimeoutsBreakpoint.value) {
     124                            WI.settings.showAllTimeoutsBreakpoint.value = true;
     125                            this.addEventBreakpoint(this._allTimeoutsBreakpoint);
     126                        }
     127                        break;
     128
     129                    case "setInterval":
     130                        this._allIntervalsBreakpoint.disabled = breakpoint.disabled;
     131                        if (!WI.settings.showAllIntervalsBreakpoint.value) {
     132                            WI.settings.showAllIntervalsBreakpoint.value = true;
     133                            this.addEventBreakpoint(this._allIntervalsBreakpoint);
     134                        }
     135                        break;
     136                    }
     137
     138                    WI.objectStores.eventBreakpoints.deleteObject(breakpoint);
     139                    return;
     140                }
     141
    87142                this.addEventBreakpoint(breakpoint);
    88143            });
    89 
     144        }
     145
     146        if (DOMDebuggerManager.supportsURLBreakpoints() || DOMDebuggerManager.supportsXHRBreakpoints()) {
    90147            loadBreakpoints(WI.URLBreakpoint, WI.objectStores.urlBreakpoints, ["xhr-breakpoints", "url-breakpoints"], (breakpoint) => {
    91148                this.addURLBreakpoint(breakpoint);
    … …  
    102159                this._speculativelyResolveDOMBreakpointsForURL(target.mainResource.url);
    103160
    104             for (let breakpoint of this._eventBreakpoints) {
     161            if (!this._allAnimationFramesBreakpoint.disabled)
     162                this._updateEventBreakpoint(this._allAnimationFramesBreakpoint, target);
     163
     164            if (!this._allIntervalsBreakpoint.disabled)
     165                this._updateEventBreakpoint(this._allIntervalsBreakpoint, target);
     166
     167            if (!this._allListenersBreakpoint.disabled)
     168                this._updateEventBreakpoint(this._allListenersBreakpoint, target);
     169
     170            if (!this._allTimeoutsBreakpoint.disabled)
     171                this._updateEventBreakpoint(this._allTimeoutsBreakpoint, target);
     172
     173            if (!this._allRequestsBreakpoint.disabled)
     174                this._updateURLBreakpoint(this._allRequestsBreakpoint, target);
     175
     176            for (let breakpoint of this._listenerBreakpoints) {
    105177                if (!breakpoint.disabled)
    106178                    this._updateEventBreakpoint(breakpoint, target);
    … …  
    111183                    this._updateURLBreakpoint(breakpoint, target);
    112184            }
    113 
    114             if (!this._allRequestsBreakpoint.disabled)
    115                 this._updateURLBreakpoint(this._allRequestsBreakpoint, target);
    116185        }
    117186    }
    … …  
    119188    // Static
    120189
     190    static supportsDOMBreakpoints()
     191    {
     192        // COMPATIBILITY (iOS 10.3): DOMDebugger.setDOMBreakpoint and DOMDebugger.removeDOMBreakpoint did not exist yet.
     193        return InspectorBackend.domains.DOMDebugger && InspectorBackend.domains.DOMDebugger.setDOMBreakpoint && InspectorBackend.domains.DOMDebugger.removeDOMBreakpoint;
     194    }
     195
    121196    static supportsEventBreakpoints()
    122197    {
    123         return InspectorBackend.domains.DOMDebugger.setEventBreakpoint && InspectorBackend.domains.DOMDebugger.removeEventBreakpoint;
     198        // COMPATIBILITY (iOS 13): DOMDebugger.setEventBreakpoint and DOMDebugger.removeEventBreakpoint did not exist yet.
     199        return InspectorBackend.domains.DOMDebugger && InspectorBackend.domains.DOMDebugger.setEventBreakpoint && InspectorBackend.domains.DOMDebugger.removeEventBreakpoint;
     200    }
     201
     202    static supportsEventListenerBreakpoints()
     203    {
     204        // COMPATIBILITY (iOS 12.2): Replaced by DOMDebugger.setEventBreakpoint and DOMDebugger.removeEventBreakpoint.
     205        return InspectorBackend.domains.DOMDebugger && InspectorBackend.domains.DOMDebugger.setEventListenerBreakpoint && InspectorBackend.domains.DOMDebugger.removeEventListenerBreakpoint;
    124206    }
    125207
    126208    static supportsURLBreakpoints()
    127209    {
    128         return InspectorBackend.domains.DOMDebugger.setURLBreakpoint && InspectorBackend.domains.DOMDebugger.removeURLBreakpoint;
     210        // COMPATIBILITY (iOS 13): DOMDebugger.setURLBreakpoint and DOMDebugger.removeURLBreakpoint did not exist yet.
     211        return InspectorBackend.domains.DOMDebugger && InspectorBackend.domains.DOMDebugger.setURLBreakpoint && InspectorBackend.domains.DOMDebugger.removeURLBreakpoint;
     212    }
     213
     214    static supportsXHRBreakpoints()
     215    {
     216        // COMPATIBILITY (iOS 13): Replaced by DOMDebugger.setURLBreakpoint and DOMDebugger.removeURLBreakpoint.
     217        return InspectorBackend.domains.DOMDebugger && InspectorBackend.domains.DOMDebugger.setXHRBreakpoint && InspectorBackend.domains.DOMDebugger.removeXHRBreakpoint;
     218    }
     219
     220    static supportsAllListenersBreakpoint()
     221    {
     222        // COMPATIBILITY (iOS 13): DOMDebugger.EventBreakpointType.Interval and DOMDebugger.EventBreakpointType.Timeout did not exist yet.
     223        return DOMDebuggerManager.supportsEventBreakpoints() && InspectorBackend.domains.DOMDebugger.EventBreakpointType.Interval && InspectorBackend.domains.DOMDebugger.EventBreakpointType.Timeout;
    129224    }
    130225
    … …  
    136231    }
    137232
     233    get allAnimationFramesBreakpoint() { return this._allAnimationFramesBreakpoint; }
     234    get allIntervalsBreakpoint() { return this._allIntervalsBreakpoint; }
     235    get allListenersBreakpoint() { return this._allListenersBreakpoint; }
     236    get allTimeoutsBreakpoint() { return this._allTimeoutsBreakpoint; }
    138237    get allRequestsBreakpoint() { return this._allRequestsBreakpoint; }
    139238
    … …  
    158257    }
    159258
    160     get eventBreakpoints() { return this._eventBreakpoints; }
    161 
     259    get listenerBreakpoints() { return this._listenerBreakpoints; }
    162260    get urlBreakpoints() { return this._urlBreakpoints; }
    163261
    164262    isBreakpointSpecial(breakpoint)
    165263    {
    166         return breakpoint === this._allRequestsBreakpoint;
     264        return breakpoint === this._allAnimationFramesBreakpoint
     265            || breakpoint === this._allIntervalsBreakpoint
     266            || breakpoint === this._allListenersBreakpoint
     267            || breakpoint === this._allTimeoutsBreakpoint
     268            || breakpoint === this._allRequestsBreakpoint;
    167269    }
    168270
    … …  
    258360    }
    259361
    260     eventBreakpointForTypeAndEventName(type, eventName)
    261     {
    262         return this._eventBreakpoints.find((breakpoint) => breakpoint.type === type && breakpoint.eventName === eventName) || null;
     362    listenerBreakpointForEventName(eventName)
     363    {
     364        if (DOMDebuggerManager.supportsAllListenersBreakpoint() && !this._allListenersBreakpoint.disabled)
     365            return this._allListenersBreakpoint;
     366        return this._listenerBreakpoints.find((breakpoint) => breakpoint.eventName === eventName) || null;
    263367    }
    264368
    … …  
    274378        }
    275379
    276         if (this.eventBreakpointForTypeAndEventName(breakpoint.type, breakpoint.eventName))
    277             return;
    278 
    279         this._eventBreakpoints.push(breakpoint);
     380        console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
     381
     382        if (this.listenerBreakpointForEventName(breakpoint.eventName))
     383            return;
     384
     385        this._listenerBreakpoints.push(breakpoint);
    280386
    281387        this.dispatchEventToListeners(WI.DOMDebuggerManager.Event.EventBreakpointAdded, {breakpoint});
    282388
    283389        if (!breakpoint.disabled) {
    284             for (let target of WI.targets) {
    285                 if (target.DOMDebuggerAgent)
    286                     this._updateEventBreakpoint(breakpoint, target);
    287             }
     390            for (let target of WI.targets)
     391                this._updateEventBreakpoint(breakpoint, target);
    288392        }
    289393
    … …  
    304408        }
    305409
    306         if (!this._eventBreakpoints.includes(breakpoint))
    307             return;
    308 
    309         this._eventBreakpoints.remove(breakpoint);
     410        console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
     411
     412        if (!this._listenerBreakpoints.includes(breakpoint))
     413            return;
     414
     415        this._listenerBreakpoints.remove(breakpoint);
    310416
    311417        if (!this._restoringBreakpoints)
    … …  
    318424
    319425        for (let target of WI.targets) {
    320             if (target.DOMDebuggerAgent) {
     426            if (target.DOMDebuggerAgent && (target.DOMDebuggerAgent.removeEventBreakpoint || target.DOMDebuggerAgent.removeEventListenerBreakpoint)) {
    321427                // Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
    322428                if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
    … …  
    359465
    360466        if (!breakpoint.disabled) {
    361             for (let target of WI.targets) {
    362                 if (target.DOMDebuggerAgent)
    363                     this._updateURLBreakpoint(breakpoint, target);
    364             }
     467            for (let target of WI.targets)
     468                this._updateURLBreakpoint(breakpoint, target);
    365469        }
    366470
    … …  
    485589            // We should get the target associated with the nodeIdentifier of this breakpoint.
    486590            let target = WI.assumingMainTarget();
    487             if (target && target.DOMDebuggerAgent)
     591            if (target)
    488592                this._updateDOMBreakpoint(breakpoint, target);
    489593        }
    … …  
    492596    _updateDOMBreakpoint(breakpoint, target)
    493597    {
    494         console.assert(target.DOMDebuggerAgent);
     598        if (!target.DOMDebuggerAgent || !target.DOMDebuggerAgent.setDOMBreakpoint || !target.DOMDebuggerAgent.removeDOMBreakpoint)
     599            return;
    495600
    496601        if (!breakpoint.domNodeIdentifier)
    … …  
    509614    _updateEventBreakpoint(breakpoint, target)
    510615    {
    511         console.assert(target.DOMDebuggerAgent);
     616        if (!target.DOMDebuggerAgent)
     617            return;
    512618
    513619        // Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
    514620        if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
     621            if (!target.DOMDebuggerAgent.setEventListenerBreakpoint || !target.DOMDebuggerAgent.removeEventListenerBreakpoint)
     622                return;
     623
    515624            console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
    516625            if (breakpoint.disabled)
    … …  
    525634        }
    526635
     636        if (!target.DOMDebuggerAgent.setEventBreakpoint || !target.DOMDebuggerAgent.removeEventBreakpoint)
     637            return;
     638
     639        let commandArguments = {};
     640
     641        switch (breakpoint) {
     642        case this._allAnimationFramesBreakpoint:
     643            commandArguments.breakpointType = WI.EventBreakpoint.Type.AnimationFrame;
     644            if (!DOMDebuggerManager.supportsAllListenersBreakpoint())
     645                commandArguments.eventName = "requestAnimationFrame";
     646            break;
     647
     648        case this._allIntervalsBreakpoint:
     649            if (DOMDebuggerManager.supportsAllListenersBreakpoint())
     650                commandArguments.breakpointType = WI.EventBreakpoint.Type.Interval;
     651            else {
     652                commandArguments.breakpointType = WI.EventBreakpoint.Type.Timer;
     653                commandArguments.eventName = "setInterval";
     654            }
     655            break;
     656
     657        case this._allListenersBreakpoint:
     658            if (!DOMDebuggerManager.supportsAllListenersBreakpoint())
     659                return;
     660
     661            commandArguments.breakpointType = WI.EventBreakpoint.Type.Listener;
     662            break;
     663
     664        case this._allTimeoutsBreakpoint:
     665            if (DOMDebuggerManager.supportsAllListenersBreakpoint())
     666                commandArguments.breakpointType = WI.EventBreakpoint.Type.Timeout;
     667            else {
     668                commandArguments.breakpointType = WI.EventBreakpoint.Type.Timer;
     669                commandArguments.eventName = "setTimeout";
     670            }
     671            break;
     672
     673        default:
     674            commandArguments.breakpointType = breakpoint.type;
     675            commandArguments.eventName = breakpoint.eventName;
     676            console.assert(commandArguments.eventName);
     677            break;
     678        }
     679
    527680        if (breakpoint.disabled)
    528             target.DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName);
     681            target.DOMDebuggerAgent.removeEventBreakpoint.invoke(commandArguments);
    529682        else {
    530683            if (!this._restoringBreakpoints && !WI.debuggerManager.breakpointsDisabledTemporarily)
    531684                WI.debuggerManager.breakpointsEnabled = true;
    532685
    533             target.DOMDebuggerAgent.setEventBreakpoint(breakpoint.type, breakpoint.eventName);
     686            target.DOMDebuggerAgent.setEventBreakpoint.invoke(commandArguments);
    534687        }
    535688    }
    … …  
    537690    _updateURLBreakpoint(breakpoint, target)
    538691    {
    539         console.assert(target.DOMDebuggerAgent);
     692        if (!target.DOMDebuggerAgent)
     693            return;
    540694
    541695        // Compatibility (iOS 12.1): DOMDebuggerAgent.removeURLBreakpoint did not exist.
    542696        if (!WI.DOMDebuggerManager.supportsURLBreakpoints()) {
     697            if (!target.DOMDebuggerAgent.setXHRBreakpoint || !target.DOMDebuggerAgent.removeXHRBreakpoint)
     698                return;
     699
    543700            if (breakpoint.disabled)
    544701                target.DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url);
    … …  
    553710        }
    554711
     712        if (!target.DOMDebuggerAgent.setURLBreakpoint || !target.DOMDebuggerAgent.removeURLBreakpoint)
     713            return;
     714
    555715        if (breakpoint.disabled)
    556716            target.DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url);
    … …  
    568728        let breakpoint = event.target;
    569729        let target = WI.assumingMainTarget();
    570         if (target && target.DOMDebuggerAgent)
     730        if (target)
    571731            this._updateDOMBreakpoint(breakpoint, target);
    572732
    … …  
    583743            return;
    584744
    585         for (let target of WI.targets) {
    586             if (target.DOMDebuggerAgent)
    587                 this._updateEventBreakpoint(breakpoint, target);
     745        for (let target of WI.targets)
     746            this._updateEventBreakpoint(breakpoint, target);
     747
     748        switch (breakpoint) {
     749        case this._allAnimationFramesBreakpoint:
     750            this._allAnimationFramesBreakpointEnabledSetting.value = !breakpoint.disabled;
     751            return;
     752
     753        case this._allIntervalsBreakpoint:
     754            this._allIntervalsBreakpointEnabledSetting.value = !breakpoint.disabled;
     755            return;
     756
     757        case this._allListenersBreakpoint:
     758            this._allListenersBreakpointEnabledSetting.value = !breakpoint.disabled;
     759            return;
     760
     761        case this._allTimeoutsBreakpoint:
     762            this._allTimeoutsBreakpointEnabledSetting.value = !breakpoint.disabled;
     763            return;
    588764        }
    589765
    … …  
    596772        let breakpoint = event.target;
    597773
    598         if (breakpoint === this._allRequestsBreakpoint)
     774        for (let target of WI.targets)
     775            this._updateURLBreakpoint(breakpoint, target);
     776
     777        if (breakpoint === this._allRequestsBreakpoint) {
    599778            this._allRequestsBreakpointEnabledSetting.value = !breakpoint.disabled;
    600 
    601         for (let target of WI.targets) {
    602             if (target.DOMDebuggerAgent)
    603                 this._updateURLBreakpoint(breakpoint, target);
     779            return;
    604780        }
    605781

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/DebuggerManager.js

    r248176 r248201  
    864864        case DebuggerAgent.PausedReason.Fetch:
    865865            return WI.DebuggerManager.PauseReason.Fetch;
     866        case DebuggerAgent.PausedReason.Interval:
     867            return WI.DebuggerManager.PauseReason.Interval;
     868        case DebuggerAgent.PausedReason.Listener:
     869            return WI.DebuggerManager.PauseReason.Listener;
    866870        case DebuggerAgent.PausedReason.PauseOnNextStatement:
    867871            return WI.DebuggerManager.PauseReason.PauseOnNextStatement;
     872        case DebuggerAgent.PausedReason.Timeout:
     873            return WI.DebuggerManager.PauseReason.Timeout;
    868874        case DebuggerAgent.PausedReason.Timer:
    869875            return WI.DebuggerManager.PauseReason.Timer;
    … …  
    13841390    DebuggerStatement: "debugger-statement",
    13851391    DOM: "DOM",
    1386     EventListener: "event-listener",
    13871392    Exception: "exception",
    13881393    Fetch: "fetch",
     1394    Interval: "interval",
     1395    Listener: "listener",
    13891396    PauseOnNextStatement: "pause-on-next-statement",
    1390     Timer: "timer",
     1397    Timeout: "timeout",
    13911398    XHR: "xhr",
    13921399    Other: "other",
     1400
     1401    // COMPATIBILITY (iOS 13): DOMDebugger.EventBreakpointType.Timer was replaced by DOMDebugger.EventBreakpointType.Interval and DOMDebugger.EventBreakpointType.Timeout.
     1402    Timer: "timer",
     1403
     1404    // COMPATIBILITY (iOS 13): DOMDebugger.EventBreakpointType.EventListener was replaced by DOMDebugger.EventBreakpointType.Listener.
     1405    EventListener: "event-listener",
    13931406};

  • trunk/Source/WebInspectorUI/UserInterface/Controllers/JavaScriptRuntimeCompletionProvider.js

    r243161 r248201  
    222222                if (WI.debuggerManager.paused) {
    223223                    let targetData = WI.debuggerManager.dataForTarget(WI.runtimeManager.activeExecutionContext.target);
    224                     if (targetData.pauseReason === WI.DebuggerManager.PauseReason.EventListener)
     224                    if (targetData.pauseReason === WI.DebuggerManager.PauseReason.Listener || targetData.pauseReason === WI.DebuggerManager.PauseReason.EventListener)
    225225                        commandLineAPI.push("$event");
    226226                    else if (targetData.pauseReason === WI.DebuggerManager.PauseReason.Exception)

  • trunk/Source/WebInspectorUI/UserInterface/Models/EventBreakpoint.js

    r244279 r248201  
    2626WI.EventBreakpoint = class EventBreakpoint extends WI.Object
    2727{
    28     constructor(type, eventName, {eventListener, disabled} = {})
     28    constructor(type, {eventName, eventListener, disabled} = {})
    2929    {
    3030        super();
    3131
    3232        console.assert(Object.values(WI.EventBreakpoint.Type).includes(type), type);
    33         console.assert(typeof eventName === "string", eventName);
    3433
    3534        this._type = type;
    36         this._eventName = eventName;
     35        this._eventName = eventName || null;
    3736        this._eventListener = eventListener || null;
    3837        this._disabled = disabled || false;
    … …  
    4342    static deserialize(serializedInfo)
    4443    {
    45         return new WI.EventBreakpoint(serializedInfo.type, serializedInfo.eventName, {
     44        return new WI.EventBreakpoint(serializedInfo.type, {
     45            eventName: serializedInfo.eventName,
    4646            disabled: !!serializedInfo.disabled,
    4747        });
    … …  
    7272    {
    7373        cookie["event-breakpoint-type"] = this._type;
    74         cookie["event-breakpoint-event-name"] = this._eventName;
     74        if (this._eventName)
     75            cookie["event-breakpoint-event-name"] = this._eventName;
     76        if (this._eventListener)
     77            cookie["event-breakpoint-event-listener"] = this._eventListener.eventListenerId;
     78        if (this._disabled)
     79            cookie["event-breakpoint-disabled"] = this._disabled;
    7580    }
    7681
    … …  
    7984        let json = {
    8085            type: this._type,
    81             eventName: this._eventName,
    8286        };
     87        if (this._eventName)
     88            json.eventName = this._eventName;
    8389        if (this._disabled)
    8490            json.disabled = true;
    8591        if (key === WI.ObjectStore.toJSONSymbol)
    86             json[WI.objectStores.eventBreakpoints.keyPath] = this._type + ":" + this._eventName;
     92            json[WI.objectStores.eventBreakpoints.keyPath] = this._type + (this._eventName ? ":" + this._eventName : "");
    8793        return json;
    8894    }
    … …  
    9197WI.EventBreakpoint.Type = {
    9298    AnimationFrame: "animation-frame",
     99    Interval: "interval",
    93100    Listener: "listener",
     101    Timeout: "timeout",
     102
     103    // COMPATIBILITY (iOS 13): DOMDebugger.EventBreakpointTypes.Timer was removed.
    94104    Timer: "timer",
    95105};

  • trunk/Source/WebInspectorUI/UserInterface/Views/DebuggerSidebarPanel.js

    r248094 r248201  
    228228
    229229        if (WI.domDebuggerManager.supported) {
     230            if (WI.settings.showAllAnimationFramesBreakpoint.value)
     231                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint);
     232
     233            if (WI.settings.showAllTimeoutsBreakpoint.value)
     234                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allTimeoutsBreakpoint);
     235
     236            if (WI.settings.showAllIntervalsBreakpoint.value)
     237                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allIntervalsBreakpoint);
     238
     239            if (WI.settings.showAllListenersBreakpoint.value)
     240                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allListenersBreakpoint);
     241
     242            for (let eventBreakpoint of WI.domDebuggerManager.listenerBreakpoints)
     243                this._addBreakpoint(eventBreakpoint);
     244
     245            for (let eventListenerBreakpoint of WI.domManager.eventListenerBreakpoints)
     246                this._addBreakpoint(eventListenerBreakpoint);
     247
     248            for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
     249                this._addBreakpoint(domBreakpoint);
     250
    230251            if (WI.settings.showAllRequestsBreakpoint.value)
    231252                WI.domDebuggerManager.addURLBreakpoint(WI.domDebuggerManager.allRequestsBreakpoint);
    232 
    233             for (let eventBreakpoint of WI.domDebuggerManager.eventBreakpoints)
    234                 this._addBreakpoint(eventBreakpoint);
    235 
    236             for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
    237                 this._addBreakpoint(domBreakpoint);
    238 
    239             for (let eventListenerBreakpoint of WI.domManager.eventListenerBreakpoints)
    240                 this._addBreakpoint(eventListenerBreakpoint);
    241253
    242254            for (let urlBreakpoints of WI.domDebuggerManager.urlBreakpoints)
    … …  
    365377        }
    366378
    367         var representedObject = selectedTreeElement.representedObject;
    368 
    369         if (representedObject === WI.debuggerManager.allExceptionsBreakpoint) {
    370             cookie[WI.DebuggerSidebarPanel.SelectedAllExceptionsCookieKey] = true;
    371             return;
    372         }
    373 
    374         if (representedObject === WI.debuggerManager.uncaughtExceptionsBreakpoint) {
    375             cookie[WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey] = true;
    376             return;
    377         }
    378 
    379         if (representedObject === WI.debuggerManager.assertionFailuresBreakpoint) {
    380             cookie[WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey] = true;
    381             return;
    382         }
    383 
    384         if (representedObject === WI.domDebuggerManager.allRequestsBreakpoint) {
    385             cookie[WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey] = true;
     379        switch (selectedTreeElement.representedObject) {
     380        case WI.debuggerManager.allExceptionsBreakpoint:
     381            cookie[DebuggerSidebarPanel.SelectedAllExceptionsCookieKey] = true;
     382            return;
     383
     384        case WI.debuggerManager.uncaughtExceptionsBreakpoint:
     385            cookie[DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey] = true;
     386            return;
     387
     388        case WI.debuggerManager.assertionFailuresBreakpoint:
     389            cookie[DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey] = true;
     390            return;
     391
     392        case WI.domDebuggerManager.allAnimationFramesBreakpoint:
     393            cookie[DebuggerSidebarPanel.SelectedAllAnimationFramesBreakpoint] = true;
     394            return;
     395
     396        case WI.domDebuggerManager.allIntervalsBreakpoint:
     397            cookie[DebuggerSidebarPanel.SelectedAllIntervalsBreakpoint] = true;
     398            return;
     399
     400        case WI.domDebuggerManager.allListenersBreakpoint:
     401            cookie[DebuggerSidebarPanel.SelectedAllListenersBreakpoint] = true;
     402            return;
     403
     404        case WI.domDebuggerManager.allTimeoutsBreakpoint:
     405            cookie[DebuggerSidebarPanel.SelectedAllTimeoutsBreakpoint] = true;
     406            return;
     407
     408        case WI.domDebuggerManager.allRequestsBreakpoint:
     409            cookie[DebuggerSidebarPanel.SelectedAllRequestsCookieKey] = true;
    386410            return;
    387411        }
    … …  
    403427
    404428        // Eagerly resolve the special breakpoints; otherwise, use the default behavior.
    405         if (cookie[WI.DebuggerSidebarPanel.SelectedAllExceptionsCookieKey])
     429        if (cookie[DebuggerSidebarPanel.SelectedAllExceptionsCookieKey])
    406430            revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.allExceptionsBreakpoint);
    407         else if (cookie[WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey])
     431        else if (cookie[DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey])
    408432            revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.uncaughtExceptionsBreakpoint);
    409         else if (cookie[WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey])
     433        else if (cookie[DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey])
    410434            revealAndSelect(this._breakpointsContentTreeOutline, WI.debuggerManager.assertionFailuresBreakpoint);
    411         else if (cookie[WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey])
     435        else if (cookie[DebuggerSidebarPanel.SelectedAllAnimationFramesBreakpoint])
     436            revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allAnimationFramesBreakpoint);
     437        else if (cookie[DebuggerSidebarPanel.SelectedAllIntervalsBreakpoint])
     438            revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allIntervalsBreakpoint);
     439        else if (cookie[DebuggerSidebarPanel.SelectedAllListenersBreakpoint])
     440            revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allListenersBreakpoint);
     441        else if (cookie[DebuggerSidebarPanel.SelectedAllRequestsCookieKey])
    412442            revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allRequestsBreakpoint);
     443        else if (cookie[DebuggerSidebarPanel.SelectedAllTimeoutsBreakpoint])
     444            revealAndSelect(this._breakpointsContentTreeOutline, WI.domDebuggerManager.allTimeoutsBreakpoint);
    413445        else
    414446            super.restoreStateFromCookie(cookie, relaxedMatchDelay);
    … …  
    513545            constructor = WI.EventBreakpointTreeElement;
    514546
    515             if (breakpoint.eventListener) {
     547            if (breakpoint === WI.domDebuggerManager.allAnimationFramesBreakpoint)
     548                options.title = WI.UIString("All Animation Frames");
     549            else if (breakpoint === WI.domDebuggerManager.allIntervalsBreakpoint)
     550                options.title = WI.UIString("All Intervals");
     551            else if (breakpoint === WI.domDebuggerManager.allListenersBreakpoint)
     552                options.title = WI.UIString("All Events");
     553            else if (breakpoint === WI.domDebuggerManager.allTimeoutsBreakpoint)
     554                options.title = WI.UIString("All Timeouts");
     555            else if (breakpoint.eventListener) {
    516556                let eventTargetTreeElement = null;
    517557                if (breakpoint.eventListener.onWindow) {
    … …  
    10651105                (treeElement) => treeElement.representedObject === WI.debuggerManager.assertionFailuresBreakpoint,
    10661106                (treeElement) => treeElement instanceof WI.BreakpointTreeElement || treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement,
     1107                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allAnimationFramesBreakpoint,
     1108                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allTimeoutsBreakpoint,
     1109                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allIntervalsBreakpoint,
     1110                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allListenersBreakpoint,
    10671111                (treeElement) => treeElement instanceof WI.EventBreakpointTreeElement,
    10681112                (treeElement) => treeElement instanceof WI.DOMNodeTreeElement,
    … …  
    11241168        switch (pauseReason) {
    11251169        case WI.DebuggerManager.PauseReason.AnimationFrame:
    1126             console.assert(pauseData, "Expected data with an animation frame, but found none.");
    1127             if (!pauseData)
    1128                 return false;
    1129 
    1130             var eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.AnimationFrame, pauseData.eventName);
    1131             console.assert(eventBreakpoint, "Expected AnimationFrame breakpoint for event name.", pauseData.eventName);
    1132             if (!eventBreakpoint)
    1133                 return false;
    1134 
    11351170            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
    11361171
    1137             var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(eventBreakpoint, {
     1172            var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allAnimationFramesBreakpoint, {
    11381173                className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
    1139                 title: WI.UIString("%s Fired").format(pauseData.eventName),
     1174                title: WI.UIString("requestAnimationFrame Fired"),
    11401175            });
    11411176            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
    … …  
    12541289            break;
    12551290
     1291        case WI.DebuggerManager.PauseReason.Listener:
    12561292        case WI.DebuggerManager.PauseReason.EventListener:
    12571293            console.assert(pauseData, "Expected data with an event listener, but found none.");
    … …  
    12631299                eventBreakpoint = WI.domManager.breakpointForEventListenerId(pauseData.eventListenerId);
    12641300            if (!eventBreakpoint)
    1265                 eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Listener, pauseData.eventName);
     1301                eventBreakpoint = WI.domDebuggerManager.listenerBreakpointForEventName(pauseData.eventName);
    12661302
    12671303            console.assert(eventBreakpoint, "Expected Event Listener breakpoint for event name.", pauseData.eventName);
    … …  
    13091345            break;
    13101346
     1347        case WI.DebuggerManager.PauseReason.Interval:
     1348            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
     1349
     1350            var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allIntervalsBreakpoint, {
     1351                className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
     1352                title: WI.UIString("setInterval Fired"),
     1353            });
     1354            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
     1355
     1356            var eventBreakpointRow = new WI.DetailsSectionRow;
     1357            eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
     1358
     1359            this._pauseReasonGroup.rows = [eventBreakpointRow];
     1360            return true;
     1361
    13111362        case WI.DebuggerManager.PauseReason.PauseOnNextStatement:
    13121363            this._pauseReasonTextRow.text = WI.UIString("Immediate Pause Requested");
    … …  
    13191370                return false;
    13201371
    1321             var eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Timer, pauseData.eventName);
     1372            var eventBreakpoint = null;
     1373            switch (pauseData.eventName) {
     1374            case "setTimeout":
     1375                eventBreakpoint = WI.domDebuggerManager.allTimeoutsBreakpoint;
     1376                break;
     1377
     1378            case "setInterval":
     1379                eventBreakpoint = WI.domDebuggerManager.allIntervalsBreakpoint;
     1380                break;
     1381            }
    13221382            console.assert(eventBreakpoint, "Expected Timer breakpoint for event name.", pauseData.eventName);
    13231383            if (!eventBreakpoint)
    … …  
    13291389                className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
    13301390                title: WI.UIString("%s Fired").format(pauseData.eventName),
     1391            });
     1392            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
     1393
     1394            var eventBreakpointRow = new WI.DetailsSectionRow;
     1395            eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
     1396
     1397            this._pauseReasonGroup.rows = [eventBreakpointRow];
     1398            return true;
     1399
     1400        case WI.DebuggerManager.PauseReason.Timeout:
     1401            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
     1402
     1403            var eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allTimeoutsBreakpoint, {
     1404                className: WI.DebuggerSidebarPanel.PausedBreakpointIconStyleClassName,
     1405                title: WI.UIString("setTimeout Fired"),
    13311406            });
    13321407            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
    … …  
    14571532
    14581533        let setting = null;
    1459         if (treeElement.breakpoint === WI.debuggerManager.assertionFailuresBreakpoint)
     1534        switch (treeElement.representedObject) {
     1535        case WI.debuggerManager.assertionFailuresBreakpoint:
    14601536            setting = WI.settings.showAssertionFailuresBreakpoint;
    1461         else if (treeElement.representedObject === WI.domDebuggerManager.allRequestsBreakpoint)
     1537            break;
     1538
     1539        case WI.domDebuggerManager.allAnimationFramesBreakpoint:
     1540            setting = WI.settings.showAllAnimationFramesBreakpoint;
     1541            break;
     1542
     1543        case WI.domDebuggerManager.allIntervalsBreakpoint:
     1544            setting = WI.settings.showAllIntervalsBreakpoint;
     1545            break;
     1546
     1547        case WI.domDebuggerManager.allListenersBreakpoint:
     1548            setting = WI.settings.showAllListenersBreakpoint;
     1549            break;
     1550
     1551        case WI.domDebuggerManager.allRequestsBreakpoint:
    14621552            setting = WI.settings.showAllRequestsBreakpoint;
    1463 
     1553            break;
     1554
     1555        case WI.domDebuggerManager.allTimeoutsBreakpoint:
     1556            setting = WI.settings.showAllTimeoutsBreakpoint;
     1557            break;
     1558        }
    14641559        if (setting)
    14651560            setting.value = !!treeElement.parent;
    … …  
    14821577        }
    14831578
    1484         if (WI.domDebuggerManager.supported) {
     1579        if (WI.DOMDebuggerManager.supportsEventBreakpoints() || WI.DOMDebuggerManager.supportsEventListenerBreakpoints()) {
     1580            function addToggleForSpecialEventBreakpoint(breakpoint, label, checked) {
     1581                contextMenu.appendCheckboxItem(label, () => {
     1582                    if (checked)
     1583                        WI.domDebuggerManager.removeEventBreakpoint(breakpoint);
     1584                    else {
     1585                        breakpoint.disabled = false;
     1586                        WI.domDebuggerManager.addEventBreakpoint(breakpoint);
     1587                    }
     1588                }, checked);
     1589            }
     1590
    14851591            contextMenu.appendSeparator();
     1592
     1593            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint, WI.UIString("All Animation Frames"), WI.settings.showAllAnimationFramesBreakpoint.value);
     1594            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allTimeoutsBreakpoint, WI.UIString("All Timeouts"), WI.settings.showAllTimeoutsBreakpoint.value);
     1595            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allIntervalsBreakpoint, WI.UIString("All Intervals"), WI.settings.showAllIntervalsBreakpoint.value);
     1596
     1597            contextMenu.appendSeparator();
     1598
     1599            if (WI.DOMDebuggerManager.supportsAllListenersBreakpoint())
     1600                addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allListenersBreakpoint, WI.UIString("All Events"), WI.settings.showAllListenersBreakpoint.value);
    14861601
    14871602            contextMenu.appendItem(WI.UIString("Event Breakpoint\u2026"), () => {
    … …  
    14911606
    14921607            contextMenu.appendSeparator();
    1493 
     1608        }
     1609
     1610        if (WI.DOMDebuggerManager.supportsURLBreakpoints() || WI.DOMDebuggerManager.supportsXHRBreakpoints()) {
    14941611            let allRequestsBreakpointShown = WI.settings.showAllRequestsBreakpoint.value;
    1495 
    14961612            contextMenu.appendCheckboxItem(WI.repeatedUIString.allRequests(), () => {
    14971613                if (allRequestsBreakpointShown)
    … …  
    15191635WI.DebuggerSidebarPanel.SelectedUncaughtExceptionsCookieKey = "debugger-sidebar-panel-uncaught-exceptions-breakpoint";
    15201636WI.DebuggerSidebarPanel.SelectedAssertionFailuresCookieKey = "debugger-sidebar-panel-assertion-failures-breakpoint";
     1637WI.DebuggerSidebarPanel.SelectedAllAnimationFramesBreakpoint = "debugger-sidebar-panel-all-animation-frames-breakpoint";
     1638WI.DebuggerSidebarPanel.SelectedAllIntervalsBreakpoint = "debugger-sidebar-panel-all-intervals-breakpoint";
     1639WI.DebuggerSidebarPanel.SelectedAllListenersBreakpoint = "debugger-sidebar-panel-all-listeners-breakpoint";
     1640WI.DebuggerSidebarPanel.SelectedAllTimeoutsBreakpoint = "debugger-sidebar-panel-all-timeouts-breakpoint";
    15211641WI.DebuggerSidebarPanel.SelectedAllRequestsCookieKey = "debugger-sidebar-panel-all-requests-breakpoint";

  • trunk/Source/WebInspectorUI/UserInterface/Views/EventBreakpointPopover.css

    r239953 r248201  
    2929}
    3030
    31 .popover .event-breakpoint-content > .event-type {
    32     display: flex;
     31.popover .event-breakpoint-content > input {
    3332    margin-top: 4px;
    34 }
    35 
    36 .popover .event-breakpoint-content > .event-type > input {
    3733    font-family: Menlo, monospace;
    3834    text-align: left;
    3935}
    4036
    41 .popover .event-breakpoint-content > .event-type > input::placeholder {
     37.popover .event-breakpoint-content > input::placeholder {
    4238    font-family: system-ui;
    4339}

  • trunk/Source/WebInspectorUI/UserInterface/Views/EventBreakpointPopover.js

    r239955 r248201  
    5757        label.textContent = WI.UIString("Break on events with name:");
    5858
    59         let typeContainer = contentElement.appendChild(document.createElement("div"));
    60         typeContainer.classList.add("event-type");
    61 
    62         this._typeSelectElement = typeContainer.appendChild(document.createElement("select"));
    63         this._typeSelectElement.addEventListener("change", this._handleTypeSelectChange.bind(this));
    64         this._typeSelectElement.addEventListener("keydown", (event) => {
    65             if (isEnterKey(event))
    66                 this.dismiss();
    67         });
    68 
    69         let createOption = (text, value) => {
    70             let optionElement = this._typeSelectElement.appendChild(document.createElement("option"));
    71             optionElement.value = value;
    72             optionElement.textContent = text;
    73         };
    74 
    75         createOption(WI.UIString("DOM Event"), WI.EventBreakpoint.Type.Listener);
    76 
    77         if (WI.DOMDebuggerManager.supportsEventBreakpoints()) {
    78             createOption(WI.unlocalizedString("requestAnimationFrame"), "requestAnimationFrame");
    79             createOption(WI.unlocalizedString("setTimeout"), "setTimeout");
    80             createOption(WI.unlocalizedString("setInterval"), "setInterval");
    81         } else
    82             this._typeSelectElement.hidden = true;
    83 
    84         this._domEventNameInputElement = typeContainer.appendChild(document.createElement("input"));
     59        this._domEventNameInputElement = contentElement.appendChild(document.createElement("input"));
    8560        this._domEventNameInputElement.setAttribute("dir", "ltr");
    8661        this._domEventNameInputElement.placeholder = WI.UIString("Example: \u201C%s\u201D").format("click");
    … …  
    126101        this._presentOverTargetElement();
    127102
    128         this._typeSelectElement.value = WI.EventBreakpoint.Type.Listener;
    129103        this._domEventNameInputElement.select();
    130104    }
    … …  
    132106    dismiss()
    133107    {
    134         let type = this._typeSelectElement.value;
    135         let value = null;
    136 
    137         if (type === WI.EventBreakpoint.Type.Listener)
    138             value = this._domEventNameInputElement.value;
    139         else {
    140             value = type;
    141 
    142             if (value === "requestAnimationFrame")
    143                 type = WI.EventBreakpoint.Type.AnimationFrame;
    144             else if (value === "setTimeout" || value === "setInterval")
    145                 type = WI.EventBreakpoint.Type.Timer;
    146         }
    147 
    148         if (type && value)
    149             this._breakpoint = new WI.EventBreakpoint(type, value);
     108        this._breakpoint = new WI.EventBreakpoint(WI.EventBreakpoint.Type.Listener, {eventName: this._domEventNameInputElement.value});
    150109
    151110        super.dismiss();
    … …  
    174133    }
    175134
    176     _handleTypeSelectChange(event)
    177     {
    178         let listenerTypeSelected = this._typeSelectElement.value === WI.EventBreakpoint.Type.Listener;
    179         this._domEventNameInputElement.hidden = !listenerTypeSelected;
    180 
    181         this.update();
    182 
    183         if (listenerTypeSelected) {
    184             this._domEventNameInputElement.focus();
    185 
    186             if (this._domEventNameInputElement.value)
    187                 this._showSuggestionsView();
    188         } else
    189             this._suggestionsView.hide();
    190     }
    191 
    192135     _showSuggestionsView()
    193136     {

  • trunk/Source/WebInspectorUI/UserInterface/Views/EventBreakpointTreeElement.css

    r235248 r248201  
    2828}
    2929
     30.breakpoint.event.breakpoint-for-interval:not(.breakpoint-paused-icon) .icon {
     31    content: url(../Images/EventBreakpointInterval.svg);
     32}
     33
    3034.breakpoint.event.breakpoint-for-listener:not(.breakpoint-paused-icon) .icon {
    3135    content: url(../Images/EventBreakpointListener.svg);
    3236}
    3337
    34 .breakpoint.event.breakpoint-for-timer:not(.breakpoint-paused-icon) .icon {
    35     content: url(../Images/EventBreakpointTimer.svg);
     38.breakpoint.event.breakpoint-for-timeout:not(.breakpoint-paused-icon) .icon {
     39    content: url(../Images/EventBreakpointTimeout.svg);
    3640}

  • trunk/Source/WebInspectorUI/UserInterface/Views/SourcesNavigationSidebarPanel.js

    r248094 r248201  
    317317
    318318        if (WI.domDebuggerManager.supported) {
     319            if (WI.settings.showAllAnimationFramesBreakpoint.value)
     320                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint);
     321
     322            if (WI.settings.showAllTimeoutsBreakpoint.value)
     323                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allTimeoutsBreakpoint);
     324
     325            if (WI.settings.showAllIntervalsBreakpoint.value)
     326                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allIntervalsBreakpoint);
     327
     328            if (WI.settings.showAllListenersBreakpoint.value)
     329                WI.domDebuggerManager.addEventBreakpoint(WI.domDebuggerManager.allListenersBreakpoint);
     330
     331            for (let eventBreakpoint of WI.domDebuggerManager.listenerBreakpoints)
     332                this._addBreakpoint(eventBreakpoint);
     333
     334            for (let eventListenerBreakpoint of WI.domManager.eventListenerBreakpoints)
     335                this._addBreakpoint(eventListenerBreakpoint);
     336
     337            for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
     338                this._addBreakpoint(domBreakpoint);
     339
    319340            if (WI.settings.showAllRequestsBreakpoint.value)
    320341                WI.domDebuggerManager.addURLBreakpoint(WI.domDebuggerManager.allRequestsBreakpoint);
    321 
    322             for (let eventBreakpoint of WI.domDebuggerManager.eventBreakpoints)
    323                 this._addBreakpoint(eventBreakpoint);
    324 
    325             for (let domBreakpoint of WI.domDebuggerManager.domBreakpoints)
    326                 this._addBreakpoint(domBreakpoint);
    327 
    328             for (let eventListenerBreakpoint of WI.domManager.eventListenerBreakpoints)
    329                 this._addBreakpoint(eventListenerBreakpoint);
    330342
    331343            for (let urlBreakpoints of WI.domDebuggerManager.urlBreakpoints)
    … …  
    855867                (treeElement) => treeElement.representedObject === WI.debuggerManager.assertionFailuresBreakpoint,
    856868                (treeElement) => treeElement instanceof WI.BreakpointTreeElement || treeElement instanceof WI.ResourceTreeElement || treeElement instanceof WI.ScriptTreeElement,
     869                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allAnimationFramesBreakpoint,
     870                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allTimeoutsBreakpoint,
     871                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allIntervalsBreakpoint,
     872                (treeElement) => treeElement.representedObject === WI.domDebuggerManager.allListenersBreakpoint,
    857873                (treeElement) => treeElement instanceof WI.EventBreakpointTreeElement,
    858874                (treeElement) => treeElement instanceof WI.DOMNodeTreeElement,
    … …  
    936952            constructor = WI.EventBreakpointTreeElement;
    937953
    938             if (breakpoint.eventListener) {
     954            if (breakpoint === WI.domDebuggerManager.allAnimationFramesBreakpoint)
     955                options.title = WI.UIString("All Animation Frames");
     956            else if (breakpoint === WI.domDebuggerManager.allIntervalsBreakpoint)
     957                options.title = WI.UIString("All Intervals");
     958            else if (breakpoint === WI.domDebuggerManager.allListenersBreakpoint)
     959                options.title = WI.UIString("All Events");
     960            else if (breakpoint === WI.domDebuggerManager.allTimeoutsBreakpoint)
     961                options.title = WI.UIString("All Timeouts");
     962            else if (breakpoint.eventListener) {
    939963                let eventTargetTreeElement = null;
    940964                if (breakpoint.eventListener.onWindow) {
    … …  
    11371161        switch (pauseReason) {
    11381162        case WI.DebuggerManager.PauseReason.AnimationFrame: {
    1139             console.assert(pauseData, "Expected data with an animation frame, but found none.");
    1140             if (!pauseData)
    1141                 break;
    1142 
    1143             let eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.AnimationFrame, pauseData.eventName);
    1144             console.assert(eventBreakpoint, "Expected AnimationFrame breakpoint for event name.", pauseData.eventName);
    1145             if (!eventBreakpoint)
    1146                 break;
    1147 
    11481163            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
    11491164
    1150             let eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(eventBreakpoint, {
     1165            let eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allAnimationFramesBreakpoint, {
    11511166                className: "breakpoint-paused-icon",
    1152                 title: WI.UIString("%s Fired").format(pauseData.eventName),
     1167                title: WI.UIString("requestAnimationFrame Fired"),
    11531168            });
    11541169            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
    … …  
    12691284        }
    12701285
     1286        case WI.DebuggerManager.PauseReason.Listener:
    12711287        case WI.DebuggerManager.PauseReason.EventListener: {
    12721288            console.assert(pauseData, "Expected data with an event listener, but found none.");
    … …  
    12781294                eventBreakpoint = WI.domManager.breakpointForEventListenerId(pauseData.eventListenerId);
    12791295            if (!eventBreakpoint)
    1280                 eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Listener, pauseData.eventName);
     1296                eventBreakpoint = WI.domDebuggerManager.listenerBreakpointForEventName(pauseData.eventName);
    12811297
    12821298            console.assert(eventBreakpoint, "Expected Event Listener breakpoint for event name.", pauseData.eventName);
    … …  
    13261342        }
    13271343
     1344        case WI.DebuggerManager.PauseReason.Interval: {
     1345            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
     1346
     1347            let eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allIntervalsBreakpoint, {
     1348                className: "breakpoint-paused-icon",
     1349                title: WI.UIString("setInterval Fired"),
     1350            });
     1351            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
     1352
     1353            let eventBreakpointRow = new WI.DetailsSectionRow;
     1354            eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
     1355
     1356            this._pauseReasonGroup.rows = [eventBreakpointRow];
     1357            return true;
     1358        }
     1359
    13281360        case WI.DebuggerManager.PauseReason.PauseOnNextStatement:
    13291361            this._pauseReasonTextRow.text = WI.UIString("Immediate Pause Requested");
    … …  
    13361368                break;
    13371369
    1338             let eventBreakpoint = WI.domDebuggerManager.eventBreakpointForTypeAndEventName(WI.EventBreakpoint.Type.Timer, pauseData.eventName);
     1370            let eventBreakpoint = null;
     1371            switch (pauseData.eventName) {
     1372            case "setTimeout":
     1373                eventBreakpoint = WI.domDebuggerManager.allTimeoutsBreakpoint;
     1374                break;
     1375
     1376            case "setInterval":
     1377                eventBreakpoint = WI.domDebuggerManager.allIntervalsBreakpoint;
     1378                break;
     1379            }
    13391380            console.assert(eventBreakpoint, "Expected Timer breakpoint for event name.", pauseData.eventName);
    13401381            if (!eventBreakpoint)
    … …  
    13461387                className: "breakpoint-paused-icon",
    13471388                title: WI.UIString("%s Fired").format(pauseData.eventName),
     1389            });
     1390            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
     1391
     1392            let eventBreakpointRow = new WI.DetailsSectionRow;
     1393            eventBreakpointRow.element.appendChild(this._pauseReasonTreeOutline.element);
     1394
     1395            this._pauseReasonGroup.rows = [eventBreakpointRow];
     1396            return true;
     1397        }
     1398
     1399        case WI.DebuggerManager.PauseReason.Timeout: {
     1400            this._pauseReasonTreeOutline = this.createContentTreeOutline({suppressFiltering: true});
     1401
     1402            let eventBreakpointTreeElement = new WI.EventBreakpointTreeElement(WI.domDebuggerManager.allTimeoutsBreakpoint, {
     1403                className: "breakpoint-paused-icon",
     1404                title: WI.UIString("setTimeout Fired"),
    13481405            });
    13491406            this._pauseReasonTreeOutline.appendChild(eventBreakpointTreeElement);
    … …  
    14941551
    14951552        let setting = null;
    1496         if (treeElement.breakpoint === WI.debuggerManager.assertionFailuresBreakpoint)
     1553        switch (treeElement.representedObject) {
     1554        case WI.debuggerManager.assertionFailuresBreakpoint:
    14971555            setting = WI.settings.showAssertionFailuresBreakpoint;
    1498         else if (treeElement.representedObject === WI.domDebuggerManager.allRequestsBreakpoint)
     1556            break;
     1557
     1558        case WI.domDebuggerManager.allAnimationFramesBreakpoint:
     1559            setting = WI.settings.showAllAnimationFramesBreakpoint;
     1560            break;
     1561
     1562        case WI.domDebuggerManager.allIntervalsBreakpoint:
     1563            setting = WI.settings.showAllIntervalsBreakpoint;
     1564            break;
     1565
     1566        case WI.domDebuggerManager.allListenersBreakpoint:
     1567            setting = WI.settings.showAllListenersBreakpoint;
     1568            break;
     1569
     1570        case WI.domDebuggerManager.allRequestsBreakpoint:
    14991571            setting = WI.settings.showAllRequestsBreakpoint;
     1572            break;
     1573
     1574        case WI.domDebuggerManager.allTimeoutsBreakpoint:
     1575            setting = WI.settings.showAllTimeoutsBreakpoint;
     1576            break;
     1577        }
    15001578
    15011579        if (setting)
    … …  
    15241602        }
    15251603
    1526         if (WI.domDebuggerManager.supported) {
     1604        if (WI.DOMDebuggerManager.supportsEventBreakpoints() || WI.DOMDebuggerManager.supportsEventListenerBreakpoints()) {
     1605            function addToggleForSpecialEventBreakpoint(breakpoint, label, checked) {
     1606                contextMenu.appendCheckboxItem(label, () => {
     1607                    if (checked)
     1608                        WI.domDebuggerManager.removeEventBreakpoint(breakpoint);
     1609                    else {
     1610                        breakpoint.disabled = false;
     1611                        WI.domDebuggerManager.addEventBreakpoint(breakpoint);
     1612                    }
     1613                }, checked);
     1614            }
     1615
    15271616            contextMenu.appendSeparator();
     1617
     1618            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allAnimationFramesBreakpoint, WI.UIString("All Animation Frames"), WI.settings.showAllAnimationFramesBreakpoint.value);
     1619            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allTimeoutsBreakpoint, WI.UIString("All Timeouts"), WI.settings.showAllTimeoutsBreakpoint.value);
     1620            addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allIntervalsBreakpoint, WI.UIString("All Intervals"), WI.settings.showAllIntervalsBreakpoint.value);
     1621
     1622            contextMenu.appendSeparator();
     1623
     1624            if (WI.DOMDebuggerManager.supportsAllListenersBreakpoint())
     1625                addToggleForSpecialEventBreakpoint(WI.domDebuggerManager.allListenersBreakpoint, WI.UIString("All Events"), WI.settings.showAllListenersBreakpoint.value);
    15281626
    15291627            contextMenu.appendItem(WI.UIString("Event Breakpoint\u2026"), () => {
    … …  
    15331631
    15341632            contextMenu.appendSeparator();
    1535 
     1633        }
     1634
     1635        if (WI.DOMDebuggerManager.supportsURLBreakpoints() || WI.DOMDebuggerManager.supportsXHRBreakpoints()) {
    15361636            let allRequestsBreakpointShown = WI.settings.showAllRequestsBreakpoint.value;
    1537 
    15381637            contextMenu.appendCheckboxItem(WI.repeatedUIString.allRequests(), () => {
    15391638                if (allRequestsBreakpointShown)
    … …  
    15451644            }, allRequestsBreakpointShown);
    15461645
    1547             contextMenu.appendItem(WI.UIString("URL Breakpoint\u2026"), () => {
     1646            contextMenu.appendItem(WI.DOMDebuggerManager.supportsURLBreakpoints() ? WI.UIString("URL Breakpoint\u2026") : WI.UIString("XHR Breakpoint\u2026"), () => {
    15481647                let popover = new WI.URLBreakpointPopover(this);
    15491648                popover.show(this._createBreakpointButton.element, [WI.RectEdge.MAX_Y, WI.RectEdge.MIN_Y, WI.RectEdge.MAX_X]);
Note: See TracChangeset for help on using the changeset viewer.