DevTools: make console viewport less error prone by always defining cumulativeHeights

third_party/WebKit/Source/devtools/front_end/console/ConsoleViewport.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 44 matching lines @@
     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._firstActiveIndex = 0;
     this._lastActiveIndex = -1;
     this._renderedItems = [];
     this._anchorSelection = null;
     this._headSelection = null;
     this._itemCount = 0;
+    this._cumulativeHeights = new Int32Array(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));
     this._observerConfig = {childList: true, subtree: true};
   }
 
   /**
    * @return {boolean}
@@ skipping 38 matching lines @@
   }
 
   /**
    * @return {!Element}
    */
   contentElement() {
     return this._contentElement;
   }
 
   invalidate() {
-    delete this._cumulativeHeights;
     delete this._cachedProviderElements;
     this._itemCount = this._provider.itemCount();
+    this._rebuildCumulativeHeights();
     this.refresh();
   }
 
   /**
    * @param {number} index
    * @return {?Console.ConsoleViewportElement}
    */
   _providerElement(index) {
     if (!this._cachedProviderElements)
       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() {
-    if (this._cumulativeHeights)
+  _rebuildCumulativeHeights() {
+    if (!this._itemCount) {

[dgozman, 2017/04/07 20:31:44]

I think this special-casing is not needed anymore.

[luoe, 2017/04/07 22:09:54]

Done.

+      this._cumulativeHeights = new Int32Array(0);
       return;
-    if (!this._itemCount)
-      return;
+    }
     var firstActiveIndex = this._firstActiveIndex;
     var lastActiveIndex = this._lastActiveIndex;
     var height = 0;
     this._cumulativeHeights = new Int32Array(this._itemCount);
     for (var i = 0; i < this._itemCount; ++i) {
       if (firstActiveIndex <= i && i <= lastActiveIndex)
         height += this._renderedItems[i - firstActiveIndex].element().offsetHeight;
       else
         height += this._provider.fastHeight(i);
       this._cumulativeHeights[i] = height;
@@ skipping 158 matching lines @@
     }
 
     var selection = this.element.getComponentSelection();
     var shouldRestoreSelection = this._updateSelectionModel(selection);
 
     var visibleFrom = this.element.scrollTop;
     var visibleHeight = this._visibleHeight();
 
     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._firstActiveIndex + i) - this._renderedItems[i].element().offsetHeight) >
-              1)
-        delete this._cumulativeHeights;
+      var cachedItemHeight = this._cachedItemHeight(this._firstActiveIndex + i);
+      if (Math.abs(cachedItemHeight - this._renderedItems[i].element().offsetHeight) > 1) {
+        this._rebuildCumulativeHeights();
+        break;
+      }
     }
-    this._rebuildCumulativeHeightsIfNeeded();
     var activeHeight = visibleHeight * 2;
     // 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._firstActiveIndex =
           Math.max(this._itemCount - Math.ceil(activeHeight / this._provider.minimumRowHeight()), 0);
       this._lastActiveIndex = this._itemCount - 1;
     } else {
       this._firstActiveIndex = Math.max(
-          Array.prototype.lowerBound.call(
+          Int32Array.prototype.lowerBound.call(
               this._cumulativeHeights, visibleFrom + 1 - (activeHeight - visibleHeight) / 2),
           0);
       // Proactively render more rows in case some of them will be collapsed without triggering refresh. @see crbug.com/390169
       this._lastActiveIndex = this._firstActiveIndex + Math.ceil(activeHeight / this._provider.minimumRowHeight()) - 1;
       this._lastActiveIndex = Math.min(this._lastActiveIndex, this._itemCount - 1);
     }
 
     var topGapHeight = this._cumulativeHeights[this._firstActiveIndex - 1] || 0;
     var bottomGapHeight =
         this._cumulativeHeights[this._cumulativeHeights.length - 1] - this._cumulativeHeights[this._lastActiveIndex];
@@ skipping 114 matching lines @@
    */
   _onScroll(event) {
     this.refresh();
   }
 
   /**
    * @return {number}
    */
   firstVisibleIndex() {
     var firstVisibleIndex =
-        Math.max(Array.prototype.lowerBound.call(this._cumulativeHeights, this.element.scrollTop + 1), 0);
+        Math.max(Int32Array.prototype.lowerBound.call(this._cumulativeHeights, this.element.scrollTop + 1), 0);
     return Math.max(firstVisibleIndex, this._firstActiveIndex);
   }
 
   /**
    * @return {number}
    */
   lastVisibleIndex() {
     var lastVisibleIndex;
     if (this._stickToBottom) {
       lastVisibleIndex = this._itemCount - 1;
@@ skipping 30 matching lines @@
       this.forceScrollItemToBeFirst(index);
     else if (index >= lastVisibleIndex)
       this.forceScrollItemToBeLast(index);
   }
 
   /**
    * @param {number} index
    */
   forceScrollItemToBeFirst(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(index) {
     this.setStickToBottom(false);
-    this._rebuildCumulativeHeightsIfNeeded();

[luoe, 2017/04/07 01:19:38]

By default, CH is an empty typed array if there are no items.  CH only changes
in invalidate() and innerRefresh() so we should only need to rebuild there.

     this.element.scrollTop = this._cumulativeHeights[index] - this._visibleHeight();
     if (this.element.isScrolledToBottom())
       this.setStickToBottom(true);
     this.refresh();
   }
 
   /**
    * @return {number}
    */
   _visibleHeight() {
@@ skipping 46 matching lines @@
 Console.ConsoleViewportElement.prototype = {
   willHide() {},
 
   wasShown() {},
 
   /**
    * @return {!Element}
    */
   element() {},
 };