Changeset 242318 in webkit


Ignore:
Timestamp:
Mar 2, 2019 2:40:43 PM (5 years ago)
Author:
Devin Rousso
Message:

Web Inspector: Debugger: DOM, URL, and Event breakpoints don't grey out when all breakpoints are disabled
​https://bugs.webkit.org/show_bug.cgi?id=195170
<rdar://problem/48478193>

Reviewed by Joseph Pecoraro.

  • UserInterface/Views/DOMBreakpointTreeElement.js:

(WI.DOMBreakpointTreeElement):
(WI.DOMBreakpointTreeElement.prototype.onattach):
(WI.DOMBreakpointTreeElement.prototype.ondetach):
(WI.DOMBreakpointTreeElement.prototype._updateStatus):

  • UserInterface/Views/EventBreakpointTreeElement.js:

(WI.EventBreakpointTreeElement):
(WI.EventBreakpointTreeElement.prototype.onattach):
(WI.EventBreakpointTreeElement.prototype.ondetach):
(WI.EventBreakpointTreeElement.prototype._updateStatus):

  • UserInterface/Views/URLBreakpointTreeElement.js:

(WI.URLBreakpointTreeElement):
(WI.URLBreakpointTreeElement.prototype.onattach):
(WI.URLBreakpointTreeElement.prototype.ondetach):
(WI.URLBreakpointTreeElement.prototype._updateStatus):
Remove the "resolved" class when the global "breakpoints enabled" state is changed.

  • UserInterface/Controllers/DOMDebuggerManager.js:

(WI.DOMDebuggerManager):
(WI.DOMDebuggerManager.prototype._handleDOMBreakpointDisabledStateChanged): Added.
(WI.DOMDebuggerManager.prototype._handleEventBreakpointDisabledStateChanged): Added.
(WI.DOMDebuggerManager.prototype._handleURLBreakpointDisabledStateChanged): Added.
(WI.DOMDebuggerManager.prototype._updateEventBreakpoint):
(WI.DOMDebuggerManager.prototype._updateURLBreakpoint):
(WI.DOMDebuggerManager.prototype._resolveEventBreakpoint):
(WI.DOMDebuggerManager.prototype._resolveURLBreakpoint):
(WI.DOMDebuggerManager.prototype._updateEventBreakpoint.breakpointUpdated): Deleted.
(WI.DOMDebuggerManager.prototype._updateURLBreakpoint.breakpointUpdated): Deleted.

  • UserInterface/Models/DOMBreakpoint.js:

(WI.DOMBreakpoint):
(WI.DOMBreakpoint.deserialize): Added.
(WI.DOMBreakpoint.prototype.set disabled):
(WI.DOMBreakpoint.prototype.set domNodeIdentifier):

  • UserInterface/Models/EventBreakpoint.js:

(WI.EventBreakpoint.deserialize): Added.
(WI.EventBreakpoint.prototype.set disabled):
(WI.EventBreakpoint.fromPayload): Deleted.

  • UserInterface/Models/URLBreakpoint.js:

(WI.URLBreakpoint.deserialize): Added.
(WI.URLBreakpoint.prototype.set disabled):

  • UserInterface/Views/DOMTreeContentView.js:

(WI.DOMTreeContentView):
(WI.DOMTreeContentView.prototype._handleDOMBreakpointDisabledStateChanged): Added.
(WI.DOMTreeContentView.prototype._handleDOMBreakpointDOMNodeChanged): Added.

  • UserInterface/Views/DebuggerSidebarPanel.js:

(WI.DebuggerSidebarPanel.prototype._handleDOMBreakpointResolvedStateChanged): Added.

  • UserInterface/Views/SourcesNavigationSidebarPanel.js:

(WI.SourcesNavigationSidebarPanel):
(WI.SourcesNavigationSidebarPanel.prototype._handleDOMBreakpointResolvedStateChanged): Added.
Drive-by: rename all events with the name *DidChange to *Changed.
Drive-by: create static deserialize helper functions.

