Implement AutomationNode.querySelector().

chrome/renderer/resources/extensions/automation/automation_node.js

 // Copyright 2014 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.
 
 var AutomationEvent = require('automationEvent').AutomationEvent;
 var automationInternal =
     require('binding').Binding.create('automationInternal').generate();
 var IsInteractPermitted =
     requireNative('automationInternal').IsInteractPermitted;
 
@@ skipping 77 matching lines @@
   makeVisible: function() {
     this.performAction_('makeVisible');
   },
 
   setSelection: function(startIndex, endIndex) {
     this.performAction_('setSelection',
                         { startIndex: startIndex,
                           endIndex: endIndex });
   },
 
+  querySelector: function(selector, callback) {
+    automationInternal.querySelector(
+      { processID: this.rootImpl.processID,
+        routingID: this.rootImpl.routingID,
+        automationNodeID: this.id,
+        selector: selector },
+      this.querySelectorCallback_.bind(this, callback));
+  },
+
   addEventListener: function(eventType, callback, capture) {
     this.removeEventListener(eventType, callback);
     if (!this.listeners[eventType])
       this.listeners[eventType] = [];
     this.listeners[eventType].push({callback: callback, capture: !!capture});
   },
 
   // TODO(dtseng/aboxhall): Check this impl against spec.
   removeEventListener: function(eventType, callback) {
     if (this.listeners[eventType]) {
@@ skipping 21 matching lines @@
     // - bubbling: starting from the target's parent, going back up to the root.
     // At any stage, a listener may call stopPropagation() on the event, which
     // will immediately stop event propagation through this path.
     if (this.dispatchEventAtCapturing_(event, path)) {
       if (this.dispatchEventAtTargeting_(event, path))
         this.dispatchEventAtBubbling_(event, path);
     }
   },
 
   toString: function() {
-    return 'node id=' + this.id +
+    var impl = privates(this).impl;
+    if (!impl)
+      impl = this;
+    return 'node id=' + impl.id +
         ' role=' + this.role +
         ' state=' + $JSON.stringify(this.state) +
-        ' parentID=' + this.parentID +
-        ' childIds=' + $JSON.stringify(this.childIds) +
+        ' parentID=' + impl.parentID +
+        ' childIds=' + $JSON.stringify(impl.childIds) +
         ' attributes=' + $JSON.stringify(this.attributes);
   },
 
   dispatchEventAtCapturing_: function(event, path) {
     privates(event).impl.eventPhase = Event.CAPTURING_PHASE;
     for (var i = path.length - 1; i >= 0; i--) {
       this.fireEventListeners_(path[i], event);
       if (privates(event).impl.propagationStopped)
         return false;
     }
@@ skipping 50 matching lines @@
     if (!IsInteractPermitted()) {
       throw new Error(actionType + ' requires {"desktop": true} or' +
           ' {"interact": true} in the "automation" manifest key.');
     }
 
     automationInternal.performAction({ processID: this.rootImpl.processID,
                                        routingID: this.rootImpl.routingID,
                                        automationNodeID: this.id,
                                        actionType: actionType },
                                      opt_args || {});
+  },
+
+  querySelectorCallback_: function(userCallback, resultAutomationNodeID) {
+    if (resultAutomationNodeID == 0) {
+      userCallback(null);
+      return;
+    }
+    var resultNode = this.rootImpl.get(resultAutomationNodeID);
+    if (!resultNode) {

[dmazzoni, 2014/10/30 23:32:42]

Do you want to return here? It looks like you're calling userCallback(null) if
the result is not in the tree.

[aboxhall, 2014/10/31 20:32:22]

I think that's WAI - they need to know that they don't need to wait any longer.
I thought about setting an error in chrome.lastError, but I think this is really
an implementation detail - the user wouldn't be able to act on the error.

However, writing the test for removing the node demonstrated that this was
calling the callback with undefined rather than null, so I fixed that here.

+      logging.WARNING('Query selector result not in tree: ' +
+                      resultAutomationNodeID)
+    }
+    userCallback(resultNode);
   }
 };
 
 // Maps an attribute to its default value in an invalidated node.
 // These attributes are taken directly from the Automation idl.
 var AutomationAttributeDefaults = {
   'id': -1,
   'role': '',
   'state': {},
   'location': { left: 0, top: 0, width: 0, height: 0 }
@@ skipping 368 matching lines @@
                                                 'firstChild',
                                                 'lastChild',
                                                 'children',
                                                 'previousSibling',
                                                 'nextSibling',
                                                 'doDefault',
                                                 'focus',
                                                 'makeVisible',
                                                 'setSelection',
                                                 'addEventListener',
-                                                'removeEventListener'],
+                                                'removeEventListener',
+                                                'querySelector',
+                                                'toString'],
                                     readonly: ['isRootNode',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
                                                'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
                                       { superclass: AutomationNode,
-                                        functions: ['load'],
+                                        functions: ['load',
+                                                    'toString'],
                                         readonly: ['loaded'] });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;