Show reasons why nodes are ignored in accessibility sidebar

LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodesTest.js

Index: LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodesTest.js
diff --git a/LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodesTest.js b/LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodesTest.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe4a2196aa5fc5ce8fa9d93b73827af9857cc8af
--- /dev/null
+++ b/LayoutTests/inspector-protocol/accessibility/accessibility-ignoredNodesTest.js
@@ -0,0 +1,163 @@
+function initialize_IgnoredNodesTests() {

[pfeldman, 2015/04/29 13:59:22]

insert copyright, unindent contents.

[aboxhall, 2015/04/29 19:08:11]

Done.

+    InspectorTest.dumpAccessibilityNodesByIdref = function(ids, msg)

[pfeldman, 2015/04/29 13:59:22]

...AndCompleteTest

[aboxhall, 2015/04/29 19:08:11]

Done.

+    {
+        if (msg.error) {
+            InspectorTest.log(msg.error.message);
+            InspectorTest.completeTest();
+            return;
+        }
+
+
+        var rootNode = msg.result.root;
+        var promises = [];
+        for (var id of ids) {
+            var selector = "#" + id;
+            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(); });
+    }
+
+    function sendCommandPromise(command, params)

[pfeldman, 2015/04/29 13:59:22]

These should all be prefixed with InspectorTest.

private ones should start with _.

[aboxhall, 2015/04/29 19:08:11]

Done, but:
What benefit does this provide? Won't these functions already be scoped to the
closure? Surely this just makes the code less readable and risks clobbering
things already on InspectorTest.

+    {
+        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, "  "));
+    }
+}