DevTools: Prepare for recursive viewport in datagrid

Source/devtools/front_end/HeapSnapshotGridNodes.js

 /*
  * Copyright (C) 2011 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 74 matching lines @@
      * @return {!Element}
      */
     createCell: function(columnIdentifier)
     {
         var cell = WebInspector.DataGridNode.prototype.createCell.call(this, columnIdentifier);
         if (this._searchMatched)
             cell.classList.add("highlight");
         return cell;
     },
 
+    /**
+     * @override
+     */
     collapse: function()
     {
         WebInspector.DataGridNode.prototype.collapse.call(this);
         this._dataGrid.updateVisibleNodes();
     },
 
+    /**
+     * @override
+     */
     dispose: function()
     {
         if (this._providerObject)
             this._providerObject.dispose();
         for (var node = this.children[0]; node; node = node.traverseNextNode(true, this, true))
             if (node.dispose)
                 node.dispose();
     },
 
     _reachableFromWindow: false,
 
     queryObjectContent: function(callback)
     {
     },
 
     /**
      * @override
      */
     wasDetached: function()
     {
         this._dataGrid.nodeWasDetached(this);
     },
 
     _toPercentString: function(num)
     {
         return num.toFixed(0) + "\u2009%"; // \u2009 is a thin space.
     },
 
     /**
+     * @return {!Array.<!WebInspector.DataGridNode>}
+     */
+    allChildren: function()
+    {
+        return this.children;
+    },
+
+    /**
+     * @param {number} index
+     */
+    removeChildByIndex: function(index)
+    {
+        this.removeChild(this.children[index]);
+    },
+
+    /**
      * @param {number} nodePosition
      * @return {?WebInspector.DataGridNode}
      */
     childForPosition: function(nodePosition)
     {
-        var indexOfFirsChildInRange = 0;
+        var indexOfFirstChildInRange = 0;
         for (var i = 0; i < this._retrievedChildrenRanges.length; i++) {
            var range = this._retrievedChildrenRanges[i];
            if (range.from <= nodePosition && nodePosition < range.to) {
-               var childIndex = indexOfFirsChildInRange + nodePosition - range.from;
-               return this.children[childIndex];
+               var childIndex = indexOfFirstChildInRange + nodePosition - range.from;
+               return this.allChildren()[childIndex];
            }
-           indexOfFirsChildInRange += range.to - range.from + 1;
+           indexOfFirstChildInRange += range.to - range.from + 1;
         }
         return null;
     },
 
+    /**
+     * @param {string} columnIdentifier
+     * @return {!Element}
+     */
     _createValueCell: function(columnIdentifier)
     {
         var cell = document.createElement("td");
         cell.className = columnIdentifier + "-column";
         if (this.dataGrid.snapshot.totalSize !== 0) {
             var div = document.createElement("div");
             var valueSpan = document.createElement("span");
             valueSpan.textContent = this.data[columnIdentifier];
             div.appendChild(valueSpan);
             var percentColumn = columnIdentifier + "-percent";
@@ skipping 113 matching lines @@
                     }
                     insertionIndex += range.to - range.from;
                     // Skip the button if there is one.
                     if (range.to < itemsRange.totalLength)
                         insertionIndex += 1;
                     ++rangeIndex;
                 }
 
                 if (!found || itemsRange.startPosition < range.from) {
                     // Update previous button.
-                    this.children[insertionIndex - 1].setEndPosition(itemsRange.startPosition);
+                    this.allChildren()[insertionIndex - 1].setEndPosition(itemsRange.startPosition);
                     insertShowMoreButton.call(this, itemsRange.startPosition, found ? range.from : itemsRange.totalLength, insertionIndex);
                     range = {from: itemsRange.startPosition, to: itemsRange.startPosition};
                     if (!found)
                         rangeIndex = this._retrievedChildrenRanges.length;
                     this._retrievedChildrenRanges.splice(rangeIndex, 0, range);
                 } else {
                     insertionIndex += itemPosition - range.from;
                 }
                 // At this point insertionIndex is always an index before button or between nodes.
                 // Also it is always true here that range.from <= itemPosition <= range.to
