Do not override data getter in heap snapshot grid nodes

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 93 matching lines @@
 WebInspector.HeapSnapshotGridNode.prototype = {
     /**
      * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
      */
     createProvider: function()
     {
         throw new Error("Not implemented.");
     },
 
     /**
+     * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+     */
+    retainersDataSource: function()
+    {
+        return null;
+    },
+
+    /**
      * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
      */
     _provider: function()
     {
         if (!this._providerObject)
             this._providerObject = this.createProvider();
         return this._providerObject;
     },
 
     /**
@@ skipping 338 matching lines @@
         this._provider().sortAndRewind(this.comparator(), afterSort.bind(this));
     },
 
     __proto__: WebInspector.DataGridNode.prototype
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotGridNode}
- * @param {!WebInspector.HeapSnapshotSortableDataGrid} tree
+ * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
  */
-WebInspector.HeapSnapshotGenericObjectNode = function(tree, node)
+WebInspector.HeapSnapshotGenericObjectNode = function(dataGrid, node)
 {
-    this.snapshotNodeIndex = 0;
-    WebInspector.HeapSnapshotGridNode.call(this, tree, false);
+    WebInspector.HeapSnapshotGridNode.call(this, 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;
     this._retainedSize = node.retainedSize;

[loislo, 2014/03/26 08:36:04]

Looks like we don't need these 3 properties on 'this'.

[yurys, 2014/03/26 09:25:09]

They are used when sorting rows, see _sortFields method.

     this.snapshotNodeId = node.id;
     this.snapshotNodeIndex = node.nodeIndex;
     if (this._type === "string")
         this._reachableFromWindow = true;
     else if (this._type === "object" && this._name.startsWith("Window")) {
         this._name = this.shortenWindowURL(this._name, false);
         this._reachableFromWindow = true;
     } else if (node.canBeQueried)
         this._reachableFromWindow = true;
     if (node.detachedDOMTreeNode)
         this.detachedDOMTreeNode = true;
+
+    var snapshot = dataGrid.snapshot;
+    var shallowSizePercent = this._shallowSize / snapshot.totalSize * 100.0;
+    var retainedSizePercent = this._retainedSize / snapshot.totalSize * 100.0;
+    this.data = {
+        "distance": this._distance,
+        "shallowSize": Number.withThousandsSeparator(this._shallowSize),
+        "retainedSize": Number.withThousandsSeparator(this._retainedSize),
+        "shallowSize-percent": this._toPercentString(shallowSizePercent),
+        "retainedSize-percent": this._toPercentString(retainedSizePercent)
+    };
 };
 
 WebInspector.HeapSnapshotGenericObjectNode.prototype = {
     /**
+     * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+     */
+    retainersDataSource: function()
+    {
+        return {snapshot: this._dataGrid.snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
+    },
+
+    /**
      * @param {string} columnIdentifier
      * @return {!Element}
      */
     createCell: function(columnIdentifier)
     {
         var cell = columnIdentifier !== "object" ? this._createValueCell(columnIdentifier) : this._createObjectCell();
         if (this._searchMatched)
             cell.classList.add("highlight");
         return cell;
     },
 
+    /**
+     * @return {!Element}
+     */
     _createObjectCell: function()
     {
-        var cell = document.createElement("td");
-        cell.className = "object-column";
-        var div = document.createElement("div");
-        div.className = "source-code event-properties";
-        div.style.overflow = "visible";
-
-        var data = this.data["object"];
-        if (this._prefixObjectCell)
-            this._prefixObjectCell(div, data);
-
-        var valueSpan = document.createElement("span");
-        valueSpan.className = "value console-formatted-" + data.valueStyle;
-        valueSpan.textContent = data.value;
-        div.appendChild(valueSpan);
-
-        var idSpan = document.createElement("span");
-        idSpan.className = "console-formatted-id";
-        idSpan.textContent = " @" + data["nodeId"];
-        div.appendChild(idSpan);
-
-        if (this._postfixObjectCell)
-            this._postfixObjectCell(div, data);
-
-        cell.appendChild(div);
-        cell.classList.add("disclosure");
-        if (this.depth)
-            cell.style.setProperty("padding-left", (this.depth * this.dataGrid.indentWidth) + "px");
-        cell.heapSnapshotNode = this;
-        return cell;
-    },
-
-    get data()
-    {
-        var data = this._emptyData();
-
         var value = this._name;
         var valueStyle = "object";
         switch (this._type) {
         case "concatenated string":
         case "string":
             value = "\"" + value + "\"";
             valueStyle = "string";
             break;
         case "regexp":
             value = "/" + value + "/";
@@ skipping 15 matching lines @@
             else
                 value += "[]";
             break;
         };
         if (this._reachableFromWindow)
             valueStyle += " highlight";
         if (value === "Object")
             value = "";
         if (this.detachedDOMTreeNode)
             valueStyle += " detached-dom-tree-node";
-        data["object"] = { valueStyle: valueStyle, value: value, nodeId: this.snapshotNodeId };
+        return this._createObjectCellWithValue(valueStyle, value);
+    },
 
-        data["distance"] =  this._distance;
-        data["shallowSize"] = Number.withThousandsSeparator(this._shallowSize);
-        data["retainedSize"] = Number.withThousandsSeparator(this._retainedSize);
-        data["shallowSize-percent"] = this._toPercentString(this._shallowSizePercent);
-        data["retainedSize-percent"] = this._toPercentString(this._retainedSizePercent);
+    _createObjectCellWithValue: function(valueStyle, value)
+    {
+        var cell = document.createElement("td");
+        cell.className = "object-column";
+        var div = document.createElement("div");
+        div.className = "source-code event-properties";
+        div.style.overflow = "visible";
 
-        return this._enhanceData ? this._enhanceData(data) : data;
+        this._prefixObjectCell(div);
+
+        var valueSpan = document.createElement("span");
+        valueSpan.className = "value console-formatted-" + valueStyle;
+        valueSpan.textContent = value;
+        div.appendChild(valueSpan);
+
+        var idSpan = document.createElement("span");
+        idSpan.className = "console-formatted-id";
+        idSpan.textContent = " @" + this.snapshotNodeId;
+        div.appendChild(idSpan);
+
+        cell.appendChild(div);
+        cell.classList.add("disclosure");
+        if (this.depth)
+            cell.style.setProperty("padding-left", (this.depth * this.dataGrid.indentWidth) + "px");
+        cell.heapSnapshotNode = this;
+        return cell;
+    },
+
+    _prefixObjectCell: function(div)
+    {
     },
 
     queryObjectContent: function(callback, objectGroupName)
     {
         /**
          * @param {?Protocol.Error} error
          * @param {!RuntimeAgent.RemoteObject} object
          */
         function formatResult(error, object)
         {
             if (!error && object.type)
                 callback(WebInspector.RemoteObject.fromPayload(object), !!error);
             else
                 callback(WebInspector.RemoteObject.fromPrimitiveValue(WebInspector.UIString("Preview is not available")));
         }
 
         if (this._type === "string")
             callback(WebInspector.RemoteObject.fromPrimitiveValue(this._name));
         else
             HeapProfilerAgent.getObjectByHeapObjectId(String(this.snapshotNodeId), objectGroupName, formatResult);
     },
 
-    get _retainedSizePercent()
-    {
-        return this._retainedSize / this.dataGrid.snapshot.totalSize * 100.0;
-    },
-
-    get _shallowSizePercent()
-    {
-        return this._shallowSize / this.dataGrid.snapshot.totalSize * 100.0;
-    },
-
     updateHasChildren: function()
     {
         /**
          * @this {WebInspector.HeapSnapshotGenericObjectNode}
          */
         function isEmptyCallback(isEmpty)
         {
             this.hasChildren = !isEmpty;
         }
         this._provider().isEmpty(isEmptyCallback.bind(this));
@@ skipping 17 matching lines @@
         } else
             return fullName;
     },
 
     __proto__: WebInspector.HeapSnapshotGridNode.prototype
 }
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotGenericObjectNode}
- * @param {!WebInspector.HeapSnapshotSortableDataGrid} tree
- * @param {boolean} isFromBaseSnapshot
+ * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
+ * @param {!WebInspector.HeapSnapshotProxy} snapshot
  */
-WebInspector.HeapSnapshotObjectNode = function(tree, isFromBaseSnapshot, edge, parentGridNode)
+WebInspector.HeapSnapshotObjectNode = function(dataGrid, snapshot, edge, parentGridNode)
 {
-    WebInspector.HeapSnapshotGenericObjectNode.call(this, tree, edge.node);
+    WebInspector.HeapSnapshotGenericObjectNode.call(this, dataGrid, edge.node);
     this._referenceName = edge.name;
     this._referenceType = edge.type;
-    this._distance = edge.distance;
-    this.showRetainingEdges = tree.showRetainingEdges;
-    this._isFromBaseSnapshot = isFromBaseSnapshot;
+    this.showRetainingEdges = dataGrid.showRetainingEdges;
+    this._snapshot = snapshot;
 
     this._parentGridNode = parentGridNode;
     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"] = "";
 }
 
 WebInspector.HeapSnapshotObjectNode.prototype = {
     /**
+     * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+     */
+    retainersDataSource: function()
+    {
+        return {snapshot: this._snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
+    },
+
+    /**
      * @return {!WebInspector.HeapSnapshotProviderProxy}
      */
     createProvider: function()
     {
         var tree = this._dataGrid;
         var showHiddenData = WebInspector.settings.showAdvancedHeapSnapshotProperties.get();
-        var snapshot = this._isFromBaseSnapshot ? tree.baseSnapshot : tree.snapshot;
         if (this.showRetainingEdges)
-            return snapshot.createRetainingEdgesProvider(this.snapshotNodeIndex, showHiddenData);
+            return this._snapshot.createRetainingEdgesProvider(this.snapshotNodeIndex, showHiddenData);
         else
-            return snapshot.createEdgesProvider(this.snapshotNodeIndex, showHiddenData);
+            return this._snapshot.createEdgesProvider(this.snapshotNodeIndex, showHiddenData);
     },
 
     _findAncestorWithSameSnapshotNodeId: function()
     {
         var ancestor = this._parentGridNode;
         while (ancestor) {
             if (ancestor.snapshotNodeId === this.snapshotNodeId)
                 return ancestor;
             ancestor = ancestor._parentGridNode;
         }
         return null;
     },
 
     _createChildNode: function(item)
     {
-        return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._isFromBaseSnapshot, item, this);
+        return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._snapshot, item, this);
     },
 
     _childHashForEntity: function(edge)
     {
         var prefix = this.showRetainingEdges ? edge.node.id + "#" : "";
         return prefix + edge.type + "#" + edge.name;
     },
 
     _childHashForNode: function(childNode)
     {
@@ skipping 11 matching lines @@
         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]
         }[sortColumnIdentifier] || ["!edgeName", true, "retainedSize", false];
         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
     },
 
