Changeset 207371 in webkit


Ignore:
Timestamp:
Oct 15, 2016 12:22:03 AM (8 years ago)
Author:
Joseph Pecoraro
Message:

Web Inspector: Cleanup parts of DebuggerManager
​https://bugs.webkit.org/show_bug.cgi?id=163400

Reviewed by Timothy Hatcher.

  • UserInterface/Controllers/DebuggerManager.js:

(WebInspector.DebuggerManager.restoreBreakpointsSoon):

(WebInspector.DebuggerManager.prototype.get paused):
(WebInspector.DebuggerManager.prototype.get pauseReason):
(WebInspector.DebuggerManager.prototype.get pauseData):
(WebInspector.DebuggerManager.prototype.get callFrames):
(WebInspector.DebuggerManager.prototype.get activeCallFrame):
(WebInspector.DebuggerManager.prototype.set activeCallFrame):
Put simple accessors at the top.

(WebInspector.DebuggerManager.prototype.get allExceptionsBreakpoint):
(WebInspector.DebuggerManager.prototype.get allUncaughtExceptionsBreakpoint):
(WebInspector.DebuggerManager.prototype.get breakpoints):
(WebInspector.DebuggerManager.prototype.breakpointForIdentifier):
(WebInspector.DebuggerManager.prototype.breakpointsForSourceCode):
(WebInspector.DebuggerManager.prototype.isBreakpointRemovable):
(WebInspector.DebuggerManager.prototype.isBreakpointEditable):
(WebInspector.DebuggerManager.prototype.get breakpointsDisabledTemporarily):
Group public breakpoint state and access methods.

(WebInspector.DebuggerManager.prototype.scriptForIdentifier):
(WebInspector.DebuggerManager.prototype.scriptsForURL):
(WebInspector.DebuggerManager.prototype.get searchableScripts):
(WebInspector.DebuggerManager.prototype.get knownNonResourceScripts):
Group public script access methods.

(WebInspector.DebuggerManager.prototype.pause):
(WebInspector.DebuggerManager.prototype.resume):
(WebInspector.DebuggerManager.prototype.stepOver):
(WebInspector.DebuggerManager.prototype.stepInto):
(WebInspector.DebuggerManager.prototype.stepOut):
(WebInspector.DebuggerManager.prototype.continueToLocation):
(WebInspector.DebuggerManager.prototype.addBreakpoint):
(WebInspector.DebuggerManager.prototype.removeBreakpoint):
Group and modernize public methods that perform actions.

(WebInspector.DebuggerManager.prototype.nextBreakpointActionIdentifier):
Misc. methods.

(WebInspector.DebuggerManager.prototype.breakpointResolved):
(WebInspector.DebuggerManager.prototype.reset):
(WebInspector.DebuggerManager.prototype.playBreakpointActionSound):
(WebInspector.DebuggerManager.prototype.scriptDidParse):
(WebInspector.DebuggerManager.prototype._setBreakpoint.didSetBreakpoint):
(WebInspector.DebuggerManager.prototype._setBreakpoint):
(WebInspector.DebuggerManager.prototype._breakpointEditablePropertyDidChange):
(WebInspector.DebuggerManager.prototype._updateBreakOnExceptionsState):
(WebInspector.DebuggerManager.prototype._associateBreakpointsWithSourceCode):
Minor cleanup in protected and private methods.

  • UserInterface/Models/BreakpointAction.js:

(WebInspector.BreakpointAction):
Getting the next identifier is an action so it should be a function call.

  • UserInterface/Views/SourceCodeTextEditor.js:

(WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointAdded):
Remove unused parameter.

