DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/profiler/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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotGridNode = class extends WebInspector.DataGridNode {
+Profiler.HeapSnapshotGridNode = class extends UI.DataGridNode {
   /**
-   * @param {!WebInspector.HeapSnapshotSortableDataGrid} tree
+   * @param {!Profiler.HeapSnapshotSortableDataGrid} tree
    * @param {boolean} hasChildren
    */
   constructor(tree, hasChildren) {
     super(null, hasChildren);
     this._dataGrid = tree;
     this._instanceCount = 0;
 
     this._savedChildren = null;
     /**
      * List of position ranges for all visible nodes: [startPos1, endPos1),...,[startPosN, endPosN)
      * Position is an item position in the provider.
      */
     this._retrievedChildrenRanges = [];
 
     /**
-     * @type {?WebInspector.HeapSnapshotGridNode.ChildrenProvider}
+     * @type {?Profiler.HeapSnapshotGridNode.ChildrenProvider}
      */
     this._providerObject = null;
     this._reachableFromWindow = false;
   }
 
   /**
    * @param {!Array.<string>} fieldNames
-   * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
    */
   static createComparator(fieldNames) {
-    return /** @type {!WebInspector.HeapSnapshotCommon.ComparatorConfig} */ (
+    return /** @type {!Profiler.HeapSnapshotCommon.ComparatorConfig} */ (
         {fieldName1: fieldNames[0], ascending1: fieldNames[1], fieldName2: fieldNames[2], ascending2: fieldNames[3]});
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotSortableDataGrid}
+   * @return {!Profiler.HeapSnapshotSortableDataGrid}
    */
   heapSnapshotDataGrid() {
     return this._dataGrid;
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
+   * @return {!Profiler.HeapSnapshotGridNode.ChildrenProvider}
    */
   createProvider() {
     throw new Error('Not implemented.');
   }
 
   /**
-   * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+   * @return {?{snapshot:!Profiler.HeapSnapshotProxy, snapshotNodeIndex:number}}
    */
   retainersDataSource() {
     return null;
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
+   * @return {!Profiler.HeapSnapshotGridNode.ChildrenProvider}
    */
   _provider() {
     if (!this._providerObject)
       this._providerObject = this.createProvider();
     return this._providerObject;
   }
 
   /**
    * @override
    * @param {string} columnId
@@ skipping 24 matching lines @@
 
   dispose() {
     if (this._providerObject)
       this._providerObject.dispose();
     for (var node = this.children[0]; node; node = node.traverseNextNode(true, this, true))
       if (node.dispose)
         node.dispose();
   }
 
   /**
-   * @param {!WebInspector.Target} target
-   * @param {function(!WebInspector.RemoteObject)} callback
+   * @param {!SDK.Target} target
+   * @param {function(!SDK.RemoteObject)} callback
    * @param {string} objectGroupName
    */
   queryObjectContent(target, callback, objectGroupName) {
   }
 
   /**
    * @override
    */
   wasDetached() {
     this._dataGrid.nodeWasDetached(this);
   }
 
   /**
    * @param {number} num
    * @return {string}
    */
   _toPercentString(num) {
     return num.toFixed(0) + '\u2009%';  // \u2009 is a thin space.
   }
 
   /**
    * @param {number} distance
    * @return {string}
    */
   _toUIDistance(distance) {
-    var baseSystemDistance = WebInspector.HeapSnapshotCommon.baseSystemDistance;
-    return distance >= 0 && distance < baseSystemDistance ? WebInspector.UIString('%d', distance) :
-                                                            WebInspector.UIString('\u2212');
+    var baseSystemDistance = Profiler.HeapSnapshotCommon.baseSystemDistance;
+    return distance >= 0 && distance < baseSystemDistance ? Common.UIString('%d', distance) :
+                                                            Common.UIString('\u2212');
   }
 
   /**
-   * @return {!Array.<!WebInspector.DataGridNode>}
+   * @return {!Array.<!UI.DataGridNode>}
    */
   allChildren() {
     return this._dataGrid.allChildren(this);
   }
 
   /**
    * @param {number} index
    */
   removeChildByIndex(index) {
     this._dataGrid.removeChildByIndex(this, index);
   }
 
   /**
    * @param {number} nodePosition
-   * @return {?WebInspector.DataGridNode}
+   * @return {?UI.DataGridNode}
    */
   childForPosition(nodePosition) {
     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 = indexOfFirstChildInRange + nodePosition - range.from;
         return this.allChildren()[childIndex];
       }
       indexOfFirstChildInRange += range.to - range.from + 1;
@@ skipping 50 matching lines @@
    * @param {?number=} fromPosition
    * @param {?number=} toPosition
    * @param {function()=} afterPopulate
    */
   _populateChildren(fromPosition, toPosition, afterPopulate) {
     fromPosition = fromPosition || 0;
     toPosition = toPosition || fromPosition + this._dataGrid.defaultPopulateCount();
     var firstNotSerializedPosition = fromPosition;
 
     /**
-     * @this {WebInspector.HeapSnapshotGridNode}
+     * @this {Profiler.HeapSnapshotGridNode}
      */
     function serializeNextChunk() {
       if (firstNotSerializedPosition >= toPosition)
         return;
       var end = Math.min(firstNotSerializedPosition + this._dataGrid.defaultPopulateCount(), toPosition);
       this._provider().serializeItemsRange(firstNotSerializedPosition, end, childrenRetrieved.bind(this));
       firstNotSerializedPosition = end;
     }
 
     /**
-     * @this {WebInspector.HeapSnapshotGridNode}
+     * @this {Profiler.HeapSnapshotGridNode}
      */
     function insertRetrievedChild(item, insertionIndex) {
       if (this._savedChildren) {
         var hash = this._childHashForEntity(item);
         if (hash in this._savedChildren) {
           this._dataGrid.insertChild(this, this._savedChildren[hash], insertionIndex);
           return;
         }
       }
       this._dataGrid.insertChild(this, this._createChildNode(item), insertionIndex);
     }
 
     /**
-     * @this {WebInspector.HeapSnapshotGridNode}
+     * @this {Profiler.HeapSnapshotGridNode}
      */
     function insertShowMoreButton(from, to, insertionIndex) {
-      var button = new WebInspector.ShowMoreDataGridNode(
+      var button = new UI.ShowMoreDataGridNode(
           this._populateChildren.bind(this), from, to, this._dataGrid.defaultPopulateCount());
       this._dataGrid.insertChild(this, button, insertionIndex);
     }
 
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
-     * @this {WebInspector.HeapSnapshotGridNode}
+     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @this {Profiler.HeapSnapshotGridNode}
      */
     function childrenRetrieved(itemsRange) {
       var itemIndex = 0;
       var itemPosition = itemsRange.startPosition;
       var items = itemsRange.items;
       var insertionIndex = 0;
 
       if (!this._retrievedChildrenRanges.length) {
         if (itemsRange.startPosition > 0) {
           this._retrievedChildrenRanges.push({from: 0, to: 0});
@@ skipping 75 matching lines @@
       this._instanceCount += items.length;
       if (firstNotSerializedPosition < toPosition) {
         serializeNextChunk.call(this);
         return;
       }
 
       if (this.expanded)
         this._dataGrid.updateVisibleNodes(true);
       if (afterPopulate)
         afterPopulate();
-      this.dispatchEventToListeners(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete);
+      this.dispatchEventToListeners(Profiler.HeapSnapshotGridNode.Events.PopulateComplete);
     }
     serializeNextChunk.call(this);
   }
 
   _saveChildren() {
     this._savedChildren = null;
     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() {
     this._dataGrid.recursiveSortingEnter();
 
     /**
-     * @this {WebInspector.HeapSnapshotGridNode}
+     * @this {Profiler.HeapSnapshotGridNode}
      */
     function afterSort() {
       this._saveChildren();
       this._dataGrid.removeAllChildren(this);
       this._retrievedChildrenRanges = [];
 
       /**
-       * @this {WebInspector.HeapSnapshotGridNode}
+       * @this {Profiler.HeapSnapshotGridNode}
        */
       function afterPopulate() {
         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));
     }
 
     this._provider().sortAndRewind(this.comparator()).then(afterSort.bind(this));
   }
 };
 
 /** @enum {symbol} */
-WebInspector.HeapSnapshotGridNode.Events = {
+Profiler.HeapSnapshotGridNode.Events = {
   PopulateComplete: Symbol('PopulateComplete')
 };
 
 
 /**
  * @interface
  */
-WebInspector.HeapSnapshotGridNode.ChildrenProvider = function() {};
+Profiler.HeapSnapshotGridNode.ChildrenProvider = function() {};
 
-WebInspector.HeapSnapshotGridNode.ChildrenProvider.prototype = {
+Profiler.HeapSnapshotGridNode.ChildrenProvider.prototype = {
   dispose: function() {},
 
   /**
    * @param {number} snapshotObjectId
    * @return {!Promise<number>}
    */
   nodePosition: function(snapshotObjectId) {},
 
   /**
    * @param {function(boolean)} callback
    */
   isEmpty: function(callback) {},
 
   /**
    * @param {number} startPosition
    * @param {number} endPosition
-   * @param {function(!WebInspector.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
    */
   serializeItemsRange: function(startPosition, endPosition, callback) {},
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind: function(comparator) {}
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotGenericObjectNode = class extends WebInspector.HeapSnapshotGridNode {
+Profiler.HeapSnapshotGenericObjectNode = class extends Profiler.HeapSnapshotGridNode {
   /**
-   * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
-   * @param {!WebInspector.HeapSnapshotCommon.Node} node
+   * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotCommon.Node} node
    */
   constructor(dataGrid, node) {
     super(dataGrid, false);
     // node is null for DataGrid root nodes.
     if (!node)
       return;
     this._name = node.name;
     this._type = node.type;
     this._distance = node.distance;
     this._shallowSize = node.selfSize;
@@ skipping 17 matching lines @@
       'distance': this._toUIDistance(this._distance),
       'shallowSize': Number.withThousandsSeparator(this._shallowSize),
       'retainedSize': Number.withThousandsSeparator(this._retainedSize),
       'shallowSize-percent': this._toPercentString(shallowSizePercent),
       'retainedSize-percent': this._toPercentString(retainedSizePercent)
     };
   }
 
   /**
    * @override
-   * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+   * @return {?{snapshot:!Profiler.HeapSnapshotProxy, snapshotNodeIndex:number}}
    */
   retainersDataSource() {
     return {snapshot: this._dataGrid.snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
   }
 
   /**
    * @override
    * @param {string} columnId
    * @return {!Element}
    */
@@ skipping 68 matching lines @@
       cell.style.setProperty('padding-left', (this.depth * this.dataGrid.indentWidth) + 'px');
     cell.heapSnapshotNode = this;
     return cell;
   }
 
   _prefixObjectCell(div) {
   }
 
   /**
    * @override
-   * @param {!WebInspector.Target} target
-   * @param {function(!WebInspector.RemoteObject)} callback
+   * @param {!SDK.Target} target
+   * @param {function(!SDK.RemoteObject)} callback
    * @param {string} objectGroupName
    */
   queryObjectContent(target, callback, objectGroupName) {
     /**
      * @param {?Protocol.Error} error
      * @param {!Protocol.Runtime.RemoteObject} object
      */
     function formatResult(error, object) {
       if (!error && object.type)
         callback(target.runtimeModel.createRemoteObject(object));
       else
         callback(target.runtimeModel.createRemoteObjectFromPrimitiveValue(
-            WebInspector.UIString('Preview is not available')));
+            Common.UIString('Preview is not available')));
     }
 
     if (this._type === 'string')
       callback(target.runtimeModel.createRemoteObjectFromPrimitiveValue(this._name));
     else
       target.heapProfilerAgent().getObjectByHeapObjectId(String(this.snapshotNodeId), objectGroupName, formatResult);
   }
 
   updateHasChildren() {
     /**
-     * @this {WebInspector.HeapSnapshotGenericObjectNode}
+     * @this {Profiler.HeapSnapshotGenericObjectNode}
      */
     function isEmptyCallback(isEmpty) {
       this.hasChildren = !isEmpty;
     }
     this._provider().isEmpty(isEmptyCallback.bind(this));
   }
 
   /**
    * @param {string} fullName
    * @param {boolean} hasObjectId
    * @return {string}
    */
   shortenWindowURL(fullName, hasObjectId) {
     var startPos = fullName.indexOf('/');
     var endPos = hasObjectId ? fullName.indexOf('@') : fullName.length;
     if (startPos !== -1 && endPos !== -1) {
       var fullURL = fullName.substring(startPos + 1, endPos).trimLeft();
       var url = fullURL.trimURL();
       if (url.length > 40)
         url = url.trimMiddle(40);
       return fullName.substr(0, startPos + 2) + url + fullName.substr(endPos);
     } else
       return fullName;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotObjectNode = class extends WebInspector.HeapSnapshotGenericObjectNode {
+Profiler.HeapSnapshotObjectNode = class extends Profiler.HeapSnapshotGenericObjectNode {
   /**
-   * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
-   * @param {!WebInspector.HeapSnapshotProxy} snapshot
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
-   * @param {?WebInspector.HeapSnapshotObjectNode} parentObjectNode
+   * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotProxy} snapshot
+   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {?Profiler.HeapSnapshotObjectNode} parentObjectNode
    */
   constructor(dataGrid, snapshot, edge, parentObjectNode) {
     super(dataGrid, edge.node);
     this._referenceName = edge.name;
     this._referenceType = edge.type;
     this._edgeIndex = edge.edgeIndex;
     this._snapshot = snapshot;
 
     this._parentObjectNode = parentObjectNode;
     this._cycledWithAncestorGridNode = this._findAncestorWithSameSnapshotNodeId();
     if (!this._cycledWithAncestorGridNode)
       this.updateHasChildren();
 
     var data = this.data;
     data['count'] = '';
     data['addedCount'] = '';
     data['removedCount'] = '';
     data['countDelta'] = '';
     data['addedSize'] = '';
     data['removedSize'] = '';
     data['sizeDelta'] = '';
   }
 
   /**
    * @override
-   * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+   * @return {?{snapshot:!Profiler.HeapSnapshotProxy, snapshotNodeIndex:number}}
    */
   retainersDataSource() {
     return {snapshot: this._snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
   }
 
   /**
    * @override
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._snapshot.createEdgesProvider(this.snapshotNodeIndex);
   }
 
   _findAncestorWithSameSnapshotNodeId() {
     var ancestor = this._parentObjectNode;
     while (ancestor) {
       if (ancestor.snapshotNodeId === this.snapshotNodeId)
         return ancestor;
       ancestor = ancestor._parentObjectNode;
     }
     return null;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} item
-   * @return {!WebInspector.HeapSnapshotObjectNode}
+   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @return {!Profiler.HeapSnapshotObjectNode}
    */
   _createChildNode(item) {
-    return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._snapshot, item, this);
+    return new Profiler.HeapSnapshotObjectNode(this._dataGrid, this._snapshot, item, this);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
+   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
    * @return {number}
    */
   _childHashForEntity(edge) {
     return edge.edgeIndex;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotObjectNode} childNode
+   * @param {!Profiler.HeapSnapshotObjectNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode._edgeIndex;
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
    */
   comparator() {
     var sortAscending = this._dataGrid.isSortOrderAscending();
     var sortColumnId = this._dataGrid.sortColumnId();
     var sortFields = {
       object: ['!edgeName', sortAscending, 'retainedSize', false],
       count: ['!edgeName', true, 'retainedSize', false],
       shallowSize: ['selfSize', sortAscending, '!edgeName', true],
       retainedSize: ['retainedSize', sortAscending, '!edgeName', true],
       distance: ['distance', sortAscending, '_name', true]
     }[sortColumnId] ||
         ['!edgeName', true, 'retainedSize', false];
-    return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
+    return Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 
   /**
    * @override
    */
   _prefixObjectCell(div) {
     var name = this._referenceName || '(empty)';
     var nameClass = 'name';
     switch (this._referenceType) {
       case 'context':
@@ skipping 27 matching lines @@
    * @return {string}
    */
   _edgeNodeSeparator() {
     return ' :: ';
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotRetainingObjectNode = class extends WebInspector.HeapSnapshotObjectNode {
+Profiler.HeapSnapshotRetainingObjectNode = class extends Profiler.HeapSnapshotObjectNode {
   /**
-   * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
-   * @param {!WebInspector.HeapSnapshotProxy} snapshot
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
-   * @param {?WebInspector.HeapSnapshotRetainingObjectNode} parentRetainingObjectNode
+   * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotProxy} snapshot
+   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {?Profiler.HeapSnapshotRetainingObjectNode} parentRetainingObjectNode
    */
   constructor(dataGrid, snapshot, edge, parentRetainingObjectNode) {
     super(dataGrid, snapshot, edge, parentRetainingObjectNode);
   }
 
   /**
    * @override
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._snapshot.createRetainingEdgesProvider(this.snapshotNodeIndex);
   }
 
   /**
    * @override
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} item
-   * @return {!WebInspector.HeapSnapshotRetainingObjectNode}
+   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @return {!Profiler.HeapSnapshotRetainingObjectNode}
    */
   _createChildNode(item) {
-    return new WebInspector.HeapSnapshotRetainingObjectNode(this._dataGrid, this._snapshot, item, this);
+    return new Profiler.HeapSnapshotRetainingObjectNode(this._dataGrid, this._snapshot, item, this);
   }
 
   /**
    * @override
    * @return {string}
    */
   _edgeNodeSeparator() {
     return ' in ';
   }
 
   /**
    * @override
    */
   expand() {
     this._expandRetainersChain(20);
   }
 
   /**
    * @param {number} maxExpandLevels
    */
   _expandRetainersChain(maxExpandLevels) {
     /**
-     * @this {!WebInspector.HeapSnapshotRetainingObjectNode}
+     * @this {!Profiler.HeapSnapshotRetainingObjectNode}
      */
     function populateComplete() {
-      this.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+      this.removeEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
       this._expandRetainersChain(maxExpandLevels);
     }
 
     if (!this._populated) {
-      this.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+      this.addEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
       this.populate();
       return;
     }
     super.expand();
     if (--maxExpandLevels > 0 && this.children.length > 0) {
       var retainer = this.children[0];
       if (retainer._distance > 1) {
         retainer._expandRetainersChain(maxExpandLevels);
         return;
       }
     }
-    this._dataGrid.dispatchEventToListeners(WebInspector.HeapSnapshotRetainmentDataGrid.Events.ExpandRetainersComplete);
+    this._dataGrid.dispatchEventToListeners(Profiler.HeapSnapshotRetainmentDataGrid.Events.ExpandRetainersComplete);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotInstanceNode = class extends WebInspector.HeapSnapshotGenericObjectNode {
+Profiler.HeapSnapshotInstanceNode = class extends Profiler.HeapSnapshotGenericObjectNode {
   /**
-   * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
-   * @param {!WebInspector.HeapSnapshotProxy} snapshot
-   * @param {!WebInspector.HeapSnapshotCommon.Node} node
+   * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotProxy} snapshot
+   * @param {!Profiler.HeapSnapshotCommon.Node} node
    * @param {boolean} isDeletedNode
    */
   constructor(dataGrid, snapshot, node, isDeletedNode) {
     super(dataGrid, node);
     this._baseSnapshotOrSnapshot = snapshot;
     this._isDeletedNode = isDeletedNode;
     this.updateHasChildren();
 
     var data = this.data;
     data['count'] = '';
     data['countDelta'] = '';
     data['sizeDelta'] = '';
     if (this._isDeletedNode) {
       data['addedCount'] = '';
       data['addedSize'] = '';
       data['removedCount'] = '\u2022';
       data['removedSize'] = Number.withThousandsSeparator(this._shallowSize);
     } else {
       data['addedCount'] = '\u2022';
       data['addedSize'] = Number.withThousandsSeparator(this._shallowSize);
       data['removedCount'] = '';
       data['removedSize'] = '';
     }
   }
 
   /**
    * @override
-   * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+   * @return {?{snapshot:!Profiler.HeapSnapshotProxy, snapshotNodeIndex:number}}
    */
   retainersDataSource() {
     return {snapshot: this._baseSnapshotOrSnapshot, snapshotNodeIndex: this.snapshotNodeIndex};
   }
 
   /**
    * @override
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._baseSnapshotOrSnapshot.createEdgesProvider(this.snapshotNodeIndex);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} item
-   * @return {!WebInspector.HeapSnapshotObjectNode}
+   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @return {!Profiler.HeapSnapshotObjectNode}
    */
   _createChildNode(item) {
-    return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._baseSnapshotOrSnapshot, item, null);
+    return new Profiler.HeapSnapshotObjectNode(this._dataGrid, this._baseSnapshotOrSnapshot, item, null);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
+   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
    * @return {number}
    */
   _childHashForEntity(edge) {
     return edge.edgeIndex;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotObjectNode} childNode
+   * @param {!Profiler.HeapSnapshotObjectNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode._edgeIndex;
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
    */
   comparator() {
     var sortAscending = this._dataGrid.isSortOrderAscending();
     var sortColumnId = this._dataGrid.sortColumnId();
     var sortFields = {
       object: ['!edgeName', sortAscending, 'retainedSize', false],
       distance: ['distance', sortAscending, 'retainedSize', false],
       count: ['!edgeName', true, 'retainedSize', false],
       addedSize: ['selfSize', sortAscending, '!edgeName', true],
       removedSize: ['selfSize', sortAscending, '!edgeName', true],
       shallowSize: ['selfSize', sortAscending, '!edgeName', true],
       retainedSize: ['retainedSize', sortAscending, '!edgeName', true]
     }[sortColumnId] ||
         ['!edgeName', true, 'retainedSize', false];
-    return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
+    return Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotConstructorNode = class extends WebInspector.HeapSnapshotGridNode {
+Profiler.HeapSnapshotConstructorNode = class extends Profiler.HeapSnapshotGridNode {
   /**
-   * @param {!WebInspector.HeapSnapshotConstructorsDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotConstructorsDataGrid} dataGrid
    * @param {string} className
-   * @param {!WebInspector.HeapSnapshotCommon.Aggregate} aggregate
-   * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} nodeFilter
+   * @param {!Profiler.HeapSnapshotCommon.Aggregate} aggregate
+   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} nodeFilter
    */
   constructor(dataGrid, className, aggregate, nodeFilter) {
     super(dataGrid, aggregate.count > 0);
     this._name = className;
     this._nodeFilter = nodeFilter;
     this._distance = aggregate.distance;
     this._count = aggregate.count;
     this._shallowSize = aggregate.self;
     this._retainedSize = aggregate.maxRet;
 
     var snapshot = dataGrid.snapshot;
     var countPercent = this._count / snapshot.nodeCount * 100.0;
     var retainedSizePercent = this._retainedSize / snapshot.totalSize * 100.0;
     var shallowSizePercent = this._shallowSize / snapshot.totalSize * 100.0;
 
     this.data = {
       'object': className,
       'count': Number.withThousandsSeparator(this._count),
       'distance': this._toUIDistance(this._distance),
       'shallowSize': Number.withThousandsSeparator(this._shallowSize),
       'retainedSize': Number.withThousandsSeparator(this._retainedSize),
       'count-percent': this._toPercentString(countPercent),
       'shallowSize-percent': this._toPercentString(shallowSizePercent),
       'retainedSize-percent': this._toPercentString(retainedSizePercent)
     };
   }
 
   /**
    * @override
-   * @return {!WebInspector.HeapSnapshotProviderProxy}
+   * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._dataGrid.snapshot.createNodesProviderForClass(this._name, this._nodeFilter);
   }
 
   /**
    * @param {number} snapshotObjectId
-   * @return {!Promise<!Array<!WebInspector.HeapSnapshotGridNode>>}
+   * @return {!Promise<!Array<!Profiler.HeapSnapshotGridNode>>}
    */
   populateNodeBySnapshotObjectId(snapshotObjectId) {
     /**
-     * @this {WebInspector.HeapSnapshotConstructorNode}
+     * @this {Profiler.HeapSnapshotConstructorNode}
      */
     function didExpand() {
       return this._provider().nodePosition(snapshotObjectId).then(didGetNodePosition.bind(this));
     }
 
     /**
-     * @this {WebInspector.HeapSnapshotConstructorNode}
+     * @this {Profiler.HeapSnapshotConstructorNode}
      * @param {number} nodePosition
-     * @return {!Promise<!Array<!WebInspector.HeapSnapshotGridNode>>}
+     * @return {!Promise<!Array<!Profiler.HeapSnapshotGridNode>>}
      */
     function didGetNodePosition(nodePosition) {
       if (nodePosition === -1) {
         this.collapse();
         return Promise.resolve([]);
       } else {
         /**
-         * @param {function(!Array<!WebInspector.HeapSnapshotGridNode>)} fulfill
-         * @this {WebInspector.HeapSnapshotConstructorNode}
+         * @param {function(!Array<!Profiler.HeapSnapshotGridNode>)} fulfill
+         * @this {Profiler.HeapSnapshotConstructorNode}
          */
         function action(fulfill) {
           this._populateChildren(nodePosition, null, didPopulateChildren.bind(this, nodePosition, fulfill));
         }
         return new Promise(action.bind(this));
       }
     }
 
     /**
-     * @this {WebInspector.HeapSnapshotConstructorNode}
+     * @this {Profiler.HeapSnapshotConstructorNode}
      * @param {number} nodePosition
-     * @param {function(!Array<!WebInspector.HeapSnapshotGridNode>)} callback
+     * @param {function(!Array<!Profiler.HeapSnapshotGridNode>)} callback
      */
     function didPopulateChildren(nodePosition, callback) {
-      var node = /** @type {?WebInspector.HeapSnapshotGridNode} */ (this.childForPosition(nodePosition));
+      var node = /** @type {?Profiler.HeapSnapshotGridNode} */ (this.childForPosition(nodePosition));
       callback(node ? [this, node] : []);
     }
 
     this._dataGrid.resetNameFilter();
     return this.expandWithoutPopulate().then(didExpand.bind(this));
   }
 
   /**
    * @param {string} filterValue
    * @return {boolean}
    */
   filteredOut(filterValue) {
     return this._name.toLowerCase().indexOf(filterValue) === -1;
   }
 
   /**
    * @override
    * @param {string} columnId
    * @return {!Element}
    */
   createCell(columnId) {
     var cell = columnId !== 'object' ? this._createValueCell(columnId) : super.createCell(columnId);
     if (this._searchMatched)
       cell.classList.add('highlight');
     return cell;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Node} item
-   * @return {!WebInspector.HeapSnapshotInstanceNode}
+   * @param {!Profiler.HeapSnapshotCommon.Node} item
+   * @return {!Profiler.HeapSnapshotInstanceNode}
    */
   _createChildNode(item) {
-    return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
+    return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
    */
   comparator() {
     var sortAscending = this._dataGrid.isSortOrderAscending();
     var sortColumnId = this._dataGrid.sortColumnId();
     var sortFields = {
       object: ['name', sortAscending, 'id', true],
       distance: ['distance', sortAscending, 'retainedSize', false],
       count: ['name', true, 'id', true],
       shallowSize: ['selfSize', sortAscending, 'id', true],
       retainedSize: ['retainedSize', sortAscending, 'id', true]
     }[sortColumnId];
-    return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
+    return Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Node} node
+   * @param {!Profiler.HeapSnapshotCommon.Node} node
    * @return {number}
    */
   _childHashForEntity(node) {
     return node.id;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotInstanceNode} childNode
+   * @param {!Profiler.HeapSnapshotInstanceNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode.snapshotNodeId;
   }
 };
 
 /**
- * @implements {WebInspector.HeapSnapshotGridNode.ChildrenProvider}
+ * @implements {Profiler.HeapSnapshotGridNode.ChildrenProvider}
  * @unrestricted
  */
-WebInspector.HeapSnapshotDiffNodesProvider = class {
+Profiler.HeapSnapshotDiffNodesProvider = class {
   /**
-   * @param {!WebInspector.HeapSnapshotProviderProxy} addedNodesProvider
-   * @param {!WebInspector.HeapSnapshotProviderProxy} deletedNodesProvider
+   * @param {!Profiler.HeapSnapshotProviderProxy} addedNodesProvider
+   * @param {!Profiler.HeapSnapshotProviderProxy} deletedNodesProvider
    * @param {number} addedCount
    * @param {number} removedCount
    */
   constructor(addedNodesProvider, deletedNodesProvider, addedCount, removedCount) {
     this._addedNodesProvider = addedNodesProvider;
     this._deletedNodesProvider = deletedNodesProvider;
     this._addedCount = addedCount;
     this._removedCount = removedCount;
   }
 
@@ skipping 19 matching lines @@
    * @param {function(boolean)} callback
    */
   isEmpty(callback) {
     callback(false);
   }
 
   /**
    * @override
    * @param {number} beginPosition
    * @param {number} endPosition
-   * @param {function(!WebInspector.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
    */
   serializeItemsRange(beginPosition, endPosition, callback) {
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} items
-     * @this {WebInspector.HeapSnapshotDiffNodesProvider}
+     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} items
+     * @this {Profiler.HeapSnapshotDiffNodesProvider}
      */
     function didReceiveAllItems(items) {
       items.totalLength = this._addedCount + this._removedCount;
       callback(items);
     }
 
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} addedItems
-     * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
-     * @this {WebInspector.HeapSnapshotDiffNodesProvider}
+     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} addedItems
+     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @this {Profiler.HeapSnapshotDiffNodesProvider}
      */
     function didReceiveDeletedItems(addedItems, itemsRange) {
       var items = itemsRange.items;
       if (!addedItems.items.length)
         addedItems.startPosition = this._addedCount + itemsRange.startPosition;
       for (var i = 0; i < items.length; i++) {
         items[i].isAddedNotRemoved = false;
         addedItems.items.push(items[i]);
       }
       addedItems.endPosition = this._addedCount + itemsRange.endPosition;
       didReceiveAllItems.call(this, addedItems);
     }
 
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
-     * @this {WebInspector.HeapSnapshotDiffNodesProvider}
+     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @this {Profiler.HeapSnapshotDiffNodesProvider}
      */
     function didReceiveAddedItems(itemsRange) {
       var items = itemsRange.items;
       for (var i = 0; i < items.length; i++)
         items[i].isAddedNotRemoved = true;
       if (itemsRange.endPosition < endPosition)
         return this._deletedNodesProvider.serializeItemsRange(
             0, endPosition - itemsRange.endPosition, didReceiveDeletedItems.bind(this, itemsRange));
 
       itemsRange.totalLength = this._addedCount + this._removedCount;
       didReceiveAllItems.call(this, itemsRange);
     }
 
     if (beginPosition < this._addedCount) {
       this._addedNodesProvider.serializeItemsRange(beginPosition, endPosition, didReceiveAddedItems.bind(this));
     } else {
-      var emptyRange = new WebInspector.HeapSnapshotCommon.ItemsRange(0, 0, 0, []);
+      var emptyRange = new Profiler.HeapSnapshotCommon.ItemsRange(0, 0, 0, []);
       this._deletedNodesProvider.serializeItemsRange(
           beginPosition - this._addedCount, endPosition - this._addedCount,
           didReceiveDeletedItems.bind(this, emptyRange));
     }
   }
 
   /**
    * @override
-   * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind(comparator) {
     /**
-     * @this {WebInspector.HeapSnapshotDiffNodesProvider}
+     * @this {Profiler.HeapSnapshotDiffNodesProvider}
      * @return {!Promise<?>}
      */
     function afterSort() {
       return this._deletedNodesProvider.sortAndRewind(comparator);
     }
     return this._addedNodesProvider.sortAndRewind(comparator).then(afterSort.bind(this));
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.HeapSnapshotDiffNode = class extends WebInspector.HeapSnapshotGridNode {
+Profiler.HeapSnapshotDiffNode = class extends Profiler.HeapSnapshotGridNode {
   /**
-   * @param {!WebInspector.HeapSnapshotDiffDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotDiffDataGrid} dataGrid
    * @param {string} className
-   * @param {!WebInspector.HeapSnapshotCommon.DiffForClass} diffForClass
+   * @param {!Profiler.HeapSnapshotCommon.DiffForClass} diffForClass
    */
   constructor(dataGrid, className, diffForClass) {
     super(dataGrid, true);
     this._name = className;
     this._addedCount = diffForClass.addedCount;
     this._removedCount = diffForClass.removedCount;
     this._countDelta = diffForClass.countDelta;
     this._addedSize = diffForClass.addedSize;
     this._removedSize = diffForClass.removedSize;
     this._sizeDelta = diffForClass.sizeDelta;
     this._deletedIndexes = diffForClass.deletedIndexes;
     this.data = {
       'object': className,
       'addedCount': Number.withThousandsSeparator(this._addedCount),
       'removedCount': Number.withThousandsSeparator(this._removedCount),
       'countDelta': this._signForDelta(this._countDelta) + Number.withThousandsSeparator(Math.abs(this._countDelta)),
       'addedSize': Number.withThousandsSeparator(this._addedSize),
       'removedSize': Number.withThousandsSeparator(this._removedSize),
       'sizeDelta': this._signForDelta(this._sizeDelta) + Number.withThousandsSeparator(Math.abs(this._sizeDelta))
     };
   }
 
   /**
    * @override
-   * @return {!WebInspector.HeapSnapshotDiffNodesProvider}
+   * @return {!Profiler.HeapSnapshotDiffNodesProvider}
    */
   createProvider() {
     var tree = this._dataGrid;
-    return new WebInspector.HeapSnapshotDiffNodesProvider(
+    return new Profiler.HeapSnapshotDiffNodesProvider(
         tree.snapshot.createAddedNodesProvider(tree.baseSnapshot.uid, this._name),
         tree.baseSnapshot.createDeletedNodesProvider(this._deletedIndexes), this._addedCount, this._removedCount);
   }
 
   /**
    * @override
    * @param {string} columnId
    * @return {!Element}
    */
   createCell(columnId) {
     var cell = super.createCell(columnId);
     if (columnId !== 'object')
       cell.classList.add('numeric-column');
     return cell;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Node} item
-   * @return {!WebInspector.HeapSnapshotInstanceNode}
+   * @param {!Profiler.HeapSnapshotCommon.Node} item
+   * @return {!Profiler.HeapSnapshotInstanceNode}
    */
   _createChildNode(item) {
     if (item.isAddedNotRemoved)
-      return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
+      return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
     else
-      return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, item, true);
+      return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, item, true);
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotCommon.Node} node
+   * @param {!Profiler.HeapSnapshotCommon.Node} node
    * @return {number}
    */
   _childHashForEntity(node) {
     return node.id;
   }
 
   /**
-   * @param {!WebInspector.HeapSnapshotInstanceNode} childNode
+   * @param {!Profiler.HeapSnapshotInstanceNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode.snapshotNodeId;
   }
 
   /**
-   * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
    */
   comparator() {
     var sortAscending = this._dataGrid.isSortOrderAscending();
     var sortColumnId = this._dataGrid.sortColumnId();
     var sortFields = {
       object: ['name', sortAscending, 'id', true],
       addedCount: ['name', true, 'id', true],
       removedCount: ['name', true, 'id', true],
       countDelta: ['name', true, 'id', true],
       addedSize: ['selfSize', sortAscending, 'id', true],
       removedSize: ['selfSize', sortAscending, 'id', true],
       sizeDelta: ['selfSize', sortAscending, 'id', true]
     }[sortColumnId];
-    return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
+    return Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 
   /**
    * @param {string} filterValue
    * @return {boolean}
    */
   filteredOut(filterValue) {
     return this._name.toLowerCase().indexOf(filterValue) === -1;
   }
 
   _signForDelta(delta) {
     if (delta === 0)
       return '';
     if (delta > 0)
       return '+';
     else
       return '\u2212';  // Math minus sign, same width as plus.
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AllocationGridNode = class extends WebInspector.HeapSnapshotGridNode {
+Profiler.AllocationGridNode = class extends Profiler.HeapSnapshotGridNode {
   /**
-   * @param {!WebInspector.AllocationDataGrid} dataGrid
-   * @param {!WebInspector.HeapSnapshotCommon.SerializedAllocationNode} data
+   * @param {!Profiler.AllocationDataGrid} dataGrid
+   * @param {!Profiler.HeapSnapshotCommon.SerializedAllocationNode} data
    */
   constructor(dataGrid, data) {
     super(dataGrid, data.hasChildren);
     this._populated = false;
     this._allocationNode = data;
     this.data = {
       'liveCount': Number.withThousandsSeparator(data.liveCount),
       'count': Number.withThousandsSeparator(data.count),
       'liveSize': Number.withThousandsSeparator(data.liveSize),
       'size': Number.withThousandsSeparator(data.size),
       'name': data.name
     };
   }
 
   /**
    * @override
    */
   populate() {
     if (this._populated)
       return;
     this._populated = true;
     this._dataGrid.snapshot.allocationNodeCallers(this._allocationNode.id, didReceiveCallers.bind(this));
 
     /**
-     * @param {!WebInspector.HeapSnapshotCommon.AllocationNodeCallers} callers
-     * @this {WebInspector.AllocationGridNode}
+     * @param {!Profiler.HeapSnapshotCommon.AllocationNodeCallers} callers
+     * @this {Profiler.AllocationGridNode}
      */
     function didReceiveCallers(callers) {
       var callersChain = callers.nodesWithSingleCaller;
       var parentNode = this;
-      var dataGrid = /** @type {!WebInspector.AllocationDataGrid} */ (this._dataGrid);
+      var dataGrid = /** @type {!Profiler.AllocationDataGrid} */ (this._dataGrid);
       for (var i = 0; i < callersChain.length; i++) {
-        var child = new WebInspector.AllocationGridNode(dataGrid, callersChain[i]);
+        var child = new Profiler.AllocationGridNode(dataGrid, callersChain[i]);
         dataGrid.appendNode(parentNode, child);
         parentNode = child;
         parentNode._populated = true;
         if (this.expanded)
           parentNode.expand();
       }
 
       var callersBranch = callers.branchingCallers;
       callersBranch.sort(this._dataGrid._createComparator());
       for (var i = 0; i < callersBranch.length; i++)
-        dataGrid.appendNode(parentNode, new WebInspector.AllocationGridNode(dataGrid, callersBranch[i]));
+        dataGrid.appendNode(parentNode, new Profiler.AllocationGridNode(dataGrid, callersBranch[i]));
       dataGrid.updateVisibleNodes(true);
     }
   }
 
   /**
    * @override
    */
   expand() {
     super.expand();
     if (this.children.length === 1)
@@ skipping 23 matching lines @@
     return cell;
   }
 
   /**
    * @return {number}
    */
   allocationNodeId() {
     return this._allocationNode.id;
   }
 };