DevTools: rename WebInspector into modules.

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

 var initialize_ElementTest = function() {
 
 InspectorTest.preloadPanel("elements");
 
 InspectorTest.inlineStyleSection = function()
 {
-    return WebInspector.panels.elements._stylesWidget._sectionBlocks[0].sections[0];
+    return UI.panels.elements._stylesWidget._sectionBlocks[0].sections[0];
 }
 
 InspectorTest.computedStyleWidget = function()
 {
-    return WebInspector.panels.elements._computedStyleWidget;
+    return UI.panels.elements._computedStyleWidget;
 }
 
 InspectorTest.dumpComputedStyle = function(doNotAutoExpand)
 {
     var computed = InspectorTest.computedStyleWidget();
     var treeOutline = computed._propertiesOutline;
     var children = treeOutline.rootElement().children();
     for (var treeElement of children) {
-        var property = treeElement[WebInspector.ComputedStyleWidget._propertySymbol];
+        var property = treeElement[Elements.ComputedStyleWidget._propertySymbol];
         if (property.name === "width" || property.name === "height")
             continue;
         var dumpText = "";
         dumpText += treeElement.title.querySelector(".property-name").textContent;
         dumpText += " ";
         dumpText += treeElement.title.querySelector(".property-value").textContent;
         InspectorTest.addResult(dumpText);
         if (doNotAutoExpand && !treeElement.expanded)
             continue;
         for (var trace of treeElement.children()) {
@@ skipping 11 matching lines @@
         }
     }
 }
 
 InspectorTest.findComputedPropertyWithName = function(name)
 {
     var computed = InspectorTest.computedStyleWidget();
     var treeOutline = computed._propertiesOutline;
     var children = treeOutline.rootElement().children();
     for (var treeElement of children) {
-        var property = treeElement[WebInspector.ComputedStyleWidget._propertySymbol];
+        var property = treeElement[Elements.ComputedStyleWidget._propertySymbol];
         if (property.name === name)
             return treeElement;
     }
     return null;
 }
 
 InspectorTest.firstMatchedStyleSection = function()
 {
-    return WebInspector.panels.elements._stylesWidget._sectionBlocks[0].sections[1];
+    return UI.panels.elements._stylesWidget._sectionBlocks[0].sections[1];
 }
 
 InspectorTest.firstMediaTextElementInSection = function(section)
 {
     return section.element.querySelector(".media-text");
 }
 
 InspectorTest.findNode = function(matchFunction, callback)
 {
     callback = InspectorTest.safeWrap(callback);
@@ skipping 88 matching lines @@
     function callback(node)
     {
         result = node;
     }
     InspectorTest.nodeWithId(idValue, callback);
     return result;
 }
 
 InspectorTest.selectNode = function(node)
 {
-    return WebInspector.Revealer.revealPromise(node);
+    return Common.Revealer.revealPromise(node);
 }
 
 InspectorTest.selectNodeWithId = function(idValue, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     function onNodeFound(node)
     {
         InspectorTest.selectNode(node).then(callback.bind(null, node));
     }
     InspectorTest.nodeWithId(idValue, onNodeFound);
 }
 
 function waitForStylesRebuild(matchFunction, callback, requireRebuild)
 {
     (function sniff(node, rebuild)
     {
         if ((rebuild || !requireRebuild) && node && matchFunction(node)) {
             callback();
             return;
         }
-        InspectorTest.addSniffer(WebInspector.StylesSidebarPane.prototype, "_nodeStylesUpdatedForTest", sniff);
+        InspectorTest.addSniffer(Elements.StylesSidebarPane.prototype, "_nodeStylesUpdatedForTest", sniff);
     })(null);
 }
 
 InspectorTest.waitForStyles = function(idValue, callback, requireRebuild)
 {
     callback = InspectorTest.safeWrap(callback);
 
     function nodeWithId(node)
     {
         return node.getAttribute("id") === idValue;
@@ skipping 10 matching lines @@
     {
         var classAttr = node.getAttribute("class");
         return classAttr && classAttr.indexOf(classValue) > -1;
     }
 
     waitForStylesRebuild(nodeWithClass, callback, requireRebuild);
 }
 
 InspectorTest.waitForSelectorCommitted = function(callback)
 {
-    InspectorTest.addSniffer(WebInspector.StylePropertiesSection.prototype, "_editingSelectorCommittedForTest", callback);
+    InspectorTest.addSniffer(Elements.StylePropertiesSection.prototype, "_editingSelectorCommittedForTest", callback);
 }
 
 InspectorTest.waitForMediaTextCommitted = function(callback)
 {
-    InspectorTest.addSniffer(WebInspector.StylePropertiesSection.prototype, "_editingMediaTextCommittedForTest", callback);
+    InspectorTest.addSniffer(Elements.StylePropertiesSection.prototype, "_editingMediaTextCommittedForTest", callback);
 }
 
 InspectorTest.waitForStyleApplied = function(callback)
 {
-    InspectorTest.addSniffer(WebInspector.StylePropertyTreeElement.prototype, "styleTextAppliedForTest", callback);
+    InspectorTest.addSniffer(Elements.StylePropertyTreeElement.prototype, "styleTextAppliedForTest", callback);
 }
 
 InspectorTest.selectNodeAndWaitForStyles = function(idValue, callback)
 {
     callback = InspectorTest.safeWrap(callback);
 
     var targetNode;
 
     InspectorTest.waitForStyles(idValue, stylesUpdated, true);
     InspectorTest.selectNodeWithId(idValue, nodeSelected);
@@ skipping 14 matching lines @@
     callback = InspectorTest.safeWrap(callback);
 
     var targetNode;
 
     waitForStylesRebuild(isPseudoElement, stylesUpdated, true);
     InspectorTest.findNode(isPseudoElement, nodeFound)
 
     function nodeFound(node)
     {
         targetNode = node;
-        WebInspector.Revealer.reveal(node);
+        Common.Revealer.reveal(node);
     }
 
     function stylesUpdated()
     {
         callback(targetNode);
     }
 
     function isPseudoElement(node)
     {
         return node.parentNode && node.parentNode.getAttribute("id") === parentId && node.pseudoType() == pseudoType;
     }
 }
 
 InspectorTest.selectNodeAndWaitForStylesWithComputed = function(idValue, callback)
 {
     callback = InspectorTest.safeWrap(callback);
     InspectorTest.selectNodeAndWaitForStyles(idValue, onSidebarRendered);
 
     function onSidebarRendered(node)
     {
         InspectorTest.computedStyleWidget().doUpdate().then(callback.bind(null, node));
     }
 }
 
 InspectorTest.firstElementsTreeOutline = function()
 {
-    return WebInspector.panels.elements._treeOutlines[0];
+    return UI.panels.elements._treeOutlines[0];
 }
 
 InspectorTest.filterMatchedStyles = function(text)
 {
     var regex = text ? new RegExp(text, "i") : null;
     InspectorTest.addResult("Filtering styles by: " + text);
-    WebInspector.panels.elements._stylesWidget.onFilterChanged(regex);
+    UI.panels.elements._stylesWidget.onFilterChanged(regex);
 }
 
 InspectorTest.dumpRenderedMatchedStyles = function()
 {
-    var sectionBlocks = WebInspector.panels.elements._stylesWidget._sectionBlocks;
+    var sectionBlocks = UI.panels.elements._stylesWidget._sectionBlocks;
     for (var block of sectionBlocks) {
         for (var section of block.sections) {
             // Skip sections which were filtered out.
             if (section.element.classList.contains("hidden"))
                 continue;
             dumpRenderedSection(section);
         }
     }
 
     function dumpRenderedSection(section)
@@ skipping 27 matching lines @@
             text += String.sprintf("%s: %s", childProperty.nameElement.textContent, childProperty.valueElement.textContent);
             if (childProperty.listItemElement.classList.contains("filter-match"))
                 text = "F" + text.substring(1);
             InspectorTest.addResult(text);
         }
     }
 }
 
 InspectorTest.dumpSelectedElementStyles = function(excludeComputed, excludeMatched, omitLonghands, includeSelectorGroupMarks)
 {
-    var sectionBlocks = WebInspector.panels.elements._stylesWidget._sectionBlocks;
+    var sectionBlocks = UI.panels.elements._stylesWidget._sectionBlocks;
     if (!excludeComputed)
         InspectorTest.dumpComputedStyle();
     for (var block of sectionBlocks) {
         for (var section of block.sections) {
             if (section.style().parentRule && excludeMatched)
                 continue;
             if (section.element.previousSibling && section.element.previousSibling.className === "sidebar-separator") {
                 var nodeDescription = "";
                 if (section.element.previousSibling.firstElementChild)
                     nodeDescription = section.element.previousSibling.firstElementChild.shadowRoot.lastChild.textContent;
@@ skipping 29 matching lines @@
     InspectorTest.dumpStyleTreeOutline(section.propertiesTreeOutline, omitLonghands ? 1 : 2);
     InspectorTest.addResult("");
 }
 
 function extractLinkText(element)
 {
     var anchor = element.nodeName === "A" ? element : element.querySelector("a");
     if (!anchor)
         return element.textContent;
     var anchorText = anchor.textContent;
-    var uiLocation = anchor[WebInspector.Linkifier._uiLocationSymbol];
+    var uiLocation = anchor[Components.Linkifier._uiLocationSymbol];
     var anchorTarget = uiLocation ? (uiLocation.uiSourceCode.name() + ":" + (uiLocation.lineNumber + 1) + ":" + (uiLocation.columnNumber + 1)) : "";
     return anchorText + " -> " + anchorTarget;
 }
 
 function buildMarkedSelectors(element)
 {
     var result = "";
     for (var node = element.firstChild; node; node = node.nextSibling) {
         if (node.nodeType === Node.ELEMENT_NODE && node.classList.contains("selector-matches"))
             result += "[$" + node.textContent + "$]";
@@ skipping 10 matching lines @@
 }
 
 InspectorTest.toggleMatchedStyleProperty = function(propertyName, checked)
 {
     var treeItem = InspectorTest.getMatchedStylePropertyTreeItem(propertyName);
     treeItem._toggleEnabled({ target: { checked: checked }, consume: function() { } });
 }
 
 InspectorTest.eventListenersWidget = function()
 {
-    WebInspector.viewManager.showView("elements.eventListeners");
-    return self.runtime.sharedInstance(WebInspector.EventListenersWidget);
+    UI.viewManager.showView("elements.eventListeners");
+    return self.runtime.sharedInstance(Elements.EventListenersWidget);
 }
 
 InspectorTest.showEventListenersWidget = function()
 {
-    return WebInspector.viewManager.showView("elements.eventListeners");
+    return UI.viewManager.showView("elements.eventListeners");
 }
 
 InspectorTest.expandAndDumpSelectedElementEventListeners = function(callback)
 {
     InspectorTest.expandAndDumpEventListeners(InspectorTest.eventListenersWidget()._eventListenersView, callback);
 }
 
 InspectorTest.dumpObjectPropertySectionDeep = function(section)
 {
     function domNodeToString(node) {
@@ skipping 19 matching lines @@
 
 // FIXME: this returns the first tree item found (may fail for same-named properties in a style).
 InspectorTest.getElementStylePropertyTreeItem = function(propertyName)
 {
     return InspectorTest.getFirstPropertyTreeItemForSection(InspectorTest.inlineStyleSection(), propertyName);
 };
 
 // FIXME: this returns the first tree item found (may fail for same-named properties in a style).
 InspectorTest.getMatchedStylePropertyTreeItem = function(propertyName)
 {
-    var sectionBlocks = WebInspector.panels.elements._stylesWidget._sectionBlocks;
+    var sectionBlocks = UI.panels.elements._stylesWidget._sectionBlocks;
     for (var block of sectionBlocks) {
         for (var section of block.sections) {
             var treeItem = InspectorTest.getFirstPropertyTreeItemForSection(section, propertyName);
             if (treeItem)
                 return treeItem;
         }
     }
     return null;
 };
 
@@ skipping 123 matching lines @@
 
     var treeOutline = InspectorTest.firstElementsTreeOutline();
     treeOutline.runPendingUpdates();
     print(rootNode ? treeOutline.findTreeElement(rootNode) : treeOutline.rootElement(), "", depth || 10000);
 };
 
 InspectorTest.dumpDOMUpdateHighlights = function(rootNode, callback, depth)
 {
     var hasHighlights = false;
 
-    InspectorTest.addSniffer(WebInspector.ElementsTreeOutline.prototype, "_updateModifiedNodes", didUpdate);
+    InspectorTest.addSniffer(Elements.ElementsTreeOutline.prototype, "_updateModifiedNodes", didUpdate);
 
     function didUpdate()
     {
         var treeOutline = InspectorTest.firstElementsTreeOutline();
         print(rootNode ? treeOutline.findTreeElement(rootNode) : treeOutline.rootElement(), "", depth || 10000);
         if (!hasHighlights)
             InspectorTest.addResult("<No highlights>");
         if (callback)
             callback();
     }
 
     function print(treeItem, prefix, depth)
     {
         if (!treeItem.root) {
-            var elementXPath = WebInspector.DOMPresentationUtils.xPath(treeItem.node(), true);
+            var elementXPath = Components.DOMPresentationUtils.xPath(treeItem.node(), true);
             var highlightedElements = treeItem.listItemElement.querySelectorAll(".dom-update-highlight");
             for (var i = 0; i < highlightedElements.length; ++i) {
                 var element = highlightedElements[i];
                 var classList = element.classList;
                 var xpath = elementXPath;
                 if (classList.contains("webkit-html-attribute-name")) {
                     xpath += "/@" + element.textContent + " (empty)";
                 } else if (classList.contains("webkit-html-attribute-value")) {
                     name = element.parentElement.querySelector(".webkit-html-attribute-name").textContent;
                     xpath += "/@" + name + " " + element.textContent;
@@ skipping 247 matching lines @@
         else
             InspectorTest.addResult(currentIndent + "[text='" + property.text + "'] disabled");
     }
 }
 
 InspectorTest.dumpBreadcrumb = function(message)
 {
     if (message)
         InspectorTest.addResult(message + ":");
     var result = [];
-    var crumbs = WebInspector.panels.elements._breadcrumbs.crumbsElement;
+    var crumbs = UI.panels.elements._breadcrumbs.crumbsElement;
     var crumb = crumbs.lastChild;
     while (crumb) {
         result.unshift(crumb.textContent);
         crumb = crumb.previousSibling;
     }
     InspectorTest.addResult(result.join(" > "));
 }
 
 InspectorTest.matchingSelectors = function(matchedStyles, rule)
 {
     var selectors = [];
     var matchingSelectors = matchedStyles.matchingSelectors(rule);
     for (var i = 0; i < matchingSelectors.length; ++i)
         selectors.push(rule.selectors[matchingSelectors[i]].text);
     return "[" + selectors.join(", ") + "]";
 }
 
 InspectorTest.addNewRuleInStyleSheet = function(styleSheetHeader, selector, callback)
 {
-    InspectorTest.addSniffer(WebInspector.StylesSidebarPane.prototype, "_addBlankSection", onBlankSection.bind(null, selector, callback));
-    WebInspector.panels.elements._stylesWidget._createNewRuleInStyleSheet(styleSheetHeader);
+    InspectorTest.addSniffer(Elements.StylesSidebarPane.prototype, "_addBlankSection", onBlankSection.bind(null, selector, callback));
+    UI.panels.elements._stylesWidget._createNewRuleInStyleSheet(styleSheetHeader);
 }
 
 InspectorTest.addNewRule = function(selector, callback)
 {
     // Click "Add new rule".
     document.querySelector(".styles-pane-toolbar").shadowRoot.querySelector(".largeicon-add").click();
-    InspectorTest.addSniffer(WebInspector.StylesSidebarPane.prototype, "_addBlankSection", onBlankSection.bind(null, selector, callback));
+    InspectorTest.addSniffer(Elements.StylesSidebarPane.prototype, "_addBlankSection", onBlankSection.bind(null, selector, callback));
 }
 
 function onBlankSection(selector, callback)
 {
     var section = InspectorTest.firstMatchedStyleSection();
     if (typeof selector === "string")
         section._selectorElement.textContent = selector;
     section._selectorElement.dispatchEvent(InspectorTest.createKeyEvent("Enter"));
     InspectorTest.waitForSelectorCommitted(callback.bind(null, section));
 }
 
 InspectorTest.dumpInspectorHighlightJSON = function(idValue, callback)
 {
     InspectorTest.nodeWithId(idValue, nodeResolved);
 
     function nodeResolved(node)
     {
         InspectorTest.DOMAgent.getHighlightObjectForTest(node.id, report);
     }
 
     function report(error, result)
     {
         InspectorTest.addResult(idValue + JSON.stringify(result, null, 2));
         callback();
     }
 }
 
 InspectorTest.waitForAnimationAdded = function(callback)
 {
-    InspectorTest.addSniffer(WebInspector.AnimationTimeline.prototype, "_addAnimationGroup", callback);
+    InspectorTest.addSniffer(Animation.AnimationTimeline.prototype, "_addAnimationGroup", callback);
 }
 
 InspectorTest.dumpAnimationTimeline = function(timeline)
 {
     for (var ui of timeline._uiAnimations) {
         InspectorTest.addResult(ui.animation().type());
         InspectorTest.addResult(ui._nameElement.innerHTML);
         InspectorTest.addResult(ui._svg.innerHTML);
     }
 }
 
 };