Location:
trunk/Source/WebInspectorUI
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebInspectorUI/ChangeLog

    r207359 r207371  
     12016-10-15  Joseph Pecoraro  <pecoraro@apple.com>
     2
     3        Web Inspector: Cleanup parts of DebuggerManager
     4        https://bugs.webkit.org/show_bug.cgi?id=163400
     5
     6        Reviewed by Timothy Hatcher.
     7
     8        * UserInterface/Controllers/DebuggerManager.js:
     9        (WebInspector.DebuggerManager.restoreBreakpointsSoon):
     10
     11        (WebInspector.DebuggerManager.prototype.get paused):
     12        (WebInspector.DebuggerManager.prototype.get pauseReason):
     13        (WebInspector.DebuggerManager.prototype.get pauseData):
     14        (WebInspector.DebuggerManager.prototype.get callFrames):
     15        (WebInspector.DebuggerManager.prototype.get activeCallFrame):
     16        (WebInspector.DebuggerManager.prototype.set activeCallFrame):
     17        Put simple accessors at the top.
     18
     19        (WebInspector.DebuggerManager.prototype.get allExceptionsBreakpoint):
     20        (WebInspector.DebuggerManager.prototype.get allUncaughtExceptionsBreakpoint):
     21        (WebInspector.DebuggerManager.prototype.get breakpoints):
     22        (WebInspector.DebuggerManager.prototype.breakpointForIdentifier):
     23        (WebInspector.DebuggerManager.prototype.breakpointsForSourceCode):
     24        (WebInspector.DebuggerManager.prototype.isBreakpointRemovable):
     25        (WebInspector.DebuggerManager.prototype.isBreakpointEditable):
     26        (WebInspector.DebuggerManager.prototype.get breakpointsDisabledTemporarily):
     27        Group public breakpoint state and access methods.
     28
     29        (WebInspector.DebuggerManager.prototype.scriptForIdentifier):
     30        (WebInspector.DebuggerManager.prototype.scriptsForURL):
     31        (WebInspector.DebuggerManager.prototype.get searchableScripts):
     32        (WebInspector.DebuggerManager.prototype.get knownNonResourceScripts):
     33        Group public script access methods.
     34
     35        (WebInspector.DebuggerManager.prototype.pause):
     36        (WebInspector.DebuggerManager.prototype.resume):
     37        (WebInspector.DebuggerManager.prototype.stepOver):
     38        (WebInspector.DebuggerManager.prototype.stepInto):
     39        (WebInspector.DebuggerManager.prototype.stepOut):
     40        (WebInspector.DebuggerManager.prototype.continueToLocation):
     41        (WebInspector.DebuggerManager.prototype.addBreakpoint):
     42        (WebInspector.DebuggerManager.prototype.removeBreakpoint):
     43        Group and modernize public methods that perform actions.
     44
     45        (WebInspector.DebuggerManager.prototype.nextBreakpointActionIdentifier):
     46        Misc. methods.
     47
     48        (WebInspector.DebuggerManager.prototype.breakpointResolved):
     49        (WebInspector.DebuggerManager.prototype.reset):
     50        (WebInspector.DebuggerManager.prototype.playBreakpointActionSound):
     51        (WebInspector.DebuggerManager.prototype.scriptDidParse):
     52        (WebInspector.DebuggerManager.prototype._setBreakpoint.didSetBreakpoint):
     53        (WebInspector.DebuggerManager.prototype._setBreakpoint):
     54        (WebInspector.DebuggerManager.prototype._breakpointEditablePropertyDidChange):
     55        (WebInspector.DebuggerManager.prototype._updateBreakOnExceptionsState):
     56        (WebInspector.DebuggerManager.prototype._associateBreakpointsWithSourceCode):
     57        Minor cleanup in protected and private methods.
     58
     59        * UserInterface/Models/BreakpointAction.js:
     60        (WebInspector.BreakpointAction):
     61        Getting the next identifier is an action so it should be a function call.
     62
     63        * UserInterface/Views/SourceCodeTextEditor.js:
     64        (WebInspector.SourceCodeTextEditor.prototype.textEditorBreakpointAdded):
     65        Remove unused parameter.
     66
    1672016-10-14  Joseph Pecoraro  <pecoraro@apple.com>
    268

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

    r205424 r207371  
    11/*
    2  * Copyright (C) 2013, 2014, 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2013-2016 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    4949        this._allUncaughtExceptionsBreakpointEnabledSetting = new WebInspector.Setting("break-on-all-uncaught-exceptions", false);
    5050
    51         var specialBreakpointLocation = new WebInspector.SourceCodeLocation(null, Infinity, Infinity);
     51        let specialBreakpointLocation = new WebInspector.SourceCodeLocation(null, Infinity, Infinity);
    5252
    5353        this._allExceptionsBreakpoint = new WebInspector.Breakpoint(specialBreakpointLocation, !this._allExceptionsBreakpointEnabledSetting.value);
    … …  
    8686        this._updateBreakOnExceptionsState();
    8787
     88        this._ignoreBreakpointDisplayLocationDidChangeEvent = false;
     89
    8890        function restoreBreakpointsSoon() {
    8991            this._restoringBreakpoints = true;
    90             for (var cookie of this._breakpointsSetting.value)
     92            for (let cookie of this._breakpointsSetting.value)
    9193                this.addBreakpoint(new WebInspector.Breakpoint(cookie));
    9294            this._restoringBreakpoints = false;
    … …  
    100102    // Public
    101103
    102     get breakpointsEnabled()
    103     {
    104         return this._breakpointsEnabledSetting.value;
    105     }
    106 
    107     set breakpointsEnabled(enabled)
    108     {
    109         if (this._breakpointsEnabledSetting.value === enabled)
    110             return;
    111 
    112         console.assert(!(enabled && this.breakpointsDisabledTemporarily), "Should not enable breakpoints when we are temporarily disabling breakpoints.");
    113         if (enabled && this.breakpointsDisabledTemporarily)
    114             return;
    115 
    116         this._breakpointsEnabledSetting.value = enabled;
    117 
    118         this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.BreakpointsEnabledDidChange);
    119 
    120         DebuggerAgent.setBreakpointsActive(enabled);
    121 
    122         this._updateBreakOnExceptionsState();
    123     }
    124 
    125104    get paused()
    126105    {
    … …  
    158137    }
    159138
    160     pause()
    161     {
    162         if (this._paused)
    163             return Promise.resolve();
    164 
    165         this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.WaitingToPause);
    166 
    167         var listener = new WebInspector.EventListener(this, true);
    168 
    169         var managerResult = new Promise(function(resolve, reject) {
    170             listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.Paused, resolve);
    171         });
    172 
    173         var protocolResult = DebuggerAgent.pause()
    174             .catch(function(error) {
    175                 listener.disconnect();
    176                 console.error("DebuggerManager.pause failed: ", error);
    177                 throw error;
    178             });
    179 
    180         return Promise.all([managerResult, protocolResult]);
    181     }
    182 
    183     resume()
    184     {
    185         if (!this._paused)
    186             return Promise.resolve();
    187 
    188         var listener = new WebInspector.EventListener(this, true);
    189 
    190         var managerResult = new Promise(function(resolve, reject) {
    191             listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.Resumed, resolve);
    192         });
    193 
    194         var protocolResult = DebuggerAgent.resume()
    195             .catch(function(error) {
    196                 listener.disconnect();
    197                 console.error("DebuggerManager.resume failed: ", error);
    198                 throw error;
    199             });
    200 
    201         return Promise.all([managerResult, protocolResult]);
    202     }
    203 
    204     stepOver()
    205     {
    206         if (!this._paused)
    207             return Promise.reject(new Error("Cannot step over because debugger is not paused."));
    208 
    209         var listener = new WebInspector.EventListener(this, true);
    210 
    211         var managerResult = new Promise(function(resolve, reject) {
    212             listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
    213         });
    214 
    215         var protocolResult = DebuggerAgent.stepOver()
    216             .catch(function(error) {
    217                 listener.disconnect();
    218                 console.error("DebuggerManager.stepOver failed: ", error);
    219                 throw error;
    220             });
    221 
    222         return Promise.all([managerResult, protocolResult]);
    223     }
    224 
    225     stepInto()
    226     {
    227         if (!this._paused)
    228             return Promise.reject(new Error("Cannot step into because debugger is not paused."));
    229 
    230         var listener = new WebInspector.EventListener(this, true);
    231 
    232         var managerResult = new Promise(function(resolve, reject) {
    233             listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
    234         });
    235 
    236         var protocolResult = DebuggerAgent.stepInto()
    237             .catch(function(error) {
    238                 listener.disconnect();
    239                 console.error("DebuggerManager.stepInto failed: ", error);
    240                 throw error;
    241             });
    242 
    243         return Promise.all([managerResult, protocolResult]);
    244     }
    245 
    246     stepOut()
    247     {
    248         if (!this._paused)
    249             return Promise.reject(new Error("Cannot step out because debugger is not paused."));
    250 
    251         var listener = new WebInspector.EventListener(this, true);
    252 
    253         var managerResult = new Promise(function(resolve, reject) {
    254             listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
    255         });
    256 
    257         var protocolResult = DebuggerAgent.stepOut()
    258             .catch(function(error) {
    259                 listener.disconnect();
    260                 console.error("DebuggerManager.stepOut failed: ", error);
    261                 throw error;
    262             });
    263 
    264         return Promise.all([managerResult, protocolResult]);
    265     }
    266 
    267139    get allExceptionsBreakpoint()
    268140    {
    … …  
    280152    }
    281153
     154    breakpointForIdentifier(id)
     155    {
     156        return this._breakpointIdMap.get(id) || null;
     157    }
     158
    282159    breakpointsForSourceCode(sourceCode)
    283160    {
    … …  
    285162
    286163        if (sourceCode instanceof WebInspector.SourceMapResource) {
    287             var originalSourceCodeBreakpoints = this.breakpointsForSourceCode(sourceCode.sourceMap.originalSourceCode);
     164            let originalSourceCodeBreakpoints = this.breakpointsForSourceCode(sourceCode.sourceMap.originalSourceCode);
    288165            return originalSourceCodeBreakpoints.filter(function(breakpoint) {
    289166                return breakpoint.sourceCodeLocation.displaySourceCode === sourceCode;
    … …  
    308185    }
    309186
    310     breakpointForIdentifier(id)
    311     {
    312         return this._breakpointIdMap.get(id) || null;
     187    isBreakpointRemovable(breakpoint)
     188    {
     189        return breakpoint !== this._allExceptionsBreakpoint && breakpoint !== this._allUncaughtExceptionsBreakpoint;
     190    }
     191
     192    isBreakpointEditable(breakpoint)
     193    {
     194        return this.isBreakpointRemovable(breakpoint);
     195    }
     196
     197    get breakpointsEnabled()
     198    {
     199        return this._breakpointsEnabledSetting.value;
     200    }
     201
     202    set breakpointsEnabled(enabled)
     203    {
     204        if (this._breakpointsEnabledSetting.value === enabled)
     205            return;
     206
     207        console.assert(!(enabled && this.breakpointsDisabledTemporarily), "Should not enable breakpoints when we are temporarily disabling breakpoints.");
     208        if (enabled && this.breakpointsDisabledTemporarily)
     209            return;
     210
     211        this._breakpointsEnabledSetting.value = enabled;
     212
     213        this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.BreakpointsEnabledDidChange);
     214
     215        DebuggerAgent.setBreakpointsActive(enabled);
     216
     217        this._updateBreakOnExceptionsState();
     218    }
     219
     220    get breakpointsDisabledTemporarily()
     221    {
     222        return this._temporarilyDisabledBreakpointsRestoreSetting.value !== null;
    313223    }
    314224
    … …  
    322232        // FIXME: This may not be safe. A Resource's URL may differ from a Script's URL.
    323233        return this._scriptContentIdentifierMap.get(url) || [];
    324     }
    325 
    326     continueToLocation(scriptIdentifier, lineNumber, columnNumber)
    327     {
    328         DebuggerAgent.continueToLocation({scriptId: scriptIdentifier, lineNumber, columnNumber});
    329234    }
    330235
    … …  
    348253    }
    349254
    350     addBreakpoint(breakpoint, skipEventDispatch, shouldSpeculativelyResolve)
    351     {
    352         console.assert(breakpoint instanceof WebInspector.Breakpoint, "Bad argument to DebuggerManger.addBreakpoint: ", breakpoint);
     255    pause()
     256    {
     257        if (this._paused)
     258            return Promise.resolve();
     259
     260        this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.WaitingToPause);
     261
     262        let listener = new WebInspector.EventListener(this, true);
     263
     264        let managerResult = new Promise(function(resolve, reject) {
     265            listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.Paused, resolve);
     266        });
     267
     268        let protocolResult = DebuggerAgent.pause()
     269            .catch(function(error) {
     270                listener.disconnect();
     271                console.error("DebuggerManager.pause failed: ", error);
     272                throw error;
     273            });
     274
     275        return Promise.all([managerResult, protocolResult]);
     276    }
     277
     278    resume()
     279    {
     280        if (!this._paused)
     281            return Promise.resolve();
     282
     283        let listener = new WebInspector.EventListener(this, true);
     284
     285        let managerResult = new Promise(function(resolve, reject) {
     286            listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.Resumed, resolve);
     287        });
     288
     289        let protocolResult = DebuggerAgent.resume()
     290            .catch(function(error) {
     291                listener.disconnect();
     292                console.error("DebuggerManager.resume failed: ", error);
     293                throw error;
     294            });
     295
     296        return Promise.all([managerResult, protocolResult]);
     297    }
     298
     299    stepOver()
     300    {
     301        if (!this._paused)
     302            return Promise.reject(new Error("Cannot step over because debugger is not paused."));
     303
     304        let listener = new WebInspector.EventListener(this, true);
     305
     306        let managerResult = new Promise(function(resolve, reject) {
     307            listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
     308        });
     309
     310        let protocolResult = DebuggerAgent.stepOver()
     311            .catch(function(error) {
     312                listener.disconnect();
     313                console.error("DebuggerManager.stepOver failed: ", error);
     314                throw error;
     315            });
     316
     317        return Promise.all([managerResult, protocolResult]);
     318    }
     319
     320    stepInto()
     321    {
     322        if (!this._paused)
     323            return Promise.reject(new Error("Cannot step into because debugger is not paused."));
     324
     325        let listener = new WebInspector.EventListener(this, true);
     326
     327        let managerResult = new Promise(function(resolve, reject) {
     328            listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
     329        });
     330
     331        let protocolResult = DebuggerAgent.stepInto()
     332            .catch(function(error) {
     333                listener.disconnect();
     334                console.error("DebuggerManager.stepInto failed: ", error);
     335                throw error;
     336            });
     337
     338        return Promise.all([managerResult, protocolResult]);
     339    }
     340
     341    stepOut()
     342    {
     343        if (!this._paused)
     344            return Promise.reject(new Error("Cannot step out because debugger is not paused."));
     345
     346        let listener = new WebInspector.EventListener(this, true);
     347
     348        let managerResult = new Promise(function(resolve, reject) {
     349            listener.connect(WebInspector.debuggerManager, WebInspector.DebuggerManager.Event.ActiveCallFrameDidChange, resolve);
     350        });
     351
     352        let protocolResult = DebuggerAgent.stepOut()
     353            .catch(function(error) {
     354                listener.disconnect();
     355                console.error("DebuggerManager.stepOut failed: ", error);
     356                throw error;
     357            });
     358
     359        return Promise.all([managerResult, protocolResult]);
     360    }
     361
     362    continueToLocation(scriptId, lineNumber, columnNumber)
     363    {
     364        return DebuggerAgent.continueToLocation({scriptId, lineNumber, columnNumber});
     365    }
     366
     367    addBreakpoint(breakpoint, shouldSpeculativelyResolve)
     368    {
     369        console.assert(breakpoint instanceof WebInspector.Breakpoint);
    353370        if (!breakpoint)
    354371            return;
    … …  
    374391        this._breakpoints.push(breakpoint);
    375392
    376         function speculativelyResolveBreakpoint(breakpoint) {
    377             breakpoint.resolved = true;
    378         }
    379 
    380         if (!breakpoint.disabled)
    381             this._setBreakpoint(breakpoint, shouldSpeculativelyResolve ? speculativelyResolveBreakpoint.bind(null, breakpoint) : null);
     393        if (!breakpoint.disabled) {
     394            this._setBreakpoint(breakpoint, () => {
     395                if (shouldSpeculativelyResolve)
     396                    breakpoint.resolved = true;
     397            });
     398        }
    382399
    383400        this._saveBreakpoints();
    384401
    385         if (!skipEventDispatch)
    386             this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.BreakpointAdded, {breakpoint});
     402        this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.BreakpointAdded, {breakpoint});
    387403    }
    388404
    389405    removeBreakpoint(breakpoint)
    390406    {
    391         console.assert(breakpoint);
     407        console.assert(breakpoint instanceof WebInspector.Breakpoint);
    392408        if (!breakpoint)
    393409            return;
    … …  
    429445    }
    430446
     447    nextBreakpointActionIdentifier()
     448    {
     449        return this._nextBreakpointActionIdentifier++;
     450    }
     451
     452    // Protected (Called from WebInspector.DebuggerObserver)
     453
    431454    breakpointResolved(breakpointIdentifier, location)
    432455    {
    … …  
    441464
    442465        if (!breakpoint.sourceCodeLocation.sourceCode) {
    443             var sourceCodeLocation = this._sourceCodeLocationFromPayload(location);
     466            let sourceCodeLocation = this._sourceCodeLocationFromPayload(location);
    444467            breakpoint.sourceCodeLocation.sourceCode = sourceCodeLocation.sourceCode;
    445468        }
    … …  
    452475        // Called from WebInspector.DebuggerObserver.
    453476
    454         var wasPaused = this._paused;
     477        let wasPaused = this._paused;
    455478
    456479        WebInspector.Script.resetUniqueDisplayNameNumbers();
    … …  
    468491        // Mark all the breakpoints as unresolved. They will be reported as resolved when
    469492        // breakpointResolved is called as the page loads.
    470         for (var i = 0; i < this._breakpoints.length; ++i) {
    471             var breakpoint = this._breakpoints[i];
     493        for (let breakpoint of this._breakpoints) {
    472494            breakpoint.resolved = false;
    473495            if (breakpoint.sourceCodeLocation.sourceCode)
    … …  
    545567    playBreakpointActionSound(breakpointActionIdentifier)
    546568    {
     569        // Called from WebInspector.DebuggerObserver.
     570
    547571        InspectorFrontendHost.beep();
    548572    }
    … …  
    550574    scriptDidParse(scriptIdentifier, url, startLine, startColumn, endLine, endColumn, isContentScript, sourceURL, sourceMapURL)
    551575    {
     576        // Called from WebInspector.DebuggerObserver.
     577
    552578        // Don't add the script again if it is already known.
    553579        if (this._scriptIdMap.has(scriptIdentifier)) {
    … …  
    588614
    589615        this.dispatchEventToListeners(WebInspector.DebuggerManager.Event.ScriptAdded, {script});
    590     }
    591 
    592     isBreakpointRemovable(breakpoint)
    593     {
    594         return breakpoint !== this._allExceptionsBreakpoint && breakpoint !== this._allUncaughtExceptionsBreakpoint;
    595     }
    596 
    597     isBreakpointEditable(breakpoint)
    598     {
    599         return this.isBreakpointRemovable(breakpoint);
    600     }
    601 
    602     get nextBreakpointActionIdentifier()
    603     {
    604         return this._nextBreakpointActionIdentifier++;
    605616    }
    606617
    … …  
    730741                locations = [locations];
    731742
    732             for (var location of locations)
     743            for (let location of locations)
    733744                this.breakpointResolved(breakpointIdentifier, location);
    734745
    … …  
    802813            return;
    803814
    804         var breakpoint = event.target;
     815        let breakpoint = event.target;
    805816        if (!breakpoint.identifier || breakpoint.disabled)
    806817            return;
    … …  
    862873        function breakpointRemoved()
    863874        {
    864             // Add the breakpoint with its new condition and get a new id.
     875            // Add the breakpoint with its new properties and get a new id.
    865876            this._setBreakpoint(breakpoint);
    866877        }
    867     }
    868 
    869     get breakpointsDisabledTemporarily()
    870     {
    871         return this._temporarilyDisabledBreakpointsRestoreSetting.value !== null;
    872878    }
    873879
    … …  
    937943    _updateBreakOnExceptionsState()
    938944    {
    939         var state = "none";
     945        let state = "none";
    940946
    941947        if (this._breakpointsEnabledSetting.value) {
    … …  
    976982        this._ignoreBreakpointDisplayLocationDidChangeEvent = true;
    977983
    978         for (var i = 0; i < breakpoints.length; ++i) {
    979             var breakpoint = breakpoints[i];
    980             if (breakpoint.sourceCodeLocation.sourceCode === null)
     984        for (let breakpoint of breakpoints) {
     985            if (!breakpoint.sourceCodeLocation.sourceCode)
    981986                breakpoint.sourceCodeLocation.sourceCode = sourceCode;
    982987            // SourceCodes can be unequal if the SourceCodeLocation is associated with a Script and we are looking at the Resource.

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

    r204507 r207371  
    4545
    4646        console.assert(typeof this._type === "string");
    47         this._id = WebInspector.debuggerManager.nextBreakpointActionIdentifier;
     47        this._id = WebInspector.debuggerManager.nextBreakpointActionIdentifier();
    4848    }
    4949

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

    r207358 r207371  
    11051105
    11061106        this._ignoreBreakpointAddedBreakpoint = breakpoint;
    1107         var shouldSkipEventDispatch = false;
    1108         var shouldSpeculativelyResolveBreakpoint = true;
    1109         WebInspector.debuggerManager.addBreakpoint(breakpoint, shouldSkipEventDispatch, shouldSpeculativelyResolveBreakpoint);
     1107        const shouldSpeculativelyResolveBreakpoint = true;
     1108        WebInspector.debuggerManager.addBreakpoint(breakpoint, shouldSpeculativelyResolveBreakpoint);
    11101109        this._ignoreBreakpointAddedBreakpoint = null;
    11111110
Note: See TracChangeset for help on using the changeset viewer.