-    _emptyData: function()
-    {
-        return { count: "", addedCount: "", removedCount: "", countDelta: "", addedSize: "", removedSize: "", sizeDelta: "" };
-    },
-
-    _enhanceData: function(data)
+    _prefixObjectCell: function(div)
     {
         var name = this._referenceName;
         if (name === "") name = "(empty)";
         var nameClass = "name";
         switch (this._referenceType) {
         case "context":
             nameClass = "console-formatted-number";
             break;
         case "internal":
         case "hidden":
         case "weak":
             nameClass = "console-formatted-null";
             break;
         case "element":
             name = "[" + name + "]";
             break;
         }
-        data["object"].nameClass = nameClass;
-        data["object"].name = name;
-        data["distance"] = this._distance;
-        return data;
-    },
 
-    _prefixObjectCell: function(div, data)
-    {
         if (this._cycledWithAncestorGridNode)
             div.className += " cycled-ancessor-node";
 
         var nameSpan = document.createElement("span");
-        nameSpan.className = data.nameClass;
-        nameSpan.textContent = data.name;
+        nameSpan.className = nameClass;
+        nameSpan.textContent = name;
         div.appendChild(nameSpan);
 
         var separatorSpan = document.createElement("span");
         separatorSpan.className = "grayed";
         separatorSpan.textContent = this.showRetainingEdges ? " in " : " :: ";
         div.appendChild(separatorSpan);
     },
 
     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
 }
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotGenericObjectNode}
+ * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
+ * @param {!WebInspector.HeapSnapshotProxy} snapshot
+ * @param {boolean} isDeletedNode
  */
