[DevTools] Move inspector-protocol/accessibility tests to new harness

third_party/WebKit/LayoutTests/inspector-protocol/resources/accessibility-dumpAccessibilityNodes.js

 // Copyright 2015 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.
 
-function initialize_DumpAccessibilityNodesTest() {
+(function initialize_DumpAccessibilityNodesTest(testRunner, session) {
+
+  function trackGetChildNodesEvents(nodeInfo, callback)
+  {
+    session.protocol.DOM.onSetChildNodes(setChildNodes);
+
+    function setChildNodes(message)
+    {
+      var nodes = message.params.nodes;
+      for (var i = 0; i < nodes.length; ++i)
+        addNode(nodeInfo, nodes[i]);
+      if (callback)
+        callback();
+    }
+  }
+
+  function addNode(nodeInfo, node)
+  {
+    nodeInfo[node.nodeId] = node;
+    delete node.nodeId;
+    var children = node.children || [];
+    for (var i = 0; i < children.length; ++i)
+      addNode(nodeInfo, children[i]);
+    var shadowRoots = node.shadowRoots || [];
+    for (var i = 0; i < shadowRoots.length; ++i)
+      addNode(nodeInfo, shadowRoots[i]);
+  }
+
+  async function requestDocumentNodeId(callback)
+  {
+    var result = (await session.protocol.DOM.getDocument()).result;
+    if (callback)
+      callback(result.root.nodeId);
+    return result.root.nodeId;
+  };
+
+  async function requestNodeId(documentNodeId, selector, callback)
+  {
+    var result = (await session.protocol.DOM.querySelector({"nodeId": documentNodeId , "selector": selector})).result;
+    if (callback)
+      callback(result.nodeId);
+    return result.nodeId;
+  };
 
 var nodeInfo = {};
-InspectorTest.trackGetChildNodesEvents(nodeInfo);
+trackGetChildNodesEvents(nodeInfo);
 
-InspectorTest.dumpAccessibilityNodesBySelectorAndCompleteTest = function(selector, fetchRelatives, msg) {
+function dumpAccessibilityNodesBySelectorAndCompleteTest(selector, fetchRelatives, msg) {
     if (msg.error) {
-        InspectorTest.log(msg.error.message);
-        InspectorTest.completeTest();
+        testRunner.log(msg.error.message);
+        testRunner.completeTest();
         return;
     }
 
     var rootNode = msg.result.root;
     var rootNodeId = rootNode.nodeId;
-    InspectorTest.addNode(nodeInfo, rootNode);
+    addNode(nodeInfo, rootNode);
 
     sendQuerySelectorAll(rootNodeId, selector)
         .then((msg) => { return getAXNodes(msg, fetchRelatives || false) } )
         .then(() => { done(); })
         .then(() => {
-            InspectorTest.completeTest();
+            testRunner.completeTest();
         })
-        .catch((msg) => { InspectorTest.log("Error: " + JSON.stringify(msg)); })
-}
-
-function sendCommandPromise(command, params)
-{
-    return new Promise(function(resolve, reject) {
-        InspectorTest.sendCommand(command, params, function(msg) {
-            if (msg.error) {
-                reject(msg.error);
-                return;
-            }
-
-            resolve(msg);
-        })
-    });
+        .catch((msg) => { testRunner.log("Error: " + JSON.stringify(msg)); })
 }
 
 function done()
 {
-    sendCommandPromise("Runtime.evaluate", { expression: "done();" });
+    session.protocol.Runtime.evaluate({expression: "done();"});
 }
 
 function sendQuerySelectorAll(nodeId, selector)
 {
-    return sendCommandPromise("DOM.querySelectorAll", { "nodeId": nodeId, "selector":
- selector });
+    return session.protocol.DOM.querySelectorAll({"nodeId": nodeId, "selector": selector });
 }
 
 function getAXNodes(msg, fetchRelatives)
 {
     var promise = Promise.resolve();
     if (!msg.result || !msg.result.nodeIds) {
-        InspectorTest.log("Unexpected result: " + JSON.stringify(msg));
-        InspectorTest.completeTest();
+        testRunner.log("Unexpected result: " + JSON.stringify(msg));
+        testRunner.completeTest();
     }
     msg.result.nodeIds.forEach((id) => {
         if (fetchRelatives) {
             promise = promise.then(() => {
-                return sendCommandPromise("Accessibility.getPartialAXTree", { "nodeId": id, "fetchRelatives": true });
+                return session.protocol.Accessibility.getPartialAXTree({ "nodeId": id, "fetchRelatives": true });
             });
             promise = promise.then((msg) => { return rewriteRelatedNodes(msg, id); })
                              .then((msg) => { return dumpTreeStructure(msg); });
 
         }
-        promise = promise.then(() => { return sendCommandPromise("Accessibility.getPartialAXTree", { "nodeId": id, "fetchRelatives": false }); })
+        promise = promise.then(() => { return session.protocol.Accessibility.getPartialAXTree({ "nodeId": id, "fetchRelatives": false }); })
                          .then((msg) => { return rewriteRelatedNodes(msg, id); })
                          .then((msg) => { return dumpNode(msg); });
 
     });
     return promise;
 }
 
 function describeDomNode(nodeData)
 {
     var description = nodeData.nodeName.toLowerCase();
@@ skipping 15 matching lines @@
     {
         if (!("backendDOMNodeId" in axNode)) {
             resolve();
             return;
         }
         var backendDOMNodeId = axNode.backendDOMNodeId;
 
         function onDomNodeResolved(backendDOMNodeId, message)
         {
             if (!message.result || !message.result.nodeIds) {
-                InspectorTest.log("Unexpected result for pushNodesByBackendIdsToFrontend: " + JSON.stringify(message));
-                InspectorTest.completeTest();
+                testRunner.log("Unexpected result for pushNodesByBackendIdsToFrontend: " + JSON.stringify(message));
+                testRunner.completeTest();
                 return;
             }
             var nodeId = message.result.nodeIds[0];
             if (!(nodeId in nodeInfo)) {
                 axNode.domNode = "[NODE NOT FOUND]";
                 resolve();
                 return;
             }
             var domNode = nodeInfo[nodeId];
             delete axNode.backendDOMNodeId;
             axNode.domNode = describeDomNode(domNode);
             if (nodeId === selectedNodeId)
               axNode.selected = true;
             resolve();
         }
 
         var params = { "backendNodeIds": [ backendDOMNodeId ] };
-        InspectorTest.sendCommand("DOM.pushNodesByBackendIdsToFrontend", params , onDomNodeResolved.bind(null, backendDOMNodeId));
+        session.protocol.DOM.pushNodesByBackendIdsToFrontend(params).then(onDomNodeResolved.bind(null, backendDOMNodeId));
     }
     promises.push(new Promise(rewriteBackendDomNodeIdPromise));
 }
 
 function rewriteRelatedNode(relatedNode)
 {
     function rewriteRelatedNodePromise(resolve, reject)
     {
         if (!("backendDOMNodeId" in relatedNode)) {
             reject("Could not find backendDOMNodeId in " + JSON.stringify(relatedNode));
             return;
         }
         var backendDOMNodeId = relatedNode.backendDOMNodeId;
 
         function onNodeResolved(backendDOMNodeId, message)
         {
             if (!message.result || !message.result.nodeIds) {
-                InspectorTest.log("Unexpected result for pushNodesByBackendIdsToFrontend: " + JSON.stringify(message));
-                InspectorTest.completeTest();
+                testRunner.log("Unexpected result for pushNodesByBackendIdsToFrontend: " + JSON.stringify(message));
+                testRunner.completeTest();
                 return;
             }
             var nodeId = message.result.nodeIds[0];
             if (!(nodeId in nodeInfo)) {
                 relatedNode.nodeResult = "[NODE NOT FOUND]";
                 resolve();
                 return;
             }
             var domNode = nodeInfo[nodeId];
             delete relatedNode.backendDOMNodeId;
             relatedNode.nodeResult = describeDomNode(domNode);
             resolve();
         }
         var params = { "backendNodeIds": [ backendDOMNodeId ] };
-        InspectorTest.sendCommand("DOM.pushNodesByBackendIdsToFrontend", params, onNodeResolved.bind(null, backendDOMNodeId));
+        session.protocol.DOM.pushNodesByBackendIdsToFrontend(params).then(onNodeResolved.bind(null, backendDOMNodeId));
 
     }
     return new Promise(rewriteRelatedNodePromise);
 }
 
 function checkExists(path, obj)
 {
     var pathComponents = path.split(".");
     var currentPath = [];
     var currentObject = obj;
     for (var component of pathComponents) {
         var isArray = false;
         var index = -1;
         var matches = component.match(/(\w+)\[(\d+)\]/);
         if (matches) {
             isArray = true;
             component = matches[1];
             index = Number.parseInt(matches[2], 10);
         }
         currentPath.push(component);
         if (!(component in currentObject)) {
-            InspectorTest.log("Could not find " + currentPath.join(".") + " in " + JSON.stringify(obj, null, "  "));
-            InspectorTest.completeTest();
+            testRunner.log("Could not find " + currentPath.join(".") + " in " + JSON.stringify(obj, null, "  "));
+            testRunner.completeTest();
         }
         if (isArray)
             currentObject = currentObject[component][index];
         else
             currentObject = currentObject[component];
     }
     return true;
 }
 
 function check(condition, errorMsg, obj)
@@ skipping 60 matching lines @@
     {
         var stripKeys = ["id", "backendDOMNodeId", "nodeId", "parentId"];
         if (stripKeys.indexOf(key) !== -1)
             return "<" + typeof(value) + ">";
         var deleteKeys = ["selected"];
         if (deleteKeys.indexOf(key) !== -1)
             return undefined;
         return value;
     }
     if (!msg.result || !msg.result.nodes || msg.result.nodes.length !== 1) {
-        InspectorTest.log("Expected exactly one node in " + JSON.stringify(msg, null, "  "));
+        testRunner.log("Expected exactly one node in " + JSON.stringify(msg, null, "  "));
         return;
     }
-    InspectorTest.log(JSON.stringify(msg.result.nodes[0], stripIds, "  "));
+    testRunner.log(JSON.stringify(msg.result.nodes[0], stripIds, "  "));
 }
 
 function dumpTreeStructure(msg)
 {
     function printNodeAndChildren(node, leadingSpace)
     {
         leadingSpace = leadingSpace || "";
         var string = leadingSpace;
         if (node.selected)
             string += "*";
@@ skipping 35 matching lines @@
             if (!node.childIds.length)
                 delete node.childIds;
             if (!node.children.length)
                 delete node.children;
         }
     }
     var rootNode = Object.values(nodeMap).find((node) => !("parentId" in node));
     for (var node of Object.values(nodeMap))
         delete node.parentId;
 
-    InspectorTest.log("\n" + printNodeAndChildren(rootNode));
+    testRunner.log("\n" + printNodeAndChildren(rootNode));
 }
 
-}
+return dumpAccessibilityNodesBySelectorAndCompleteTest;
+
+})