DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/accessibility/AXTreePane.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
-WebInspector.AXTreePane = class extends WebInspector.AccessibilitySubPane {
+Accessibility.AXTreePane = class extends Accessibility.AccessibilitySubPane {
   constructor() {
-    super(WebInspector.UIString('Accessibility Tree'));
+    super(Common.UIString('Accessibility Tree'));
 
     this._treeOutline = this.createTreeOutline();
 
     this.element.classList.add('accessibility-computed');
 
     this._expandedNodes = new Set();
   }
 
   /**
-   * @param {?WebInspector.AccessibilityNode} axNode
+   * @param {?Accessibility.AccessibilityNode} axNode
    * @override
    */
   setAXNode(axNode) {
     this._axNode = axNode;
 
     var treeOutline = this._treeOutline;
     treeOutline.removeChildren();
 
     // TODO(aboxhall): show no node UI
     if (!axNode)
       return;
 
     treeOutline.element.classList.remove('hidden');
     var previousTreeElement = treeOutline.rootElement();
-    var inspectedNodeTreeElement = new WebInspector.AXNodeTreeElement(axNode, this);
+    var inspectedNodeTreeElement = new Accessibility.AXNodeTreeElement(axNode, this);
     inspectedNodeTreeElement.setInspected(true);
 
     var parent = axNode.parentNode();
     if (parent) {
       this.setExpanded(parent.backendDOMNodeId(), false);
 
       var chain = [];
       var ancestor = parent.parentNode();
       while (ancestor) {
         chain.unshift(ancestor);
         ancestor = ancestor.parentNode();
       }
       for (var ancestorNode of chain) {
-        var ancestorTreeElement = new WebInspector.AXNodeTreeElement(ancestorNode, this);
+        var ancestorTreeElement = new Accessibility.AXNodeTreeElement(ancestorNode, this);
         previousTreeElement.appendChild(ancestorTreeElement);
         previousTreeElement.expand();
         previousTreeElement = ancestorTreeElement;
       }
-      var parentTreeElement = new WebInspector.AXNodeTreeParentElement(parent, inspectedNodeTreeElement, this);
+      var parentTreeElement = new Accessibility.AXNodeTreeParentElement(parent, inspectedNodeTreeElement, this);
       previousTreeElement.appendChild(parentTreeElement);
       if (this.isExpanded(parent.backendDOMNodeId()))
         parentTreeElement.appendSiblings();
       else
         parentTreeElement.appendChild(inspectedNodeTreeElement);
       previousTreeElement.expand();
       previousTreeElement = parentTreeElement;
     } else {
       previousTreeElement.appendChild(inspectedNodeTreeElement);
     }
 
     previousTreeElement.expand();
 
     for (var child of axNode.children()) {
-      var childTreeElement = new WebInspector.AXNodeTreeElement(child, this);
+      var childTreeElement = new Accessibility.AXNodeTreeElement(child, this);
       inspectedNodeTreeElement.appendChild(childTreeElement);
     }
 
     inspectedNodeTreeElement.selectable = true;
     inspectedNodeTreeElement.select(!this._selectedByUser /* omitFocus */, false);
     if (this.isExpanded(axNode.backendDOMNodeId()))
       inspectedNodeTreeElement.expand();
     this.clearSelectedByUser();
   }
 
   /**
    * @param {boolean} selectedByUser
    */
   setSelectedByUser(selectedByUser) {
     this._selectedByUser = true;
   }
 
   clearSelectedByUser() {
     delete this._selectedByUser;
   }
 
   /**
-   * @return {!WebInspector.Target}
+   * @return {!SDK.Target}
    */
   target() {
     return this.node().target();
   }
 
   /**
    * @param {?number} backendDOMNodeId
    * @param {boolean} expanded
    */
   setExpanded(backendDOMNodeId, expanded) {
@@ skipping 10 matching lines @@
    * @return {boolean}
    */
   isExpanded(backendDOMNodeId) {
     if (!backendDOMNodeId)
       return false;
 
     return this._expandedNodes.has(backendDOMNodeId);
   }
 };
 
-WebInspector.InspectNodeButton = class {
+Accessibility.InspectNodeButton = class {
   /**
-   * @param {!WebInspector.AccessibilityNode} axNode
-   * @param {!WebInspector.AXTreePane} treePane
+   * @param {!Accessibility.AccessibilityNode} axNode
+   * @param {!Accessibility.AXTreePane} treePane
    */
   constructor(axNode, treePane) {
     this._axNode = axNode;
     this._treePane = treePane;
 
     this.element = createElementWithClass('button', 'inspect-dom-node');
     this.element.addEventListener('mousedown', this._handleMouseDown.bind(this));
   }
 
   /**
    * @param {!Event} event
    */
   _handleMouseDown(event) {
     this._treePane.setSelectedByUser(true);
-    WebInspector.Revealer.reveal(this._axNode.deferredDOMNode());
+    Common.Revealer.reveal(this._axNode.deferredDOMNode());
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AXNodeTreeElement = class extends TreeElement {
+Accessibility.AXNodeTreeElement = class extends TreeElement {
   /**
-   * @param {!WebInspector.AccessibilityNode} axNode
-   * @param {!WebInspector.AXTreePane} treePane
+   * @param {!Accessibility.AccessibilityNode} axNode
+   * @param {!Accessibility.AXTreePane} treePane
    */
   constructor(axNode, treePane) {
     // Pass an empty title, the title gets made later in onattach.
     super('');
 
-    /** @type {!WebInspector.AccessibilityNode} */
+    /** @type {!Accessibility.AccessibilityNode} */
     this._axNode = axNode;
 
-    /** @type {!WebInspector.AXTreePane} */
+    /** @type {!Accessibility.AXTreePane} */
     this._treePane = treePane;
 
     this.selectable = true;
 
     this._inspectNodeButton =
-        new WebInspector.InspectNodeButton(axNode, treePane);
+        new Accessibility.InspectNodeButton(axNode, treePane);
   }
 
   /**
-   * @return {!WebInspector.AccessibilityNode}
+   * @return {!Accessibility.AccessibilityNode}
    */
   axNode() {
     return this._axNode;
   }
 
   /**
    * @param {boolean} inspected
    */
   setInspected(inspected) {
     this._inspected = inspected;
@@ skipping 14 matching lines @@
    * @param {!Event} event
    * @return {boolean}
    */
   ondblclick(event) {
     this.inspectDOMNode();
     return true;
   }
 
   inspectDOMNode() {
     this._treePane.setSelectedByUser(true);
-    WebInspector.Revealer.reveal(this._axNode.deferredDOMNode());
+    Common.Revealer.reveal(this._axNode.deferredDOMNode());
   }
 
   /**
    * @override
    */
   onattach() {
     this._update();
   }
 
   _update() {
@@ skipping 55 matching lines @@
   }
 
   /**
    * @param {?Protocol.Accessibility.AXValue} role
    */
   _appendRoleElement(role) {
     if (!role)
       return;
 
     var roleElement = createElementWithClass('span', 'monospace');
-    roleElement.classList.add(WebInspector.AXNodeTreeElement.RoleStyles[role.type]);
+    roleElement.classList.add(Accessibility.AXNodeTreeElement.RoleStyles[role.type]);
     roleElement.setTextContentTruncatedIfNeeded(role.value || '');
 
     this.listItemElement.appendChild(roleElement);
   }
 
   _appendIgnoredNodeElement() {
     var ignoredNodeElement = createElementWithClass('span', 'monospace');
-    ignoredNodeElement.textContent = WebInspector.UIString('Ignored');
+    ignoredNodeElement.textContent = Common.UIString('Ignored');
     ignoredNodeElement.classList.add('ax-tree-ignored-node');
     this.listItemElement.appendChild(ignoredNodeElement);
   }
 
   /**
    * @param {boolean=} omitFocus
    * @param {boolean=} selectedByUser
    * @return {boolean}
    * @override
    */
   select(omitFocus, selectedByUser) {
     this._treePane.setSelectedByUser(!!selectedByUser);
 
     return super.select(omitFocus, selectedByUser);
   }
 };
 
 /** @type {!Object<string, string>} */
-WebInspector.AXNodeTreeElement.RoleStyles = {
+Accessibility.AXNodeTreeElement.RoleStyles = {
   internalRole: 'ax-internal-role',
   role: 'ax-role',
 };
 
 /**
  * @unrestricted
  */
-WebInspector.ExpandSiblingsButton = class {
+Accessibility.ExpandSiblingsButton = class {
   /**
-   * @param {!WebInspector.AXNodeTreeParentElement} treeElement
+   * @param {!Accessibility.AXNodeTreeParentElement} treeElement
    * @param {number} numSiblings
    */
   constructor(treeElement, numSiblings) {
     this._treeElement = treeElement;
 
     this.element = createElementWithClass('button', 'expand-siblings');
-    this.element.textContent = WebInspector.UIString(
+    this.element.textContent = Common.UIString(
         (numSiblings === 1 ? '+ %d node' : '+ %d nodes'), numSiblings);
     this.element.addEventListener('mousedown', this._handleMouseDown.bind(this));
   }
 
   /**
    * @param {!Event} event
    */
   _handleMouseDown(event) {
     this._treeElement.expandSiblings();
     event.consume();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.AXNodeTreeParentElement = class extends WebInspector.AXNodeTreeElement {
+Accessibility.AXNodeTreeParentElement = class extends Accessibility.AXNodeTreeElement {
   /**
-   * @param {!WebInspector.AccessibilityNode} axNode
-   * @param {!WebInspector.AXNodeTreeElement} inspectedNodeTreeElement
-   * @param {!WebInspector.AXTreePane} treePane
+   * @param {!Accessibility.AccessibilityNode} axNode
+   * @param {!Accessibility.AXNodeTreeElement} inspectedNodeTreeElement
+   * @param {!Accessibility.AXTreePane} treePane
    */
   constructor(axNode, inspectedNodeTreeElement, treePane) {
     super(axNode, treePane);
 
     this._inspectedNodeTreeElement = inspectedNodeTreeElement;
     var numSiblings = axNode.children().length - 1;
-    this._expandSiblingsButton = new WebInspector.ExpandSiblingsButton(this, numSiblings);
+    this._expandSiblingsButton = new Accessibility.ExpandSiblingsButton(this, numSiblings);
     this._partiallyExpanded = false;
   }
 
   /**
    * @override
    */
   onattach() {
     super.onattach();
     if (this._treePane.isExpanded(this._axNode.backendDOMNodeId()))
       this._listItemNode.classList.add('siblings-expanded');
@@ skipping 37 matching lines @@
   appendSiblings() {
     var inspectedAXNode = this._inspectedNodeTreeElement.axNode();
     var nextIndex = 0;
     var foundInspectedNode = false;
     for (var sibling of this._axNode.children()) {
       var siblingTreeElement = null;
       if (sibling === inspectedAXNode) {
         foundInspectedNode = true;
         continue;
       }
-      siblingTreeElement = new WebInspector.AXNodeTreeElement(sibling, this._treePane);
+      siblingTreeElement = new Accessibility.AXNodeTreeElement(sibling, this._treePane);
       if (foundInspectedNode)
         this.appendChild(siblingTreeElement);
       else
         this.insertChild(siblingTreeElement, nextIndex++);
     }
   }
 };