-WebInspector.HeapSnapshotInstanceNode = function(tree, baseSnapshot, snapshot, node)
+WebInspector.HeapSnapshotInstanceNode = function(dataGrid, snapshot, node, isDeletedNode)
 {
-    WebInspector.HeapSnapshotGenericObjectNode.call(this, tree, node);
-    this._baseSnapshotOrSnapshot = baseSnapshot || snapshot;
-    this._isDeletedNode = !!baseSnapshot;
+    WebInspector.HeapSnapshotGenericObjectNode.call(this, 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"] = "";
+    }
 };
 
 WebInspector.HeapSnapshotInstanceNode.prototype = {
     /**
+     * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
+     */
+    retainersDataSource: function()
+    {
+        return {snapshot: this._baseSnapshotOrSnapshot, snapshotNodeIndex: this.snapshotNodeIndex};
+    },
+
+    /**
      * @return {!WebInspector.HeapSnapshotProviderProxy}
      */
     createProvider: function()
     {
         var showHiddenData = WebInspector.settings.showAdvancedHeapSnapshotProperties.get();
         return this._baseSnapshotOrSnapshot.createEdgesProvider(
             this.snapshotNodeIndex,
             showHiddenData);
     },
 
     _createChildNode: function(item)
     {
-        return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._isDeletedNode, item, null);
+        return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._baseSnapshotOrSnapshot, item, null);
     },
 
     _childHashForEntity: function(edge)
     {
         return edge.type + "#" + edge.name;
     },
 
     _childHashForNode: function(childNode)
     {
         return childNode._referenceType + "#" + childNode._referenceName;
@@ skipping 11 matching lines @@
             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]
         }[sortColumnIdentifier] || ["!edgeName", true, "retainedSize", false];
         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
     },
 
