Show reasons why nodes are ignored in accessibility sidebar

LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodes-common.js

+function common_onGotDocument(maxId, msg)

[pfeldman, 2015/04/28 15:49:36]

Can this be named in a way that it was clear what it does?

[aboxhall, 2015/04/28 18:14:20]

Done.

+{
+    if (msg.error) {
+        InspectorTest.log(msg.error.message);
+        InspectorTest.completeTest();
+        return;
+    }
+
+    function sendCommandPromise(command, params) {

[pfeldman, 2015/04/28 15:49:36]

Here and below, poor coding style.

[aboxhall, 2015/04/28 16:01:16]

Could you give some more detail on this? What problem are you referring to?

[aboxhall, 2015/04/28 18:14:20]

Done, I think.

+        return new Promise(function(resolve, reject) {
+            InspectorTest.sendCommand(command, params, function(msg) {
+                if (msg.error) { reject(msg.error); return; }
+                resolve(msg);
+            })
+        });
+    }
+
+
+    function sendQuerySelector(nodeId, selector)
+    {
+        return sendCommandPromise("DOM.querySelector", { "nodeId": nodeId, "selector": selector });
+    }
+
+    function getAXNode(msg) {
+        var node = msg.result;
+        return sendCommandPromise("Accessibility.getAXNode", { "nodeId": node.nodeId });
+    }
+
+    function describeNode(nodeData)
+    {
+        var description = nodeData.nodeName.toLowerCase();
+        switch (nodeData.nodeType) {
+        case Node.ELEMENT_NODE:
+            var p = nodeData.attributes.indexOf("id");
+            if (p >= 0)
+                description += "#" + nodeData.attributes[p + 1];
+        }
+        return description;
+    }
+
+    function rewriteNode(relatedNode)
+    {
+        function rewriteNodePromise(resolve, reject) {
+            if (!("backendNodeId" in relatedNode)) {
+                reject("Could not find backendNodeId in " + JSON.stringify(relatedNode));
+                return;
+            }
+            var backendNodeId = relatedNode.backendNodeId;
+
+            function onNodeResolved(backendNodeId, message) {
+                var nodeId = message.result.nodeIds[0];
+                if (!(nodeId in nodeInfo)) {
+                    relatedNode.nodeResult = "[NODE NOT FOUND]";
+                    resolve();
+                    return;
+                }
+                var node = nodeInfo[nodeId];
+                delete relatedNode.backendNodeId;
+                relatedNode.nodeResult = describeNode(node);
+                resolve();
+            }
+            InspectorTest.sendCommand("DOM.pushNodesByBackendIdsToFrontend", { "backendNodeIds": [ backendNodeId ] }, onNodeResolved.bind(null, backendNodeId));
+        }
+        return new Promise(rewriteNodePromise);
+    }
+
+    function checkExists(path, obj, reject)
+    {
+        var pathComponents = path.split(".");
+        var currentPath = [];
+        var currentObject = obj;
+        for (var component of pathComponents) {
+            currentPath.push(component);
+            if (!(component in currentObject)) {
+                reject("Could not find " + currentPath.join(".") + " in " + JSON.stringify(obj, null, "  "));
+                return false;
+            }
+            currentObject = currentObject[component];
+        }
+        return true;
+    }
+
+    function check(condition, errorMsg, obj, reject)
+    {
+        if (condition)
+            return true;
+        reject(errorMsg + " in " + JSON.stringify(obj, null, "  "));
+    }
+
+    function rewriteNodes(msg)
+    {
+        function rewriteNodesPromise(resolve, reject) {
+            if (msg.error) {
+                reject(msg.error.message);
+                return;
+            }
+
+            if (msg.result.accessibilityNode.ignored) {
+                checkExists("result.accessibilityNode.ignoredReasons", msg);
+                var properties = msg.result.accessibilityNode.ignoredReasons;
+            } else {
+                checkExists("result.accessibilityNode.properties", msg);
+                var properties = msg.result.accessibilityNode.properties;
+            }
+            var promises = [];
+            for (var property of properties) {
+                if (property.value.type === "idrefList") {
+                    if (!checkExists("value.relatedNodeArrayValue", property, reject))
+                        return;
+                    var relatedNodeArray = property.value.relatedNodeArrayValue;
+                    check(Array.isArray(relatedNodeArray), "value.relatedNodeArrayValue should be an array", JSON.stringify(property), reject);
+                     for (var relatedNode of relatedNodeArray) {
+                         promises.push(rewriteNode(relatedNode));
+                     }
+                } else if (property.value.type === "idref") {
+                    if (!checkExists("value.relatedNodeValue", property, reject))
+                        return;
+                    var relatedNode = property.value.relatedNodeValue;
+                    promises.push(rewriteNode(relatedNode));
+                }
+            }
+
+            Promise.all(promises).then(resolve(msg));
+        }
+        return new Promise(rewriteNodesPromise);
+    }
+
+    function dumpNode(selector, msg)
+    {
+        function stripIds(key, value) {
+            if (key == "id")
+                return "<int>"
+            if (key == "backendNodeId")
+                return "<string>"
+            if (key == "nodeId")
+                return "<string>"
+            return value;
+        }
+        InspectorTest.log(selector + ": " + JSON.stringify(msg, stripIds, "  "));
+    }
+
+    var rootNode = msg.result.root;
+    var promises = [];
+    for (var i = 1; i <= maxId; i++) {
+        var selector = "#_" + i;
+        var promise = sendQuerySelector(rootNode.nodeId, selector)
+            .then(getAXNode)
+            .then(rewriteNodes)
+            .then(dumpNode.bind(null, selector))
+            .catch(function(msg) { InspectorTest.log("Error: " + JSON.stringify(msg)); })
+        promises.push(promise);
+    }
+
+    Promise.all(promises).then(function() { InspectorTest.completeTest(); });
+}