DevTools: Prepare for recursive viewport in datagrid

Source/devtools/front_end/HeapSnapshotDataGrids.js

 /*
  * Copyright (C) 2012 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 204 matching lines @@
             if (!sortFields[3])
                 result = -result;
             return result;
         }
         this._performSorting(SortByTwoFields);
     },
 
     _performSorting: function(sortFunction)
     {
         this.recursiveSortingEnter();
-        var children = this.rootNode()._allChildNodes;
+        var children = this.allChildren(this.rootNode());
         this.rootNode().removeChildren();
         children.sort(sortFunction);
         for (var i = 0, l = children.length; i < l; ++i) {
             var child = children[i];
             this.appendChildAfterSorting(child);
             if (child.expanded)
                 child.sort();
         }
         this.updateVisibleNodes();
         this.recursiveSortingLeave();
     },
 
     appendChildAfterSorting: function(child)
     {
         var revealed = child.revealed;
         this.rootNode().appendChild(child);
         child.revealed = revealed;
     },
 
-    updateVisibleNodes: function()
-    {
-    },
-
     recursiveSortingEnter: function()
     {
         ++this._recursiveSortingDepth;
     },
 
     recursiveSortingLeave: function()
     {
         if (!this._recursiveSortingDepth)
             return;
         if (!--this._recursiveSortingDepth)
             this.dispatchEventToListeners("sorting complete");
     },
 
+    updateVisibleNodes: function()
+    {
+    },
+
+    /**
+     * @param {!WebInspector.DataGridNode} parent
+     * @return {!Array.<!WebInspector.HeapSnapshotGridNode>}
+     */
+    allChildren: function(parent)
+    {
+        return parent.children;
+    },
+
+    /**
+     * @param {!WebInspector.DataGridNode} parent
+     * @param {!WebInspector.DataGridNode} node
+     * @param {number} index
+     */
+    insertChild: function(parent, node, index)
+    {
+        parent.insertChild(node, index);
+    },
+
+    /**
+     * @param {!WebInspector.HeapSnapshotGridNode} parent
+     * @param {number} index
+     */
+    removeChildByIndex: function(parent, index)
+    {
+        parent.removeChild(parent.children[index]);
+    },
+
+    /**
+     * @param {!WebInspector.HeapSnapshotGridNode} parent
+     */
+    removeAllChildren: function(parent)
+    {
+        parent.removeChildren();
+    },
+
     __proto__: WebInspector.DataGrid.prototype
 }
 
 