-    _emptyData: function()
-    {
-        return {count: "", countDelta: "", sizeDelta: ""};
-    },
-
-    _enhanceData: function(data)
-    {
-        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"] = "";
-        }
-        return data;
-    },
-
-    get isDeletedNode()
-    {
-        return this._isDeletedNode;
-    },
-
     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
 }
 
 /**
  * @constructor
+ * @param {!WebInspector.HeapSnapshotConstructorsDataGrid} dataGrid
  * @param {string} className
  * @param {!WebInspector.HeapSnapshotCommon.Aggregate} aggregate
  * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} nodeFilter
  * @extends {WebInspector.HeapSnapshotGridNode}
  */
-WebInspector.HeapSnapshotConstructorNode = function(tree, className, aggregate, nodeFilter)
+WebInspector.HeapSnapshotConstructorNode = function(dataGrid, className, aggregate, nodeFilter)
 {
-    WebInspector.HeapSnapshotGridNode.call(this, tree, aggregate.count > 0);
+    WebInspector.HeapSnapshotGridNode.call(this, 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;

[loislo, 2014/03/26 08:36:04]

ditto

[yurys, 2014/03/26 09:25:09]

Same as above.

+
+    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._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)
+    };
 }
 
 WebInspector.HeapSnapshotConstructorNode.prototype = {
     /**
      * @override
      * @return {!WebInspector.HeapSnapshotProviderProxy}
      */
     createProvider: function()
     {
         return this._dataGrid.snapshot.createNodesProviderForClass(this._name, this._nodeFilter)
@@ skipping 59 matching lines @@
     createCell: function(columnIdentifier)
     {
         var cell = columnIdentifier !== "object" ? this._createValueCell(columnIdentifier) : WebInspector.HeapSnapshotGridNode.prototype.createCell.call(this, columnIdentifier);
         if (this._searchMatched)
             cell.classList.add("highlight");
         return cell;
     },
 
     _createChildNode: function(item)
     {
-        return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, null, this._dataGrid.snapshot, item);
+        return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
     },
 
     /**
      * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
      */
     comparator: function()
     {
         var sortAscending = this._dataGrid.isSortOrderAscending();
         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
         var sortFields = {
             object: ["id", sortAscending, "retainedSize", false],
             distance: ["distance", sortAscending, "retainedSize", false],
             count: ["id", true, "retainedSize", false],
             shallowSize: ["selfSize", sortAscending, "id", true],
             retainedSize: ["retainedSize", sortAscending, "id", true]
         }[sortColumnIdentifier];
         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
     },
 
     _childHashForEntity: function(node)
     {
         return node.id;
     },
 
     _childHashForNode: function(childNode)
     {
         return childNode.snapshotNodeId;
     },
 
-    get data()
-    {
-        var data = { object: this._name };
-        data["count"] =  Number.withThousandsSeparator(this._count);
-        data["distance"] =  this._distance;
-        data["shallowSize"] = Number.withThousandsSeparator(this._shallowSize);
-        data["retainedSize"] = Number.withThousandsSeparator(this._retainedSize);
-        data["count-percent"] =  this._toPercentString(this._countPercent);
-        data["shallowSize-percent"] = this._toPercentString(this._shallowSizePercent);
-        data["retainedSize-percent"] = this._toPercentString(this._retainedSizePercent);
-        return data;
-    },
-
-    get _countPercent()
-    {
-        return this._count / this.dataGrid.snapshot.nodeCount * 100.0;
-    },
-
-    get _retainedSizePercent()
-    {
-        return this._retainedSize / this.dataGrid.snapshot.totalSize * 100.0;
-    },
-
-    get _shallowSizePercent()
-    {
-        return this._shallowSize / this.dataGrid.snapshot.totalSize * 100.0;
-    },
-
     __proto__: WebInspector.HeapSnapshotGridNode.prototype
 }
 
 
 /**
  * @constructor
  * @implements {WebInspector.HeapSnapshotGridNode.ChildrenProvider}
  * @param {!WebInspector.HeapSnapshotProviderProxy} addedNodesProvider
  * @param {!WebInspector.HeapSnapshotProviderProxy} deletedNodesProvider
  */
