src/third_party/WebKit/Source/devtools/front_end/profiler/HeapSnapshotGridNodes.js

   1 /*
   2  * Copyright (C) 2011 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 /**
  32  * @constructor
  33  * @extends {WebInspector.DataGridNode}
  34  * @param {!WebInspector.HeapSnapshotSortableDataGrid} tree
  35  * @param {boolean} hasChildren
  36  */
  37 WebInspector.HeapSnapshotGridNode = function(tree, hasChildren)
  38 {
  39     WebInspector.DataGridNode.call(this, null, hasChildren);
  40     this._dataGrid = tree;
  41     this._instanceCount = 0;
  42
  43     this._savedChildren = null;
  44     /**
  45      * List of position ranges for all visible nodes: [startPos1, endPos1),...,[startPosN, endPosN)
  46      * Position is an item position in the provider.
  47      */
  48     this._retrievedChildrenRanges = [];
  49
  50     /**
  51       * @type {?WebInspector.HeapSnapshotGridNode.ChildrenProvider}
  52       */
  53     this._providerObject = null;
  54 }
  55
  56 WebInspector.HeapSnapshotGridNode.Events = {
  57     PopulateComplete: "PopulateComplete"
  58 }
  59
  60 /**
  61  * @param {!Array.<string>} fieldNames
  62  * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
  63  */
  64 WebInspector.HeapSnapshotGridNode.createComparator = function(fieldNames)
  65 {
  66     return /** @type {!WebInspector.HeapSnapshotCommon.ComparatorConfig} */ ({fieldName1: fieldNames[0], ascending1: fieldNames[1], fieldName2: fieldNames[2], ascending2: fieldNames[3]});
  67 }
  68
  69
  70 /**
  71  * @interface
  72  */
  73 WebInspector.HeapSnapshotGridNode.ChildrenProvider = function() { }
  74
  75 WebInspector.HeapSnapshotGridNode.ChildrenProvider.prototype = {
  76     dispose: function() { },
  77
  78     /**
  79      * @param {number} snapshotObjectId
  80      * @param {function(number)} callback
  81      */
  82     nodePosition: function(snapshotObjectId, callback) { },
  83
  84     /**
  85      * @param {function(boolean)} callback
  86      */
  87     isEmpty: function(callback) { },
  88
  89     /**
  90      * @param {number} startPosition
  91      * @param {number} endPosition
  92      * @param {function(!WebInspector.HeapSnapshotCommon.ItemsRange)} callback
  93      */
  94     serializeItemsRange: function(startPosition, endPosition, callback) { },
  95
  96     /**
  97      * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
  98      * @param {function()} callback
  99      */
 100     sortAndRewind: function(comparator, callback) { }
 101 }
 102
 103
 104 WebInspector.HeapSnapshotGridNode.prototype = {
 105     /**
 106      * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
 107      */
 108     createProvider: function()
 109     {
 110         throw new Error("Not implemented.");
 111     },
 112
 113     /**
 114      * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
 115      */
 116     retainersDataSource: function()
 117     {
 118         return null;
 119     },
 120
 121     /**
 122      * @return {!WebInspector.HeapSnapshotGridNode.ChildrenProvider}
 123      */
 124     _provider: function()
 125     {
 126         if (!this._providerObject)
 127             this._providerObject = this.createProvider();
 128         return this._providerObject;
 129     },
 130
 131     /**
 132      * @param {string} columnIdentifier
 133      * @return {!Element}
 134      */
 135     createCell: function(columnIdentifier)
 136     {
 137         var cell = WebInspector.DataGridNode.prototype.createCell.call(this, columnIdentifier);
 138         if (this._searchMatched)
 139             cell.classList.add("highlight");
 140         return cell;
 141     },
 142
 143     /**
 144      * @override
 145      */
 146     collapse: function()
 147     {
 148         WebInspector.DataGridNode.prototype.collapse.call(this);
 149         this._dataGrid.updateVisibleNodes(true);
 150     },
 151
 152     /**
 153      * @override
 154      */
 155     expand: function()
 156     {
 157         WebInspector.DataGridNode.prototype.expand.call(this);
 158         this._dataGrid.updateVisibleNodes(true);
 159     },
 160
 161     /**
 162      * @override
 163      */
 164     dispose: function()
 165     {
 166         if (this._providerObject)
 167             this._providerObject.dispose();
 168         for (var node = this.children[0]; node; node = node.traverseNextNode(true, this, true))
 169             if (node.dispose)
 170                 node.dispose();
 171     },
 172
 173     _reachableFromWindow: false,
 174
 175     queryObjectContent: function(callback)
 176     {
 177     },
 178
 179     /**
 180      * @override
 181      */
 182     wasDetached: function()
 183     {
 184         this._dataGrid.nodeWasDetached(this);
 185     },
 186
 187     /**
 188      * @param {number} num
 189      * @return {string}
 190      */
 191     _toPercentString: function(num)
 192     {
 193         return num.toFixed(0) + "\u2009%"; // \u2009 is a thin space.
 194     },
 195
 196     /**
 197      * @param {number} distance
 198      * @return {string}
 199      */
 200     _toUIDistance: function(distance)
 201     {
 202         var baseSystemDistance = WebInspector.HeapSnapshotCommon.baseSystemDistance;
 203         return distance >= 0 && distance < baseSystemDistance ? WebInspector.UIString("%d", distance) : WebInspector.UIString("\u2212");
 204     },
 205
 206     /**
 207      * @return {!Array.<!WebInspector.DataGridNode>}
 208      */
 209     allChildren: function()
 210     {
 211         return this._dataGrid.allChildren(this);
 212     },
 213
 214     /**
 215      * @param {number} index
 216      */
 217     removeChildByIndex: function(index)
 218     {
 219         this._dataGrid.removeChildByIndex(this, index);
 220     },
 221
 222     /**
 223      * @param {number} nodePosition
 224      * @return {?WebInspector.DataGridNode}
 225      */
 226     childForPosition: function(nodePosition)
 227     {
 228         var indexOfFirstChildInRange = 0;
 229         for (var i = 0; i < this._retrievedChildrenRanges.length; i++) {
 230            var range = this._retrievedChildrenRanges[i];
 231            if (range.from <= nodePosition && nodePosition < range.to) {
 232                var childIndex = indexOfFirstChildInRange + nodePosition - range.from;
 233                return this.allChildren()[childIndex];
 234            }
 235            indexOfFirstChildInRange += range.to - range.from + 1;
 236         }
 237         return null;
 238     },
 239
 240     /**
 241      * @param {string} columnIdentifier
 242      * @return {!Element}
 243      */
 244     _createValueCell: function(columnIdentifier)
 245     {
 246         var cell = document.createElement("td");
 247         cell.className = "numeric-column";
 248         if (this.dataGrid.snapshot.totalSize !== 0) {
 249             var div = document.createElement("div");
 250             var valueSpan = document.createElement("span");
 251             valueSpan.textContent = this.data[columnIdentifier];
 252             div.appendChild(valueSpan);
 253             var percentColumn = columnIdentifier + "-percent";
 254             if (percentColumn in this.data) {
 255                 var percentSpan = document.createElement("span");
 256                 percentSpan.className = "percent-column";
 257                 percentSpan.textContent = this.data[percentColumn];
 258                 div.appendChild(percentSpan);
 259                 div.classList.add("profile-multiple-values");
 260             }
 261             cell.appendChild(div);
 262         }
 263         return cell;
 264     },
 265
 266     populate: function(event)
 267     {
 268         if (this._populated)
 269             return;
 270         this._populated = true;
 271
 272         /**
 273          * @this {WebInspector.HeapSnapshotGridNode}
 274          */
 275         function sorted()
 276         {
 277             this._populateChildren();
 278         }
 279         this._provider().sortAndRewind(this.comparator(), sorted.bind(this));
 280     },
 281
 282     expandWithoutPopulate: function(callback)
 283     {
 284         // Make sure default populate won't take action.
 285         this._populated = true;
 286         this.expand();
 287         this._provider().sortAndRewind(this.comparator(), callback);
 288     },
 289
 290     /**
 291      * @param {?number=} fromPosition
 292      * @param {?number=} toPosition
 293      * @param {function()=} afterPopulate
 294      */
 295     _populateChildren: function(fromPosition, toPosition, afterPopulate)
 296     {
 297         fromPosition = fromPosition || 0;
 298         toPosition = toPosition || fromPosition + this._dataGrid.defaultPopulateCount();
 299         var firstNotSerializedPosition = fromPosition;
 300
 301         /**
 302          * @this {WebInspector.HeapSnapshotGridNode}
 303          */
 304         function serializeNextChunk()
 305         {
 306             if (firstNotSerializedPosition >= toPosition)
 307                 return;
 308             var end = Math.min(firstNotSerializedPosition + this._dataGrid.defaultPopulateCount(), toPosition);
 309             this._provider().serializeItemsRange(firstNotSerializedPosition, end, childrenRetrieved.bind(this));
 310             firstNotSerializedPosition = end;
 311         }
 312
 313         /**
 314          * @this {WebInspector.HeapSnapshotGridNode}
 315          */
 316         function insertRetrievedChild(item, insertionIndex)
 317         {
 318             if (this._savedChildren) {
 319                 var hash = this._childHashForEntity(item);
 320                 if (hash in this._savedChildren) {
 321                     this._dataGrid.insertChild(this, this._savedChildren[hash], insertionIndex);
 322                     return;
 323                 }
 324             }
 325             this._dataGrid.insertChild(this, this._createChildNode(item), insertionIndex);
 326         }
 327
 328         /**
 329          * @this {WebInspector.HeapSnapshotGridNode}
 330          */
 331         function insertShowMoreButton(from, to, insertionIndex)
 332         {
 333             var button = new WebInspector.ShowMoreDataGridNode(this._populateChildren.bind(this), from, to, this._dataGrid.defaultPopulateCount());
 334             this._dataGrid.insertChild(this, button, insertionIndex);
 335         }
 336
 337         /**
 338          * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
 339          * @this {WebInspector.HeapSnapshotGridNode}
 340          */
 341         function childrenRetrieved(itemsRange)
 342         {
 343             var itemIndex = 0;
 344             var itemPosition = itemsRange.startPosition;
 345             var items = itemsRange.items;
 346             var insertionIndex = 0;
 347
 348             if (!this._retrievedChildrenRanges.length) {
 349                 if (itemsRange.startPosition > 0) {
 350                     this._retrievedChildrenRanges.push({from: 0, to: 0});
 351                     insertShowMoreButton.call(this, 0, itemsRange.startPosition, insertionIndex++);
 352                 }
 353                 this._retrievedChildrenRanges.push({from: itemsRange.startPosition, to: itemsRange.endPosition});
 354                 for (var i = 0, l = items.length; i < l; ++i)
 355                     insertRetrievedChild.call(this, items[i], insertionIndex++);
 356                 if (itemsRange.endPosition < itemsRange.totalLength)
 357                     insertShowMoreButton.call(this, itemsRange.endPosition, itemsRange.totalLength, insertionIndex++);
 358             } else {
 359                 var rangeIndex = 0;
 360                 var found = false;
 361                 var range;
 362                 while (rangeIndex < this._retrievedChildrenRanges.length) {
 363                     range = this._retrievedChildrenRanges[rangeIndex];
 364                     if (range.to >= itemPosition) {
 365                         found = true;
 366                         break;
 367                     }
 368                     insertionIndex += range.to - range.from;
 369                     // Skip the button if there is one.
 370                     if (range.to < itemsRange.totalLength)
 371                         insertionIndex += 1;
 372                     ++rangeIndex;
 373                 }
 374
 375                 if (!found || itemsRange.startPosition < range.from) {
 376                     // Update previous button.
 377                     this.allChildren()[insertionIndex - 1].setEndPosition(itemsRange.startPosition);
 378                     insertShowMoreButton.call(this, itemsRange.startPosition, found ? range.from : itemsRange.totalLength, insertionIndex);
 379                     range = {from: itemsRange.startPosition, to: itemsRange.startPosition};
 380                     if (!found)
 381                         rangeIndex = this._retrievedChildrenRanges.length;
 382                     this._retrievedChildrenRanges.splice(rangeIndex, 0, range);
 383                 } else {
 384                     insertionIndex += itemPosition - range.from;
 385                 }
 386                 // At this point insertionIndex is always an index before button or between nodes.
 387                 // Also it is always true here that range.from <= itemPosition <= range.to
 388
 389                 // Stretch the range right bound to include all new items.
 390                 while (range.to < itemsRange.endPosition) {
 391                     // Skip already added nodes.
 392                     var skipCount = range.to - itemPosition;
 393                     insertionIndex += skipCount;
 394                     itemIndex += skipCount;
 395                     itemPosition = range.to;
 396
 397                     // We're at the position before button: ...<?node>x<button>
 398                     var nextRange = this._retrievedChildrenRanges[rangeIndex + 1];
 399                     var newEndOfRange = nextRange ? nextRange.from : itemsRange.totalLength;
 400                     if (newEndOfRange > itemsRange.endPosition)
 401                         newEndOfRange = itemsRange.endPosition;
 402                     while (itemPosition < newEndOfRange) {
 403                         insertRetrievedChild.call(this, items[itemIndex++], insertionIndex++);
 404                         ++itemPosition;
 405                     }
 406                     // Merge with the next range.
 407                     if (nextRange && newEndOfRange === nextRange.from) {
 408                         range.to = nextRange.to;
 409                         // Remove "show next" button if there is one.
 410                         this.removeChildByIndex(insertionIndex);
 411                         this._retrievedChildrenRanges.splice(rangeIndex + 1, 1);
 412                     } else {
 413                         range.to = newEndOfRange;
 414                         // Remove or update next button.
 415                         if (newEndOfRange === itemsRange.totalLength)
 416                             this.removeChildByIndex(insertionIndex);
 417                         else
 418                             this.allChildren()[insertionIndex].setStartPosition(itemsRange.endPosition);
 419                     }
 420                 }
 421             }
 422
 423             // TODO: fix this.
 424             this._instanceCount += items.length;
 425             if (firstNotSerializedPosition < toPosition) {
 426                 serializeNextChunk.call(this);
 427                 return;
 428             }
 429
 430             if (this.expanded)
 431                 this._dataGrid.updateVisibleNodes(true);
 432             if (afterPopulate)
 433                 afterPopulate();
 434             this.dispatchEventToListeners(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete);
 435         }
 436         serializeNextChunk.call(this);
 437     },
 438
 439     _saveChildren: function()
 440     {
 441         this._savedChildren = null;
 442         var children = this.allChildren();
 443         for (var i = 0, l = children.length; i < l; ++i) {
 444             var child = children[i];
 445             if (!child.expanded)
 446                 continue;
 447             if (!this._savedChildren)
 448                 this._savedChildren = {};
 449             this._savedChildren[this._childHashForNode(child)] = child;
 450         }
 451     },
 452
 453     sort: function()
 454     {
 455         this._dataGrid.recursiveSortingEnter();
 456
 457         /**
 458          * @this {WebInspector.HeapSnapshotGridNode}
 459          */
 460         function afterSort()
 461         {
 462             this._saveChildren();
 463             this._dataGrid.removeAllChildren(this);
 464             this._retrievedChildrenRanges = [];
 465
 466             /**
 467              * @this {WebInspector.HeapSnapshotGridNode}
 468              */
 469             function afterPopulate()
 470             {
 471                 var children = this.allChildren();
 472                 for (var i = 0, l = children.length; i < l; ++i) {
 473                     var child = children[i];
 474                     if (child.expanded)
 475                         child.sort();
 476                 }
 477                 this._dataGrid.recursiveSortingLeave();
 478             }
 479             var instanceCount = this._instanceCount;
 480             this._instanceCount = 0;
 481             this._populateChildren(0, instanceCount, afterPopulate.bind(this));
 482         }
 483
 484         this._provider().sortAndRewind(this.comparator(), afterSort.bind(this));
 485     },
 486
 487     __proto__: WebInspector.DataGridNode.prototype
 488 }
 489
 490
 491 /**
 492  * @constructor
 493  * @extends {WebInspector.HeapSnapshotGridNode}
 494  * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
 495  * @param {!WebInspector.HeapSnapshotCommon.Node} node
 496  */
 497 WebInspector.HeapSnapshotGenericObjectNode = function(dataGrid, node)
 498 {
 499     WebInspector.HeapSnapshotGridNode.call(this, dataGrid, false);
 500     // node is null for DataGrid root nodes.
 501     if (!node)
 502         return;
 503     this._name = node.name;
 504     this._type = node.type;
 505     this._distance = node.distance;
 506     this._shallowSize = node.selfSize;
 507     this._retainedSize = node.retainedSize;
 508     this.snapshotNodeId = node.id;
 509     this.snapshotNodeIndex = node.nodeIndex;
 510     if (this._type === "string")
 511         this._reachableFromWindow = true;
 512     else if (this._type === "object" && this._name.startsWith("Window")) {
 513         this._name = this.shortenWindowURL(this._name, false);
 514         this._reachableFromWindow = true;
 515     } else if (node.canBeQueried)
 516         this._reachableFromWindow = true;
 517     if (node.detachedDOMTreeNode)
 518         this.detachedDOMTreeNode = true;
 519
 520     var snapshot = dataGrid.snapshot;
 521     var shallowSizePercent = this._shallowSize / snapshot.totalSize * 100.0;
 522     var retainedSizePercent = this._retainedSize / snapshot.totalSize * 100.0;
 523     this.data = {
 524         "distance": this._toUIDistance(this._distance),
 525         "shallowSize": Number.withThousandsSeparator(this._shallowSize),
 526         "retainedSize": Number.withThousandsSeparator(this._retainedSize),
 527         "shallowSize-percent": this._toPercentString(shallowSizePercent),
 528         "retainedSize-percent": this._toPercentString(retainedSizePercent)
 529     };
 530 };
 531
 532 WebInspector.HeapSnapshotGenericObjectNode.prototype = {
 533     /**
 534      * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
 535      */
 536     retainersDataSource: function()
 537     {
 538         return {snapshot: this._dataGrid.snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
 539     },
 540
 541     /**
 542      * @param {string} columnIdentifier
 543      * @return {!Element}
 544      */
 545     createCell: function(columnIdentifier)
 546     {
 547         var cell = columnIdentifier !== "object" ? this._createValueCell(columnIdentifier) : this._createObjectCell();
 548         if (this._searchMatched)
 549             cell.classList.add("highlight");
 550         return cell;
 551     },
 552
 553     /**
 554      * @return {!Element}
 555      */
 556     _createObjectCell: function()
 557     {
 558         var value = this._name;
 559         var valueStyle = "object";
 560         switch (this._type) {
 561         case "concatenated string":
 562         case "string":
 563             value = "\"" + value + "\"";
 564             valueStyle = "string";
 565             break;
 566         case "regexp":
 567             value = "/" + value + "/";
 568             valueStyle = "string";
 569             break;
 570         case "closure":
 571             value = "function" + (value ? " " : "") + value + "()";
 572             valueStyle = "function";
 573             break;
 574         case "number":
 575             valueStyle = "number";
 576             break;
 577         case "hidden":
 578             valueStyle = "null";
 579             break;
 580         case "array":
 581             if (!value)
 582                 value = "[]";
 583             else
 584                 value += "[]";
 585             break;
 586         };
 587         if (this._reachableFromWindow)
 588             valueStyle += " highlight";
 589         if (value === "Object")
 590             value = "";
 591         if (this.detachedDOMTreeNode)
 592             valueStyle += " detached-dom-tree-node";
 593         return this._createObjectCellWithValue(valueStyle, value);
 594     },
 595
 596     _createObjectCellWithValue: function(valueStyle, value)
 597     {
 598         var cell = document.createElement("td");
 599         cell.className = "object-column";
 600         var div = document.createElement("div");
 601         div.className = "source-code event-properties";
 602         div.style.overflow = "visible";
 603
 604         this._prefixObjectCell(div);
 605
 606         var valueSpan = document.createElement("span");
 607         valueSpan.className = "value console-formatted-" + valueStyle;
 608         valueSpan.textContent = value;
 609         div.appendChild(valueSpan);
 610
 611         var idSpan = document.createElement("span");
 612         idSpan.className = "console-formatted-id";
 613         idSpan.textContent = " @" + this.snapshotNodeId;
 614         div.appendChild(idSpan);
 615
 616         cell.appendChild(div);
 617         cell.classList.add("disclosure");
 618         if (this.depth)
 619             cell.style.setProperty("padding-left", (this.depth * this.dataGrid.indentWidth) + "px");
 620         cell.heapSnapshotNode = this;
 621         return cell;
 622     },
 623
 624     _prefixObjectCell: function(div)
 625     {
 626     },
 627
 628     /**
 629      * @param {!WebInspector.Target} target
 630      * @param {!function(!WebInspector.RemoteObject)} callback
 631      * @param {string} objectGroupName
 632      */
 633     queryObjectContent: function(target, callback, objectGroupName)
 634     {
 635         /**
 636          * @param {?Protocol.Error} error
 637          * @param {!RuntimeAgent.RemoteObject} object
 638          */
 639         function formatResult(error, object)
 640         {
 641             if (!error && object.type)
 642                 callback(target.runtimeModel.createRemoteObject(object));
 643             else
 644                 callback(target.runtimeModel.createRemoteObjectFromPrimitiveValue(WebInspector.UIString("Preview is not available")));
 645         }
 646
 647         if (this._type === "string")
 648             callback(target.runtimeModel.createRemoteObjectFromPrimitiveValue(this._name));
 649         else
 650             target.heapProfilerAgent().getObjectByHeapObjectId(String(this.snapshotNodeId), objectGroupName, formatResult);
 651     },
 652
 653     updateHasChildren: function()
 654     {
 655         /**
 656          * @this {WebInspector.HeapSnapshotGenericObjectNode}
 657          */
 658         function isEmptyCallback(isEmpty)
 659         {
 660             this.hasChildren = !isEmpty;
 661         }
 662         this._provider().isEmpty(isEmptyCallback.bind(this));
 663     },
 664
 665     /**
 666      * @param {string} fullName
 667      * @param {boolean} hasObjectId
 668      * @return {string}
 669      */
 670     shortenWindowURL: function(fullName, hasObjectId)
 671     {
 672         var startPos = fullName.indexOf("/");
 673         var endPos = hasObjectId ? fullName.indexOf("@") : fullName.length;
 674         if (startPos !== -1 && endPos !== -1) {
 675             var fullURL = fullName.substring(startPos + 1, endPos).trimLeft();
 676             var url = fullURL.trimURL();
 677             if (url.length > 40)
 678                 url = url.trimMiddle(40);
 679             return fullName.substr(0, startPos + 2) + url + fullName.substr(endPos);
 680         } else
 681             return fullName;
 682     },
 683
 684     __proto__: WebInspector.HeapSnapshotGridNode.prototype
 685 }
 686
 687 /**
 688  * @constructor
 689  * @extends {WebInspector.HeapSnapshotGenericObjectNode}
 690  * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
 691  * @param {!WebInspector.HeapSnapshotProxy} snapshot
 692  * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
 693  * @param {?WebInspector.HeapSnapshotObjectNode} parentObjectNode
 694  */
 695 WebInspector.HeapSnapshotObjectNode = function(dataGrid, snapshot, edge, parentObjectNode)
 696 {
 697     WebInspector.HeapSnapshotGenericObjectNode.call(this, dataGrid, edge.node);
 698     this._referenceName = edge.name;
 699     this._referenceType = edge.type;
 700     this._edgeIndex = edge.edgeIndex;
 701     this._snapshot = snapshot;
 702
 703     this._parentObjectNode = parentObjectNode;
 704     this._cycledWithAncestorGridNode = this._findAncestorWithSameSnapshotNodeId();
 705     if (!this._cycledWithAncestorGridNode)
 706         this.updateHasChildren();
 707
 708     var data = this.data;
 709     data["count"] = "";
 710     data["addedCount"] = "";
 711     data["removedCount"] = "";
 712     data["countDelta"] = "";
 713     data["addedSize"] = "";
 714     data["removedSize"] = "";
 715     data["sizeDelta"] = "";
 716 }
 717
 718 WebInspector.HeapSnapshotObjectNode.prototype = {
 719     /**
 720      * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
 721      */
 722     retainersDataSource: function()
 723     {
 724         return {snapshot: this._snapshot, snapshotNodeIndex: this.snapshotNodeIndex};
 725     },
 726
 727     /**
 728      * @return {!WebInspector.HeapSnapshotProviderProxy}
 729      */
 730     createProvider: function()
 731     {
 732         return this._snapshot.createEdgesProvider(this.snapshotNodeIndex);
 733     },
 734
 735     _findAncestorWithSameSnapshotNodeId: function()
 736     {
 737         var ancestor = this._parentObjectNode;
 738         while (ancestor) {
 739             if (ancestor.snapshotNodeId === this.snapshotNodeId)
 740                 return ancestor;
 741             ancestor = ancestor._parentObjectNode;
 742         }
 743         return null;
 744     },
 745
 746     /**
 747      * @param {!WebInspector.HeapSnapshotCommon.Edge} item
 748      * @return {!WebInspector.HeapSnapshotObjectNode}
 749      */
 750     _createChildNode: function(item)
 751     {
 752         return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._snapshot, item, this);
 753     },
 754
 755     /**
 756      * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
 757      * @return {number}
 758      */
 759     _childHashForEntity: function(edge)
 760     {
 761         return edge.edgeIndex;
 762     },
 763
 764     /**
 765      * @param {!WebInspector.HeapSnapshotObjectNode} childNode
 766      * @return {number}
 767      */
 768     _childHashForNode: function(childNode)
 769     {
 770         return childNode._edgeIndex;
 771     },
 772
 773     /**
 774      * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
 775      */
 776     comparator: function()
 777     {
 778         var sortAscending = this._dataGrid.isSortOrderAscending();
 779         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
 780         var sortFields = {
 781             object: ["!edgeName", sortAscending, "retainedSize", false],
 782             count: ["!edgeName", true, "retainedSize", false],
 783             shallowSize: ["selfSize", sortAscending, "!edgeName", true],
 784             retainedSize: ["retainedSize", sortAscending, "!edgeName", true],
 785             distance: ["distance", sortAscending, "_name", true]
 786         }[sortColumnIdentifier] || ["!edgeName", true, "retainedSize", false];
 787         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
 788     },
 789
 790     _prefixObjectCell: function(div)
 791     {
 792         var name = this._referenceName;
 793         if (name === "") name = "(empty)";
 794         var nameClass = "name";
 795         switch (this._referenceType) {
 796         case "context":
 797             nameClass = "console-formatted-number";
 798             break;
 799         case "internal":
 800         case "hidden":
 801         case "weak":
 802             nameClass = "console-formatted-null";
 803             break;
 804         case "element":
 805             name = "[" + name + "]";
 806             break;
 807         }
 808
 809         if (this._cycledWithAncestorGridNode)
 810             div.className += " cycled-ancessor-node";
 811
 812         var nameSpan = document.createElement("span");
 813         nameSpan.className = nameClass;
 814         nameSpan.textContent = name;
 815         div.appendChild(nameSpan);
 816
 817         var separatorSpan = document.createElement("span");
 818         separatorSpan.className = "grayed";
 819         separatorSpan.textContent = this._edgeNodeSeparator();
 820         div.appendChild(separatorSpan);
 821     },
 822
 823     /**
 824      * @return {string}
 825      */
 826     _edgeNodeSeparator: function()
 827     {
 828         return " :: ";
 829     },
 830
 831     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
 832 }
 833
 834 /**
 835  * @constructor
 836  * @extends {WebInspector.HeapSnapshotObjectNode}
 837  * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
 838  * @param {!WebInspector.HeapSnapshotProxy} snapshot
 839  * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
 840  * @param {?WebInspector.HeapSnapshotRetainingObjectNode} parentRetainingObjectNode
 841  */
 842 WebInspector.HeapSnapshotRetainingObjectNode = function(dataGrid, snapshot, edge, parentRetainingObjectNode)
 843 {
 844     WebInspector.HeapSnapshotObjectNode.call(this, dataGrid, snapshot, edge, parentRetainingObjectNode);
 845 }
 846
 847 WebInspector.HeapSnapshotRetainingObjectNode.prototype = {
 848     /**
 849      * @return {!WebInspector.HeapSnapshotProviderProxy}
 850      */
 851     createProvider: function()
 852     {
 853         return this._snapshot.createRetainingEdgesProvider(this.snapshotNodeIndex);
 854     },
 855
 856     /**
 857      * @param {!WebInspector.HeapSnapshotCommon.Edge} item
 858      * @return {!WebInspector.HeapSnapshotRetainingObjectNode}
 859      */
 860     _createChildNode: function(item)
 861     {
 862         return new WebInspector.HeapSnapshotRetainingObjectNode(this._dataGrid, this._snapshot, item, this);
 863     },
 864
 865     /**
 866      * @return {string}
 867      */
 868     _edgeNodeSeparator: function()
 869     {
 870         return " in ";
 871     },
 872
 873     expand: function()
 874     {
 875         this._expandRetainersChain(20);
 876     },
 877
 878     /**
 879      * @param {number} maxExpandLevels
 880      */
 881     _expandRetainersChain: function(maxExpandLevels)
 882     {
 883         /**
 884          * @this {!WebInspector.HeapSnapshotRetainingObjectNode}
 885          */
 886         function populateComplete()
 887         {
 888             this.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 889             this._expandRetainersChain(maxExpandLevels);
 890         }
 891
 892         if (!this._populated) {
 893             this.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 894             this.populate();
 895             return;
 896         }
 897         WebInspector.HeapSnapshotGenericObjectNode.prototype.expand.call(this);
 898         if (--maxExpandLevels > 0 && this.children.length > 0) {
 899             var retainer = this.children[0];
 900             if (retainer._distance > 1) {
 901                 retainer._expandRetainersChain(maxExpandLevels);
 902                 return;
 903             }
 904         }
 905         this._dataGrid.dispatchEventToListeners(WebInspector.HeapSnapshotRetainmentDataGrid.Events.ExpandRetainersComplete);
 906     },
 907
 908     __proto__: WebInspector.HeapSnapshotObjectNode.prototype
 909 }
 910
 911 /**
 912  * @constructor
 913  * @extends {WebInspector.HeapSnapshotGenericObjectNode}
 914  * @param {!WebInspector.HeapSnapshotSortableDataGrid} dataGrid
 915  * @param {!WebInspector.HeapSnapshotProxy} snapshot
 916  * @param {!WebInspector.HeapSnapshotCommon.Node} node
 917  * @param {boolean} isDeletedNode
 918  */
 919 WebInspector.HeapSnapshotInstanceNode = function(dataGrid, snapshot, node, isDeletedNode)
 920 {
 921     WebInspector.HeapSnapshotGenericObjectNode.call(this, dataGrid, node);
 922     this._baseSnapshotOrSnapshot = snapshot;
 923     this._isDeletedNode = isDeletedNode;
 924     this.updateHasChildren();
 925
 926     var data = this.data;
 927     data["count"] = "";
 928     data["countDelta"] = "";
 929     data["sizeDelta"] = "";
 930     if (this._isDeletedNode) {
 931         data["addedCount"] = "";
 932         data["addedSize"] = "";
 933         data["removedCount"] = "\u2022";
 934         data["removedSize"] = Number.withThousandsSeparator(this._shallowSize);
 935     } else {
 936         data["addedCount"] = "\u2022";
 937         data["addedSize"] = Number.withThousandsSeparator(this._shallowSize);
 938         data["removedCount"] = "";
 939         data["removedSize"] = "";
 940     }
 941 };
 942
 943 WebInspector.HeapSnapshotInstanceNode.prototype = {
 944     /**
 945      * @return {?{snapshot:!WebInspector.HeapSnapshotProxy, snapshotNodeIndex:number}}
 946      */
 947     retainersDataSource: function()
 948     {
 949         return {snapshot: this._baseSnapshotOrSnapshot, snapshotNodeIndex: this.snapshotNodeIndex};
 950     },
 951
 952     /**
 953      * @return {!WebInspector.HeapSnapshotProviderProxy}
 954      */
 955     createProvider: function()
 956     {
 957         return this._baseSnapshotOrSnapshot.createEdgesProvider(this.snapshotNodeIndex);
 958     },
 959
 960     /**
 961      * @param {!WebInspector.HeapSnapshotCommon.Edge} item
 962      * @return {!WebInspector.HeapSnapshotObjectNode}
 963      */
 964     _createChildNode: function(item)
 965     {
 966         return new WebInspector.HeapSnapshotObjectNode(this._dataGrid, this._baseSnapshotOrSnapshot, item, null);
 967     },
 968
 969     /**
 970      * @param {!WebInspector.HeapSnapshotCommon.Edge} edge
 971      * @return {number}
 972      */
 973     _childHashForEntity: function(edge)
 974     {
 975         return edge.edgeIndex;
 976     },
 977
 978     /**
 979      * @param {!WebInspector.HeapSnapshotObjectNode} childNode
 980      * @return {number}
 981      */
 982     _childHashForNode: function(childNode)
 983     {
 984         return childNode._edgeIndex;
 985     },
 986
 987     /**
 988      * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
 989      */
 990     comparator: function()
 991     {
 992         var sortAscending = this._dataGrid.isSortOrderAscending();
 993         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
 994         var sortFields = {
 995             object: ["!edgeName", sortAscending, "retainedSize", false],
 996             distance: ["distance", sortAscending, "retainedSize", false],
 997             count: ["!edgeName", true, "retainedSize", false],
 998             addedSize: ["selfSize", sortAscending, "!edgeName", true],
 999             removedSize: ["selfSize", sortAscending, "!edgeName", true],
1000             shallowSize: ["selfSize", sortAscending, "!edgeName", true],
1001             retainedSize: ["retainedSize", sortAscending, "!edgeName", true]
1002         }[sortColumnIdentifier] || ["!edgeName", true, "retainedSize", false];
1003         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
1004     },
1005
1006     __proto__: WebInspector.HeapSnapshotGenericObjectNode.prototype
1007 }
1008
1009 /**
1010  * @constructor
1011  * @param {!WebInspector.HeapSnapshotConstructorsDataGrid} dataGrid
1012  * @param {string} className
1013  * @param {!WebInspector.HeapSnapshotCommon.Aggregate} aggregate
1014  * @param {!WebInspector.HeapSnapshotCommon.NodeFilter} nodeFilter
1015  * @extends {WebInspector.HeapSnapshotGridNode}
1016  */
1017 WebInspector.HeapSnapshotConstructorNode = function(dataGrid, className, aggregate, nodeFilter)
1018 {
1019     WebInspector.HeapSnapshotGridNode.call(this, dataGrid, aggregate.count > 0);
1020     this._name = className;
1021     this._nodeFilter = nodeFilter;
1022     this._distance = aggregate.distance;
1023     this._count = aggregate.count;
1024     this._shallowSize = aggregate.self;
1025     this._retainedSize = aggregate.maxRet;
1026
1027     var snapshot = dataGrid.snapshot;
1028     var countPercent = this._count / snapshot.nodeCount * 100.0;
1029     var retainedSizePercent = this._retainedSize / snapshot.totalSize * 100.0;
1030     var shallowSizePercent = this._shallowSize / snapshot.totalSize * 100.0;
1031
1032     this.data = {
1033         "object": className,
1034         "count": Number.withThousandsSeparator(this._count),
1035         "distance": this._toUIDistance(this._distance),
1036         "shallowSize": Number.withThousandsSeparator(this._shallowSize),
1037         "retainedSize": Number.withThousandsSeparator(this._retainedSize),
1038         "count-percent": this._toPercentString(countPercent),
1039         "shallowSize-percent": this._toPercentString(shallowSizePercent),
1040         "retainedSize-percent": this._toPercentString(retainedSizePercent)
1041     };
1042 }
1043
1044 WebInspector.HeapSnapshotConstructorNode.prototype = {
1045     /**
1046      * @override
1047      * @return {!WebInspector.HeapSnapshotProviderProxy}
1048      */
1049     createProvider: function()
1050     {
1051         return this._dataGrid.snapshot.createNodesProviderForClass(this._name, this._nodeFilter)
1052     },
1053
1054     /**
1055      * @param {number} snapshotObjectId
1056      * @param {function(boolean)} callback
1057      */
1058     revealNodeBySnapshotObjectId: function(snapshotObjectId, callback)
1059     {
1060         /**
1061          * @this {WebInspector.HeapSnapshotConstructorNode}
1062          */
1063         function didExpand()
1064         {
1065             this._provider().nodePosition(snapshotObjectId, didGetNodePosition.bind(this));
1066         }
1067
1068         /**
1069          * @this {WebInspector.HeapSnapshotConstructorNode}
1070          * @param {number} nodePosition
1071          */
1072         function didGetNodePosition(nodePosition)
1073         {
1074             if (nodePosition === -1) {
1075                 this.collapse();
1076                 callback(false);
1077             } else {
1078                 this._populateChildren(nodePosition, null, didPopulateChildren.bind(this, nodePosition));
1079             }
1080         }
1081
1082         /**
1083          * @this {WebInspector.HeapSnapshotConstructorNode}
1084          * @param {number} nodePosition
1085          */
1086         function didPopulateChildren(nodePosition)
1087         {
1088             var child = this.childForPosition(nodePosition);
1089             if (child) {
1090                 this._dataGrid.revealTreeNode([this, child]);
1091                 this._dataGrid.highlightNode(/** @type {!WebInspector.HeapSnapshotGridNode} */ (child));
1092             }
1093             callback(!!child);
1094         }
1095
1096         this._dataGrid.resetNameFilter();
1097         this.expandWithoutPopulate(didExpand.bind(this));
1098     },
1099
1100     /**
1101      * @param {string} filterValue
1102      * @return {boolean}
1103      */
1104     filteredOut: function(filterValue)
1105     {
1106         return this._name.toLowerCase().indexOf(filterValue) === -1;
1107     },
1108
1109     /**
1110      * @param {string} columnIdentifier
1111      * @return {!Element}
1112      */
1113     createCell: function(columnIdentifier)
1114     {
1115         var cell = columnIdentifier !== "object" ? this._createValueCell(columnIdentifier) : WebInspector.HeapSnapshotGridNode.prototype.createCell.call(this, columnIdentifier);
1116         if (this._searchMatched)
1117             cell.classList.add("highlight");
1118         return cell;
1119     },
1120
1121     /**
1122      * @param {!WebInspector.HeapSnapshotCommon.Node} item
1123      * @return {!WebInspector.HeapSnapshotInstanceNode}
1124      */
1125     _createChildNode: function(item)
1126     {
1127         return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
1128     },
1129
1130     /**
1131      * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
1132      */
1133     comparator: function()
1134     {
1135         var sortAscending = this._dataGrid.isSortOrderAscending();
1136         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
1137         var sortFields = {
1138             object: ["id", sortAscending, "retainedSize", false],
1139             distance: ["distance", sortAscending, "retainedSize", false],
1140             count: ["id", true, "retainedSize", false],
1141             shallowSize: ["selfSize", sortAscending, "id", true],
1142             retainedSize: ["retainedSize", sortAscending, "id", true]
1143         }[sortColumnIdentifier];
1144         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
1145     },
1146
1147     /**
1148      * @param {!WebInspector.HeapSnapshotCommon.Node} node
1149      * @return {number}
1150      */
1151     _childHashForEntity: function(node)
1152     {
1153         return node.id;
1154     },
1155
1156     /**
1157      * @param {!WebInspector.HeapSnapshotInstanceNode} childNode
1158      * @return {number}
1159      */
1160     _childHashForNode: function(childNode)
1161     {
1162         return childNode.snapshotNodeId;
1163     },
1164
1165     __proto__: WebInspector.HeapSnapshotGridNode.prototype
1166 }
1167
1168
1169 /**
1170  * @constructor
1171  * @implements {WebInspector.HeapSnapshotGridNode.ChildrenProvider}
1172  * @param {!WebInspector.HeapSnapshotProviderProxy} addedNodesProvider
1173  * @param {!WebInspector.HeapSnapshotProviderProxy} deletedNodesProvider
1174  * @param {number} addedCount
1175  * @param {number} removedCount
1176  */
1177 WebInspector.HeapSnapshotDiffNodesProvider = function(addedNodesProvider, deletedNodesProvider, addedCount, removedCount)
1178 {
1179     this._addedNodesProvider = addedNodesProvider;
1180     this._deletedNodesProvider = deletedNodesProvider;
1181     this._addedCount = addedCount;
1182     this._removedCount = removedCount;
1183 }
1184
1185 WebInspector.HeapSnapshotDiffNodesProvider.prototype = {
1186     dispose: function()
1187     {
1188         this._addedNodesProvider.dispose();
1189         this._deletedNodesProvider.dispose();
1190     },
1191
1192     /**
1193      * @override
1194      * @param {number} snapshotObjectId
1195      * @param {function(number)} callback
1196      */
1197     nodePosition: function(snapshotObjectId, callback)
1198     {
1199         throw new Error("Unreachable");
1200     },
1201
1202     /**
1203      * @param {function(boolean)} callback
1204      */
1205     isEmpty: function(callback)
1206     {
1207         callback(false);
1208     },
1209
1210     /**
1211      * @param {number} beginPosition
1212      * @param {number} endPosition
1213      * @param {!function(!WebInspector.HeapSnapshotCommon.ItemsRange)} callback
1214      */
1215     serializeItemsRange: function(beginPosition, endPosition, callback)
1216     {
1217         /**
1218          * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} items
1219          * @this {WebInspector.HeapSnapshotDiffNodesProvider}
1220          */
1221         function didReceiveAllItems(items)
1222         {
1223             items.totalLength = this._addedCount + this._removedCount;
1224             callback(items);
1225         }
1226
1227         /**
1228          * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} addedItems
1229          * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
1230          * @this {WebInspector.HeapSnapshotDiffNodesProvider}
1231          */
1232         function didReceiveDeletedItems(addedItems, itemsRange)
1233         {
1234             var items = itemsRange.items;
1235             if (!addedItems.items.length)
1236                 addedItems.startPosition = this._addedCount + itemsRange.startPosition;
1237             for (var i = 0; i < items.length; i++) {
1238                 items[i].isAddedNotRemoved = false;
1239                 addedItems.items.push(items[i]);
1240             }
1241             addedItems.endPosition = this._addedCount + itemsRange.endPosition;
1242             didReceiveAllItems.call(this, addedItems);
1243         }
1244
1245         /**
1246          * @param {!WebInspector.HeapSnapshotCommon.ItemsRange} itemsRange
1247          * @this {WebInspector.HeapSnapshotDiffNodesProvider}
1248          */
1249         function didReceiveAddedItems(itemsRange)
1250         {
1251             var items = itemsRange.items;
1252             for (var i = 0; i < items.length; i++)
1253                 items[i].isAddedNotRemoved = true;
1254             if (itemsRange.endPosition < endPosition)
1255                 return this._deletedNodesProvider.serializeItemsRange(0, endPosition - itemsRange.endPosition, didReceiveDeletedItems.bind(this, itemsRange));
1256
1257             itemsRange.totalLength = this._addedCount + this._removedCount;
1258             didReceiveAllItems.call(this, itemsRange);
1259         }
1260
1261         if (beginPosition < this._addedCount) {
1262             this._addedNodesProvider.serializeItemsRange(beginPosition, endPosition, didReceiveAddedItems.bind(this));
1263         } else {
1264             var emptyRange = new WebInspector.HeapSnapshotCommon.ItemsRange(0, 0, 0, []);
1265             this._deletedNodesProvider.serializeItemsRange(beginPosition - this._addedCount, endPosition - this._addedCount, didReceiveDeletedItems.bind(this, emptyRange));
1266         }
1267     },
1268
1269     /**
1270      * @param {!WebInspector.HeapSnapshotCommon.ComparatorConfig} comparator
1271      * @param {function()} callback
1272      */
1273     sortAndRewind: function(comparator, callback)
1274     {
1275         /**
1276          * @this {WebInspector.HeapSnapshotDiffNodesProvider}
1277          */
1278         function afterSort()
1279         {
1280             this._deletedNodesProvider.sortAndRewind(comparator, callback);
1281         }
1282         this._addedNodesProvider.sortAndRewind(comparator, afterSort.bind(this));
1283     }
1284 };
1285
1286 /**
1287  * @constructor
1288  * @param {!WebInspector.HeapSnapshotDiffDataGrid} dataGrid
1289  * @param {string} className
1290  * @param {!WebInspector.HeapSnapshotCommon.DiffForClass} diffForClass
1291  * @extends {WebInspector.HeapSnapshotGridNode}
1292  */
1293 WebInspector.HeapSnapshotDiffNode = function(dataGrid, className, diffForClass)
1294 {
1295     WebInspector.HeapSnapshotGridNode.call(this, dataGrid, true);
1296     this._name = className;
1297     this._addedCount = diffForClass.addedCount;
1298     this._removedCount = diffForClass.removedCount;
1299     this._countDelta = diffForClass.countDelta;
1300     this._addedSize = diffForClass.addedSize;
1301     this._removedSize = diffForClass.removedSize;
1302     this._sizeDelta = diffForClass.sizeDelta;
1303     this._deletedIndexes = diffForClass.deletedIndexes;
1304     this.data = {
1305         "object": className,
1306         "addedCount": Number.withThousandsSeparator(this._addedCount),
1307         "removedCount": Number.withThousandsSeparator(this._removedCount),
1308         "countDelta":  this._signForDelta(this._countDelta) + Number.withThousandsSeparator(Math.abs(this._countDelta)),
1309         "addedSize": Number.withThousandsSeparator(this._addedSize),
1310         "removedSize": Number.withThousandsSeparator(this._removedSize),
1311         "sizeDelta": this._signForDelta(this._sizeDelta) + Number.withThousandsSeparator(Math.abs(this._sizeDelta))
1312     };
1313 }
1314
1315 WebInspector.HeapSnapshotDiffNode.prototype = {
1316     /**
1317      * @override
1318      * @return {!WebInspector.HeapSnapshotDiffNodesProvider}
1319      */
1320     createProvider: function()
1321     {
1322         var tree = this._dataGrid;
1323         return new WebInspector.HeapSnapshotDiffNodesProvider(
1324             tree.snapshot.createAddedNodesProvider(tree.baseSnapshot.uid, this._name),
1325             tree.baseSnapshot.createDeletedNodesProvider(this._deletedIndexes),
1326             this._addedCount,
1327             this._removedCount);
1328     },
1329
1330     /**
1331      * @param {string} columnIdentifier
1332      * @return {!Element}
1333      */
1334     createCell: function(columnIdentifier)
1335     {
1336         var cell = WebInspector.HeapSnapshotGridNode.prototype.createCell.call(this, columnIdentifier);
1337         if (columnIdentifier !== "object")
1338             cell.classList.add("numeric-column");
1339         return cell;
1340     },
1341
1342     /**
1343      * @param {!WebInspector.HeapSnapshotCommon.Node} item
1344      * @return {!WebInspector.HeapSnapshotInstanceNode}
1345      */
1346     _createChildNode: function(item)
1347     {
1348         if (item.isAddedNotRemoved)
1349             return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.snapshot, item, false);
1350         else
1351             return new WebInspector.HeapSnapshotInstanceNode(this._dataGrid, this._dataGrid.baseSnapshot, item, true);
1352     },
1353
1354     /**
1355      * @param {!WebInspector.HeapSnapshotCommon.Node} node
1356      * @return {number}
1357      */
1358     _childHashForEntity: function(node)
1359     {
1360         return node.id;
1361     },
1362
1363     /**
1364      * @param {!WebInspector.HeapSnapshotInstanceNode} childNode
1365      * @return {number}
1366      */
1367     _childHashForNode: function(childNode)
1368     {
1369         return childNode.snapshotNodeId;
1370     },
1371
1372     /**
1373      * @return {!WebInspector.HeapSnapshotCommon.ComparatorConfig}
1374      */
1375     comparator: function()
1376     {
1377         var sortAscending = this._dataGrid.isSortOrderAscending();
1378         var sortColumnIdentifier = this._dataGrid.sortColumnIdentifier();
1379         var sortFields = {
1380             object: ["id", sortAscending, "selfSize", false],
1381             addedCount: ["selfSize", sortAscending, "id", true],
1382             removedCount: ["selfSize", sortAscending, "id", true],
1383             countDelta: ["selfSize", sortAscending, "id", true],
1384             addedSize: ["selfSize", sortAscending, "id", true],
1385             removedSize: ["selfSize", sortAscending, "id", true],
1386             sizeDelta: ["selfSize", sortAscending, "id", true]
1387         }[sortColumnIdentifier];
1388         return WebInspector.HeapSnapshotGridNode.createComparator(sortFields);
1389     },
1390
1391     /**
1392      * @param {string} filterValue
1393      * @return {boolean}
1394      */
1395     filteredOut: function(filterValue)
1396     {
1397         return this._name.toLowerCase().indexOf(filterValue) === -1;
1398     },
1399
1400     _signForDelta: function(delta)
1401     {
1402         if (delta === 0)
1403             return "";
1404         if (delta > 0)
1405             return "+";
1406         else
1407             return "\u2212";  // Math minus sign, same width as plus.
1408     },
1409
1410     __proto__: WebInspector.HeapSnapshotGridNode.prototype
1411 }
1412
1413
1414 /**
1415  * @constructor
1416  * @extends {WebInspector.HeapSnapshotGridNode}
1417  * @param {!WebInspector.AllocationDataGrid} dataGrid
1418  * @param {!WebInspector.HeapSnapshotCommon.SerializedAllocationNode} data
1419  */
1420 WebInspector.AllocationGridNode = function(dataGrid, data)
1421 {
1422     WebInspector.HeapSnapshotGridNode.call(this, dataGrid, data.hasChildren);
1423     this._populated = false;
1424     this._allocationNode = data;
1425     this.data = {
1426         "liveCount": Number.withThousandsSeparator(data.liveCount),
1427         "count": Number.withThousandsSeparator(data.count),
1428         "liveSize": Number.withThousandsSeparator(data.liveSize),
1429         "size": Number.withThousandsSeparator(data.size),
1430         "name": data.name
1431     };
1432 }
1433
1434 WebInspector.AllocationGridNode.prototype = {
1435     populate: function()
1436     {
1437         if (this._populated)
1438             return;
1439         this._populated = true;
1440         this._dataGrid.snapshot.allocationNodeCallers(this._allocationNode.id, didReceiveCallers.bind(this));
1441
1442         /**
1443          * @param {!WebInspector.HeapSnapshotCommon.AllocationNodeCallers} callers
1444          * @this {WebInspector.AllocationGridNode}
1445          */
1446         function didReceiveCallers(callers)
1447         {
1448             var callersChain = callers.nodesWithSingleCaller;
1449             var parentNode = this;
1450             var dataGrid = /** @type {!WebInspector.AllocationDataGrid} */ (this._dataGrid);
1451             for (var i = 0; i < callersChain.length; i++) {
1452                 var child = new WebInspector.AllocationGridNode(dataGrid, callersChain[i]);
1453                 dataGrid.appendNode(parentNode, child);
1454                 parentNode = child;
1455                 parentNode._populated = true;
1456                 if (this.expanded)
1457                     parentNode.expand();
1458             }
1459
1460             var callersBranch = callers.branchingCallers;
1461             callersBranch.sort(this._dataGrid._createComparator());
1462             for (var i = 0; i < callersBranch.length; i++)
1463                 dataGrid.appendNode(parentNode, new WebInspector.AllocationGridNode(dataGrid, callersBranch[i]));
1464             dataGrid.updateVisibleNodes(true);
1465         }
1466     },
1467
1468     /**
1469      * @override
1470      */
1471     expand: function()
1472     {
1473         WebInspector.HeapSnapshotGridNode.prototype.expand.call(this);
1474         if (this.children.length === 1)
1475             this.children[0].expand();
1476     },
1477
1478     /**
1479      * @override
1480      * @param {string} columnIdentifier
1481      * @return {!Element}
1482      */
1483     createCell: function(columnIdentifier)
1484     {
1485         if (columnIdentifier !== "name")
1486             return this._createValueCell(columnIdentifier);
1487
1488         var cell = WebInspector.HeapSnapshotGridNode.prototype.createCell.call(this, columnIdentifier);
1489         var allocationNode = this._allocationNode;
1490         var target = this._dataGrid.target();
1491         if (allocationNode.scriptId) {
1492             var linkifier = this._dataGrid._linkifier;
1493             var urlElement = linkifier.linkifyScriptLocation(target, String(allocationNode.scriptId), allocationNode.scriptName, allocationNode.line - 1, allocationNode.column - 1, "profile-node-file");
1494             urlElement.style.maxWidth = "75%";
1495             cell.insertBefore(urlElement, cell.firstChild);
1496         }
1497         return cell;
1498     },
1499
1500     /**
1501      * @return {number}
1502      */
1503     allocationNodeId: function()
1504     {
1505         return this._allocationNode.id;
1506     },
1507
1508     __proto__: WebInspector.HeapSnapshotGridNode.prototype
1509 }