DevTools: rename WebInspector into modules.

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

 var initialize_HeapSnapshotTest = function() {
 
 InspectorTest.preloadPanel("profiles");
 
 InspectorTest.createHeapSnapshotMockFactories = function() {
 
 InspectorTest.createJSHeapSnapshotMockObject = function()
 {
     return {
         _rootNodeIndex: 0,
@@ skipping 30 matching lines @@
         containmentEdges: new Uint32Array([
             2,  6, 3,   //  0: shortcut 'a' to node 'A'
             1,  7, 6,   //  3: property 'b' to node 'B'
             0,  1, 6,   //  6: element '1' to node 'B'
             1,  8, 9,   //  9: property 'ac' to node 'C'
             1,  9, 9,   // 12: property 'bc' to node 'C'
             1, 10, 12,  // 15: property 'bd' to node 'D'
             1, 11, 15]),// 18: property 'ce' to node 'E'
         strings: ["", "A", "B", "C", "D", "E", "a", "b", "ac", "bc", "bd", "ce"],
         _firstEdgeIndexes: new Uint32Array([0, 6, 12, 18, 21, 21, 21]),
-        createNode: WebInspector.JSHeapSnapshot.prototype.createNode,
-        createEdge: WebInspector.JSHeapSnapshot.prototype.createEdge,
-        createRetainingEdge: WebInspector.JSHeapSnapshot.prototype.createRetainingEdge
+        createNode: HeapSnapshotWorker.JSHeapSnapshot.prototype.createNode,
+        createEdge: HeapSnapshotWorker.JSHeapSnapshot.prototype.createEdge,
+        createRetainingEdge: HeapSnapshotWorker.JSHeapSnapshot.prototype.createRetainingEdge
     };
 };
 
 InspectorTest.createHeapSnapshotMockRaw = function()
 {
     // Effectively the same graph as in createJSHeapSnapshotMockObject,
     // but having full set of fields.
     //
     // A triple in parentheses indicates node index, self size and
     // retained size.
@@ skipping 263 matching lines @@
         var meta = rawSnapshot.snapshot.meta;
         rawSnapshot.snapshot.edge_count = rawSnapshot.edges.length / meta.edge_fields.length;
         rawSnapshot.snapshot.node_count = rawSnapshot.nodes.length / meta.node_fields.length;
 
         return rawSnapshot;
     },
 
     createJSHeapSnapshot: function()
     {
         var parsedSnapshot = InspectorTest._postprocessHeapSnapshotMock(this.generateSnapshot());
-        return new WebInspector.JSHeapSnapshot(parsedSnapshot, new WebInspector.HeapSnapshotProgress());
+        return new HeapSnapshotWorker.JSHeapSnapshot(parsedSnapshot, new HeapSnapshotWorker.HeapSnapshotProgress());
     },
 
     _registerNode: function(node)
     {
         this._nodes.push(node);
         return this._nodes.length - 1;
     },
 
     lookupNodeType: function(typeName)
     {
@@ skipping 63 matching lines @@
 
 InspectorTest.createHeapSnapshotMockFactories();
 
 
 InspectorTest.startProfilerTest = function(callback)
 {
     InspectorTest.addResult("Profiler was enabled.");
     // We mock out HeapProfilerAgent -- as DRT runs in single-process mode, Inspector
     // and test share the same heap. Taking a snapshot takes too long for a test,
     // so we provide synthetic snapshots.
-    InspectorTest._panelReset = InspectorTest.override(WebInspector.panels.profiles, "_reset", function(){}, true);
-    InspectorTest.addSniffer(WebInspector.HeapSnapshotView.prototype, "show", InspectorTest._snapshotViewShown, true);
+    InspectorTest._panelReset = InspectorTest.override(UI.panels.profiles, "_reset", function(){}, true);
+    InspectorTest.addSniffer(Profiler.HeapSnapshotView.prototype, "show", InspectorTest._snapshotViewShown, true);
 
     // Reduce the number of populated nodes to speed up testing.
-    WebInspector.HeapSnapshotContainmentDataGrid.prototype.defaultPopulateCount = function() { return 10; };
-    WebInspector.HeapSnapshotConstructorsDataGrid.prototype.defaultPopulateCount = function() { return 10; };
-    WebInspector.HeapSnapshotDiffDataGrid.prototype.defaultPopulateCount = function() { return 5; };
+    Profiler.HeapSnapshotContainmentDataGrid.prototype.defaultPopulateCount = function() { return 10; };
+    Profiler.HeapSnapshotConstructorsDataGrid.prototype.defaultPopulateCount = function() { return 10; };
+    Profiler.HeapSnapshotDiffDataGrid.prototype.defaultPopulateCount = function() { return 5; };
     InspectorTest.addResult("Detailed heap profiles were enabled.");
     InspectorTest.safeWrap(callback)();
 };
 
 InspectorTest.completeProfilerTest = function()
 {
     // There is no way to disable detailed heap profiles.
     InspectorTest.addResult("");
     InspectorTest.addResult("Profiler was disabled.");
     InspectorTest.completeTest();
@@ skipping 10 matching lines @@
             if (completeTestStack)
                 InspectorTest.addResult("FAIL: test already completed at " + completeTestStack);
             InspectorTest.completeProfilerTest();
             completeTestStack = new Error().stack;
             return;
         }
 
         var nextTest = testSuiteTests.shift();
         InspectorTest.addResult("");
         InspectorTest.addResult("Running: " + /function\s([^(]*)/.exec(nextTest)[1]);
-        InspectorTest._panelReset.call(WebInspector.panels.profiles);
+        InspectorTest._panelReset.call(UI.panels.profiles);
         InspectorTest.safeWrap(nextTest)(runner, runner);
     }
 
     InspectorTest.startProfilerTest(runner);
 };
 
 InspectorTest.assertColumnContentsEqual = function(reference, actual)
 {
     var length = Math.min(reference.length, actual.length);
     for (var i = 0; i < length; ++i)
@@ skipping 22 matching lines @@
         name: function (data) { return data; },
         id: function (data) { return parseInt(data, 10); }
     }[sortType];
 
     if (!extractor) {
         InspectorTest.addResult("Invalid sort type: " + sortType);
         return;
     }
 
     var acceptableComparisonResult;
-    if (sortOrder === WebInspector.DataGrid.Order.Ascending) {
+    if (sortOrder === UI.DataGrid.Order.Ascending) {
         acceptableComparisonResult = -1;
-    } else if (sortOrder === WebInspector.DataGrid.Order.Descending) {
+    } else if (sortOrder === UI.DataGrid.Order.Descending) {
         acceptableComparisonResult = 1;
     } else {
         InspectorTest.addResult("Invalid sort order: " + sortOrder);
         return;
     }
 
     for (var i = 0; i < contents.length - 1; ++i) {
         var a = extractor(contents[i]);
         var b = extractor(contents[i + 1]);
         var result = simpleComparator(a, b);
         if (result !== 0 && result !== acceptableComparisonResult) {
             InspectorTest.addResult("Elements " + i + " and " + (i + 1) + " are out of order: " + a + " " + b + " (" + sortOrder + ")");
         }
     }
 };
 
 InspectorTest.clickColumn = function(column, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     var cell = this._currentGrid()._headerTableHeaders[column.id];
     var event = { target: { enclosingNodeOrSelfWithNodeName: function() { return cell; } } };
 
     function sortingComplete()
     {
-        InspectorTest._currentGrid().removeEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
+        InspectorTest._currentGrid().removeEventListener(Profiler.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
         InspectorTest.assertEquals(column.id, this._currentGrid().sortColumnId(), "unexpected sorting");
         column.sort = this._currentGrid().sortOrder();
         function callCallback()
         {
             callback(column);
         }
         setTimeout(callCallback, 0);
     }
-    InspectorTest._currentGrid().addEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
+    InspectorTest._currentGrid().addEventListener(Profiler.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, this);
     this._currentGrid()._clickInHeaderCell(event);
 };
 
 InspectorTest.clickRowAndGetRetainers = function(row, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     var event = {
         target: {
             enclosingNodeOrSelfWithNodeName: function() { return row._element; },
             selectedNode: row
         }
     };
     this._currentGrid()._mouseDownInDataTable(event);
     var rootNode = InspectorTest.currentProfileView()._retainmentDataGrid.rootNode();
     function populateComplete()
     {
-        rootNode.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+        rootNode.removeEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
         callback(rootNode);
     }
-    rootNode.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+    rootNode.addEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
 };
 
 InspectorTest.clickShowMoreButton = function(buttonName, row, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     var parent = row.parent;
     function populateComplete()
     {
-        parent.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+        parent.removeEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
         function callCallback()
         {
             callback(parent);
         }
         setTimeout(callCallback, 0);
     }
-    parent.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+    parent.addEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
     row[buttonName].click();
 };
 
 InspectorTest.columnContents = function(column, row)
 {
     // Make sure invisible nodes are removed from the view port.
     this._currentGrid().updateVisibleNodes();
     var columnOrdinal = InspectorTest.viewColumns().indexOf(column);
     var result = [];
     var parent = row || this._currentGrid().rootNode();
@@ skipping 18 matching lines @@
             ++result;
     }
     return result;
 };
 
 InspectorTest.expandRow = function(row, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     function populateComplete()
     {
-        row.removeEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+        row.removeEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
         function callCallback()
         {
             callback(row);
         }
         setTimeout(callCallback, 0);
     }
-    row.addEventListener(WebInspector.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
+    row.addEventListener(Profiler.HeapSnapshotGridNode.Events.PopulateComplete, populateComplete, this);
     (function expand()
     {
         if (row.hasChildren)
             row.expand();
         else
             setTimeout(expand, 0);
     })();
 };
 
 InspectorTest.findAndExpandGCRoots = function(callback)
@@ skipping 39 matching lines @@
     for (var node = parent.children[0]; node; node = node.traverseNextNode(true, parent, true)) {
         if (matcher(node))
             return node;
     }
     return null;
 };
 
 InspectorTest.switchToView = function(title, callback)
 {
     callback = InspectorTest.safeWrap(callback);
-    var view = WebInspector.panels.profiles.visibleView;
+    var view = UI.panels.profiles.visibleView;
     view._changePerspectiveAndWait(title, callback);
     // Increase the grid container height so the viewport don't limit the number of nodes.
     InspectorTest._currentGrid().scrollContainer.style.height = "10000px";
 };
 
 InspectorTest.takeAndOpenSnapshot = function(generator, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     var snapshot = generator();
-    var profileType = WebInspector.ProfileTypeRegistry.instance.heapSnapshotProfileType;
+    var profileType = Profiler.ProfileTypeRegistry.instance.heapSnapshotProfileType;
     function pushGeneratedSnapshot(reportProgress, callback2)
     {
         var profile = profileType.profileBeingRecorded();
         if (reportProgress) {
             profileType._reportHeapSnapshotProgress({data: {done: 50, total: 100, finished: false}});
             profileType._reportHeapSnapshotProgress({data: {done: 100, total: 100, finished: true}});
         }
         snapshot.snapshot.typeId = "HEAP";
         profileType._addHeapSnapshotChunk({data: JSON.stringify(snapshot)});
         setTimeout(callback2, 0);
     }
     InspectorTest.override(InspectorTest.HeapProfilerAgent, "takeHeapSnapshot", pushGeneratedSnapshot);
     InspectorTest._takeAndOpenSnapshotCallback = callback;
     profileType._takeHeapSnapshot(function() { });
 };
 
 InspectorTest.viewColumns = function()
 {
     return InspectorTest._currentGrid()._columnsArray;
 };
 
 InspectorTest.currentProfileView = function()
 {
-    return WebInspector.panels.profiles.visibleView;
+    return UI.panels.profiles.visibleView;
 };
 
 InspectorTest._currentGrid = function()
 {
     return this.currentProfileView()._dataGrid;
 };
 
 InspectorTest._snapshotViewShown = function()
 {
     if (InspectorTest._takeAndOpenSnapshotCallback) {
         var callback = InspectorTest._takeAndOpenSnapshotCallback;
         InspectorTest._takeAndOpenSnapshotCallback = null;
         var dataGrid = this._dataGrid;
         function sortingComplete()
         {
-            dataGrid.removeEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
+            dataGrid.removeEventListener(Profiler.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
             callback();
         }
-        dataGrid.addEventListener(WebInspector.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
+        dataGrid.addEventListener(Profiler.HeapSnapshotSortableDataGrid.Events.SortingComplete, sortingComplete, null);
     }
 };
 
 };