DevTools: rename WebInspector into modules.

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

 var initialize_ConsoleTest = function() {
 
 InspectorTest.preloadModule("source_frame");
 InspectorTest.preloadPanel("console");
 
 InspectorTest.selectMainExecutionContext = function()
 {
     var executionContexts = InspectorTest.mainTarget.runtimeModel.executionContexts();
     for (var context of executionContexts) {
         if (context.isDefault) {
-            WebInspector.context.setFlavor(WebInspector.ExecutionContext, context);
+            UI.context.setFlavor(SDK.ExecutionContext, context);
             return;
         }
     }
 }
 
 InspectorTest.evaluateInConsole = function(code, callback, dontForceMainContext)
 {
     if (!dontForceMainContext)
         InspectorTest.selectMainExecutionContext();
     callback = InspectorTest.safeWrap(callback);
 
-    var consoleView = WebInspector.ConsoleView.instance();
+    var consoleView = Console.ConsoleView.instance();
     consoleView._prompt._appendCommand(code, true);
     InspectorTest.addConsoleViewSniffer(function(commandResult) {
         callback(commandResult.toMessageElement().deepTextContent());
     });
 }
 
 InspectorTest.addConsoleViewSniffer = function(override, opt_sticky)
 {
     var sniffer = function (viewMessage) {
         override(viewMessage);
     };
 
-    InspectorTest.addSniffer(WebInspector.ConsoleView.prototype, "_consoleMessageAddedForTest", sniffer, opt_sticky);
+    InspectorTest.addSniffer(Console.ConsoleView.prototype, "_consoleMessageAddedForTest", sniffer, opt_sticky);
 }
 
 InspectorTest.evaluateInConsoleAndDump = function(code, callback, dontForceMainContext)
 {
     callback = InspectorTest.safeWrap(callback);
 
     function mycallback(text)
     {
         text = text.replace(/\bVM\d+/g, "VM");
         InspectorTest.addResult(code + " = " + text);
@@ skipping 19 matching lines @@
     return messageText;
 }
 
 InspectorTest.disableConsoleViewport = function()
 {
     InspectorTest.fixConsoleViewportDimensions(600, 2000);
 }
 
 InspectorTest.fixConsoleViewportDimensions = function(width, height)
 {
-    var viewport = WebInspector.ConsoleView.instance()._viewport;
+    var viewport = Console.ConsoleView.instance()._viewport;
     viewport.element.style.width = width + "px";
     viewport.element.style.height = height + "px";
     viewport.element.style.position = "absolute";
     viewport.invalidate();
 }
 
 InspectorTest.consoleMessagesCount = function()
 {
-    var consoleView = WebInspector.ConsoleView.instance();
+    var consoleView = Console.ConsoleView.instance();
     return consoleView._consoleMessages.length;
 }
 
 InspectorTest.dumpConsoleMessages = function(printOriginatingCommand, dumpClassNames, formatter)
 {
     InspectorTest.addResults(InspectorTest.dumpConsoleMessagesIntoArray(printOriginatingCommand, dumpClassNames, formatter));
 }
 
 InspectorTest.dumpConsoleMessagesIntoArray = function(printOriginatingCommand, dumpClassNames, formatter)
 {
     formatter = formatter || InspectorTest.prepareConsoleMessageText;
     var result = [];
     InspectorTest.disableConsoleViewport();
-    var consoleView = WebInspector.ConsoleView.instance();
+    var consoleView = Console.ConsoleView.instance();
     if (consoleView._needsFullUpdate)
         consoleView._updateMessageList();
     var viewMessages = consoleView._visibleViewMessages;
     for (var i = 0; i < viewMessages.length; ++i) {
         var uiMessage = viewMessages[i];
         var message = uiMessage.consoleMessage();
         var element = uiMessage.element();
 
         if (dumpClassNames) {
             var classNames = [];
@@ skipping 43 matching lines @@
 }
 
 InspectorTest.dumpConsoleMessagesIgnoreErrorStackFrames = function(printOriginatingCommand, dumpClassNames, messageFormatter)
 {
     InspectorTest.addResults(InspectorTest.dumpConsoleMessagesIntoArray(printOriginatingCommand, dumpClassNames, InspectorTest.formatterIgnoreStackFrameUrls.bind(this, messageFormatter)));
 }
 
 InspectorTest.dumpConsoleTableMessage = function(viewMessage, forceInvalidate, results)
 {
     if (forceInvalidate)
-        WebInspector.ConsoleView.instance()._viewport.invalidate();
+        Console.ConsoleView.instance()._viewport.invalidate();
     var table = viewMessage.element();
     var headers = table.querySelectorAll("th > div:first-child");
     if (!headers.length)
         return false;
 
     var headerLine = "";
     for (var i = 0; i < headers.length; i++)
         headerLine += headers[i].textContent + " | ";
 
     addResult("HEADER " + headerLine);
@@ skipping 18 matching lines @@
         else
             InspectorTest.addResult(x);
     }
 
     return true;
 }
 
 InspectorTest.dumpConsoleMessagesWithStyles = function(sortMessages)
 {
     var result = [];
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     for (var i = 0; i < messageViews.length; ++i) {
         var element = messageViews[i].element();
         var messageText = InspectorTest.prepareConsoleMessageText(element);
         InspectorTest.addResult(messageText);
         var spans = element.querySelectorAll(".console-message-text *");
         for (var j = 0; j < spans.length; ++j)
             InspectorTest.addResult("Styled text #" + j + ": " + (spans[j].style.cssText || "NO STYLES DEFINED"));
     }
 }
 
 InspectorTest.dumpConsoleMessagesWithClasses = function(sortMessages) {
     var result = [];
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     for (var i = 0; i < messageViews.length; ++i) {
         var element = messageViews[i].element();
         var contentElement = messageViews[i].contentElement();
         var messageText = InspectorTest.prepareConsoleMessageText(element);
         result.push(messageText + " " + element.getAttribute("class") + " > " + contentElement.getAttribute("class"));
     }
     if (sortMessages)
         result.sort();
     for (var i = 0; i < result.length; ++i)
         InspectorTest.addResult(result[i]);
 }
 
 InspectorTest.dumpConsoleClassesBrief = function()
 {
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     for (var i = 0; i < messageViews.length; ++i)
         InspectorTest.addResult(messageViews[i].toMessageElement().className);
 }
 
 InspectorTest.dumpConsoleCounters = function()
 {
-    var counter = WebInspector.Main.WarningErrorCounter._instanceForTest;
+    var counter = Main.Main.WarningErrorCounter._instanceForTest;
     for (var index = 0; index < counter._titles.length; ++index)
         InspectorTest.addResult(counter._titles[index]);
     InspectorTest.dumpConsoleClassesBrief();
 }
 
 InspectorTest.expandConsoleMessages = function(callback, deepFilter, sectionFilter)
 {
-    WebInspector.ConsoleView.instance()._viewportThrottler.flush();
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    Console.ConsoleView.instance()._viewportThrottler.flush();
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
 
     // Initiate round-trips to fetch necessary data for further rendering.
     for (var i = 0; i < messageViews.length; ++i)
         messageViews[i].element();
 
     InspectorTest.deprecatedRunAfterPendingDispatches(expandTreeElements);
 
     function expandTreeElements()
     {
         for (var i = 0; i < messageViews.length; ++i) {
@@ skipping 19 matching lines @@
                     }
                 }
             }
         }
         InspectorTest.deprecatedRunAfterPendingDispatches(callback);
     }
 }
 
 InspectorTest.expandGettersInConsoleMessages = function(callback)
 {
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     var properties = [];
     var propertiesCount  = 0;
-    InspectorTest.addSniffer(WebInspector.ObjectPropertyTreeElement.prototype, "_updateExpandable", propertyExpandableUpdated);
+    InspectorTest.addSniffer(Components.ObjectPropertyTreeElement.prototype, "_updateExpandable", propertyExpandableUpdated);
     for (var i = 0; i < messageViews.length; ++i) {
         var element = messageViews[i].element();
         for (var node = element; node; node = node.traverseNextNode(element)) {
             if (node.classList && node.classList.contains("object-value-calculate-value-button")) {
                 ++propertiesCount;
                 node.click();
                 properties.push(node.parentElement.parentElement);
             }
         }
     }
 
     function propertyExpandableUpdated()
     {
         --propertiesCount;
         if (propertiesCount === 0) {
             for (var i = 0; i < properties.length; ++i)
                 properties[i].click();
             InspectorTest.deprecatedRunAfterPendingDispatches(callback);
         } else {
-            InspectorTest.addSniffer(WebInspector.ObjectPropertyTreeElement.prototype, "_updateExpandable", propertyExpandableUpdated);
+            InspectorTest.addSniffer(Components.ObjectPropertyTreeElement.prototype, "_updateExpandable", propertyExpandableUpdated);
         }
     }
 }
 
 InspectorTest.expandConsoleMessagesErrorParameters = function(callback)
 {
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     // Initiate round-trips to fetch necessary data for further rendering.
     for (var i = 0; i < messageViews.length; ++i)
         messageViews[i].element();
     InspectorTest.deprecatedRunAfterPendingDispatches(callback);
 }
 
 InspectorTest.waitForRemoteObjectsConsoleMessages = function(callback)
 {
-    var messages = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messages = Console.ConsoleView.instance()._visibleViewMessages;
     for (var i = 0; i < messages.length; ++i)
         messages[i].toMessageElement();
     InspectorTest.deprecatedRunAfterPendingDispatches(callback);
 }
 
 InspectorTest.checkConsoleMessagesDontHaveParameters = function()
 {
-    var messageViews = WebInspector.ConsoleView.instance()._visibleViewMessages;
+    var messageViews = Console.ConsoleView.instance()._visibleViewMessages;
     for (var i = 0; i < messageViews.length; ++i) {
         var m = messageViews[i].consoleMessage();
         InspectorTest.addResult("Message[" + i + "]:");
-        InspectorTest.addResult("Message: " + WebInspector.displayNameForURL(m.url) + ":" + m.line + " " + m.message);
+        InspectorTest.addResult("Message: " + Bindings.displayNameForURL(m.url) + ":" + m.line + " " + m.message);
         if ("_parameters" in m) {
             if (m._parameters)
                 InspectorTest.addResult("FAILED: message parameters list is not empty: " + m.parameters);
             else
                 InspectorTest.addResult("SUCCESS: message parameters list is empty. ");
         } else {
             InspectorTest.addResult("FAILED: didn't find _parameters field in the message.");
         }
     }
 }
 
 InspectorTest.waitUntilConsoleEditorLoaded = function()
 {
     var fulfill;
     var promise = new Promise(x => fulfill = x);
-    var editor = WebInspector.ConsoleView.instance()._prompt._editor;
+    var editor = Console.ConsoleView.instance()._prompt._editor;
     if (editor)
         fulfill(editor);
     else
-        InspectorTest.addSniffer(WebInspector.ConsolePrompt.prototype, "_editorSetForTest", _ => fulfill(editor))
+        InspectorTest.addSniffer(Console.ConsolePrompt.prototype, "_editorSetForTest", _ => fulfill(editor))
     return promise;
 }
 
 InspectorTest.waitUntilMessageReceived = function(callback)
 {
     InspectorTest.addSniffer(InspectorTest.consoleModel, "addMessage", callback, false);
 }
 
 InspectorTest.waitUntilMessageReceivedPromise = function()
 {
@@ skipping 18 matching lines @@
 InspectorTest.waitUntilNthMessageReceivedPromise = function(count)
 {
     var callback;
     var promise = new Promise((fullfill) => callback = fullfill);
     InspectorTest.waitUntilNthMessageReceived(count, callback);
     return promise;
 }
 
 InspectorTest.changeExecutionContext = function(namePrefix)
 {
-    var selector = WebInspector.ConsoleView.instance()._consoleContextSelector._selectElement;
+    var selector = Console.ConsoleView.instance()._consoleContextSelector._selectElement;
     var option = selector.firstChild;
     while (option) {
         if (option.textContent && option.textContent.startsWith(namePrefix))
             break;
         option = option.nextSibling;
     }
     if (!option) {
         InspectorTest.addResult("FAILED: context with prefix: "  + namePrefix + " not found in the context list");
         return;
     }
     option.selected = true;
-    WebInspector.ConsoleView.instance()._consoleContextSelector._executionContextChanged();
+    Console.ConsoleView.instance()._consoleContextSelector._executionContextChanged();
 }
 
 InspectorTest.waitForConsoleMessages = function(expectedCount, callback)
 {
-    var consoleView = WebInspector.ConsoleView.instance();
+    var consoleView = Console.ConsoleView.instance();
     checkAndReturn();
 
     function checkAndReturn()
     {
         if (consoleView._visibleViewMessages.length === expectedCount) {
             InspectorTest.addResult("Message count: " + expectedCount);
             callback();
         } else {
             InspectorTest.addSniffer(consoleView, "_messageAppendedForTests", checkAndReturn);
         }
     }
 }
 
 }