[DevTools] reworked JavaScriptBreakpointsSidebarPane.js

third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js

Index: third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js
diff --git a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js
index 69e066cc3d12623f641966e7e4fc7f08d8846524..03d7d3214a1b1600118b5a96da0d3c3e88a8d420 100644
--- a/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js
+++ b/third_party/WebKit/Source/devtools/front_end/sources/JavaScriptBreakpointsSidebarPane.js
@@ -5,263 +5,222 @@
  * @implements {UI.ContextFlavorListener}
  * @unrestricted
  */
-Sources.JavaScriptBreakpointsSidebarPane = class extends UI.VBox {
+Sources.JavaScriptBreakpointsSidebarPane = class extends UI.ThrottledWidget {
   constructor() {
-    super();
+    super(true);
     this.registerRequiredCSS('components/breakpointsList.css');
 
     this._breakpointManager = Bindings.breakpointManager;
-
-    this._listElement = createElementWithClass('ol', 'breakpoint-list');
-
-    this.emptyElement = this.element.createChild('div', 'gray-info-message');
-    this.emptyElement.textContent = Common.UIString('No Breakpoints');
-
-    this._items = new Map();
-
-    var breakpointLocations = this._breakpointManager.allBreakpointLocations();
-    for (var i = 0; i < breakpointLocations.length; ++i)
-      this._addBreakpoint(breakpointLocations[i].breakpoint, breakpointLocations[i].uiLocation);
-
     this._breakpointManager.addEventListener(
-        Bindings.BreakpointManager.Events.BreakpointAdded, this._breakpointAdded, this);
+        Bindings.BreakpointManager.Events.BreakpointAdded, this.update, this);
     this._breakpointManager.addEventListener(
-        Bindings.BreakpointManager.Events.BreakpointRemoved, this._breakpointRemoved, this);
-
-    this.emptyElement.addEventListener('contextmenu', this._emptyElementContextMenu.bind(this), true);
+        Bindings.BreakpointManager.Events.BreakpointRemoved, this.update, this);
     this._breakpointManager.addEventListener(
-        Bindings.BreakpointManager.Events.BreakpointsActiveStateChanged, this._breakpointsActiveStateChanged, this);
-    this._breakpointsActiveStateChanged();
-    this._update();
-  }
+        Bindings.BreakpointManager.Events.BreakpointsActiveStateChanged, this.update, this);
 
-  _emptyElementContextMenu(event) {
-    var contextMenu = new UI.ContextMenu(event);
-    this._appendBreakpointActiveItem(contextMenu);
-    contextMenu.show();
+    /** @type {?Element} */
+    this._listElement = null;
+    this.update();
   }
 
   /**
-   * @param {!UI.ContextMenu} contextMenu
+   * @override
+   * @return {!Promise<?>}
    */
