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: [
  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: [
  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: [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 };
 191
 192 InspectorTest.HeapNode.prototype = {
 193     linkNode: function(node, type, nameOrIndex)
 194     {
 195         if (!this._builder)
 196             throw new Error("parent node is not connected to a snapshot");
 197
 198         if (!node._builder)
 199             node._setBuilder(this._builder);
 200
 201         if (nameOrIndex === undefined)
 202             nameOrIndex = this._edgesCount;
 203         ++this._edgesCount;
 204
 205         if (nameOrIndex in this._edges)
 206             throw new Error("Can't add edge with the same nameOrIndex. nameOrIndex: " + nameOrIndex + " oldNodeName: " + this._edges[nameOrIndex]._name + " newNodeName: " + node._name);
 207         this._edges[nameOrIndex] = new InspectorTest.HeapEdge(node, type, nameOrIndex);
 208     },
 209
 210     _setBuilder: function(builder)
 211     {
 212         if (this._builder)
 213             throw new Error("node reusing is prohibited");
 214
 215         this._builder = builder;
 216         this._ordinal = this._builder._registerNode(this);
 217     },
 218
 219     _serialize: function(rawSnapshot)
 220     {
 221         rawSnapshot.nodes.push(this._builder.lookupNodeType(this._type));
 222         rawSnapshot.nodes.push(this._builder.lookupOrAddString(this._name));
 223         // JS engine snapshot impementation generates monotonicaly increasing odd id for JS objects,
 224         // and even ids based on a hash for native DOMObject groups.
 225         rawSnapshot.nodes.push(this._id || this._ordinal * 2 + 1);
 226         rawSnapshot.nodes.push(this._selfSize);
 227         rawSnapshot.nodes.push(0);                               // retained_size
 228         rawSnapshot.nodes.push(0);                               // dominator
 229         rawSnapshot.nodes.push(Object.keys(this._edges).length); // edge_count
 230
 231         for (var i in this._edges)
 232             this._edges[i]._serialize(rawSnapshot);
 233     }
 234 }
 235
 236 InspectorTest.HeapEdge = function(targetNode, type, nameOrIndex)
 237 {
 238     this._targetNode = targetNode;
 239     this._type = type;
 240     this._nameOrIndex = nameOrIndex;
 241 }
 242
 243 InspectorTest.HeapEdge.prototype = {
 244     _serialize: function(rawSnapshot)
 245     {
 246         if (!this._targetNode._builder)
 247             throw new Error("Inconsistent state of node: " + this._name + " no builder assigned");
 248         var builder = this._targetNode._builder;
 249         rawSnapshot.edges.push(builder.lookupEdgeType(this._type));
 250         rawSnapshot.edges.push(typeof this._nameOrIndex === "string" ? builder.lookupOrAddString(this._nameOrIndex) : this._nameOrIndex);
 251         rawSnapshot.edges.push(this._targetNode._ordinal * builder.nodeFieldsCount); // index
 252     }
 253 }
 254
 255 InspectorTest.HeapEdge.Type = {
 256     "context": "context",
 257     "element": "element",
 258     "property": "property",
 259     "internal": "internal",
 260     "hidden": "hidden",
 261     "shortcut": "shortcut"
 262 };
 263
 264 InspectorTest.HeapSnapshotBuilder = function()
 265 {
 266     this._nodes = [];
 267     this._string2id = {};
 268     this._strings = [];
 269     this.nodeFieldsCount = 7;
 270
 271     this._nodeTypesMap = {};
 272     this._nodeTypesArray = [];
 273     for (var nodeType in InspectorTest.HeapNode.Type) {
 274         this._nodeTypesMap[nodeType] = this._nodeTypesArray.length
 275         this._nodeTypesArray.push(nodeType);
 276     }
 277
 278     this._edgeTypesMap = {};
 279     this._edgeTypesArray = [];
 280     for (var edgeType in InspectorTest.HeapEdge.Type) {
 281         this._edgeTypesMap[edgeType] = this._edgeTypesArray.length
 282         this._edgeTypesArray.push(edgeType);
 283     }
 284
 285     this.rootNode = new InspectorTest.HeapNode("root", 0, "object");
 286     this.rootNode._setBuilder(this);
 287 }
 288
 289 InspectorTest.HeapSnapshotBuilder.prototype = {
 290     generateSnapshot: function()
 291     {
 292         var rawSnapshot = {
 293             "snapshot": {
 294                 "meta": {
 295                     "node_fields": ["type","name","id","self_size","retained_size","dominator","edge_count"],
 296                     "node_types": [
 297                         this._nodeTypesArray,
 298                         "string",
 299                         "number",
 300                         "number",
 301                         "number",
 302                         "number",
 303                         "number"
 304                     ],
 305                     "edge_fields": ["type","name_or_index","to_node"],
 306                     "edge_types": [
 307                         this._edgeTypesArray,
 308                         "string_or_number",
 309                         "node"
 310                     ]
 311                 }
 312             },
 313             "nodes": [],
 314             "edges":[],
 315             "strings": []
 316         };
 317
 318         for (var i = 0; i < this._nodes.length; ++i)
 319             this._nodes[i]._serialize(rawSnapshot);
 320
 321         rawSnapshot.strings = this._strings.slice();
 322
 323         var meta = rawSnapshot.snapshot.meta;
 324         rawSnapshot.snapshot.edge_count = rawSnapshot.edges.length / meta.edge_fields.length;
 325         rawSnapshot.snapshot.node_count = rawSnapshot.nodes.length / meta.node_fields.length;
 326
 327         return rawSnapshot;
 328     },
 329
 330     _registerNode: function(node)
 331     {
 332         this._nodes.push(node);
 333         return this._nodes.length - 1;
 334     },
 335
 336     lookupNodeType: function(typeName)
 337     {
 338         if (typeName === undefined)
 339             throw new Error("wrong node type: " + typeName);
 340         if (!typeName in this._nodeTypesMap)
 341             throw new Error("wrong node type name: " + typeName);
 342         return this._nodeTypesMap[typeName];
 343     },
 344
 345     lookupEdgeType: function(typeName)
 346     {
 347         if (!typeName in this._edgeTypesMap)
 348             throw new Error("wrong edge type name: " + typeName);
 349         return this._edgeTypesMap[typeName];
 350     },
 351
 352     lookupOrAddString: function(string)
 353     {
 354         if (string in this._string2id)
 355             return this._string2id[string];
 356         this._string2id[string] = this._strings.length;
 357         this._strings.push(string);
 358         return this._strings.length - 1;
 359     }
 360 }
 361
 362 InspectorTest.createHeapSnapshot = function(instanceCount, firstId)
 363 {
 364     // Mocking results of running the following code:
 365     //
 366     // function A() { this.a = this; }
 367     // function B() { this.a = new A(); }
 368     // for (var i = 0; i < instanceCount; ++i) window[i] = new B();
 369     //
 370     // Set A and B object sizes to pseudo random numbers. It is used in sorting tests.
 371
 372     var seed = 881669;
 373     function pseudoRandom(limit) {
 374         seed = ((seed * 355109 + 153763) >> 2) & 0xffff;
 375         return seed % limit;
 376     }
 377
 378     var builder = new InspectorTest.HeapSnapshotBuilder();
 379     var rootNode = builder.rootNode;
 380
 381     var gcRootsNode = new InspectorTest.HeapNode("(GC roots)");
 382     rootNode.linkNode(gcRootsNode, InspectorTest.HeapEdge.Type.element);
 383
 384     var windowNode = new InspectorTest.HeapNode("Window", 20);
 385     rootNode.linkNode(windowNode, InspectorTest.HeapEdge.Type.shortcut);
 386     gcRootsNode.linkNode(windowNode, InspectorTest.HeapEdge.Type.element);
 387
 388     for (var i = 0; i < instanceCount; ++i) {
 389         var sizeOfB = pseudoRandom(20) + 1;
 390         var nodeB = new InspectorTest.HeapNode("B", sizeOfB, undefined, firstId++);
 391         windowNode.linkNode(nodeB, InspectorTest.HeapEdge.Type.element);
 392         var sizeOfA = pseudoRandom(50) + 1;
 393         var nodeA = new InspectorTest.HeapNode("A", sizeOfA, undefined, firstId++);
 394         nodeB.linkNode(nodeA, InspectorTest.HeapEdge.Type.property, "a");
 395         nodeA.linkNode(nodeA, InspectorTest.HeapEdge.Type.property, "a");
 396     }
 397     return builder.generateSnapshot();
 398 }
 399
 400 }
 401
 402 InspectorTest.createHeapSnapshotMockFactories();
 403
 404
 405 InspectorTest.startProfilerTest = function(callback)
 406 {
 407     WebInspector.showPanel("profiles");
 408     WebInspector.settings.showAdvancedHeapSnapshotProperties.set(true);
 409
 410     InspectorTest.addResult("Profiler was enabled.");
 411     // We mock out HeapProfilerAgent -- as DRT runs in single-process mode, Inspector
 412     // and test share the same heap. Taking a snapshot takes too long for a test,
 413     // so we provide synthetic snapshots.
 414     InspectorTest._panelReset = InspectorTest.override(WebInspector.panels.profiles, "_reset", function(){}, true);
 415     InspectorTest.addSniffer(WebInspector.HeapSnapshotView.prototype, "show", InspectorTest._snapshotViewShown, true);
 416
 417     // Reduce the number of populated nodes to speed up testing.
 418     WebInspector.HeapSnapshotContainmentDataGrid.prototype.defaultPopulateCount = function() { return 10; };
 419     WebInspector.HeapSnapshotConstructorsDataGrid.prototype.defaultPopulateCount = function() { return 10; };
 420     WebInspector.HeapSnapshotDiffDataGrid.prototype.defaultPopulateCount = function() { return 5; };
 421     WebInspector.HeapSnapshotDominatorsDataGrid.prototype.defaultPopulateCount = function() { return 3; }
 422     InspectorTest.addResult("Detailed heap profiles were enabled.");
 423     InspectorTest.safeWrap(callback)();
 424 };
 425
 426 InspectorTest.completeProfilerTest = function()
 427 {
 428     // There is no way to disable detailed heap profiles.
 429     InspectorTest.addResult("");
 430     InspectorTest.addResult("Profiler was disabled.");
 431     InspectorTest.completeTest();
 432 };
 433
 434 InspectorTest.runHeapSnapshotTestSuite = function(testSuite)
 435 {
 436     InspectorTest._nextUid = 1;
 437     var testSuiteTests = testSuite.slice();
 438
 439     function runner()
 440     {
 441         if (!testSuiteTests.length) {
 442             InspectorTest.completeProfilerTest();
 443             return;
 444         }
 445
 446         var nextTest = testSuiteTests.shift();
 447         InspectorTest.addResult("");
 448         InspectorTest.addResult("Running: " + /function\s([^(]*)/.exec(nextTest)[1]);
 449         InspectorTest._panelReset.call(WebInspector.panels.profiles);
 450         InspectorTest.safeWrap(nextTest)(runner, runner);
 451     }
 452
 453     InspectorTest.startProfilerTest(runner);
 454 };
 455
 456 InspectorTest.assertColumnContentsEqual = function(reference, actual)
 457 {
 458     var length = Math.min(reference.length, actual.length);
 459     for (var i = 0; i < length; ++i)
 460         InspectorTest.assertEquals(reference[i], actual[i], "row " + i);
 461     if (reference.length > length)
 462         InspectorTest.addResult("extra rows in reference array:\n" + reference.slice(length).join("\n"));
 463     else if (actual.length > length)
 464         InspectorTest.addResult("extra rows in actual array:\n" + actual.slice(length).join("\n"));
 465 };
 466
 467 InspectorTest.checkArrayIsSorted = function(contents, sortType, sortOrder)
 468 {
 469     function simpleComparator(a, b)
 470     {
 471         return a < b ? -1 : (a > b ? 1 : 0);
 472     }
 473     function parseSize(size)
 474     {
 475         if (size.substr(0, 1) === '"') size = JSON.parse(size);
 476         // Remove thousands separator.
 477         return parseInt(size.replace(/[\u2009,]/g, ""));
 478     }
 479     function extractField(data, field)
 480     {
 481         if (data.substr(0, 1) !== "{") return data;
 482         data = JSON.parse(data);
 483         if (!data[field])
 484             InspectorTest.addResult("No " + field + " field in " + JSON.stringify(data));
 485         return data[field];
 486     }
 487     function extractId(data)
 488     {
 489         return parseInt(extractField(data, "nodeId"));
 490     }
 491     var extractor = {
 492         text: function (data) { return extractField(data, "value"); },
 493         number: function (data) { return parseInt(data, 10); },
 494         size: function (data) { return parseSize(data); },
 495         name: function (data) { return extractField(data, "name"); },
 496         id: function (data) { return extractId(data); }
 497     }[sortType];
 498     var acceptableComparisonResult = {
 499         ascending: -1,
 500         descending: 1
 501     }[sortOrder];
 502
 503     if (!extractor) {
 504         InspectorTest.addResult("Invalid sort type: " + sortType);
 505         return;
 506     }
 507     if (!acceptableComparisonResult) {
 508         InspectorTest.addResult("Invalid sort order: " + sortOrder);
 509         return;
 510     }
 511
 512     for (var i = 0; i < contents.length - 1; ++i) {
 513         var a = extractor(contents[i]);
 514         var b = extractor(contents[i + 1]);
 515         var result = simpleComparator(a, b);
 516         if (result !== 0 && result !== acceptableComparisonResult)
 517             InspectorTest.addResult("Elements " + i + " and " + (i + 1) + " are out of order: " + a + " " + b + " (" + sortOrder + ")");
 518     }
 519 };
 520
 521 InspectorTest.clickColumn = function(column, callback)
 522 {
 523     callback = InspectorTest.safeWrap(callback);
 524     var cell = this._currentGrid()._headerTableHeaders[column.identifier];
 525     var event = { target: { enclosingNodeOrSelfWithNodeName: function() { return cell; } } };
 526
 527     function sortingComplete()
 528     {
 529         InspectorTest._currentGrid().removeEventListener("sorting complete", sortingComplete, this);
 530         InspectorTest.assertEquals(column.identifier, this._currentGrid().sortColumnIdentifier(), "unexpected sorting");
 531         column.sort = this._currentGrid().sortOrder();
 532         function callCallback()
 533         {
 534             callback(column);
 535         }
 536         setTimeout(callCallback, 0);
 537     }
 538     InspectorTest._currentGrid().addEventListener("sorting complete", sortingComplete, this);
 539     this._currentGrid()._clickInHeaderCell(event);
 540 };
 541
 542 InspectorTest.clickRowAndGetRetainers = function(row, callback)
 543 {
 544     callback = InspectorTest.safeWrap(callback);
 545     var event = {
 546         target: {
 547             enclosingNodeOrSelfWithNodeName: function() { return row._element; },
 548             selectedNode: row
 549         }
 550     };
 551     this._currentGrid()._mouseDownInDataTable(event);
 552     var rootNode = InspectorTest.currentProfileView().retainmentDataGrid.rootNode();
 553     function populateComplete()
 554     {
 555         rootNode.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 556         callback(rootNode);
 557     }
 558     rootNode.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 559 };
 560
 561 InspectorTest.clickShowMoreButton = function(buttonName, row, callback)
 562 {
 563     callback = InspectorTest.safeWrap(callback);
 564     var parent = row.parent;
 565     function populateComplete()
 566     {
 567         parent.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 568         function callCallback()
 569         {
 570             callback(parent);
 571         }
 572         setTimeout(callCallback, 0);
 573     }
 574     parent.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 575     row[buttonName].click();
 576 };
 577
 578 InspectorTest.columnContents = function(column, row)
 579 {
 580     // Make sure invisible nodes are removed from the view port.
 581     this._currentGrid().updateVisibleNodes();
 582     var result = [];
 583     var parent = row || this._currentGrid().rootNode();
 584     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
 585         if (!node.selectable)
 586             continue;
 587         var data = node.data[column.identifier];
 588         if (typeof data === "object")
 589             data = JSON.stringify(data);
 590         result.push(data);
 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     function propertyMatcher(data)
 642     {
 643         return data.value === name;
 644     }
 645     var row = InspectorTest.findRow("object", propertyMatcher);
 646     InspectorTest.assertEquals(true, !!row, '"' + name + '" row');
 647     InspectorTest.expandRow(row, callback);
 648 };
 649
 650 InspectorTest.findButtonsNode = function(row, startNode)
 651 {
 652     var result = 0;
 653     for (var node = startNode || row.children[0]; node; node = node.traverseNextNode(true, row, true)) {
 654         if (!node.selectable && node.showNext)
 655             return node;
 656     }
 657     return null;
 658 };
 659
 660 InspectorTest.findRow = function(columnIdentifier, matcher, parent)
 661 {
 662     parent = parent || this._currentGrid().rootNode();
 663     if (typeof matcher !== "function") {
 664         var value = matcher;
 665         matcher = function(x) { return x === value; };
 666     }
 667     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
 668         if (matcher(node.data[columnIdentifier]))
 669             return node;
 670     }
 671     return null;
 672 };
 673
 674 InspectorTest.findRow2 = function(matcher, parent)
 675 {
 676     parent = parent || this._currentGrid().rootNode();
 677     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
 678         if (matcher(node.data))
 679             return node;
 680     }
 681     return null;
 682 };
 683
 684 InspectorTest.switchToView = function(title, callback)
 685 {
 686     callback = InspectorTest.safeWrap(callback);
 687     var view = WebInspector.panels.profiles.visibleView;
 688     view.changeView(title, callback);
 689 };
 690
 691 InspectorTest.takeAndOpenSnapshot = function(generator, callback)
 692 {
 693     callback = InspectorTest.safeWrap(callback);
 694     var uid = InspectorTest._nextUid++;
 695     var snapshot = generator();
 696     var profileType = WebInspector.panels.profiles.getProfileType(WebInspector.HeapSnapshotProfileType.TypeId);
 697     var profile = new WebInspector.HeapProfileHeader(profileType, "Mock snapshot #" + uid, uid);
 698     function pushGeneratedSnapshot(uid, callback)
 699     {
 700         snapshot.snapshot.typeId = "HEAP";
 701         snapshot.snapshot.title = profile.title;
 702         snapshot.snapshot.uid = profile.uid;
 703         profileType.addHeapSnapshotChunk(uid, JSON.stringify(snapshot));
 704         setTimeout(callback, 0);
 705     }
 706     InspectorTest.override(HeapProfilerAgent, "getHeapSnapshot", pushGeneratedSnapshot);
 707     InspectorTest._takeAndOpenSnapshotCallback = callback;
 708     profileType.addProfile(profile);
 709     WebInspector.panels.profiles._showProfile(profile);
 710 };
 711
 712 InspectorTest.viewColumns = function()
 713 {
 714     return InspectorTest._currentGrid()._columnsArray;
 715 };
 716
 717 InspectorTest.currentProfileView = function()
 718 {
 719     return WebInspector.panels.profiles.visibleView;
 720 };
 721
 722 InspectorTest._currentGrid = function()
 723 {
 724     return this.currentProfileView().dataGrid;
 725 };
 726
 727 InspectorTest._snapshotViewShown = function()
 728 {
 729     if (InspectorTest._takeAndOpenSnapshotCallback) {
 730         var callback = InspectorTest._takeAndOpenSnapshotCallback;
 731         InspectorTest._takeAndOpenSnapshotCallback = null;
 732         var dataGrid = this.dataGrid;
 733         function sortingComplete()
 734         {
 735             dataGrid.removeEventListener("sorting complete", sortingComplete, null);
 736             callback();
 737         }
 738         dataGrid.addEventListener("sorting complete", sortingComplete, null);
 739     }
 740 };
 741
 742 };