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;
 
@@ skipping 22 matching lines @@
   id: -1,
   role: '',
   state: { busy: true },
   isRootNode: false,
 
   get root() {
     return this.rootImpl.wrapper;
   },
 
   parent: function() {
-    return this.rootImpl.get(this.parentID);
+    return this.hostTree || this.rootImpl.get(this.parentID);
   },
 
   firstChild: function() {
-    var node = this.rootImpl.get(this.childIds[0]);
-    return node;
+    return this.childTree || 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.childTree || 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);
       }
     }
   },
 
+  toJSON: function() {
+    return { treeID: this.treeID,
+             id: this.id,
+             role: this.role,
+             attributes: this.attributes };
+  },
+
   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.
@@ skipping 55 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,
 
   get: function(id) {
     if (id == undefined)
@@ skipping 47 matching lines @@
       lastError.set('automation',
                     'Bad update received on automation tree',
                     null,
                     chrome);
       return false;
     }
     return true;
   },
 
   destroy: function() {
+    if (this.hostTree)
+      this.hostTree.childTree = undefined;
+    this.hostTree = undefined;
+
     this.dispatchEvent(schema.EventType.destroyed);
     this.invalidate_(this.wrapper);
   },
 
   onAccessibilityEvent: function(eventParams) {
     if (!this.unserialize(eventParams.update)) {
       logging.WARNING('unserialization failed');
       return false;
     }
 
@@ skipping 35 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;
+
+    // TODO(dtseng): Make into set listing all hosting node roles.
+    if (nodeData.role == schema.RoleType.webView) {
+      if (nodeImpl.pendingChildFrame === undefined)
+        nodeImpl.pendingChildFrame = true;
+
+      if (nodeImpl.pendingChildFrame) {
+        nodeImpl.childTreeID = nodeData.intAttributes.childTreeId;
+        automationInternal.enableFrame(nodeImpl.childTreeID);
+        automationUtil.storeTreeCallback(nodeImpl.childTreeID, function(root) {
+          nodeImpl.pendingChildFrame = false;
+          nodeImpl.childTree = root;
+          privates(root).impl.hostTree = node;
+          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 84 matching lines @@
                                                 'firstChild',
                                                 'lastChild',
                                                 'children',
                                                 'previousSibling',
                                                 'nextSibling',
                                                 'doDefault',
                                                 'focus',
                                                 'makeVisible',
                                                 'setSelection',
                                                 'addEventListener',
-                                                'removeEventListener'],
+                                                'removeEventListener',
+                                                'toJSON'],
                                     readonly: ['isRootNode',
                                                'role',
                                                'state',
                                                'location',
                                                'attributes',
+                                               'indexInParent',
                                                'root'] });
 
 var AutomationRootNode = utils.expose('AutomationRootNode',
                                       AutomationRootNodeImpl,
-                                      { superclass: AutomationNode,
-                                        functions: ['load'],
-                                        readonly: ['loaded'] });
+                                      { superclass: AutomationNode });
 
 exports.AutomationNode = AutomationNode;
 exports.AutomationRootNode = AutomationRootNode;