-  _appendBreakpointActiveItem(contextMenu) {
-    var breakpointActive = this._breakpointManager.breakpointsActive();
-    var breakpointActiveTitle = breakpointActive ? Common.UIString.capitalize('Deactivate ^breakpoints') :
-                                                   Common.UIString.capitalize('Activate ^breakpoints');
-    contextMenu.appendItem(
-        breakpointActiveTitle,
-        this._breakpointManager.setBreakpointsActive.bind(this._breakpointManager, !breakpointActive));
-  }
+  doUpdate() {
+    var breakpointLocations = this._breakpointManager.allBreakpointLocations();
+    if (!breakpointLocations.length) {
+      this._listElement = null;
+      this.contentElement.removeChildren();
+      var emptyElement = this.contentElement.createChild('div', 'gray-info-message');
+      emptyElement.textContent = Common.UIString('No Breakpoints');
+      this.contentElement.appendChild(emptyElement);
+      this._didUpdateForTest();
+      return Promise.resolve();
+    }
 
-  /**
-   * @param {!Common.Event} event
-   */
-  _breakpointAdded(event) {
-    this._breakpointRemoved(event);
+    if (!this._listElement) {
+      this.contentElement.removeChildren();
+      this._listElement = this.contentElement.createChild('div');
+      this.contentElement.appendChild(this._listElement);
+    }
+
+    breakpointLocations.sort((item1, item2) => item1.uiLocation.compareTo(item2.uiLocation));
+
+    /** @type {!Multimap<string, !{breakpoint: !Bindings.BreakpointManager.Breakpoint, uiLocation: !Workspace.UILocation}>} */
+    var locationForEntry = new Multimap();
+    for (var breakpointLocation of breakpointLocations) {
+      var uiLocation = breakpointLocation.uiLocation;
+      var entryDescriptor = uiLocation.uiSourceCode.url() + ':' + uiLocation.lineNumber;
+      locationForEntry.set(entryDescriptor, breakpointLocation);
+    }
+
+    var details = UI.context.flavor(SDK.DebuggerPausedDetails);
+    var selectedUILocation = details && details.callFrames.length ?
+        Bindings.debuggerWorkspaceBinding.rawLocationToUILocation(details.callFrames[0].location()) :
+        null;
 
-    var breakpoint = /** @type {!Bindings.BreakpointManager.Breakpoint} */ (event.data.breakpoint);
-    var uiLocation = /** @type {!Workspace.UILocation} */ (event.data.uiLocation);
-    this._addBreakpoint(breakpoint, uiLocation);
+    var shouldShowView = false;
+    var entry = this._listElement.firstChild;
+    var promises = [];
+    for (var descriptor of locationForEntry.keysArray()) {
+      if (!entry) {
+        entry = this._listElement.createChild('div', 'breakpoint-entry');
+        entry.addEventListener('contextmenu', this._breakpointContextMenu.bind(this), true);
+        entry.addEventListener('click', this._revealLocation.bind(this), false);
+        var checkboxLabel = createCheckboxLabel('');
+        checkboxLabel.addEventListener('click', this._breakpointCheckboxClicked.bind(this), false);
+        entry.appendChild(checkboxLabel);
+        entry[Sources.JavaScriptBreakpointsSidebarPane._checkboxLabelSymbol] = checkboxLabel;
+        var snippetElement = entry.createChild('div', 'source-text monospace');
+        entry[Sources.JavaScriptBreakpointsSidebarPane._snippetElementSymbol] = snippetElement;
+      }
+
+      var locations = Array.from(locationForEntry.get(descriptor));
+      var uiLocation = locations[0].uiLocation;
+      var isSelected = !!selectedUILocation && locations.some(location => location.uiLocation.id() === selectedUILocation.id());
+      var hasEnabled = locations.some(location => location.breakpoint.enabled());
+      var hasDisabled = locations.some(location => !location.breakpoint.enabled());
+      promises.push(this._resetEntry(/** @type {!Element}*/(entry), uiLocation, isSelected, hasEnabled, hasDisabled));
+
+      if (isSelected)
+        shouldShowView = true;
+      entry = entry.nextSibling;
+    }
+    while (entry) {
+       var next = entry.nextSibling;
+       entry.remove();
+       entry = next;
+    }
+    if (shouldShowView)
+      UI.viewManager.showView('sources.jsBreakpoints');
+    this._listElement.classList.toggle('breakpoints-list-deactivated', !this._breakpointManager.breakpointsActive());
+    Promise.all(promises).then(() => this._didUpdateForTest());
+    return Promise.resolve();
   }
 
   /**
-   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
+   * @param {!Element} element
    * @param {!Workspace.UILocation} uiLocation
+   * @param {boolean} isSelected
+   * @param {boolean} hasEnabled
+   * @param {boolean} hasDisabled
+   * @return {!Promise<undefined>}
    */
-  _addBreakpoint(breakpoint, uiLocation) {
-    var element = createElementWithClass('li', 'cursor-pointer');
-    element.addEventListener('contextmenu', this._breakpointContextMenu.bind(this, breakpoint), true);
-    element.addEventListener('click', this._breakpointClicked.bind(this, uiLocation), false);
+  _resetEntry(element, uiLocation, isSelected, hasEnabled, hasDisabled) {
+    element[Sources.JavaScriptBreakpointsSidebarPane._locationSymbol] = uiLocation;
+    element.classList.toggle('breakpoint-hit', isSelected);
 
-    var checkboxLabel = createCheckboxLabel(uiLocation.linkText(), breakpoint.enabled());
-    element.appendChild(checkboxLabel);
-    checkboxLabel.addEventListener('click', this._breakpointCheckboxClicked.bind(this, breakpoint), false);
+    var checkboxLabel = element[Sources.JavaScriptBreakpointsSidebarPane._checkboxLabelSymbol];
+    checkboxLabel.textElement.textContent = uiLocation.linkText();
+    checkboxLabel.checkboxElement.checked = hasEnabled;
+    checkboxLabel.checkboxElement.indeterminate = hasEnabled && hasDisabled;
 
-    var snippetElement = element.createChild('div', 'source-text monospace');
+    var snippetElement = element[Sources.JavaScriptBreakpointsSidebarPane._snippetElementSymbol];
+    return uiLocation.uiSourceCode.requestContent().then(fillSnippetElement.bind(null, snippetElement));
 
     /**
+     * @param {!Element} snippetElement
      * @param {?string} content
-     * @this {Sources.JavaScriptBreakpointsSidebarPane}
      */
-    function didRequestContent(content) {
+    function fillSnippetElement(snippetElement, content) {
       var lineNumber = uiLocation.lineNumber;
-      var columnNumber = uiLocation.columnNumber;
       var text = new Common.Text(content || '');
       if (lineNumber < text.lineCount()) {
         var lineText = text.lineAt(lineNumber);
         var maxSnippetLength = 200;
-        var snippetStartIndex = columnNumber > 100 ? columnNumber : 0;
-        snippetElement.textContent = lineText.substr(snippetStartIndex).trimEnd(maxSnippetLength);
+        snippetElement.textContent = lineText.trimEnd(maxSnippetLength);
       }
-      this.didReceiveBreakpointLineForTest(uiLocation.uiSourceCode, lineNumber, columnNumber);
-    }
-
-    uiLocation.uiSourceCode.requestContent().then(didRequestContent.bind(this));
-
-    element._data = uiLocation;
-    var currentElement = this._listElement.firstChild;
-    while (currentElement) {
-      if (currentElement._data && this._compareBreakpoints(currentElement._data, element._data) > 0)
-        break;
-      currentElement = currentElement.nextSibling;
     }
-    this._addListElement(element, currentElement);
-
-    var breakpointItem = {element: element, checkbox: checkboxLabel.checkboxElement};
-    this._items.set(breakpoint, breakpointItem);
   }
 
   /**
-   * @param {!Workspace.UISourceCode} uiSourceCode
-   * @param {number} lineNumber
-   * @param {number} columnNumber
+   * @param {!Event} event
+   * @return {?Workspace.UILocation}
    */
-  didReceiveBreakpointLineForTest(uiSourceCode, lineNumber, columnNumber) {
+  _uiLocationFromEvent(event) {
+    var node = event.target.enclosingNodeOrSelfWithClass('breakpoint-entry');
+    if (!node)
+      return null;
+    return node[Sources.JavaScriptBreakpointsSidebarPane._locationSymbol] || null;
   }
 
   /**
-   * @param {!Common.Event} event
+   * @param {!Event} event
    */
-  _breakpointRemoved(event) {
-    var breakpoint = /** @type {!Bindings.BreakpointManager.Breakpoint} */ (event.data.breakpoint);
-    var breakpointItem = this._items.get(breakpoint);
-    if (!breakpointItem)
+  _breakpointCheckboxClicked(event) {
+    var uiLocation = this._uiLocationFromEvent(event);
+    if (!uiLocation)
       return;
-    this._items.remove(breakpoint);
-    this._removeListElement(breakpointItem.element);
-  }
-
-  /**
-   * @override
-   * @param {?Object} object
-   */
-  flavorChanged(object) {
-    this._update();
-  }
 
-  _update() {
-    var details = UI.context.flavor(SDK.DebuggerPausedDetails);
-    var uiLocation = details && details.callFrames.length ?
-        Bindings.debuggerWorkspaceBinding.rawLocationToUILocation(details.callFrames[0].location()) :
-        null;
-    var breakpoint = uiLocation ?
-        this._breakpointManager.findBreakpoint(
-            uiLocation.uiSourceCode, uiLocation.lineNumber, uiLocation.columnNumber) :
-        null;
-    var breakpointItem = this._items.get(breakpoint);
-    if (!breakpointItem) {
-      if (this._highlightedBreakpointItem) {
-        this._highlightedBreakpointItem.element.classList.remove('breakpoint-hit');
-        delete this._highlightedBreakpointItem;
-      }
-      return;
-    }
-
-    breakpointItem.element.classList.add('breakpoint-hit');
-    this._highlightedBreakpointItem = breakpointItem;
-    UI.viewManager.showView('sources.jsBreakpoints');
-  }
-
-  _breakpointsActiveStateChanged() {
-    this._listElement.classList.toggle('breakpoints-list-deactivated', !this._breakpointManager.breakpointsActive());
-  }
-
-  /**
-   * @param {!Workspace.UILocation} uiLocation
-   */
-  _breakpointClicked(uiLocation) {
-    Common.Revealer.reveal(uiLocation);
+    var breakpoints = this._breakpointManager.findBreakpoints(uiLocation.uiSourceCode, uiLocation.lineNumber);
+    var newState = event.target.checkboxElement.checked;
+    for (var breakpoint of breakpoints)
+      breakpoint.setEnabled(newState);
+    event.consume();
   }
 
   /**
-   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    * @param {!Event} event
    */
-  _breakpointCheckboxClicked(breakpoint, event) {
-    // Breakpoint element has it's own click handler.
-    event.consume();
-    breakpoint.setEnabled(event.target.checkboxElement.checked);
+  _revealLocation(event) {
+    var uiLocation = this._uiLocationFromEvent(event);
+    if (uiLocation)
+      Common.Revealer.reveal(uiLocation);
   }
 
   /**
-   * @param {!Bindings.BreakpointManager.Breakpoint} breakpoint
    * @param {!Event} event
    */
-  _breakpointContextMenu(breakpoint, event) {
-    var breakpoints = this._items.valuesArray();
-    var contextMenu = new UI.ContextMenu(event);
-    contextMenu.appendItem(Common.UIString.capitalize('Remove ^breakpoint'), breakpoint.remove.bind(breakpoint));
-    if (breakpoints.length > 1) {
-      var removeAllTitle = Common.UIString.capitalize('Remove ^all ^breakpoints');
-      contextMenu.appendItem(
-          removeAllTitle, this._breakpointManager.removeAllBreakpoints.bind(this._breakpointManager));
-    }
+  _breakpointContextMenu(event) {
+    var uiLocation = this._uiLocationFromEvent(event);
+    if (!uiLocation)
+      return;
 
-    contextMenu.appendSeparator();
-    this._appendBreakpointActiveItem(contextMenu);
+    var breakpoints = this._breakpointManager.findBreakpoints(uiLocation.uiSourceCode, uiLocation.lineNumber);
 
-    function enabledBreakpointCount(breakpoints) {
-      var count = 0;
-      for (var i = 0; i < breakpoints.length; ++i) {
-        if (breakpoints[i].checkbox.checked)
-          count++;
-      }
-      return count;
-    }
-    if (breakpoints.length > 1) {
-      var enableBreakpointCount = enabledBreakpointCount(breakpoints);
-      var enableTitle = Common.UIString.capitalize('Enable ^all ^breakpoints');
-      var disableTitle = Common.UIString.capitalize('Disable ^all ^breakpoints');
+    var contextMenu = new UI.ContextMenu(event);
+    var removeEntryTitle = breakpoints.length > 1 ? Common.UIString('Remove all breakpoints in line')
+                                                  : Common.UIString('Remove breakpoint');
+    contextMenu.appendItem(removeEntryTitle, () => breakpoints.map(breakpoint => breakpoint.remove()));
 
-      contextMenu.appendSeparator();
+    contextMenu.appendSeparator();
+    var breakpointActive = this._breakpointManager.breakpointsActive();
+    var breakpointActiveTitle = breakpointActive ? Common.UIString('Deactivate breakpoints') :
+                                                   Common.UIString('Activate breakpoints');
+    contextMenu.appendItem(
+        breakpointActiveTitle,
+        this._breakpointManager.setBreakpointsActive.bind(this._breakpointManager, !breakpointActive));
 
+    contextMenu.appendSeparator();
+    if (breakpoints.some(breakpoint => !breakpoint.enabled())) {
+      var enableTitle = Common.UIString('Enable all breakpoints');
       contextMenu.appendItem(
-          enableTitle, this._breakpointManager.toggleAllBreakpoints.bind(this._breakpointManager, true),
-          !(enableBreakpointCount !== breakpoints.length));
+          enableTitle, this._breakpointManager.toggleAllBreakpoints.bind(this._breakpointManager, true));
+    }
+    if (breakpoints.some(breakpoint => breakpoint.enabled())) {
+      var disableTitle = Common.UIString('Disable all breakpoints');
       contextMenu.appendItem(
-          disableTitle, this._breakpointManager.toggleAllBreakpoints.bind(this._breakpointManager, false),
-          !(enableBreakpointCount > 1));
+          disableTitle, this._breakpointManager.toggleAllBreakpoints.bind(this._breakpointManager, false));
     }
-
+    var removeAllTitle = Common.UIString('Remove all breakpoints');
+    contextMenu.appendItem(
+        removeAllTitle, this._breakpointManager.removeAllBreakpoints.bind(this._breakpointManager));
     contextMenu.show();
   }
 
-  _addListElement(element, beforeElement) {
-    if (beforeElement)
-      this._listElement.insertBefore(element, beforeElement);
-    else {
-      if (!this._listElement.firstChild) {
-        this.element.removeChild(this.emptyElement);
-        this.element.appendChild(this._listElement);
-      }
-      this._listElement.appendChild(element);
-    }
-  }
-
-  _removeListElement(element) {
-    this._listElement.removeChild(element);
-    if (!this._listElement.firstChild) {
-      this.element.removeChild(this._listElement);
-      this.element.appendChild(this.emptyElement);
-    }
-  }
-
-  _compare(x, y) {
-    if (x !== y)
-      return x < y ? -1 : 1;
-    return 0;
-  }
-
-  _compareBreakpoints(b1, b2) {
-    return this._compare(b1.uiSourceCode.url(), b2.uiSourceCode.url()) || this._compare(b1.lineNumber, b2.lineNumber);
+  /**
+   * @override
+   * @param {?Object} object
+   */
+  flavorChanged(object) {
+    this.update();
   }
 
-  reset() {
-    this._listElement.removeChildren();
-    if (this._listElement.parentElement) {
-      this.element.removeChild(this._listElement);
-      this.element.appendChild(this.emptyElement);
-    }
-    this._items.clear();
+  _didUpdateForTest() {
   }
 };
+
+Sources.JavaScriptBreakpointsSidebarPane._locationSymbol = Symbol('location');
+Sources.JavaScriptBreakpointsSidebarPane._checkboxLabelSymbol = Symbol('checkbox-label');
+Sources.JavaScriptBreakpointsSidebarPane._snippetElementSymbol = Symbol('snippet-element');