[DevTools] New harness for inspector-protocol layout tests

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(session) {
+
+  InspectorTest.trackGetChildNodesEvents = function(nodeInfo, callback)
+  {
+    session.Protocol.DOM.onSetChildNodes(setChildNodes);
+
+    function setChildNodes(message)
+    {
+      var nodes = message.params.nodes;
+      for (var i = 0; i < nodes.length; ++i)
+        InspectorTest.addNode(nodeInfo, nodes[i]);
+      if (callback)
+        callback();
+    }
+  }
+
+  InspectorTest.addNode = function(nodeInfo, node)
+  {
+    nodeInfo[node.nodeId] = node;
+    delete node.nodeId;
+    var children = node.children || [];
+    for (var i = 0; i < children.length; ++i)
+      InspectorTest.addNode(nodeInfo, children[i]);
+    var shadowRoots = node.shadowRoots || [];
+    for (var i = 0; i < shadowRoots.length; ++i)
+      InspectorTest.addNode(nodeInfo, shadowRoots[i]);
+  }
+
+  InspectorTest.requestDocumentNodeId = async function(callback)
+  {
+    var result = (await session.Protocol.DOM.getDocument()).result;
+    if (callback)
+      callback(result.root.nodeId);
+    return result.root.nodeId;
+  };
+
+  InspectorTest.requestNodeId = async function(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);
 
 InspectorTest.dumpAccessibilityNodesBySelectorAndCompleteTest = function(selector, fetchRelatives, msg) {
     if (msg.error) {
         InspectorTest.log(msg.error.message);
         InspectorTest.completeTest();
         return;
     }
 
     var rootNode = msg.result.root;
     var rootNodeId = rootNode.nodeId;
     InspectorTest.addNode(nodeInfo, rootNode);
 
     sendQuerySelectorAll(rootNodeId, selector)
         .then((msg) => { return getAXNodes(msg, fetchRelatives || false) } )
         .then(() => { done(); })
         .then(() => {
             InspectorTest.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);
-        })
-    });
-}
-
 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();
     }
     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 34 matching lines @@
             }
             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));
@@ skipping 13 matching lines @@
                 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;
@@ skipping 145 matching lines @@
                 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));
 }
 
-}
+})