DevTools: Flesh out AccessibilityModel and use SDK objects instead of protocol objects

third_party/WebKit/Source/devtools/front_end/accessibility/AccessibilityNodeView.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.
 
 /**
  * @constructor
  * @extends {WebInspector.AccessibilitySubPane}
  */
 WebInspector.AXNodeSubPane = function()
 {
     WebInspector.AccessibilitySubPane.call(this, WebInspector.UIString("Computed Properties"));
 
     this._noNodeInfo = this.createInfo(WebInspector.UIString("No accessibility node"));
     this._ignoredInfo = this.createInfo(WebInspector.UIString("Accessibility node not exposed"), "ax-ignored-info hidden");
 
     this._treeOutline = this.createTreeOutline();
     this._ignoredReasonsTree = this.createTreeOutline();
 
     this.element.classList.add("accessibility-computed");
 };
 
 
 WebInspector.AXNodeSubPane.prototype = {
     /**
-     * @param {?AccessibilityAgent.AXNode} axNode
+     * @param {?WebInspector.AccessibilityNode} axNode
      * @override
      */
     setAXNode: function(axNode)
     {
         if (this._axNode === axNode)
             return;
         this._axNode = axNode;
 
         var treeOutline = this._treeOutline;
         treeOutline.removeChildren();
         var ignoredReasons = this._ignoredReasonsTree;
         ignoredReasons.removeChildren();
-        var target = this.node().target();
 
         if (!axNode) {
             treeOutline.element.classList.add("hidden");
             this._ignoredInfo.classList.add("hidden");
             ignoredReasons.element.classList.add("hidden");
 
             this._noNodeInfo.classList.remove("hidden");
             this.element.classList.add("ax-ignored-node-pane");
 
             return;
-        } else if (axNode.ignored) {
+        }
+
+        if (axNode.ignored()) {
             this._noNodeInfo.classList.add("hidden");
             treeOutline.element.classList.add("hidden");
             this.element.classList.add("ax-ignored-node-pane");
 
             this._ignoredInfo.classList.remove("hidden");
             ignoredReasons.element.classList.remove("hidden");
             /**
              * @param {!AccessibilityAgent.AXProperty} property
              */
             function addIgnoredReason(property)
             {
-                ignoredReasons.appendChild(new WebInspector.AXNodeIgnoredReasonTreeElement(property, axNode, target));
+                ignoredReasons.appendChild(new WebInspector.AXNodeIgnoredReasonTreeElement(property, /** @type {!WebInspector.AccessibilityNode} */ (axNode)));
             }
-            var ignoredReasonsArray = /** @type {!Array<!AccessibilityAgent.AXProperty>} */(axNode.ignoredReasons);
+            var ignoredReasonsArray = /** @type {!Array<!AccessibilityAgent.AXProperty>} */(axNode.ignoredReasons());
             for (var reason of ignoredReasonsArray)
                 addIgnoredReason(reason);
             if (!ignoredReasons.firstChild())
                 ignoredReasons.element.classList.add("hidden");
             return;
         }
         this.element.classList.remove("ax-ignored-node-pane");
 
         this._ignoredInfo.classList.add("hidden");
         ignoredReasons.element.classList.add("hidden");
         this._noNodeInfo.classList.add("hidden");
 
         treeOutline.element.classList.remove("hidden");
 
         /**
          * @param {!AccessibilityAgent.AXProperty} property
          */
         function addProperty(property)
         {
-            treeOutline.appendChild(new WebInspector.AXNodePropertyTreePropertyElement(property, target));
+            treeOutline.appendChild(new WebInspector.AXNodePropertyTreePropertyElement(property, /** @type {!WebInspector.AccessibilityNode} */ (axNode)));
         }
 
-        for (var propertyName of ["name", "description", "help", "value"]) {
-            if (propertyName in axNode) {
-                var defaultProperty = /** @type {!AccessibilityAgent.AXProperty} */ ({name: propertyName, value: axNode[propertyName]});
-                addProperty(defaultProperty);
-            }
-        }
+        for (var property of axNode.coreProperties())
+            addProperty(property);
 
-        var roleProperty = /** @type {!AccessibilityAgent.AXProperty} */ ({name: "role", value: axNode.role});
+        var roleProperty = /** @type {!AccessibilityAgent.AXProperty} */ ({name: "role", value: axNode.role()});
         addProperty(roleProperty);
 
         var propertyMap = {};
-        var propertiesArray = /** @type {!Array.<!AccessibilityAgent.AXProperty>} */ (axNode.properties);
+        var propertiesArray = /** @type {!Array.<!AccessibilityAgent.AXProperty>} */ (axNode.properties());
         for (var property of propertiesArray)
             propertyMap[property.name] = property;
 
         for (var propertySet of [AccessibilityAgent.AXWidgetAttributes, AccessibilityAgent.AXWidgetStates, AccessibilityAgent.AXGlobalStates, AccessibilityAgent.AXLiveRegionAttributes, AccessibilityAgent.AXRelationshipAttributes]) {
             for (var propertyKey in propertySet) {
                 var property = propertySet[propertyKey];
                 if (property in propertyMap)
                     addProperty(propertyMap[property]);
             }
         }
     },
 
     /**
      * @override
      * @param {?WebInspector.DOMNode} node
      */
     setNode: function(node)
     {
         WebInspector.AccessibilitySubPane.prototype.setNode.call(this, node);
         this._axNode = null;
     },
 
     __proto__: WebInspector.AccessibilitySubPane.prototype
 };
 
 /**
  * @constructor
+ * @param {!WebInspector.AccessibilityNode} axNode
  * @extends {TreeElement}
- * @param {!WebInspector.Target} target
  */