Location:
trunk/Source/WebInspectorUI
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebInspectorUI/ChangeLog

    r242315 r242318  
     12019-03-02  Devin Rousso  <drousso@apple.com>
     2
     3        Web Inspector: Debugger: DOM, URL, and Event breakpoints don't grey out when all breakpoints are disabled
     4        https://bugs.webkit.org/show_bug.cgi?id=195170
     5        <rdar://problem/48478193>
     6
     7        Reviewed by Joseph Pecoraro.
     8
     9        * UserInterface/Views/DOMBreakpointTreeElement.js:
     10        (WI.DOMBreakpointTreeElement):
     11        (WI.DOMBreakpointTreeElement.prototype.onattach):
     12        (WI.DOMBreakpointTreeElement.prototype.ondetach):
     13        (WI.DOMBreakpointTreeElement.prototype._updateStatus):
     14        * UserInterface/Views/EventBreakpointTreeElement.js:
     15        (WI.EventBreakpointTreeElement):
     16        (WI.EventBreakpointTreeElement.prototype.onattach):
     17        (WI.EventBreakpointTreeElement.prototype.ondetach):
     18        (WI.EventBreakpointTreeElement.prototype._updateStatus):
     19        * UserInterface/Views/URLBreakpointTreeElement.js:
     20        (WI.URLBreakpointTreeElement):
     21        (WI.URLBreakpointTreeElement.prototype.onattach):
     22        (WI.URLBreakpointTreeElement.prototype.ondetach):
     23        (WI.URLBreakpointTreeElement.prototype._updateStatus):
     24        Remove the `"resolved"` class when the global "breakpoints enabled" state is changed.
     25
     26        * UserInterface/Controllers/DOMDebuggerManager.js:
     27        (WI.DOMDebuggerManager):
     28        (WI.DOMDebuggerManager.prototype._handleDOMBreakpointDisabledStateChanged): Added.
     29        (WI.DOMDebuggerManager.prototype._handleEventBreakpointDisabledStateChanged): Added.
     30        (WI.DOMDebuggerManager.prototype._handleURLBreakpointDisabledStateChanged): Added.
     31        (WI.DOMDebuggerManager.prototype._updateEventBreakpoint):
     32        (WI.DOMDebuggerManager.prototype._updateURLBreakpoint):
     33        (WI.DOMDebuggerManager.prototype._resolveEventBreakpoint):
     34        (WI.DOMDebuggerManager.prototype._resolveURLBreakpoint):
     35        (WI.DOMDebuggerManager.prototype._updateEventBreakpoint.breakpointUpdated): Deleted.
     36        (WI.DOMDebuggerManager.prototype._updateURLBreakpoint.breakpointUpdated): Deleted.
     37        * UserInterface/Models/DOMBreakpoint.js:
     38        (WI.DOMBreakpoint):
     39        (WI.DOMBreakpoint.deserialize): Added.
     40        (WI.DOMBreakpoint.prototype.set disabled):
     41        (WI.DOMBreakpoint.prototype.set domNodeIdentifier):
     42        * UserInterface/Models/EventBreakpoint.js:
     43        (WI.EventBreakpoint.deserialize): Added.
     44        (WI.EventBreakpoint.prototype.set disabled):
     45        (WI.EventBreakpoint.fromPayload): Deleted.
     46        * UserInterface/Models/URLBreakpoint.js:
     47        (WI.URLBreakpoint.deserialize): Added.
     48        (WI.URLBreakpoint.prototype.set disabled):
     49        * UserInterface/Views/DOMTreeContentView.js:
     50        (WI.DOMTreeContentView):
     51        (WI.DOMTreeContentView.prototype._handleDOMBreakpointDisabledStateChanged): Added.
     52        (WI.DOMTreeContentView.prototype._handleDOMBreakpointDOMNodeChanged): Added.
     53        * UserInterface/Views/DebuggerSidebarPanel.js:
     54        (WI.DebuggerSidebarPanel.prototype._handleDOMBreakpointResolvedStateChanged): Added.
     55        * UserInterface/Views/SourcesNavigationSidebarPanel.js:
     56        (WI.SourcesNavigationSidebarPanel):
     57        (WI.SourcesNavigationSidebarPanel.prototype._handleDOMBreakpointResolvedStateChanged): Added.
     58        Drive-by: rename all events with the name `*DidChange` to `*Changed`.
     59        Drive-by: create static `deserialize` helper functions.
     60
    1612019-03-02  Devin Rousso  <drousso@apple.com>
    262

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

    r239703 r242318  
    4141        this._allRequestsBreakpointEnabledSetting = new WI.Setting("break-on-all-requests", false);
    4242
    43         this._allRequestsBreakpoint = new WI.URLBreakpoint(null, null, !this._allRequestsBreakpointEnabledSetting.value);
    44 
    45         WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DisabledStateDidChange, this._domBreakpointDisabledStateDidChange, this);
    46         WI.EventBreakpoint.addEventListener(WI.EventBreakpoint.Event.DisabledStateDidChange, this._eventBreakpointDisabledStateDidChange, this);
    47         WI.URLBreakpoint.addEventListener(WI.URLBreakpoint.Event.DisabledStateDidChange, this._urlBreakpointDisabledStateDidChange, this);
     43        this._allRequestsBreakpoint = new WI.URLBreakpoint(WI.URLBreakpoint.Type.Text, "", {
     44            disabled: !this._allRequestsBreakpointEnabledSetting.value,
     45        });
     46
     47        WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DisabledStateChanged, this._handleDOMBreakpointDisabledStateChanged, this);
     48        WI.EventBreakpoint.addEventListener(WI.EventBreakpoint.Event.DisabledStateChanged, this._handleEventBreakpointDisabledStateChanged, this);
     49        WI.URLBreakpoint.addEventListener(WI.URLBreakpoint.Event.DisabledStateChanged, this._handleURLBreakpointDisabledStateChanged, this);
    4850
    4951        WI.domManager.addEventListener(WI.DOMManager.Event.NodeRemoved, this._nodeRemoved, this);
    … …  
    5860            this._restoringBreakpoints = true;
    5961
    60             for (let cookie of this._domBreakpointsSetting.value) {
    61                 let breakpoint = new WI.DOMBreakpoint(cookie, cookie.type, cookie.disabled);
    62                 this.addDOMBreakpoint(breakpoint);
    63             }
    64 
    65             for (let payload of this._eventBreakpointSetting.value)
    66                 this.addEventBreakpoint(WI.EventBreakpoint.fromPayload(payload));
    67 
    68             for (let cookie of this._urlBreakpointsSetting.value) {
    69                 let breakpoint = new WI.URLBreakpoint(cookie.type, cookie.url, cookie.disabled);
    70                 this.addURLBreakpoint(breakpoint);
    71             }
     62            for (let serializedInfo of this._domBreakpointsSetting.value)
     63                this.addDOMBreakpoint(WI.DOMBreakpoint.deserialize(serializedInfo));
     64
     65            for (let serializedInfo of this._eventBreakpointSetting.value)
     66                this.addEventBreakpoint(WI.EventBreakpoint.deserialize(serializedInfo));
     67
     68            for (let serializedInfo of this._urlBreakpointsSetting.value)
     69                this.addURLBreakpoint(WI.URLBreakpoint.deserialize(serializedInfo));
    7270
    7371            this._restoringBreakpoints = false;
    … …  
    467465    }
    468466
    469     _updateEventBreakpoint(breakpoint, callback)
    470     {
    471         function breakpointUpdated(error)
    472         {
    473             if (error)
    474                 console.error(error);
    475 
    476             if (callback)
    477                 callback(error);
    478         }
    479 
     467    _updateEventBreakpoint(breakpoint)
     468    {
    480469        // Compatibility (iOS 12): DOMDebuggerAgent.removeEventBreakpoint did not exist.
    481470        if (!WI.DOMDebuggerManager.supportsEventBreakpoints()) {
    482471            console.assert(breakpoint.type === WI.EventBreakpoint.Type.Listener);
    483472            if (breakpoint.disabled)
    484                 DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName, breakpointUpdated);
     473                DOMDebuggerAgent.removeEventListenerBreakpoint(breakpoint.eventName);
    485474            else
    486                 DOMDebuggerAgent.setEventListenerBreakpoint(breakpoint.eventName, breakpointUpdated);
     475                DOMDebuggerAgent.setEventListenerBreakpoint(breakpoint.eventName);
    487476            return;
    488477        }
    489478
    490479        if (breakpoint.disabled)
    491             DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName, breakpointUpdated);
     480            DOMDebuggerAgent.removeEventBreakpoint(breakpoint.type, breakpoint.eventName);
    492481        else
    493             DOMDebuggerAgent.setEventBreakpoint(breakpoint.type, breakpoint.eventName, breakpointUpdated);
    494     }
    495 
    496     _updateURLBreakpoint(breakpoint, callback)
    497     {
    498         function breakpointUpdated(error)
    499         {
    500             if (error)
    501                 console.error(error);
    502 
    503             if (callback && typeof callback === "function")
    504                 callback(error);
    505         }
    506 
     482            DOMDebuggerAgent.setEventBreakpoint(breakpoint.type, breakpoint.eventName);
     483    }
     484
     485    _updateURLBreakpoint(breakpoint)
     486    {
    507487        // Compatibility (iOS 12.1): DOMDebuggerAgent.removeURLBreakpoint did not exist.
    508488        if (!WI.DOMDebuggerManager.supportsURLBreakpoints()) {
    509489            if (breakpoint.disabled)
    510                 DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url, breakpointUpdated);
     490                DOMDebuggerAgent.removeXHRBreakpoint(breakpoint.url);
    511491            else {
    512492                let isRegex = breakpoint.type === WI.URLBreakpoint.Type.RegularExpression;
    513                 DebuggerAgent.setXHRBreakpoint(breakpoint.url, isRegex, breakpointUpdated);
     493                DebuggerAgent.setXHRBreakpoint(breakpoint.url, isRegex);
    514494            }
    515495            return;
    … …  
    517497
    518498        if (breakpoint.disabled)
    519             DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url, breakpointUpdated);
     499            DOMDebuggerAgent.removeURLBreakpoint(breakpoint.url);
    520500        else {
    521501            let isRegex = breakpoint.type === WI.URLBreakpoint.Type.RegularExpression;
    522             DOMDebuggerAgent.setURLBreakpoint(breakpoint.url, isRegex, breakpointUpdated);
     502            DOMDebuggerAgent.setURLBreakpoint(breakpoint.url, isRegex);
    523503        }
    524504    }
    … …  
    529509            return;
    530510
    531         this._updateEventBreakpoint(breakpoint, () => {
    532             breakpoint.dispatchEventToListeners(WI.EventBreakpoint.Event.ResolvedStateDidChange);
    533         });
     511        this._updateEventBreakpoint(breakpoint);
    534512    }
    535513
    … …  
    539517            return;
    540518
    541         this._updateURLBreakpoint(breakpoint, () => {
    542             breakpoint.dispatchEventToListeners(WI.URLBreakpoint.Event.ResolvedStateDidChange);
    543         });
     519        this._updateURLBreakpoint(breakpoint);
    544520    }
    545521
    … …  
    572548    }
    573549
    574     _domBreakpointDisabledStateDidChange(event)
     550    _handleDOMBreakpointDisabledStateChanged(event)
    575551    {
    576552        let breakpoint = event.target;
    … …  
    579555    }
    580556
    581     _eventBreakpointDisabledStateDidChange(event)
     557    _handleEventBreakpointDisabledStateChanged(event)
    582558    {
    583559        let breakpoint = event.target;
    … …  
    586562    }
    587563
    588     _urlBreakpointDisabledStateDidChange(event)
     564    _handleURLBreakpointDisabledStateChanged(event)
    589565    {
    590566        let breakpoint = event.target;

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

    r236766 r242318  
    2626WI.DOMBreakpoint = class DOMBreakpoint extends WI.Object
    2727{
    28     constructor(domNodeOrInfo, type, disabled)
     28    constructor(domNodeOrInfo, type, {disabled} = {})
    2929    {
    30         console.assert(domNodeOrInfo, "Missing DOMNode or info.");
     30        console.assert(domNodeOrInfo instanceof WI.DOMNode || typeof domNodeOrInfo === "object", domNodeOrInfo);
     31        console.assert(Object.values(WI.DOMBreakpoint.Type).includes(type), type);
    3132
    3233        super();
    … …  
    4546        this._type = type;
    4647        this._disabled = disabled || false;
     48    }
     49
     50    // Static
     51
     52    static deserialize(serializedInfo)
     53    {
     54        return new WI.DOMBreakpoint(serializedInfo, serializedInfo.type, {
     55            disabled: !!serializedInfo.disabled,
     56        });
    4757    }
    4858
    … …  
    6575        this._disabled = disabled;
    6676
    67         this.dispatchEventToListeners(WI.DOMBreakpoint.Event.DisabledStateDidChange);
     77        this.dispatchEventToListeners(WI.DOMBreakpoint.Event.DisabledStateChanged);
    6878    }
    6979
    … …  
    8494        this._domNodeIdentifier = nodeIdentifier;
    8595
    86         this.dispatchEventToListeners(WI.DOMBreakpoint.Event.ResolvedStateDidChange, data);
     96        this.dispatchEventToListeners(WI.DOMBreakpoint.Event.DOMNodeChanged, data);
    8797    }
    8898
    … …  
    115125
    116126WI.DOMBreakpoint.Event = {
    117     DisabledStateDidChange: "dom-breakpoint-disabled-state-did-change",
    118     ResolvedStateDidChange: "dom-breakpoint-resolved-state-did-change",
     127    DOMNodeChanged: "dom-breakpoint-dom-node-changed",
     128    DisabledStateChanged: "dom-breakpoint-disabled-state-changed",
    119129};

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

    r235248 r242318  
    2626WI.EventBreakpoint = class EventBreakpoint extends WI.Object
    2727{
    28     constructor(type, eventName, {disabled, eventListener} = {})
     28    constructor(type, eventName, {eventListener, disabled} = {})
    2929    {
    3030        super();
    3131
    32         console.assert(typeof type === "string");
    33         console.assert(Object.values(WI.EventBreakpoint.Type).includes(type));
    34         console.assert(typeof eventName === "string");
     32        console.assert(Object.values(WI.EventBreakpoint.Type).includes(type), type);
     33        console.assert(typeof eventName === "string", eventName);
    3534
    3635        this._type = type;
    3736        this._eventName = eventName;
    38 
     37        this._eventListener = eventListener || null;
    3938        this._disabled = disabled || false;
    40         this._eventListener = eventListener || null;
    4139    }
    4240
    4341    // Static
    4442
    45     static fromPayload(payload)
     43    static deserialize(serializedInfo)
    4644    {
    47         return new WI.EventBreakpoint(payload.type, payload.eventName, {
    48             disabled: !!payload.disabled,
     45        return new WI.EventBreakpoint(serializedInfo.type, serializedInfo.eventName, {
     46            disabled: !!serializedInfo.disabled,
    4947        });
    5048    }
    … …  
    6866        this._disabled = disabled;
    6967
    70         this.dispatchEventToListeners(WI.EventBreakpoint.Event.DisabledStateDidChange);
     68        this.dispatchEventToListeners(WI.EventBreakpoint.Event.DisabledStateChanged);
    7169    }
    7270
    … …  
    10098
    10199WI.EventBreakpoint.Event = {
    102     DisabledStateDidChange: "event-breakpoint-disabled-state-did-change",
    103     ResolvedStateDidChange: "event-breakpoint-resolved-state-did-change",
     100    DisabledStateChanged: "event-breakpoint-disabled-state-changed",
    104101};

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

    r239703 r242318  
    2626WI.URLBreakpoint = class URLBreakpoint extends WI.Object
    2727{
    28     constructor(type, url, disabled)
     28    constructor(type, url, {disabled} = {})
    2929    {
     30        console.assert(Object.values(WI.URLBreakpoint.Type).includes(type), type);
     31        console.assert(typeof url === "string", url);
     32
    3033        super();
    3134
    32         this._type = type || WI.URLBreakpoint.Type.Text;
    33         this._url = url || "";
     35        this._type = type;
     36        this._url = url;
    3437        this._disabled = disabled || false;
     38    }
     39
     40    // Static
     41
     42    static deserialize(serializedInfo)
     43    {
     44        return new WI.URLBreakpoint(serializedInfo.type, serializedInfo.url, {
     45            disabled: !!serializedInfo.disabled,
     46        });
    3547    }
    3648
    … …  
    5264        this._disabled = disabled;
    5365
    54         this.dispatchEventToListeners(WI.URLBreakpoint.Event.DisabledStateDidChange);
     66        this.dispatchEventToListeners(WI.URLBreakpoint.Event.DisabledStateChanged);
    5567    }
    5668
    … …  
    7183
    7284WI.URLBreakpoint.Event = {
    73     DisabledStateDidChange: "url-breakpoint-disabled-state-did-change",
    74     ResolvedStateDidChange: "url-breakpoint-resolved-state-did-change",
     85    DisabledStateChanged: "url-breakpoint-disabled-state-changed",
    7586};
    7687

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

    r242118 r242318  
    4040
    4141        this.status = WI.ImageUtilities.useSVGSymbol("Images/Breakpoint.svg");
    42         this.status.classList.add("status-image", "resolved");
     42        this.status.className = WI.BreakpointTreeElement.StatusImageElementStyleClassName;
    4343
    4444        this.tooltipHandledSeparately = true;
    45 
    46         breakpoint.addEventListener(WI.DOMBreakpoint.Event.DisabledStateDidChange, this._updateStatus, this);
    47 
    48         this._updateStatus();
    4945    }
    5046
    … …  
    7268        super.onattach();
    7369
     70        this.representedObject.addEventListener(WI.DOMBreakpoint.Event.DisabledStateChanged, this._updateStatus, this);
     71        WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointsEnabledDidChange, this._updateStatus, this);
     72
    7473        this._boundStatusImageElementClicked = this._statusImageElementClicked.bind(this);
    7574        this._boundStatusImageElementFocused = this._statusImageElementFocused.bind(this);
    … …  
    7978        this.status.addEventListener("focus", this._boundStatusImageElementFocused);
    8079        this.status.addEventListener("mousedown", this._boundStatusImageElementMouseDown);
     80
     81        this._updateStatus();
    8182    }
    8283
    … …  
    8485    {
    8586        super.ondetach();
     87
     88        this.representedObject.removeEventListener(null, null, this);
     89        WI.debuggerManager.removeEventListener(null, null, this);
    8690
    8791        this.status.removeEventListener("click", this._boundStatusImageElementClicked);
    … …  
    155159    _updateStatus()
    156160    {
    157         this.status.classList.toggle("disabled", this.representedObject.disabled);
     161        if (!this.status)
     162            return;
     163
     164        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageDisabledStyleClassName, this.representedObject.disabled);
     165        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageResolvedStyleClassName, WI.debuggerManager.breakpointsEnabled);
    158166    }
    159167};

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

    r242174 r242318  
    9696            WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, this._domBreakpointAddedOrRemoved, this);
    9797
    98             WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DisabledStateDidChange, this._domBreakpointDisabledStateDidChange, this);
    99             WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.ResolvedStateDidChange, this._domBreakpointResolvedStateDidChange, this);
     98            WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DisabledStateChanged, this._handleDOMBreakpointDisabledStateChanged, this);
     99            WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DOMNodeChanged, this._handleDOMBreakpointDOMNodeChanged, this);
    100100
    101101            this._breakpointsEnabledDidChange();
    … …  
    746746    }
    747747
    748     _domBreakpointDisabledStateDidChange(event)
     748    _handleDOMBreakpointDisabledStateChanged(event)
    749749    {
    750750        let breakpoint = event.target;
    … …  
    752752    }
    753753
    754     _domBreakpointResolvedStateDidChange(event)
     754    _handleDOMBreakpointDOMNodeChanged(event)
    755755    {
    756756        let breakpoint = event.target;

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

    r242315 r242318  
    5454        WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.WaitingToPause, this._debuggerWaitingToPause, this);
    5555
    56         WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.ResolvedStateDidChange, this._domBreakpointResolvedStateDidChange, this);
     56        WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DOMNodeChanged, this._handleDOMBreakpointDOMNodeChanged, this);
    5757
    5858        WI.timelineManager.addEventListener(WI.TimelineManager.Event.CapturingWillStart, this._timelineCapturingWillStart, this);
    … …  
    13691369    }
    13701370
    1371     _domBreakpointResolvedStateDidChange(event)
     1371    _handleDOMBreakpointDOMNodeChanged(event)
    13721372    {
    13731373        let breakpoint = event.target;

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

    r242161 r242318  
    4141
    4242        this.status = WI.ImageUtilities.useSVGSymbol("Images/Breakpoint.svg");
    43         this.status.classList.add("status-image", "resolved");
     43        this.status.className = WI.BreakpointTreeElement.StatusImageElementStyleClassName;
    4444
    4545        this.tooltipHandledSeparately = true;
    46 
    47         breakpoint.addEventListener(WI.EventBreakpoint.Event.DisabledStateDidChange, this._updateStatus, this);
    48 
    49         this._updateStatus();
    5046    }
    5147
    … …  
    5652        super.onattach();
    5753
     54        this.representedObject.addEventListener(WI.EventBreakpoint.Event.DisabledStateChanged, this._updateStatus, this);
     55        WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointsEnabledDidChange, this._updateStatus, this);
     56
    5857        this._boundStatusImageElementClicked = this._statusImageElementClicked.bind(this);
    5958        this._boundStatusImageElementFocused = this._statusImageElementFocused.bind(this);
    … …  
    6362        this.status.addEventListener("focus", this._boundStatusImageElementFocused);
    6463        this.status.addEventListener("mousedown", this._boundStatusImageElementMouseDown);
     64
     65        this._updateStatus();
    6566    }
    6667
    … …  
    6869    {
    6970        super.ondetach();
     71
     72        this.representedObject.removeEventListener(null, null, this);
     73        WI.debuggerManager.removeEventListener(null, null, this);
    7074
    7175        this.status.removeEventListener("click", this._boundStatusImageElementClicked);
    … …  
    153157    _updateStatus()
    154158    {
    155         this.status.classList.toggle("disabled", this.representedObject.disabled);
     159        if (!this.status)
     160            return;
     161
     162        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageDisabledStyleClassName, this.representedObject.disabled);
     163        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageResolvedStyleClassName, WI.debuggerManager.breakpointsEnabled);
    156164    }
    157165};

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

    r242315 r242318  
    250250        WI.IssueMessage.addEventListener(WI.IssueMessage.Event.DisplayLocationDidChange, this._handleDebuggerObjectDisplayLocationDidChange, this);
    251251
    252         WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.ResolvedStateDidChange, this._handleDOMBreakpointResolvedStateDidChange, this);
     252        WI.DOMBreakpoint.addEventListener(WI.DOMBreakpoint.Event.DOMNodeChanged, this._handleDOMBreakpointDOMNodeChanged, this);
    253253
    254254        WI.consoleManager.addEventListener(WI.ConsoleManager.Event.IssueAdded, this._handleConsoleIssueAdded, this);
    … …  
    15861586    }
    15871587
    1588     _handleDOMBreakpointResolvedStateDidChange(event)
     1588    _handleDOMBreakpointDOMNodeChanged(event)
    15891589    {
    15901590        let breakpoint = event.target;

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

    r242118 r242318  
    4545
    4646        this.status = WI.ImageUtilities.useSVGSymbol("Images/Breakpoint.svg");
    47         this.status.classList.add("status-image", "resolved");
     47        this.status.className = WI.BreakpointTreeElement.StatusImageElementStyleClassName;
    4848
    4949        this.tooltipHandledSeparately = true;
    50 
    51         breakpoint.addEventListener(WI.URLBreakpoint.Event.DisabledStateDidChange, this._updateStatus, this);
    52 
    53         this._updateStatus();
    5450    }
    5551
    … …  
    6056        super.onattach();
    6157
     58        this.representedObject.addEventListener(WI.URLBreakpoint.Event.DisabledStateChanged, this._updateStatus, this);
     59        WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.BreakpointsEnabledDidChange, this._updateStatus, this);
     60
    6261        this._boundStatusImageElementClicked = this._statusImageElementClicked.bind(this);
    6362        this._boundStatusImageElementFocused = this._statusImageElementFocused.bind(this);
    … …  
    6766        this.status.addEventListener("focus", this._boundStatusImageElementFocused);
    6867        this.status.addEventListener("mousedown", this._boundStatusImageElementMouseDown);
     68
     69        this._updateStatus();
    6970    }
    7071
    … …  
    7273    {
    7374        super.ondetach();
     75
     76        this.representedObject.removeEventListener(null, null, this);
     77        WI.debuggerManager.removeEventListener(null, null, this);
    7478
    7579        this.status.removeEventListener("click", this._boundStatusImageElementClicked);
    … …  
    144148    _updateStatus()
    145149    {
    146         this.status.classList.toggle("disabled", this.representedObject.disabled);
     150        if (!this.status)
     151            return;
     152
     153        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageDisabledStyleClassName, this.representedObject.disabled);
     154        this.status.classList.toggle(WI.BreakpointTreeElement.StatusImageResolvedStyleClassName, WI.debuggerManager.breakpointsEnabled);
    147155    }
    148156};
Note: See TracChangeset for help on using the changeset viewer.