@@ skipping 101 matching lines @@
         function afterSort()
         {
             this._deletedNodesProvider.sortAndRewind(comparator, callback);
         }
         this._addedNodesProvider.sortAndRewind(comparator, afterSort.bind(this));
     }
 };
 
 /**
  * @constructor
+ * @param {!WebInspector.HeapSnapshotDiffDataGrid} dataGrid
  * @param {string} className
  * @param {!WebInspector.HeapSnapshotCommon.DiffForClass} diffForClass
  * @extends {WebInspector.HeapSnapshotGridNode}
  */
-WebInspector.HeapSnapshotDiffNode = function(tree, className, diffForClass)
+WebInspector.HeapSnapshotDiffNode = function(dataGrid, className, diffForClass)
 {
-    WebInspector.HeapSnapshotGridNode.call(this, tree, true);
+    WebInspector.HeapSnapshotGridNode.call(this, dataGrid, true);
     this._name = className;
-
     this._addedCount = diffForClass.addedCount;
     this._removedCount = diffForClass.removedCount;
     this._countDelta = diffForClass.countDelta;

[loislo, 2014/03/26 08:36:04]

looks like we don't need _countDelta, _addedSize, _removedSize and _sizeDelta
properties on 'this'

     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))
+    };
 }
 
 WebInspector.HeapSnapshotDiffNode.prototype = {
     /**
      * @override
      * @return {!WebInspector.HeapSnapshotDiffNodesProvider}
      */
     createProvider: function()
     {
         var tree = this._dataGrid;
         return new WebInspector.HeapSnapshotDiffNodesProvider(
             tree.snapshot.createAddedNodesProvider(tree.baseSnapshot.uid, this._name),
             tree.baseSnapshot.createDeletedNodesProvider(this._deletedIndexes),
             this._addedCount,
             this._removedCount);
     },
 
     _createChildNode: function(item)
     {
         if (item.isAddedNotRemoved)
-            return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, null, this._dataGrid.snapshot, item);
+            return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
         else
-            return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, null, item);
+            return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, item, true);
     },
 
     _childHashForEntity: function(node)
     {
         return node.id;
     },
 
     _childHashForNode: function(childNode)
     {
         return childNode.snapshotNodeId;
@@ skipping 29 matching lines @@
     _signForDelta: function(delta)
     {
         if (delta === 0)
             return "";
         if (delta > 0)
             return "+";
         else
             return "\u2212";  // Math minus sign, same width as plus.
     },
 
-    get data()
-    {
-        var data = {object: this._name};
-
-        data["addedCount"] = Number.withThousandsSeparator(this._addedCount);
-        data["removedCount"] = Number.withThousandsSeparator(this._removedCount);
-        data["countDelta"] = this._signForDelta(this._countDelta) + Number.withThousandsSeparator(Math.abs(this._countDelta));
-        data["addedSize"] = Number.withThousandsSeparator(this._addedSize);
-        data["removedSize"] = Number.withThousandsSeparator(this._removedSize);
-        data["sizeDelta"] = this._signForDelta(this._sizeDelta) + Number.withThousandsSeparator(Math.abs(this._sizeDelta));
-
-        return data;
-    },
-
     __proto__: WebInspector.HeapSnapshotGridNode.prototype
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.HeapSnapshotGenericObjectNode}
+ * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
  */
