[DevTools] Accessibility: Show siblings and children of selected node

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

 // Copyright (c) 2014 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.AccessibilityNode = class extends WebInspector.SDKObject {
   /**
    * @param {!WebInspector.AccessibilityModel} accessibilityModel
    * @param {!AccessibilityAgent.AXNode} payload
    */
   constructor(accessibilityModel, payload) {
     super(accessibilityModel.target());
     this._accessibilityModel = accessibilityModel;
     this._agent = accessibilityModel._agent;
 
     this._id = payload.nodeId;
     accessibilityModel._setAXNodeForAXId(this._id, this);
 
     this._ignored = payload.ignored;
     if (this._ignored && 'ignoredReasons' in payload)
       this._ignoredReasons = payload.ignoredReasons;
 
     this._role = payload.role || null;
     this._name = payload.name || null;
     this._description = payload.description || null;
     this._value = payload.value || null;
     this._properties = payload.properties || null;
-    this._parentId = payload.parentId || null;
     this._childIds = payload.childIds || null;
-    this._domNodeId = payload.domNodeId || null;
+    this._backendDomNodeId = payload.backendDomNodeId || null;
+    this._parentNode = null;
   }
 
   /**
    * @return {boolean}
    */
   ignored() {
     return this._ignored;
   }
 
   /**
@@ skipping 51 matching lines @@
    * @return {?Array<!AccessibilityAgent.AXProperty>}
    */
   properties() {
     return this._properties || null;
   }
 
   /**
    * @return {?WebInspector.AccessibilityNode}
    */
   parentNode() {
-    if (!this._parentId)
-      return null;
-    return this._accessibilityModel.axNodeForId(this._parentId);
+    return this._parentNode;
+  }
+
+  /**
+   * @param {?WebInspector.AccessibilityNode} parentNode
+   */
+  _setParentNode(parentNode) {
+    this._parentNode = parentNode;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isDOMNode() {
+    return !!this._backendDomNodeId;
+  }
+
+  /**
+   * @return {?WebInspector.DOMNode}
+   */
+  domNode() {
+    return this._domNode || null;
+  }
+
+  /**
+   * @param {?WebInspector.DOMNode} domNode
+   */
+  _setDOMNode(domNode) {
+    this._domNode = domNode;
+    if (domNode)
+      this._accessibilityModel.setAXNodeForDOMNode(domNode, this);
+  }
+
+  /**
+   * @return {!Promise<?WebInspector.DOMNode>}
+   */
+  resolveDOMNode() {
+    if (this._domNode)
+      return Promise.resolve(this._domNode);
+    if (!this._backendDomNodeId)
+      return Promise.resolve(/** @type {?WebInspector.DOMNode} */ (null));
+
+    var deferredNode = new WebInspector.DeferredDOMNode(this.target(), this._backendDomNodeId);
+    return deferredNode.resolvePromise().then((domNode) => {
+      this._setDOMNode(domNode);
+      return domNode;
+    });
+  }
+
+  /**
+   * @return {!Array<!WebInspector.AccessibilityNode>}
+   */
+  children() {
+    var children = [];
+    if (!this._childIds)
+      return children;
+
+    for (var childId of this._childIds) {
+      var child = this._accessibilityModel.axNodeForId(childId);
+      if (child)
+        children.push(child);
+    }
+
+    return children;
+  }
+
+  /**
+   * @return {number}
+   */
+  numChildren() {
+    if (!this._childIds)
+      return 0;
+    return this._childIds.length;
+  }
+
+  /**
+   * @return {boolean}
+   */
+  hasOnlyUnloadedChildren() {
+    if (!this._childIds || !this._childIds.length)
+      return false;
+
+    return !this._childIds.some((id) => this._accessibilityModel.axNodeForId(id) !== undefined);
+  }
+
+  /**
+   * TODO(aboxhall): Remove once protocol is stable.
+   * @param {!WebInspector.AccessibilityNode} inspectedNode
+   * @param {string=} leadingSpace
+   * @return {string}
+   */
+  printSelfAndChildren(inspectedNode, leadingSpace) {
+    var string = leadingSpace || '';
+    if (this._role)
+      string += this._role.value;
+    else
+      string += '<no role>';
+    string += (this._name ? ' ' + this._name.value : '');
+    string += ' ' + this._id;
+    if (this._domNode)
+      string += ' (' + this._domNode.nodeName() + ')';
+    if (this === inspectedNode)
+      string += ' *';
+    for (var child of this.children())
+      string += '\n' + child.printSelfAndChildren(inspectedNode, (leadingSpace || '') + '  ');
+    return string;
   }
 };
 
 /**
  * @unrestricted
  */
 WebInspector.AccessibilityModel = class extends WebInspector.SDKModel {
   /**
    * @param {!WebInspector.Target} target
    */
   constructor(target) {
     super(WebInspector.AccessibilityModel, target);
     this._agent = target.accessibilityAgent();
 
     /** @type {!Map<string, !WebInspector.AccessibilityNode>} */
     this._axIdToAXNode = new Map();
+    this._domNodeToAXNode = new Map();
   }
 
   /**
    * @param {!WebInspector.Target} target
    * @return {!WebInspector.AccessibilityModel}
    */
   static fromTarget(target) {
     if (!target[WebInspector.AccessibilityModel._symbol])
       target[WebInspector.AccessibilityModel._symbol] = new WebInspector.AccessibilityModel(target);
 
     return target[WebInspector.AccessibilityModel._symbol];
   }
 
   /**
-   * @param {string} axId
-   * @return {?WebInspector.AccessibilityNode}
-   */
-  axNodeForId(axId) {
-    return this._axIdToAXNode.get(axId);
-  }
-
-  /**
-   * @param {string} axId
-   * @param {!WebInspector.AccessibilityNode} axNode
-   */
-  _setAXNodeForAXId(axId, axNode) {
-    this._axIdToAXNode.set(axId, axNode);
-  }
-
-  /**
    * @param {!WebInspector.DOMNode} node
-   * @return {!Promise<?Array<!WebInspector.AccessibilityNode>>}
+   * @return {!Promise<?WebInspector.AccessibilityNode>}
    */
-  getAXNodeChain(node) {
+  setDOMNode(node) {
     this._axIdToAXNode.clear();
+    this._inspectedDOMNode = node;
 
+    return this._requestPartialAXTree(node);
+  }
+
+  /**
+   * @param {!WebInspector.DOMNode} node
+   * @return {!Promise}
+   */
+  _requestPartialAXTree(node) {
     /**
      * @this {WebInspector.AccessibilityModel}
      * @param {?string} error
      * @param {!Array<!AccessibilityAgent.AXNode>=} payloads
-     * @return {?Array<!WebInspector.AccessibilityNode>}
      */
     function parsePayload(error, payloads) {
       if (error) {
         console.error('AccessibilityAgent.getAXNodeChain(): ' + error);
         return null;
       }
 
       if (!payloads)
-        return null;
+        return;
 
-      var nodes = [];
       for (var payload of payloads)
-        nodes.push(new WebInspector.AccessibilityNode(this, payload));
+        new WebInspector.AccessibilityNode(this, payload);
 
-      return nodes;
+      for (var axNode of this._axIdToAXNode.values()) {
+        for (var axChild of axNode.children()) {
+          axChild._setParentNode(axNode);
+        }
+      }
     }
-    return this._agent.getAXNodeChain(node.id, true, parsePayload.bind(this));
+    return this._agent.getPartialAXTree(node.id, true, parsePayload.bind(this));
+  }
+
+  /**
+   * @return {?WebInspector.AccessibilityNode}
+   */
+  getInspectedAXNode() {
+    return this._domNodeToAXNode.get(this._inspectedDOMNode);
+  }
+
+  /**
+   * @param {string} axId
+   * @return {?WebInspector.AccessibilityNode}
+   */
+  axNodeForId(axId) {
+    return this._axIdToAXNode.get(axId);
+  }
+
+  /**
+   * @param {string} axId
+   * @param {!WebInspector.AccessibilityNode} axNode
+   */
+  _setAXNodeForAXId(axId, axNode) {
+    this._axIdToAXNode.set(axId, axNode);
+  }
+
+  /**
+   * @param {!WebInspector.DOMNode} domNode
+   * @return {?WebInspector.AccessibilityNode}
+   */
+  axNodeForDOMNode(domNode) {
+    return this._domNodeToAXNode.get(domNode);
+  }
+
+  /**
+   * @param {!WebInspector.DOMNode} domNode
+   * @param {!WebInspector.AccessibilityNode} axNode
+   */
+  setAXNodeForDOMNode(domNode, axNode) {
+    this._domNodeToAXNode.set(domNode, axNode);
+  }
+
+  // TODO(aboxhall): Remove once protocol is stable.
+  logTree() {
+    var inspectedNode = this._domNodeToAXNode.get(this._inspectedDOMNode);
+    if (!inspectedNode)
+      return;
+    var rootNode = inspectedNode;
+    while (rootNode.parentNode())
+      rootNode = rootNode.parentNode();
+    console.log(rootNode.printSelfAndChildren(inspectedNode));
+  }
+
+  /**
+   * @return {!Promise}
+   */
+  resolveAllDOMNodes() {
+    var promises = [];
+    for (var axNode of this._axIdToAXNode.values())
+      promises.push(axNode.resolveDOMNode());
+    return Promise.all(promises);
   }
 };
 
 WebInspector.AccessibilityModel._symbol = Symbol('AccessibilityModel');