DevTools: [Console] fix console stick-to-bottom behavior in case of multiline messages

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 43 matching lines @@
     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;
 }
 
 /**
  * @interface
  */
 WebInspector.ViewportControl.Provider = function()
 {
 }
 
 WebInspector.ViewportControl.Provider.prototype = {
@@ skipping 114 matching lines @@
      */
     contentElement: function()
     {
         return this._contentElement;
     },
 
     invalidate: function()
     {
         delete this._cumulativeHeights;
         delete this._cachedProviderElements;
-        this.refresh();
+        this._itemCount = this._provider.itemCount();
+        this._innerRefresh(false);
     },
 
     /**
      * @param {number} index
      * @return {?WebInspector.ViewportElement}
      */
     _providerElement: function(index)
     {
         if (!this._cachedProviderElements)
-            this._cachedProviderElements = new Array(this._provider.itemCount());
+            this._cachedProviderElements = new Array(this._itemCount);
         var element = this._cachedProviderElements[index];
         if (!element) {
             element = this._provider.itemElement(index);
             this._cachedProviderElements[index] = element;
         }
         return element;
     },
 
     _rebuildCumulativeHeightsIfNeeded: function()
     {
         if (this._cumulativeHeights)
             return;
-        var itemCount = this._provider.itemCount();
-        if (!itemCount)
+        if (!this._itemCount)
             return;
         var firstVisibleIndex = this._firstVisibleIndex;
         var lastVisibleIndex = this._lastVisibleIndex;
         var height = 0;
-        this._cumulativeHeights = new Int32Array(itemCount);
-        for (var i = 0; i < itemCount; ++i) {
+        this._cumulativeHeights = new Int32Array(this._itemCount);
+        for (var i = 0; i < this._itemCount; ++i) {
             if (firstVisibleIndex <= i && i <= lastVisibleIndex)
                 height += this._renderedItems[i - firstVisibleIndex].element().offsetHeight;
             else
                 height += this._provider.fastHeight(i);
             this._cumulativeHeights[i] = height;
         }
     },
 
     /**
      * @param {number} index
@@ skipping 64 matching lines @@
         var topOverlap = range.intersectsNode(this._topGapElement) && this._topGapElement._active;
         var bottomOverlap = range.intersectsNode(this._bottomGapElement) && this._bottomGapElement._active;
         if (!topOverlap && !bottomOverlap && !hasVisibleSelection) {
             this._headSelection = null;
             this._anchorSelection = null;
             return false;
         }
 
         if (!this._anchorSelection || !this._headSelection) {
             this._anchorSelection = this._createSelectionModel(0, this.element, 0);
-            this._headSelection = this._createSelectionModel(this._provider.itemCount() - 1, this.element, this.element.children.length);
+            this._headSelection = this._createSelectionModel(this._itemCount - 1, this.element, this.element.children.length);
             this._selectionIsBackward = false;
         }
 
         var isBackward = this._isSelectionBackwards(selection);
         var startSelection = this._selectionIsBackward ? this._headSelection : this._anchorSelection;
         var endSelection = this._selectionIsBackward ? this._anchorSelection : this._headSelection;
         if (topOverlap && bottomOverlap && hasVisibleSelection) {
             firstSelected = firstSelected.item < startSelection.item ? firstSelected : startSelection;
             lastSelected = lastSelected.item > endSelection.item ? lastSelected : endSelection;
         } else if (!hasVisibleSelection) {
@@ skipping 44 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._innerRefresh(false);
+    },
+
+    /**
+     * @param {boolean} isUserGesture
+     */
+    _innerRefresh: function(isUserGesture)
+    {
         if (!this._visibleHeight())
             return;  // Do nothing for invisible controls.
 
-        if (!this._provider.itemCount()) {
+        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 itemCount = this._cumulativeHeights.length;
         var oldFirstVisibleIndex = this._firstVisibleIndex;
         var oldLastVisibleIndex = this._lastVisibleIndex;
 
-        var shouldStickToBottom = isInvalidating && this._stickToBottom && this._scrolledToBottom;
+        var shouldStickToBottom = !isUserGesture && this._stickToBottom && this._scrolledToBottom;
 
         if (shouldStickToBottom) {
-            this._lastVisibleIndex = itemCount - 1;
-            this._firstVisibleIndex = Math.max(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, itemCount - 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)
-            this.element.scrollTop = this.element.scrollHeight;
+            this.element.scrollTop = 10000000;
     },
 
     /**
      * @param {function()} prepare
      */
     _fullViewportUpdate: function(prepare)
     {
         for (var i = 0; i < this._renderedItems.length; ++i)
             this._renderedItems[i].willHide();
         prepare();
@@ skipping 96 matching lines @@
         while ((node = node.traverseNextTextNode()) && node !== container)
             chars += node.textContent.length;
         return chars + offset;
     },
 
     /**
      * @param {!Event} event
      */
     _onScroll: function(event)
     {
-        this.refresh();
+        this._innerRefresh(event.isTrusted);
     },
 
     /**
      * @return {number}
      */
     firstVisibleIndex: function()
     {
         return this._firstVisibleIndex;
     },
 
@@ skipping 33 matching lines @@
             this.forceScrollItemToBeLast(index);
     },
 
     /**
      * @param {number} index
      */
     forceScrollItemToBeFirst: function(index)
     {
         this._rebuildCumulativeHeightsIfNeeded();
         this.element.scrollTop = index > 0 ? this._cumulativeHeights[index - 1] : 0;
-        this.refresh();
+        this._innerRefresh(false);
     },
 
     /**
      * @param {number} index
      */
     forceScrollItemToBeLast: function(index)
     {
         this._rebuildCumulativeHeightsIfNeeded();
         this.element.scrollTop = this._cumulativeHeights[index] - this._visibleHeight();
-        this.refresh();
+        this._innerRefresh(false);
     },
 
     /**
      * @return {number}
      */
     _visibleHeight: function()
     {
         // Use offsetHeight instead of clientHeight to avoid being affected by horizontal scroll.
         return this.element.offsetHeight;
     }
 }