-WebInspector.AXNodePropertyTreeElement = function(target)
+WebInspector.AXNodePropertyTreeElement = function(axNode)
 {
-    this._target = target;
+    this._axNode = axNode;
 
     // Pass an empty title, the title gets made later in onattach.
     TreeElement.call(this, "");
 };
 
 /**
  * @param {?AccessibilityAgent.AXValueType} type
  * @param {string} value
  * @return {!Element}
  */
@@ skipping 91 matching lines @@
         var AXValueType = AccessibilityAgent.AXValueType;
         if (value.type === AXValueType.Idref || value.type === AXValueType.Node ||
             value.type === AXValueType.IdrefList || value.type === AXValueType.NodeList) {
             this.appendRelatedNodeListValueElement(value);
             if (!value.value)
                 return null;
         } else if (value.sources) {
             var sources = value.sources;
             for (var i = 0; i < sources.length; i++) {
                 var source = sources[i];
-                var child = new WebInspector.AXValueSourceTreeElement(source, this._target);
+                var child = new WebInspector.AXValueSourceTreeElement(source, this._axNode);
                 this.appendChild(child);
             }
             this.expand();
         }
         var element = WebInspector.AXNodePropertyTreeElement.createSimpleValueElement(value.type, String(value.value));
         this.listItemElement.appendChild(element);
         return element;
     },
 
     /**
      * @param {!AccessibilityAgent.AXRelatedNode} relatedNode
      * @param {number} index
      */
     appendRelatedNode: function(relatedNode, index)
     {
-        var deferredNode = new WebInspector.DeferredDOMNode(this._target, relatedNode.backendNodeId);
+        var deferredNode = new WebInspector.DeferredDOMNode(this._axNode.target(), relatedNode.backendNodeId);
         var nodeTreeElement = new WebInspector.AXRelatedNodeSourceTreeElement({ deferredNode: deferredNode }, relatedNode);
         this.appendChild(nodeTreeElement);
     },
 
     /**
      * @param {!AccessibilityAgent.AXRelatedNode} relatedNode
      */
     appendRelatedNodeInline: function(relatedNode)
     {
-        var deferredNode = new WebInspector.DeferredDOMNode(this._target, relatedNode.backendNodeId);
+        var deferredNode = new WebInspector.DeferredDOMNode(this._axNode.target(), relatedNode.backendNodeId);
         var linkedNode = new WebInspector.AXRelatedNodeElement({ deferredNode: deferredNode }, relatedNode);
         this.listItemElement.appendChild(linkedNode.render());
     },
 
     /**
      * @param {!AccessibilityAgent.AXValue} value
      */
     appendRelatedNodeListValueElement: function(value)
     {
         if (value.relatedNodes.length === 1 && !value.value) {
             this.appendRelatedNodeInline(value.relatedNodes[0]);
             return;
         }
 
         value.relatedNodes.forEach(this.appendRelatedNode, this);
         if (value.relatedNodes.length <= 3)
             this.expand();
         else
             this.collapse();
     },
 
     __proto__: TreeElement.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.AXNodePropertyTreeElement}
  * @param {!AccessibilityAgent.AXProperty} property
- * @param {!WebInspector.Target} target
+ * @param {!WebInspector.AccessibilityNode} axNode
  */
-WebInspector.AXNodePropertyTreePropertyElement = function(property, target)
+WebInspector.AXNodePropertyTreePropertyElement = function(property, axNode)
 {
     this._property = property;
     this.toggleOnClick = true;
     this.selectable = false;
 
-    WebInspector.AXNodePropertyTreeElement.call(this, target);
+    WebInspector.AXNodePropertyTreeElement.call(this, axNode);
     this.listItemElement.classList.add("property");
 }
 
 WebInspector.AXNodePropertyTreePropertyElement.prototype = {
     /**
      * @override
      */
     onattach: function()
     {
         this._update();
@@ skipping 12 matching lines @@
             valueElement.classList.add("ax-computed-text");
     },
 
     __proto__: WebInspector.AXNodePropertyTreeElement.prototype
 };
 
 /**
  * @constructor
  * @extends {WebInspector.AXNodePropertyTreeElement}
  * @param {!AccessibilityAgent.AXValueSource} source
- * @param {!WebInspector.Target} target
+ * @param {!WebInspector.AccessibilityNode} axNode
  */
