DevTools: rename WebInspector into modules.

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

 if (window.GCController)
     GCController.collectAll();
 var initialize_InspectorTest = function() {
 
 var results = [];
 
 function consoleOutputHook(messageType)
 {
     InspectorTest.addResult(messageType + ": " + Array.prototype.slice.call(arguments, 1));
 }
@@ skipping 303 matching lines @@
     for (var i = 0; i < treeElement.childCount(); ++i) {
         var property = treeElement.childAt(i).property;
         var key = property.name;
         var value = property.value._description;
         InspectorTest.addResult("    " + key + ": " + value);
     }
 }
 
 InspectorTest.expandAndDumpEventListeners = function(eventListenersView, callback)
 {
-    InspectorTest.addSniffer(WebInspector.EventListenersView.prototype, "_eventListenersArrivedForTest", listenersArrived);
+    InspectorTest.addSniffer(Components.EventListenersView.prototype, "_eventListenersArrivedForTest", listenersArrived);
 
     function listenersArrived()
     {
         var listenerTypes = eventListenersView._treeOutline.rootElement().children();
         for (var i = 0; i < listenerTypes.length; ++i) {
             listenerTypes[i].expand();
             var listenerItems = listenerTypes[i].children();
             for (var j = 0; j < listenerItems.length; ++j)
                 listenerItems[j].expand();
         }
@@ skipping 23 matching lines @@
 {
     dumpNavigatorTreeOutline(navigatorView._scriptsTree);
 
     function dumpNavigatorTreeElement(prefix, treeElement)
     {
         var titleText;
         if (treeElement.title instanceof Element)
             titleText = treeElement.title.firstChild.textContent + " [mapped]";
         else
             titleText = treeElement.title;
-        if (treeElement._nodeType === WebInspector.NavigatorView.Types.FileSystem || treeElement._nodeType === WebInspector.NavigatorView.Types.FileSystemFolder) {
+        if (treeElement._nodeType === Sources.NavigatorView.Types.FileSystem || treeElement._nodeType === Sources.NavigatorView.Types.FileSystemFolder) {
             var hasMappedFiles = treeElement.listItemElement.classList.contains("has-mapped-files");
             if (!hasMappedFiles)
                 titleText += " [dimmed]";
         }
         InspectorTest.addResult(prefix + titleText);
         treeElement.expand();
         var children = treeElement.children();
         for (var i = 0; i < children.length; ++i)
             dumpNavigatorTreeElement(prefix + "  ", children[i]);
     }
 
     function dumpNavigatorTreeOutline(treeOutline)
     {
         var children = treeOutline.rootElement().children();
         for (var i = 0; i < children.length; ++i)
             dumpNavigatorTreeElement("", children[i]);
     }
 }
 
 InspectorTest.dumpNavigatorViewInAllModes = function(view)
 {
     ["frame", "frame/domain", "frame/domain/folder", "domain", "domain/folder"].forEach(InspectorTest.dumpNavigatorViewInMode.bind(InspectorTest, view));
 }
 
 InspectorTest.dumpNavigatorViewInMode = function(view, mode)
 {
-    InspectorTest.addResult(view instanceof WebInspector.SourcesNavigatorView ? "Sources:" : "Content Scripts:");
+    InspectorTest.addResult(view instanceof Sources.SourcesNavigatorView ? "Sources:" : "Content Scripts:");
     view._groupByFrame = mode.includes("frame");
     view._groupByDomain = mode.includes("domain");
     view._groupByFolder = mode.includes("folder");
     view._resetForTest();
     InspectorTest.addResult("-------- Setting mode: [" + mode + "]");
     InspectorTest.dumpNavigatorView(view);
 }
 
 InspectorTest.assertGreaterOrEqual = function(a, b, message)
 {
@@ skipping 14 matching lines @@
 
 InspectorTest.reloadPage = function(callback, scriptToEvaluateOnLoad, scriptPreprocessor)
 {
     InspectorTest._innerReloadPage(false, callback, scriptToEvaluateOnLoad, scriptPreprocessor);
 }
 
 InspectorTest._innerReloadPage = function(hardReload, callback, scriptToEvaluateOnLoad, scriptPreprocessor)
 {
     InspectorTest._pageLoadedCallback = InspectorTest.safeWrap(callback);
 
-    if (WebInspector.panels.network)
-        WebInspector.panels.network._networkLogView.reset();
+    if (UI.panels.network)
+        UI.panels.network._networkLogView.reset();
     InspectorTest.PageAgent.reload(hardReload, scriptToEvaluateOnLoad, scriptPreprocessor);
 }
 
 InspectorTest.pageLoaded = function()
 {
     InspectorTest.addResult("Page reloaded.");
     if (InspectorTest._pageLoadedCallback) {
         var callback = InspectorTest._pageLoadedCallback;
         delete InspectorTest._pageLoadedCallback;
         callback();
     }
 }
 
 InspectorTest.runWhenPageLoads = function(callback)
 {
     var oldCallback = InspectorTest._pageLoadedCallback;
     function chainedCallback()
     {
         if (oldCallback)
             oldCallback();
         callback();
     }
     InspectorTest._pageLoadedCallback = InspectorTest.safeWrap(chainedCallback);
 }
 
 InspectorTest.deprecatedRunAfterPendingDispatches = function(callback)
 {
     var barrier = new CallbackBarrier();
-    var targets = WebInspector.targetManager.targets();
+    var targets = SDK.targetManager.targets();
     for (var i = 0; i < targets.length; ++i)
         targets[i]._deprecatedRunAfterPendingDispatches(barrier.createCallback());
     barrier.callWhenDone(InspectorTest.safeWrap(callback));
 }
 
 InspectorTest.createKeyEvent = function(key, ctrlKey, altKey, shiftKey, metaKey)
 {
     return new KeyboardEvent("keydown", {key: key, bubbles: true, cancelable: true, ctrlKey: ctrlKey, altKey: altKey, shiftKey: shiftKey, metaKey: metaKey});
 }
 
@@ skipping 118 matching lines @@
             } catch (e) {
                 reject("Exception in overriden method '" + methodName + "': " + e);
             }
             return result;
         };
     });
 }
 
 InspectorTest.addConsoleSniffer = function(override, opt_sticky)
 {
-    InspectorTest.addSniffer(WebInspector.ConsoleModel.prototype, "addMessage", override, opt_sticky);
+    InspectorTest.addSniffer(SDK.ConsoleModel.prototype, "addMessage", override, opt_sticky);
 }
 
 InspectorTest.override = function(receiver, methodName, override, opt_sticky)
 {
     override = InspectorTest.safeWrap(override);
 
     var original = receiver[methodName];
     if (typeof original !== "function")
         throw ("Cannot find method to override: " + methodName);
 
@@ skipping 64 matching lines @@
 InspectorTest.clearSpecificInfoFromStackFrames = function(text)
 {
     var buffer = text.replace(/\(file:\/\/\/(?:[^)]+\)|[\w\/:-]+)/g, "(...)");
     buffer = buffer.replace(/\(<anonymous>:[^)]+\)/g, "(...)");
     buffer = buffer.replace(/VM\d+/g, "VM");
     return buffer.replace(/\s*at[^()]+\(native\)/g, "");
 }
 
 InspectorTest.hideInspectorView = function()
 {
-    WebInspector.inspectorView.element.setAttribute("style", "display:none !important");
+    UI.inspectorView.element.setAttribute("style", "display:none !important");
 }
 
 InspectorTest.mainFrame = function()
 {
-    return WebInspector.ResourceTreeModel.fromTarget(InspectorTest.mainTarget).mainFrame;
+    return SDK.ResourceTreeModel.fromTarget(InspectorTest.mainTarget).mainFrame;
 }
 
 InspectorTest.StringOutputStream = function(callback)
 {
     this._callback = callback;
     this._buffer = "";
 };
 
 InspectorTest.StringOutputStream.prototype = {
     open: function(fileName, callback)
@@ skipping 27 matching lines @@
     set: function(value) {
         this._value = value;
     }
 };
 
 
 /**
  * @constructor
  * @param {!string} dirPath
  * @param {!string} name
- * @param {!function(?WebInspector.TempFile)} callback
+ * @param {!function(?Bindings.TempFile)} callback
  */
 InspectorTest.TempFileMock = function(dirPath, name)
 {
     this._chunks = [];
     this._name = name;
 }
 
 InspectorTest.TempFileMock.prototype = {
     /**
      * @param {!Array.<string>} chunks
@@ skipping 30 matching lines @@
         reader = new FileReader();
         var self = this;
         reader.onloadend = function()
         {
             callback(reader.result);
         }
         reader.readAsText(blob);
     },
 
     /**
-     * @param {!WebInspector.OutputStream} outputStream
-     * @param {!WebInspector.OutputStreamDelegate} delegate
+     * @param {!Common.OutputStream} outputStream
+     * @param {!Bindings.OutputStreamDelegate} delegate
      */
     copyToOutputStream: function(outputStream, delegate)
     {
         var name = this._name;
         var text = this._chunks.join("");
         var chunkedReaderMock = {
             loadedSize: function()
             {
                 return text.length;
             },
@@ skipping 73 matching lines @@
 
     fireAllTimers: function()
     {
         for (var timeoutId in this._timeoutIdToProcess)
             this._timeoutIdToProcess[timeoutId].call(window);
         this._timeoutIdToProcess = {};
         this._timeoutIdToMillis = {};
     }
 }
 
-WebInspector.targetManager.observeTargets({
+SDK.targetManager.observeTargets({
     targetAdded: function(target)
     {
         if (InspectorTest.CSSAgent)
             return;
         InspectorTest.CSSAgent = target.cssAgent();
         InspectorTest.DeviceOrientationAgent = target.deviceOrientationAgent();
         InspectorTest.DOMAgent = target.domAgent();
         InspectorTest.DOMDebuggerAgent = target.domdebuggerAgent();
         InspectorTest.DebuggerAgent = target.debuggerAgent();
         InspectorTest.EmulationAgent = target.emulationAgent();
         InspectorTest.HeapProfilerAgent = target.heapProfilerAgent();
         InspectorTest.InspectorAgent = target.inspectorAgent();
         InspectorTest.NetworkAgent = target.networkAgent();
         InspectorTest.PageAgent = target.pageAgent();
         InspectorTest.ProfilerAgent = target.profilerAgent();
         InspectorTest.RuntimeAgent = target.runtimeAgent();
         InspectorTest.TargetAgent = target.targetAgent();
 
         InspectorTest.consoleModel = target.consoleModel;
-        InspectorTest.networkManager = WebInspector.NetworkManager.fromTarget(target);
-        InspectorTest.securityOriginManager = WebInspector.SecurityOriginManager.fromTarget(target);
-        InspectorTest.resourceTreeModel = WebInspector.ResourceTreeModel.fromTarget(target);
-        InspectorTest.networkLog = WebInspector.NetworkLog.fromTarget(target);
-        InspectorTest.debuggerModel = WebInspector.DebuggerModel.fromTarget(target);
+        InspectorTest.networkManager = SDK.NetworkManager.fromTarget(target);
+        InspectorTest.securityOriginManager = SDK.SecurityOriginManager.fromTarget(target);
+        InspectorTest.resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target);
+        InspectorTest.networkLog = SDK.NetworkLog.fromTarget(target);
+        InspectorTest.debuggerModel = SDK.DebuggerModel.fromTarget(target);
         InspectorTest.runtimeModel = target.runtimeModel;
-        InspectorTest.domModel = WebInspector.DOMModel.fromTarget(target);
-        InspectorTest.cssModel = WebInspector.CSSModel.fromTarget(target);
+        InspectorTest.domModel = SDK.DOMModel.fromTarget(target);
+        InspectorTest.cssModel = SDK.CSSModel.fromTarget(target);
         InspectorTest.powerProfiler = target.powerProfiler;
         InspectorTest.cpuProfilerModel = target.cpuProfilerModel;
         InspectorTest.heapProfilerModel = target.heapProfilerModel;
         InspectorTest.animationModel = target.animationModel;
         InspectorTest.serviceWorkerCacheModel = target.serviceWorkerCacheModel;
         InspectorTest.serviceWorkerManager = target.serviceWorkerManager;
         InspectorTest.tracingManager = target.tracingManager;
         InspectorTest.mainTarget = target;
     },
 
@@ skipping 115 matching lines @@
 
         // 1. Preload panels.
         var lastLoadedPanel;
 
         var promises = [];
         for (var moduleName of InspectorTest._modulesToPreload)
             promises.push(self.runtime.loadModulePromise(moduleName));
 
         for (var i = 0; i < InspectorTest._panelsToPreload.length; ++i) {
             lastLoadedPanel = InspectorTest._panelsToPreload[i];
-            promises.push(WebInspector.inspectorView.panel(lastLoadedPanel));
+            promises.push(UI.inspectorView.panel(lastLoadedPanel));
         }
 
-        var testPath = WebInspector.settings.createSetting("testPath", "").get();
+        var testPath = Common.settings.createSetting("testPath", "").get();
 
         // 2. Show initial panel based on test path.
         var initialPanelByFolder = {
             "animation": "elements",
             "audits": "audits",
             "console": "console",
             "elements": "elements",
             "editor": "sources",
             "layers": "layers",
             "network": "network",
             "profiler": "profiles",
             "resource-tree": "resources",
             "search": "sources",
             "security": "security",
             "service-workers": "resources",
             "sources": "sources",
             "timeline": "timeline",
             "tracing": "timeline",
         }
         var initialPanelShown = false;
         for (var folder in initialPanelByFolder) {
             if (testPath.indexOf(folder + "/") !== -1) {
                 lastLoadedPanel = initialPanelByFolder[folder];
-                promises.push(WebInspector.inspectorView.panel(lastLoadedPanel));
+                promises.push(UI.inspectorView.panel(lastLoadedPanel));
                 break;
             }
         }
 
         // 3. Run test function.
         Promise.all(promises).then(() => {
             if (lastLoadedPanel)
-                WebInspector.inspectorView.showPanel(lastLoadedPanel).then(testFunction);
+                UI.inspectorView.showPanel(lastLoadedPanel).then(testFunction);
             else
                 testFunction();
         }).catch(function(e) {
             console.error(e);
             InspectorTest.completeTest();
         });
     }
 
     var initializationFunctions = [ String(initialize_InspectorTest) ];
     for (var name in window) {
@@ skipping 70 matching lines @@
     _output("[page] " + text);
 }
 
 function _output(result)
 {
     if (!outputElement)
         createOutputElement();
     outputElement.appendChild(document.createTextNode(result));
     outputElement.appendChild(document.createElement("br"));
 }