Implement automatic load of composed/embedded automation trees

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;
 
 var lastError = require('lastError');
 var logging = requireNative('logging');
 var schema = requireNative('automationInternal').GetSchemaAdditions();
 var utils = require('utils');
 
 /**
+ * Maps an accessibility tree id to an AutomationNode with role type webView.
+ * @type {!Object.<string, string>}
+ */
+var idToWebView_ = {};
+
+/**
  * A single node in the Automation tree.
  * @param {AutomationRootNodeImpl} root The root of the tree.
  * @constructor
  */
 function AutomationNodeImpl(root) {
   this.rootImpl = root;
   this.childIds = [];
   // Public attributes. No actual data gets set on this object.
   this.attributes = {};
   // Internal object holding all attributes.
   this.attributesInternal = {};
   this.listeners = {};
   this.location = { left: 0, top: 0, width: 0, height: 0 };
 }
 
 AutomationNodeImpl.prototype = {
   id: -1,
   role: '',
   state: { busy: true },
   isRootNode: false,
 
   get root() {
     return this.rootImpl.wrapper;
   },
 
   parent: function() {
+    if (this.role == schema.RoleType.rootWebArea) {
+      if (idToWebView_[this.treeID])
+        return idToWebView_[this.treeID];
+    }
     return this.rootImpl.get(this.parentID);
   },
 
   firstChild: function() {
-    var node = this.rootImpl.get(this.childIds[0]);
-    return node;
+    return this.lookupWebViewChild_() || this.rootImpl.get(this.childIds[0]);
   },
 
   lastChild: function() {
     var childIds = this.childIds;
-    var node = this.rootImpl.get(childIds[childIds.length - 1]);
-    return node;
+    return this.lookupWebViewChild_() ||
+        this.rootImpl.get(childIds[childIds.length - 1]);
   },
 
   children: function() {
     var children = [];
     for (var i = 0, childID; childID = this.childIds[i]; i++) {
       logging.CHECK(this.rootImpl.get(childID));
       children.push(this.rootImpl.get(childID));
     }
     return children;
   },
@@ skipping 46 matching lines @@
           listeners.splice(i, 1);
       }
     }
   },
 
   dispatchEvent: function(eventType) {
     var path = [];
     var parent = this.parent();
     while (parent) {
       path.push(parent);
-      // TODO(aboxhall/dtseng): handle unloaded parent node
       parent = parent.parent();
     }
     var event = new AutomationEvent(eventType, this.wrapper);
 
     // Dispatch the event through the propagation path in three phases:
     // - capturing: starting from the root and going down to the target's parent
     // - targeting: dispatching the event on the target itself
     // - 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 +
         ' role=' + this.role +
         ' state=' + $JSON.stringify(this.state) +
         ' parentID=' + this.parentID +
         ' childIds=' + $JSON.stringify(this.childIds) +
         ' attributes=' + $JSON.stringify(this.attributes);
   },
 
+  lookupWebViewChild_: function() {
+    if (this.role != schema.RoleType.webView)
+      return null;
+
+    return automationUtil.idToAutomationRootNode[this.childTreeID];
+  },
+
   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;
     }
     return true;
   },
 
@@ skipping 30 matching lines @@
       } catch (e) {
         console.error('Error in event handler for ' + event.type +
                       'during phase ' + eventPhase + ': ' +
                       e.message + '\nStack trace: ' + e.stack);
       }
     }
   },
 
   performAction_: function(actionType, opt_args) {
     // Not yet initialized.
-    if (this.rootImpl.processID === undefined ||
-        this.rootImpl.routingID === undefined ||
+    if (this.rootImpl.treeID === undefined ||
         this.id === undefined) {
       return;
     }
 
     // Check permissions.
     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,
+    automationInternal.performAction({ treeID: this.rootImpl.treeID,
                                        automationNodeID: this.id,
                                        actionType: actionType },
                                      opt_args || {});
   }
 };
 
 // Maps an attribute to its default value in an invalidated node.
 // These attributes are taken directly from the Automation idl.
 var AutomationAttributeDefaults = {
   'id': -1,
@@ skipping 27 matching lines @@
   'aria-labelledby': 'labelledbyIds',
   'aria-owns': 'ownsIds'
 };
 
 /**
  * A set of attributes ignored in the automation API.
  * @param {!Object.<string, boolean>}
  * @const
  */
 var ATTRIBUTE_BLACKLIST = {'activedescendantId': true,
+                           'childTreeId': true,
                            'controlsIds': true,
                            'describedbyIds': true,
                            'flowtoIds': true,
                            'labelledbyIds': true,
                            'ownsIds': true
 };
 
 
 /**
  * AutomationRootNode.
  *
  * An AutomationRootNode is the javascript end of an AXTree living in the
  * browser. AutomationRootNode handles unserializing incremental updates from
  * the source AXTree. Each update contains node data that form a complete tree
  * after applying the update.
  *
  * A brief note about ids used through this class. The source AXTree assigns
  * unique ids per node and we use these ids to build a hash to the actual
  * AutomationNode object.
  * Thus, tree traversals amount to a lookup in our hash.
  *
- * The tree itself is identified by the process id and routing id of the
+ * The tree itself is identified by the accessibility tree id of the
  * renderer widget host.
  * @constructor
  */
