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 id in the form:
+ *     <process_id>_<routing_id>
+ *     to an AutomationNode with role type webArea.
+ * @type {!Object.<string, string>}
+ */
+var idToWebArea_ = {};
+
+/**
  * 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,
+  loaded: false,
 
   get root() {
     return this.rootImpl.wrapper;
   },
 
   parent: function() {
+    if (this.role == schema.RoleType.rootWebArea) {
+      var parentId = this.processID + '_' + this.routingID;
+      if (idToWebArea_[parentId])
+        return idToWebArea_[parentId];
+    }
     return this.rootImpl.get(this.parentID);
   },
 
   firstChild: function() {
-    var node = this.rootImpl.get(this.childIds[0]);
-    return node;
+    return this.lookupWebAreaChild_() || 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.lookupWebAreaChild_() ||
+        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 41 matching lines @@
   removeEventListener: function(eventType, callback) {
     if (this.listeners[eventType]) {
       var listeners = this.listeners[eventType];
       for (var i = 0; i < listeners.length; i++) {
         if (callback === listeners[i].callback)
           listeners.splice(i, 1);
       }
     }
   },
 
+  load: function(callback) {
+    if (this.role != schema.RoleType.webArea)
+      throw 'Unsupported state: can only load webArea nodes.';
+
+    if (!this.loaded)
+      automationInternal.enableFrame(this.processID, this.routingID);
+
+    automationUtil.onTreeLoaded(this.processID, this.routingID, function(root) {

[aboxhall, 2014/10/29 19:29:11]

What if instead of creating the AutomationRootNode in automationUtil, we made
load() a function on AutomationRootNode and created all webArea nodes as
AutomationRootNodes as we were building the tree? Then we could pass the webArea
(root) node into a function in automationUtil to cache it in the map, and it
would receive events as normal, without having to do any extra accounting in
this file. Do you think that could work?

[David Tseng, 2014/10/29 20:35:30]

Could you explain further?

The webArea node hosts the rootWebArea node. So,

desktop tree contains a leaf webArea node which "points" to a tabs (or rfh)
backed tree.

A webArea node is _not_ a root node; it's process id and routing id only serve
to point to a child; it also doesn't manage an ax object cache.

Same problem here as stated earlier. The webArea node is a descendant of some
desktop root node, so the creation of such a node occurs during createChildren_
(and not in automation_custom_bindings); since we make various passes to set the
data, we don't have the actual role at creation time. This is perfectly fine,
but means the way I'm doing it now is probably the only way unless we change the
unserialization logic.

[aboxhall, 2014/10/29 20:53:29]

So if I understand correctly, the webArea node has as its only child the root
node of the embedded tree? I was assuming (from this change) that we were
treating the webArea node as the root of the new tree (although now I see that's
not the case).

So in that case, why not construct the new AutomationRootNode as the only child
of the webArea node during unserialization, with its loaded attribute set to
false, and then set that in the map in automationUtil, (since we have its pid
and rid at unserialization time now) rather than constructing it later on? Then
this method would only need to call enableFrame with the appropriate PID and RID
(which could be private properties of the AutomationRootNode), and the existing
bindings would take care of the rest. Am I missing something?

[David Tseng, 2014/10/29 21:05:39]

Good questions.

Again, to do that during unserialization, we need to know we're dealing with a
webArea node. We don't have that information because role gets set later; unless
we do some kind of post processing.

Also, the webArea node (backed by views::WebView) may not actually have a valid
rfh. For example, in the test, you will see two webAreas. The first, for
whatever reason, never actually maps to a valid rfh on the ash desktop.


I understand the confusion about load() applying only to AutomationRootNode's,
but I think we want to be flexible here and allowing load() to get called on a
node that's hosting a root.

[aboxhall, 2014/10/29 21:33:08]

I don't think it would be that hard to do the post-processing. It would just be
a step in between setData_() and the event propagation during updateNode_()
where we check the role and create a new AutomationRootNode if necessary.
So what happens if you call load() on that other webArea? How do we handle that
case now? Is it significantly different to if we created an unloaded placeholder
AutomationRootNode? Can we detect ahead of time that there's no valid RFH and
avoid creating the placeholder in that case?
I still don't see the advantage :\

[David Tseng, 2014/10/29 21:47:47]

Right, it wouldn't be that hard at all...but the node would have an invalid ax
id and have no backing object back in the browser/renderer side.

+      if (callback)

[aboxhall, 2014/10/29 19:29:11]

Perhaps onTreeLoaded should check for null/undefined callback instead; then we
could just pass callback directly here.

[David Tseng, 2014/10/29 20:35:30]

Done.

+        callback(root);
+    }.bind(this));
+  },
+
   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);
 
@@ skipping 11 matching lines @@
 
   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);
   },
 
+  lookupWebAreaChild_: function() {
+    if (this.role != schema.RoleType.webArea)
+      return null;
+
+    return automationUtil.idToAutomationRootNode[
+      automationUtil.createAutomationRootNodeID(
+          this.processID, this.routingID)];
+  },
+
   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 189 matching lines @@
                     null,
                     chrome);
       return false;
     }
     return true;
   },
 
   destroy: function() {
     this.dispatchEvent(schema.EventType.destroyed);
     this.invalidate_(this.wrapper);
+    idToWebArea_[this.processID +
+        '_' +
+        this.routingID] = undefined;
   },
 
   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 56 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.webArea) {
+      nodeImpl.processID = nodeData.intAttributes.frameId;
+      nodeImpl.routingID = nodeData.intAttributes.childFrameId;
+      idToWebArea_[nodeImpl.processID +
+          '_' +
+          nodeImpl.routingID] = node;
+      delete nodeData.intAttributes['processId'];
+      delete nodeData.intAttributes['routingId'];
+    }
     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 84 matching lines @@
                                                 'firstChild',
                                                 'lastChild',
                                                 'children',
                                                 'previousSibling',
                                                 'nextSibling',
                                                 'doDefault',
                                                 'focus',
                                                 'makeVisible',
                                                 'setSelection',
                                                 'addEventListener',
-                                                'removeEventListener'],
+                                                'removeEventListener',
+                                                'load'],
                                     readonly: ['isRootNode',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
+                                               'loaded',
                                                'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
                                       { superclass: AutomationNode,
-                                        functions: ['load'],
-                                        readonly: ['loaded'] });
+                                        functions: ['load'] });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;