DevTools: fix stick to bottom in console viewport

third_party/WebKit/Source/devtools/front_end/ui/ViewportControl.js

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 41 matching lines @@
     this._provider = provider;
     this.element.addEventListener("scroll", this._onScroll.bind(this), false);
     this.element.addEventListener("copy", this._onCopy.bind(this), false);
     this.element.addEventListener("dragstart", this._onDragStart.bind(this), false);
 
     this._firstVisibleIndex = 0;
     this._lastVisibleIndex = -1;
     this._renderedItems = [];
     this._anchorSelection = null;
     this._headSelection = null;
-    this._stickToBottom = false;
-    this._scrolledToBottom = true;
     this._itemCount = 0;
+
+    // Listen for any changes to descendants and trigger a refresh. This ensures
+    // that items updated asynchronously will not break stick-to-bottom behavior
+    // if they change the scroll height.
+    this._observer = new MutationObserver(this.refresh.bind(this));

[dgozman, 2016/08/03 21:19:01]

Did you check the performance of this? E.g. do console.table() with a lot of
rows and measure.

[luoe, 2016/08/04 23:13:01]

Scrolling with a console.table() was slow!  Not because of the mutation
observer, but because there was an invalidate() and full viewport update called
every scroll.  I've removed the unnecessary scheduleViewportRefresh() in
ConsoleView.js:1052 to address this.

Mutation observer doesn't run its handler while a viewport update occurs, so it
should be fine.

