src/third_party/WebKit/LayoutTests/inspector/profiler/heap-snapshot-test.js

   1 var initialize_HeapSnapshotTest = function() {
   2
   3 InspectorTest.createHeapSnapshotMockFactories = function() {
   4
   5 InspectorTest.createJSHeapSnapshotMockObject = function()
   6 {
   7     return {
   8         _rootNodeIndex: 0,
   9         _nodeTypeOffset: 0,
  10         _nodeNameOffset: 1,
  11         _nodeEdgeCountOffset: 2,
  12         _nodeFieldCount: 3,
  13         _edgeFieldsCount: 3,
  14         _edgeTypeOffset: 0,
  15         _edgeNameOffset: 1,
  16         _edgeToNodeOffset: 2,
  17         _nodeTypes: ["hidden", "object"],
  18         _edgeTypes: ["element", "property", "shortcut"],
  19         _edgeShortcutType: -1,
  20         _edgeHiddenType: -1,
  21         _edgeElementType: 0,
  22         _realNodesLength: 18,
  23         // Represents the following graph:
  24         //   (numbers in parentheses indicate node offset)
  25         //
  26         //         -> A (3) --ac- C (9) -ce- E(15)
  27         //       a/   |          /
  28         //  "" (0)    1    - bc -
  29         //       b\   v   /
  30         //         -> B (6) -bd- D (12)
  31         //
  32         _nodes: new Uint32Array([
  33             0, 0, 2,    //  0: root
  34             1, 1, 2,    //  3: A
  35             1, 2, 2,    //  6: B
  36             1, 3, 1,    //  9: C
  37             1, 4, 0,    // 12: D
  38             1, 5, 0]),  // 15: E
  39         _containmentEdges: new Uint32Array([
  40             2,  6, 3,   //  0: shortcut 'a' to node 'A'
  41             1,  7, 6,   //  3: property 'b' to node 'B'
  42             0,  1, 6,   //  6: element '1' to node 'B'
  43             1,  8, 9,   //  9: property 'ac' to node 'C'
  44             1,  9, 9,   // 12: property 'bc' to node 'C'
  45             1, 10, 12,  // 15: property 'bd' to node 'D'
  46             1, 11, 15]),// 18: property 'ce' to node 'E'
  47         _strings: ["", "A", "B", "C", "D", "E", "a", "b", "ac", "bc", "bd", "ce"],
  48         _firstEdgeIndexes: new Uint32Array([0, 6, 12, 18, 21, 21, 21]),
  49         createNode: WebInspector.JSHeapSnapshot.prototype.createNode,
  50         createEdge: WebInspector.JSHeapSnapshot.prototype.createEdge,
  51         createRetainingEdge: WebInspector.JSHeapSnapshot.prototype.createRetainingEdge
  52     };
  53 };
  54
  55 InspectorTest.createHeapSnapshotMockRaw = function()
  56 {
  57     // Effectively the same graph as in createJSHeapSnapshotMockObject,
  58     // but having full set of fields.
  59     //
  60     // A triple in parentheses indicates node index, self size and
  61     // retained size.
  62     //
  63     //          --- A (14,2,2) --ac- C (40,4,10) -ce- E(57,6,6)
  64     //         /    |                /
  65     //  "" (1,0,20) 1       --bc-----
  66     //         \    v      /
  67     //          --- B (27,3,8) --bd- D (50,5,5)
  68     //
  69     return {
  70         snapshot: {
  71             meta: {
  72                 node_fields: ["type", "name", "id", "self_size", "retained_size", "dominator", "edge_count"],
  73                 node_types: [["hidden", "object"], "", "", "", "", "", ""],
  74                 edge_fields: ["type", "name_or_index", "to_node"],
  75                 edge_types: [["element", "property", "shortcut"], "", ""]
  76             },
  77             node_count: 6,
  78             edge_count: 7},
  79         nodes: [
  80             0, 0, 1, 0, 20,  0, 2,  // root (0)
  81             1, 1, 2, 2,  2,  0, 2,  // A (7)
  82             1, 2, 3, 3,  8,  0, 2,  // B (14)
  83             1, 3, 4, 4, 10,  0, 1,  // C (21)
  84             1, 4, 5, 5,  5, 14, 0,  // D (28)
  85             1, 5, 6, 6,  6, 21, 0], // E (35)
  86         edges: [
  87             // root node edges
  88             2,  6,  7, // shortcut 'a' to node 'A'
  89             1,  7, 14, // property 'b' to node 'B'
  90
  91             // A node edges
  92             0,  1, 14, // element 1 to node 'B'
  93             1,  8, 21, // property 'ac' to node 'C'
  94
  95             // B node edges
  96             1,  9, 21, // property 'bc' to node 'C'
  97             1, 10, 28, // property 'bd' to node 'D'
  98
  99             // C node edges
 100             1, 11, 35], // property 'ce' to node 'E'
 101         strings: ["", "A", "B", "C", "D", "E", "a", "b", "ac", "bc", "bd", "ce"]
 102     };
 103 };
 104
 105 InspectorTest._postprocessHeapSnapshotMock = function(mock)
 106 {
 107     mock.nodes = new Uint32Array(mock.nodes);
 108     mock.edges = new Uint32Array(mock.edges);
 109     return mock;
 110 };
 111
 112 InspectorTest.createHeapSnapshotMock = function()
 113 {
 114     return InspectorTest._postprocessHeapSnapshotMock(InspectorTest.createHeapSnapshotMockRaw());
 115 };
 116
 117 InspectorTest.createHeapSnapshotMockWithDOM = function()
 118 {
 119     return InspectorTest._postprocessHeapSnapshotMock({
 120         snapshot: {
 121             meta: {
 122                 node_fields: ["type", "name", "id", "edge_count"],
 123                 node_types: [["hidden", "object", "synthetic"], "", "", ""],
 124                 edge_fields: ["type", "name_or_index", "to_node"],
 125                 edge_types: [["element", "hidden", "internal"], "", ""]
 126             },
 127             node_count: 13,
 128             edge_count: 13
 129         },
 130         nodes: [
 131             // A tree with Window objects.
 132             //
 133             //    |----->Window--->A
 134             //    |             \
 135             //    |----->Window--->B--->C
 136             //    |        |     \
 137             //  (root)   hidden   --->D--internal / "native"-->N
 138             //    |          \        |
 139             //    |----->E    H    internal
 140             //    |                   v
 141             //    |----->F--->G       M
 142             //
 143             /* (root) */    2,  0,  1, 4,
 144             /* Window */    1, 11,  2, 2,
 145             /* Window */    1, 11,  3, 3,
 146             /* E */         2,  5,  4, 0,
 147             /* F */         2,  6,  5, 1,
 148             /* A */         1,  1,  6, 0,
 149             /* B */         1,  2,  7, 1,
 150             /* D */         1,  4,  8, 2,
 151             /* H */         1,  8,  9, 0,
 152             /* G */         1,  7, 10, 0,
 153             /* C */         1,  3, 11, 0,
 154             /* N */         1, 10, 12, 0,
 155             /* M */         1,  9, 13, 0
 156             ],
 157         edges: [
 158             /* from (root) */  0,  1,  4, 0, 2,  8, 0, 3, 12, 0, 4, 16,
 159             /* from Window */  0,  1, 20, 0, 2, 24,
 160             /* from Window */  0,  1, 24, 0, 2, 28, 1, 3, 32,
 161             /* from F */       0,  1, 36,
 162             /* from B */       0,  1, 40,
 163             /* from D */       2, 12, 44, 2, 1, 48
 164             ],
 165         strings: ["", "A", "B", "C", "D", "E", "F", "G", "H", "M", "N", "Window", "native"]
 166     });
 167 };
 168
 169 InspectorTest.HeapNode = function(name, selfSize, type, id)
 170 {
 171     this._type = type || InspectorTest.HeapNode.Type.object;
 172     this._name = name;
 173     this._selfSize = selfSize || 0;
 174     this._builder = null;
 175     this._edges = {};
 176     this._edgesCount = 0;
 177     this._id = id;
 178 }
 179
 180 InspectorTest.HeapNode.Type = {
 181     "hidden": "hidden",
 182     "array": "array",
 183     "string": "string",
 184     "object": "object",
 185     "code": "code",
 186     "closure": "closure",
 187     "regexp": "regexp",
 188     "number": "number",
 189     "native": "native",
 190     "synthetic": "synthetic"
 191 };
 192
 193 InspectorTest.HeapNode.prototype = {
 194     linkNode: function(node, type, nameOrIndex)
 195     {
 196         if (!this._builder)
 197             throw new Error("parent node is not connected to a snapshot");
 198
 199         if (!node._builder)
 200             node._setBuilder(this._builder);
 201
 202         if (nameOrIndex === undefined)
 203             nameOrIndex = this._edgesCount;
 204         ++this._edgesCount;
 205
 206         if (nameOrIndex in this._edges)
 207             throw new Error("Can't add edge with the same nameOrIndex. nameOrIndex: " + nameOrIndex + " oldNodeName: " + this._edges[nameOrIndex]._name + " newNodeName: " + node._name);
 208         this._edges[nameOrIndex] = new InspectorTest.HeapEdge(node, type, nameOrIndex);
 209     },
 210
 211     _setBuilder: function(builder)
 212     {
 213         if (this._builder)
 214             throw new Error("node reusing is prohibited");
 215
 216         this._builder = builder;
 217         this._ordinal = this._builder._registerNode(this);
 218     },
 219
 220     _serialize: function(rawSnapshot)
 221     {
 222         rawSnapshot.nodes.push(this._builder.lookupNodeType(this._type));
 223         rawSnapshot.nodes.push(this._builder.lookupOrAddString(this._name));
 224         // JS engine snapshot impementation generates monotonicaly increasing odd id for JS objects,
 225         // and even ids based on a hash for native DOMObject groups.
 226         rawSnapshot.nodes.push(this._id || this._ordinal * 2 + 1);
 227         rawSnapshot.nodes.push(this._selfSize);
 228         rawSnapshot.nodes.push(0);                               // retained_size
 229         rawSnapshot.nodes.push(0);                               // dominator
 230         rawSnapshot.nodes.push(Object.keys(this._edges).length); // edge_count
 231
 232         for (var i in this._edges)
 233             this._edges[i]._serialize(rawSnapshot);
 234     }
 235 }
 236
 237 InspectorTest.HeapEdge = function(targetNode, type, nameOrIndex)
 238 {
 239     this._targetNode = targetNode;
 240     this._type = type;
 241     this._nameOrIndex = nameOrIndex;
 242 }
 243
 244 InspectorTest.HeapEdge.prototype = {
 245     _serialize: function(rawSnapshot)
 246     {
 247         if (!this._targetNode._builder)
 248             throw new Error("Inconsistent state of node: " + this._name + " no builder assigned");
 249         var builder = this._targetNode._builder;
 250         rawSnapshot.edges.push(builder.lookupEdgeType(this._type));
 251         rawSnapshot.edges.push(typeof this._nameOrIndex === "string" ? builder.lookupOrAddString(this._nameOrIndex) : this._nameOrIndex);
 252         rawSnapshot.edges.push(this._targetNode._ordinal * builder.nodeFieldsCount); // index
 253     }
 254 }
 255
 256 InspectorTest.HeapEdge.Type = {
 257     "context": "context",
 258     "element": "element",
 259     "property": "property",
 260     "internal": "internal",
 261     "hidden": "hidden",
 262     "shortcut": "shortcut"
 263 };
 264
 265 InspectorTest.HeapSnapshotBuilder = function()
 266 {
 267     this._nodes = [];
 268     this._string2id = {};
 269     this._strings = [];
 270     this.nodeFieldsCount = 7;
 271
 272     this._nodeTypesMap = {};
 273     this._nodeTypesArray = [];
 274     for (var nodeType in InspectorTest.HeapNode.Type) {
 275         this._nodeTypesMap[nodeType] = this._nodeTypesArray.length
 276         this._nodeTypesArray.push(nodeType);
 277     }
 278
 279     this._edgeTypesMap = {};
 280     this._edgeTypesArray = [];
 281     for (var edgeType in InspectorTest.HeapEdge.Type) {
 282         this._edgeTypesMap[edgeType] = this._edgeTypesArray.length
 283         this._edgeTypesArray.push(edgeType);
 284     }
 285
 286     this.rootNode = new InspectorTest.HeapNode("root", 0, "object");
 287     this.rootNode._setBuilder(this);
 288 }
 289
 290 InspectorTest.HeapSnapshotBuilder.prototype = {
 291     generateSnapshot: function()
 292     {
 293         var rawSnapshot = {
 294             "snapshot": {
 295                 "meta": {
 296                     "node_fields": ["type","name","id","self_size","retained_size","dominator","edge_count"],
 297                     "node_types": [
 298                         this._nodeTypesArray,
 299                         "string",
 300                         "number",
 301                         "number",
 302                         "number",
 303                         "number",
 304                         "number"
 305                     ],
 306                     "edge_fields": ["type","name_or_index","to_node"],
 307                     "edge_types": [
 308                         this._edgeTypesArray,
 309                         "string_or_number",
 310                         "node"
 311                     ]
 312                 }
 313             },
 314             "nodes": [],
 315             "edges":[],
 316             "strings": []
 317         };
 318
 319         for (var i = 0; i < this._nodes.length; ++i)
 320             this._nodes[i]._serialize(rawSnapshot);
 321
 322         rawSnapshot.strings = this._strings.slice();
 323
 324         var meta = rawSnapshot.snapshot.meta;
 325         rawSnapshot.snapshot.edge_count = rawSnapshot.edges.length / meta.edge_fields.length;
 326         rawSnapshot.snapshot.node_count = rawSnapshot.nodes.length / meta.node_fields.length;
 327
 328         return rawSnapshot;
 329     },
 330
 331     createJSHeapSnapshot: function()
 332     {
 333         var parsedSnapshot = InspectorTest._postprocessHeapSnapshotMock(this.generateSnapshot());
 334         return new WebInspector.JSHeapSnapshot(parsedSnapshot, new WebInspector.HeapSnapshotProgress());
 335     },
 336
 337     _registerNode: function(node)
 338     {
 339         this._nodes.push(node);
 340         return this._nodes.length - 1;
 341     },
 342
 343     lookupNodeType: function(typeName)
 344     {
 345         if (typeName === undefined)
 346             throw new Error("wrong node type: " + typeName);
 347         if (!typeName in this._nodeTypesMap)
 348             throw new Error("wrong node type name: " + typeName);
 349         return this._nodeTypesMap[typeName];
 350     },
 351
 352     lookupEdgeType: function(typeName)
 353     {
 354         if (!typeName in this._edgeTypesMap)
 355             throw new Error("wrong edge type name: " + typeName);
 356         return this._edgeTypesMap[typeName];
 357     },
 358
 359     lookupOrAddString: function(string)
 360     {
 361         if (string in this._string2id)
 362             return this._string2id[string];
 363         this._string2id[string] = this._strings.length;
 364         this._strings.push(string);
 365         return this._strings.length - 1;
 366     }
 367 }
 368
 369 InspectorTest.createHeapSnapshot = function(instanceCount, firstId)
 370 {
 371     // Mocking results of running the following code:
 372     //
 373     // function A() { this.a = this; }
 374     // function B() { this.a = new A(); }
 375     // for (var i = 0; i < instanceCount; ++i) window[i] = new B();
 376     //
 377     // Set A and B object sizes to pseudo random numbers. It is used in sorting tests.
 378
 379     var seed = 881669;
 380     function pseudoRandom(limit) {
 381         seed = ((seed * 355109 + 153763) >> 2) & 0xffff;
 382         return seed % limit;
 383     }
 384
 385     var builder = new InspectorTest.HeapSnapshotBuilder();
 386     var rootNode = builder.rootNode;
 387
 388     var gcRootsNode = new InspectorTest.HeapNode("(GC roots)", 0, InspectorTest.HeapNode.Type.synthetic);
 389     rootNode.linkNode(gcRootsNode, InspectorTest.HeapEdge.Type.element);
 390
 391     var windowNode = new InspectorTest.HeapNode("Window", 20);
 392     rootNode.linkNode(windowNode, InspectorTest.HeapEdge.Type.shortcut);
 393     gcRootsNode.linkNode(windowNode, InspectorTest.HeapEdge.Type.element);
 394
 395     for (var i = 0; i < instanceCount; ++i) {
 396         var sizeOfB = pseudoRandom(20) + 1;
 397         var nodeB = new InspectorTest.HeapNode("B", sizeOfB, undefined, firstId++);
 398         windowNode.linkNode(nodeB, InspectorTest.HeapEdge.Type.element);
 399         var sizeOfA = pseudoRandom(50) + 1;
 400         var nodeA = new InspectorTest.HeapNode("A", sizeOfA, undefined, firstId++);
 401         nodeB.linkNode(nodeA, InspectorTest.HeapEdge.Type.property, "a");
 402         nodeA.linkNode(nodeA, InspectorTest.HeapEdge.Type.property, "a");
 403     }
 404     return builder.generateSnapshot();
 405 }
 406
 407 }
 408
 409 InspectorTest.createHeapSnapshotMockFactories();
 410
 411
 412 InspectorTest.startProfilerTest = function(callback)
 413 {
 414     WebInspector.inspectorView.showPanel("profiles");
 415     WebInspector.settings.showAdvancedHeapSnapshotProperties.set(true);
 416
 417     InspectorTest.addResult("Profiler was enabled.");
 418     // We mock out HeapProfilerAgent -- as DRT runs in single-process mode, Inspector
 419     // and test share the same heap. Taking a snapshot takes too long for a test,
 420     // so we provide synthetic snapshots.
 421     InspectorTest._panelReset = InspectorTest.override(WebInspector.panels.profiles, "_reset", function(){}, true);
 422     InspectorTest.addSniffer(WebInspector.HeapSnapshotView.prototype, "show", InspectorTest._snapshotViewShown, true);
 423
 424     // Reduce the number of populated nodes to speed up testing.
 425     WebInspector.HeapSnapshotContainmentDataGrid.prototype.defaultPopulateCount = function() { return 10; };
 426     WebInspector.HeapSnapshotConstructorsDataGrid.prototype.defaultPopulateCount = function() { return 10; };
 427     WebInspector.HeapSnapshotDiffDataGrid.prototype.defaultPopulateCount = function() { return 5; };
 428     WebInspector.HeapSnapshotDominatorsDataGrid.prototype.defaultPopulateCount = function() { return 3; }
 429     InspectorTest.addResult("Detailed heap profiles were enabled.");
 430     InspectorTest.safeWrap(callback)();
 431 };
 432
 433 InspectorTest.completeProfilerTest = function()
 434 {
 435     // There is no way to disable detailed heap profiles.
 436     InspectorTest.addResult("");
 437     InspectorTest.addResult("Profiler was disabled.");
 438     InspectorTest.completeTest();
 439 };
 440
 441 InspectorTest.runHeapSnapshotTestSuite = function(testSuite)
 442 {
 443     var testSuiteTests = testSuite.slice();
 444     var completeTestStack;
 445
 446     function runner()
 447     {
 448         if (!testSuiteTests.length) {
 449             if (completeTestStack)
 450                 InspectorTest.addResult("FAIL: test already completed at " + completeTestStack);
 451             InspectorTest.completeProfilerTest();
 452             completeTestStack = new Error().stack;
 453             return;
 454         }
 455
 456         var nextTest = testSuiteTests.shift();
 457         InspectorTest.addResult("");
 458         InspectorTest.addResult("Running: " + /function\s([^(]*)/.exec(nextTest)[1]);
 459         InspectorTest._panelReset.call(WebInspector.panels.profiles);
 460         InspectorTest.safeWrap(nextTest)(runner, runner);
 461     }
 462
 463     InspectorTest.startProfilerTest(runner);
 464 };
 465
 466 InspectorTest.assertColumnContentsEqual = function(reference, actual)
 467 {
 468     var length = Math.min(reference.length, actual.length);
 469     for (var i = 0; i < length; ++i)
 470         InspectorTest.assertEquals(reference[i], actual[i], "row " + i);
 471     if (reference.length > length)
 472         InspectorTest.addResult("extra rows in reference array:\n" + reference.slice(length).join("\n"));
 473     else if (actual.length > length)
 474         InspectorTest.addResult("extra rows in actual array:\n" + actual.slice(length).join("\n"));
 475 };
 476
 477 InspectorTest.checkArrayIsSorted = function(contents, sortType, sortOrder)
 478 {
 479     function simpleComparator(a, b)
 480     {
 481         return a < b ? -1 : (a > b ? 1 : 0);
 482     }
 483     function parseSize(size)
 484     {
 485         // Remove thousands separator.
 486         return parseInt(size.replace(/[\u2009,]/g, ""), 10);
 487     }
 488     var extractor = {
 489         text: function (data) { data; },
 490         number: function (data) { return parseInt(data, 10); },
 491         size: parseSize,
 492         name: function (data) { return data; },
 493         id: function (data) { return parseInt(data, 10); }
 494     }[sortType];
 495     var acceptableComparisonResult = {
 496         ascending: -1,
 497         descending: 1
 498     }[sortOrder];
 499
 500     if (!extractor) {
 501         InspectorTest.addResult("Invalid sort type: " + sortType);
 502         return;
 503     }
 504     if (!acceptableComparisonResult) {
 505         InspectorTest.addResult("Invalid sort order: " + sortOrder);
 506         return;
 507     }
 508
 509     for (var i = 0; i < contents.length - 1; ++i) {
 510         var a = extractor(contents[i]);
 511         var b = extractor(contents[i + 1]);
 512         var result = simpleComparator(a, b);
 513         if (result !== 0 && result !== acceptableComparisonResult) {
 514             InspectorTest.addResult("Elements " + i + " and " + (i + 1) + " are out of order: " + a + " " + b + " (" + sortOrder + ")");
 515         }
 516     }
 517 };
 518
 519 InspectorTest.clickColumn = function(column, callback)
 520 {
 521     callback = InspectorTest.safeWrap(callback);
 522     var cell = this._currentGrid()._headerTableHeaders[column.identifier];
 523     var event = { target: { enclosingNodeOrSelfWithNodeName: function() { return cell; } } };
 524
 525     function sortingComplete()
 526     {
 527         InspectorTest._currentGrid().removeEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
 528         InspectorTest.assertEquals(column.identifier, this._currentGrid().sortColumnIdentifier(), "unexpected sorting");
 529         column.sort = this._currentGrid().sortOrder();
 530         function callCallback()
 531         {
 532             callback(column);
 533         }
 534         setTimeout(callCallback, 0);
 535     }
 536     InspectorTest._currentGrid().addEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
 537     this._currentGrid()._clickInHeaderCell(event);
 538 };
 539
 540 InspectorTest.clickRowAndGetRetainers = function(row, callback)
 541 {
 542     callback = InspectorTest.safeWrap(callback);
 543     var event = {
 544         target: {
 545             enclosingNodeOrSelfWithNodeName: function() { return row._element; },
 546             selectedNode: row
 547         }
 548     };
 549     this._currentGrid()._mouseDownInDataTable(event);
 550     var rootNode = InspectorTest.currentProfileView()._retainmentDataGrid.rootNode();
 551     function populateComplete()
 552     {
 553         rootNode.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 554         callback(rootNode);
 555     }
 556     rootNode.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 557 };
 558
 559 InspectorTest.clickShowMoreButton = function(buttonName, row, callback)
 560 {
 561     callback = InspectorTest.safeWrap(callback);
 562     var parent = row.parent;
 563     function populateComplete()
 564     {
 565         parent.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 566         function callCallback()
 567         {
 568             callback(parent);
 569         }
 570         setTimeout(callCallback, 0);
 571     }
 572     parent.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 573     row[buttonName].click();
 574 };
 575
 576 InspectorTest.columnContents = function(column, row)
 577 {
 578     // Make sure invisible nodes are removed from the view port.
 579     this._currentGrid().updateVisibleNodes();
 580     var result = [];
 581     var parent = row || this._currentGrid().rootNode();
 582     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
 583         if (!node.selectable)
 584             continue;
 585         var cell = node.element.children[column.ordinal];
 586         var content = cell.firstElementChild;
 587         // Do not inlcude percents
 588         if (content.firstElementChild)
 589             content = content.firstElementChild;
 590         result.push(content.textContent);
 591     }
 592     return result;
 593 };
 594
 595 InspectorTest.countDataRows = function(row, filter)
 596 {
 597     var result = 0;
 598     filter = filter || function(node) { return node.selectable; };
 599     for (var node = row.children[0]; node; node = node.traverseNextNode(true, row, true)) {
 600         if (filter(node))
 601             ++result;
 602     }
 603     return result;
 604 };
 605
 606 InspectorTest.expandRow = function(row, callback)
 607 {
 608     callback = InspectorTest.safeWrap(callback);
 609     function populateComplete()
 610     {
 611         row.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 612         function callCallback()
 613         {
 614             callback(row);
 615         }
 616         setTimeout(callCallback, 0);
 617     }
 618     row.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 619     (function expand()
 620     {
 621         if (row.hasChildren)
 622             row.expand();
 623         else
 624             setTimeout(expand, 0);
 625     })();
 626 };
 627
 628 InspectorTest.findAndExpandGCRoots = function(callback)
 629 {
 630     InspectorTest.findAndExpandRow("(GC roots)", callback);
 631 };
 632
 633 InspectorTest.findAndExpandWindow = function(callback)
 634 {
 635     InspectorTest.findAndExpandRow("Window", callback);
 636 };
 637
 638 InspectorTest.findAndExpandRow = function(name, callback)
 639 {
 640     callback = InspectorTest.safeWrap(callback);
 641     var row = InspectorTest.findRow(name);
 642     InspectorTest.assertEquals(true, !!row, '"' + name + '" row');
 643     InspectorTest.expandRow(row, callback);
 644 };
 645
 646 InspectorTest.findButtonsNode = function(row, startNode)
 647 {
 648     var result = 0;
 649     for (var node = startNode || row.children[0]; node; node = node.traverseNextNode(true, row, true)) {
 650         if (!node.selectable && node.showNext)
 651             return node;
 652     }
 653     return null;
 654 };
 655
 656 InspectorTest.findRow = function(name, parent)
 657 {
 658     function matcher(x)
 659     {
 660         return x._name === name;
 661     };
 662     return InspectorTest.findMatchingRow(matcher, parent);
 663 };
 664
 665 InspectorTest.findMatchingRow = function(matcher, parent)
 666 {
 667     parent = parent || this._currentGrid().rootNode();
 668     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
 669         if (matcher(node))
 670             return node;
 671     }
 672     return null;
 673 };
 674
 675 InspectorTest.switchToView = function(title, callback)
 676 {
 677     callback = InspectorTest.safeWrap(callback);
 678     var view = WebInspector.panels.profiles.visibleView;
 679     view._changePerspectiveAndWait(title, callback);
 680     // Increase the grid container height so the viewport don't limit the number of nodes.
 681     InspectorTest._currentGrid().scrollContainer.style.height = "10000px";
 682 };
 683
 684 InspectorTest.takeAndOpenSnapshot = function(generator, callback)
 685 {
 686     callback = InspectorTest.safeWrap(callback);
 687     var snapshot = generator();
 688     var profileType =  WebInspector.ProfileTypeRegistry.instance.heapSnapshotProfileType;
 689     function pushGeneratedSnapshot(reportProgress, callback)
 690     {
 691         var profile = profileType.profileBeingRecorded();
 692         if (reportProgress) {
 693             profileType.reportHeapSnapshotProgress(50, 100, false);
 694             profileType.reportHeapSnapshotProgress(100, 100, true);
 695         }
 696         snapshot.snapshot.typeId = "HEAP";
 697         profileType.addHeapSnapshotChunk(JSON.stringify(snapshot));
 698         setTimeout(callback, 0);
 699     }
 700     InspectorTest.override(HeapProfilerAgent, "takeHeapSnapshot", pushGeneratedSnapshot);
 701     InspectorTest._takeAndOpenSnapshotCallback = callback;
 702     profileType._takeHeapSnapshot(function() { });
 703 };
 704
 705 InspectorTest.viewColumns = function()
 706 {
 707     return InspectorTest._currentGrid()._columnsArray;
 708 };
 709
 710 InspectorTest.currentProfileView = function()
 711 {
 712     return WebInspector.panels.profiles.visibleView;
 713 };
 714
 715 InspectorTest._currentGrid = function()
 716 {
 717     return this.currentProfileView()._dataGrid;
 718 };
 719
 720 InspectorTest._snapshotViewShown = function()
 721 {
 722     if (InspectorTest._takeAndOpenSnapshotCallback) {
 723         var callback = InspectorTest._takeAndOpenSnapshotCallback;
 724         InspectorTest._takeAndOpenSnapshotCallback = null;
 725         var dataGrid = this._dataGrid;
 726         function sortingComplete()
 727         {
 728             dataGrid.removeEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
 729             callback();
 730         }
 731         dataGrid.addEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
 732     }
 733 };
 734
 735 };