DevTools: rename WebInspector into modules.

third_party/WebKit/LayoutTests/http/tests/inspector/timeline-test.js

 function wrapCallFunctionForTimeline(f)
 {
     var script = document.createElement("script");
     script.textContent = "(" + f.toString() + ")()\n//# sourceURL=wrapCallFunctionForTimeline.js";
     document.body.appendChild(script);
 }
 
 var initialize_Timeline = function() {
 
 InspectorTest.preloadPanel("timeline");
-WebInspector.TempFile = InspectorTest.TempFileMock;
+Bindings.TempFile = InspectorTest.TempFileMock;
 
 // Scrub values when printing out these properties in the record or data field.
 InspectorTest.timelinePropertyFormatters = {
     children: "formatAsTypeName",
     endTime: "formatAsTypeName",
     requestId: "formatAsTypeName",
     startTime: "formatAsTypeName",
     stackTrace: "formatAsTypeName",
     url: "formatAsURL",
     scriptName: "formatAsTypeName",
@@ skipping 40 matching lines @@
 {
     if (!cause)
         return "<undefined>";
     var stackTrace;
     if (cause.stackTrace && cause.stackTrace.length)
         stackTrace = InspectorTest.formatters.formatAsURL(cause.stackTrace[0].url) + ":" + (cause.stackTrace[0].lineNumber + 1);
     return "{reason: " + cause.reason + ", stackTrace: " + stackTrace + "}";
 }
 
 InspectorTest.preloadPanel("timeline");
-WebInspector.TempFile = InspectorTest.TempFileMock;
+Bindings.TempFile = InspectorTest.TempFileMock;
 
 InspectorTest.createTracingModel = function()
 {
-    return new WebInspector.TracingModel(new WebInspector.TempFileBackingStorage("tracing"));
+    return new SDK.TracingModel(new Bindings.TempFileBackingStorage("tracing"));
 }
 
 InspectorTest.tracingModel = function()
 {
-    return WebInspector.panels.timeline._tracingModel;
+    return UI.panels.timeline._tracingModel;
 }
 
 InspectorTest.invokeWithTracing = function(functionName, callback, additionalCategories, enableJSSampling)
 {
-    var categories = "-*,disabled-by-default-devtools.timeline*,devtools.timeline," + WebInspector.TracingModel.TopLevelEventCategory;
+    var categories = "-*,disabled-by-default-devtools.timeline*,devtools.timeline," + SDK.TracingModel.TopLevelEventCategory;
     if (additionalCategories)
         categories += "," + additionalCategories;
-    var timelinePanel = WebInspector.panels.timeline;
+    var timelinePanel = UI.panels.timeline;
     var timelineController = InspectorTest.timelineController();
     timelinePanel._timelineController = timelineController;
     timelineController._startRecordingWithCategories(categories, enableJSSampling, tracingStarted);
 
     function tracingStarted()
     {
         InspectorTest.callFunctionInPageAsync(functionName).then(onPageActionsDone);
     }
 
     function onPageActionsDone()
     {
-        InspectorTest.addSniffer(WebInspector.panels.timeline, "loadingComplete", callback)
+        InspectorTest.addSniffer(UI.panels.timeline, "loadingComplete", callback)
         timelineController.stopRecording();
     }
 }
 
 InspectorTest.timelineModel = function()
 {
-    return WebInspector.panels.timeline._model;
+    return UI.panels.timeline._model;
 }
 
 InspectorTest.timelineFrameModel = function()
 {
-    return WebInspector.panels.timeline._frameModel;
+    return UI.panels.timeline._frameModel;
 }
 
 InspectorTest.setTraceEvents = function(timelineModel, tracingModel, events)
 {
     tracingModel.reset();
     tracingModel.addEvents(events);
     tracingModel.tracingComplete();
     timelineModel.setEvents(tracingModel);
 }
 
 InspectorTest.createTimelineModelWithEvents = function(events)
 {
-    var tracingModel = new WebInspector.TracingModel(new WebInspector.TempFileBackingStorage("tracing"));
-    var timelineModel = new WebInspector.TimelineModel(WebInspector.TimelineUIUtils.visibleEventsFilter());
+    var tracingModel = new SDK.TracingModel(new Bindings.TempFileBackingStorage("tracing"));
+    var timelineModel = new TimelineModel.TimelineModel(Timeline.TimelineUIUtils.visibleEventsFilter());
     InspectorTest.setTraceEvents(timelineModel, tracingModel, events);
     return timelineModel;
 }
 
 InspectorTest.timelineController = function()
 {
-    var mainTarget = WebInspector.targetManager.mainTarget();
-    var timelinePanel =  WebInspector.panels.timeline;
-    return new WebInspector.TimelineController(mainTarget, timelinePanel, timelinePanel._tracingModel);
+    var mainTarget = SDK.targetManager.mainTarget();
+    var timelinePanel =  UI.panels.timeline;
+    return new Timeline.TimelineController(mainTarget, timelinePanel, timelinePanel._tracingModel);
 }
 
 InspectorTest.startTimeline = function(callback)
 {
-    var panel = WebInspector.panels.timeline;
+    var panel = UI.panels.timeline;
     InspectorTest.addSniffer(panel, "recordingStarted", callback);
     panel._toggleRecording();
 };
 
 InspectorTest.stopTimeline = function(callback)
 {
-    var panel = WebInspector.panels.timeline;
+    var panel = UI.panels.timeline;
     function didStop()
     {
         InspectorTest.deprecatedRunAfterPendingDispatches(callback);
     }
     InspectorTest.addSniffer(panel, "loadingComplete", didStop);
     panel._toggleRecording();
 };
 
 InspectorTest.evaluateWithTimeline = function(actions, doneCallback)
 {
@@ skipping 18 matching lines @@
     }
 
     function step2()
     {
         InspectorTest.stopTimeline(InspectorTest.safeWrap(doneCallback));
     }
 }
 
 InspectorTest.loadTimelineRecords = function(records)
 {
-    var model = WebInspector.panels.timeline._model;
+    var model = UI.panels.timeline._model;
     model.reset();
     records.forEach(model._addRecord, model);
 }
 
 InspectorTest.performActionsAndPrint = function(actions, typeName, includeTimeStamps)
 {
     function callback()
     {
         InspectorTest.printTimelineRecordsWithDetails(typeName);
         if (includeTimeStamps) {
             InspectorTest.addResult("Timestamp records: ");
             InspectorTest.printTimestampRecords(typeName);
         }
         InspectorTest.completeTest();
     }
     InspectorTest.evaluateWithTimeline(actions, callback);
 };
 
 InspectorTest.printTimelineRecords = function(typeName, formatter)
 {
     InspectorTest.timelineModel().forAllRecords(InspectorTest._printTimlineRecord.bind(InspectorTest, typeName, formatter));
 };
 
 InspectorTest.detailsTextForTraceEvent = function(traceEvent)
 {
-    return WebInspector.TimelineUIUtils.buildDetailsTextForTraceEvent(traceEvent,
-        WebInspector.targetManager.mainTarget(),
-        new WebInspector.Linkifier());
+    return Timeline.TimelineUIUtils.buildDetailsTextForTraceEvent(traceEvent,
+        SDK.targetManager.mainTarget(),
+        new Components.Linkifier());
 }
 
 InspectorTest.printTimelineRecordsWithDetails = function(typeName)
 {
     function detailsFormatter(recordType, record)
     {
         if (recordType && recordType !== record.type())
             return;
         var event = record.traceEvent();
         InspectorTest.addResult("Text details for " + record.type() + ": " + InspectorTest.detailsTextForTraceEvent(event));
-        if (WebInspector.TimelineData.forEvent(event).warning)
+        if (TimelineModel.TimelineData.forEvent(event).warning)
             InspectorTest.addResult(record.type() + " has a warning");
     }
 
     InspectorTest.timelineModel().forAllRecords(InspectorTest._printTimlineRecord.bind(InspectorTest, typeName, detailsFormatter.bind(null, typeName)));
 };
 
 InspectorTest.walkTimelineEventTree = function(callback)
 {
     var model = InspectorTest.timelineModel();
-    var view = new WebInspector.EventsTimelineTreeView(model, WebInspector.panels.timeline._filters, null);
-    var selection = WebInspector.TimelineSelection.fromRange(model.minimumRecordTime(), model.maximumRecordTime());
+    var view = new Timeline.EventsTimelineTreeView(model, UI.panels.timeline._filters, null);
+    var selection = Timeline.TimelineSelection.fromRange(model.minimumRecordTime(), model.maximumRecordTime());
     view.updateContents(selection);
     InspectorTest.walkTimelineEventTreeUnderNode(callback, view._currentTree, 0);
 }
 
 InspectorTest.walkTimelineEventTreeUnderNode = function(callback, root, level)
 {
     var event = root.event;
     if (event)
         callback(event, level)
     var children = root.children ? root.children.values() : [];
@@ skipping 23 matching lines @@
 // Dump just the record name, indenting output on separate lines for subrecords
 InspectorTest.dumpTimelineRecord = function(record, detailsCallback, level, filterTypes)
 {
     if (typeof level !== "number")
         level = 0;
     var message = "";
     for (var i = 0; i < level ; ++i)
         message = "----" + message;
     if (level > 0)
         message = message + "> ";
-    if (record.type() === WebInspector.TimelineModel.RecordType.TimeStamp
-        || record.type() === WebInspector.TimelineModel.RecordType.ConsoleTime) {
-        message += WebInspector.TimelineUIUtils.eventTitle(record.traceEvent());
+    if (record.type() === TimelineModel.TimelineModel.RecordType.TimeStamp
+        || record.type() === TimelineModel.TimelineModel.RecordType.ConsoleTime) {
+        message += Timeline.TimelineUIUtils.eventTitle(record.traceEvent());
     } else  {
         message += record.type();
     }
     if (detailsCallback)
         message += " " + detailsCallback(record);
     InspectorTest.addResult(message);
 
     var children = record.children();
     var numChildren = children.length;
     for (var i = 0; i < numChildren; ++i) {
         if (filterTypes && filterTypes.indexOf(children[i].type()) == -1)
             continue;
         InspectorTest.dumpTimelineRecord(children[i], detailsCallback, level + 1, filterTypes);
     }
 }
 
 InspectorTest.dumpTimelineModelRecord = function(record, level)
 {
     if (typeof level !== "number")
         level = 0;
     var prefix = "";
     for (var i = 0; i < level ; ++i)
         prefix = "----" + prefix;
     if (level > 0)
         prefix = prefix + "> ";
-    InspectorTest.addResult(prefix + record.type() + ": " + (WebInspector.TimelineUIUtils.buildDetailsTextForTraceEvent(record.traceEvent(), null) || ""));
+    InspectorTest.addResult(prefix + record.type() + ": " + (Timeline.TimelineUIUtils.buildDetailsTextForTraceEvent(record.traceEvent(), null) || ""));
 
     var numChildren = record.children() ? record.children().length : 0;
     for (var i = 0; i < numChildren; ++i)
         InspectorTest.dumpTimelineModelRecord(record.children()[i], level + 1);
 }
 
 InspectorTest.dumpTimelineRecords = function(timelineRecords)
 {
     for (var i = 0; i < timelineRecords.length; ++i)
         InspectorTest.dumpTimelineRecord(timelineRecords[i], 0);
@@ skipping 12 matching lines @@
 
 InspectorTest.printTraceEventProperties = function(traceEvent)
 {
     InspectorTest.addResult(traceEvent.name + " Properties:");
     var data = traceEvent.args["beginData"] || traceEvent.args["data"];
     var frameId = data && data["frame"];
     var object = {
         data: traceEvent.args["data"] || traceEvent.args,
         endTime: traceEvent.endTime || traceEvent.startTime,
         frameId: frameId,
-        stackTrace: WebInspector.TimelineData.forEvent(traceEvent).stackTrace,
+        stackTrace: TimelineModel.TimelineData.forEvent(traceEvent).stackTrace,
         startTime: traceEvent.startTime,
         type: traceEvent.name,
     };
     for (var field in object) {
         if (object[field] === null || object[field] === undefined)
             delete object[field];
     }
     InspectorTest.addObject(object, InspectorTest.timelinePropertyFormatters);
 };
 
@@ skipping 47 matching lines @@
             result[key] = value;
         }
         return result;
     }
     InspectorTest.addObject(formatFields(frame));
 }
 
 InspectorTest.dumpInvalidations = function(recordType, index, comment)
 {
     var record = InspectorTest.findTimelineRecord(recordType, index || 0);
-    InspectorTest.addArray(WebInspector.InvalidationTracker.invalidationEventsFor(record._event), InspectorTest.InvalidationFormatters, "", comment);
+    InspectorTest.addArray(TimelineModel.InvalidationTracker.invalidationEventsFor(record._event), InspectorTest.InvalidationFormatters, "", comment);
 }
 
 InspectorTest.FakeFileReader.prototype = {
     start: function(output)
     {
         this._delegate.onTransferStarted(this);
 
         var length = this._input.length;
         var half = (length + 1) >> 1;
 
@@ skipping 26 matching lines @@
     },
 
     fileName: function()
     {
         return "fakeFile";
     }
 };
 
 InspectorTest.loadTimeline = function(timelineData)
 {
-    var timeline = WebInspector.panels.timeline;
+    var timeline = UI.panels.timeline;
 
     function createFileReader(file, delegate)
     {
         return new InspectorTest.FakeFileReader(timelineData, delegate, timeline._saveToFile.bind(timeline));
     }
 
-    InspectorTest.override(WebInspector.TimelineLoader, "_createFileReader", createFileReader);
+    InspectorTest.override(Timeline.TimelineLoader, "_createFileReader", createFileReader);
     timeline._loadFromFile({});
 }
 
 };
 
 function generateFrames(count)
 {
     var promise = Promise.resolve();
     for (let i = count; i > 0; --i)
         promise = promise.then(changeBackgroundAndWaitForFrame.bind(null, i));
     return promise;
 
     function changeBackgroundAndWaitForFrame(i)
     {
         document.body.style.backgroundColor = i & 1 ? "rgb(200, 200, 200)" : "rgb(240, 240, 240)";
         return waitForFrame();
     }
 }
 
 function waitForFrame()
 {
     var callback;
     var promise = new Promise((fulfill) => callback = fulfill);
     if (window.testRunner)
         testRunner.capturePixelsAsyncThen(() => window.requestAnimationFrame(callback));
     else
         window.requestAnimationFrame(callback);
     return promise;
 }