-
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotSortableDataGrid}
  */
 WebInspector.HeapSnapshotViewportDataGrid = function(columns)
 {
     WebInspector.HeapSnapshotSortableDataGrid.call(this, columns);
     this.scrollContainer.addEventListener("scroll", this._onScroll.bind(this), true);
     /**
      * @type {?WebInspector.HeapSnapshotGridNode}
      */
     this._nodeToHighlightAfterScroll = null;
+    this._topPadding = new WebInspector.HeapSnapshotPaddingNode();
+    this.dataTableBody.insertBefore(this._topPadding.element, this.dataTableBody.firstChild);
+    this._bottomPadding = new WebInspector.HeapSnapshotPaddingNode();
+    this.dataTableBody.insertBefore(this._bottomPadding.element, this.dataTableBody.lastChild);
 }
 
 WebInspector.HeapSnapshotViewportDataGrid.prototype = {
     /**
      * @return {!Array.<!WebInspector.HeapSnapshotGridNode>}
      */
     topLevelNodes: function()
     {
-        return this._allChildrenForNode(this.rootNode());
+        return this.allChildren(this.rootNode());
     },
 
     appendChildAfterSorting: function(child)
     {
         // Do nothing here, it will be added in updateVisibleNodes.
     },
 
     updateVisibleNodes: function()
     {
         var scrollTop = this.scrollContainer.scrollTop;
@@ skipping 15 matching lines @@
     /**
      * @param {!WebInspector.DataGridNode} parentNode
      * @param {number} firstVisibleNodeIndex
      * @param {number} firstNodeHiddenHeight
      * @param {number} topPadding
      */
     _addVisibleNodes: function(parentNode, firstVisibleNodeIndex, firstNodeHiddenHeight, topPadding)
     {
         var viewPortHeight = this.scrollContainer.offsetHeight;
 
-        var children = parentNode._allChildNodes;
+        var children = this.allChildren(parentNode);
         var selectedNode = this.selectedNode;
 
         parentNode.removeChildren();
-        this._ensurePaddingRows(parentNode);
 
         // The height of the view port + invisible top part.
         var heightToFill = viewPortHeight + firstNodeHiddenHeight;
         var filledHeight = 0;
         var i = firstVisibleNodeIndex;
         while (i < children.length && filledHeight < heightToFill) {
             if (children[i].revealed) {
                 parentNode.appendChild(children[i]);
                 filledHeight += children[i].nodeHeight();
             }
             ++i;
         }
 
         var bottomPadding = 0;
         while (i < children.length) {
             bottomPadding += children[i].nodeHeight();
             ++i;
         }
 
-        this._updatePaddingRows(parentNode, topPadding, bottomPadding);
+        this._topPadding.setHeight(topPadding);
+        this._bottomPadding.setHeight(bottomPadding);
 
         if (selectedNode) {
             if (selectedNode.parent) {
                 selectedNode.select(true);
             } else {
                 // Keep selection even if the node is not in the current viewport.
                 this.selectedNode = selectedNode;
             }
         }
     },
 
     /**
      * @override
      * @return {?Element}
      */
     defaultAttachLocation: function()
     {
-        return this.rootNode()._bottomPadding.element;
+        return this._bottomPadding.element;
     },
 
     _revealTopLevelNode: function(nodeToReveal)
     {
-        var children = this.rootNode()._allChildNodes;
+        var children = this.allChildren(this.rootNode());
 
         var topPadding = 0;
         for (var i = 0; i < children.length; ++i) {
             if (children[i] === nodeToReveal)
                 break;
             if (children[i].revealed) {
                 var newTop = topPadding + children[i].nodeHeight();
                 topPadding = newTop;
             }
         }
 
         this._addVisibleNodes(this.rootNode(), i, 0, topPadding);
     },
 
     /**
-     * @param {!WebInspector.DataGridNode} node
+     * @param {!WebInspector.DataGridNode} parent
      * @return {!Array.<!WebInspector.DataGridNode>}
      */
-    _allChildrenForNode: function(node)
+    allChildren: function(parent)
     {
-        return node._allChildNodes || (node._allChildNodes = []);
+        return parent._allChildren || (parent._allChildren = []);
     },
 
     /**
      * @param {!WebInspector.DataGridNode} parent
      * @param {!WebInspector.DataGridNode} node
      */
     appendNode: function(parent, node)
     {
-        this._allChildrenForNode(parent).push(node);
+        this.allChildren(parent).push(node);
+    },
+
+    /**
+     * @param {!WebInspector.DataGridNode} parent
+     * @param {!WebInspector.DataGridNode} node
+     * @param {number} index
+     */
+    insertChild: function(parent, node, index)
+    {
+        this.allChildren(parent).splice(index, 0, node);
+    },
+
+    removeChildByIndex: function(parent, index)
+    {
+        this.allChildren(parent).splice(index, 1);
+    },
+
+    removeAllChildren: function(parent)
+    {
+        parent._allChildren = [];
     },
 
     removeTopLevelNodes: function()
     {
         this._disposeAllNodes();
         this.rootNode().removeChildren();
-        this.rootNode()._allChildNodes = [];
+        this.rootNode()._allChildren = [];
     },
 
     /**
      * @override
      * @param {!WebInspector.HeapSnapshotGridNode} node
      */
     highlightNode: function(node)
     {
         if (this._isScrolledIntoView(node.element))
             WebInspector.HeapSnapshotSortableDataGrid.prototype.highlightNode.call(this, node);
         else {
             node.element.scrollIntoViewIfNeeded(true);
             this._nodeToHighlightAfterScroll = node;
         }
     },
 
     /**
      * @param {!Element} element
      * @return {boolean}
      */
     _isScrolledIntoView: function(element)
     {
         var viewportTop = this.scrollContainer.scrollTop;
         var viewportBottom = viewportTop + this.scrollContainer.clientHeight;
         var elemTop = element.offsetTop
         var elemBottom = elemTop + element.offsetHeight;
         return elemBottom <= viewportBottom && elemTop >= viewportTop;
     },
 
-    /**
-     * @param {!WebInspector.DataGridNode} node
-     */
-    _ensurePaddingRows: function(node)
-    {
-        var parentElement = node == this.rootNode() ? this.dataTableBody : node.element;
-        if (!node._topPadding) {
-            node._topPadding = new WebInspector.HeapSnapshotPaddingNode();
-            parentElement.insertBefore(node._topPadding.element, parentElement.firstChild);
-        }
-        if (!node._bottomPadding) {
-            node._bottomPadding = new WebInspector.HeapSnapshotPaddingNode();
-            // At the root level lastChild is a filler node.
-            var insertLocation = node === this.rootNode() ? parentElement.lastChild : null;
-            parentElement.insertBefore(node._bottomPadding.element, insertLocation);
-        }
-    },
-
-    /**
-     * @param {!WebInspector.DataGridNode} node
-     * @param {number} top
-     * @param {number} bottom
-     */
-    _updatePaddingRows: function(node, top, bottom)
-    {
-        node._topPadding.setHeight(top);
-        node._bottomPadding.setHeight(bottom);
-    },
-
     onResize: function()
     {
         WebInspector.HeapSnapshotSortableDataGrid.prototype.onResize.call(this);
         this.updateVisibleNodes();
     },
 
     _onScroll: function(event)
     {
         this.updateVisibleNodes();
 
@@ skipping 594 matching lines @@
             urlElement.style.maxWidth = "75%";
             cell.insertBefore(urlElement, cell.firstChild);
         }
 
         return cell;
     },
 
     __proto__: WebInspector.DataGridNode.prototype
 }