-function AutomationRootNodeImpl(processID, routingID) {
+function AutomationRootNodeImpl(treeID) {
   AutomationNodeImpl.call(this, this);
-  this.processID = processID;
-  this.routingID = routingID;
+  this.treeID = treeID;
   this.axNodeDataCache_ = {};
 }
 
 AutomationRootNodeImpl.prototype = {
   __proto__: AutomationNodeImpl.prototype,
 
   isRootNode: true,
 
+  role: 'rootWebArea',

[aboxhall, 2014/11/03 17:15:49]

Why is this necessary? Won't this come down in the initial data?

[David Tseng, 2014/11/03 19:31:53]

It was (if we give callers the placeholder node) which comes before any data; no
longer true so removed.

+
   get: function(id) {
     if (id == undefined)
       return undefined;
 
     return this.axNodeDataCache_[id];
   },
 
   unserialize: function(update) {
     var updateState = { pendingNodes: {}, newNodes: {} };
     var oldRootId = this.id;
@@ skipping 41 matching lines @@
                     null,
                     chrome);
       return false;
     }
     return true;
   },
 
   destroy: function() {
     this.dispatchEvent(schema.EventType.destroyed);
     this.invalidate_(this.wrapper);
+    idToWebView_[this.treeID] = undefined;

[aboxhall, 2014/11/03 17:15:49]

delete idToWebView_[this.treeID] does the same thing and (to me) looks clearer.

[David Tseng, 2014/11/03 19:31:52]

Obsolete.

   },
 
   onAccessibilityEvent: function(eventParams) {
     if (!this.unserialize(eventParams.update)) {
       logging.WARNING('unserialization failed');
       return false;
     }
 
     var targetNode = this.get(eventParams.targetID);
     if (targetNode) {
@@ skipping 33 matching lines @@
 
     // Retrieve the internal AutomationNodeImpl instance for this node.
     // This object is not accessible outside of bindings code, but we can access
     // it here.
     var nodeImpl = privates(node).impl;
     var id = nodeImpl.id;
     for (var key in AutomationAttributeDefaults) {
       nodeImpl[key] = AutomationAttributeDefaults[key];
     }
     nodeImpl.childIds = [];
-    nodeImpl.loaded = false;
     nodeImpl.id = id;
     delete this.axNodeDataCache_[id];
   },
 
-  load: function(callback) {
-    // TODO(dtseng/aboxhall): Implement.
-    if (!this.loaded)
-      throw 'Unsupported state: root node is not loaded.';
-
-    setTimeout(callback, 0);
-  },
-
   deleteOldChildren_: function(node, newChildIds) {
     // Create a set of child ids in |src| for fast lookup, and return false
     // if a duplicate is found;
     var newChildIdSet = {};
     for (var i = 0; i < newChildIds.length; i++) {
       var childId = newChildIds[i];
       if (newChildIdSet[childId]) {
         logging.WARNING('Node ' + privates(node).impl.id +
                         ' has duplicate child id ' + childId);
         lastError.set('automation',
@@ skipping 18 matching lines @@
       }
     }
     nodeImpl.childIds = oldChildIds;
 
     return true;
   },
 
   createNewChildren_: function(node, newChildIds, updateState) {
     logging.CHECK(node);
     var success = true;
+
     for (var i = 0; i < newChildIds.length; i++) {
       var childId = newChildIds[i];
       var childNode = this.axNodeDataCache_[childId];
       if (childNode) {
         if (childNode.parent() != node) {
           var parentId = -1;
           if (childNode.parent()) {
             var parentImpl = privates(childNode.parent()).impl;
             parentId = parentImpl.id;
           }
@@ skipping 18 matching lines @@
       }
       privates(childNode).impl.indexInParent = i;
       privates(childNode).impl.parentID = privates(node).impl.id;
     }
 
     return success;
   },
 
   setData_: function(node, nodeData) {
     var nodeImpl = privates(node).impl;
+
+    if (nodeData.role == schema.RoleType.webView) {

[aboxhall, 2014/11/03 17:15:49]

I think we should have a set of roles which can be host nodes, and check against
that here, or at least a TODO to add it. This logic will be the same for
iframes, right? Anything else?

[David Tseng, 2014/11/03 19:31:53]

Added TODO since that seems a bit early at this point.

+      if (nodeImpl.pendingChildFrame === undefined)
+        nodeImpl.pendingChildFrame = true;

[aboxhall, 2014/11/03 17:15:49]

Do we want to expose the pendingChildFrame property?

[David Tseng, 2014/11/03 19:31:52]

I'd prefer for the caller to check if there are children.

+
+      if (nodeImpl.pendingChildFrame) {
+        nodeImpl.childTreeID = nodeData.intAttributes.childTreeId;
+        idToWebView_[nodeImpl.childTreeID] = node;

[aboxhall, 2014/11/03 17:15:49]

So the id in idToWebView is the ID of the frame it's hosting? Perhaps it would
be better named as frameIdToHostNode or similar?

[David Tseng, 2014/11/03 19:31:52]

Obsolete with other change.

+        automationInternal.enableFrame(nodeImpl.childTreeID);
+        automationUtil.storeTreeCallback(nodeImpl.childTreeID, function(root) {

[aboxhall, 2014/11/03 17:15:49]

What's preventing us from setting root.id as the sole child of nodeImpl here,
and nodeImpl.id as root's parent ID? Node IDs are globally unique, aren't they?
It's entirely possible I'm (again) missing some reason why this wouldn't work,
but it seems like that would be much simpler, and remove the need to keep
idToWebView and lookUpWebChild_(), and thus the need to expose
idToAutomationRootNode to this file.

Please help me figure out what I'm missing here :)

[David Tseng, 2014/11/03 19:31:52]

I'm pretty sure node ids are not globally unique across two different ax trees.
AX tree idds are globally unique.

I suppose we could keep a parentHostID and childRootID on nodeImpl and root
respectively, but I'm not clear how to update those nodes when a destroyed event
comes through.

The idToWebView_ establishes the parent to child mapping while the
idToAutomationRootNode maps the child to parent mapping where child is the
subroot and parent is the host.
No worries; I just spent some time trying to do this; it does indeed make the
code cleaner.

The only reason to not do this and make things slightly more complex is nthat
now JSON.stringify() won't work on some nodes (since they have circular
references).

Other than that, it does clean up things a bit. Thanks.

[aboxhall, 2014/11/03 19:40:18]

Ah of course, they won't be unique if they're in different renderers, which is
the whole point of this.
Oh, this looks great! Thanks for that.

+          nodeImpl.pendingChildFrame = false;
+          nodeImpl.dispatchEvent(schema.EventType.childrenChanged);
+        });
+      }
+    }
     for (var key in AutomationAttributeDefaults) {
       if (key in nodeData)
         nodeImpl[key] = nodeData[key];
       else
         nodeImpl[key] = AutomationAttributeDefaults[key];
     }
     for (var i = 0; i < AutomationAttributeTypes.length; i++) {
       var attributeType = AutomationAttributeTypes[i];
       for (var attributeName in nodeData[attributeType]) {
         nodeImpl.attributesInternal[attributeName] =
@@ skipping 92 matching lines @@
                                                 'setSelection',
                                                 'addEventListener',
                                                 'removeEventListener'],
                                     readonly: ['isRootNode',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
                                                'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',

[aboxhall, 2014/11/03 17:15:49]

Do we still need to expose this type at all?

[David Tseng, 2014/11/03 19:31:52]

Still seems useful at least for testing.

                                       AutomationRootNodeImpl,
-                                      { superclass: AutomationNode,
-                                        functions: ['load'],
-                                        readonly: ['loaded'] });
+                                      { superclass: AutomationNode });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;