@@ skipping 12 matching lines @@
                     if (newEndOfRange > itemsRange.endPosition)
                         newEndOfRange = itemsRange.endPosition;
                     while (itemPosition < newEndOfRange) {
                         insertRetrievedChild.call(this, items[itemIndex++], insertionIndex++);
                         ++itemPosition;
                     }
                     // Merge with the next range.
                     if (nextRange && newEndOfRange === nextRange.from) {
                         range.to = nextRange.to;
                         // Remove "show next" button if there is one.
-                        this.removeChild(this.children[insertionIndex]);
+                        this.removeChildByIndex(insertionIndex);
                         this._retrievedChildrenRanges.splice(rangeIndex + 1, 1);
                     } else {
                         range.to = newEndOfRange;
                         // Remove or update next button.
                         if (newEndOfRange === itemsRange.totalLength)
-                            this.removeChild(this.children[insertionIndex]);
+                            this.removeChildByIndex(insertionIndex);
                         else
-                            this.children[insertionIndex].setStartPosition(itemsRange.endPosition);
+                            this.allChildren()[insertionIndex].setStartPosition(itemsRange.endPosition);
                     }
                 }
             }
 
             // TODO: fix this.
             this._instanceCount += items.length;
             if (firstNotSerializedPosition < toPosition) {
                 serializeNextChunk.call(this);
                 return;
             }
 
             if (afterPopulate)
                 afterPopulate();
             this.dispatchEventToListeners(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete);
         }
         serializeNextChunk.call(this);
     },
 
     _saveChildren: function()
     {
         this._savedChildren = null;
-        for (var i = 0, childrenCount = this.children.length; i < childrenCount; ++i) {
-            var child = this.children[i];
+        var children = this.allChildren();
+        for (var i = 0, l = children.length; i < l; ++i) {
+            var child = children[i];
             if (!child.expanded)
                 continue;
             if (!this._savedChildren)
                 this._savedChildren = {};
             this._savedChildren[this._childHashForNode(child)] = child;
         }
     },
 
     sort: function()
     {
         this._dataGrid.recursiveSortingEnter();
 
         /**
          * @this {WebInspector.HeapSnapshotGridNode}
          */
         function afterSort()
         {
             this._saveChildren();
             this.removeChildren();
             this._retrievedChildrenRanges = [];
 
             /**
              * @this {WebInspector.HeapSnapshotGridNode}
              */
             function afterPopulate()
             {
-                for (var i = 0, l = this.children.length; i < l; ++i) {
-                    var child = this.children[i];
+                var children = this.allChildren();
+                for (var i = 0, l = children.length; i < l; ++i) {
+                    var child = children[i];
                     if (child.expanded)
                         child.sort();
                 }
                 this._dataGrid.recursiveSortingLeave();
             }
             var instanceCount = this._instanceCount;
             this._instanceCount = 0;
             this._populateChildren(0, instanceCount, afterPopulate.bind(this));
         }
 
@@ skipping 447 matching lines @@
         /**
          * @this {WebInspector.HeapSnapshotConstructorNode}
          */
         function didExpand()
         {
             this._provider().nodePosition(snapshotObjectId, didGetNodePosition.bind(this));
         }
 
         /**
          * @this {WebInspector.HeapSnapshotConstructorNode}
+         * @param {number} nodePosition
          */
         function didGetNodePosition(nodePosition)
         {
             if (nodePosition === -1) {
                 this.collapse();
                 callback(false);
             } else {
                 this._populateChildren(nodePosition, null, didPopulateChildren.bind(this, nodePosition));
             }
         }
 
         /**
          * @this {WebInspector.HeapSnapshotConstructorNode}
+         * @param {number} nodePosition
          */
         function didPopulateChildren(nodePosition)
         {
-            var indexOfFirsChildInRange = 0;
-            for (var i = 0; i < this._retrievedChildrenRanges.length; i++) {
-               var range = this._retrievedChildrenRanges[i];
-               if (range.from <= nodePosition && nodePosition < range.to) {
-                   var childIndex = indexOfFirsChildInRange + nodePosition - range.from;
-                   var instanceNode = this.children[childIndex];
-                   this._dataGrid.highlightNode(/** @type {!WebInspector.HeapSnapshotGridNode} */ (instanceNode));
-                   callback(true);
-                   return;
-               }
-               indexOfFirsChildInRange += range.to - range.from + 1;
-            }
-            callback(false);
+            var child = this.childForPosition(nodePosition);
+            if (child)
+                this._dataGrid.highlightNode(/** @type {!WebInspector.HeapSnapshotGridNode} */ (child));
+            callback(!!child);
         }
 
         this.expandWithoutPopulate(didExpand.bind(this));
     },
 
     /**
      * @param {string} columnIdentifier
      * @return {!Element}
      */
     createCell: function(columnIdentifier)
@@ skipping 360 matching lines @@
     },
 
     _emptyData: function()
     {
         return {};
     },
 
     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
 }