-WebInspector.HeapSnapshotDominatorObjectNode = function(tree, node)
+WebInspector.HeapSnapshotDominatorObjectNode = function(dataGrid, node)
 {
-    WebInspector.HeapSnapshotGenericObjectNode.call(this, tree, node);
+    WebInspector.HeapSnapshotGenericObjectNode.call(this, dataGrid, node);
     this.updateHasChildren();
 };
 
 WebInspector.HeapSnapshotDominatorObjectNode.prototype = {
     /**
      * @override
      * @return {!WebInspector.HeapSnapshotProviderProxy}
      */
     createProvider: function()
     {
@@ skipping 64 matching lines @@
         var sortAscending = this._dataGrid.isSortOrderAscending();
         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
         var sortFields = {
             object: ["id", sortAscending, "retainedSize", false],
             shallowSize: ["selfSize", sortAscending, "id", true],
             retainedSize: ["retainedSize", sortAscending, "id", true]
         }[sortColumnIdentifier];
         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
     },
 
-    _emptyData: function()
-    {
-        return {};
-    },
-
     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
 }
 
 
 /**
  * @constructor
  * @extends {WebInspector.DataGridNode}
  * @param {!WebInspector.AllocationDataGrid} dataGrid
  * @param {!WebInspector.HeapSnapshotCommon.SerializedAllocationNode} data
  */
@@ skipping 71 matching lines @@
     /**
      * @return {number}
      */
     allocationNodeId: function()
     {
         return this.data.id;
     },
 
     __proto__: WebInspector.DataGridNode.prototype
 }