DevTools: Extract HeapSnapshotCommon.js into HeapSnapshotModel module

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 39 matching lines @@
 
     /**
      * @type {?Profiler.HeapSnapshotGridNode.ChildrenProvider}
      */
     this._providerObject = null;
     this._reachableFromWindow = false;
   }
 
   /**
    * @param {!Array.<string>} fieldNames
-   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!HeapSnapshotModel.ComparatorConfig}
    */
   static createComparator(fieldNames) {
-    return /** @type {!Profiler.HeapSnapshotCommon.ComparatorConfig} */ (
+    return /** @type {!HeapSnapshotModel.ComparatorConfig} */ (
         {fieldName1: fieldNames[0], ascending1: fieldNames[1], fieldName2: fieldNames[2], ascending2: fieldNames[3]});
   }
 
   /**
    * @return {!Profiler.HeapSnapshotSortableDataGrid}
    */
   heapSnapshotDataGrid() {
     return this._dataGrid;
   }
 
@@ skipping 78 matching lines @@
    */
   _toPercentString(num) {
     return num.toFixed(0) + '\u2009%';  // \u2009 is a thin space.
   }
 
   /**
    * @param {number} distance
    * @return {string}
    */
   _toUIDistance(distance) {
-    var baseSystemDistance = Profiler.HeapSnapshotCommon.baseSystemDistance;
+    var baseSystemDistance = HeapSnapshotModel.baseSystemDistance;
     return distance >= 0 && distance < baseSystemDistance ? Common.UIString('%d', distance) : Common.UIString('\u2212');
   }
 
   /**
    * @return {!Array.<!DataGrid.DataGridNode>}
    */
   allChildren() {
     return this._dataGrid.allChildren(this);
   }
 
@@ skipping 104 matching lines @@
     /**
      * @this {Profiler.HeapSnapshotGridNode}
      */
     function insertShowMoreButton(from, to, insertionIndex) {
       var button = new DataGrid.ShowMoreDataGridNode(
           this._populateChildren.bind(this), from, to, this._dataGrid.defaultPopulateCount());
       this._dataGrid.insertChild(this, button, insertionIndex);
     }
 
     /**
-     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @param {!HeapSnapshotModel.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) {
@@ skipping 154 matching lines @@
   nodePosition(snapshotObjectId) {},
 
   /**
    * @param {function(boolean)} callback
    */
   isEmpty(callback) {},
 
   /**
    * @param {number} startPosition
    * @param {number} endPosition
-   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!HeapSnapshotModel.ItemsRange)} callback
    */
   serializeItemsRange(startPosition, endPosition, callback) {},
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!HeapSnapshotModel.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind(comparator) {}
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotGenericObjectNode = class extends Profiler.HeapSnapshotGridNode {
   /**
    * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
-   * @param {!Profiler.HeapSnapshotCommon.Node} node
+   * @param {!HeapSnapshotModel.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 166 matching lines @@
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotObjectNode = class extends Profiler.HeapSnapshotGenericObjectNode {
   /**
    * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
    * @param {!Profiler.HeapSnapshotProxy} snapshot
-   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {!HeapSnapshotModel.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;
@@ skipping 31 matching lines @@
     var ancestor = this._parentObjectNode;
     while (ancestor) {
       if (ancestor.snapshotNodeId === this.snapshotNodeId)
         return ancestor;
       ancestor = ancestor._parentObjectNode;
     }
     return null;
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @param {!HeapSnapshotModel.Edge} item
    * @return {!Profiler.HeapSnapshotObjectNode}
    */
   _createChildNode(item) {
     return new Profiler.HeapSnapshotObjectNode(this._dataGrid, this._snapshot, item, this);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {!HeapSnapshotModel.Edge} edge
    * @return {number}
    */
   _childHashForEntity(edge) {
     return edge.edgeIndex;
   }
 
   /**
    * @param {!Profiler.HeapSnapshotObjectNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode._edgeIndex;
   }
 
   /**
-   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!HeapSnapshotModel.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]
@@ skipping 44 matching lines @@
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotRetainingObjectNode = class extends Profiler.HeapSnapshotObjectNode {
   /**
    * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
    * @param {!Profiler.HeapSnapshotProxy} snapshot
-   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {!HeapSnapshotModel.Edge} edge
    * @param {?Profiler.HeapSnapshotRetainingObjectNode} parentRetainingObjectNode
    */
   constructor(dataGrid, snapshot, edge, parentRetainingObjectNode) {
     super(dataGrid, snapshot, edge, parentRetainingObjectNode);
   }
 
   /**
    * @override
    * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._snapshot.createRetainingEdgesProvider(this.snapshotNodeIndex);
   }
 
   /**
    * @override
-   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @param {!HeapSnapshotModel.Edge} item
    * @return {!Profiler.HeapSnapshotRetainingObjectNode}
    */
   _createChildNode(item) {
     return new Profiler.HeapSnapshotRetainingObjectNode(this._dataGrid, this._snapshot, item, this);
   }
 
   /**
    * @override
    * @return {string}
    */
@@ skipping 37 matching lines @@
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotInstanceNode = class extends Profiler.HeapSnapshotGenericObjectNode {
   /**
    * @param {!Profiler.HeapSnapshotSortableDataGrid} dataGrid
    * @param {!Profiler.HeapSnapshotProxy} snapshot
-   * @param {!Profiler.HeapSnapshotCommon.Node} node
+   * @param {!HeapSnapshotModel.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'] = '';
@@ skipping 22 matching lines @@
 
   /**
    * @override
    * @return {!Profiler.HeapSnapshotProviderProxy}
    */
   createProvider() {
     return this._baseSnapshotOrSnapshot.createEdgesProvider(this.snapshotNodeIndex);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Edge} item
+   * @param {!HeapSnapshotModel.Edge} item
    * @return {!Profiler.HeapSnapshotObjectNode}
    */
   _createChildNode(item) {
     return new Profiler.HeapSnapshotObjectNode(this._dataGrid, this._baseSnapshotOrSnapshot, item, null);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Edge} edge
+   * @param {!HeapSnapshotModel.Edge} edge
    * @return {number}
    */
   _childHashForEntity(edge) {
     return edge.edgeIndex;
   }
 
   /**
    * @param {!Profiler.HeapSnapshotObjectNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode._edgeIndex;
   }
 
   /**
-   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!HeapSnapshotModel.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 Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotConstructorNode = class extends Profiler.HeapSnapshotGridNode {
   /**
    * @param {!Profiler.HeapSnapshotConstructorsDataGrid} dataGrid
    * @param {string} className
-   * @param {!Profiler.HeapSnapshotCommon.Aggregate} aggregate
-   * @param {!Profiler.HeapSnapshotCommon.NodeFilter} nodeFilter
+   * @param {!HeapSnapshotModel.Aggregate} aggregate
+   * @param {!HeapSnapshotModel.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;
 
@@ skipping 83 matching lines @@
    * @return {!Element}
    */
   createCell(columnId) {
     var cell = columnId !== 'object' ? this._createValueCell(columnId) : super.createCell(columnId);
     if (this._searchMatched)
       cell.classList.add('highlight');
     return cell;
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Node} item
+   * @param {!HeapSnapshotModel.Node} item
    * @return {!Profiler.HeapSnapshotInstanceNode}
    */
   _createChildNode(item) {
     return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
   }
 
   /**
-   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!HeapSnapshotModel.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 Profiler.HeapSnapshotGridNode.createComparator(sortFields);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Node} node
+   * @param {!HeapSnapshotModel.Node} node
    * @return {number}
    */
   _childHashForEntity(node) {
     return node.id;
   }
 
   /**
    * @param {!Profiler.HeapSnapshotInstanceNode} childNode
    * @return {number}
    */
@@ skipping 42 matching lines @@
    * @param {function(boolean)} callback
    */
   isEmpty(callback) {
     callback(false);
   }
 
   /**
    * @override
    * @param {number} beginPosition
    * @param {number} endPosition
-   * @param {function(!Profiler.HeapSnapshotCommon.ItemsRange)} callback
+   * @param {function(!HeapSnapshotModel.ItemsRange)} callback
    */
   serializeItemsRange(beginPosition, endPosition, callback) {
     /**
-     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} items
+     * @param {!HeapSnapshotModel.ItemsRange} items
      * @this {Profiler.HeapSnapshotDiffNodesProvider}
      */
     function didReceiveAllItems(items) {
       items.totalLength = this._addedCount + this._removedCount;
       callback(items);
     }
 
     /**
-     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} addedItems
-     * @param {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @param {!HeapSnapshotModel.ItemsRange} addedItems
+     * @param {!HeapSnapshotModel.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 {!Profiler.HeapSnapshotCommon.ItemsRange} itemsRange
+     * @param {!HeapSnapshotModel.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 Profiler.HeapSnapshotCommon.ItemsRange(0, 0, 0, []);
+      var emptyRange = new HeapSnapshotModel.ItemsRange(0, 0, 0, []);
       this._deletedNodesProvider.serializeItemsRange(
           beginPosition - this._addedCount, endPosition - this._addedCount,
           didReceiveDeletedItems.bind(this, emptyRange));
     }
   }
 
   /**
    * @override
-   * @param {!Profiler.HeapSnapshotCommon.ComparatorConfig} comparator
+   * @param {!HeapSnapshotModel.ComparatorConfig} comparator
    * @return {!Promise<?>}
    */
   sortAndRewind(comparator) {
     /**
      * @this {Profiler.HeapSnapshotDiffNodesProvider}
      * @return {!Promise<?>}
      */
     function afterSort() {
       return this._deletedNodesProvider.sortAndRewind(comparator);
     }
     return this._addedNodesProvider.sortAndRewind(comparator).then(afterSort.bind(this));
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.HeapSnapshotDiffNode = class extends Profiler.HeapSnapshotGridNode {
   /**
    * @param {!Profiler.HeapSnapshotDiffDataGrid} dataGrid
    * @param {string} className
-   * @param {!Profiler.HeapSnapshotCommon.DiffForClass} diffForClass
+   * @param {!HeapSnapshotModel.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;
@@ skipping 26 matching lines @@
    * @return {!Element}
    */
   createCell(columnId) {
     var cell = super.createCell(columnId);
     if (columnId !== 'object')
       cell.classList.add('numeric-column');
     return cell;
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Node} item
+   * @param {!HeapSnapshotModel.Node} item
    * @return {!Profiler.HeapSnapshotInstanceNode}
    */
   _createChildNode(item) {
     if (item.isAddedNotRemoved)
       return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
     else
       return new Profiler.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, item, true);
   }
 
   /**
-   * @param {!Profiler.HeapSnapshotCommon.Node} node
+   * @param {!HeapSnapshotModel.Node} node
    * @return {number}
    */
   _childHashForEntity(node) {
     return node.id;
   }
 
   /**
    * @param {!Profiler.HeapSnapshotInstanceNode} childNode
    * @return {number}
    */
   _childHashForNode(childNode) {
     return childNode.snapshotNodeId;
   }
 
   /**
-   * @return {!Profiler.HeapSnapshotCommon.ComparatorConfig}
+   * @return {!HeapSnapshotModel.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],
@@ skipping 20 matching lines @@
       return '\u2212';  // Math minus sign, same width as plus.
   }
 };
 
 /**
  * @unrestricted
  */
 Profiler.AllocationGridNode = class extends Profiler.HeapSnapshotGridNode {
   /**
    * @param {!Profiler.AllocationDataGrid} dataGrid
-   * @param {!Profiler.HeapSnapshotCommon.SerializedAllocationNode} data
+   * @param {!HeapSnapshotModel.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 {!Profiler.HeapSnapshotCommon.AllocationNodeCallers} callers
+     * @param {!HeapSnapshotModel.AllocationNodeCallers} callers
      * @this {Profiler.AllocationGridNode}
      */
     function didReceiveCallers(callers) {
       var callersChain = callers.nodesWithSingleCaller;
       var parentNode = this;
       var dataGrid = /** @type {!Profiler.AllocationDataGrid} */ (this._dataGrid);
       for (var i = 0; i < callersChain.length; i++) {
         var child = new Profiler.AllocationGridNode(dataGrid, callersChain[i]);
         dataGrid.appendNode(parentNode, child);
         parentNode = child;
@@ skipping 42 matching lines @@
     return cell;
   }
 
   /**
    * @return {number}
    */
   allocationNodeId() {
     return this._allocationNode.id;
   }
 };