+    this._observerConfig = { childList: true, subtree: true };
 }
 
 /**
  * @interface
  */
 WebInspector.ViewportControl.Provider = function()
 {
 }
 
 WebInspector.ViewportControl.Provider.prototype = {
@@ skipping 63 matching lines @@
     element: function()
     {
         return this._element;
     },
 }
 
 WebInspector.ViewportControl.prototype = {
     /**
      * @return {boolean}
      */
-    scrolledToBottom: function()
+    stickToBottom: function()
     {
-        return this._scrolledToBottom;
+        return this._stickToBottom;
     },
 
     /**
      * @param {boolean} value
      */
     setStickToBottom: function(value)
     {
         this._stickToBottom = value;
+        if (this._stickToBottom)
+            this._observer.observe(this._contentElement, this._observerConfig);
+        else
+            this._observer.disconnect();
     },
 
     /**
      * @param {!Event} event
      */
     _onCopy: function(event)
     {
         var text = this._selectedText();
         if (!text)
             return;
@@ skipping 200 matching lines @@
             else if (this._headSelection.item > this._lastVisibleIndex)
                 headElement = this._bottomGapElement;
             headOffset = this._selectionIsBackward ? 0 : 1;
         }
 
         selection.setBaseAndExtent(anchorElement, anchorOffset, headElement, headOffset);
     },
 
     refresh: function()
     {
+        this._observer.disconnect();
+        this._innerRefresh();
+        if (this._stickToBottom)
+            this._observer.observe(this._contentElement, this._observerConfig);
+    },
+
+    _innerRefresh: function()
+    {
         if (!this._visibleHeight())
             return;  // Do nothing for invisible controls.
 
         if (!this._itemCount) {
             for (var i = 0; i < this._renderedItems.length; ++i)
                 this._renderedItems[i].willHide();
             this._renderedItems = [];
             this._contentElement.removeChildren();
             this._topGapElement.style.height = "0px";
             this._bottomGapElement.style.height = "0px";
             this._firstVisibleIndex = -1;
             this._lastVisibleIndex = -1;
             return;
         }
 
         var selection = this.element.getComponentSelection();
         var shouldRestoreSelection = this._updateSelectionModel(selection);
 
         var visibleFrom = this.element.scrollTop;
         var visibleHeight = this._visibleHeight();
-        this._scrolledToBottom = this.element.isScrolledToBottom();
         var isInvalidating = !this._cumulativeHeights;
 
         for (var i = 0; i < this._renderedItems.length; ++i) {
             // Tolerate 1-pixel error due to double-to-integer rounding errors.
             if (this._cumulativeHeights && Math.abs(this._cachedItemHeight(this._firstVisibleIndex + i) - this._renderedItems[i].element().offsetHeight) > 1)
                 delete this._cumulativeHeights;
         }
         this._rebuildCumulativeHeightsIfNeeded();
         var oldFirstVisibleIndex = this._firstVisibleIndex;
         var oldLastVisibleIndex = this._lastVisibleIndex;
 
-        var shouldStickToBottom = this._stickToBottom && this._scrolledToBottom;
-
-        if (shouldStickToBottom) {
+        // When the viewport is scrolled to the bottom, using the cumulative heights estimate is not
+        // precise enough to determine next visible indices. This stickToBottom check avoids extra
+        // calls to refresh in those cases.
+        if (this._stickToBottom) {
+            this._firstVisibleIndex = Math.max(this._itemCount - Math.ceil(visibleHeight / this._provider.minimumRowHeight()), 0);
             this._lastVisibleIndex = this._itemCount - 1;
-            this._firstVisibleIndex = Math.max(this._itemCount - Math.ceil(visibleHeight / this._provider.minimumRowHeight()), 0);
         } else {
             this._firstVisibleIndex = Math.max(Array.prototype.lowerBound.call(this._cumulativeHeights, visibleFrom + 1), 0);
             // Proactively render more rows in case some of them will be collapsed without triggering refresh. @see crbug.com/390169
             this._lastVisibleIndex = this._firstVisibleIndex + Math.ceil(visibleHeight / this._provider.minimumRowHeight()) - 1;
             this._lastVisibleIndex = Math.min(this._lastVisibleIndex, this._itemCount - 1);
         }
+
         var topGapHeight = this._cumulativeHeights[this._firstVisibleIndex - 1] || 0;
         var bottomGapHeight = this._cumulativeHeights[this._cumulativeHeights.length - 1] - this._cumulativeHeights[this._lastVisibleIndex];
 
         /**
          * @this {WebInspector.ViewportControl}
          */
         function prepare()
         {
             this._topGapElement.style.height = topGapHeight + "px";
             this._bottomGapElement.style.height = bottomGapHeight + "px";
             this._topGapElement._active = !!topGapHeight;
             this._bottomGapElement._active = !!bottomGapHeight;
             this._contentElement.style.setProperty("height", "10000000px");
         }
 
         if (isInvalidating)
             this._fullViewportUpdate(prepare.bind(this));
         else
             this._partialViewportUpdate(oldFirstVisibleIndex, oldLastVisibleIndex, prepare.bind(this));
         this._contentElement.style.removeProperty("height");
         // Should be the last call in the method as it might force layout.
         if (shouldRestoreSelection)
             this._restoreSelection(selection);
-        if (shouldStickToBottom)
+        if (this._stickToBottom)
             this.element.scrollTop = 10000000;
     },
 
     /**
      * @param {function()} prepare
      */
     _fullViewportUpdate: function(prepare)
     {
         for (var i = 0; i < this._renderedItems.length; ++i)
             this._renderedItems[i].willHide();
@@ skipping 149 matching lines @@
             this.forceScrollItemToBeFirst(index);
         else if (index >= this._lastVisibleIndex)
             this.forceScrollItemToBeLast(index);
     },
 
     /**
      * @param {number} index
      */
     forceScrollItemToBeFirst: function(index)
     {
+        this.setStickToBottom(false);
         this._rebuildCumulativeHeightsIfNeeded();
         this.element.scrollTop = index > 0 ? this._cumulativeHeights[index - 1] : 0;
+        if (this.element.isScrolledToBottom())
+            this.setStickToBottom(true);
         this.refresh();
     },
 
     /**
      * @param {number} index
      */
     forceScrollItemToBeLast: function(index)
     {
+        this.setStickToBottom(false);
         this._rebuildCumulativeHeightsIfNeeded();
         this.element.scrollTop = this._cumulativeHeights[index] - this._visibleHeight();
+        if (this.element.isScrolledToBottom())
+            this.setStickToBottom(true);
         this.refresh();
     },
 
     /**
      * @return {number}
      */
     _visibleHeight: function()
     {
         // Use offsetHeight instead of clientHeight to avoid being affected by horizontal scroll.
         return this.element.offsetHeight;
     }
 }