-WebInspector.AXValueSourceTreeElement = function(source, target)
+WebInspector.AXValueSourceTreeElement = function(source, axNode)
 {
     this._source = source;
-    WebInspector.AXNodePropertyTreeElement.call(this, target);
+    WebInspector.AXNodePropertyTreeElement.call(this, axNode);
     this.selectable = false;
 }
 
 WebInspector.AXValueSourceTreeElement.prototype = {
     /**
      * @override
      */
     onattach: function()
     {
         this._update();
     },
 
     /**
      * @param {!AccessibilityAgent.AXRelatedNode} relatedNode
      * @param {number} index
      * @param {string} idref
      */
     appendRelatedNodeWithIdref: function(relatedNode, index, idref)
     {
-        var deferredNode = new WebInspector.DeferredDOMNode(this._target, relatedNode.backendNodeId);
+        var deferredNode = new WebInspector.DeferredDOMNode(this._axNode.target(), relatedNode.backendNodeId);
         var nodeTreeElement = new WebInspector.AXRelatedNodeSourceTreeElement({ deferredNode: deferredNode, idref: idref }, relatedNode);
         this.appendChild(nodeTreeElement);
     },
 
     /**
      * @param {!AccessibilityAgent.AXValue} value
      */
     appendIDRefValueElement: function(value)
     {
         var relatedNodes = value.relatedNodes;
@@ skipping 212 matching lines @@
         }
 
         return element;
     }
 };
 
 /**
  * @constructor
  * @extends {WebInspector.AXNodePropertyTreeElement}
  * @param {!AccessibilityAgent.AXProperty} property
- * @param {?AccessibilityAgent.AXNode} axNode
- * @param {!WebInspector.Target} target
+ * @param {!WebInspector.AccessibilityNode} axNode
  */
-WebInspector.AXNodeIgnoredReasonTreeElement = function(property, axNode, target)
+WebInspector.AXNodeIgnoredReasonTreeElement = function(property, axNode)
 {
     this._property = property;
     this._axNode = axNode;
 
-    WebInspector.AXNodePropertyTreeElement.call(this, target);
+    WebInspector.AXNodePropertyTreeElement.call(this, axNode);
     this.toggleOnClick = true;
     this.selectable = false;
 }
 
 WebInspector.AXNodeIgnoredReasonTreeElement.prototype = {
     /**
      * @override
      */
     onattach: function()
     {
         this.listItemElement.removeChildren();
 
         this._reasonElement = WebInspector.AXNodeIgnoredReasonTreeElement.createReasonElement(this._property.name, this._axNode);
         this.listItemElement.appendChild(this._reasonElement);
 
         var value = this._property.value;
         if (value.type === AccessibilityAgent.AXValueType.Idref)
             this.appendRelatedNodeListValueElement(value);
     },
 
     __proto__: WebInspector.AXNodePropertyTreeElement.prototype
 };
 
 /**
  * @param {?string} reason
- * @param {?AccessibilityAgent.AXNode} axNode
+ * @param {?WebInspector.AccessibilityNode} axNode
  * @return {?Element}
  */
 WebInspector.AXNodeIgnoredReasonTreeElement.createReasonElement = function(reason, axNode)
 {
     var reasonElement = null;
     switch (reason) {
     case "activeModalDialog":
         reasonElement = WebInspector.formatLocalized("Element is hidden by active modal dialog:\u00a0", []);
         break;
     case "ancestorDisallowsChild":
@@ skipping 30 matching lines @@
     case "labelFor":
         reasonElement = WebInspector.formatLocalized("Label for\u00a0", []);
         break;
     case "notRendered":
         reasonElement = WebInspector.formatLocalized("Element is not rendered.", []);
         break;
     case "notVisible":
         reasonElement = WebInspector.formatLocalized("Element is not visible.", []);
         break;
     case "presentationalRole":
-        var rolePresentationSpan = createElement("span", "source-code").textContent = "role=" + axNode.role.value;
+        var rolePresentationSpan = createElement("span", "source-code").textContent = "role=" + axNode.role().value;
         reasonElement = WebInspector.formatLocalized("Element has %s.", [ rolePresentationSpan ]);
         break;
     case "probablyPresentational":
         reasonElement = WebInspector.formatLocalized("Element is presentational.", []);
         break;
     case "staticTextUsedAsNameFor":
         reasonElement = WebInspector.formatLocalized("Static text node is used as name for\u00a0", []);
         break;
     case "uninteresting":
         reasonElement = WebInspector.formatLocalized("Element not interesting for accessibility.", []);
         break;
     }
     if (reasonElement)
         reasonElement.classList.add("ax-reason");
     return reasonElement;
 };